From 218633b8fd6ee41aee8eb18ba9806e8d90694751 Mon Sep 17 00:00:00 2001
From: Taylor Ho <taylorkmho@gmail.com>
Date: Tue, 8 Sep 2026 12:59:03 -0700
Subject: [PATCH 01/19] fix(link-preview): keep composer fetches user-paced
 (#7211)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

**Category:** fix
**User Impact:** Link previews can keep loading while a message is being
composed, while sending still has a finite escape hatch and stalled
network transports cannot occupy preview slots forever.

**Problem:** Native metadata and image deadlines could collapse slow
previews into fallback cards while the user was still composing, and a
shared image-host cooldown made pasted batches fail inconsistently after
one rate limit. **Solution:** Keep preview resolution user-paced with no
aggregate request deadline, bound transport inactivity (15s DNS/connect,
30s idle read), serialize image requests by host, and allow at most one
server-directed cooldown wait of up to 30s across an image fetch and its
redirects. The existing bounded post-Send preparation and immediate Skip
paths remain unchanged.

<details>
<summary>File changes</summary>

**desktop/src-tauri/src/commands/link_preview.rs**
Removes aggregate native deadlines so composer metadata work can
complete at the user's pace, while retaining DNS/connect/idle-read
liveness bounds. Adds bounded host-paced image request coordination that
releases its gate during cooldown, waits inline at most once for at most
30 seconds, and cannot renew that wait through redirects or the outer
transient retry. Same-host image and favicon requests remain
deliberately serialized to align with host rate limits.

**desktop/src-tauri/src/commands/link_preview_rate_limit.rs**
Adds a fixed-size striped host gate so concurrent image requests are
serialized without retaining an unbounded attacker-controlled hostname
map.

**desktop/src-tauri/src/commands/link_preview_tests.rs**
Moves native link-preview tests into a dedicated module and covers the
user-paced metadata contract, bounded one-shot cooldown behavior, and
gate release while a rate-limited request sleeps—including a different
host sharing the same bounded gate stripe.

**desktop/src-tauri/src/commands/link_preview_youtube.rs**
Removes the thumbnail fetch deadline so YouTube previews follow the same
composer lifecycle contract while using the shared bounded transport.

**desktop/src/shared/lib/useResolvedLinkPreviews.ts**
Adds development-only metadata outcome diagnostics with elapsed time and
image/fallback state, without logging encoded image payloads.

</details>

### Reproduction steps

1. Open the desktop composer and paste several GitHub pull request links
whose OpenGraph images share a host.
2. Observe that image requests are paced by host instead of racing, and
slow-but-progressing preview work remains pending rather than
immediately becoming a completed favicon fallback.
3. Send while preview work is still pending and confirm **Preparing link
preview** remains bounded by the existing post-Send budget.
4. Use **Skip** during preparation and confirm the message proceeds
immediately.
5. In a development build, inspect the console for `[link-preview]
metadata fetch completed` diagnostics containing elapsed time and image
state without base64 payloads.

### Related issue

N/A — scoped from the linked Buzz implementation room.

### Testing

At current head `dfb394aafbee537e9ffb04ad3732d08f65f30b8e`:

- Production-bound paused-time metadata regression passed through
`fetch_link_preview_metadata`; restoring the former 10-second aggregate
wrapper makes it fail at the pending assertion.
- Native link-preview module: 19/19 passed.
- `cargo check --manifest-path desktop/src-tauri/Cargo.toml` passed.
- Rust formatting and `git diff --check` passed.
- Pre-push `push-head-scope`, org safety, differential file-size,
branch-skew, and `desktop-tauri-checks` hooks passed.

At prior head `59e2dcf167b15c7a3e637ad2608008b7f9cef5f3`:

- Full Tauri Rust suite: 3,056 passed, 19 ignored; integration crates 7
+ 3 passed.
- Focused native link-preview suite: 26/26 passed.
- The pasted multi-preview workflow was exercised in the desktop app and
confirmed improved before draft publication.

---------

Signed-off-by: Taylor Ho <taylorkmho@gmail.com>
Co-authored-by: Carl <acda9e433d19dcd0e6b6840f7f4b98f3a56f1fab98049d444c087019e6d36560@buzz.block.builderlab.xyz>
Co-authored-by: Carl <acda9e433d19dcd0e6b6840f7f4b98f3a56f1fab98049d444c087019e6d36560@users.noreply.github.com>
---
 .../src-tauri/src/commands/link_preview.rs    | 530 +++++----------
 .../src/commands/link_preview_cancellation.rs |  89 +++
 .../src/commands/link_preview_rate_limit.rs   |  21 +-
 .../src/commands/link_preview_tests.rs        | 604 ++++++++++++++++++
 .../src/commands/link_preview_youtube.rs      |  16 +-
 desktop/src-tauri/src/lib.rs                  |   2 +
 .../lib/linkPreviewPreparationStore.test.mjs  |  97 ++-
 .../lib/linkPreviewPreparationStore.ts        |  58 +-
 .../lib/useResolvedLinkPreviews.test.mjs      | 262 +++++++-
 .../src/shared/lib/useResolvedLinkPreviews.ts | 278 ++++++--
 10 files changed, 1510 insertions(+), 447 deletions(-)
 create mode 100644 desktop/src-tauri/src/commands/link_preview_cancellation.rs
 create mode 100644 desktop/src-tauri/src/commands/link_preview_tests.rs

diff --git a/desktop/src-tauri/src/commands/link_preview.rs b/desktop/src-tauri/src/commands/link_preview.rs
index b781f8d9e68..a746cc80598 100644
--- a/desktop/src-tauri/src/commands/link_preview.rs
+++ b/desktop/src-tauri/src/commands/link_preview.rs
@@ -10,6 +10,8 @@ use reqwest::{
 use serde::Serialize;
 use url::Url;
 
+#[path = "link_preview_cancellation.rs"]
+mod cancellation;
 #[path = "link_preview_image_retry.rs"]
 mod image_retry;
 #[path = "link_preview_rate_limit.rs"]
@@ -17,15 +19,19 @@ mod rate_limit;
 #[path = "link_preview_youtube.rs"]
 mod youtube;
 
-use rate_limit::{image_host_cooldown_remaining, retry_after_duration, set_image_host_cooldown};
+use rate_limit::{
+    image_host_cooldown_remaining, image_host_gate, retry_after_duration, set_image_host_cooldown,
+};
 
 const MAX_PREVIEW_FETCH_BYTES: usize = 256 * 1024;
 const MAX_IMAGE_FETCH_BYTES: usize = 2 * 1024 * 1024;
 const MAX_IMAGE_DIMENSION: u32 = 4096;
 const MAX_IMAGE_PIXELS: u64 = 16_000_000;
 const MAX_SANITIZED_DIMENSION: u32 = 1200;
-const PREVIEW_FETCH_TIMEOUT: Duration = Duration::from_secs(4);
-const PREVIEW_TOTAL_TIMEOUT: Duration = Duration::from_secs(10);
+const TRANSPORT_CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
+const TRANSPORT_IDLE_TIMEOUT: Duration = Duration::from_secs(30);
+const DNS_RESOLUTION_TIMEOUT: Duration = Duration::from_secs(15);
+const MAX_INLINE_IMAGE_COOLDOWN: Duration = Duration::from_secs(30);
 const MAX_REDIRECTS: usize = 3;
 const MAX_METADATA_CHARS: usize = 180;
 const MAX_METADATA_DESCRIPTION_CHARS: usize = 280;
@@ -55,27 +61,46 @@ pub struct LinkPreviewMetadata {
 #[tauri::command]
 pub async fn fetch_link_preview_metadata(
     href: String,
+    request_id: Option<String>,
 ) -> Result<Option<LinkPreviewMetadata>, String> {
-    tokio::time::timeout(
-        PREVIEW_TOTAL_TIMEOUT,
-        fetch_link_preview_metadata_inner(href),
-    )
-    .await
-    .map_err(|_| "link preview request timed out".to_string())?
+    let cancellation = cancellation::begin(request_id.as_deref());
+    let result = match cancellation {
+        Some(cancellation) => {
+            tokio::select! {
+                result = fetch_link_preview_metadata_for_url(href) => result,
+                () = cancellation.cancelled() => Err("link preview request cancelled".to_string()),
+            }
+        }
+        None => fetch_link_preview_metadata_for_url(href).await,
+    };
+    cancellation::finish(request_id.as_deref());
+    result
 }
 
-async fn fetch_link_preview_metadata_inner(
+/// Cancel renderer-owned metadata work, including an in-flight response body.
+#[tauri::command]
+pub fn cancel_link_preview_metadata(request_id: String) {
+    cancellation::cancel(&request_id);
+}
+
+/// Release a renderer's cancellation record after its invocation settles.
+#[tauri::command]
+pub fn release_link_preview_metadata(request_id: String) {
+    cancellation::finish(Some(&request_id));
+}
+
+async fn fetch_link_preview_metadata_for_url(
     href: String,
 ) -> Result<Option<LinkPreviewMetadata>, String> {
     let mut url = Url::parse(href.trim()).map_err(|error| format!("invalid URL: {error}"))?;
-    validate_public_https_url(&url).await?;
+    validate_metadata_url(&url).await?;
 
     if youtube::is_video_url(&url) {
         return youtube::fetch_oembed_metadata(&url).await;
     }
 
     for redirect_count in 0..=MAX_REDIRECTS {
-        let response = send_pinned_request(&url, "text/html,application/xhtml+xml;q=0.9").await?;
+        let response = send_metadata_request(&url, "text/html,application/xhtml+xml;q=0.9").await?;
 
         if response.status().is_redirection() {
             if redirect_count == MAX_REDIRECTS {
@@ -90,7 +115,7 @@ async fn fetch_link_preview_metadata_inner(
             url = url
                 .join(location)
                 .map_err(|error| format!("invalid link preview redirect: {error}"))?;
-            validate_public_https_url(&url).await?;
+            validate_metadata_url(&url).await?;
             continue;
         }
 
@@ -107,28 +132,15 @@ async fn fetch_link_preview_metadata_inner(
         let (image_result, favicon_result) = tokio::join!(
             async {
                 match image_url {
-                    Some(image_url) => Some(
-                        tokio::time::timeout(
-                            PREVIEW_FETCH_TIMEOUT,
-                            fetch_sanitized_image_with_retry(image_url, false),
-                        )
-                        .await
-                        .unwrap_or(Err(ImageFetchError::Transient {
-                            retry_after: None,
-                            retry_inline: false,
-                        })),
-                    ),
+                    Some(image_url) => {
+                        Some(fetch_sanitized_image_with_retry(image_url, false).await)
+                    }
                     None => None,
                 }
             },
             async {
                 match favicon_url {
-                    Some(favicon_url) => tokio::time::timeout(
-                        PREVIEW_FETCH_TIMEOUT,
-                        fetch_sanitized_image(favicon_url, true),
-                    )
-                    .await
-                    .ok(),
+                    Some(favicon_url) => Some(fetch_sanitized_image(favicon_url, true).await),
                     None => None,
                 }
             }
@@ -166,6 +178,15 @@ fn apply_image_result(
     }
 }
 
+async fn validate_metadata_url(url: &Url) -> Result<(), String> {
+    #[cfg(test)]
+    if METADATA_TEST_SERVER.try_with(|_| ()).is_ok() {
+        return Ok(());
+    }
+
+    validate_public_https_url(url).await
+}
+
 async fn validate_public_https_url(url: &Url) -> Result<(), String> {
     if url.scheme() != "https" || url.username() != "" || url.password().is_some() {
         return Err("link previews require an HTTPS URL without credentials".to_string());
@@ -182,11 +203,15 @@ async fn validate_public_https_url(url: &Url) -> Result<(), String> {
 
 async fn resolve_public_addresses(host: &str) -> Result<Vec<IpAddr>, String> {
     let host = host.to_string();
-    let addresses = tokio::net::lookup_host((host.as_str(), 443))
-        .await
-        .map_err(|error| format!("link preview DNS resolution failed: {error}"))?
-        .map(|address| address.ip())
-        .collect::<Vec<_>>();
+    let addresses = tokio::time::timeout(
+        DNS_RESOLUTION_TIMEOUT,
+        tokio::net::lookup_host((host.as_str(), 443)),
+    )
+    .await
+    .map_err(|_| "link preview DNS resolution timed out".to_string())?
+    .map_err(|error| format!("link preview DNS resolution failed: {error}"))?
+    .map(|address| address.ip())
+    .collect::<Vec<_>>();
 
     if addresses.is_empty() {
         return Err("link preview DNS resolution returned no addresses".to_string());
@@ -198,6 +223,25 @@ async fn resolve_public_addresses(host: &str) -> Result<Vec<IpAddr>, String> {
     Ok(addresses)
 }
 
+#[cfg(test)]
+tokio::task_local! {
+    static METADATA_TEST_SERVER: std::net::SocketAddr;
+}
+
+async fn send_metadata_request(url: &Url, accept: &str) -> Result<reqwest::Response, String> {
+    #[cfg(test)]
+    if let Ok(address) = METADATA_TEST_SERVER.try_with(|address| *address) {
+        return reqwest::Client::new()
+            .get(format!("http://{address}{}", url.path()))
+            .header(ACCEPT, accept)
+            .send()
+            .await
+            .map_err(|error| format!("link preview test request failed: {error}"));
+    }
+
+    send_pinned_request(url, accept).await
+}
+
 async fn send_pinned_request(url: &Url, accept: &str) -> Result<reqwest::Response, String> {
     let host = url
         .host_str()
@@ -211,6 +255,8 @@ async fn send_pinned_request(url: &Url, accept: &str) -> Result<reqwest::Respons
         .no_proxy()
         .redirect(Policy::none())
         .pool_max_idle_per_host(0)
+        .connect_timeout(TRANSPORT_CONNECT_TIMEOUT)
+        .read_timeout(TRANSPORT_IDLE_TIMEOUT)
         .resolve_to_addrs(host, &socket_addresses)
         .build()
         .map_err(|error| format!("link preview client failed: {error}"))?;
@@ -219,9 +265,9 @@ async fn send_pinned_request(url: &Url, accept: &str) -> Result<reqwest::Respons
         .header(ACCEPT, accept)
         .header(USER_AGENT, "Buzz Desktop link preview");
 
-    tokio::time::timeout(PREVIEW_FETCH_TIMEOUT, request.send())
+    request
+        .send()
         .await
-        .map_err(|_| "link preview request timed out".to_string())?
         .map_err(|error| format!("link preview request failed: {error}"))
 }
 
@@ -340,25 +386,88 @@ async fn fetch_sanitized_image_with_retry(
     .await
 }
 
+async fn wait_for_image_host_cooldown(
+    waited_for_cooldown: &mut bool,
+    retry_after: Duration,
+) -> bool {
+    if *waited_for_cooldown {
+        return false;
+    }
+    *waited_for_cooldown = true;
+    tokio::time::sleep(retry_after).await;
+    true
+}
+
+fn retryable_image_cooldown(
+    url: &Url,
+    retry_after: Option<Duration>,
+    waited_for_cooldown: &mut bool,
+) -> Option<Duration> {
+    let retry_after = retry_after?;
+    if *waited_for_cooldown {
+        return None;
+    }
+    set_image_host_cooldown(url, retry_after);
+    if retry_after > MAX_INLINE_IMAGE_COOLDOWN {
+        return None;
+    }
+    *waited_for_cooldown = true;
+    Some(retry_after)
+}
+
 async fn fetch_sanitized_image(
-    mut url: Url,
+    url: Url,
     preserve_transparency: bool,
 ) -> Result<(String, String), ImageFetchError> {
-    validate_public_https_url(&url)
+    fetch_sanitized_image_using(
+        url,
+        preserve_transparency,
+        |url| async move { validate_public_https_url(&url).await },
+        |url, accept| async move { send_pinned_request(&url, accept).await },
+    )
+    .await
+}
+
+async fn fetch_sanitized_image_using<V, VFut, F, Fut>(
+    mut url: Url,
+    preserve_transparency: bool,
+    mut validate_url: V,
+    mut send_request: F,
+) -> Result<(String, String), ImageFetchError>
+where
+    V: FnMut(Url) -> VFut,
+    VFut: std::future::Future<Output = Result<(), String>>,
+    F: FnMut(Url, &'static str) -> Fut,
+    Fut: std::future::Future<Output = Result<reqwest::Response, String>>,
+{
+    validate_url(url.clone())
         .await
         .map_err(|_| ImageFetchError::Rejected)?;
-    for redirect_count in 0..=MAX_REDIRECTS {
+    let mut redirect_count = 0;
+    let mut waited_for_cooldown = false;
+    while redirect_count <= MAX_REDIRECTS {
         if let Some(retry_after) = image_host_cooldown_remaining(&url) {
-            return Err(ImageFetchError::Transient {
-                retry_after: Some(retry_after),
-                retry_inline: false,
-            });
+            if retry_after > MAX_INLINE_IMAGE_COOLDOWN
+                || !wait_for_image_host_cooldown(&mut waited_for_cooldown, retry_after).await
+            {
+                return Err(ImageFetchError::Transient {
+                    retry_after: Some(retry_after),
+                    retry_inline: false,
+                });
+            }
+            continue;
         }
-        let response = send_pinned_request(&url, "image/jpeg,image/png,image/webp")
+
+        let host_gate = image_host_gate(&url);
+        let host_guard = host_gate.lock().await;
+        if image_host_cooldown_remaining(&url).is_some() {
+            continue;
+        }
+        let response = send_request(url.clone(), "image/jpeg,image/png,image/webp")
             .await
             .map_err(|_| ImageFetchError::Transient {
                 retry_after: None,
-                retry_inline: true,
+                retry_inline: !waited_for_cooldown,
             })?;
         if response.status().is_redirection() {
             if redirect_count == MAX_REDIRECTS {
@@ -370,9 +479,10 @@ async fn fetch_sanitized_image(
                 .and_then(|value| value.to_str().ok())
                 .ok_or(ImageFetchError::Rejected)?;
             url = url.join(location).map_err(|_| ImageFetchError::Rejected)?;
-            validate_public_https_url(&url)
+            validate_url(url.clone())
                 .await
                 .map_err(|_| ImageFetchError::Rejected)?;
+            redirect_count += 1;
             continue;
         }
         if !response.status().is_success() {
@@ -383,12 +493,18 @@ async fn fetch_sanitized_image(
                 || status.is_server_error()
             {
                 let retry_after = retry_after_duration(&response);
-                if let Some(retry_after) = retry_after {
-                    set_image_host_cooldown(&url, retry_after);
+                if let Some(retry_after) =
+                    retryable_image_cooldown(&url, retry_after, &mut waited_for_cooldown)
+                {
+                    drop(host_guard);
+                    tokio::time::sleep(retry_after).await;
+                    continue;
                 }
                 return Err(ImageFetchError::Transient {
                     retry_after,
-                    retry_inline: status != reqwest::StatusCode::TOO_MANY_REQUESTS,
+                    retry_inline: retry_after.is_none()
+                        && status != reqwest::StatusCode::TOO_MANY_REQUESTS
+                        && !waited_for_cooldown,
                 });
             }
             return Err(ImageFetchError::Rejected);
@@ -677,315 +793,5 @@ fn decode_html_entities(value: &str) -> String {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::rate_limit::MAX_IMAGE_RETRY_AFTER;
-    use super::{
-        apply_image_result, declares_animation, extract_favicon_url, extract_image_url,
-        extract_link_preview_metadata, is_html_response, read_bytes_prefix, retry_after_duration,
-        sanitize_image, ImageFetchError, LinkPreviewImageFetchState, LinkPreviewMetadata,
-        MAX_METADATA_DESCRIPTION_CHARS,
-    };
-    use axum::{body::Body, http::Response, routing::get, Router};
-    use base64::Engine as _;
-    use bytes::Bytes;
-    use futures_util::stream;
-    use image::{DynamicImage, ImageFormat, Rgb, RgbImage, Rgba, RgbaImage};
-    use std::{convert::Infallible, io::Cursor};
-    use url::Url;
-
-    async fn test_response(router: Router, path: &str) -> reqwest::Response {
-        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let address = listener.local_addr().unwrap();
-        tokio::spawn(async move {
-            axum::serve(listener, router).await.unwrap();
-        });
-        reqwest::get(format!("http://{address}{path}"))
-            .await
-            .unwrap()
-    }
-
-    #[test]
-    fn metadata_prefers_open_graph_and_reads_site_name() {
-        let html = r#"<meta content="Buzz" property="og:site_name">
-          <meta content="Rich previews &amp; cards" property="og:title">
-          <meta content="Safe &amp; useful previews" property="og:description">
-          <meta name="twitter:title" content="Twitter fallback"><title>Fallback</title>"#;
-        assert_eq!(
-            extract_link_preview_metadata(html),
-            Some(LinkPreviewMetadata {
-                title: "Rich previews & cards".to_string(),
-                site_name: Some("Buzz".to_string()),
-                description: Some("Safe & useful previews".to_string()),
-                image_data_url: None,
-                image_domain: None,
-                image_fetch_state: LinkPreviewImageFetchState::None,
-                image_retry_after_ms: None,
-                favicon_data_url: None,
-            })
-        );
-    }
-
-    #[test]
-    fn image_results_preserve_absence_and_classify_recovery() {
-        let mut metadata = extract_link_preview_metadata("<title>Preview result</title>").unwrap();
-        apply_image_result(&mut metadata, None);
-        assert_eq!(metadata.image_fetch_state, LinkPreviewImageFetchState::None);
-
-        apply_image_result(
-            &mut metadata,
-            Some(Err(ImageFetchError::Transient {
-                retry_after: Some(std::time::Duration::from_secs(15)),
-                retry_inline: false,
-            })),
-        );
-        assert_eq!(
-            metadata.image_fetch_state,
-            LinkPreviewImageFetchState::TransientFailure
-        );
-        assert_eq!(metadata.image_retry_after_ms, Some(15_000));
-
-        apply_image_result(
-            &mut metadata,
-            Some(Ok((
-                "data:image/jpeg;base64,abc".to_string(),
-                "images.example.com".to_string(),
-            ))),
-        );
-        assert_eq!(
-            metadata.image_fetch_state,
-            LinkPreviewImageFetchState::Image
-        );
-        assert_eq!(metadata.image_domain.as_deref(), Some("images.example.com"));
-    }
-
-    #[test]
-    fn metadata_falls_back_to_twitter_then_title() {
-        assert_eq!(
-            extract_link_preview_metadata("<meta content='Tweet title' name='twitter:title'>")
-                .map(|metadata| metadata.title),
-            Some("Tweet title".to_string())
-        );
-        assert_eq!(
-            extract_link_preview_metadata("<title> Plain   title </title>")
-                .map(|metadata| metadata.title),
-            Some("Plain title".to_string())
-        );
-    }
-
-    #[test]
-    fn metadata_preserves_description_line_breaks() {
-        let html = r#"<meta property="og:title" content="Tweet title">
-          <meta property="og:description" content="First paragraph.&#10;&#10;Agents:&#10;- One&#10;- Two">"#;
-        assert_eq!(
-            extract_link_preview_metadata(html).and_then(|metadata| metadata.description),
-            Some("First paragraph.\n\nAgents:\n- One\n- Two".to_string())
-        );
-    }
-
-    #[test]
-    fn metadata_description_supports_standard_x_posts() {
-        let description = "x".repeat(MAX_METADATA_DESCRIPTION_CHARS + 1);
-        let html = format!(
-            r#"<meta property="og:title" content="Long post"><meta property="og:description" content="{description}">"#
-        );
-        let extracted = extract_link_preview_metadata(&html)
-            .and_then(|metadata| metadata.description)
-            .unwrap();
-        assert_eq!(extracted.chars().count(), MAX_METADATA_DESCRIPTION_CHARS);
-    }
-
-    #[test]
-    fn favicon_metadata_resolves_relative_icon_links() {
-        let page = Url::parse("https://example.com/articles/one").unwrap();
-        let html = r#"<link rel="stylesheet" href="styles.css">
-          <link href="../favicon.png" rel="shortcut icon">"#;
-        assert_eq!(
-            extract_favicon_url(html, &page).unwrap().as_str(),
-            "https://example.com/favicon.png"
-        );
-    }
-
-    #[test]
-    fn favicon_metadata_prefers_a_supported_raster_candidate() {
-        let page = Url::parse("https://github.com/block/buzz").unwrap();
-        let html = r#"<link rel="mask-icon" href="https://assets.example/favicon.svg">
-          <link rel="alternate icon" type="image/png" href="https://assets.example/favicon.png">
-          <link rel="icon" type="image/svg+xml" href="https://assets.example/favicon.svg">"#;
-        assert_eq!(
-            extract_favicon_url(html, &page).unwrap().as_str(),
-            "https://assets.example/favicon.png"
-        );
-    }
-
-    #[test]
-    fn favicon_metadata_uses_touch_icon_before_unsupported_ico() {
-        let page = Url::parse("https://twitter.com/tellaho").unwrap();
-        let html = r#"<link rel="icon" href="/favicon.ico">
-          <link rel="apple-touch-icon" sizes="192x192" href="/apple-touch-icon.png">"#;
-        assert_eq!(
-            extract_favicon_url(html, &page).unwrap().as_str(),
-            "https://twitter.com/apple-touch-icon.png"
-        );
-    }
-
-    #[test]
-    fn image_metadata_resolves_relative_urls_and_prefers_open_graph() {
-        let page = Url::parse("https://example.com/articles/one").unwrap();
-        let html = r#"<meta name="twitter:image" content="https://cdn.example/twitter.jpg">
-          <meta property="og:image" content="../preview.png">"#;
-        assert_eq!(
-            extract_image_url(html, &page).unwrap().as_str(),
-            "https://example.com/preview.png"
-        );
-    }
-
-    #[tokio::test]
-    async fn oversized_html_uses_metadata_within_the_bounded_prefix() {
-        const LIMIT: usize = 256;
-        let metadata = r#"<meta property="og:title" content="Prefix title"><meta property="og:image" content="https://example.com/preview.png">"#;
-        let body = format!("{metadata}{}", "x".repeat(LIMIT));
-        let response = test_response(
-            Router::new().route(
-                "/declared",
-                get(move || {
-                    let body = body.clone();
-                    async move {
-                        Response::builder()
-                            .header("content-type", "text/html")
-                            .body(Body::from(body))
-                            .unwrap()
-                    }
-                }),
-            ),
-            "/declared",
-        )
-        .await;
-        assert!(response
-            .content_length()
-            .is_some_and(|size| size > LIMIT as u64));
-        assert!(is_html_response(&response));
-
-        let prefix = read_bytes_prefix(response, LIMIT).await.unwrap();
-        assert_eq!(prefix.len(), LIMIT);
-        let html = String::from_utf8_lossy(&prefix);
-        assert_eq!(
-            extract_link_preview_metadata(&html).map(|metadata| metadata.title),
-            Some("Prefix title".to_string())
-        );
-        assert!(extract_image_url(&html, &Url::parse("https://example.com").unwrap()).is_some());
-    }
-
-    #[tokio::test]
-    async fn image_retry_after_uses_bounded_delta_seconds() {
-        let response = test_response(
-            Router::new().route(
-                "/rate-limited",
-                get(|| async {
-                    Response::builder()
-                        .status(429)
-                        .header("retry-after", "900")
-                        .body(Body::empty())
-                        .unwrap()
-                }),
-            ),
-            "/rate-limited",
-        )
-        .await;
-        assert_eq!(
-            retry_after_duration(&response),
-            Some(std::time::Duration::from_secs(900))
-        );
-
-        let response = test_response(
-            Router::new().route(
-                "/excessive",
-                get(|| async {
-                    Response::builder()
-                        .status(429)
-                        .header("retry-after", "7200")
-                        .body(Body::empty())
-                        .unwrap()
-                }),
-            ),
-            "/excessive",
-        )
-        .await;
-        assert_eq!(retry_after_duration(&response), Some(MAX_IMAGE_RETRY_AFTER));
-    }
-
-    #[tokio::test]
-    async fn oversized_chunked_html_ignores_metadata_beyond_the_bounded_prefix() {
-        const LIMIT: usize = 256;
-        let response = test_response(
-            Router::new().route(
-                "/chunked",
-                get(|| async {
-                    let chunks = stream::iter([
-                        Ok::<_, Infallible>(Bytes::from(vec![b'x'; LIMIT])),
-                        Ok(Bytes::from_static(
-                            br#"<meta property="og:title" content="Too late"><meta property="og:image" content="https://example.com/late.png">"#,
-                        )),
-                    ]);
-                    Response::builder()
-                        .header("content-type", "text/html")
-                        .body(Body::from_stream(chunks))
-                        .unwrap()
-                }),
-            ),
-            "/chunked",
-        )
-        .await;
-        assert_eq!(response.content_length(), None);
-
-        let prefix = read_bytes_prefix(response, LIMIT).await.unwrap();
-        assert_eq!(prefix.len(), LIMIT);
-        let html = String::from_utf8_lossy(&prefix);
-        assert_eq!(extract_link_preview_metadata(&html), None);
-        assert_eq!(
-            extract_image_url(&html, &Url::parse("https://example.com").unwrap()),
-            None
-        );
-    }
-
-    #[test]
-    fn sanitizer_rejects_mime_mismatch_and_outputs_static_jpeg() {
-        let source = DynamicImage::ImageRgb8(RgbImage::from_pixel(2, 2, Rgb([10, 20, 30])));
-        let mut png = Cursor::new(Vec::new());
-        source.write_to(&mut png, ImageFormat::Png).unwrap();
-        assert!(sanitize_image(png.get_ref(), "image/jpeg", false).is_err());
-        let sanitized = sanitize_image(png.get_ref(), "image/png", false).unwrap();
-        assert!(sanitized.starts_with("data:image/jpeg;base64,"));
-    }
-
-    #[test]
-    fn favicon_sanitizer_preserves_png_transparency() {
-        let source = DynamicImage::ImageRgba8(RgbaImage::from_pixel(2, 2, Rgba([36, 41, 47, 0])));
-        let mut png = Cursor::new(Vec::new());
-        source.write_to(&mut png, ImageFormat::Png).unwrap();
-
-        let sanitized = sanitize_image(png.get_ref(), "image/png", true).unwrap();
-        assert!(sanitized.starts_with("data:image/png;base64,"));
-        let encoded = sanitized.split_once(',').unwrap().1;
-        let bytes = base64::engine::general_purpose::STANDARD
-            .decode(encoded)
-            .unwrap();
-        assert!(image::load_from_memory(&bytes).unwrap().color().has_alpha());
-    }
-
-    #[test]
-    fn animation_markers_are_rejected_before_decode() {
-        let mut apng = b"\x89PNG\r\n\x1a\n".to_vec();
-        apng.extend_from_slice(b"junkacTLjunk");
-        assert!(declares_animation(&apng, ImageFormat::Png));
-
-        let mut webp = b"RIFF\x00\x00\x00\x00WEBPVP8X\x0a\x00\x00\x00".to_vec();
-        webp.push(0x02);
-        assert!(declares_animation(&webp, ImageFormat::WebP));
-    }
-
-    #[test]
-    fn metadata_requires_a_non_empty_title() {
-        assert_eq!(extract_link_preview_metadata("<title>   </title>"), None);
-        assert_eq!(extract_link_preview_metadata("<html></html>"), None);
-    }
-}
+#[path = "link_preview_tests.rs"]
+mod tests;
diff --git a/desktop/src-tauri/src/commands/link_preview_cancellation.rs b/desktop/src-tauri/src/commands/link_preview_cancellation.rs
new file mode 100644
index 00000000000..38be2b3a386
--- /dev/null
+++ b/desktop/src-tauri/src/commands/link_preview_cancellation.rs
@@ -0,0 +1,89 @@
+use std::{
+    collections::HashMap,
+    sync::{LazyLock, Mutex},
+};
+
+use tokio_util::sync::CancellationToken;
+
+#[derive(Default)]
+struct LinkPreviewCancellations {
+    tokens: HashMap<String, CancellationToken>,
+}
+
+impl LinkPreviewCancellations {
+    fn begin(&mut self, request_id: &str) -> CancellationToken {
+        if let Some(cancellation) = self.tokens.get(request_id).cloned() {
+            return cancellation;
+        }
+        let cancellation = CancellationToken::new();
+        self.tokens
+            .insert(request_id.to_string(), cancellation.clone());
+        cancellation
+    }
+
+    fn cancel(&mut self, request_id: &str) {
+        self.tokens
+            .entry(request_id.to_string())
+            .or_default()
+            .cancel();
+    }
+
+    fn finish(&mut self, request_id: &str) {
+        self.tokens.remove(request_id);
+    }
+}
+
+static LINK_PREVIEW_CANCELLATIONS: LazyLock<Mutex<LinkPreviewCancellations>> =
+    LazyLock::new(|| Mutex::new(LinkPreviewCancellations::default()));
+
+pub(super) fn begin(request_id: Option<&str>) -> Option<CancellationToken> {
+    let request_id = request_id?;
+    LINK_PREVIEW_CANCELLATIONS
+        .lock()
+        .ok()
+        .map(|mut fetches| fetches.begin(request_id))
+}
+
+pub(super) fn cancel(request_id: &str) {
+    if let Ok(mut fetches) = LINK_PREVIEW_CANCELLATIONS.lock() {
+        fetches.cancel(request_id);
+    }
+}
+
+pub(super) fn finish(request_id: Option<&str>) {
+    let Some(request_id) = request_id else {
+        return;
+    };
+    if let Ok(mut fetches) = LINK_PREVIEW_CANCELLATIONS.lock() {
+        fetches.finish(request_id);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn cancellation_before_begin_is_retained() {
+        let mut fetches = LinkPreviewCancellations::default();
+        fetches.cancel("cancel-before-begin");
+
+        let cancellation = fetches.begin("cancel-before-begin");
+
+        assert!(cancellation.is_cancelled());
+        fetches.finish("cancel-before-begin");
+        assert!(fetches.tokens.is_empty());
+    }
+
+    #[test]
+    fn cancellation_reaches_active_owner() {
+        let mut fetches = LinkPreviewCancellations::default();
+        let cancellation = fetches.begin("active-fetch");
+
+        fetches.cancel("active-fetch");
+
+        assert!(cancellation.is_cancelled());
+        fetches.finish("active-fetch");
+        assert!(fetches.tokens.is_empty());
+    }
+}
diff --git a/desktop/src-tauri/src/commands/link_preview_rate_limit.rs b/desktop/src-tauri/src/commands/link_preview_rate_limit.rs
index c3f7ed7188c..46032fc5f01 100644
--- a/desktop/src-tauri/src/commands/link_preview_rate_limit.rs
+++ b/desktop/src-tauri/src/commands/link_preview_rate_limit.rs
@@ -1,16 +1,31 @@
 use std::{
-    collections::HashMap,
-    sync::{Mutex, OnceLock},
-    time::{Duration, Instant},
+    collections::{hash_map::DefaultHasher, HashMap},
+    hash::{Hash, Hasher},
+    sync::{LazyLock, Mutex, OnceLock},
+    time::Duration,
 };
 
 use reqwest::header::RETRY_AFTER;
+use tokio::{sync::Mutex as AsyncMutex, time::Instant};
 use url::Url;
 
 pub(super) const MAX_IMAGE_RETRY_AFTER: Duration = Duration::from_secs(60 * 60);
 const MAX_IMAGE_HOST_COOLDOWNS: usize = 128;
+const IMAGE_HOST_GATE_COUNT: usize = 64;
 
 static IMAGE_HOST_COOLDOWNS: OnceLock<Mutex<HashMap<String, Instant>>> = OnceLock::new();
+// A bounded stripe table serializes image requests by host without retaining an
+// unbounded attacker-controlled hostname map. Hash collisions only make two
+// unrelated hosts wait for one another; they never weaken the host boundary.
+static IMAGE_HOST_GATES: LazyLock<[AsyncMutex<()>; IMAGE_HOST_GATE_COUNT]> =
+    LazyLock::new(|| std::array::from_fn(|_| AsyncMutex::new(())));
+
+pub(super) fn image_host_gate(url: &Url) -> &'static AsyncMutex<()> {
+    let mut hasher = DefaultHasher::new();
+    url.host_str().unwrap_or_default().hash(&mut hasher);
+    let index = (hasher.finish() as usize) % IMAGE_HOST_GATE_COUNT;
+    &IMAGE_HOST_GATES[index]
+}
 
 pub(super) fn retry_after_duration(response: &reqwest::Response) -> Option<Duration> {
     response
diff --git a/desktop/src-tauri/src/commands/link_preview_tests.rs b/desktop/src-tauri/src/commands/link_preview_tests.rs
new file mode 100644
index 00000000000..05ab0eec2ce
--- /dev/null
+++ b/desktop/src-tauri/src/commands/link_preview_tests.rs
@@ -0,0 +1,604 @@
+use super::rate_limit::MAX_IMAGE_RETRY_AFTER;
+use super::{
+    apply_image_result, cancel_link_preview_metadata, declares_animation, extract_favicon_url,
+    extract_image_url, extract_link_preview_metadata, fetch_link_preview_metadata,
+    fetch_sanitized_image_using, is_html_response, read_bytes_prefix, retry_after_duration,
+    retryable_image_cooldown, sanitize_image, ImageFetchError, LinkPreviewImageFetchState,
+    LinkPreviewMetadata, MAX_INLINE_IMAGE_COOLDOWN, MAX_METADATA_DESCRIPTION_CHARS,
+};
+use axum::{body::Body, http::Response, routing::get, Router};
+use base64::Engine as _;
+use bytes::Bytes;
+use futures_util::stream;
+use image::{DynamicImage, ImageFormat, Rgb, RgbImage, Rgba, RgbaImage};
+use std::{
+    convert::Infallible,
+    io::Cursor,
+    sync::{Arc, Mutex},
+};
+use tokio::sync::oneshot;
+use url::Url;
+
+async fn start_test_server(router: Router) -> std::net::SocketAddr {
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let address = listener.local_addr().unwrap();
+    tokio::spawn(async move {
+        axum::serve(listener, router).await.unwrap();
+    });
+    address
+}
+
+async fn test_response(router: Router, path: &str) -> reqwest::Response {
+    let address = start_test_server(router).await;
+    reqwest::get(format!("http://{address}{path}"))
+        .await
+        .unwrap()
+}
+
+#[tokio::test(start_paused = true)]
+async fn metadata_pipeline_remains_pending_beyond_former_aggregate_deadline() {
+    let (request_started_tx, request_started_rx) = oneshot::channel::<()>();
+    let request_started_tx = Arc::new(Mutex::new(Some(request_started_tx)));
+    let (release_response_tx, release_response_rx) = oneshot::channel::<()>();
+    let release_response_rx = Arc::new(Mutex::new(Some(release_response_rx)));
+    let address = start_test_server(Router::new().route(
+        "/preview",
+        get(move || {
+            let request_started_tx = Arc::clone(&request_started_tx);
+            let release_response_rx = Arc::clone(&release_response_rx);
+            async move {
+                request_started_tx
+                    .lock()
+                    .unwrap()
+                    .take()
+                    .unwrap()
+                    .send(())
+                    .unwrap();
+                let release_response_rx = release_response_rx.lock().unwrap().take().unwrap();
+                release_response_rx.await.unwrap();
+                Response::builder()
+                    .header("content-type", "text/html")
+                    .body(Body::from("<title>User-paced metadata</title>"))
+                    .unwrap()
+            }
+        }),
+    ))
+    .await;
+    let fetch = tokio::spawn(super::METADATA_TEST_SERVER.scope(
+        address,
+        fetch_link_preview_metadata("https://user-paced.example/preview".to_string(), None),
+    ));
+
+    request_started_rx.await.unwrap();
+    tokio::time::advance(std::time::Duration::from_secs(11)).await;
+    assert!(!fetch.is_finished());
+
+    release_response_tx.send(()).unwrap();
+    let metadata = fetch.await.unwrap().unwrap().unwrap();
+    assert_eq!(metadata.title, "User-paced metadata");
+}
+
+#[tokio::test]
+async fn metadata_command_cancellation_drops_an_in_flight_response() {
+    let (request_started_tx, request_started_rx) = oneshot::channel::<()>();
+    let request_started_tx = Arc::new(Mutex::new(Some(request_started_tx)));
+    let (_release_response_tx, release_response_rx) = oneshot::channel::<()>();
+    let release_response_rx = Arc::new(Mutex::new(Some(release_response_rx)));
+    let address = start_test_server(Router::new().route(
+        "/preview",
+        get(move || {
+            let request_started_tx = Arc::clone(&request_started_tx);
+            let release_response_rx = Arc::clone(&release_response_rx);
+            async move {
+                request_started_tx
+                    .lock()
+                    .unwrap()
+                    .take()
+                    .unwrap()
+                    .send(())
+                    .unwrap();
+                let release_response_rx = release_response_rx.lock().unwrap().take().unwrap();
+                let _ = release_response_rx.await;
+                Response::builder()
+                    .header("content-type", "text/html")
+                    .body(Body::from("<title>Too late</title>"))
+                    .unwrap()
+            }
+        }),
+    ))
+    .await;
+    let request_id = "cancel-in-flight".to_string();
+    let fetch = tokio::spawn(super::METADATA_TEST_SERVER.scope(
+        address,
+        fetch_link_preview_metadata(
+            "https://cancel.example/preview".to_string(),
+            Some(request_id.clone()),
+        ),
+    ));
+
+    request_started_rx.await.unwrap();
+    cancel_link_preview_metadata(request_id);
+
+    assert_eq!(
+        fetch.await.unwrap(),
+        Err("link preview request cancelled".to_string())
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn first_rate_limit_and_queued_host_request_share_one_cooldown_boundary() {
+    let cooldown = std::time::Duration::from_secs(20);
+    let rate_limited_path = "/rate-limited.png";
+    let success_path = "/success.png";
+    let url = Url::parse(&format!(
+        "https://rate-limit-regression.example{rate_limited_path}"
+    ))
+    .unwrap();
+    let attempts = Arc::new(Mutex::new(0));
+    let collision_attempts = Arc::new(Mutex::new(0));
+    let image = DynamicImage::ImageRgb8(RgbImage::from_pixel(2, 2, Rgb([10, 20, 30])));
+    let mut png = Cursor::new(Vec::new());
+    image.write_to(&mut png, ImageFormat::Png).unwrap();
+    let image_bytes = png.into_inner();
+    let server_attempts = Arc::clone(&attempts);
+    let address = start_test_server(Router::new().route(
+        "/{image}",
+        get(
+            move |axum::extract::Path(image): axum::extract::Path<String>| {
+                let image_bytes = image_bytes.clone();
+                let server_attempts = Arc::clone(&server_attempts);
+                async move {
+                    if image == "rate-limited.png" {
+                        let attempt = {
+                            let mut attempts = server_attempts.lock().unwrap();
+                            *attempts += 1;
+                            *attempts
+                        };
+                        if attempt == 1 {
+                            return Response::builder()
+                                .status(429)
+                                .header("retry-after", cooldown.as_secs())
+                                .body(Body::empty())
+                                .unwrap();
+                        }
+                    }
+                    Response::builder()
+                        .header("content-type", "image/png")
+                        .body(Body::from(image_bytes))
+                        .unwrap()
+                }
+            },
+        ),
+    ))
+    .await;
+    let test_client = reqwest::Client::new();
+    let request = move |url: Url, _accept: &'static str| {
+        let test_client = test_client.clone();
+        async move {
+            test_client
+                .get(format!("http://{address}{}", url.path()))
+                .send()
+                .await
+                .map_err(|error| error.to_string())
+        }
+    };
+    let collision_request = {
+        let collision_attempts = Arc::clone(&collision_attempts);
+        let test_client = reqwest::Client::new();
+        move |url: Url, _accept: &'static str| {
+            let collision_attempts = Arc::clone(&collision_attempts);
+            let test_client = test_client.clone();
+            async move {
+                *collision_attempts.lock().unwrap() += 1;
+                test_client
+                    .get(format!("http://{address}{}", url.path()))
+                    .send()
+                    .await
+                    .map_err(|error| error.to_string())
+            }
+        }
+    };
+    let validate = |_url: Url| async { Ok(()) };
+    let first = tokio::spawn(fetch_sanitized_image_using(
+        url.clone(),
+        false,
+        validate,
+        request.clone(),
+    ));
+    while super::image_host_cooldown_remaining(&url).is_none() {
+        tokio::task::yield_now().await;
+    }
+    assert!(!first.is_finished());
+    assert_eq!(*attempts.lock().unwrap(), 1);
+    assert_eq!(super::image_host_cooldown_remaining(&url), Some(cooldown));
+
+    let colliding_url = (0..10_000)
+        .map(|index| {
+            Url::parse(&format!("https://collision-{index}.example{success_path}")).unwrap()
+        })
+        .find(|candidate| {
+            std::ptr::eq(
+                super::image_host_gate(candidate),
+                super::image_host_gate(&url),
+            )
+        })
+        .expect("a different host sharing the bounded gate stripe");
+
+    let (collision_started_tx, collision_started_rx) = oneshot::channel();
+    tokio::spawn(async move {
+        let collision =
+            fetch_sanitized_image_using(colliding_url, false, validate, collision_request);
+        tokio::pin!(collision);
+        assert!(futures_util::poll!(&mut collision).is_pending());
+        collision_started_tx.send(()).ok();
+        assert!(collision.await.is_ok());
+    });
+    collision_started_rx.await.unwrap();
+    assert_eq!(*collision_attempts.lock().unwrap(), 1);
+    assert_eq!(*attempts.lock().unwrap(), 1);
+
+    let queued = tokio::spawn(fetch_sanitized_image_using(url, false, validate, request));
+    tokio::task::yield_now().await;
+    assert!(!queued.is_finished());
+    assert_eq!(*attempts.lock().unwrap(), 1);
+
+    tokio::time::advance(cooldown - std::time::Duration::from_millis(1)).await;
+    assert!(!first.is_finished());
+    assert!(!queued.is_finished());
+    assert_eq!(*attempts.lock().unwrap(), 1);
+
+    tokio::time::advance(std::time::Duration::from_millis(1)).await;
+    let (first, queued) = tokio::join!(first, queued);
+    assert!(first.unwrap().is_ok());
+    assert!(queued.unwrap().is_ok());
+    assert_eq!(*attempts.lock().unwrap(), 3);
+}
+
+#[tokio::test(start_paused = true)]
+async fn transport_failure_after_cooldown_does_not_renew_wait_on_outer_retry() {
+    let cooldown = std::time::Duration::from_secs(20);
+    let url = Url::parse("https://transport-after-cooldown.example/image.png").unwrap();
+    super::set_image_host_cooldown(&url, cooldown);
+    let attempts = Arc::new(Mutex::new(0));
+
+    let result = super::image_retry::retry_transient_image_fetch(|| {
+        let url = url.clone();
+        let attempts = Arc::clone(&attempts);
+        async move {
+            fetch_sanitized_image_using(
+                url,
+                false,
+                |_url| async { Ok(()) },
+                move |_url, _accept| {
+                    let attempts = Arc::clone(&attempts);
+                    async move {
+                        *attempts.lock().unwrap() += 1;
+                        Err("connection failed".to_string())
+                    }
+                },
+            )
+            .await
+        }
+    })
+    .await;
+
+    assert_eq!(
+        result,
+        Err(ImageFetchError::Transient {
+            retry_after: None,
+            retry_inline: false,
+        })
+    );
+    assert_eq!(*attempts.lock().unwrap(), 1);
+}
+
+#[test]
+fn image_cooldown_wait_is_short_and_one_shot() {
+    let url = Url::parse("https://bounded-cooldown.example/image.png").unwrap();
+    let mut waited = false;
+    assert_eq!(
+        retryable_image_cooldown(&url, Some(MAX_INLINE_IMAGE_COOLDOWN), &mut waited,),
+        Some(MAX_INLINE_IMAGE_COOLDOWN)
+    );
+    assert!(waited);
+    assert_eq!(
+        retryable_image_cooldown(&url, Some(MAX_INLINE_IMAGE_COOLDOWN), &mut waited,),
+        None
+    );
+    let excessive_url = Url::parse("https://excessive-cooldown.example/image.png").unwrap();
+    let mut excessive_waited = false;
+    assert_eq!(
+        retryable_image_cooldown(
+            &excessive_url,
+            Some(MAX_INLINE_IMAGE_COOLDOWN + std::time::Duration::from_secs(1)),
+            &mut excessive_waited,
+        ),
+        None
+    );
+    assert!(!excessive_waited);
+}
+
+#[test]
+fn metadata_prefers_open_graph_and_reads_site_name() {
+    let html = r#"<meta content="Buzz" property="og:site_name">
+          <meta content="Rich previews &amp; cards" property="og:title">
+          <meta content="Safe &amp; useful previews" property="og:description">
+          <meta name="twitter:title" content="Twitter fallback"><title>Fallback</title>"#;
+    assert_eq!(
+        extract_link_preview_metadata(html),
+        Some(LinkPreviewMetadata {
+            title: "Rich previews & cards".to_string(),
+            site_name: Some("Buzz".to_string()),
+            description: Some("Safe & useful previews".to_string()),
+            image_data_url: None,
+            image_domain: None,
+            image_fetch_state: LinkPreviewImageFetchState::None,
+            image_retry_after_ms: None,
+            favicon_data_url: None,
+        })
+    );
+}
+
+#[test]
+fn image_results_preserve_absence_and_classify_recovery() {
+    let mut metadata = extract_link_preview_metadata("<title>Preview result</title>").unwrap();
+    apply_image_result(&mut metadata, None);
+    assert_eq!(metadata.image_fetch_state, LinkPreviewImageFetchState::None);
+
+    apply_image_result(
+        &mut metadata,
+        Some(Err(ImageFetchError::Transient {
+            retry_after: Some(std::time::Duration::from_secs(15)),
+            retry_inline: false,
+        })),
+    );
+    assert_eq!(
+        metadata.image_fetch_state,
+        LinkPreviewImageFetchState::TransientFailure
+    );
+    assert_eq!(metadata.image_retry_after_ms, Some(15_000));
+
+    apply_image_result(
+        &mut metadata,
+        Some(Ok((
+            "data:image/jpeg;base64,abc".to_string(),
+            "images.example.com".to_string(),
+        ))),
+    );
+    assert_eq!(
+        metadata.image_fetch_state,
+        LinkPreviewImageFetchState::Image
+    );
+    assert_eq!(metadata.image_domain.as_deref(), Some("images.example.com"));
+}
+
+#[test]
+fn metadata_falls_back_to_twitter_then_title() {
+    assert_eq!(
+        extract_link_preview_metadata("<meta content='Tweet title' name='twitter:title'>")
+            .map(|metadata| metadata.title),
+        Some("Tweet title".to_string())
+    );
+    assert_eq!(
+        extract_link_preview_metadata("<title> Plain   title </title>")
+            .map(|metadata| metadata.title),
+        Some("Plain title".to_string())
+    );
+}
+
+#[test]
+fn metadata_preserves_description_line_breaks() {
+    let html = r#"<meta property="og:title" content="Tweet title">
+          <meta property="og:description" content="First paragraph.&#10;&#10;Agents:&#10;- One&#10;- Two">"#;
+    assert_eq!(
+        extract_link_preview_metadata(html).and_then(|metadata| metadata.description),
+        Some("First paragraph.\n\nAgents:\n- One\n- Two".to_string())
+    );
+}
+
+#[test]
+fn metadata_description_supports_standard_x_posts() {
+    let description = "x".repeat(MAX_METADATA_DESCRIPTION_CHARS + 1);
+    let html = format!(
+        r#"<meta property="og:title" content="Long post"><meta property="og:description" content="{description}">"#
+    );
+    let extracted = extract_link_preview_metadata(&html)
+        .and_then(|metadata| metadata.description)
+        .unwrap();
+    assert_eq!(extracted.chars().count(), MAX_METADATA_DESCRIPTION_CHARS);
+}
+
+#[test]
+fn favicon_metadata_resolves_relative_icon_links() {
+    let page = Url::parse("https://example.com/articles/one").unwrap();
+    let html = r#"<link rel="stylesheet" href="styles.css">
+          <link href="../favicon.png" rel="shortcut icon">"#;
+    assert_eq!(
+        extract_favicon_url(html, &page).unwrap().as_str(),
+        "https://example.com/favicon.png"
+    );
+}
+
+#[test]
+fn favicon_metadata_prefers_a_supported_raster_candidate() {
+    let page = Url::parse("https://github.com/block/buzz").unwrap();
+    let html = r#"<link rel="mask-icon" href="https://assets.example/favicon.svg">
+          <link rel="alternate icon" type="image/png" href="https://assets.example/favicon.png">
+          <link rel="icon" type="image/svg+xml" href="https://assets.example/favicon.svg">"#;
+    assert_eq!(
+        extract_favicon_url(html, &page).unwrap().as_str(),
+        "https://assets.example/favicon.png"
+    );
+}
+
+#[test]
+fn favicon_metadata_uses_touch_icon_before_unsupported_ico() {
+    let page = Url::parse("https://twitter.com/tellaho").unwrap();
+    let html = r#"<link rel="icon" href="/favicon.ico">
+          <link rel="apple-touch-icon" sizes="192x192" href="/apple-touch-icon.png">"#;
+    assert_eq!(
+        extract_favicon_url(html, &page).unwrap().as_str(),
+        "https://twitter.com/apple-touch-icon.png"
+    );
+}
+
+#[test]
+fn image_metadata_resolves_relative_urls_and_prefers_open_graph() {
+    let page = Url::parse("https://example.com/articles/one").unwrap();
+    let html = r#"<meta name="twitter:image" content="https://cdn.example/twitter.jpg">
+          <meta property="og:image" content="../preview.png">"#;
+    assert_eq!(
+        extract_image_url(html, &page).unwrap().as_str(),
+        "https://example.com/preview.png"
+    );
+}
+
+#[tokio::test]
+async fn oversized_html_uses_metadata_within_the_bounded_prefix() {
+    const LIMIT: usize = 256;
+    let metadata = r#"<meta property="og:title" content="Prefix title"><meta property="og:image" content="https://example.com/preview.png">"#;
+    let body = format!("{metadata}{}", "x".repeat(LIMIT));
+    let response = test_response(
+        Router::new().route(
+            "/declared",
+            get(move || {
+                let body = body.clone();
+                async move {
+                    Response::builder()
+                        .header("content-type", "text/html")
+                        .body(Body::from(body))
+                        .unwrap()
+                }
+            }),
+        ),
+        "/declared",
+    )
+    .await;
+    assert!(response
+        .content_length()
+        .is_some_and(|size| size > LIMIT as u64));
+    assert!(is_html_response(&response));
+
+    let prefix = read_bytes_prefix(response, LIMIT).await.unwrap();
+    assert_eq!(prefix.len(), LIMIT);
+    let html = String::from_utf8_lossy(&prefix);
+    assert_eq!(
+        extract_link_preview_metadata(&html).map(|metadata| metadata.title),
+        Some("Prefix title".to_string())
+    );
+    assert!(extract_image_url(&html, &Url::parse("https://example.com").unwrap()).is_some());
+}
+
+#[tokio::test]
+async fn image_retry_after_uses_bounded_delta_seconds() {
+    let response = test_response(
+        Router::new().route(
+            "/rate-limited",
+            get(|| async {
+                Response::builder()
+                    .status(429)
+                    .header("retry-after", "900")
+                    .body(Body::empty())
+                    .unwrap()
+            }),
+        ),
+        "/rate-limited",
+    )
+    .await;
+    assert_eq!(
+        retry_after_duration(&response),
+        Some(std::time::Duration::from_secs(900))
+    );
+
+    let response = test_response(
+        Router::new().route(
+            "/excessive",
+            get(|| async {
+                Response::builder()
+                    .status(429)
+                    .header("retry-after", "7200")
+                    .body(Body::empty())
+                    .unwrap()
+            }),
+        ),
+        "/excessive",
+    )
+    .await;
+    assert_eq!(retry_after_duration(&response), Some(MAX_IMAGE_RETRY_AFTER));
+}
+
+#[tokio::test]
+async fn oversized_chunked_html_ignores_metadata_beyond_the_bounded_prefix() {
+    const LIMIT: usize = 256;
+    let response = test_response(
+            Router::new().route(
+                "/chunked",
+                get(|| async {
+                    let chunks = stream::iter([
+                        Ok::<_, Infallible>(Bytes::from(vec![b'x'; LIMIT])),
+                        Ok(Bytes::from_static(
+                            br#"<meta property="og:title" content="Too late"><meta property="og:image" content="https://example.com/late.png">"#,
+                        )),
+                    ]);
+                    Response::builder()
+                        .header("content-type", "text/html")
+                        .body(Body::from_stream(chunks))
+                        .unwrap()
+                }),
+            ),
+            "/chunked",
+        )
+        .await;
+    assert_eq!(response.content_length(), None);
+
+    let prefix = read_bytes_prefix(response, LIMIT).await.unwrap();
+    assert_eq!(prefix.len(), LIMIT);
+    let html = String::from_utf8_lossy(&prefix);
+    assert_eq!(extract_link_preview_metadata(&html), None);
+    assert_eq!(
+        extract_image_url(&html, &Url::parse("https://example.com").unwrap()),
+        None
+    );
+}
+
+#[test]
+fn sanitizer_rejects_mime_mismatch_and_outputs_static_jpeg() {
+    let source = DynamicImage::ImageRgb8(RgbImage::from_pixel(2, 2, Rgb([10, 20, 30])));
+    let mut png = Cursor::new(Vec::new());
+    source.write_to(&mut png, ImageFormat::Png).unwrap();
+    assert!(sanitize_image(png.get_ref(), "image/jpeg", false).is_err());
+    let sanitized = sanitize_image(png.get_ref(), "image/png", false).unwrap();
+    assert!(sanitized.starts_with("data:image/jpeg;base64,"));
+}
+
+#[test]
+fn favicon_sanitizer_preserves_png_transparency() {
+    let source = DynamicImage::ImageRgba8(RgbaImage::from_pixel(2, 2, Rgba([36, 41, 47, 0])));
+    let mut png = Cursor::new(Vec::new());
+    source.write_to(&mut png, ImageFormat::Png).unwrap();
+
+    let sanitized = sanitize_image(png.get_ref(), "image/png", true).unwrap();
+    assert!(sanitized.starts_with("data:image/png;base64,"));
+    let encoded = sanitized.split_once(',').unwrap().1;
+    let bytes = base64::engine::general_purpose::STANDARD
+        .decode(encoded)
+        .unwrap();
+    assert!(image::load_from_memory(&bytes).unwrap().color().has_alpha());
+}
+
+#[test]
+fn animation_markers_are_rejected_before_decode() {
+    let mut apng = b"\x89PNG\r\n\x1a\n".to_vec();
+    apng.extend_from_slice(b"junkacTLjunk");
+    assert!(declares_animation(&apng, ImageFormat::Png));
+
+    let mut webp = b"RIFF\x00\x00\x00\x00WEBPVP8X\x0a\x00\x00\x00".to_vec();
+    webp.push(0x02);
+    assert!(declares_animation(&webp, ImageFormat::WebP));
+}
+
+#[test]
+fn metadata_requires_a_non_empty_title() {
+    assert_eq!(extract_link_preview_metadata("<title>   </title>"), None);
+    assert_eq!(extract_link_preview_metadata("<html></html>"), None);
+}
diff --git a/desktop/src-tauri/src/commands/link_preview_youtube.rs b/desktop/src-tauri/src/commands/link_preview_youtube.rs
index a0a5a753dcd..b759046d8f0 100644
--- a/desktop/src-tauri/src/commands/link_preview_youtube.rs
+++ b/desktop/src-tauri/src/commands/link_preview_youtube.rs
@@ -5,8 +5,8 @@ use url::Url;
 
 use super::{
     apply_image_result, fetch_sanitized_image, normalize_metadata_description,
-    normalize_metadata_text, read_limited_bytes, send_pinned_request, ImageFetchError,
-    LinkPreviewImageFetchState, LinkPreviewMetadata, PREVIEW_FETCH_TIMEOUT,
+    normalize_metadata_text, read_limited_bytes, send_pinned_request, LinkPreviewImageFetchState,
+    LinkPreviewMetadata,
 };
 
 const MAX_OEMBED_FETCH_BYTES: usize = 64 * 1024;
@@ -54,17 +54,7 @@ pub(super) async fn fetch_oembed_metadata(
         return Ok(None);
     };
     let image_result = match thumbnail_url {
-        Some(thumbnail_url) => Some(
-            tokio::time::timeout(
-                PREVIEW_FETCH_TIMEOUT,
-                fetch_sanitized_image(thumbnail_url, false),
-            )
-            .await
-            .unwrap_or(Err(ImageFetchError::Transient {
-                retry_after: None,
-                retry_inline: false,
-            })),
-        ),
+        Some(thumbnail_url) => Some(fetch_sanitized_image(thumbnail_url, false).await),
         None => None,
     };
     apply_image_result(&mut metadata, image_result);
diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs
index 12082a2a82e..e3ac45953dc 100644
--- a/desktop/src-tauri/src/lib.rs
+++ b/desktop/src-tauri/src/lib.rs
@@ -600,6 +600,8 @@ pub fn run() {
             get_relay_http_url,
             get_media_proxy_port,
             fetch_link_preview_metadata,
+            cancel_link_preview_metadata,
+            release_link_preview_metadata,
             discover_acp_auth_methods,
             discover_acp_providers,
             discover_git_bash_prerequisite,
diff --git a/desktop/src/features/messages/lib/linkPreviewPreparationStore.test.mjs b/desktop/src/features/messages/lib/linkPreviewPreparationStore.test.mjs
index 293fb63e154..7153ff38518 100644
--- a/desktop/src/features/messages/lib/linkPreviewPreparationStore.test.mjs
+++ b/desktop/src/features/messages/lib/linkPreviewPreparationStore.test.mjs
@@ -1,5 +1,7 @@
 import assert from "node:assert/strict";
-import test from "node:test";
+import { after, before, test } from "node:test";
+
+import { JSDOM } from "jsdom";
 
 import {
   __linkPreviewPreparationTest,
@@ -12,6 +14,29 @@ import {
 const first = { href: "https://example.com/first" };
 const second = { href: "https://example.com/second" };
 const firstTag = ["link-preview", "snapshot", first.href];
+const dom = new JSDOM("<!doctype html><html><body></body></html>", {
+  url: "http://localhost",
+});
+const ipcHandlers = new Map();
+
+before(() => {
+  Object.assign(globalThis, {
+    document: dom.window.document,
+    HTMLElement: dom.window.HTMLElement,
+    window: dom.window,
+  });
+  dom.window.__TAURI_INTERNALS__ = {
+    invoke: (cmd, args) => {
+      const handler = ipcHandlers.get(cmd);
+      return handler
+        ? handler(args)
+        : Promise.reject(new Error(`unmocked Tauri command: ${cmd}`));
+    },
+    transformCallback: () => Math.random(),
+  };
+});
+
+after(() => dom.window.close());
 
 function deferred() {
   let resolve;
@@ -41,6 +66,7 @@ function seed(
 
 test.afterEach(() => {
   __linkPreviewPreparationTest.reset();
+  ipcHandlers.clear();
 });
 
 test("adopts one in-flight job for the same canonical URL", () => {
@@ -223,6 +249,60 @@ test("Skip after completion cannot replace finalized tags", async () => {
   });
 });
 
+test("expired settled work replaced by a pending retry keeps deadline and Skip", async () => {
+  const expiredTag = ["link-preview", "snapshot", first.href, "expired"];
+  const pendingRetry = deferred();
+  let fetchCalls = 0;
+  ipcHandlers.set("fetch_link_preview_metadata", () => {
+    fetchCalls += 1;
+    return pendingRetry.promise;
+  });
+  ipcHandlers.set("cancel_link_preview_metadata", () => Promise.resolve());
+  ipcHandlers.set("release_link_preview_metadata", () => Promise.resolve());
+
+  const seedExpiredFallback = () =>
+    seed(
+      first,
+      Promise.resolve(expiredTag),
+      true,
+      Date.now() - 5 * 60_000,
+      expiredTag,
+      expiredTag,
+    );
+
+  seedExpiredFallback();
+  const timeoutPreparation = prepareBackgroundLinkPreviews([first], 0);
+  assert.ok(timeoutPreparation);
+  assert.equal(
+    __linkPreviewPreparationTest.jobs.get(first.href)?.settled,
+    false,
+  );
+  assert.equal(
+    fetchCalls,
+    1,
+    "the expired job was replaced through production I/O",
+  );
+  assert.deepEqual(await timeoutPreparation.promise, {
+    status: "ready",
+    tags: [],
+  });
+
+  seedExpiredFallback();
+  const skipPreparation = prepareBackgroundLinkPreviews([first], 1_000);
+  assert.ok(skipPreparation);
+  assert.equal(
+    __linkPreviewPreparationTest.jobs.get(first.href)?.settled,
+    false,
+  );
+  skipPreparation.skip();
+  assert.deepEqual(await skipPreparation.promise, {
+    status: "ready",
+    tags: [],
+  });
+
+  pendingRetry.resolve(null);
+});
+
 test("already-settled partial results contain only successful tags", async () => {
   seed(first, Promise.resolve(firstTag), true);
   seed(second, Promise.resolve(null), true);
@@ -272,3 +352,18 @@ test("reset cancels pending preparations instead of authorizing send", async ()
 
   assert.deepEqual(await preparation.promise, { status: "cancelled" });
 });
+
+test("Skip aborts an abandoned in-flight preview job", async () => {
+  const pending = deferred();
+  seed(first, pending.promise);
+  const job = __linkPreviewPreparationTest.jobs.get(first.href);
+
+  const preparation = prepareBackgroundLinkPreviews([first], 1_000);
+  assert.ok(preparation);
+  preparation.skip();
+
+  assert.deepEqual(await preparation.promise, { status: "ready", tags: [] });
+  assert.equal(job.controller.signal.aborted, true);
+  assert.equal(__linkPreviewPreparationTest.jobs.has(first.href), false);
+  pending.resolve(null);
+});
diff --git a/desktop/src/features/messages/lib/linkPreviewPreparationStore.ts b/desktop/src/features/messages/lib/linkPreviewPreparationStore.ts
index d61750fcd86..a4f1273ecf2 100644
--- a/desktop/src/features/messages/lib/linkPreviewPreparationStore.ts
+++ b/desktop/src/features/messages/lib/linkPreviewPreparationStore.ts
@@ -9,6 +9,7 @@ import {
 } from "@/shared/lib/linkPreviewSnapshot";
 import {
   loadLinkPreviewMetadata,
+  type LinkPreviewMetadata,
   resolveLinkPreview,
 } from "@/shared/lib/useResolvedLinkPreviews";
 
@@ -27,6 +28,7 @@ type PreviewJob = {
 
 type BackgroundPreviewTask = {
   cancel: () => void;
+  hrefs: Set<string>;
   id: number;
   skip: () => void;
 };
@@ -113,7 +115,26 @@ async function buildSnapshot(
   signal: AbortSignal,
   onMetadataReady: (tag: string[]) => void,
 ): Promise<string[] | null> {
-  const metadata = await loadLinkPreviewMetadata(candidate.href);
+  const metadataLoad = loadLinkPreviewMetadata(candidate.href);
+  let settleAbortedMetadata: (() => void) | null = null;
+  const abortedMetadata = new Promise<null>((resolve) => {
+    settleAbortedMetadata = () => resolve(null);
+  });
+  const cancelMetadata = () => {
+    metadataLoad.cancel();
+    settleAbortedMetadata?.();
+  };
+  signal.addEventListener("abort", cancelMetadata, { once: true });
+  if (signal.aborted) cancelMetadata();
+  let metadata: LinkPreviewMetadata | null;
+  try {
+    metadata = await Promise.race([metadataLoad.promise, abortedMetadata]);
+  } catch {
+    return null;
+  } finally {
+    signal.removeEventListener("abort", cancelMetadata);
+    metadataLoad.cancel();
+  }
   if (signal.aborted || !metadata) return null;
   const preview = resolveLinkPreview(candidate, metadata);
   if (!preview.snapshotReady) return null;
@@ -265,12 +286,15 @@ export function prepareBackgroundLinkPreviews(
     skip,
   });
 
+  const preparations = external.map((candidate) =>
+    prepareLinkPreview(candidate),
+  );
   const pending = external.some(
     (candidate) => !jobs.get(candidate.href)?.settled,
   );
   if (!pending) {
     return preparedSend(
-      Promise.all(external.map(prepareLinkPreview)).then((tags) => ({
+      Promise.all(preparations).then((tags) => ({
         status: "ready" as const,
         tags: tags.filter((tag): tag is string[] => tag !== null),
       })),
@@ -288,27 +312,45 @@ export function prepareBackgroundLinkPreviews(
   let finish: ((result: BackgroundLinkPreviewResult) => void) | null = null;
   let terminal = false;
   let timer: ReturnType<typeof setTimeout> | null = null;
-  const complete = (result: BackgroundLinkPreviewResult) => {
+  const complete = (
+    result: BackgroundLinkPreviewResult,
+    abortUnobservedJobs = false,
+  ) => {
     if (terminal) return;
     terminal = true;
     if (timer !== null) clearTimeout(timer);
     tasks.delete(taskId);
+    if (abortUnobservedJobs) {
+      for (const candidate of external) {
+        const observedByAnotherSend = [...tasks.values()].some((task) =>
+          task.hrefs.has(candidate.href),
+        );
+        if (!observedByAnotherSend) {
+          invalidateLinkPreviewPreparation(candidate.href);
+        }
+      }
+    }
     publishSnapshot();
     finish?.(result);
   };
   const promise = new Promise<BackgroundLinkPreviewResult>((resolve) => {
     finish = resolve;
   });
-  const cancel = () => complete({ status: "cancelled" });
-  const skip = () => complete({ status: "ready", tags: [] });
-  tasks.set(taskId, { cancel, id: taskId, skip });
+  const cancel = () => complete({ status: "cancelled" }, true);
+  const skip = () => complete({ status: "ready", tags: [] }, true);
+  tasks.set(taskId, {
+    cancel,
+    hrefs: new Set(external.map((candidate) => candidate.href)),
+    id: taskId,
+    skip,
+  });
   publishSnapshot();
 
   timer = setTimeout(
-    () => complete({ status: "ready", tags: availableTags() }),
+    () => complete({ status: "ready", tags: availableTags() }, true),
     timeoutMs,
   );
-  void Promise.all(external.map(prepareLinkPreview)).then((tags) => {
+  void Promise.all(preparations).then((tags) => {
     complete({
       status: "ready",
       tags: tags.filter((tag): tag is string[] => tag !== null),
diff --git a/desktop/src/shared/lib/useResolvedLinkPreviews.test.mjs b/desktop/src/shared/lib/useResolvedLinkPreviews.test.mjs
index e413f9c7c20..26811489037 100644
--- a/desktop/src/shared/lib/useResolvedLinkPreviews.test.mjs
+++ b/desktop/src/shared/lib/useResolvedLinkPreviews.test.mjs
@@ -6,6 +6,7 @@ import { JSDOM } from "jsdom";
 import {
   __linkPreviewMetadataTest,
   fetchBuzzEntityMetadata,
+  loadLinkPreviewMetadata,
   isBuzzEntityPreview,
   resetLinkPreviewMetadataCache,
   resolveLinkPreview,
@@ -33,6 +34,16 @@ function metadata(overrides = {}) {
   };
 }
 
+function deferred() {
+  let reject;
+  let resolve;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    reject = rejectPromise;
+    resolve = resolvePromise;
+  });
+  return { promise, reject, resolve };
+}
+
 test("pending external metadata reserves the image treatment", () => {
   assert.deepEqual(resolveLinkPreview(preview, undefined), {
     ...preview,
@@ -140,14 +151,14 @@ test("metadata loader retries transient images after the server cooldown", async
   });
 
   assert.equal(
-    (await loader.load(preview.href)).metadata?.imageFetchState,
+    (await loader.load(preview.href).promise).metadata?.imageFetchState,
     "transient_failure",
   );
   assert.equal(calls, 1);
 
   now += 10_000;
   assert.equal(
-    (await loader.load(preview.href)).metadata?.imageFetchState,
+    (await loader.load(preview.href).promise).metadata?.imageFetchState,
     "image",
   );
   assert.equal(calls, 2);
@@ -165,12 +176,15 @@ test("metadata loader retries rejected requests after the negative-cache TTL", a
     now: () => now,
   });
 
-  assert.equal((await loader.load(preview.href)).metadata, null);
-  assert.equal((await loader.load(preview.href)).metadata, null);
+  assert.equal((await loader.load(preview.href).promise).metadata, null);
+  assert.equal((await loader.load(preview.href).promise).metadata, null);
   assert.equal(calls, 1);
 
   now += 5 * 60_000;
-  assert.deepEqual((await loader.load(preview.href)).metadata, metadata());
+  assert.deepEqual(
+    (await loader.load(preview.href).promise).metadata,
+    metadata(),
+  );
   assert.equal(calls, 2);
 });
 
@@ -191,10 +205,10 @@ test("metadata loader coalesces fragment variants and bounds concurrency", async
   });
 
   await Promise.all([
-    loader.load("https://example.com/one#first"),
-    loader.load("https://example.com/one#second"),
-    loader.load("https://example.com/two"),
-    loader.load("https://example.com/three"),
+    loader.load("https://example.com/one#first").promise,
+    loader.load("https://example.com/one#second").promise,
+    loader.load("https://example.com/two").promise,
+    loader.load("https://example.com/three").promise,
   ]);
 
   assert.equal(calls, 3);
@@ -504,12 +518,15 @@ test("invalidateNegative drops a cached null miss so the next load refetches", a
     now: () => now,
   });
 
-  assert.equal((await loader.load(preview.href)).metadata, null);
+  assert.equal((await loader.load(preview.href).promise).metadata, null);
   assert.equal(calls, 1);
 
   loader.invalidateNegative(preview.href);
   nextResult = metadata();
-  assert.deepEqual((await loader.load(preview.href)).metadata, metadata());
+  assert.deepEqual(
+    (await loader.load(preview.href).promise).metadata,
+    metadata(),
+  );
   assert.equal(calls, 2);
 });
 
@@ -538,7 +555,7 @@ test("invalidateNegative drops a cached transient failure so the next load refet
   });
 
   assert.equal(
-    (await loader.load(preview.href)).metadata?.imageFetchState,
+    (await loader.load(preview.href).promise).metadata?.imageFetchState,
     "transient_failure",
   );
   assert.equal(calls, 1);
@@ -547,7 +564,7 @@ test("invalidateNegative drops a cached transient failure so the next load refet
   // the cooldown — is what forces the refetch.
   loader.invalidateNegative(preview.href);
   assert.equal(
-    (await loader.load(preview.href)).metadata?.imageFetchState,
+    (await loader.load(preview.href).promise).metadata?.imageFetchState,
     "image",
   );
   assert.equal(calls, 2);
@@ -566,11 +583,17 @@ test("invalidateNegative leaves a healthy cached hit untouched", async () => {
     now: () => now,
   });
 
-  assert.deepEqual((await loader.load(preview.href)).metadata, metadata());
+  assert.deepEqual(
+    (await loader.load(preview.href).promise).metadata,
+    metadata(),
+  );
   assert.equal(calls, 1);
 
   loader.invalidateNegative(preview.href);
-  assert.deepEqual((await loader.load(preview.href)).metadata, metadata());
+  assert.deepEqual(
+    (await loader.load(preview.href).promise).metadata,
+    metadata(),
+  );
   assert.equal(calls, 1);
 });
 
@@ -599,10 +622,74 @@ test("invalidateNegative leaves an in-flight fetch untouched", async () => {
   assert.equal(calls, 1, "no redundant fetch started by the bust");
 
   releaseFetch();
-  assert.deepEqual((await pending).metadata, metadata());
+  assert.deepEqual((await pending.promise).metadata, metadata());
   assert.equal(calls, 1, "the original in-flight fetch resolved, not a retry");
 });
 
+test("an orphaned metadata load is cancelled after its re-entry grace period", async () => {
+  let cancelled = false;
+  const loader = __linkPreviewMetadataTest.createMetadataLoader({
+    fetcher: (_href, signal) =>
+      new Promise((_resolve, reject) => {
+        signal.addEventListener(
+          "abort",
+          () => {
+            cancelled = true;
+            reject(new Error("cancelled"));
+          },
+          { once: true },
+        );
+      }),
+  });
+
+  const load = loader.load(preview.href);
+  const rejection = assert.rejects(load.promise, /cancelled/);
+  load.cancel();
+  await new Promise((resolve) => setTimeout(resolve, 1_050));
+  assert.equal(cancelled, true);
+  await rejection;
+});
+
+test("new metadata demand immediately reclaims slots from orphaned loads", async () => {
+  const started = [];
+  const cancelled = [];
+  const releases = new Map();
+  const loader = __linkPreviewMetadataTest.createMetadataLoader({
+    concurrency: 2,
+    fetcher: (href, signal) =>
+      new Promise((resolve, reject) => {
+        started.push(href);
+        releases.set(href, () => resolve(metadata()));
+        signal.addEventListener(
+          "abort",
+          () => {
+            cancelled.push(href);
+            reject(new Error("cancelled"));
+          },
+          { once: true },
+        );
+      }),
+  });
+
+  const firstHref = "https://example.com/stalled-one";
+  const secondHref = "https://example.com/stalled-two";
+  const thirdHref = "https://example.com/ordinary";
+  const first = loader.load(firstHref);
+  const second = loader.load(secondHref);
+  const firstSettled = first.promise.catch(() => undefined);
+  const secondSettled = second.promise.catch(() => undefined);
+  first.cancel();
+  second.cancel();
+
+  const third = loader.load(thirdHref);
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.deepEqual(started, [firstHref, secondHref, thirdHref]);
+  assert.deepEqual(new Set(cancelled), new Set([firstHref, secondHref]));
+  releases.get(thirdHref)();
+  assert.deepEqual((await third.promise).metadata, metadata());
+  await Promise.all([firstSettled, secondSettled]);
+});
+
 // ── Hook-level regression: retained resolved-state invalidation on re-entry ───
 //
 // The loader tests above prove `invalidateNegative` drops the SHARED loader
@@ -899,3 +986,146 @@ test("hook clears a re-entered negative even when the shared cache holds an in-f
     ipcHandlers.clear();
   }
 });
+
+test("preparation abort releases only its own shared metadata lease", async () => {
+  const { prepareLinkPreview, resetLinkPreviewPreparations } = await import(
+    "../../features/messages/lib/linkPreviewPreparationStore.ts"
+  );
+
+  resetLinkPreviewMetadataCache();
+  resetLinkPreviewPreparations();
+  ipcHandlers.clear();
+
+  const href = "https://example.com/shared-pending";
+  let fetchRequest;
+  const cancelledRequestIds = [];
+  ipcHandlers.set("fetch_link_preview_metadata", (args) => {
+    const request = deferred();
+    fetchRequest = { ...args, ...request };
+    return request.promise;
+  });
+  ipcHandlers.set("cancel_link_preview_metadata", ({ requestId }) => {
+    cancelledRequestIds.push(requestId);
+    return Promise.resolve();
+  });
+  ipcHandlers.set("release_link_preview_metadata", () => Promise.resolve());
+
+  try {
+    const composerLoad = loadLinkPreviewMetadata(href);
+    const preparation = prepareLinkPreview({ ...hookPreview, href });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.ok(fetchRequest, "shared metadata reached the native fetch seam");
+
+    resetLinkPreviewPreparations();
+    assert.equal(await preparation, null);
+    await new Promise((resolve) => setTimeout(resolve, 1_050));
+    assert.deepEqual(
+      cancelledRequestIds,
+      [],
+      "preparation listener plus finally must not release the composer lease",
+    );
+
+    fetchRequest.resolve(metadata());
+    assert.deepEqual(await composerLoad.promise, metadata());
+
+    const finalHref = `${href}/final`;
+    const finalLoad = loadLinkPreviewMetadata(finalHref);
+    await new Promise((resolve) => setImmediate(resolve));
+    const finalRequest = fetchRequest;
+    const finalRejection = assert.rejects(finalLoad.promise);
+    finalLoad.cancel();
+    finalLoad.cancel();
+    await new Promise((resolve) => setTimeout(resolve, 1_050));
+    assert.deepEqual(
+      cancelledRequestIds,
+      [finalRequest.requestId],
+      "one final consumer release permits native abort",
+    );
+    finalRequest.reject(new Error("cancelled by test native seam"));
+    await finalRejection;
+  } finally {
+    resetLinkPreviewPreparations();
+    resetLinkPreviewMetadataCache();
+    ipcHandlers.clear();
+  }
+});
+
+test("removing two stalled previews cancels native work and admits a third URL", async () => {
+  const { act, cleanup, renderHook } = await import("@testing-library/react");
+  const { useResolvedLinkPreviews } = await import(
+    "./useResolvedLinkPreviews.ts"
+  );
+
+  resetLinkPreviewMetadataCache();
+  ipcHandlers.clear();
+
+  const firstPreview = {
+    ...hookPreview,
+    href: "https://example.com/stalled-one",
+  };
+  const secondPreview = {
+    ...hookPreview,
+    href: "https://example.com/stalled-two",
+  };
+  const thirdPreview = { ...hookPreview, href: "https://example.com/ordinary" };
+  const pending = new Map();
+  const started = [];
+  const cancelled = [];
+
+  ipcHandlers.set("fetch_link_preview_metadata", ({ href, requestId }) => {
+    started.push(href);
+    return new Promise((resolve, reject) => {
+      pending.set(requestId, { href, reject, resolve });
+    });
+  });
+  ipcHandlers.set("cancel_link_preview_metadata", ({ requestId }) => {
+    const request = pending.get(requestId);
+    if (!request) return Promise.resolve();
+    cancelled.push(request.href);
+    pending.delete(requestId);
+    request.reject(new Error("cancelled by test native seam"));
+    return Promise.resolve();
+  });
+  ipcHandlers.set("release_link_preview_metadata", () => Promise.resolve());
+
+  const flushScheduledLoads = async () => {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+  };
+
+  const hook = renderHook(({ previews }) => useResolvedLinkPreviews(previews), {
+    initialProps: { previews: [firstPreview, secondPreview] },
+  });
+
+  try {
+    await flushScheduledLoads();
+    assert.deepEqual(started, [firstPreview.href, secondPreview.href]);
+
+    hook.rerender({ previews: [thirdPreview] });
+    await flushScheduledLoads();
+    assert.deepEqual(
+      new Set(cancelled),
+      new Set([firstPreview.href, secondPreview.href]),
+    );
+    assert.deepEqual(started, [
+      firstPreview.href,
+      secondPreview.href,
+      thirdPreview.href,
+    ]);
+
+    const third = [...pending.values()].find(
+      (request) => request.href === thirdPreview.href,
+    );
+    assert.ok(third, "third URL reached the native fetch seam");
+    await act(async () => {
+      third.resolve(metadata());
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+    assert.equal(hook.result.current[0].title, "A story");
+  } finally {
+    hook.unmount();
+    cleanup();
+    ipcHandlers.clear();
+  }
+});
diff --git a/desktop/src/shared/lib/useResolvedLinkPreviews.ts b/desktop/src/shared/lib/useResolvedLinkPreviews.ts
index 4591d54e7dd..5111929b3e3 100644
--- a/desktop/src/shared/lib/useResolvedLinkPreviews.ts
+++ b/desktop/src/shared/lib/useResolvedLinkPreviews.ts
@@ -51,6 +51,10 @@ type MetadataLoadResult = MetadataCacheEntry & {
 const DEFAULT_TRANSIENT_RETRY_MS = 30_000;
 const NULL_METADATA_RETRY_MS = 5 * 60_000;
 const MAX_CONCURRENT_METADATA_FETCHES = 2;
+// Keep a just-removed request cacheable through a brief edit/re-entry gap, but
+// never let unobserved native work linger indefinitely. New queued demand
+// reclaims these loads immediately rather than waiting for this grace period.
+const ORPHANED_METADATA_LOAD_GRACE_MS = 1_000;
 
 /**
  * React may flush an interaction-triggered effect before the browser paints.
@@ -107,29 +111,70 @@ function metadataExpiry(
   return now + retryAfterMs;
 }
 
+type PendingMetadataLoad = {
+  controller: AbortController;
+  consumers: number;
+  orphanTimer: ReturnType<typeof setTimeout> | null;
+  promise: Promise<MetadataLoadResult>;
+};
+
+type MetadataCacheValue = MetadataCacheEntry | PendingMetadataLoad;
+
+function isPendingMetadataLoad(
+  value: MetadataCacheValue,
+): value is PendingMetadataLoad {
+  return "promise" in value;
+}
+
+function abortError(): DOMException {
+  return new DOMException("Link preview fetch cancelled", "AbortError");
+}
+
 function createTaskScheduler(concurrency: number) {
-  const pending: Array<() => void> = [];
+  const pending: Array<{
+    reject: (reason?: unknown) => void;
+    run: () => void;
+    signal: AbortSignal;
+  }> = [];
   let active = 0;
 
   const drain = () => {
     while (active < concurrency) {
-      const run = pending.shift();
-      if (!run) return;
+      const next = pending.shift();
+      if (!next) return;
+      if (next.signal.aborted) {
+        next.reject(abortError());
+        continue;
+      }
       active += 1;
-      run();
+      next.run();
     }
   };
 
-  return <T>(task: () => Promise<T>): Promise<T> =>
+  return <T>(task: () => Promise<T>, signal: AbortSignal): Promise<T> =>
     new Promise<T>((resolve, reject) => {
-      pending.push(() => {
-        void task()
-          .then(resolve, reject)
-          .finally(() => {
-            active -= 1;
-            drain();
-          });
-      });
+      const entry = {
+        reject,
+        signal,
+        run: () => {
+          signal.removeEventListener("abort", cancelPending);
+          void task()
+            .then(resolve, reject)
+            .finally(() => {
+              active -= 1;
+              drain();
+            });
+        },
+      };
+      const cancelPending = () => {
+        const index = pending.indexOf(entry);
+        if (index < 0) return;
+        pending.splice(index, 1);
+        reject(abortError());
+        drain();
+      };
+      signal.addEventListener("abort", cancelPending, { once: true });
+      pending.push(entry);
       drain();
     });
 }
@@ -140,20 +185,20 @@ function createMetadataLoader({
   now = Date.now,
 }: {
   concurrency?: number;
-  fetcher: (href: string) => Promise<LinkPreviewMetadata | null>;
+  fetcher: (
+    href: string,
+    signal: AbortSignal,
+  ) => Promise<LinkPreviewMetadata | null>;
   now?: () => number;
 }) {
-  const cache = new Map<
-    string,
-    MetadataCacheEntry | Promise<MetadataLoadResult>
-  >();
+  const cache = new Map<string, MetadataCacheValue>();
   const schedule = createTaskScheduler(Math.max(1, concurrency));
   let generation = 0;
 
   const peek = (href: string): MetadataLoadResult | undefined => {
     const key = metadataCacheKey(href);
     const cached = cache.get(key);
-    if (!cached || cached instanceof Promise) return undefined;
+    if (!cached || isPendingMetadataLoad(cached)) return undefined;
     if (cached.expiresAt !== null && cached.expiresAt <= now()) {
       cache.delete(key);
       return undefined;
@@ -161,32 +206,116 @@ function createMetadataLoader({
     return { key, ...cached };
   };
 
-  const load = (href: string): Promise<MetadataLoadResult> => {
+  const abortPending = (key: string, pending: PendingMetadataLoad) => {
+    if (pending.orphanTimer !== null) clearTimeout(pending.orphanTimer);
+    pending.orphanTimer = null;
+    if (cache.get(key) === pending) cache.delete(key);
+    pending.controller.abort();
+  };
+
+  const release = (key: string, pending: PendingMetadataLoad) => {
+    if (pending.consumers <= 0) return;
+    pending.consumers -= 1;
+    if (
+      pending.consumers > 0 ||
+      pending.orphanTimer !== null ||
+      cache.get(key) !== pending
+    ) {
+      return;
+    }
+    pending.orphanTimer = setTimeout(
+      () => abortPending(key, pending),
+      ORPHANED_METADATA_LOAD_GRACE_MS,
+    );
+  };
+
+  const createRelease = (key: string, pending: PendingMetadataLoad) => {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      release(key, pending);
+    };
+  };
+
+  const abortOrphanedLoads = (exceptKey: string) => {
+    for (const [key, cached] of cache) {
+      if (
+        key !== exceptKey &&
+        isPendingMetadataLoad(cached) &&
+        cached.consumers === 0
+      ) {
+        abortPending(key, cached);
+      }
+    }
+  };
+
+  const load = (
+    href: string,
+  ): { cancel: () => void; promise: Promise<MetadataLoadResult> } => {
     const key = metadataCacheKey(href);
     const cached = cache.get(key);
-    if (cached instanceof Promise) return cached;
+    if (cached && isPendingMetadataLoad(cached)) {
+      if (cached.orphanTimer !== null) clearTimeout(cached.orphanTimer);
+      cached.orphanTimer = null;
+      cached.consumers += 1;
+      return {
+        cancel: createRelease(key, cached),
+        promise: cached.promise,
+      };
+    }
     if (cached) {
       if (cached.expiresAt === null || cached.expiresAt > now()) {
-        return Promise.resolve({ key, ...cached });
+        return {
+          cancel: () => undefined,
+          promise: Promise.resolve({ key, ...cached }),
+        };
       }
       cache.delete(key);
     }
 
+    abortOrphanedLoads(key);
     const requestGeneration = generation;
-    const promise = schedule(() => fetcher(href))
-      .catch(() => null)
+    const controller = new AbortController();
+    const pending: PendingMetadataLoad = {
+      controller,
+      consumers: 1,
+      orphanTimer: null,
+      promise: Promise.resolve({
+        expiresAt: null,
+        key,
+        metadata: null,
+      }),
+    };
+    pending.promise = schedule(
+      () => fetcher(href, controller.signal),
+      controller.signal,
+    )
+      .catch((error) => {
+        if (controller.signal.aborted) throw error;
+        return null;
+      })
       .then((metadata) => {
+        if (pending.orphanTimer !== null) clearTimeout(pending.orphanTimer);
+        pending.orphanTimer = null;
         const entry = {
           expiresAt: metadataExpiry(metadata, now()),
           metadata,
         };
-        if (requestGeneration === generation) {
+        if (
+          requestGeneration === generation &&
+          cache.get(key) === pending &&
+          !controller.signal.aborted
+        ) {
           cache.set(key, entry);
         }
         return { key, ...entry };
       });
-    cache.set(key, promise);
-    return promise;
+    cache.set(key, pending);
+    return {
+      cancel: createRelease(key, pending),
+      promise: pending.promise,
+    };
   };
 
   return {
@@ -205,7 +334,7 @@ function createMetadataLoader({
     invalidateNegative(href: string): boolean {
       const key = metadataCacheKey(href);
       const cached = cache.get(key);
-      if (!cached || cached instanceof Promise) return false;
+      if (!cached || isPendingMetadataLoad(cached)) return false;
       if (!isNegativeMetadata(cached.metadata)) return false;
       cache.delete(key);
       return true;
@@ -214,6 +343,9 @@ function createMetadataLoader({
     peek,
     reset() {
       generation += 1;
+      for (const [key, cached] of cache) {
+        if (isPendingMetadataLoad(cached)) abortPending(key, cached);
+      }
       cache.clear();
     },
   };
@@ -221,13 +353,57 @@ function createMetadataLoader({
 
 function fetchLinkPreviewMetadata(
   href: string,
+  signal: AbortSignal,
 ): Promise<LinkPreviewMetadata | null> {
-  return invokeTauri<LinkPreviewMetadata | null>(
+  const requestId = crypto.randomUUID();
+  const startedAt = performance.now();
+  const logResult = (
+    result: LinkPreviewMetadata | null,
+  ): LinkPreviewMetadata | null => {
+    if (import.meta.env?.DEV) {
+      console.info("[link-preview] metadata fetch completed", {
+        href,
+        elapsedMs: Math.round(performance.now() - startedAt),
+        result: result === null ? "miss" : "hit",
+        imageFetchState: result?.imageFetchState ?? "none",
+        imageRetryAfterMs: result?.imageRetryAfterMs ?? null,
+        hasImage: Boolean(result?.imageDataUrl && result.imageDomain),
+        hasFavicon: Boolean(result?.faviconDataUrl),
+      });
+    }
+    return result;
+  };
+  const logFailure = (error: unknown): never => {
+    if (import.meta.env?.DEV) {
+      console.warn("[link-preview] metadata fetch failed", {
+        href,
+        elapsedMs: Math.round(performance.now() - startedAt),
+        error,
+      });
+    }
+    throw error;
+  };
+
+  const request = invokeTauri<LinkPreviewMetadata | null>(
     "fetch_link_preview_metadata",
     {
       href,
+      requestId,
     },
   );
+  const onAbort = () => {
+    void invokeTauri("cancel_link_preview_metadata", { requestId }).catch(
+      () => undefined,
+    );
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  if (signal.aborted) onAbort();
+  return request.then(logResult, logFailure).finally(() => {
+    signal.removeEventListener("abort", onAbort);
+    void invokeTauri("release_link_preview_metadata", { requestId }).catch(
+      () => undefined,
+    );
+  });
 }
 
 const metadataLoader = createMetadataLoader({
@@ -235,10 +411,15 @@ const metadataLoader = createMetadataLoader({
 });
 
 /** Share the same deduplicated metadata job between composer rendering and send preparation. */
-export async function loadLinkPreviewMetadata(
-  href: string,
-): Promise<LinkPreviewMetadata | null> {
-  return (await metadataLoader.load(href)).metadata;
+export function loadLinkPreviewMetadata(href: string): {
+  cancel: () => void;
+  promise: Promise<LinkPreviewMetadata | null>;
+} {
+  const load = metadataLoader.load(href);
+  return {
+    cancel: load.cancel,
+    promise: load.promise.then((result) => result.metadata),
+  };
 }
 type EntityEventFetcher = (
   filter: Parameters<typeof relayClient.fetchEvents>[0],
@@ -348,14 +529,19 @@ export async function fetchBuzzEntityMetadata(
 }
 
 const entityMetadataLoader = createMetadataLoader({
-  fetcher: fetchBuzzEntityMetadata,
+  fetcher: (href) => fetchBuzzEntityMetadata(href),
 });
 
 /** Share deduplicated relay-native entity metadata across cards and inline tooltips. */
 export async function loadBuzzEntityMetadata(
   href: string,
 ): Promise<LinkPreviewMetadata | null> {
-  return (await entityMetadataLoader.load(href)).metadata;
+  const load = entityMetadataLoader.load(href);
+  try {
+    return (await load.promise).metadata;
+  } finally {
+    load.cancel();
+  }
 }
 
 /** Clear ephemeral metadata when the active relay/community changes. */
@@ -622,15 +808,19 @@ export function useResolvedLinkPreviews(
 
       cancelScheduledLoads.push(
         scheduleAfterPaint(() => {
-          void loader.load(preview.href).then((result) => {
-            if (cancelled) return;
-            setResolvedMetadata((current) =>
-              current[result.key] === result.metadata
-                ? current
-                : { ...current, [result.key]: result.metadata },
-            );
-            scheduleRetry(result, loader);
-          });
+          const load = loader.load(preview.href);
+          cancelScheduledLoads.push(load.cancel);
+          void load.promise
+            .then((result) => {
+              if (cancelled) return;
+              setResolvedMetadata((current) =>
+                current[result.key] === result.metadata
+                  ? current
+                  : { ...current, [result.key]: result.metadata },
+              );
+              scheduleRetry(result, loader);
+            })
+            .catch(() => undefined);
         }),
       );
     }

From c045321a7fb3ca8939f28519ce7a555a6f597728 Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Tue, 8 Sep 2026 17:51:47 -0400
Subject: [PATCH 02/19] fix(acp): pace targeted overflow recovery on consumer
 capacity (#7325)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖
## Summary

When a Buzz agent falls behind on incoming messages, its connection can
make the backlog worse while trying to recover. The connection buffers
messages from the relay server until the agent is ready to process them;
if that buffer overflows, recovery previously requested history for
**every subscribed channel** and paused socket reads while sending those
requests. That adds traffic to an already overloaded connection. This
change requests history only for affected subscriptions, once the code
consuming those messages has room, with at least five seconds between
attempts.

The recovery path now:

- Combines repeated losses into one pending recovery per affected
subscription, keeping the oldest dropped timestamp so replay starts
early enough.
- Waits until at least half the consumer queue is free and the relay's
existing rate-limit delay has expired. The queue wakes recovery when
space becomes available; recovery does not periodically sample capacity
or hold queue space away from live messages.
- Attempts one subscription at a time, choosing the least recently
attempted so a busy channel cannot crowd out other channels or
membership notifications. The five-second delay starts when an attempt
finishes, including a failed write; failed writes leave recovery
pending.

Recovery is paced by available capacity, not by how often messages are
lost. This is not a larger buffer or a cutoff that abandons recovery.
Subscription identifiers, message filters, replay timestamp overlap and
duplicate filtering are unchanged; no downstream agent changes are
required.

This targets a reproducible overload **amplifier**, not every cause of
overload or every catch-up limitation. The initial live overload's cause
has not been established. Recovery remains best effort: a successful
request write is not proof of delivery, and existing history/retention
limits, bounded duplicate tracking and replay limitations still apply.
There is no exactly-once or complete catch-up guarantee. A stalled write
can still pause socket reads for the existing ten-second timeout; the
pacing bound does not cover initial subscriptions, reconnects or other
retry paths.

### Related issue

Closest related: #5014 (channel re-subscription); also #6661 (membership
reconciliation) and #6090 (relay backpressure gap signaling). This
addresses local overflow recovery scheduling, not those separate
mechanisms.

### Testing

Recorded offline comparisons against the previous behavior, with the
final implementation at `8000636f3073167c5a5107bb179c7d91160f1729`:

| Same fixture: 18 subscriptions, three overload rounds | Before | After
|
| --- | --- | --- |
| Recovery history requests | 108 | 3 |
| Ping-response delay | About 4.6 seconds | Below the measurement's 1 ms
resolution |

A separate bounded-history fixture delivered all 320 events plus
subsequent live traffic in **both** versions. Regression coverage
exercises the real socket-handling task, including intermittent consumer
capacity, fairness, failed writes and cancellation of capacity waits
before live delivery. These are synthetic results, not production
throughput measurements or evidence of a deployed cure.

The full local `RUST_TEST_THREADS=4 just ci` run passed on September 4,
2026. Earlier unsuccessful local runs remain part of the validation
history. The [recorded validation evidence and separate desktop
follow-up](https://github.com/block/buzz/pull/7325#issuecomment-5540592398)
preserve the original desktop mock-history scroll failure, its passing
rerun and the remaining investigation. That desktop path does not run
the agent connection code; neither this repair nor the passing rerun
fixes the observed scroll problem.

---------

Signed-off-by: Logan Johnson <loganj@squareup.com>
---
 crates/buzz-acp/README.md                     |   4 +
 crates/buzz-acp/src/relay.rs                  | 112 +---
 crates/buzz-acp/src/relay/recovery.rs         | 132 +++++
 crates/buzz-acp/src/relay/recovery_tests.rs   | 388 ++++++++++++++
 .../buzz-acp/src/relay/recovery_wake_tests.rs | 507 ++++++++++++++++++
 5 files changed, 1052 insertions(+), 91 deletions(-)
 create mode 100644 crates/buzz-acp/src/relay/recovery.rs
 create mode 100644 crates/buzz-acp/src/relay/recovery_tests.rs
 create mode 100644 crates/buzz-acp/src/relay/recovery_wake_tests.rs

diff --git a/crates/buzz-acp/README.md b/crates/buzz-acp/README.md
index 41d9a214bdd..3d011eb8ebb 100644
--- a/crates/buzz-acp/README.md
+++ b/crates/buzz-acp/README.md
@@ -270,6 +270,10 @@ Forum event kinds:
 4. **Prompting** — When events are pending and no prompt is in flight for that channel, drains all queued events for the oldest channel into a single batched prompt via ACP `session/prompt`.
 5. **Agent response** — The agent processes the prompt and uses the Buzz CLI (`send_message`, `get_messages`, etc.) to interact with Buzz.
 6. **Recovery** — If the agent crashes, the harness respawns it. If the relay disconnects, the harness reconnects with a `since` filter to avoid missing events.
+   If the inbound queue overflows, the harness attempts replay for affected
+   subscriptions when capacity and relay quota permit, with at least five seconds
+   between attempts. Recovery depends on available relay history and the consumer
+   making progress; complete delivery is not guaranteed.
 
 Each channel has at most one prompt in flight. Multiple channels can be processed concurrently when agents > 1.
 
diff --git a/crates/buzz-acp/src/relay.rs b/crates/buzz-acp/src/relay.rs
index 23ed454fa2e..a019e758341 100644
--- a/crates/buzz-acp/src/relay.rs
+++ b/crates/buzz-acp/src/relay.rs
@@ -1160,10 +1160,8 @@ struct BgState {
     /// On reconnect resubscribe, `since` = min(last_seen, channel_dropped_since).
     /// Cleared per-channel after a successful resubscribe.
     channel_dropped_since: HashMap<Uuid, u64>,
-    /// Set by the backpressure handler when the event channel is full.
-    /// The main loop checks this flag and triggers a proactive resubscribe
-    /// (without waiting for a disconnect) so dropped events are replayed.
-    proactive_resubscribe_needed: bool,
+    /// Rate/fairness bookkeeping only; replay cursors retain baseline semantics.
+    recovery: recovery::RecoverySchedule,
     /// Unix timestamp captured just before the relay connection was established.
     /// Used as the floor `since` for membership notification replay so events
     /// predating this session are never re-delivered.
@@ -1237,7 +1235,7 @@ impl BgState {
             membership_sub_active: false,
             observer_control_sub_active: false,
             channel_dropped_since: HashMap::new(),
-            proactive_resubscribe_needed: false,
+            recovery: recovery::RecoverySchedule::default(),
             startup_watermark: None,
             subscribe_since: HashMap::new(),
             rate_limit_gate: None,
@@ -1298,6 +1296,9 @@ impl BgState {
     /// Prevents stale replay on re-subscribe and avoids unbounded state growth
     /// for channels that are removed and never re-added.
     fn clear_channel_state(&mut self, channel_id: &Uuid) {
+        self.recovery
+            .last_attempt
+            .remove(&channel_sub_id(*channel_id));
         self.last_seen.remove(channel_id);
         self.subscribe_since.remove(channel_id);
         self.channel_dropped_since.remove(channel_id);
@@ -1826,82 +1827,6 @@ async fn run_background_task(
     let mut drain_pacing_next: Option<tokio::time::Instant> = None;
 
     loop {
-        if state.proactive_resubscribe_needed {
-            state.proactive_resubscribe_needed = false;
-            info!("proactive resubscribe triggered by backpressure event loss");
-            // Proactive resubscribe runs on the EXISTING socket — do NOT clear the
-            // rate-limit gate or pending queues.
-            match resubscribe_after_reconnect(
-                &mut ws,
-                &mut cmd_rx,
-                &mut state,
-                &agent_pubkey_hex,
-                false, // existing socket — preserve gate state
-            )
-            .await
-            {
-                ResubscribeResult::Ok => {}
-                ResubscribeResult::Shutdown => return,
-                ResubscribeResult::RetryConnection => {
-                    warn!("proactive resubscribe had failures — triggering reconnect");
-                    let _ = event_tx.try_send(None);
-                    match try_autonomous_reconnect(
-                        &mut ws,
-                        &mut cmd_rx,
-                        &mut state,
-                        &keys,
-                        &relay_url,
-                        &agent_pubkey_hex,
-                        &event_tx,
-                        &observer_control_tx,
-                        auth_tag.as_ref(),
-                    )
-                    .await
-                    {
-                        ReconnectOutcome::Ok => {
-                            if matches!(
-                                drain_post_reconnect(
-                                    &mut ws,
-                                    &mut cmd_rx,
-                                    &mut state,
-                                    &agent_pubkey_hex
-                                )
-                                .await,
-                                ReconnectOutcome::Shutdown
-                            ) {
-                                return;
-                            }
-                        }
-                        ReconnectOutcome::Shutdown => return,
-                        ReconnectOutcome::Failed => {
-                            if matches!(
-                                wait_for_reconnect(
-                                    &mut ws,
-                                    &mut cmd_rx,
-                                    &mut state,
-                                    &keys,
-                                    &relay_url,
-                                    &agent_pubkey_hex,
-                                    &event_tx,
-                                    &observer_control_tx,
-                                    true,
-                                    auth_tag.as_ref(),
-                                )
-                                .await,
-                                ReconnectOutcome::Shutdown
-                            ) {
-                                return;
-                            }
-                        }
-                    }
-                    ping_sent = false;
-                    last_pong = Instant::now();
-                    connected_since = Instant::now();
-                    stable_logged = false;
-                }
-            }
-        }
-
         // Drain pending subs, one REQ per pacing tick within the relay's
         // admission window.
         let drain_window_open = drain_pacing_next.is_none_or(|t| tokio::time::Instant::now() >= t);
@@ -1982,7 +1907,11 @@ async fn run_background_task(
             }
         }
 
+        let recovery_at = recovery::ready_at(&mut state);
         tokio::select! {
+                   _ = recovery::ready(&event_tx, recovery_at) => {
+                       recovery::recover_one(&mut ws, &mut state, &event_tx, &agent_pubkey_hex).await;
+                   }
                    raw = ws.next() => {
                        // Determine if the socket is lost.
                        let socket_lost = match raw {
@@ -2358,12 +2287,10 @@ async fn handle_ws_message(
                                 // replay starts early enough to re-deliver it.
                                 state.membership_dropped_since =
                                     Some(state.membership_dropped_since.map_or(ts, |d| d.min(ts)));
-                                // Proactively trigger resubscribe without waiting for a disconnect.
-                                state.proactive_resubscribe_needed = true;
                                 warn!(
                                     channel_id = %channel_uuid,
                                     ts,
-                                    "membership notification dropped (backpressure) — proactive resubscribe queued"
+                                    "membership notification dropped (backpressure) — targeted recovery pending"
                                 );
                             }
                             Err(mpsc::error::TrySendError::Closed(_)) => return false,
@@ -2400,12 +2327,10 @@ async fn handle_ws_message(
                                         .entry(channel_id)
                                         .and_modify(|d| *d = (*d).min(ts))
                                         .or_insert(ts);
-                                    // Proactively trigger resubscribe without waiting for a disconnect.
-                                    state.proactive_resubscribe_needed = true;
                                     warn!(
                                         channel_id = %channel_id,
                                         ts,
-                                        "event channel full — dropping event for channel {channel_id} — proactive resubscribe queued"
+                                        "event channel full — dropping event for channel {channel_id} — targeted recovery pending"
                                     );
                                 }
                                 Err(mpsc::error::TrySendError::Closed(_)) => {
@@ -4248,6 +4173,11 @@ async fn wait_for_any_ok(
     }
 }
 
+mod recovery;
+
+#[cfg(test)]
+mod recovery_tests;
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -4775,7 +4705,7 @@ mod tests {
             .expect("signing should succeed")
     }
 
-    async fn test_ws_pair() -> (WsStream, WebSocketStream<tokio::net::TcpStream>) {
+    pub(super) async fn test_ws_pair() -> (WsStream, WebSocketStream<tokio::net::TcpStream>) {
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
             .await
             .expect("bind test websocket");
@@ -4792,7 +4722,7 @@ mod tests {
         (client, server.await.expect("join test websocket server"))
     }
 
-    async fn next_test_frame(
+    pub(super) async fn next_test_frame(
         server: &mut WebSocketStream<tokio::net::TcpStream>,
     ) -> serde_json::Value {
         let message = timeout(Duration::from_secs(1), server.next())
@@ -5035,14 +4965,14 @@ mod tests {
         ));
     }
 
-    fn test_channel_filter() -> ChannelFilter {
+    pub(super) fn test_channel_filter() -> ChannelFilter {
         ChannelFilter {
             kinds: Some(vec![9]),
             require_mention: false,
         }
     }
 
-    fn seed_test_subscription(state: &mut BgState, channel_id: Uuid) {
+    pub(super) fn seed_test_subscription(state: &mut BgState, channel_id: Uuid) {
         apply_command_to_state(
             state,
             RelayCommand::Subscribe {
diff --git a/crates/buzz-acp/src/relay/recovery.rs b/crates/buzz-acp/src/relay/recovery.rs
new file mode 100644
index 00000000000..62da119a4be
--- /dev/null
+++ b/crates/buzz-acp/src/relay/recovery.rs
@@ -0,0 +1,132 @@
+//! Overflow recovery is an attempted replay, not an EOSE/consumer receipt.
+//! Keep the existing IDs and cursor retirement rules; bound when work is sent.
+use super::*;
+
+pub(super) const RECOVERY_INTERVAL: Duration = Duration::from_secs(5);
+
+#[derive(Default)]
+pub(super) struct RecoverySchedule {
+    next_attempt: Option<tokio::time::Instant>,
+    pub(super) last_attempt: HashMap<String, tokio::time::Instant>,
+}
+
+/// Attempt at most one affected subscription, with space for replay to arrive.
+/// Failed writes retain the loss cursor and are paced too. No EOSE is interpreted
+/// as completion: overlapping requests keep their existing stable wire IDs.
+pub(super) async fn recover_one(
+    ws: &mut WsStream,
+    state: &mut BgState,
+    event_tx: &mpsc::Sender<Option<BuzzEvent>>,
+    agent_pubkey_hex: &str,
+) {
+    let now = tokio::time::Instant::now();
+    if event_tx.is_closed()
+        || event_tx.capacity() < event_tx.max_capacity().div_ceil(2)
+        || state.recovery.next_attempt.is_some_and(|next| now < next)
+        || state.check_rate_gate().is_some()
+    {
+        return;
+    }
+
+    let channel = next_channel(state);
+    let Some(channel) = channel else { return };
+    let sub = channel.map_or_else(|| MEMBERSHIP_NOTIF_SUB_ID.to_owned(), channel_sub_id);
+    state.recovery.last_attempt.insert(sub.clone(), now);
+    info!(subscription = sub, "attempting targeted overflow replay");
+
+    if let Some(ch) = channel {
+        if let Some(filter) = state.active_filters.get(&ch).cloned() {
+            let since = state.channel_since(&ch);
+            if send_subscribe(ws, state, ch, agent_pubkey_hex, since, &filter).await {
+                // Baseline retirement point: REQ write, NOT proven delivery.
+                // New overflow after this attempt creates another pending cursor.
+                state.channel_dropped_since.remove(&ch);
+            }
+        }
+    } else {
+        let since = match (state.membership_dropped_since, state.membership_last_seen) {
+            (Some(d), Some(l)) => Some(d.min(l)),
+            (Some(d), None) => Some(d),
+            (None, Some(l)) => Some(l),
+            (None, None) => state.startup_watermark,
+        };
+        if send_membership_subscribe(ws, agent_pubkey_hex, since).await {
+            state.membership_dropped_since = None;
+        }
+    }
+    // Pace from the end of a potentially backpressured write. No catch-up burst.
+    // The existing bounded write timeout and read/ping owner detect socket loss.
+    state.recovery.next_attempt = Some(tokio::time::Instant::now() + RECOVERY_INTERVAL);
+}
+
+/// No timer or capacity waiter when another authority owns all pending loss.
+/// Only actual attempts advance the cooldown; closed gates wake at expiry.
+pub(super) fn ready_at(state: &mut BgState) -> Option<tokio::time::Instant> {
+    next_channel(state)?;
+    Some(
+        state
+            .recovery
+            .next_attempt
+            .unwrap_or_else(tokio::time::Instant::now)
+            .max(
+                state
+                    .check_rate_gate()
+                    .unwrap_or_else(tokio::time::Instant::now),
+            ),
+    )
+}
+
+/// Select-local readiness, not a send or a reservation carried across reads.
+/// The socket task is the sole producer. `select!` drops this future (including
+/// partial permits) BEFORE handling another frame/command, so live try_send
+/// never competes with a recovery reservation. Receives only add capacity.
+/// Keep this future inside select!: awaiting it alone would block the reader;
+/// persisting it across iterations would steal capacity from live delivery.
+pub(super) async fn ready(
+    event_tx: &mpsc::Sender<Option<BuzzEvent>>,
+    at: Option<tokio::time::Instant>,
+) {
+    if let Some(at) = at {
+        if tokio::time::Instant::now() < at {
+            tokio::time::sleep_until(at).await;
+        }
+        // Use the channel's own race-free capacity wake, not periodic samples.
+        // Return ALL permits before recover_one rechecks capacity and intent.
+        if let Ok(permits) = event_tx
+            .reserve_many(event_tx.max_capacity().div_ceil(2))
+            .await
+        {
+            drop(permits);
+            return;
+        }
+    }
+    // No loss or a closed receiver: no immediate-ready/error wake loop.
+    std::future::pending::<()>().await;
+}
+
+fn next_channel(state: &BgState) -> Option<Option<Uuid>> {
+    // One record per active intent, not per loss or per request generation.
+    // Least recently attempted prevents a repeatedly overflowing channel from
+    // starving other channels or membership. Missing filters fail closed.
+    state
+        .channel_dropped_since
+        .keys()
+        .filter(|ch| {
+            state.active_subscriptions.contains_key(ch)
+                && state.active_filters.contains_key(ch)
+                && !state.rate_limited_pending.contains_key(ch)
+                && !state.resubscribe_retry.contains(ch)
+        })
+        .copied()
+        .map(Some)
+        .chain(
+            (state.membership_sub_active
+                && state.membership_dropped_since.is_some()
+                && !state.membership_resub_needed)
+                .then_some(None),
+        )
+        .min_by_key(|ch| {
+            let sub = ch.map_or_else(|| MEMBERSHIP_NOTIF_SUB_ID.to_owned(), channel_sub_id);
+            (state.recovery.last_attempt.get(&sub).copied(), sub)
+        })
+}
diff --git a/crates/buzz-acp/src/relay/recovery_tests.rs b/crates/buzz-acp/src/relay/recovery_tests.rs
new file mode 100644
index 00000000000..4e51a0c6147
--- /dev/null
+++ b/crates/buzz-acp/src/relay/recovery_tests.rs
@@ -0,0 +1,388 @@
+//! Bounded synthetic WebSocket fixtures; no relay service, proxy or real agent.
+use super::tests::{next_test_frame, seed_test_subscription, test_channel_filter, test_ws_pair};
+use super::*;
+
+fn fixture_event(channel: Uuid, n: u64, kind: u16) -> Event {
+    let keys =
+        Keys::parse("0000000000000000000000000000000000000000000000000000000000000001").unwrap();
+    EventBuilder::new(Kind::Custom(kind), format!("synthetic-{n}"))
+        .tags([Tag::parse(["h", &channel.to_string()]).unwrap()])
+        .custom_created_at(nostr::Timestamp::from(1_000 + n))
+        .sign_with_keys(&keys)
+        .unwrap()
+}
+
+async fn dispatch(
+    client: &mut WsStream,
+    state: &mut BgState,
+    tx: &mpsc::Sender<Option<BuzzEvent>>,
+    frame: Value,
+) {
+    let (control_tx, _control_rx) = mpsc::channel(1);
+    assert!(
+        handle_ws_message(
+            Message::Text(frame.to_string().into()),
+            client,
+            tx,
+            &control_tx,
+            state,
+            &Keys::generate(),
+            "ws://127.0.0.1:1",
+            "synthetic-agent",
+            None,
+        )
+        .await
+    );
+}
+
+#[tokio::test]
+async fn repeated_overflow_recovers_only_affected_channel_after_capacity() {
+    let (mut client, mut server) = test_ws_pair().await;
+    let mut state = BgState::new();
+    let channels: Vec<_> = (0..18).map(|_| Uuid::new_v4()).collect();
+    for ch in &channels {
+        seed_test_subscription(&mut state, *ch);
+    }
+    let ch = channels[0];
+    let sub = channel_sub_id(ch);
+    let (tx, mut rx) = mpsc::channel(256);
+    // Relay history is newest-first; the oldest dropped event must survive
+    // a watermark already advanced by much newer successfully-enqueued events.
+    let events: Vec<_> = (0..320).rev().map(|n| fixture_event(ch, n, 9)).collect();
+    for event in &events {
+        dispatch(&mut client, &mut state, &tx, json!(["EVENT", sub, event])).await;
+        recovery::recover_one(&mut client, &mut state, &tx, "synthetic-agent").await;
+    }
+    assert_eq!(rx.len(), 256);
+    assert_eq!(state.channel_dropped_since[&ch], 1_000);
+    assert!(timeout(Duration::from_millis(30), server.next())
+        .await
+        .is_err());
+    for event in &events[..256] {
+        assert_eq!(rx.recv().await.unwrap().unwrap().event.id, event.id);
+    }
+    recovery::recover_one(&mut client, &mut state, &tx, "synthetic-agent").await;
+    let req = next_test_frame(&mut server).await;
+    assert_eq!(req[0], "REQ");
+    assert_eq!(req[1], sub);
+    assert_eq!(req[2]["#h"], json!([ch.to_string()]));
+    assert_eq!(req[2]["kinds"], json!([9]));
+    assert_eq!(req[2]["since"], 995);
+    // Concurrent timer ticks / duplicate arrivals cannot replace the replay.
+    for _ in 0..40 {
+        recovery::recover_one(&mut client, &mut state, &tx, "synthetic-agent").await;
+    }
+    assert!(timeout(Duration::from_millis(30), server.next())
+        .await
+        .is_err());
+    for event in &events {
+        dispatch(&mut client, &mut state, &tx, json!(["EVENT", sub, event])).await;
+    }
+    dispatch(&mut client, &mut state, &tx, json!(["EOSE", sub])).await;
+    assert_eq!(rx.len(), 64, "delivered IDs must remain deduplicated");
+    for event in &events[256..] {
+        assert_eq!(rx.recv().await.unwrap().unwrap().event.id, event.id);
+    }
+    assert_eq!(state.channel_since(&ch), Some(1_319));
+    recovery::recover_one(&mut client, &mut state, &tx, "synthetic-agent").await;
+    assert!(timeout(Duration::from_millis(30), server.next())
+        .await
+        .is_err());
+    let live = fixture_event(ch, 400, 9);
+    dispatch(&mut client, &mut state, &tx, json!(["EVENT", sub, live])).await;
+    assert_eq!(rx.recv().await.unwrap().unwrap().event.id, live.id);
+    println!("18 subscriptions; 320 newest-first arrivals; 64 losses coalesced; 0 REQ while full; 1 targeted REQ; 320 unique deliveries + live");
+}
+
+#[tokio::test]
+async fn socket_owner_services_ping_shutdown_and_coalesces_overflow_ticks() {
+    let (client, mut server) = test_ws_pair().await;
+    let (tx, mut rx) = mpsc::channel(1);
+    let (control_tx, _control_rx) = mpsc::channel(1);
+    let (cmd_tx, cmd_rx) = mpsc::channel(64);
+    let task = tokio::spawn(run_background_task(
+        client,
+        VecDeque::new(),
+        tx,
+        control_tx,
+        cmd_rx,
+        Keys::generate(),
+        "ws://127.0.0.1:1".into(),
+        "synthetic-agent".into(),
+        None,
+    ));
+    let channels: Vec<_> = (0..18).map(|_| Uuid::new_v4()).collect();
+    for ch in &channels {
+        cmd_tx
+            .send(RelayCommand::Subscribe {
+                channel_id: *ch,
+                filter: test_channel_filter(),
+                replay_since: Some(1_000),
+            })
+            .await
+            .unwrap();
+    }
+    let mut subscriptions = 0;
+    while subscriptions < 18 {
+        let frame = timeout(Duration::from_secs(2), server.next())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap();
+        match frame {
+            Message::Text(text) => {
+                let req: Value = serde_json::from_str(&text).unwrap();
+                assert_eq!(req[0], "REQ");
+                server
+                    .send(Message::Text(json!(["EOSE", req[1]]).to_string().into()))
+                    .await
+                    .unwrap();
+                subscriptions += 1;
+            }
+            Message::Ping(payload) => server.send(Message::Pong(payload)).await.unwrap(),
+            other => panic!("unexpected {other:?}"),
+        }
+    }
+    let sub = channel_sub_id(channels[0]);
+    for n in 0..40 {
+        server
+            .send(Message::Text(
+                json!(["EVENT", sub, fixture_event(channels[0], n, 9)])
+                    .to_string()
+                    .into(),
+            ))
+            .await
+            .unwrap();
+    }
+    server.send(Message::Ping(vec![42].into())).await.unwrap();
+    timeout(Duration::from_secs(2), async {
+        loop {
+            match server.next().await.unwrap().unwrap() {
+                Message::Ping(payload) => server.send(Message::Pong(payload)).await.unwrap(),
+                Message::Pong(payload) => {
+                    assert_eq!(payload.as_ref(), &[42]);
+                    break;
+                }
+                other => panic!("no immediate all-channel recovery before ping: {other:?}"),
+            }
+        }
+    })
+    .await
+    .unwrap();
+    // Wait across a recovery tick with the consumer still full.
+    assert!(socket_frame(&mut server, Duration::from_millis(5_100))
+        .await
+        .is_none());
+    rx.recv().await.unwrap().unwrap();
+    let frame = timeout(Duration::from_secs(6), server.next())
+        .await
+        .unwrap()
+        .unwrap()
+        .unwrap();
+    let req: Value = serde_json::from_str(frame.to_text().unwrap()).unwrap();
+    assert_eq!(req[1], sub);
+    assert_eq!(req[2]["since"], 996);
+    assert!(timeout(Duration::from_millis(100), server.next())
+        .await
+        .is_err());
+    // Sustained lag: each replay is followed by another burst, without EOSE.
+    // Recovery must stay paced, not permanently stall or sweep healthy channels.
+    for round in 1..=3 {
+        let started = tokio::time::Instant::now();
+        for n in round * 40..(round + 1) * 40 {
+            server
+                .send(Message::Text(
+                    json!(["EVENT", sub, fixture_event(channels[0], n, 9)])
+                        .to_string()
+                        .into(),
+                ))
+                .await
+                .unwrap();
+        }
+        server.send(Message::Ping(vec![43].into())).await.unwrap();
+        let pong = timeout(Duration::from_secs(1), server.next())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap();
+        assert!(
+            matches!(pong, Message::Pong(_)),
+            "recovery preempted ping: {pong:?}"
+        );
+        rx.recv().await.unwrap().unwrap();
+        let frame = timeout(Duration::from_secs(6), server.next())
+            .await
+            .unwrap()
+            .unwrap()
+            .unwrap();
+        let req: Value = serde_json::from_str(frame.to_text().unwrap()).unwrap();
+        assert_eq!(req[1], sub, "healthy channels must not be swept");
+        assert!(
+            started.elapsed() >= Duration::from_secs(4),
+            "unpaced repeat"
+        );
+    }
+    cmd_tx.send(RelayCommand::Shutdown).await.unwrap();
+    timeout(Duration::from_secs(1), task)
+        .await
+        .unwrap()
+        .unwrap();
+    println!("socket-owner seam: 18 live REQs, 39 coalesced losses, PONG while full, zero recovery across full-capacity timer tick, four paced targeted REQs over sustained lag without EOSE, responsive shutdown");
+}
+
+#[tokio::test]
+async fn recovery_is_fair_and_paced_even_with_new_loss_and_stale_eose() {
+    let (mut client, mut server) = test_ws_pair().await;
+    let mut state = BgState::new();
+    let channels = [Uuid::new_v4(), Uuid::new_v4()];
+    for ch in channels {
+        seed_test_subscription(&mut state, ch);
+        state.channel_dropped_since.insert(ch, 600);
+    }
+    state.membership_sub_active = true;
+    state.membership_dropped_since = Some(500);
+    let (tx, _rx) = mpsc::channel(1);
+    let mut visited = HashSet::new();
+    for round in 0..9 {
+        timeout(
+            Duration::from_millis(100),
+            recovery::ready(&tx, recovery::ready_at(&mut state)),
+        )
+        .await
+        .unwrap();
+        recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+        let req = next_test_frame(&mut server).await;
+        let sub = req[1].as_str().unwrap();
+        if round < 3 {
+            assert!(visited.insert(sub.to_owned()), "starved intent");
+        }
+        if sub == MEMBERSHIP_NOTIF_SUB_ID {
+            assert_eq!(req[2]["since"], 495);
+            state.membership_dropped_since = Some(500);
+        } else {
+            let ch = channel_id_from_sub_id(sub).unwrap();
+            assert_eq!(req[2]["since"], 595);
+            state.channel_dropped_since.insert(ch, 600);
+        }
+        // Neither stale nor current EOSE creates completion state or erases loss.
+        dispatch(&mut client, &mut state, &tx, json!(["EOSE", sub])).await;
+        for _ in 0..30 {
+            recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+        }
+        assert!(timeout(Duration::from_millis(1), server.next())
+            .await
+            .is_err());
+        advance_clock(recovery::RECOVERY_INTERVAL).await;
+    }
+    for ch in channels {
+        state.active_subscriptions.remove(&ch);
+        state.clear_channel_state(&ch);
+        assert!(!state
+            .recovery
+            .last_attempt
+            .contains_key(&channel_sub_id(ch)));
+    }
+    assert_eq!(state.recovery.last_attempt.len(), 1);
+}
+
+#[tokio::test]
+async fn gate_headroom_failed_writes_and_reconnect_preserve_pending_attempts() {
+    let (mut client, mut server) = test_ws_pair().await;
+    let mut state = BgState::new();
+    let ch = Uuid::new_v4();
+    seed_test_subscription(&mut state, ch);
+    state.channel_dropped_since.insert(ch, 700);
+    let (tx, mut rx) = mpsc::channel(4);
+    for _ in 0..3 {
+        tx.try_send(None).unwrap();
+    }
+    recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+    assert!(state.recovery.last_attempt.is_empty());
+    rx.recv().await;
+    state.rate_limit_gate = Some(tokio::time::Instant::now() + Duration::from_secs(10));
+    recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+    assert!(state.recovery.last_attempt.is_empty());
+    advance_clock(Duration::from_secs(10)).await;
+    // Close locally, so the actual production writer fails deterministically.
+    client.close(None).await.unwrap();
+    server.next().await;
+    recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+    assert_eq!(state.channel_dropped_since[&ch], 700);
+    let attempted = state.recovery.last_attempt.clone();
+    for _ in 0..30 {
+        recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+    }
+    assert_eq!(state.recovery.last_attempt, attempted);
+    advance_clock(recovery::RECOVERY_INTERVAL).await;
+    recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+    assert_ne!(
+        state.recovery.last_attempt, attempted,
+        "failed write must be retried"
+    );
+    assert_eq!(state.channel_dropped_since[&ch], 700);
+
+    let (mut client, mut server) = test_ws_pair().await;
+    let (_cmd_tx, mut cmd_rx) = mpsc::channel(1);
+    assert!(matches!(
+        resubscribe_after_reconnect(&mut client, &mut cmd_rx, &mut state, "agent", true,).await,
+        ResubscribeResult::Ok
+    ));
+    let req = next_test_frame(&mut server).await;
+    assert_eq!(req[1], channel_sub_id(ch));
+    assert_eq!(req[2]["since"], 695);
+    assert!(!state.channel_dropped_since.contains_key(&ch));
+    // This is deliberately the baseline write-retirement contract, not a receipt.
+}
+
+async fn advance_clock(duration: Duration) {
+    tokio::time::pause();
+    tokio::time::advance(duration).await;
+    tokio::time::resume();
+}
+
+#[tokio::test]
+async fn blocked_recovery_write_is_bounded_and_retains_loss() {
+    let (mut client, _stalled_server) = test_ws_pair().await;
+    let mut state = BgState::new();
+    let ch = Uuid::new_v4();
+    seed_test_subscription(&mut state, ch);
+    // Bounded 16MB JSON request exceeds loopback TCP buffering. The server does
+    // not read it. This tests the real production write/timeout, not a mock sink.
+    state.active_filters.get_mut(&ch).unwrap().kinds = Some(vec![9; 8_000_000]);
+    state.channel_dropped_since.insert(ch, 700);
+    let (tx, _rx) = mpsc::channel(1);
+    let started = tokio::time::Instant::now();
+    timeout(
+        Duration::from_secs(15),
+        recovery::recover_one(&mut client, &mut state, &tx, "agent"),
+    )
+    .await
+    .unwrap();
+    assert!(started.elapsed() >= Duration::from_secs(WS_SEND_TIMEOUT_SECS));
+    assert_eq!(state.channel_dropped_since[&ch], 700);
+    let attempted = state.recovery.last_attempt.clone();
+    recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+    assert_eq!(state.recovery.last_attempt, attempted);
+}
+
+// Keep the fixture responsive to independent client keepalives while checking
+// recovery traffic. Wall-clock scheduling may deliver the initial ping late.
+async fn socket_frame(
+    server: &mut WebSocketStream<tokio::net::TcpStream>,
+    duration: Duration,
+) -> Option<Message> {
+    let deadline = tokio::time::Instant::now() + duration;
+    loop {
+        match tokio::time::timeout_at(deadline, server.next()).await {
+            Err(_) => return None,
+            Ok(Some(Ok(Message::Ping(payload)))) => {
+                server.send(Message::Pong(payload)).await.unwrap();
+            }
+            Ok(Some(Ok(frame))) => return Some(frame),
+            other => panic!("unexpected socket state: {other:?}"),
+        }
+    }
+}
+
+#[path = "recovery_wake_tests.rs"]
+mod wake;
diff --git a/crates/buzz-acp/src/relay/recovery_wake_tests.rs b/crates/buzz-acp/src/relay/recovery_wake_tests.rs
new file mode 100644
index 00000000000..de27c7d06c9
--- /dev/null
+++ b/crates/buzz-acp/src/relay/recovery_wake_tests.rs
@@ -0,0 +1,507 @@
+//! Capacity-wake boundaries and the independently reproduced R1 schedule.
+use super::*;
+
+// Reviewer-authored, exact-source comparison of recurring headroom at the socket owner.
+// A small periodically refilled queue is empty for most of each five-second period.
+async fn review_count_until(
+    server: &mut WebSocketStream<tokio::net::TcpStream>,
+    deadline: tokio::time::Instant,
+) -> usize {
+    let mut count = 0;
+    while tokio::time::Instant::now() < deadline {
+        let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
+        match socket_frame(server, remaining).await {
+            None => break,
+            Some(Message::Text(text)) => {
+                let frame: Value = serde_json::from_str(&text).unwrap();
+                assert_eq!(frame[0], "REQ");
+                count += 1;
+            }
+            other => panic!("unexpected {other:?}"),
+        }
+    }
+    count
+}
+
+async fn review_barrier(server: &mut WebSocketStream<tokio::net::TcpStream>) -> usize {
+    server.send(Message::Ping(vec![77].into())).await.unwrap();
+    let mut count = 0;
+    loop {
+        match socket_frame(server, Duration::from_secs(2)).await.unwrap() {
+            Message::Pong(payload) => {
+                assert_eq!(payload.as_ref(), &[77]);
+                return count;
+            }
+            Message::Text(text) => {
+                let frame: Value = serde_json::from_str(&text).unwrap();
+                assert_eq!(frame[0], "REQ");
+                count += 1;
+            }
+            other => panic!("unexpected {other:?}"),
+        }
+    }
+}
+
+#[tokio::test]
+async fn review_recurring_headroom_between_ticks_gets_an_attempt() {
+    let (client, mut server) = test_ws_pair().await;
+    let (tx, mut rx) = mpsc::channel(1);
+    let (control_tx, _control_rx) = mpsc::channel(1);
+    let (cmd_tx, cmd_rx) = mpsc::channel(8);
+    let start = tokio::time::Instant::now();
+    let task = tokio::spawn(run_background_task(
+        client,
+        VecDeque::new(),
+        tx,
+        control_tx,
+        cmd_rx,
+        Keys::generate(),
+        "ws://127.0.0.1:1".into(),
+        "agent".into(),
+        None,
+    ));
+    let ch = Uuid::new_v4();
+    let sub = channel_sub_id(ch);
+    cmd_tx
+        .send(RelayCommand::Subscribe {
+            channel_id: ch,
+            filter: test_channel_filter(),
+            replay_since: Some(1000),
+        })
+        .await
+        .unwrap();
+    let frame = socket_frame(&mut server, Duration::from_secs(2))
+        .await
+        .unwrap();
+    let req: Value = serde_json::from_str(frame.to_text().unwrap()).unwrap();
+    assert_eq!(req[1], sub);
+    let lost = fixture_event(ch, 1, 9);
+    for event in [fixture_event(ch, 0, 9), lost.clone()] {
+        server
+            .send(Message::Text(
+                json!(["EVENT", sub, event]).to_string().into(),
+            ))
+            .await
+            .unwrap();
+    }
+    let mut attempts = review_barrier(&mut server).await;
+    assert_eq!(rx.len(), 1);
+    rx.recv().await.unwrap().unwrap();
+    for round in 1..=4 {
+        // Headroom until 1s before the tick; then only one live arrival, no new
+        // overflow. The queue stays full across the tick and drains 0.5s later.
+        attempts += review_count_until(
+            &mut server,
+            start + Duration::from_millis(round * 5000 - 1000),
+        )
+        .await;
+        assert_eq!(rx.len(), 0);
+        server
+            .send(Message::Text(
+                json!(["EVENT", sub, fixture_event(ch, 10 + round, 9)])
+                    .to_string()
+                    .into(),
+            ))
+            .await
+            .unwrap();
+        attempts += review_barrier(&mut server).await;
+        assert_eq!(rx.len(), 1);
+        attempts += review_count_until(
+            &mut server,
+            start + Duration::from_millis(round * 5000 + 500),
+        )
+        .await;
+        rx.recv().await.unwrap().unwrap();
+    }
+    println!("REVIEW periodic consumer: 4 full-at-tick windows, empty >=3.5s each period, recovery_requests={attempts}");
+    assert_eq!(
+        attempts, 1,
+        "recurring headroom must not strand the first attempt"
+    );
+    // Return the missing event using the actual requested stable subscription.
+    server
+        .send(Message::Text(
+            json!(["EVENT", sub, lost]).to_string().into(),
+        ))
+        .await
+        .unwrap();
+    assert_eq!(review_barrier(&mut server).await, 0);
+    assert_eq!(rx.recv().await.unwrap().unwrap().event.id, lost.id);
+    let after = review_count_until(&mut server, start + Duration::from_millis(25_500)).await;
+    assert_eq!(
+        after, 0,
+        "no timer churn or extra requests after successful write"
+    );
+    println!(
+        "REVIEW continuous-headroom control: additional_requests={after}; missing event delivered"
+    );
+    cmd_tx.send(RelayCommand::Shutdown).await.unwrap();
+    timeout(Duration::from_secs(2), task)
+        .await
+        .unwrap()
+        .unwrap();
+}
+
+/// Same real socket owner as production, with no control of its internal state.
+struct Owner {
+    server: WebSocketStream<tokio::net::TcpStream>,
+    rx: mpsc::Receiver<Option<BuzzEvent>>,
+    cmd: mpsc::Sender<RelayCommand>,
+    task: tokio::task::JoinHandle<()>,
+    ch: Uuid,
+}
+
+impl Owner {
+    async fn new(capacity: usize) -> Self {
+        let (client, server) = test_ws_pair().await;
+        let (tx, rx) = mpsc::channel(capacity);
+        let (control_tx, _control_rx) = mpsc::channel(1);
+        let (cmd, cmd_rx) = mpsc::channel(8);
+        let task = tokio::spawn(run_background_task(
+            client,
+            VecDeque::new(),
+            tx,
+            control_tx,
+            cmd_rx,
+            Keys::generate(),
+            "ws://127.0.0.1:1".into(),
+            "agent".into(),
+            None,
+        ));
+        let mut owner = Self {
+            server,
+            rx,
+            cmd,
+            task,
+            ch: Uuid::new_v4(),
+        };
+        owner.subscribe().await;
+        owner
+    }
+
+    async fn subscribe(&mut self) {
+        self.cmd
+            .send(RelayCommand::Subscribe {
+                channel_id: self.ch,
+                filter: test_channel_filter(),
+                replay_since: Some(1000),
+            })
+            .await
+            .unwrap();
+        let req = self.request(Duration::from_secs(2)).await;
+        assert_eq!(req[1], channel_sub_id(self.ch));
+    }
+
+    async fn event(&mut self, n: u64) {
+        self.server
+            .send(Message::Text(
+                json!([
+                    "EVENT",
+                    channel_sub_id(self.ch),
+                    fixture_event(self.ch, n, 9)
+                ])
+                .to_string()
+                .into(),
+            ))
+            .await
+            .unwrap();
+    }
+
+    async fn request(&mut self, duration: Duration) -> Value {
+        let frame = socket_frame(&mut self.server, duration)
+            .await
+            .expect("recovery not woken");
+        let req: Value = serde_json::from_str(frame.to_text().unwrap()).unwrap();
+        assert_eq!(req[0], "REQ");
+        req
+    }
+
+    async fn shutdown(self) {
+        self.cmd.send(RelayCommand::Shutdown).await.unwrap();
+        timeout(Duration::from_secs(1), self.task)
+            .await
+            .unwrap()
+            .unwrap();
+    }
+}
+
+#[tokio::test]
+async fn capacity_flapping_cannot_storm_or_delay_an_allowed_attempt() {
+    let mut owner = Owner::new(1).await;
+    owner.event(0).await;
+    owner.event(1).await;
+    assert_eq!(review_barrier(&mut owner.server).await, 0);
+    owner.rx.recv().await.unwrap();
+    let first = owner.request(Duration::from_millis(500)).await;
+    let first_at = tokio::time::Instant::now();
+    assert_eq!(first[2]["since"], 996);
+    // New loss, then rapid full/empty transitions during the attempt cooldown.
+    // No socket activity or capacity transition may reset or bypass that bound.
+    for n in 1..=20 {
+        owner.event(n * 2).await;
+        owner.event(n * 2 + 1).await;
+        assert_eq!(review_barrier(&mut owner.server).await, 0);
+        owner.rx.recv().await.unwrap();
+        assert!(socket_frame(&mut owner.server, Duration::from_millis(10))
+            .await
+            .is_none());
+    }
+    let req = owner.request(Duration::from_secs(6)).await;
+    assert_eq!(req[1], channel_sub_id(owner.ch));
+    // Arrival timestamps approximate send completion; leave tolerance for TCP.
+    assert!(first_at.elapsed() >= Duration::from_millis(4_900));
+    assert!(first_at.elapsed() < Duration::from_secs(6));
+    assert_eq!(req[2]["since"], 998);
+    assert!(socket_frame(&mut owner.server, Duration::from_millis(100))
+        .await
+        .is_none());
+    owner.shutdown().await;
+}
+
+#[tokio::test]
+async fn partial_capacity_wait_does_not_steal_live_slots_and_cancels_on_unsubscribe() {
+    let mut owner = Owner::new(5).await; // odd capacity: threshold rounds UP to 3
+    for n in 0..6 {
+        owner.event(n).await;
+    }
+    assert_eq!(review_barrier(&mut owner.server).await, 0);
+    owner.rx.recv().await.unwrap(); // partial reservation, insufficient for replay
+    assert!(socket_frame(&mut owner.server, Duration::from_millis(30))
+        .await
+        .is_none());
+    owner.event(6).await;
+    assert_eq!(review_barrier(&mut owner.server).await, 0);
+    assert_eq!(
+        owner.rx.len(),
+        5,
+        "select must release partial permits BEFORE try_send"
+    );
+    for _ in 0..2 {
+        owner.rx.recv().await.unwrap();
+    }
+    assert!(socket_frame(&mut owner.server, Duration::from_millis(30))
+        .await
+        .is_none());
+    owner.rx.recv().await.unwrap(); // exactly three slots free, prompt capacity wake
+    let req = owner.request(Duration::from_millis(500)).await;
+    assert_eq!(req[2]["since"], 1000);
+    assert_eq!(
+        owner
+            .rx
+            .recv()
+            .await
+            .unwrap()
+            .unwrap()
+            .event
+            .created_at
+            .as_secs(),
+        1004
+    );
+    assert_eq!(
+        owner
+            .rx
+            .recv()
+            .await
+            .unwrap()
+            .unwrap()
+            .event
+            .created_at
+            .as_secs(),
+        1006
+    );
+
+    // Wait out cooldown then create another pending loss and partial reservation.
+    tokio::time::sleep(recovery::RECOVERY_INTERVAL).await;
+    for n in 7..13 {
+        owner.event(n).await;
+    }
+    assert_eq!(review_barrier(&mut owner.server).await, 0);
+    owner.rx.recv().await.unwrap();
+    assert!(socket_frame(&mut owner.server, Duration::from_millis(30))
+        .await
+        .is_none());
+    owner
+        .cmd
+        .send(RelayCommand::Unsubscribe {
+            channel_id: owner.ch,
+        })
+        .await
+        .unwrap();
+    let close = socket_frame(&mut owner.server, Duration::from_secs(1))
+        .await
+        .unwrap();
+    let close: Value = serde_json::from_str(close.to_text().unwrap()).unwrap();
+    assert_eq!(close[0], "CLOSE");
+    while owner.rx.try_recv().is_ok() {}
+    assert!(socket_frame(&mut owner.server, Duration::from_millis(100))
+        .await
+        .is_none());
+    owner.subscribe().await;
+    assert!(socket_frame(&mut owner.server, Duration::from_millis(100))
+        .await
+        .is_none());
+    // A re-added intent can record and recover fresh loss immediately.
+    for n in 20..26 {
+        owner.event(n).await;
+    }
+    assert_eq!(review_barrier(&mut owner.server).await, 0);
+    while owner.rx.try_recv().is_ok() {}
+    let req = owner.request(Duration::from_millis(500)).await;
+    assert_eq!(req[2]["since"], 1020);
+    owner.shutdown().await;
+}
+
+#[tokio::test]
+async fn shutdown_and_transport_loss_cancel_a_capacity_wait() {
+    let mut owner = Owner::new(1).await;
+    owner.event(0).await;
+    owner.event(1).await;
+    assert_eq!(review_barrier(&mut owner.server).await, 0);
+    // Full queue cannot block commands or processing an actual socket close.
+    owner.server.close(None).await.unwrap();
+    owner.shutdown().await;
+    let mut owner = Owner::new(1).await;
+    owner.event(0).await;
+    owner.event(1).await;
+    assert_eq!(review_barrier(&mut owner.server).await, 0);
+    owner.shutdown().await;
+}
+
+#[tokio::test]
+async fn readiness_gate_ownership_and_attempt_deadlines_are_not_polling_ticks() {
+    let (mut client, mut server) = test_ws_pair().await;
+    let mut state = BgState::new();
+    let ch = Uuid::new_v4();
+    seed_test_subscription(&mut state, ch);
+    let (tx, mut rx) = mpsc::channel(4);
+    assert!(recovery::ready_at(&mut state).is_none());
+    state.channel_dropped_since.insert(ch, 700);
+    state
+        .rate_limited_pending
+        .insert(ch, tokio::time::Instant::now());
+    assert!(recovery::ready_at(&mut state).is_none());
+    state.rate_limited_pending.clear();
+    state.resubscribe_retry.insert(ch);
+    assert!(recovery::ready_at(&mut state).is_none());
+    state.resubscribe_retry.clear();
+    state.rate_limit_gate = Some(tokio::time::Instant::now() + Duration::from_millis(80));
+    let at = recovery::ready_at(&mut state);
+    assert_eq!(at, state.rate_limit_gate);
+    assert!(timeout(Duration::from_millis(20), recovery::ready(&tx, at))
+        .await
+        .is_err());
+    timeout(Duration::from_millis(200), recovery::ready(&tx, at))
+        .await
+        .unwrap();
+    recovery::recover_one(&mut client, &mut state, &tx, "agent").await;
+    next_test_frame(&mut server).await;
+    state.channel_dropped_since.insert(ch, 800);
+    let at = recovery::ready_at(&mut state).unwrap();
+    let remaining = at.saturating_duration_since(tokio::time::Instant::now());
+    assert!(remaining > Duration::from_millis(4900));
+    // Neither new loss nor an intervening gate shorter than cooldown delays it.
+    state.rate_limit_gate = Some(tokio::time::Instant::now() + Duration::from_millis(10));
+    assert_eq!(recovery::ready_at(&mut state), Some(at));
+    state.rate_limit_gate = Some(at + Duration::from_secs(1));
+    assert_eq!(recovery::ready_at(&mut state), state.rate_limit_gate);
+    advance_clock(Duration::from_secs(6)).await;
+    // Cancellation releases partial permits. No hidden reservation survives it.
+    for _ in 0..3 {
+        tx.try_send(None).unwrap();
+    }
+    assert!(timeout(
+        Duration::from_millis(20),
+        recovery::ready(&tx, recovery::ready_at(&mut state))
+    )
+    .await
+    .is_err());
+    assert_eq!(tx.capacity(), 1);
+    rx.recv().await.unwrap();
+    timeout(
+        Duration::from_millis(100),
+        recovery::ready(&tx, recovery::ready_at(&mut state)),
+    )
+    .await
+    .unwrap();
+    assert_eq!(tx.capacity(), 2);
+    drop(rx);
+    assert!(timeout(
+        Duration::from_millis(20),
+        recovery::ready(&tx, recovery::ready_at(&mut state))
+    )
+    .await
+    .is_err());
+}
+
+#[tokio::test]
+async fn readiness_uses_channel_wakes_without_idle_churn_or_lost_capacity() {
+    use std::future::Future;
+    use std::sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    };
+    use std::task::{Context, Wake, Waker};
+    #[derive(Default)]
+    struct Wakes(AtomicUsize);
+    impl Wake for Wakes {
+        fn wake(self: Arc<Self>) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+        fn wake_by_ref(self: &Arc<Self>) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+    let wakes = Arc::new(Wakes::default());
+    let waker = Waker::from(wakes.clone());
+    let mut cx = Context::from_waker(&waker);
+    let (tx, mut rx) = mpsc::channel(4);
+    for _ in 0..4 {
+        tx.try_send(None).unwrap();
+    }
+    let mut idle = Box::pin(recovery::ready(&tx, None));
+    assert!(idle.as_mut().poll(&mut cx).is_pending());
+    rx.recv().await.unwrap();
+    rx.recv().await.unwrap();
+    assert_eq!(
+        wakes.0.load(Ordering::SeqCst),
+        0,
+        "no loss: no capacity subscription"
+    );
+    drop(idle);
+    // Capacity freed before registration cannot be lost; ready on first poll.
+    let now = Some(tokio::time::Instant::now());
+    let mut ready = Box::pin(recovery::ready(&tx, now));
+    assert!(ready.as_mut().poll(&mut cx).is_ready());
+    assert_eq!(tx.capacity(), 2, "successful readiness returns all permits");
+    drop(ready);
+    for _ in 0..2 {
+        tx.try_send(None).unwrap();
+    }
+    let mut ready = Box::pin(recovery::ready(&tx, now));
+    assert!(ready.as_mut().poll(&mut cx).is_pending());
+    assert_eq!(wakes.0.load(Ordering::SeqCst), 0);
+    rx.recv().await.unwrap();
+    assert_eq!(
+        wakes.0.load(Ordering::SeqCst),
+        0,
+        "below threshold: do not wake"
+    );
+    rx.recv().await.unwrap();
+    assert_eq!(
+        wakes.0.load(Ordering::SeqCst),
+        1,
+        "threshold: channel wakes its waiter"
+    );
+    assert!(ready.as_mut().poll(&mut cx).is_ready());
+    assert_eq!(tx.capacity(), 2);
+    drop(ready);
+    drop(rx);
+    let mut closed = Box::pin(recovery::ready(&tx, now));
+    let before = wakes.0.load(Ordering::SeqCst);
+    assert!(closed.as_mut().poll(&mut cx).is_pending());
+    assert_eq!(
+        wakes.0.load(Ordering::SeqCst),
+        before,
+        "closed: no self-wake loop"
+    );
+}

From 93761e411ced557d859c00df1933ab053d8d854b Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 9 Sep 2026 10:31:42 -0400
Subject: [PATCH 03/19] fix(mobile): render push notification sender identity
 as npub (#7494)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖

## Summary

When an iOS push notification comes from someone the app has no cached
name for, the notification title showed the first characters of the
sender's raw public key — for example `aa4fc866…`. That fragment is
unreadable and doesn't match how the same person appears anywhere else
in Buzz. This PR changes that title to the compact form of the sender's
npub (npub is the human-readable encoding of a Nostr public key): first
8 and last 4 characters — for example `npub14f8…9nsy`, the same identity
shape used across the desktop and mobile apps.

- Unnamed senders: raw hex fragment → compact npub.
- Named senders: unchanged — a sender the app has a display name for
still titles the notification with that name.
- Unverifiable sender identities (malformed keys, or lookalike strings
that are not literal 64-hex-digit keys) now render a neutral "Someone"
instead of partial raw key material.
- Everything else about the notification is unchanged: body text,
subtitle, thread matching and grouping, deep-link navigation, thread
identifiers, and the internal hex public key the resolver matches on.

The native iOS notification-service package (`BuzzPushKit`) gains a
minimal in-house bech32 codec (bech32 is the checksummed string encoding
npubs use) — checksum-validated, 32-byte keys only, and no new external
dependency. The hex input branch accepts exactly a 64 ASCII hex digit
key before any parsing, so strings that merely parse like hex (for
example a run of `+a` pairs) cannot become a displayed identity; this is
input validation for presentation. Event signature verification is
untouched.

### Related issue

Fixes: N/A. Searched existing issues/PRs for push-notification npub
identity — closest related: none found.

### Testing

At head `3e3f2813b8864b76257ccb50dea3a4b31fa4de0d` (base
`44316ff72f5f7de014c66b01cbf534298a70c249`; 4 files, +321/−4):

- CI `Mobile Swift` lane, at this exact head — all passed: `swift test`
(73 tests, 0 failures), the SwiftPM debug and release builds of
`mobile/ios/BuzzPushKit`, and the unsigned iOS release build.
- Test coverage: npub encoding cross-checked against independent
nostr-rs/NIP-19 vectors; rejection of bad checksums, mixed case, wrong
lengths, invalid alphabet, padding, and non-32-byte payloads; resolver
boundary matrix — hex/npub/invalid sender keys render compact npub or
"Someone" while body, subtitle, sender key, and thread identifier pass
through; named senders keep cached display names.

### Task provenance

Buzz channel: `1f0e4a3d-7e01-4efe-bb16-843b357f85c9`

Task:
buzz://message?channel=1f0e4a3d-7e01-4efe-bb16-843b357f85c9&id=86b34eb4bd84a1472419e9af22636c011c0fe273e3c196f967d7a36996e149b6

---------

Signed-off-by: Logan Johnson <loganj@squareup.com>
Co-authored-by: Larry <627498bd4bd1f281a16431e3c6cce3b5c25b6692798c78672298aefbf2f8f8b5@buzz.block.builderlab.xyz>
---
 .../Sources/BuzzPushKit/Bech32.swift          | 179 ++++++++++++++++++
 .../BuzzPushNotificationResolver.swift        |   9 +-
 .../Tests/BuzzPushKitTests/Bech32Tests.swift  |  98 ++++++++++
 .../BuzzPushNotificationResolverTests.swift   |  39 +++-
 4 files changed, 321 insertions(+), 4 deletions(-)
 create mode 100644 mobile/ios/BuzzPushKit/Sources/BuzzPushKit/Bech32.swift
 create mode 100644 mobile/ios/BuzzPushKit/Tests/BuzzPushKitTests/Bech32Tests.swift

diff --git a/mobile/ios/BuzzPushKit/Sources/BuzzPushKit/Bech32.swift b/mobile/ios/BuzzPushKit/Sources/BuzzPushKit/Bech32.swift
new file mode 100644
index 00000000000..e6f31bf8e3e
--- /dev/null
+++ b/mobile/ios/BuzzPushKit/Sources/BuzzPushKit/Bech32.swift
@@ -0,0 +1,179 @@
+import Foundation
+
+/// Minimal bech32 (BIP-173) codec backing NIP-19 npub sender labels.
+///
+/// Only what push notification presentation needs is implemented: encoding
+/// 32-byte public keys as npub and validating npub inputs well enough to
+/// canonicalize them. Segwit addresses and bech32m are out of scope; NIP-19
+/// uses the original bech32 checksum.
+enum Bech32 {
+  /// Bech32 data charset from BIP-173, indexed by 5-bit value.
+  private static let charset: [Character] = Array("qpzry9x8gf2tvdw0s3jn54khce6mua7l")
+  /// Bech32 charset lookup, built once for decoding.
+  private static let valueByCharacter: [Character: UInt8] = Dictionary(
+    uniqueKeysWithValues: charset.enumerated().map { ($1, UInt8($0)) })
+  /// Generator polynomial coefficients from BIP-173.
+  private static let generator: [UInt32] = [
+    0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3,
+  ]
+  /// Checksum length in 5-bit values, from BIP-173.
+  private static let checksumLength = 6
+  /// Maximum bech32 string length, from BIP-173.
+  private static let maximumLength = 90
+
+  // MARK: Codec
+
+  /// Encodes 5-bit values under a human-readable part (hrp), appending the
+  /// bech32 checksum. Returns nil for an invalid hrp or out-of-range values.
+  static func encode(hrp: String, values: [UInt8]) -> String? {
+    let valuesInRange = values.allSatisfy { $0 < 32 }
+    guard isPrintableASCII(hrp), valuesInRange,
+      hrp.count + 1 + values.count + checksumLength <= maximumLength
+    else { return nil }
+    let checksum = checksum(hrp: hrp, values: values)
+    return hrp + "1" + String((values + checksum).map { charset[Int($0)] })
+  }
+
+  /// Decodes a bech32 string into its hrp and 5-bit values, checksum-verified
+  /// and stripped. Follows BIP-173: characters must be printable ASCII, the
+  /// string must be entirely lowercase or entirely uppercase and at most 90
+  /// characters long, and it must end in a valid checksum.
+  static func decode(_ string: String) -> (hrp: String, values: [UInt8])? {
+    guard !string.isEmpty, string.count <= maximumLength, isPrintableASCII(string)
+    else { return nil }
+    let lowercased = string.lowercased()
+    guard lowercased == string || lowercased.uppercased() == string,
+      let separator = lowercased.lastIndex(of: "1"),
+      separator != lowercased.startIndex
+    else { return nil }
+    let hrp = String(lowercased[..<separator])
+    var allValues: [UInt8] = []
+    for character in lowercased[lowercased.index(after: separator)...] {
+      guard let value = valueByCharacter[character] else { return nil }
+      allValues.append(value)
+    }
+    guard allValues.count >= checksumLength,
+      polymod(hrpExpanded(hrp) + allValues.map(UInt32.init)) == 1
+    else { return nil }
+    return (hrp, Array(allValues.dropLast(checksumLength)))
+  }
+
+  // MARK: NIP-19
+
+  /// The npub of a 32-byte public key, or nil for any other length.
+  static func npub(from bytes: [UInt8]) -> String? {
+    guard bytes.count == 32,
+      let values = convertBits(bytes, fromBits: 8, toBits: 5, padding: true)
+    else { return nil }
+    return encode(hrp: "npub", values: values)
+  }
+
+  /// The 32-byte public key encoded by a valid npub, or nil for anything
+  /// else — an `npub1…` prefix alone is never trusted: the bech32 checksum
+  /// must validate and the payload must decode to exactly 32 bytes.
+  static func npubBytes(from string: String) -> [UInt8]? {
+    guard let (hrp, values) = decode(string), hrp == "npub",
+      let bytes = convertBits(values, fromBits: 5, toBits: 8, padding: false),
+      bytes.count == 32
+    else { return nil }
+    return bytes
+  }
+
+  /// The canonical npub for a public key supplied as exactly 64 ASCII hex
+  /// digits or as an existing npub (including the uppercase bech32 form,
+  /// which BIP-173 decoders must accept). Returns nil for anything else;
+  /// callers must fall back to a neutral label rather than raw key material.
+  static func canonicalNpub(from identifier: String) -> String? {
+    if isHexKey(identifier),
+      let bytes = VerifiedNostrEvent.hexBytes(identifier.lowercased()), bytes.count == 32
+    {
+      return npub(from: bytes)
+    }
+    return npubBytes(from: identifier).flatMap { npub(from: $0) }
+  }
+
+  // MARK: Internals
+
+  /// Whether `value` is exactly 64 ASCII hex digits (0-9, A-F, a-f).
+  ///
+  /// `VerifiedNostrEvent.hexBytes` parses pairs with `UInt8(_:radix: 16)`,
+  /// which also accepts a leading sign — "+a" parses as 10 and "-0" as 0 —
+  /// so strings like "+a"×32 would otherwise decode to 32 bytes. The hex
+  /// branch of `canonicalNpub` gates on this literal key shape before any
+  /// hex parsing or allocation; every other input must arrive as a strictly
+  /// checksummed npub.
+  private static func isHexKey(_ value: String) -> Bool {
+    guard value.count == 64 else { return false }
+    return value.allSatisfy { character in
+      guard let ascii = character.asciiValue else { return false }
+      return (48...57).contains(ascii)  // 0-9
+        || (65...70).contains(ascii)  // A-F
+        || (97...102).contains(ascii)  // a-f
+    }
+  }
+
+  private static func isPrintableASCII(_ string: String) -> Bool {
+    !string.isEmpty && string.allSatisfy { (33...126).contains($0.asciiValue ?? 0) }
+  }
+
+  private static func checksum(hrp: String, values: [UInt8]) -> [UInt8] {
+    let expanded =
+      hrpExpanded(hrp) + values.map(UInt32.init)
+      + [UInt32](repeating: 0, count: checksumLength)
+    let polymod = polymod(expanded) ^ 1
+    return (0..<checksumLength).map { index in
+      let shift = 5 * (checksumLength - 1 - index)
+      return UInt8((polymod >> shift) & 31)
+    }
+  }
+
+  private static func polymod(_ values: [UInt32]) -> UInt32 {
+    var accumulator: UInt32 = 1
+    for value in values {
+      let top = accumulator >> 25
+      accumulator = ((accumulator & 0x1ffffff) << 5) ^ value
+      for (index, coefficient) in generator.enumerated() where (top >> index) & 1 == 1 {
+        accumulator ^= coefficient
+      }
+    }
+    return accumulator
+  }
+
+  private static func hrpExpanded(_ hrp: String) -> [UInt32] {
+    let scalars = hrp.unicodeScalars.map { $0.value }
+    return scalars.map { $0 >> 5 } + [0] + scalars.map { $0 & 31 }
+  }
+
+  /// Regroups a byte string between bit widths, as in BIP-173's `convertbits`.
+  /// With padding disabled, a nonzero remainder is rejected instead of padded.
+  private static func convertBits(
+    _ bytes: [UInt8], fromBits: Int, toBits: Int, padding: Bool
+  ) -> [UInt8]? {
+    var accumulator: UInt32 = 0
+    var accumulated = 0
+    var result: [UInt8] = []
+    result.reserveCapacity((bytes.count * fromBits + toBits - 1) / toBits)
+    let maxValue: UInt32 = (1 << toBits) - 1
+    let maxAccumulator: UInt32 = (1 << (fromBits + toBits - 1)) - 1
+    let maxInput: Int = 1 << fromBits
+    for byte in bytes {
+      guard Int(byte) < maxInput else { return nil }
+      accumulator = ((accumulator << fromBits) | UInt32(byte)) & maxAccumulator
+      accumulated += fromBits
+      while accumulated >= toBits {
+        accumulated -= toBits
+        result.append(UInt8((accumulator >> accumulated) & maxValue))
+      }
+    }
+    if padding {
+      if accumulated > 0 {
+        result.append(UInt8((accumulator << (toBits - accumulated)) & maxValue))
+      }
+    } else if accumulated >= fromBits
+      || ((accumulator << (toBits - accumulated)) & maxValue) != 0
+    {
+      return nil
+    }
+    return result
+  }
+}
diff --git a/mobile/ios/BuzzPushKit/Sources/BuzzPushKit/BuzzPushNotificationResolver.swift b/mobile/ios/BuzzPushKit/Sources/BuzzPushKit/BuzzPushNotificationResolver.swift
index 47661e81300..7836385a773 100644
--- a/mobile/ios/BuzzPushKit/Sources/BuzzPushKit/BuzzPushNotificationResolver.swift
+++ b/mobile/ios/BuzzPushKit/Sources/BuzzPushKit/BuzzPushNotificationResolver.swift
@@ -611,8 +611,15 @@ public final class BuzzPushNotificationResolver: BuzzPushNotificationResolving {
       ? String(result.prefix(177)).trimmingCharacters(in: .whitespacesAndNewlines) + "…" : result
   }
 
+  /// Compact sender label for unnamed senders: the first 8 and last 4
+  /// characters of the sender's full npub, matching the compact npub shape
+  /// used across Buzz. A key that cannot be encoded as an npub falls back to
+  /// the neutral "Someone" identity so malformed payloads leak no key
+  /// material while the notification keeps a useful title.
   static func shortPubkey(_ pubkey: String) -> String {
-    pubkey.count > 8 ? String(pubkey.prefix(8)) + "…" : pubkey
+    guard let npub = Bech32.canonicalNpub(from: pubkey) else { return "Someone" }
+    return npub.count > 12
+      ? String(npub.prefix(8)) + "…" + String(npub.suffix(4)) : npub
   }
 
   private func loadCommunities() -> [PushLeaseCommunity] {
diff --git a/mobile/ios/BuzzPushKit/Tests/BuzzPushKitTests/Bech32Tests.swift b/mobile/ios/BuzzPushKit/Tests/BuzzPushKitTests/Bech32Tests.swift
new file mode 100644
index 00000000000..44ad58e0f2b
--- /dev/null
+++ b/mobile/ios/BuzzPushKit/Tests/BuzzPushKitTests/Bech32Tests.swift
@@ -0,0 +1,98 @@
+import XCTest
+@testable import BuzzPushKit
+
+/// Bech32 codec tests against independently published npub vectors — the
+/// NIP-19 spec example key and the nostr crate 0.44 test suite — plus
+/// degenerate key material for the padding and payload-length boundaries.
+/// Generic BIP-173 conformance is not asserted here: nothing outside the
+/// codec calls raw decode, so alphabet, checksum, case, and length
+/// rejection are pinned at canonicalNpub/npubBytes, the npub seam Buzz
+/// actually uses.
+final class Bech32Tests: XCTestCase {
+  /// Hex public keys with their published npub equivalents.
+  static let npubVectors: [(hex: String, npub: String)] = [
+    // nostr-rs 0.44 key test: aa4fc866… ↔ npub14f8usejl…qqh9nsy.
+    (
+      "aa4fc8665f5696e33db7e1a572e3b0f5b3d615837b0f362dcb1c8068b098c7b4",
+      "npub14f8usejl26twx0dhuxjh9cas7keav9vr0v8nvtwtrjqx3vycc76qqh9nsy"
+    ),
+    // The NIP-19 spec's example profile key.
+    (
+      "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+      "npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6"
+    ),
+    // Degenerate key material still encodes (and exercises 5-bit padding).
+    (String(repeating: "00", count: 32), "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzqujme"),
+  ]
+
+  func testNpubEncodingMatchesKnownVectors() throws {
+    for vector in Self.npubVectors {
+      let bytes = try XCTUnwrap(VerifiedNostrEvent.hexBytes(vector.hex))
+      XCTAssertEqual(bytes.count, 32)
+      XCTAssertEqual(Bech32.npub(from: bytes), vector.npub, "hex: \(vector.hex)")
+      XCTAssertEqual(Bech32.canonicalNpub(from: vector.hex), vector.npub, "hex: \(vector.hex)")
+    }
+  }
+
+  func testCanonicalNpubValidatesAndCanonicalizesNpubInputs() throws {
+    for vector in Self.npubVectors {
+      let npub = try XCTUnwrap(Bech32.canonicalNpub(from: vector.npub))
+      XCTAssertEqual(npub, vector.npub, "npub: \(vector.npub)")
+      XCTAssertEqual(
+        Bech32.npubBytes(from: npub).map(VerifiedNostrEvent.hex), vector.hex,
+        "npub: \(vector.npub)")
+    }
+    // Uppercase bech32 is valid per BIP-173; canonical output is lowercase.
+    XCTAssertEqual(
+      Bech32.canonicalNpub(
+        from: "NPUB14F8USEJL26TWX0DHUXJH9CAS7KEAV9VR0V8NVTWTRJQX3VYCC76QQH9NSY"),
+      "npub14f8usejl26twx0dhuxjh9cas7keav9vr0v8nvtwtrjqx3vycc76qqh9nsy")
+    // Letter case within a hex key stays valid input; digits are caseless,
+    // so mixed-case letters still canonicalize to the lowercase npub.
+    let mixedCaseHex = String(
+      Self.npubVectors[0].hex.enumerated().map {
+        $0.offset.isMultiple(of: 2) ? $0.element : Character($0.element.uppercased())
+      })
+    XCTAssertEqual(Bech32.canonicalNpub(from: mixedCaseHex), Self.npubVectors[0].npub)
+  }
+
+  func testCanonicalNpubRejectsInvalidAndLookalikeKeys() {
+    let rejected = [
+      // Junk and empty payloads.
+      "",
+      "author-pubkey",
+      String(repeating: "a", count: 63),
+      "0",
+      // Hex that is not a 32-byte key.
+      String(repeating: "ab", count: 31),
+      String(repeating: "ab", count: 33),
+      // Signed radix-16 chunks ("+a"→10, "-0"→0) parse via UInt8(_:radix:)
+      // but are not literal ASCII hex digits, so never 32-byte keys.
+      String(repeating: "+a", count: 32),
+      String(repeating: "+A", count: 32),
+      String(repeating: "-0", count: 32),
+      // Npub-shaped payload with a character outside the bech32 alphabet
+      // ("b" never appears in the charset).
+      "npub1bqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzqujme",
+      // Valid npub with the checksum's final character mutated.
+      "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzqujma",
+      // Mixed case is never valid bech32.
+      "Npub14f8usejl26twx0dhuxjh9cas7keav9vr0v8nvtwtrjqx3vycc76qqh9nsy",
+      // Valid checksum but the wrong payload length for a key.
+      "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqk7h3rf",
+      "npub1llllllllllllllllllllllllllllllllllllllllllllllllllll7w6tc2n",
+      // Valid bech32 under a different human-readable part.
+      "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqwkhnav",
+    ]
+    for string in rejected {
+      XCTAssertNil(Bech32.canonicalNpub(from: string), "expected rejection: \(string)")
+      XCTAssertNil(Bech32.npubBytes(from: string), "expected rejection: \(string)")
+    }
+  }
+
+  func testNpubRejectsNon32ByteKeys() {
+    XCTAssertNil(Bech32.npub(from: [UInt8](repeating: 0, count: 16)))
+    XCTAssertNil(Bech32.npub(from: [UInt8](repeating: 0xff, count: 33)))
+    XCTAssertNil(Bech32.npub(from: []))
+  }
+}
diff --git a/mobile/ios/BuzzPushKit/Tests/BuzzPushKitTests/BuzzPushNotificationResolverTests.swift b/mobile/ios/BuzzPushKit/Tests/BuzzPushKitTests/BuzzPushNotificationResolverTests.swift
index b25e23595f6..6620f193699 100644
--- a/mobile/ios/BuzzPushKit/Tests/BuzzPushKitTests/BuzzPushNotificationResolverTests.swift
+++ b/mobile/ios/BuzzPushKit/Tests/BuzzPushKitTests/BuzzPushNotificationResolverTests.swift
@@ -18,6 +18,10 @@ final class BuzzPushNotificationResolverTests: XCTestCase {
   static let relayPrivateKey = String(repeating: "0", count: 63) + "3"
   static let gatewayBody = "Reconnect to your relay now"
   static let channelID = "123e4567-e89b-42d3-a456-426614174000"
+  static let unnamedSenderHex =
+    "aa4fc8665f5696e33db7e1a572e3b0f5b3d615837b0f362dcb1c8068b098c7b4"
+  static let unnamedSenderNpub =
+    "npub14f8usejl26twx0dhuxjh9cas7keav9vr0v8nvtwtrjqx3vycc76qqh9nsy"
 
   override func setUp() {
     super.setUp()
@@ -129,6 +133,35 @@ final class BuzzPushNotificationResolverTests: XCTestCase {
     XCTAssertEqual(result?.0.body, "lower ID")
   }
 
+  func testDecodeResolutionSenderTitlesCanonicalizeKeysOrFallBackToNeutral() {
+    // The sender-identity presentation boundary: a verifiable key renders
+    // as the same compact npub whether it arrives as hex or as an npub, and
+    // an unverifiable key — including radix impostors like "+a"×32 that
+    // parse as hex pairs but are not literal hex keys — gets the neutral
+    // identity, never raw key material, while body, subtitle, and internal
+    // payload fields pass through untouched. Malformed-input classification
+    // itself is pinned at the codec (Bech32Tests); named senders winning
+    // over these labels is covered by the cached-profile resolve tests.
+    let senders: [(pubkey: String, title: String)] = [
+      (Self.unnamedSenderHex, "npub14f8…9nsy"),
+      (Self.unnamedSenderNpub, "npub14f8…9nsy"),
+      ("author-pubkey", "Someone"),
+      (String(repeating: "+a", count: 32), "Someone"),
+    ]
+    for sender in senders {
+      let result = BuzzPushNotificationResolver.decodeResolution(
+        events: [event(pubkey: sender.pubkey, content: "Preview")],
+        community: community()
+      )
+
+      XCTAssertEqual(result?.0.title, sender.title, "pubkey: \(sender.pubkey)")
+      XCTAssertEqual(result?.0.body, "Preview", "pubkey: \(sender.pubkey)")
+      XCTAssertEqual(result?.0.subtitle, "Community", "pubkey: \(sender.pubkey)")
+      XCTAssertEqual(result?.0.senderPubkey, sender.pubkey, "pubkey: \(sender.pubkey)")
+      XCTAssertEqual(result?.0.threadIdentifier, "community-id", "pubkey: \(sender.pubkey)")
+    }
+  }
+
   func testResolveSucceedsAndMutatesGatewayContent() throws {
     let event = try JSONDecoder().decode(
       VerifiedNostrEvent.self,
@@ -146,7 +179,7 @@ final class BuzzPushNotificationResolverTests: XCTestCase {
 
     XCTAssertNotEqual(result.title, Self.gatewayBody)
     XCTAssertNotEqual(result.body, Self.gatewayBody)
-    XCTAssertEqual(result.title, String(event.pubkey.prefix(8)) + "…")
+    XCTAssertEqual(result.title, "npub1ccz…mnyd")
     XCTAssertEqual(result.body, "Hello Buzz")
     XCTAssertEqual(result.subtitle, "Community")
     XCTAssertEqual(
@@ -559,7 +592,7 @@ final class BuzzPushNotificationResolverTests: XCTestCase {
       )
     )
 
-    XCTAssertEqual(result.title, String(message.pubkey.prefix(8)) + "…")
+    XCTAssertEqual(result.title, "npub1ccz…mnyd")
     XCTAssertNil(result.conversationDisplayName)
     XCTAssertEqual(result.subtitle, "Community")
     XCTAssertEqual(result.body, "Fallback content")
@@ -602,7 +635,7 @@ final class BuzzPushNotificationResolverTests: XCTestCase {
       )
     )
 
-    XCTAssertEqual(result.title, String(message.pubkey.prefix(8)) + "…")
+    XCTAssertEqual(result.title, "npub1ccz…mnyd")
     XCTAssertNil(result.conversationDisplayName)
     XCTAssertEqual(result.body, "Bounded fallback")
     XCTAssertEqual(URLProtocolStub.requests.count, 2)

From bfc384855889432df4a333a0edf3080f332ee169 Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 9 Sep 2026 10:32:26 -0400
Subject: [PATCH 04/19] fix(desktop): shared npub identity foundation
 (canonicalNpub, PubKey gate, strict parser) (#7488)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖
## Summary

Identity keys in the desktop app are displayed as raw 64-character hex.
A person's key shows up as something like `953d3363…` — unreadable,
impossible to recognize as the same identity on another screen, and a
hazard when copied by hand. Nostr (the protocol Buzz runs on) has a
human-readable spelling for identity keys — the `npub1…` form — but the
desktop app did not use it consistently.

This is the foundation of the desktop npub changes: it adds the shared
pieces every identity surface builds on, and two follow-up slices stack
directly on this branch — #7489 converts the identity controls (profile,
settings, allowlist, workflow key fields) and #7495 converts the
everyday display surfaces (mentions, member lists, sidebar, and other
name fallbacks).

After this change:

- The shared identity widget shows the compact npub form —
`npub1j57...fjmv` — instead of a hex prefix, everywhere it renders (for
example the owned-agent public-key row on a profile). Copying it puts
the full npub on the clipboard.
- Copy is a real interaction, verified end-to-end: both popover variants
put the exact canonical npub on the actual clipboard — never the raw hex
the popover also lists, never a truncation — and a portaled popover's
clicks no longer steal focus from the new-DM To-field mid-copy. Pointer
copy, a natural Space-then-Enter path, and inner/outer Escape are
covered.
- Anything that isn't a valid identity key fails neutrally: short or
corrupt values — including degenerate values that technically encode to
a checksum-valid npub but aren't real identity keys — show "Unavailable"
with no copy button, instead of a misleading value.
- Both valid npub spellings display: all-lowercase `npub1…` and
all-uppercase `NPUB1…` (Bech32, npub's encoding, permits either casing)
both render the same canonical lowercase npub. Mixed case is rejected by
the display path as written — `canonicalNpub` and the widget don't
case-normalize input — while input parsing (`parsePubkeyInput`) keeps
its trim-and-lowercase normalization and accepts mixed-case npubs; both
paths require the decoded payload to be exactly a 64-character identity
key.
- Identity-key input is strict on payload: an npub whose decoded payload
isn't exactly a 64-character identity key is rejected, matching the
validation the app's Rust side already applies to agent allowlists.

Intentional scope boundary: only surfaces that render through the shared
widget change here. Outer profile copy, settings identity cards, the
respond-to allowlist, and workflow key fields still show hex — they move
to npub in the controls follow-up (#7489). Nothing else changes identity
representation: display names, private keys, event IDs, and the hex the
app stores, sends, and matches internally are untouched; only the
user-facing spelling of an identity key changes.

## Details

- `desktop/src/shared/lib/pubkey.ts` — `canonicalNpub()`: strict
canonical full-npub helper (64-char hex in any case, or a
checksum-validated npub, returns the canonical npub; anything else
returns `null`); `truncateNpub()`: the compact display form; existing
exports unchanged.
- `desktop/src/shared/ui/PubKey.tsx` — the shared widget's identity gate
validates through `canonicalNpub`; the popover copies the npub only.
- `desktop/src/shared/lib/nostrUtils.ts` — `parsePubkeyInput` rejects
npubs whose payload is not exactly a 64-character identity key.
- `desktop/src/features/messages/ui/NewMessageScreen.tsx` — the To-field
focuses its search input only for clicks that land inside the field
itself, so portaled recipient popovers keep their focus while open (a
popover click previously dismissed it mid-copy).
- Unit suites cover the helper, widget, and parser (including the
degenerate-encode and uppercase regressions); the e2e specs that render
these rows assert the npub display.

### Related issue

- Fixes: N/A. Searched existing issues/PRs for npub identity display —
no existing match.
- Stack: #7489 is based on this branch and builds on these primitives;
it does not stand alone on main.

### Testing

At head `b3310c248` (base: main `44316ff72`; 12 files, +440/−39):

- Focused unit suites (pubkey, PubKey, parsePubkeyInput): 20/20 green;
mutation-checked — removing the decoded-length predicate fails the
short/empty checksum-valid-npub assertions in `canonicalNpub` and the
widget, and a wrong-identity clipboard value fails the new copy
assertions.
- `pnpm typecheck` and `pnpm check`: pass; full desktop unit suite
6459/6459 at this exact head.
- Targeted e2e at this exact head: 8/8 across the two specs that own the
clipboard flows — `agent-access-warning.spec.ts` (compact variant,
agent-access owner hint) and `pubkey-display-screenshots.spec.ts` (full
variant, new-DM recipient verification: pointer copy, popover surviving
the copy, inner/outer Escape, Space-then-Enter).
- No Rust-side or build files change in this PR, so those results are
unaffected.

### Task provenance

Buzz channel: `1f0e4a3d-7e01-4efe-bb16-843b357f85c9`

Task:
buzz://message?channel=1f0e4a3d-7e01-4efe-bb16-843b357f85c9&id=86b34eb4bd84a1472419e9af22636c011c0fe273e3c196f967d7a36996e149b6

---------

Signed-off-by: Logan Johnson <loganj@squareup.com>
Co-authored-by: Larry <627498bd4bd1f281a16431e3c6cce3b5c25b6692798c78672298aefbf2f8f8b5@buzz.block.builderlab.xyz>
---
 .../features/messages/ui/NewMessageScreen.tsx |  17 ++-
 desktop/src/shared/lib/nostrUtils.ts          |  10 +-
 .../src/shared/lib/parsePubkeyInput.test.mjs  |  17 +++
 desktop/src/shared/lib/pubkey.test.mjs        |  69 +++++++++-
 desktop/src/shared/lib/pubkey.ts              |  62 ++++++++-
 desktop/src/shared/ui/PubKey.test.mjs         | 118 ++++++++++++++++++
 desktop/src/shared/ui/PubKey.tsx              |  81 +++++++-----
 .../tests/e2e/agent-access-warning.spec.ts    |  26 ++++
 desktop/tests/e2e/identity-archive.spec.ts    |   5 +-
 desktop/tests/e2e/mentions.spec.ts            |   5 +-
 desktop/tests/e2e/profile.spec.ts             |   3 +-
 .../e2e/pubkey-display-screenshots.spec.ts    |  66 ++++++++++
 12 files changed, 440 insertions(+), 39 deletions(-)
 create mode 100644 desktop/src/shared/ui/PubKey.test.mjs

diff --git a/desktop/src/features/messages/ui/NewMessageScreen.tsx b/desktop/src/features/messages/ui/NewMessageScreen.tsx
index f7192f6e45c..5c5c527df7c 100644
--- a/desktop/src/features/messages/ui/NewMessageScreen.tsx
+++ b/desktop/src/features/messages/ui/NewMessageScreen.tsx
@@ -328,7 +328,22 @@ export function NewMessageScreen() {
               <div
                 className="group/to-field flex min-h-9 min-w-0 flex-1 cursor-text flex-wrap items-center gap-1.5 py-1"
                 data-testid="new-message-to-field"
-                onClick={() => {
+                onClick={(event) => {
+                  // Portaled popovers (recipient inspection and its nested key
+                  // copy) still bubble through React's tree to this handler,
+                  // but their event targets are not DOM descendants of the
+                  // field. Those clicks belong to the popover's own controls
+                  // — they must not steal focus into the search input (which
+                  // dismisses the popover via focus-outside) or reopen the
+                  // picker. Only clicks physically within the recipient field
+                  // focus its input.
+                  const { currentTarget, target } = event;
+                  if (
+                    !(target instanceof Node) ||
+                    !currentTarget.contains(target)
+                  ) {
+                    return;
+                  }
                   setIsRecipientPickerOpen(true);
                   searchInputRef.current?.focus({ preventScroll: true });
                 }}
diff --git a/desktop/src/shared/lib/nostrUtils.ts b/desktop/src/shared/lib/nostrUtils.ts
index d98c6ee8cfb..9b6fe0fb23d 100644
--- a/desktop/src/shared/lib/nostrUtils.ts
+++ b/desktop/src/shared/lib/nostrUtils.ts
@@ -31,7 +31,13 @@ const HEX_PUBKEY_REGEX = /^[0-9a-f]{64}$/;
  * anything else (does NOT throw — intended for live form validation).
  *
  * The input is trimmed first; surrounding whitespace from copy-paste is
- * tolerated.
+ * tolerated. It is also case-normalized before matching and decoding —
+ * preexisting behavior — so a hex key in any casing resolves, and a
+ * mixed-case npub (invalid Bech32 as written) is accepted via its
+ * lowercased form. The identity payload itself stays strict: it must
+ * decode to exactly a 64-char hex identity key, because `npubEncode` also
+ * encodes degenerate short payloads (even `""`), which are never valid
+ * identities.
  */
 export function parsePubkeyInput(input: string): string | null {
   const trimmed = input.trim().toLowerCase();
@@ -41,7 +47,7 @@ export function parsePubkeyInput(input: string): string | null {
   if (trimmed.startsWith("npub1")) {
     try {
       const decoded = decode(trimmed);
-      if (decoded.type === "npub") {
+      if (decoded.type === "npub" && HEX_PUBKEY_REGEX.test(decoded.data)) {
         return decoded.data;
       }
     } catch {
diff --git a/desktop/src/shared/lib/parsePubkeyInput.test.mjs b/desktop/src/shared/lib/parsePubkeyInput.test.mjs
index f9aa57d87f1..b74331cd984 100644
--- a/desktop/src/shared/lib/parsePubkeyInput.test.mjs
+++ b/desktop/src/shared/lib/parsePubkeyInput.test.mjs
@@ -19,6 +19,16 @@ describe("parsePubkeyInput", () => {
     assert.equal(parsePubkeyInput(NPUB), HEX);
   });
 
+  it("normalizes a mixed-case npub to its canonical hex", () => {
+    // Preexisting behavior: user input is lowercased before decoding, so a
+    // mixed-case npub — invalid Bech32 as written — still resolves to the
+    // identity. canonicalNpub is the strict counterpart (see ../lib/pubkey.ts).
+    assert.equal(
+      parsePubkeyInput(`${NPUB.slice(0, 10)}${NPUB.slice(10).toUpperCase()}`),
+      HEX,
+    );
+  });
+
   it("tolerates surrounding whitespace from copy-paste", () => {
     assert.equal(parsePubkeyInput(`  ${NPUB}\n`), HEX);
     assert.equal(parsePubkeyInput(` ${HEX} `), HEX);
@@ -42,6 +52,13 @@ describe("parsePubkeyInput", () => {
     assert.equal(parsePubkeyInput(`${HEX}0`), null);
   });
 
+  it("rejects degenerate npubs whose payload is not a 64-char identity", () => {
+    // `npubEncode` happily encodes short payloads with valid checksums —
+    // those are not identity keys and must never bind as one.
+    assert.equal(parsePubkeyInput("npub1m6kmamcvty5gd"), null);
+    assert.equal(parsePubkeyInput("npub106246s"), null);
+  });
+
   it("rejects non-hex non-npub input", () => {
     assert.equal(parsePubkeyInput(""), null);
     assert.equal(parsePubkeyInput("alice"), null);
diff --git a/desktop/src/shared/lib/pubkey.test.mjs b/desktop/src/shared/lib/pubkey.test.mjs
index 76d0a29b231..bce5834162d 100644
--- a/desktop/src/shared/lib/pubkey.test.mjs
+++ b/desktop/src/shared/lib/pubkey.test.mjs
@@ -1,10 +1,20 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { normalizePubkey, truncatePubkey } from "./pubkey.ts";
+import {
+  canonicalNpub,
+  normalizePubkey,
+  truncateNpub,
+  truncatePubkey,
+} from "./pubkey.ts";
 
 const PUBKEY =
   "44b8e82baa6e0e254e0208d68f335c283c94e7b78dd1fa10d5a49d3f13dd0435";
+const PUBKEY_NPUB =
+  "npub1gjuws2a2dc8z2nszprtg7v6u9q7ffeah3hgl5yx45jwn7y7aqs6s5e9xj6";
+const HEX = "ea9b4d7a7a78a3e3729e5568b14d764d4962be0e1f20f749bcf8d9dbbf9a9328";
+const HEX_NPUB =
+  "npub1a2d567n60z37xu57245tzntkf4yk90swrus0wjdulrvah0u6jv5qusyp60";
 
 test("truncates to the canonical 8+4 form with unicode ellipsis", () => {
   assert.equal(truncatePubkey(PUBKEY), "44b8e82b…0435");
@@ -18,3 +28,60 @@ test("returns short strings unchanged", () => {
 test("normalizePubkey trims and lowercases", () => {
   assert.equal(normalizePubkey("  ABCDEF  "), "abcdef");
 });
+
+test("truncateNpub compacts the hex pubkey's npub, not its hex form", () => {
+  assert.equal(truncateNpub(PUBKEY), "npub1gju…9xj6");
+  assert.equal(truncateNpub(HEX), "npub1a2d…yp60");
+  assert.equal(truncateNpub(HEX.toUpperCase()), "npub1a2d…yp60");
+});
+
+test("truncateNpub accepts already-npub strings", () => {
+  assert.equal(truncateNpub(PUBKEY_NPUB), "npub1gju…9xj6");
+  assert.equal(truncateNpub(`  ${HEX_NPUB} `), "npub1a2d…yp60");
+  // All-uppercase Bech32 is a valid identity per the parser; render the
+  // canonical form, never the neutral label.
+  assert.equal(truncateNpub(HEX_NPUB.toUpperCase()), "npub1a2d…yp60");
+});
+
+test("truncateNpub renders the neutral label for invalid identities", () => {
+  // Never the raw hex/input fallback: a wrong-length or non-hex string is not
+  // a displayable identity.
+  assert.equal(truncateNpub(""), "Unavailable");
+  assert.equal(truncateNpub("not a pubkey"), "Unavailable");
+  assert.equal(truncateNpub(`${HEX.slice(0, 63)}`), "Unavailable");
+  assert.equal(truncateNpub(`z${HEX.slice(1)}`), "Unavailable");
+  // Corrupted npub checksum is not a valid identity either.
+  assert.equal(truncateNpub(`${HEX_NPUB.slice(0, -1)}q`), "Unavailable");
+  // Other bech32 entities are not pubkeys.
+  assert.equal(
+    truncateNpub(
+      "nsec1vl029mgpspedva04g90vltkh6fvh240zqtv9k0t9af8935ke9laqsnlfe5",
+    ),
+    "Unavailable",
+  );
+});
+
+test("canonicalNpub returns the full npub for valid identities only", () => {
+  assert.equal(canonicalNpub(HEX), HEX_NPUB);
+  assert.equal(canonicalNpub(HEX.toUpperCase()), HEX_NPUB);
+  assert.equal(canonicalNpub(HEX_NPUB), HEX_NPUB);
+  // All-uppercase Bech32 is valid and returns the canonical lowercase npub
+  // (parser agreement); a mixed-case npub is invalid Bech32.
+  assert.equal(canonicalNpub(HEX_NPUB.toUpperCase()), HEX_NPUB);
+  assert.equal(
+    canonicalNpub(
+      `${HEX_NPUB.slice(0, 10)}${HEX_NPUB.slice(10).toUpperCase()}`,
+    ),
+    null,
+  );
+  // Strict identity keys only — short/degenerate payloads never encode.
+  assert.equal(canonicalNpub(""), null);
+  assert.equal(canonicalNpub("deadbeef"), null);
+  assert.equal(canonicalNpub(`${HEX.slice(0, 63)}`), null);
+  // Checksum-valid short npubs are degenerate payloads too (8-char and
+  // empty) — `npubEncode` would happily re-encode them, so never bind them.
+  assert.equal(canonicalNpub("npub1m6kmamcvty5gd"), null);
+  assert.equal(canonicalNpub("npub106246s"), null);
+  // Corrupted checksum never binds as the identity it resembles.
+  assert.equal(canonicalNpub(`${HEX_NPUB.slice(0, -2)}qq`), null);
+});
diff --git a/desktop/src/shared/lib/pubkey.ts b/desktop/src/shared/lib/pubkey.ts
index 6dcc48749a3..199ad52d3c1 100644
--- a/desktop/src/shared/lib/pubkey.ts
+++ b/desktop/src/shared/lib/pubkey.ts
@@ -1,3 +1,7 @@
+import { decode, npubEncode } from "nostr-tools/nip19";
+
+import { safeNpub } from "./nostrUtils";
+
 /**
  * Canonical pubkey normalisation.
  *
@@ -8,14 +12,22 @@ export function normalizePubkey(pubkey: string): string {
   return pubkey.trim().toLowerCase();
 }
 
+/** Neutral identity label for keys that cannot be encoded for display. */
+export const UNAVAILABLE_KEY_LABEL = "Unavailable";
+
+const HEX_64_REGEX = /^[0-9a-f]{64}$/;
+
 /**
- * The ONE canonical compact display form for a pubkey: `abcd1234…wxyz`.
+ * The ONE canonical compact display form for a hex string: `abcd1234…wxyz`.
  *
  * A truncated pubkey is a recognition aid, never an identity proof — vanity
  * grinders forge short prefixes cheaply. Surfaces where the user makes a
  * trust decision must show the full npub (see `<PubKey variant="full">`).
  * Do not hand-roll `pubkey.slice(…)` display forms; `check-pubkey-truncation`
  * fails the build if one sneaks in outside this module.
+ *
+ * Identity (pubkey) surfaces should use `truncateNpub` instead; this hex form
+ * remains canonical for non-identity identifiers — event and blob IDs.
  */
 export function truncatePubkey(pubkey: string): string {
   if (pubkey.length <= 12) {
@@ -23,3 +35,51 @@ export function truncatePubkey(pubkey: string): string {
   }
   return `${pubkey.slice(0, 8)}…${pubkey.slice(-4)}`;
 }
+
+/**
+ * Canonical full npub for an identity key: a 64-char hex pubkey (any
+ * case) or an already-npub string (checksum-validated) returns the
+ * canonical npub; anything else returns null. Strict 64-char identity keys
+ * only — `npubEncode` happily encodes short/degenerate payloads (even `""`),
+ * which are not displayable identities.
+ *
+ * Bech32 casing is strict on the input as written: a lowercase `npub1…`
+ * or an all-uppercase `NPUB1…` (both valid Bech32) returns the canonical
+ * lowercase npub, while a mixed-case npub is invalid Bech32 and returns
+ * null — `decode` enforces the all-lower/all-upper rule. This is
+ * intentionally stricter than the parser (`parsePubkeyInput`), which
+ * normalizes user input before decoding and so also accepts mixed-case
+ * npubs; the two agree that the payload must be a 64-hex identity key and
+ * that both valid casings above are acceptable input.
+ */
+export function canonicalNpub(pubkey: string): string | null {
+  const trimmed = pubkey.trim();
+  if (trimmed.startsWith("npub1") || trimmed.startsWith("NPUB1")) {
+    try {
+      const decoded = decode(trimmed);
+      if (decoded.type !== "npub" || !HEX_64_REGEX.test(decoded.data)) {
+        return null;
+      }
+      return npubEncode(decoded.data);
+    } catch {
+      return null;
+    }
+  }
+  const normalized = normalizePubkey(trimmed);
+  return HEX_64_REGEX.test(normalized) ? safeNpub(normalized) : null;
+}
+
+/**
+ * The ONE canonical compact identity display for a pubkey: `npub1abcd…wxyz`
+ * (first 8 + last 4 of the FULL npub).
+ *
+ * Identity surfaces render this form so a displayed prefix is always npub-
+ * shaped; the underlying hex never leaks as the identity display. A
+ * truncated key is a recognition aid, never an identity proof — trust
+ * decisions use `<PubKey variant="full">` or the full npub directly. Invalid
+ * keys render `UNAVAILABLE_KEY_LABEL`, never raw hex or raw input.
+ */
+export function truncateNpub(pubkey: string): string {
+  const npub = canonicalNpub(pubkey);
+  return npub === null ? UNAVAILABLE_KEY_LABEL : truncatePubkey(npub);
+}
diff --git a/desktop/src/shared/ui/PubKey.test.mjs b/desktop/src/shared/ui/PubKey.test.mjs
new file mode 100644
index 00000000000..08167ae1c47
--- /dev/null
+++ b/desktop/src/shared/ui/PubKey.test.mjs
@@ -0,0 +1,118 @@
+/**
+ * Widget-boundary coverage for the shared <PubKey> identity gate.
+ *
+ * Codec vectors and the exact compact/neutral strings live in
+ * ../lib/pubkey.test.mjs. This suite pins what static rendering shows: the
+ * rendered text per variant, and that an unencodable identity — including
+ * degenerate-length hex and short-payload npubs whose npubEncode outputs
+ * carry valid checksums — renders the neutral label with no copy affordance,
+ * never a fake npub. The clipboard write behind the copy affordance and the
+ * popover the widget opens are real-bridge interactions owned by the E2E
+ * regressions: the full variant's copy is pinned by the new-DM recipient
+ * verification flow (tests/e2e/pubkey-display-screenshots.spec.ts) and the
+ * compact variant's by the agent-access owner hint
+ * (tests/e2e/agent-access-warning.spec.ts); both drive CopyRow through the
+ * mock bridge into the actual browser clipboard.
+ */
+import assert from "node:assert/strict";
+import { after, afterEach, before, test } from "node:test";
+
+import { JSDOM } from "jsdom";
+
+const dom = new JSDOM("<!doctype html><html><body></body></html>", {
+  url: "http://localhost",
+});
+
+before(() => {
+  Object.assign(globalThis, {
+    document: dom.window.document,
+    getComputedStyle: dom.window.getComputedStyle.bind(dom.window),
+    HTMLElement: dom.window.HTMLElement,
+    IS_REACT_ACT_ENVIRONMENT: true,
+    Node: dom.window.Node,
+    ResizeObserver: class {
+      disconnect() {}
+      observe() {}
+      unobserve() {}
+    },
+    window: dom.window,
+  });
+});
+
+afterEach(async () => {
+  const { cleanup } = await import("@testing-library/react");
+  cleanup();
+});
+
+after(() => dom.window.close());
+
+const HEX = "ea9b4d7a7a78a3e3729e5568b14d764d4962be0e1f20f749bcf8d9dbbf9a9328";
+const NPUB = "npub1a2d567n60z37xu57245tzntkf4yk90swrus0wjdulrvah0u6jv5qusyp60";
+const COMPACT_NPUB = "npub1a2d…yp60";
+
+async function renderPubKey(props) {
+  const React = await import("react");
+  const { render, within } = await import("@testing-library/react");
+  const { PubKey } = await import("./PubKey.tsx");
+  const view = render(React.createElement(PubKey, props));
+  // render()'s bound queries search the whole body; scope to this render so
+  // earlier mounts (cleaned up only per test) stay invisible.
+  return { ...within(view.container), container: view.container };
+}
+
+test("compact PubKey renders the truncated npub, never the hex", async () => {
+  const trigger = await renderPubKey({ pubkey: HEX });
+  assert.equal(
+    trigger.getByRole("button", { name: "Show full public key" }).textContent,
+    COMPACT_NPUB,
+  );
+  assert.equal(trigger.queryByText(HEX), null);
+
+  // A parent row that owns the interaction gets the same text, not a button.
+  const text = await renderPubKey({ interactive: false, pubkey: HEX });
+  assert.equal(text.getByText(COMPACT_NPUB).tagName, "SPAN");
+  assert.equal(text.queryByRole("button"), null);
+  assert.equal(text.queryByText(HEX), null);
+
+  // An all-uppercase Bech32 npub is a valid identity (parsePubkeyInput
+  // accepts it); the gate must render its canonical compact form, not the
+  // neutral label.
+  const upper = await renderPubKey({ pubkey: NPUB.toUpperCase() });
+  assert.equal(
+    upper.getByRole("button", { name: "Show full public key" }).textContent,
+    COMPACT_NPUB,
+  );
+  assert.equal(upper.queryByText("Unavailable"), null);
+});
+
+test("full PubKey renders the complete npub with a copy affordance", async () => {
+  const view = await renderPubKey({ pubkey: HEX, variant: "full" });
+  assert.equal(view.getByText(NPUB).textContent, NPUB);
+  assert.equal(
+    view.getByRole("button", { name: "Copy public key" }).tagName,
+    "BUTTON",
+  );
+  assert.equal(view.queryByText(HEX), null);
+});
+
+test("unencodable keys render Unavailable with no copy affordance", async () => {
+  // "zz" cannot decode; "deadbeef" is a degenerate-length hex that npubEncode
+  // would happily turn into a checksum-valid fake npub; npub1m6kmamcvty5gd
+  // and npub106246s decode fine but are checksum-valid short-payload npubs
+  // (8-char and empty identity payloads). All four would masquerade as
+  // displayable identities — the gate refuses every one.
+  for (const pubkey of [
+    "zz",
+    "deadbeef",
+    "npub1m6kmamcvty5gd",
+    "npub106246s",
+  ]) {
+    for (const variant of [undefined, "full"]) {
+      const view = await renderPubKey({ pubkey, variant });
+      const label = `${pubkey} ${variant ?? "compact"}`;
+      assert.equal(view.getByText("Unavailable").tagName, "SPAN", label);
+      assert.equal(view.queryByRole("button"), null, label);
+      assert.equal(view.container.textContent?.includes("npub1"), false, label);
+    }
+  }
+});
diff --git a/desktop/src/shared/ui/PubKey.tsx b/desktop/src/shared/ui/PubKey.tsx
index fb5ac15a441..e8fe0bdead8 100644
--- a/desktop/src/shared/ui/PubKey.tsx
+++ b/desktop/src/shared/ui/PubKey.tsx
@@ -3,8 +3,11 @@ import * as React from "react";
 
 import { copyTextToClipboard } from "@/shared/lib/clipboard";
 import { cn } from "@/shared/lib/cn";
-import { safeNpub } from "@/shared/lib/nostrUtils";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import {
+  canonicalNpub,
+  truncateNpub,
+  UNAVAILABLE_KEY_LABEL,
+} from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import {
   DEFAULT_POPOVER_HOVER_OPEN_DELAY_MS,
@@ -19,12 +22,12 @@ type PubKeyProps = {
   /** 64-char hex pubkey. */
   pubkey: string;
   /**
-   * `compact` — truncated hex, click/tap opens a popover with the full npub,
-   * full hex, and copy buttons. The default for identity display in lists,
-   * cards, and metadata rows.
+   * `compact` — truncated npub (`npub1abcd…wxyz`), click/tap opens a popover
+   * with the full npub and its copy button. The default for identity display
+   * in lists, cards, and metadata rows.
    *
-   * `full` — the complete npub rendered inline with copy buttons. Required on
-   * security-decision surfaces (invite/approve, removal, trust/pairing, new
+   * `full` — the complete npub rendered inline with a copy button. Required
+   * on security-decision surfaces (invite/approve, removal, trust/pairing, new
    * DM, key import): a truncated key is forgeable by vanity grinding, so
    * decisions must be made against the whole key.
    */
@@ -66,12 +69,10 @@ function CopyRow({ label, value }: { label: string; value: string }) {
   );
 }
 
-function PubKeyDetails({ pubkey }: { pubkey: string }) {
-  const npub = safeNpub(pubkey);
+function PubKeyDetails({ npub }: { npub: string }) {
   return (
     <div className="space-y-2">
-      {npub ? <CopyRow label="npub" value={npub} /> : null}
-      <CopyRow label="hex" value={pubkey} />
+      <CopyRow label="npub" value={npub} />
     </div>
   );
 }
@@ -119,29 +120,47 @@ export function PubKey({
 
   React.useEffect(() => clearHoverTimer, [clearHoverTimer]);
 
+  // Strict identity gate: `safeNpub` would happily encode degenerate short
+  // payloads (e.g. an 8-char hex) as a fake npub, so the widget validates
+  // through `canonicalNpub` and renders Unavailable for anything else.
+  const npub = canonicalNpub(pubkey);
+
   if (variant === "full") {
-    const npub = safeNpub(pubkey);
     return (
       <span
         className={cn("inline-flex min-w-0 items-center gap-1", className)}
         data-testid={testId}
       >
-        <span className="break-all font-mono text-xs">{npub ?? pubkey}</span>
-        <Popover>
-          <PopoverTrigger asChild>
-            <Button
-              aria-label="Copy public key"
-              size="icon-xs"
-              type="button"
-              variant="ghost"
-            >
-              <Copy />
-            </Button>
-          </PopoverTrigger>
-          <PopoverContent align="start" className="w-96 max-w-[90vw]">
-            <PubKeyDetails pubkey={pubkey} />
-          </PopoverContent>
-        </Popover>
+        <span className="break-all font-mono text-xs">
+          {npub ?? UNAVAILABLE_KEY_LABEL}
+        </span>
+        {npub ? (
+          <Popover>
+            <PopoverTrigger asChild>
+              <Button
+                aria-label="Copy public key"
+                size="icon-xs"
+                type="button"
+                variant="ghost"
+              >
+                <Copy />
+              </Button>
+            </PopoverTrigger>
+            <PopoverContent align="start" className="w-96 max-w-[90vw]">
+              <PubKeyDetails npub={npub} />
+            </PopoverContent>
+          </Popover>
+        ) : null}
+      </span>
+    );
+  }
+
+  // An unencodable key has no key display to expand: render the neutral
+  // label without a popover or copy affordance.
+  if (npub === null) {
+    return (
+      <span className={cn("font-mono", className)} data-testid={testId}>
+        {UNAVAILABLE_KEY_LABEL}
       </span>
     );
   }
@@ -149,7 +168,7 @@ export function PubKey({
   if (!interactive) {
     return (
       <span className={cn("font-mono", className)} data-testid={testId}>
-        {truncatePubkey(pubkey)}
+        {truncateNpub(pubkey)}
       </span>
     );
   }
@@ -168,7 +187,7 @@ export function PubKey({
           onMouseLeave={handleMouseLeave}
           type="button"
         >
-          {truncatePubkey(pubkey)}
+          {truncateNpub(pubkey)}
         </button>
       </PopoverTrigger>
       <PopoverContent
@@ -178,7 +197,7 @@ export function PubKey({
         onMouseLeave={handleMouseLeave}
         onOpenAutoFocus={(event) => event.preventDefault()}
       >
-        <PubKeyDetails pubkey={pubkey} />
+        <PubKeyDetails npub={npub} />
       </PopoverContent>
     </Popover>
   );
diff --git a/desktop/tests/e2e/agent-access-warning.spec.ts b/desktop/tests/e2e/agent-access-warning.spec.ts
index adb9c6d58ab..55d5c4a0075 100644
--- a/desktop/tests/e2e/agent-access-warning.spec.ts
+++ b/desktop/tests/e2e/agent-access-warning.spec.ts
@@ -1,4 +1,5 @@
 import { expect, test } from "@playwright/test";
+import { npubEncode } from "nostr-tools/nip19";
 
 import { waitForAnimations } from "../helpers/animations";
 import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
@@ -123,6 +124,31 @@ test("open agent access explains the available access before save", async ({
     .getByRole("dialog", { name: "Manage agent access" })
     .screenshot({ path: `${SHOTS}/selected-people-warning.png` });
 
+  // Compact-variant clipboard regression (D1a): the owner hint's compact
+  // PubKey must expand to and copy the viewer's complete canonical npub —
+  // the truncated trigger is only a recognition aid. The real bridge writes
+  // the browser clipboard and the poll reads it back.
+  await page.context().grantPermissions(["clipboard-read", "clipboard-write"]);
+  await page
+    .getByTestId("agent-respond-to")
+    .getByRole("button", { name: "Show full public key" })
+    .click();
+  const copyNpubButton = page.getByRole("button", { name: "Copy npub" });
+  await copyNpubButton.click();
+  await expect
+    .poll(() => page.evaluate(() => navigator.clipboard.readText()))
+    .toBe(npubEncode("deadbeef".repeat(8)));
+  await expect(
+    page.locator("[data-sonner-toast]").filter({ hasText: "npub copied" }),
+  ).toBeVisible();
+  // Dismiss just the key popover: the access dialog stays open for the
+  // remaining mode assertions below.
+  await page.keyboard.press("Escape");
+  await expect(copyNpubButton).toHaveCount(0);
+  await expect(
+    page.getByRole("dialog", { name: "Manage agent access" }),
+  ).toBeVisible();
+
   // Only me shares nothing, so the warning goes away entirely.
   await accessSelect.selectOption("owner-only");
   await expect(warning).toHaveCount(0);
diff --git a/desktop/tests/e2e/identity-archive.spec.ts b/desktop/tests/e2e/identity-archive.spec.ts
index dfbe2ff2690..cb6e83def1b 100644
--- a/desktop/tests/e2e/identity-archive.spec.ts
+++ b/desktop/tests/e2e/identity-archive.spec.ts
@@ -1,4 +1,5 @@
 import { expect, test } from "@playwright/test";
+import { npubEncode } from "nostr-tools/nip19";
 
 import { installMockBridge } from "../helpers/bridge";
 
@@ -33,7 +34,9 @@ async function openAliceProfile(page: import("@playwright/test").Page) {
   await aliceMessage.locator("button", { hasText: "alice" }).first().click();
   const panel = page.getByTestId("user-profile-panel");
   await expect(panel).toBeVisible();
-  await expect(panel).toContainText(ALICE_PUBKEY.slice(0, 8));
+  // The panel's public key row renders through the shared <PubKey> widget,
+  // which displays the canonical npub form — assert the npub prefix.
+  await expect(panel).toContainText(npubEncode(ALICE_PUBKEY).slice(0, 8));
 }
 
 async function openProfileSettingsMenu(page: import("@playwright/test").Page) {
diff --git a/desktop/tests/e2e/mentions.spec.ts b/desktop/tests/e2e/mentions.spec.ts
index 6d9baa1e23b..e9248509fd1 100644
--- a/desktop/tests/e2e/mentions.spec.ts
+++ b/desktop/tests/e2e/mentions.spec.ts
@@ -1,4 +1,5 @@
 import { expect, test } from "@playwright/test";
+import { npubEncode } from "nostr-tools/nip19";
 
 import { waitForAnimations } from "../helpers/animations";
 
@@ -4534,7 +4535,9 @@ test("clicking author name opens user profile panel", async ({ page }) => {
   // Click now opens the full profile panel instead of the popover
   const panel = page.getByTestId("user-profile-panel");
   await expect(panel).toBeVisible();
-  await expect(panel).toContainText("deadbeef");
+  // The panel's public key row renders through the shared <PubKey> widget,
+  // which displays the canonical npub form — assert the npub prefix.
+  await expect(panel).toContainText(npubEncode(MOCK_VIEWER_PUBKEY).slice(0, 8));
 });
 
 test("hovering avatar opens popover, clicking opens profile panel", async ({
diff --git a/desktop/tests/e2e/profile.spec.ts b/desktop/tests/e2e/profile.spec.ts
index 095f0fe401e..e47d75706cb 100644
--- a/desktop/tests/e2e/profile.spec.ts
+++ b/desktop/tests/e2e/profile.spec.ts
@@ -1,4 +1,5 @@
 import { expect, test, type Page } from "@playwright/test";
+import { npubEncode } from "nostr-tools/nip19";
 
 import {
   createMockAgentMemoryListing,
@@ -420,7 +421,7 @@ test("owned agent profile stays in parity between Agents and its DM", async ({
     .getByRole("button", { name: `Open profile for ${agentName}` })
     .click();
   await expect(page.getByTestId("user-profile-public-key")).toContainText(
-    agentPubkey.slice(0, 8),
+    npubEncode(agentPubkey).slice(0, 8),
   );
   const dmSurface = await readOwnedAgentProfileContract(page);
 
diff --git a/desktop/tests/e2e/pubkey-display-screenshots.spec.ts b/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
index 77630467da1..81ff86c3299 100644
--- a/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
+++ b/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
@@ -1,4 +1,5 @@
 import { expect, test } from "@playwright/test";
+import { npubEncode } from "nostr-tools/nip19";
 
 import {
   installMockBridge,
@@ -189,13 +190,68 @@ test("selected new-DM recipient can be verified again through search", async ({
   await charlieNameTrigger.click();
   await expect(charlieKeyPopover).toBeVisible();
   await expect(charliePubkey).toContainText("npub1");
+  // The shared PubKey widget is npub-only — no hex text or hex copy row in
+  // the widget itself. (D1a boundary: the chip's legacy raw-hex popover line
+  // is removed with the chip change in the descendant slice.)
+  await expect(charliePubkey).not.toContainText(TEST_IDENTITIES.charlie.pubkey);
   await expect(charlieKeyPopover).toContainText(TEST_IDENTITIES.charlie.pubkey);
   await waitForAnimations(page);
   await page.getByTestId("new-message-page").screenshot({
     path: `${SHOTS}/new-dm-selected-recipient-key.png`,
   });
+
+  // Full-variant clipboard regression (D1a): the nested copy affordances
+  // must write the recipient's complete canonical npub through the real
+  // bridge — never the legacy raw hex the popover also shows, and never a
+  // truncation. The evidence screenshot above is captured first, so this
+  // interaction leaves it untouched.
+  await page.context().grantPermissions(["clipboard-read", "clipboard-write"]);
+  const copyPublicKeyTrigger = charliePubkey.getByRole("button", {
+    name: "Copy public key",
+  });
+  await copyPublicKeyTrigger.click();
+  const copyNpubButton = page.getByRole("button", { name: "Copy npub" });
+  await copyNpubButton.click();
+  await expect
+    .poll(() => page.evaluate(() => navigator.clipboard.readText()))
+    .toBe(npubEncode(TEST_IDENTITIES.charlie.pubkey));
+  await expect(
+    page.locator("[data-sonner-toast]").filter({ hasText: "npub copied" }),
+  ).toBeVisible();
+  // Copying is not a dismissal: the nested affordance and the inspection
+  // popover it lives in both survive the copy.
+  await expect(copyNpubButton).toBeVisible();
+  await expect(charlieKeyPopover).toBeVisible();
+
+  // The inner Escape closes only the nested key popover — the inspection
+  // stays open.
+  await page.keyboard.press("Escape");
+  await expect(copyNpubButton).toHaveCount(0);
+  await expect(charlieKeyPopover).toBeVisible();
+
+  // Keyboard path: after the inner Escape focus returns naturally to the
+  // full-key trigger; Space reopens the popover, whose auto-focus lands on
+  // Copy npub, and Enter activates it. The sentinel proves this keyboard
+  // copy rewrites the clipboard rather than inheriting the value above.
+  await expect(copyPublicKeyTrigger).toBeFocused();
+  await page.evaluate(() =>
+    navigator.clipboard.writeText("keyboard-copy-sentinel"),
+  );
+  await page.keyboard.press("Space");
+  await expect(copyNpubButton).toBeVisible();
+  await expect(copyNpubButton).toBeFocused();
+  await page.keyboard.press("Enter");
+  await expect
+    .poll(() => page.evaluate(() => navigator.clipboard.readText()))
+    .toBe(npubEncode(TEST_IDENTITIES.charlie.pubkey));
+
+  // Close the reopened nested popover so the inspection popover owns the
+  // final Escape; the recipient itself survives both dismissals.
+  await page.keyboard.press("Escape");
+  await expect(copyNpubButton).toHaveCount(0);
   await page.keyboard.press("Escape");
   await expect(charlieKeyPopover).toHaveCount(0);
+  await expect(charlieChip).toBeVisible();
 
   await search.fill("charlie");
   await expect(charlieResult).toBeVisible();
@@ -226,6 +282,16 @@ test("selected new-DM recipient can be verified again through search", async ({
   await page.getByTestId("new-message-page").screenshot({
     path: `${SHOTS}/new-dm-selected-recipient.png`,
   });
+
+  // The To-field guard ignores popover clicks that bubble into the field;
+  // a click on the label itself — a physical descendant of the field — must
+  // still focus the input and open the recipient picker.
+  await page
+    .getByTestId("new-message-to-field")
+    .getByText("To:", { exact: true })
+    .click();
+  await expect(search).toBeFocused();
+  await expect(page.getByTestId("new-message-recipient-popover")).toBeVisible();
 });
 
 test("member removal confirm shows the full npub inline", async ({ page }) => {

From ad2a84131ee99d087b8dba95cff0f319785209df Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 9 Sep 2026 14:07:24 -0400
Subject: [PATCH 05/19] fix(desktop): npub identity displays for mention,
 member, and workflow surfaces (#7495)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖
## Summary

Every Buzz account is identified by a long public key. Before this
change, when someone had no display name, surfaces fell back to
inconsistent labels — mostly raw hex fragments like `abcd1234…wxyz`,
sometimes a generic role label with no key — so the same person looked
different from surface to surface, and nothing looked like an npub
address. This PR applies the npub identity foundation from #7488 to the
everyday surfaces: a person without a display name now falls back to the
same compact npub everywhere — `npub1xxxx…yyyy`, the human-readable
spelling of their public key (first 8 + last 4 characters of the full
npub) — across messages and mentions, reactions, huddles, member and
participant lists, the sidebar and channel activity, search, projects,
tray, notifications, and workflow surfaces.

- **Mentions and messages**: key-only mention chips render the compact
npub. Pasting a copied mention back still re-binds it byte-exactly to
the identity it declares, for both the new npub chips and legacy
hex-truncated chips copied by older clients — wrong, missing, or
tampered key qualification is rejected instead of silently degrading to
plain text.
- **Reactions and huddles**: huddle reaction events and the huddle
roster/participants render the compact npub for unnamed participants;
workflow reaction triggers describe authors with the same form.
- **Members and sidebar**: channel and community member lists,
add-member results and invites, the members sidebar, the
channel-activity popover, search, projects (assignees/reviewers/PR
panels), the tray menu, and desktop notifications all fall back to the
compact npub; titles and aria labels keep the machine-readable full
labels.
- **Profile labels**: panel/popover display names and owner handles fall
back to the compact npub (never raw hex) when there is no name;
linked-event (nevent) message metadata shows the npub-shaped author
fallback while the event lookup and event IDs are unchanged.
- **Workflows**: author-picker secondary labels, step destination keys,
and trigger-author references render compact npubs; event and blob IDs
keep their existing hex compacts (they are not identities).
- **Avatars stay distinct**: fallback avatars for key-only identities
derive initials from the key's tail, so prefixed role labels like
"Participant npub1…" no longer collapse every unnamed participant onto
the same initials; people with names keep their name initials.

Preserved exactly: display names and distinct avatars, internal hex keys
(storage/API forms unchanged), clipboard identity roundtrips, event/blob
ID compaction, private keys (no nsec path is touched), and nevent link
handling.

Scope: this PR changes what identity labels **display**, not identity
controls — profile/settings copy controls, the respond-to allowlist,
workflow key fields, and agent dialogs are the sibling slice #7489, and
the shared primitives (`canonicalNpub`, `truncateNpub`, the `<PubKey>`
gate, strict input parsing) come from the foundation #7488.

### Related issue

- Fixes: N/A. Searched existing issues/PRs for duplicates — none found;
the related work is the npub identity stack this slice belongs to.
- Base/dependency: stacks on #7488 (foundation) — this PR does not stand
alone on main.
- #7489 is a sibling slice on the same #7488 base
(profile/agent/workflow controls), not a dependency: this PR does not
require #7489, and #7489 does not require this PR — both only require
#7488.

### Testing

At exact head `4763cbeae1dd521309755e6d61f657324cb98667` (base:
`fix/desktop-npub-identity-d1a` @
`5f3a4a8111998c8aa41ad77cf66992bd1c85343c`; 71 files, +656/−189 —
production +277/−136, test support +379/−53):

- At this head: targeted `mentions.spec.ts` (1/1), the e2e build,
typecheck, and biome — green.
- 9 changed/related unit files: 100/100 green; typecheck, e2e build,
biome, and px text/truncation checks clean; huddle-roster focused run
green; channel-activity e2e 11/11; mutation checks confirm the fallback
wiring (removing it collapses shared initials and drops fallback rows).
- Known pre-existing local e2e failures, unchanged by this PR and
reproduced identically at the upstream merge-base: huddle-transcription
voice-menu attribution (25 pass / 1 fail) and the
`workflow-local-controls` 438px caret drift. Not claimed green locally.
- Update at head `236af9e6137386737e84d3a474d6bc808a704c50` (test-only
follow-ups `1143af345` + `236af9e6`): the `workflow-local-controls`
races were fixed in the test drivers, and the 438px diff was shown to be
a stale Darwin snapshot baseline (name-row enable switch already absent
and `message_posted` already MessageSquare at recording commit
`9390e11c9`) and refreshed — the focused screenshot test, including
keyboard/caret assertions, now passes locally (twice). The full spec was
not rerun after the snapshot refresh; the huddle-transcription item
above is unchanged.

Label/copy text changes are asserted by the e2e specs (`mentions`,
`mention-recipients`, `pubkey-display-screenshots`,
`huddle-transcription`, `channel-activity-popover`,
`workflow-local-controls`) rather than new screenshots; the screenshot
spec pins the compact npub text forms.

### Task provenance

Buzz channel: `1f0e4a3d-7e01-4efe-bb16-843b357f85c9`

Task:
buzz://message?channel=1f0e4a3d-7e01-4efe-bb16-843b357f85c9&id=86b34eb4bd84a1472419e9af22636c011c0fe273e3c196f967d7a36996e149b6

---------

Signed-off-by: Logan Johnson <loganj@squareup.com>
Co-authored-by: Larry <627498bd4bd1f281a16431e3c6cce3b5c25b6692798c78672298aefbf2f8f8b5@buzz.block.builderlab.xyz>
---
 desktop/src/app/useTrayMenu.ts                |   4 +-
 .../agents/ui/PersonaShareRecipients.tsx      |   4 +-
 .../src/features/channels/lib/memberUtils.ts  |   4 +-
 .../channels/ui/AddMemberSearchResultRow.tsx  |   6 +-
 .../channels/ui/ChannelMemberInviteCard.tsx   |  10 ++--
 .../features/channels/ui/MembersSidebar.tsx   |   6 +-
 .../channels/ui/MembersSidebarMemberCard.tsx  |   4 +-
 .../channels/ui/useChannelAgentSessions.ts    |   4 +-
 .../community-members/ui/AddMemberDialog.tsx  |   4 +-
 .../ui/CommunityMembersCard.tsx               |   4 +-
 .../ui/CommunityMembersSettingsCard.tsx       |  10 +++-
 .../ui/ConfirmRemoveDialog.tsx                |   4 +-
 .../useCommunityJoinAlerts.test.mjs           |   7 ++-
 .../forum/ui/ForumComposer.lifecycle.test.mjs |   3 +
 .../forum/ui/useForumMentionPreparation.ts    |   4 +-
 .../features/home/ui/RecentNotesSection.tsx   |   5 +-
 .../features/huddle/components/HuddleBar.tsx  |   4 +-
 .../huddle/components/ParticipantList.tsx     |  17 ++++--
 .../features/huddle/lib/huddleChannelName.ts  |   4 +-
 .../messages/lib/formatTimelineMessages.ts    |   4 +-
 .../messages/lib/mentionCandidates.ts         |   4 +-
 .../messages/lib/mentionClipboard.test.mjs    |  34 ++++++++---
 .../features/messages/lib/mentionClipboard.ts |  16 ++++-
 .../features/messages/lib/mentionRanking.ts   |   4 +-
 .../lib/normalizeMentionClipboard.test.mjs    |  12 ++++
 .../messages/lib/threadPanel.test.mjs         |  13 +++-
 .../src/features/messages/lib/threadPanel.ts  |   9 ++-
 .../messages/lib/timelineMentionCopy.test.mjs |  27 +++++----
 .../messages/ui/MentionAutocomplete.tsx       |   4 +-
 .../messages/ui/MessageAgentAddressPrefix.tsx |   4 +-
 .../messages/ui/NewMessageResultRow.tsx       |   4 +-
 .../messages/ui/TypingIndicatorRow.tsx        |   4 +-
 .../messages/ui/useAgentAddressLockPicker.ts  |   6 +-
 .../ui/useMentionSendFlow.test-support.mjs    |   3 +
 .../messages/ui/useMentionSendFlow.ts         |   4 +-
 .../messages/ui/useNewMessageRecipients.ts    |   4 +-
 .../use-feed-desktop-notifications.ts         |   4 +-
 .../features/profile/lib/identity.test.mjs    |  52 +++++++++++++++-
 desktop/src/features/profile/lib/identity.ts  |   8 +--
 .../src/features/profile/ui/ProfileAvatar.tsx |  14 ++++-
 .../features/profile/ui/UserProfilePanel.tsx  |   6 +-
 .../profile/ui/UserProfilePanelUtils.ts       |   8 +--
 .../profile/ui/UserProfilePopover.tsx         |   6 +-
 .../ui/useProfileInteractionActions.ts        |   4 +-
 .../projects/ui/IssueAssigneesRow.tsx         |   8 +--
 .../projects/ui/ProjectDetailFeedPanels.tsx   |   4 +-
 .../ui/ProjectPullRequestInlineComments.tsx   |   4 +-
 .../projects/ui/ProjectPullRequestsPanel.tsx  |   4 +-
 .../projects/ui/PullRequestReviewersRow.tsx   |   8 +--
 .../features/pulse/ui/AgentActivityCard.tsx   |   4 +-
 desktop/src/features/pulse/ui/NoteCard.tsx    |   6 +-
 desktop/src/features/pulse/ui/PulseView.tsx   |   4 +-
 .../src/features/search/ui/TopbarSearch.tsx   |   4 +-
 .../settings/ui/ModerationQueueCard.tsx       |  19 +++---
 .../sidebar/ui/ChannelActivityPopover.tsx     |  22 +++++--
 .../workflows/ui/WorkflowAuthorPicker.tsx     |   4 +-
 .../ui/workflowStepDescription.test.mjs       |  33 +++++++++++
 .../workflows/ui/workflowStepDescription.ts   |  12 +++-
 .../ui/workflowTriggerDescription.test.mjs    |  33 +++++++++++
 .../ui/workflowTriggerDescription.ts          |   8 ++-
 desktop/src/shared/lib/initials.test.mjs      |  43 ++++++++++++++
 desktop/src/shared/lib/initials.ts            |  45 ++++++++++++++
 .../src/shared/lib/mentionDisplay.test.mjs    |  31 ++++++++--
 desktop/src/shared/lib/mentionDisplay.ts      |  33 +++++++++--
 desktop/src/shared/ui/UserAvatar.tsx          |  14 ++++-
 .../ui/markdown/useMessageLinkMetadata.ts     |   4 +-
 .../shared/ui/markdownMentionDisplay.test.mjs |   4 +-
 .../e2e/channel-activity-popover.spec.ts      |  56 ++++++++++++++++++
 desktop/tests/e2e/channels.spec.ts            |  40 ++++++++++++-
 .../tests/e2e/huddle-transcription.spec.ts    |  55 ++++++++++++++++-
 desktop/tests/e2e/mention-recipients.spec.ts  |   8 +--
 desktop/tests/e2e/mentions.spec.ts            |   9 ++-
 .../e2e/pubkey-display-screenshots.spec.ts    |   9 +--
 .../tests/e2e/workflow-local-controls.spec.ts |  20 ++++---
 ...ate-variable-autocomplete-smoke-darwin.png | Bin 104623 -> 103906 bytes
 75 files changed, 716 insertions(+), 198 deletions(-)

diff --git a/desktop/src/app/useTrayMenu.ts b/desktop/src/app/useTrayMenu.ts
index 355c8e5d4f2..04ce9256a30 100644
--- a/desktop/src/app/useTrayMenu.ts
+++ b/desktop/src/app/useTrayMenu.ts
@@ -10,7 +10,7 @@ import {
   useManagedAgentsQuery,
   useRelayAgentsQuery,
 } from "@/features/agents/hooks";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { useNow } from "@/shared/lib/useNow";
 import { formatElapsed } from "@/features/agents/ui/agentSessionUtils";
 import type { Channel } from "@/shared/api/types";
@@ -72,7 +72,7 @@ export function useTrayMenu({
           activityId: `${channelTurn.channelId}:${normalizePubkey(pubkey)}`,
           agentName:
             agentNames.get(normalizePubkey(pubkey)) ??
-            `Agent ${truncatePubkey(pubkey)}`,
+            `Agent ${truncateNpub(pubkey)}`,
           channelId: channelTurn.channelId,
           channelName:
             channelNames.get(channelTurn.channelId) ?? "Unknown channel",
diff --git a/desktop/src/features/agents/ui/PersonaShareRecipients.tsx b/desktop/src/features/agents/ui/PersonaShareRecipients.tsx
index 7db7c32bfa5..89588b57567 100644
--- a/desktop/src/features/agents/ui/PersonaShareRecipients.tsx
+++ b/desktop/src/features/agents/ui/PersonaShareRecipients.tsx
@@ -15,7 +15,7 @@ import { ProfileAvatar } from "@/features/profile/ui/ProfileAvatar";
 import { SelectedRecipientChip } from "@/features/profile/ui/SelectedRecipientChip";
 import { useIdentityQuery } from "@/shared/api/hooks";
 import type { UserSearchResult } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { Popover, PopoverAnchor, PopoverContent } from "@/shared/ui/popover";
 import { Skeleton } from "@/shared/ui/skeleton";
 
@@ -25,7 +25,7 @@ export function formatShareRecipientName(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
diff --git a/desktop/src/features/channels/lib/memberUtils.ts b/desktop/src/features/channels/lib/memberUtils.ts
index d921457e000..10ad4b7ff0a 100644
--- a/desktop/src/features/channels/lib/memberUtils.ts
+++ b/desktop/src/features/channels/lib/memberUtils.ts
@@ -1,5 +1,5 @@
 import type { ChannelMember } from "@/shared/api/types";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 export const roleOrder: Record<ChannelMember["role"], number> = {
   owner: 0,
@@ -17,7 +17,7 @@ export function formatMemberName(
     return "You";
   }
 
-  return member.displayName ?? truncatePubkey(member.pubkey);
+  return member.displayName ?? truncateNpub(member.pubkey);
 }
 
 export function compareMembersByRole(
diff --git a/desktop/src/features/channels/ui/AddMemberSearchResultRow.tsx b/desktop/src/features/channels/ui/AddMemberSearchResultRow.tsx
index 7edeb842c8b..9e7dda9c7fe 100644
--- a/desktop/src/features/channels/ui/AddMemberSearchResultRow.tsx
+++ b/desktop/src/features/channels/ui/AddMemberSearchResultRow.tsx
@@ -3,7 +3,7 @@ import { Bot } from "lucide-react";
 import type { UserSearchResult } from "@/shared/api/types";
 import { Button } from "@/shared/ui/button";
 import { cn } from "@/shared/lib/cn";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
 
 const MEMBER_ROW_INSET_DIVIDER_CLASS =
@@ -13,7 +13,7 @@ export function formatAddCandidateName(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
@@ -67,7 +67,7 @@ export function AddMemberSearchResultRow({
               />
             </div>
             <span className="block truncate font-mono text-2xs text-muted-foreground">
-              {truncatePubkey(user.pubkey)}
+              {truncateNpub(user.pubkey)}
             </span>
             {ownerLabel ? (
               <span className="block truncate text-xs text-muted-foreground">
diff --git a/desktop/src/features/channels/ui/ChannelMemberInviteCard.tsx b/desktop/src/features/channels/ui/ChannelMemberInviteCard.tsx
index 90fb5bfaa9b..335e379ce8e 100644
--- a/desktop/src/features/channels/ui/ChannelMemberInviteCard.tsx
+++ b/desktop/src/features/channels/ui/ChannelMemberInviteCard.tsx
@@ -2,7 +2,7 @@ import { Search, UserPlus, X } from "lucide-react";
 import * as React from "react";
 
 import { parsePubkeyInput } from "@/shared/lib/nostrUtils";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { PubKey } from "@/shared/ui/PubKey";
 import { useIsArchivedPredicate } from "@/features/identity-archive/hooks";
 import { useUserSearchQuery } from "@/features/profile/hooks";
@@ -19,7 +19,7 @@ function formatSearchUserName(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
@@ -270,11 +270,11 @@ export function ChannelMemberInviteCard({
                       <div className="flex min-w-0 items-center gap-2">
                         <UserAvatar
                           avatarUrl={null}
-                          displayName={truncatePubkey(directInvitee.pubkey)}
+                          displayName={truncateNpub(directInvitee.pubkey)}
                           size="xs"
                         />
                         <p className="truncate text-sm font-medium leading-5">
-                          {truncatePubkey(directInvitee.pubkey)}
+                          {truncateNpub(directInvitee.pubkey)}
                         </p>
                         <span className="shrink-0 text-xs text-muted-foreground">
                           by public key
@@ -370,7 +370,7 @@ export function ChannelMemberInviteCard({
         <div className="space-y-1 text-sm text-destructive">
           {submissionErrors.map((error) => (
             <p key={`${error.pubkey}-${error.error}`}>
-              {truncatePubkey(error.pubkey)}: {error.error}
+              {truncateNpub(error.pubkey)}: {error.error}
             </p>
           ))}
         </div>
diff --git a/desktop/src/features/channels/ui/MembersSidebar.tsx b/desktop/src/features/channels/ui/MembersSidebar.tsx
index 1b0b7687c1b..3c9afbfaeca 100644
--- a/desktop/src/features/channels/ui/MembersSidebar.tsx
+++ b/desktop/src/features/channels/ui/MembersSidebar.tsx
@@ -49,7 +49,7 @@ import {
 } from "@/shared/ui/dialog";
 import { useProfilePanel } from "@/shared/context/ProfilePanelContext";
 import { useFeedbackToasts } from "@/shared/hooks/useToastEffect";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import {
   MODAL_SEARCH_INPUT_CLASS,
   MODAL_SEARCH_SHELL_CLASS,
@@ -641,7 +641,7 @@ export function MembersSidebar({
         managedAgentRuntime={managedAgentRuntime}
         member={member}
         memberIsBot={memberIsBot}
-        memberAvatarLabel={member.displayName ?? truncatePubkey(member.pubkey)}
+        memberAvatarLabel={member.displayName ?? truncateNpub(member.pubkey)}
         memberLabel={formatMemberName(member, currentPubkey)}
         moderationState={moderationStateByPubkey.get(
           normalizePubkey(member.pubkey),
@@ -886,7 +886,7 @@ export function MembersSidebar({
               <div className="mt-4 space-y-1 text-sm text-destructive">
                 {inviteSubmissionErrors.map((error) => (
                   <p key={`${error.pubkey}-${error.error}`}>
-                    {truncatePubkey(error.pubkey)}: {error.error}
+                    {truncateNpub(error.pubkey)}: {error.error}
                   </p>
                 ))}
               </div>
diff --git a/desktop/src/features/channels/ui/MembersSidebarMemberCard.tsx b/desktop/src/features/channels/ui/MembersSidebarMemberCard.tsx
index 9f187388645..6cc3da1d9c2 100644
--- a/desktop/src/features/channels/ui/MembersSidebarMemberCard.tsx
+++ b/desktop/src/features/channels/ui/MembersSidebarMemberCard.tsx
@@ -27,7 +27,7 @@ import {
   MANAGED_AGENT_PAIR_ACTION_LABELS,
   type ManagedAgentPairAction,
 } from "@/features/agents/managedAgentRuntimeStatus";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import type {
   ChannelMember,
   ManagedAgent,
@@ -195,7 +195,7 @@ export function MembersSidebarMemberCard({
               </div>
               <span className="absolute inset-0 flex items-center opacity-0 transition-opacity duration-150 ease-out group-hover/member:opacity-100 group-focus-within/member:opacity-100">
                 <span className="truncate font-mono text-sm text-muted-foreground">
-                  {truncatePubkey(member.pubkey)}
+                  {truncateNpub(member.pubkey)}
                 </span>
               </span>
             </div>
diff --git a/desktop/src/features/channels/ui/useChannelAgentSessions.ts b/desktop/src/features/channels/ui/useChannelAgentSessions.ts
index e12c1bc7768..d5cd1824e0d 100644
--- a/desktop/src/features/channels/ui/useChannelAgentSessions.ts
+++ b/desktop/src/features/channels/ui/useChannelAgentSessions.ts
@@ -8,7 +8,7 @@ import type {
   RelayAgent,
 } from "@/shared/api/types";
 import { usePanelReturnTarget } from "@/shared/hooks/usePanelReturnTarget";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import {
   channelBotMemberPubkeySet,
   channelMemberPubkeySet,
@@ -100,7 +100,7 @@ export function buildChannelAgentSessionCandidates({
 
     byPubkey.set(key, {
       pubkey: member.pubkey,
-      name: member.displayName ?? truncatePubkey(member.pubkey),
+      name: member.displayName ?? truncateNpub(member.pubkey),
       status: "deployed",
       agentSource: "member-bot",
       canInterruptTurn: false,
diff --git a/desktop/src/features/community-members/ui/AddMemberDialog.tsx b/desktop/src/features/community-members/ui/AddMemberDialog.tsx
index 5464111752f..c2a26b5df3b 100644
--- a/desktop/src/features/community-members/ui/AddMemberDialog.tsx
+++ b/desktop/src/features/community-members/ui/AddMemberDialog.tsx
@@ -13,7 +13,7 @@ import { ProfileAvatar } from "@/features/profile/ui/ProfileAvatar";
 import { SelectedRecipientChip } from "@/features/profile/ui/SelectedRecipientChip";
 import type { RelayMemberRole, UserSearchResult } from "@/shared/api/types";
 import { parsePubkeyInput } from "@/shared/lib/nostrUtils";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import {
   Dialog,
@@ -50,7 +50,7 @@ function formatSearchUserName(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
diff --git a/desktop/src/features/community-members/ui/CommunityMembersCard.tsx b/desktop/src/features/community-members/ui/CommunityMembersCard.tsx
index fdc75f3d183..7693212711b 100644
--- a/desktop/src/features/community-members/ui/CommunityMembersCard.tsx
+++ b/desktop/src/features/community-members/ui/CommunityMembersCard.tsx
@@ -3,7 +3,7 @@ import { MoreHorizontal, Plus, Shield, ShieldCheck, User } from "lucide-react";
 import { toast } from "sonner";
 
 import { useUsersBatchQuery } from "@/features/profile/hooks";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { PubKey } from "@/shared/ui/PubKey";
 import {
   useChangeRelayMemberRoleMutation,
@@ -101,7 +101,7 @@ function MemberRow({
         <div className="min-w-0">
           <div className="flex items-center gap-2">
             <span className="truncate text-sm font-medium">
-              {displayName || truncatePubkey(member.pubkey)}
+              {displayName || truncateNpub(member.pubkey)}
             </span>
             <RoleBadge role={member.role} />
             {isSelf ? (
diff --git a/desktop/src/features/community-members/ui/CommunityMembersSettingsCard.tsx b/desktop/src/features/community-members/ui/CommunityMembersSettingsCard.tsx
index 29338ff5672..dad1f7ff6bc 100644
--- a/desktop/src/features/community-members/ui/CommunityMembersSettingsCard.tsx
+++ b/desktop/src/features/community-members/ui/CommunityMembersSettingsCard.tsx
@@ -19,7 +19,11 @@ import type {
   RelayMemberRole,
   UserProfileSummary,
 } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import {
+  normalizePubkey,
+  truncateNpub,
+  UNAVAILABLE_KEY_LABEL,
+} from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import {
   DropdownMenu,
@@ -65,7 +69,7 @@ function HoverMemberIdentity({
   displayName: string;
   pubkey: string;
 }) {
-  const npub = npubFromPubkey(pubkey) ?? pubkey;
+  const npub = npubFromPubkey(pubkey) ?? UNAVAILABLE_KEY_LABEL;
   return (
     <span className="inline-grid min-w-0 max-w-full grid-cols-1" title={npub}>
       <span
@@ -78,7 +82,7 @@ function HoverMemberIdentity({
         className="col-start-1 row-start-1 max-w-0 truncate font-mono text-2xs opacity-0 blur-0 transition-[max-width,opacity,filter] duration-[250ms] ease-in-out group-hover/member:max-w-40 group-hover/member:opacity-100 group-hover/member:blur-0 group-focus-within/member:max-w-40 group-focus-within/member:opacity-100 group-focus-within/member:blur-0 motion-reduce:transition-none"
         data-testid={`relay-member-npub-${pubkey}`}
       >
-        {truncatePubkey(npub)}
+        {truncateNpub(npub)}
       </span>
     </span>
   );
diff --git a/desktop/src/features/community-members/ui/ConfirmRemoveDialog.tsx b/desktop/src/features/community-members/ui/ConfirmRemoveDialog.tsx
index 64735a5d567..087ef952fff 100644
--- a/desktop/src/features/community-members/ui/ConfirmRemoveDialog.tsx
+++ b/desktop/src/features/community-members/ui/ConfirmRemoveDialog.tsx
@@ -1,6 +1,6 @@
 import { toast } from "sonner";
 
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { PubKey } from "@/shared/ui/PubKey";
 import { useRemoveRelayMemberMutation } from "@/features/community-members/hooks";
 import type { RelayMember } from "@/shared/api/types";
@@ -25,7 +25,7 @@ export function ConfirmRemoveDialog({
   onOpenChange: (open: boolean) => void;
 }) {
   const removeMutation = useRemoveRelayMemberMutation();
-  const label = displayName || (member ? truncatePubkey(member.pubkey) : "");
+  const label = displayName || (member ? truncateNpub(member.pubkey) : "");
 
   function handleOpenChange(next: boolean) {
     if (!next) {
diff --git a/desktop/src/features/community-members/useCommunityJoinAlerts.test.mjs b/desktop/src/features/community-members/useCommunityJoinAlerts.test.mjs
index 7b34b901619..52d7a0a114d 100644
--- a/desktop/src/features/community-members/useCommunityJoinAlerts.test.mjs
+++ b/desktop/src/features/community-members/useCommunityJoinAlerts.test.mjs
@@ -250,6 +250,7 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 
 import { useCommunityJoinAlerts } from "@/features/community-members/useCommunityJoinAlerts.ts";
 import { joinAlertStorageKey } from "@/features/community-members/lib/joinAlerts.ts";
+import { truncateNpub } from "@/shared/lib/pubkey.ts";
 import { relayClient } from "@/shared/api/relayClient.ts";
 import { CommunitiesProvider } from "@/features/communities/useCommunities.tsx";
 import { useCommunities } from "@/features/communities/useCommunities.tsx";
@@ -1715,7 +1716,7 @@ describe("useCommunityJoinAlerts — mounted subscription behaviour", () => {
       "a frame that predates the demotion must not re-open disclosure",
     );
     assert.ok(
-      !notifications.some((entry) => entry.body?.includes(BOB.slice(0, 8))),
+      !notifications.some((entry) => entry.body?.includes(truncateNpub(BOB))),
       "the demoted viewer must never learn the new member's identity",
     );
     assert.equal(
@@ -1982,11 +1983,11 @@ describe("useCommunityJoinAlerts — mounted subscription behaviour", () => {
       "a community switch clears the latch: the feature recovers without a reload",
     );
     assert.ok(
-      notifications.some((entry) => entry.body?.includes(BOB.slice(0, 8))),
+      notifications.some((entry) => entry.body?.includes(truncateNpub(BOB))),
       "the join suppressed by the latch is re-announced, not lost",
     );
     assert.ok(
-      notifications.some((entry) => entry.body?.includes(CAROL.slice(0, 8))),
+      notifications.some((entry) => entry.body?.includes(truncateNpub(CAROL))),
       "and the new join lands too",
     );
 
diff --git a/desktop/src/features/forum/ui/ForumComposer.lifecycle.test.mjs b/desktop/src/features/forum/ui/ForumComposer.lifecycle.test.mjs
index 65e2912ce70..e827635d145 100644
--- a/desktop/src/features/forum/ui/ForumComposer.lifecycle.test.mjs
+++ b/desktop/src/features/forum/ui/ForumComposer.lifecycle.test.mjs
@@ -86,6 +86,9 @@ async function setup(options = {}) {
     "@/shared/lib/pubkey": {
       normalizePubkey: (s) => s.toLowerCase(),
       truncatePubkey: (s) => s,
+      // Compact-identity seam stubbed alongside its sibling: this suite
+      // renders display names, never key-form labels.
+      truncateNpub: (s) => s,
     },
     "@/features/channels/hooks": {
       useAddChannelMembersMutation: () => ({
diff --git a/desktop/src/features/forum/ui/useForumMentionPreparation.ts b/desktop/src/features/forum/ui/useForumMentionPreparation.ts
index 09a7392a829..3289a5e8068 100644
--- a/desktop/src/features/forum/ui/useForumMentionPreparation.ts
+++ b/desktop/src/features/forum/ui/useForumMentionPreparation.ts
@@ -4,7 +4,7 @@ import { PRIVATE_CHANNEL_ADD_DENIED_MESSAGE } from "@/features/channels/lib/chan
 import { useCanAddChannelMembers } from "@/features/channels/useCanAddChannelMembers";
 import type { UseMentionsResult } from "@/features/messages/lib/useMentions";
 import type { ChannelType } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 
 type PendingInvite = {
   channelId: string;
@@ -176,7 +176,7 @@ export function useForumMentionPreparation(
       isInvitePending: isInviting,
       names: (pending?.nonMemberPubkeys ?? []).map(
         (pubkey) =>
-          mentions.getMentionDisplayName(pubkey) ?? truncatePubkey(pubkey),
+          mentions.getMentionDisplayName(pubkey) ?? truncateNpub(pubkey),
       ),
       onDismiss: dismiss,
       onInvite: () => void invite(),
diff --git a/desktop/src/features/home/ui/RecentNotesSection.tsx b/desktop/src/features/home/ui/RecentNotesSection.tsx
index e0837b219df..3bff5c015a7 100644
--- a/desktop/src/features/home/ui/RecentNotesSection.tsx
+++ b/desktop/src/features/home/ui/RecentNotesSection.tsx
@@ -4,7 +4,7 @@ import type { UserNote } from "@/shared/api/socialTypes";
 import type { UserProfileSummary } from "@/shared/api/types";
 import { Markdown } from "@/shared/ui/markdown";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 type RecentNotesSectionProps = {
   notes: UserNote[];
@@ -52,8 +52,7 @@ export function RecentNotesSection({
       <div className="space-y-0 overflow-hidden rounded-md border border-border/60">
         {notes.slice(0, 5).map((note) => {
           const profile = profiles[note.pubkey.toLowerCase()];
-          const displayName =
-            profile?.displayName ?? truncatePubkey(note.pubkey);
+          const displayName = profile?.displayName ?? truncateNpub(note.pubkey);
           const isAgent = agentPubkeys.has(note.pubkey);
 
           return (
diff --git a/desktop/src/features/huddle/components/HuddleBar.tsx b/desktop/src/features/huddle/components/HuddleBar.tsx
index d5a0423cf7c..4c01ca68a15 100644
--- a/desktop/src/features/huddle/components/HuddleBar.tsx
+++ b/desktop/src/features/huddle/components/HuddleBar.tsx
@@ -33,7 +33,7 @@ import { AddAgentDialog, type AgentAddResult } from "./AddAgentDialog";
 import type { HuddleAgentVoiceSettings } from "./AgentVoiceMenu";
 import { MicControls, SpeakerControls } from "./MicControls";
 import { HuddleParticipantsControl } from "./ParticipantList";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 // Mirrors HuddleState in src-tauri/src/huddle/mod.rs.
 type HuddleState = {
@@ -98,7 +98,7 @@ function clampReactionName(name: string): string {
 }
 
 function fallbackNameForPubkey(pubkey?: string | null): string {
-  return pubkey ? `Participant ${truncatePubkey(pubkey)}` : "Someone";
+  return pubkey ? `Participant ${truncateNpub(pubkey)}` : "Someone";
 }
 
 function parseHuddleReactionEvent(event: RelayEvent) {
diff --git a/desktop/src/features/huddle/components/ParticipantList.tsx b/desktop/src/features/huddle/components/ParticipantList.tsx
index 04b6a7453bf..b7d8d5888e9 100644
--- a/desktop/src/features/huddle/components/ParticipantList.tsx
+++ b/desktop/src/features/huddle/components/ParticipantList.tsx
@@ -11,7 +11,7 @@ import { UserProfilePopover } from "@/features/profile/ui/UserProfilePopover";
 import type { VoiceRegistryEntry } from "@/features/settings/ui/voiceSettingsLogic";
 import { invokeTauri } from "@/shared/api/tauri";
 import { cn } from "@/shared/lib/cn";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import { Popover, PopoverContent, PopoverTrigger } from "@/shared/ui/popover";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
@@ -49,6 +49,13 @@ const MAX_VISIBLE_PARTICIPANTS = 9;
 type ParticipantIdentity = {
   avatarUrl: string | null;
   displayName: string;
+  /**
+   * Label the avatar derives initials from: the authored name when one
+   * exists, otherwise the unprefixed compact key. `displayName` is the
+   * visible "Participant npub1…" fallback, whose word initials would
+   * collapse every unnamed participant onto "PN"/"AN".
+   */
+  initialsLabel: string;
   isActive: boolean;
   isAgent: boolean;
   pubkey: string;
@@ -110,10 +117,10 @@ function buildParticipantIdentities({
     const profile = profiles[normalizedPubkey];
     const isAgent = agentSet.has(normalizedPubkey);
     const agent = agentNames.get(normalizedPubkey);
+    const authoredName = profile?.displayName?.trim() || agent?.name?.trim();
+    const keyLabel = truncateNpub(pubkey);
     const displayName =
-      profile?.displayName?.trim() ||
-      agent?.name?.trim() ||
-      `${isAgent ? "Agent" : "Participant"} ${truncatePubkey(pubkey)}`;
+      authoredName || `${isAgent ? "Agent" : "Participant"} ${keyLabel}`;
     const speakerLevel =
       normalizedSpeakerLevels.get(normalizedPubkey) ??
       (activeSpeakerSet.has(normalizedPubkey) ? 0.55 : 0);
@@ -121,6 +128,7 @@ function buildParticipantIdentities({
     return {
       avatarUrl: profile?.avatarUrl ?? agent?.avatarUrl ?? null,
       displayName,
+      initialsLabel: authoredName || keyLabel,
       isActive: activeSpeakerSet.has(normalizedPubkey) || speakerLevel > 0.04,
       isAgent,
       pubkey,
@@ -453,6 +461,7 @@ function ParticipantAvatar({
       <ProfileAvatar
         avatarUrl={participant.avatarUrl}
         label={participant.displayName}
+        initialsLabel={participant.initialsLabel}
         className="h-full w-full border-2 border-black text-2xs"
         shape={participant.isAgent ? "squircle" : "circle"}
       />
diff --git a/desktop/src/features/huddle/lib/huddleChannelName.ts b/desktop/src/features/huddle/lib/huddleChannelName.ts
index c9f6dff2835..bd01c0d3e8a 100644
--- a/desktop/src/features/huddle/lib/huddleChannelName.ts
+++ b/desktop/src/features/huddle/lib/huddleChannelName.ts
@@ -1,5 +1,5 @@
 import type { Channel, ChannelMember } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 
 type BuildHuddleChannelNameInput = {
   channel: Channel;
@@ -33,7 +33,7 @@ function channelParticipantLabel(
     return firstName(fallbackName);
   }
 
-  return truncatePubkey(pubkey);
+  return truncateNpub(pubkey);
 }
 
 export function buildHuddleChannelName({
diff --git a/desktop/src/features/messages/lib/formatTimelineMessages.ts b/desktop/src/features/messages/lib/formatTimelineMessages.ts
index a24da67f700..b35e8140481 100644
--- a/desktop/src/features/messages/lib/formatTimelineMessages.ts
+++ b/desktop/src/features/messages/lib/formatTimelineMessages.ts
@@ -45,7 +45,7 @@ import { formatTime } from "@/features/messages/lib/dateFormatters";
 // Pure overlay helper lives in a sibling .mjs so node:test (no TS loader)
 // can exercise the exact same source the renderer uses.
 import { applyEditTagOverlay } from "@/features/messages/lib/applyEditTagOverlay.mjs";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 const HEX_RE = /^[0-9a-f]+$/i;
 
@@ -387,7 +387,7 @@ export function formatTimelineMessages(
         ? "You"
         : profile?.displayName?.trim() ||
           profile?.nip05Handle?.trim() ||
-          truncatePubkey(actorPubkey);
+          truncateNpub(actorPubkey);
     existing.users.push({
       pubkey: actorPubkey,
       displayName,
diff --git a/desktop/src/features/messages/lib/mentionCandidates.ts b/desktop/src/features/messages/lib/mentionCandidates.ts
index 2ee46b01415..9c714015b24 100644
--- a/desktop/src/features/messages/lib/mentionCandidates.ts
+++ b/desktop/src/features/messages/lib/mentionCandidates.ts
@@ -5,7 +5,7 @@ import type {
   ChannelRole,
   UserSearchResult,
 } from "@/shared/api/types";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 export function formatSearchUserDisplayName(user: UserSearchResult) {
   return user.displayName?.trim() || user.nip05Handle?.trim() || null;
@@ -54,7 +54,7 @@ export type MentionCandidate = {
 export function mentionCandidateLabel(candidate: MentionCandidate) {
   return (
     candidate.displayName ??
-    (candidate.pubkey ? truncatePubkey(candidate.pubkey) : "agent")
+    (candidate.pubkey ? truncateNpub(candidate.pubkey) : "agent")
   );
 }
 
diff --git a/desktop/src/features/messages/lib/mentionClipboard.test.mjs b/desktop/src/features/messages/lib/mentionClipboard.test.mjs
index 39f16c96791..39db21be0c3 100644
--- a/desktop/src/features/messages/lib/mentionClipboard.test.mjs
+++ b/desktop/src/features/messages/lib/mentionClipboard.test.mjs
@@ -444,20 +444,38 @@ test("does not treat an uncapped label's ellipsis as a truncation", () => {
 test("whole compact mention labels are restored only for their declared exact key", () => {
   const key = `150b20bd${"a".repeat(52)}15dc`;
   const label = `Scout (${key}) 2`;
-  const compact = "Scout (150b20bd…15dc) 2";
-  assert.equal(matchChipTextToLabel(compact, label, "@", key), "truncated");
+  // The npub compact a chip renders today, and the hex compact a chip copied
+  // before keys displayed as npub still carries: a whole chip in either
+  // form re-binds; nothing else does.
+  const npubCompact = "Scout (npub1z59…zwkg) 2";
+  const legacyCompact = "Scout (150b20bd…15dc) 2";
+
+  for (const compact of [npubCompact, legacyCompact]) {
+    assert.equal(matchChipTextToLabel(compact, label, "@", key), "truncated");
+    assert.equal(
+      matchChipTextToLabel(`@${compact}`, label, "@", key),
+      "truncated",
+    );
+  }
+  assert.equal(matchChipTextToLabel(npubCompact, label, "@"), "fragment");
+  assert.equal(
+    matchChipTextToLabel(npubCompact, label, "@", "b".repeat(64)),
+    "fragment",
+  );
+  assert.equal(matchChipTextToLabel(npubCompact, label, "#", key), "fragment");
+  // A different key's compact — npub or legacy hex — is text this record
+  // never declared: tampered text never gains the identity's binding.
   assert.equal(
-    matchChipTextToLabel(`@${compact}`, label, "@", key),
-    "truncated",
+    matchChipTextToLabel("Scout (npub1m6k…zuz0) 2", label, "@", key),
+    "fragment",
   );
-  assert.equal(matchChipTextToLabel(compact, label, "@"), "fragment");
   assert.equal(
-    matchChipTextToLabel(compact, label, "@", "b".repeat(64)),
+    matchChipTextToLabel("Scout (deadbeef…beef) 2", label, "@", key),
     "fragment",
   );
-  assert.equal(matchChipTextToLabel(compact, label, "#", key), "fragment");
+  // A dropped collision suffix is a partial chip, not a tolerated form.
   assert.equal(
-    matchChipTextToLabel("Scout (150b20bd…15dc)", label, "@", key),
+    matchChipTextToLabel("Scout (npub1z59…zwkg)", label, "@", key),
     "fragment",
   );
   assert.equal(matchChipTextToLabel("Scout", label, "@", key), "fragment");
diff --git a/desktop/src/features/messages/lib/mentionClipboard.ts b/desktop/src/features/messages/lib/mentionClipboard.ts
index 8886bf8c29d..8b093610a49 100644
--- a/desktop/src/features/messages/lib/mentionClipboard.ts
+++ b/desktop/src/features/messages/lib/mentionClipboard.ts
@@ -1,4 +1,7 @@
-import { formatMentionDisplayLabel } from "@/shared/lib/mentionDisplay";
+import {
+  formatLegacyMentionDisplayLabel,
+  formatMentionDisplayLabel,
+} from "@/shared/lib/mentionDisplay";
 import { truncateInlineChipLabel } from "@/shared/ui/mentionChip";
 
 import { getMentionOffsets } from "./hasMention";
@@ -96,6 +99,17 @@ export function matchChipTextToLabel(
   if (compact !== label && matches(canonicalMentionLabel(compact))) {
     return "truncated";
   }
+  // A chip copied before keys displayed as npub carries the hex-truncated
+  // key in its text. Accept that prior *display* form — derived from the
+  // same label and pubkey this record declares, never from the pasted text
+  // itself — so an old whole-chip copy still re-binds instead of losing its
+  // identity. The two forms are disjoint (a hex truncation cannot contain
+  // the `n` an npub starts with), so this cannot reclassify any new chip.
+  const legacy =
+    sigil === "@" ? formatLegacyMentionDisplayLabel(label, pubkey) : label;
+  if (legacy !== label && matches(canonicalMentionLabel(legacy))) {
+    return "truncated";
+  }
   return "fragment";
 }
 
diff --git a/desktop/src/features/messages/lib/mentionRanking.ts b/desktop/src/features/messages/lib/mentionRanking.ts
index 3df5bba0b0a..deef2d3ebff 100644
--- a/desktop/src/features/messages/lib/mentionRanking.ts
+++ b/desktop/src/features/messages/lib/mentionRanking.ts
@@ -1,4 +1,4 @@
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 
 export type MentionCandidateForRanking = {
   displayName: string | null;
@@ -118,7 +118,7 @@ export function rankMentionCandidates<T extends MentionCandidateForRanking>(
         : "";
       const label =
         candidate.displayName ??
-        (candidate.pubkey ? truncatePubkey(candidate.pubkey) : "agent");
+        (candidate.pubkey ? truncateNpub(candidate.pubkey) : "agent");
       const groupRank = getMentionCandidateGroupRank(
         candidate,
         activePersonaIds,
diff --git a/desktop/src/features/messages/lib/normalizeMentionClipboard.test.mjs b/desktop/src/features/messages/lib/normalizeMentionClipboard.test.mjs
index 3e0563ab96c..a42a3a9aecb 100644
--- a/desktop/src/features/messages/lib/normalizeMentionClipboard.test.mjs
+++ b/desktop/src/features/messages/lib/normalizeMentionClipboard.test.mjs
@@ -272,10 +272,22 @@ test("compact mention paste expands only complete bound labels", () => {
   const html = (text) =>
     `<span data-mention="" data-mention-pubkey="${key}" ` +
     `data-mention-label="${label}">${text}</span>`;
+  // Today's chip text renders the key as npub…
+  assert.equal(
+    normalizeMentionClipboardContent(html("Scout (npub1z59…zwkg) 2")).text,
+    `@${label}`,
+  );
+  // …and a whole chip copied before that switch still carries the hex
+  // compact, which must keep expanding to the exact declared identity.
   assert.equal(
     normalizeMentionClipboardContent(html("Scout (150b20bd…15dc) 2")).text,
     `@${label}`,
   );
+  // A dropped collision suffix — in either form — is a partial chip.
+  assert.equal(
+    normalizeMentionClipboardContent(html("Scout (npub1z59…zwkg)")).text,
+    "Scout (npub1z59…zwkg)",
+  );
   assert.equal(
     normalizeMentionClipboardContent(html("Scout (150b20bd…15dc)")).text,
     "Scout (150b20bd…15dc)",
diff --git a/desktop/src/features/messages/lib/threadPanel.test.mjs b/desktop/src/features/messages/lib/threadPanel.test.mjs
index 8981d363803..630ebbc6fea 100644
--- a/desktop/src/features/messages/lib/threadPanel.test.mjs
+++ b/desktop/src/features/messages/lib/threadPanel.test.mjs
@@ -607,6 +607,13 @@ test("buildThreadPanelDataFromIndex matches direct panel data", () => {
 
 test("buildMainTimelineEntries renders a relay-only thread summary", () => {
   const root = message({ id: "root", createdAt: 1 });
+  // Realistic 64-hex relay participant keys: a cold/relay-only summary has no
+  // client messages to derive labels from, so an unnamed participant must
+  // fall back to the compact npub (`truncateNpub`, the same form the
+  // client-assembled path derives via `resolveUserLabel`) — never the raw
+  // hex identity. `participant.author` is what `MessageThreadSummaryRow`
+  // binds to `UserAvatar`'s visible/accessible `displayName` label.
+  const bob = "deadbeef".repeat(8); // → npub1m6k…zuz0
   const summaries = new Map([
     [
       "root",
@@ -614,7 +621,7 @@ test("buildMainTimelineEntries renders a relay-only thread summary", () => {
         replyCount: 2,
         descendantCount: 4,
         lastReplyAt: 9,
-        participantPubkeys: ["alice", "bob"],
+        participantPubkeys: ["alice", bob],
       },
     ],
   ]);
@@ -631,10 +638,10 @@ test("buildMainTimelineEntries renders a relay-only thread summary", () => {
     threadHeadId: "root",
     replyCount: 4,
     lastReplyAt: 9,
-    // Relay returns participants most-recent-first (["alice", "bob"]); the
+    // Relay returns participants most-recent-first (["alice", bob]); the
     // facepile renders them oldest-first so the last replier lands rightmost.
     participants: [
-      { id: "bob", author: "bob", avatarUrl: null },
+      { id: bob, author: "npub1m6k…zuz0", avatarUrl: null },
       { id: "alice", author: "Alice", avatarUrl: "alice.png" },
     ],
   });
diff --git a/desktop/src/features/messages/lib/threadPanel.ts b/desktop/src/features/messages/lib/threadPanel.ts
index 3bc5ee39125..b85b57d1ac9 100644
--- a/desktop/src/features/messages/lib/threadPanel.ts
+++ b/desktop/src/features/messages/lib/threadPanel.ts
@@ -2,6 +2,7 @@ import type { TimelineMessage } from "@/features/messages/types";
 import type { ChannelWindowThreadSummary } from "@/features/messages/lib/channelWindowStore";
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { isBroadcastReply } from "@/features/messages/lib/threading";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { KIND_HUDDLE_STARTED } from "@/shared/constants/kinds";
 
 type ThreadPanelData = {
@@ -408,7 +409,13 @@ function buildRelayThreadSummary(
       .reverse()
       .map((pubkey) => ({
         id: pubkey,
-        author: profiles?.[pubkey.toLowerCase()]?.displayName ?? pubkey,
+        // Unnamed participants fall back to the compact npub — the same label
+        // the client-assembled path derives via `resolveUserLabel` — so a
+        // cold/relay-only facepile never surfaces raw hex. This `author` is
+        // what `MessageThreadSummaryRow` binds to `UserAvatar`'s
+        // `displayName` (the visible/accessible avatar label).
+        author:
+          profiles?.[pubkey.toLowerCase()]?.displayName ?? truncateNpub(pubkey),
         avatarUrl: profiles?.[pubkey.toLowerCase()]?.avatarUrl ?? null,
         ...(profiles?.[pubkey.toLowerCase()]?.isAgent === true
           ? { isAgent: true }
diff --git a/desktop/src/features/messages/lib/timelineMentionCopy.test.mjs b/desktop/src/features/messages/lib/timelineMentionCopy.test.mjs
index 4f8c05842aa..ceada037c0d 100644
--- a/desktop/src/features/messages/lib/timelineMentionCopy.test.mjs
+++ b/desktop/src/features/messages/lib/timelineMentionCopy.test.mjs
@@ -190,15 +190,20 @@ test("copy inlines a blockified chip but preserves its block ancestor", () => {
 
 test("copy expands compact key text but preserves the exact label and identity", () => {
   const label = `Scout (${JOHN_SMITH_PUBKEY}) 2`;
-  const flavors = copyRenderedBody(
-    `<span data-mention="" data-mention-pubkey="${JOHN_SMITH_PUBKEY}" ` +
-      `data-mention-label="${label}" class="mention-chip">` +
-      '<span class="inline-chip-leading-fragment">Scout</span> (7c7c7c7c…7c7c) 2</span>',
-  );
-  assert.ok(flavors);
-  assert.ok(flavors.html.includes(`@${label}`));
-  assert.ok(
-    flavors.html.includes(`data-mention-pubkey="${JOHN_SMITH_PUBKEY}"`),
-  );
-  assert.ok(!flavors.html.includes("…"));
+  // Chips render the npub compact today; a chip copied before that switch
+  // still carries the hex compact. A whole chip in either form expands to
+  // the declared identity.
+  for (const compact of ["npub1037…08vj", "7c7c7c7c…7c7c"]) {
+    const flavors = copyRenderedBody(
+      `<span data-mention="" data-mention-pubkey="${JOHN_SMITH_PUBKEY}" ` +
+        `data-mention-label="${label}" class="mention-chip">` +
+        `<span class="inline-chip-leading-fragment">Scout</span> (${compact}) 2</span>`,
+    );
+    assert.ok(flavors);
+    assert.ok(flavors.html.includes(`@${label}`));
+    assert.ok(
+      flavors.html.includes(`data-mention-pubkey="${JOHN_SMITH_PUBKEY}"`),
+    );
+    assert.ok(!flavors.html.includes("…"));
+  }
 });
diff --git a/desktop/src/features/messages/ui/MentionAutocomplete.tsx b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
index a380ac83a09..65ae331d594 100644
--- a/desktop/src/features/messages/ui/MentionAutocomplete.tsx
+++ b/desktop/src/features/messages/ui/MentionAutocomplete.tsx
@@ -15,7 +15,7 @@ import { Switch } from "@/shared/ui/switch";
 import { Toggle } from "@/shared/ui/toggle";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 import { safeNpub } from "@/shared/lib/nostrUtils";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { getPlatformKeysById } from "@/shared/lib/keyboard-shortcuts";
 
 export type MentionSuggestion = {
@@ -387,7 +387,7 @@ export const MentionAutocomplete = React.memo(function MentionAutocomplete({
                             data-testid="mention-collision-npub"
                             title={collisionNpub}
                           >
-                            {truncatePubkey(collisionNpub)}
+                            {truncateNpub(collisionNpub)}
                           </span>
                         ) : null}
                       </span>
diff --git a/desktop/src/features/messages/ui/MessageAgentAddressPrefix.tsx b/desktop/src/features/messages/ui/MessageAgentAddressPrefix.tsx
index e3ab0c6076a..644a8dc80d3 100644
--- a/desktop/src/features/messages/ui/MessageAgentAddressPrefix.tsx
+++ b/desktop/src/features/messages/ui/MessageAgentAddressPrefix.tsx
@@ -5,7 +5,7 @@ import { getVisibleAgentAddressPubkeys } from "../lib/getVisibleAgentAddressPubk
 
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { UserProfilePopover } from "@/features/profile/ui/UserProfilePopover";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { InlineChip } from "@/shared/ui/InlineChip";
 
 /** Resolve all literal competitors before hiding tag-backed address chips. */
@@ -54,7 +54,7 @@ export function MessageAgentAddressPrefix({
         const label =
           profile?.displayName?.trim() ||
           profile?.name?.trim() ||
-          truncatePubkey(pubkey);
+          truncateNpub(pubkey);
         return (
           <React.Fragment key={pubkey}>
             {/* biome-ignore lint/a11y/useValidAriaRole: UserProfilePopover uses role for agent classification, not as an ARIA attribute. */}
diff --git a/desktop/src/features/messages/ui/NewMessageResultRow.tsx b/desktop/src/features/messages/ui/NewMessageResultRow.tsx
index 9625fb7882e..ea07a0607a1 100644
--- a/desktop/src/features/messages/ui/NewMessageResultRow.tsx
+++ b/desktop/src/features/messages/ui/NewMessageResultRow.tsx
@@ -6,7 +6,7 @@ import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { ProfileAvatar } from "@/features/profile/ui/ProfileAvatar";
 import type { UserSearchResult } from "@/shared/api/types";
 import { cn } from "@/shared/lib/cn";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 import { formatRecipientName } from "./useNewMessageRecipients";
 
@@ -28,7 +28,7 @@ function HoverRecipientIdentity({
   displayName: string;
   pubkey: string;
 }) {
-  const identityLabel = truncatePubkey(pubkey);
+  const identityLabel = truncateNpub(pubkey);
 
   return (
     <span
diff --git a/desktop/src/features/messages/ui/TypingIndicatorRow.tsx b/desktop/src/features/messages/ui/TypingIndicatorRow.tsx
index 1dcf6e22741..5f73ef0725b 100644
--- a/desktop/src/features/messages/ui/TypingIndicatorRow.tsx
+++ b/desktop/src/features/messages/ui/TypingIndicatorRow.tsx
@@ -8,7 +8,7 @@ import { ProfileAvatar } from "@/features/profile/ui/ProfileAvatar";
 import type { Channel } from "@/shared/api/types";
 import { cn } from "@/shared/lib/cn";
 import { Shimmer } from "@/shared/ui/Shimmer";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 type TypingIndicatorRowProps = {
   channel: Channel | null;
@@ -96,7 +96,7 @@ export function TypingIndicatorRow({
           <div className="flex shrink-0 items-center">
             {typingPubkeys.map((pubkey, index) => {
               const profile = profiles?.[pubkey.toLowerCase()];
-              const label = labels[index] ?? truncatePubkey(pubkey);
+              const label = labels[index] ?? truncateNpub(pubkey);
               return (
                 <div
                   key={pubkey}
diff --git a/desktop/src/features/messages/ui/useAgentAddressLockPicker.ts b/desktop/src/features/messages/ui/useAgentAddressLockPicker.ts
index 0a0c2d02807..802f38b907b 100644
--- a/desktop/src/features/messages/ui/useAgentAddressLockPicker.ts
+++ b/desktop/src/features/messages/ui/useAgentAddressLockPicker.ts
@@ -10,7 +10,7 @@ import type {
 } from "@/features/messages/lib/useRichTextEditor";
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { detectPrefixQuery } from "@/shared/lib/detectPrefixQuery";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import type { ComposerAddressAgent } from "./ComposerAddressControls";
 import type { MentionSuggestion } from "./MentionAutocomplete";
 
@@ -87,7 +87,7 @@ export function useAgentAddressLockPicker({
           displayName:
             resolvedDisplayName ??
             lockedAgentNamesRef.current.get(normalized) ??
-            truncatePubkey(normalized),
+            truncateNpub(normalized),
           avatarUrl: profile?.avatarUrl ?? null,
         };
       }),
@@ -369,7 +369,7 @@ export function useAgentAddressLockPicker({
             profile?.nip05Handle?.trim() ||
             mentions.getMentionDisplayName(pubkey)?.trim() ||
             lockedAgentNamesRef.current.get(pubkey) ||
-            truncatePubkey(pubkey);
+            truncateNpub(pubkey);
           return { pubkey, displayName };
         });
       const { text } = richText.getPlainTextAndCursor();
diff --git a/desktop/src/features/messages/ui/useMentionSendFlow.test-support.mjs b/desktop/src/features/messages/ui/useMentionSendFlow.test-support.mjs
index c49e1f5c5e3..bb5fc3de534 100644
--- a/desktop/src/features/messages/ui/useMentionSendFlow.test-support.mjs
+++ b/desktop/src/features/messages/ui/useMentionSendFlow.test-support.mjs
@@ -160,6 +160,9 @@ export async function setup({ lifecycle = false } = {}) {
     "@/shared/lib/pubkey": {
       normalizePubkey: (key) => key.toLowerCase(),
       truncatePubkey: (key) => key,
+      // Compact-identity seam stubbed alongside its sibling: these suites
+      // render display names, never key-form labels.
+      truncateNpub: (key) => key,
     },
     "@/shared/lib/customEmojiTags": { buildCustomEmojiTags: () => [] },
     "./useMentionSendFlow.helpers": helpers,
diff --git a/desktop/src/features/messages/ui/useMentionSendFlow.ts b/desktop/src/features/messages/ui/useMentionSendFlow.ts
index 9847193101b..299c0144ab4 100644
--- a/desktop/src/features/messages/ui/useMentionSendFlow.ts
+++ b/desktop/src/features/messages/ui/useMentionSendFlow.ts
@@ -28,7 +28,7 @@ import { useDetachedAgentStart } from "./useDetachedAgentStart";
 import { useEnsureAgentMentionsReady } from "./useEnsureAgentMentionsReady";
 import { invokeTauri } from "@/shared/api/tauri";
 import type { AcpRuntime, ManagedAgent } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { buildCustomEmojiTags } from "@/shared/lib/customEmojiTags";
 import {
   dedupeQueuedAgentWakes,
@@ -941,7 +941,7 @@ export function useMentionSendFlow({
     if (!pendingNonMemberSend) return [];
     return pendingNonMemberSend.nonMemberPubkeys.map(
       (pubkey) =>
-        mentions.getMentionDisplayName(pubkey) ?? truncatePubkey(pubkey),
+        mentions.getMentionDisplayName(pubkey) ?? truncateNpub(pubkey),
     );
   }, [mentions.getMentionDisplayName, pendingNonMemberSend]);
   const invitation = useNonMemberInvite({
diff --git a/desktop/src/features/messages/ui/useNewMessageRecipients.ts b/desktop/src/features/messages/ui/useNewMessageRecipients.ts
index ffc45c6c9e2..c1b821da62b 100644
--- a/desktop/src/features/messages/ui/useNewMessageRecipients.ts
+++ b/desktop/src/features/messages/ui/useNewMessageRecipients.ts
@@ -20,7 +20,7 @@ import {
 import { rankUserCandidatesBySearch } from "@/features/profile/lib/userCandidateSearch";
 import { useIdentityQuery } from "@/shared/api/hooks";
 import type { ManagedAgent, UserSearchResult } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 
 /** Maximum recipients (excluding the current user) a DM can address. */
 export const NEW_MESSAGE_RECIPIENT_LIMIT = 8;
@@ -37,7 +37,7 @@ export function formatRecipientName(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
diff --git a/desktop/src/features/notifications/use-feed-desktop-notifications.ts b/desktop/src/features/notifications/use-feed-desktop-notifications.ts
index 4a0865437ed..e4594547eed 100644
--- a/desktop/src/features/notifications/use-feed-desktop-notifications.ts
+++ b/desktop/src/features/notifications/use-feed-desktop-notifications.ts
@@ -1,6 +1,6 @@
 import * as React from "react";
 
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import {
   resolveUserLabel,
   type UserProfileLookup,
@@ -204,7 +204,7 @@ export function useFeedDesktopNotifications(
         : undefined;
       // Only use real display names, not truncated pubkey fallbacks.
       const senderName =
-        resolvedLabel && resolvedLabel !== truncatePubkey(item.pubkey)
+        resolvedLabel && resolvedLabel !== truncateNpub(item.pubkey)
           ? resolvedLabel
           : undefined;
       void deliverFeedNotification(item, senderName);
diff --git a/desktop/src/features/profile/lib/identity.test.mjs b/desktop/src/features/profile/lib/identity.test.mjs
index da0259a66fc..089195213b3 100644
--- a/desktop/src/features/profile/lib/identity.test.mjs
+++ b/desktop/src/features/profile/lib/identity.test.mjs
@@ -1,11 +1,19 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { formatOwnerLabel, profileLookupsEqual } from "./identity.ts";
+import {
+  formatOwnerLabel,
+  profileLookupsEqual,
+  resolveUserLabel,
+} from "./identity.ts";
 
 const OWNER_PUBKEY =
   "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
+// npubEncode(OWNER_PUBKEY), pinned so a fallback regression cannot pass by
+// re-deriving the expectation from the code under test.
+const OWNER_NPUB_COMPACT = "npub1hwa…04hu";
+
 const summary = (over = {}) => ({
   displayName: "Ada",
   avatarUrl: "https://x/a.png",
@@ -15,13 +23,28 @@ const summary = (over = {}) => ({
   ...over,
 });
 
-test("formatOwnerLabel resolves a known owner's display name", () => {
+test("formatOwnerLabel prefers the owner’s authored labels over the compact npub", () => {
+  // The label ladder: display name first, then a NIP-05 handle, then the
+  // key’s compact npub — never raw hex.
   assert.equal(
     formatOwnerLabel(OWNER_PUBKEY, null, {
       [OWNER_PUBKEY]: summary({ displayName: "baxen" }),
     }),
     "baxen",
   );
+  assert.equal(
+    formatOwnerLabel(OWNER_PUBKEY, "c".repeat(64), {
+      [OWNER_PUBKEY]: summary({
+        nip05Handle: "baxen@relay",
+        displayName: null,
+      }),
+    }),
+    "baxen@relay",
+  );
+  assert.equal(
+    formatOwnerLabel(OWNER_PUBKEY, "c".repeat(64), {}),
+    OWNER_NPUB_COMPACT,
+  );
 });
 
 test("formatOwnerLabel calls the viewer-owned agent's owner you", () => {
@@ -32,6 +55,31 @@ test("formatOwnerLabel returns null when verified ownership is absent", () => {
   assert.equal(formatOwnerLabel(null, OWNER_PUBKEY, {}), null);
 });
 
+test("resolveUserLabel falls back to the key’s compact npub, never raw hex", () => {
+  // No profile, no fallback name: the last resort is the npub compact.
+  assert.equal(
+    resolveUserLabel({ pubkey: OWNER_PUBKEY, profiles: {} }),
+    OWNER_NPUB_COMPACT,
+  );
+  // A provided fallback name still wins over the key form.
+  assert.equal(
+    resolveUserLabel({
+      pubkey: OWNER_PUBKEY,
+      profiles: {},
+      fallbackName: "legacy relay agent",
+    }),
+    "legacy relay agent",
+  );
+  // A resolved display name wins over everything.
+  assert.equal(
+    resolveUserLabel({
+      pubkey: OWNER_PUBKEY,
+      profiles: { [OWNER_PUBKEY]: summary({ displayName: "baxen" }) },
+    }),
+    "baxen",
+  );
+});
+
 test("profileLookupsEqual: same reference is equal", () => {
   const a = { p1: summary() };
   assert.equal(profileLookupsEqual(a, a), true);
diff --git a/desktop/src/features/profile/lib/identity.ts b/desktop/src/features/profile/lib/identity.ts
index d2e0a4fdd38..a0d32faaaa4 100644
--- a/desktop/src/features/profile/lib/identity.ts
+++ b/desktop/src/features/profile/lib/identity.ts
@@ -1,9 +1,9 @@
 import type { Profile, UserProfileSummary } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 
 export type UserProfileLookup = Record<string, UserProfileSummary>;
 
-export { truncatePubkey };
+export { truncateNpub };
 
 /**
  * Deep-equal two profile lookups by value. Used to stabilise the merged
@@ -128,7 +128,7 @@ export function resolveUserLabel(input: {
     return safeFallback;
   }
 
-  return truncatePubkey(pubkey);
+  return truncateNpub(pubkey);
 }
 
 /**
@@ -188,6 +188,6 @@ export function formatOwnerLabel(
   return (
     owner?.displayName?.trim() ||
     owner?.nip05Handle?.trim() ||
-    truncatePubkey(ownerPubkey)
+    truncateNpub(ownerPubkey)
   );
 }
diff --git a/desktop/src/features/profile/ui/ProfileAvatar.tsx b/desktop/src/features/profile/ui/ProfileAvatar.tsx
index debbc42803a..d8d22eaa76a 100644
--- a/desktop/src/features/profile/ui/ProfileAvatar.tsx
+++ b/desktop/src/features/profile/ui/ProfileAvatar.tsx
@@ -23,6 +23,17 @@ type ProfileAvatarProps = {
   avatarUrl: string | null;
   avatarDataUrl?: string | null;
   label: string;
+  /**
+   * Label used to derive fallback initials; defaults to `label`.
+   *
+   * `label` stays the full visible/alt identity, but some callers build it
+   * as a generated role-prefixed key fallback ("Agent npub1abcd…wxyz"),
+   * which `getInitials` reads as ordinary words — collapsing every unnamed
+   * identity onto the same "AN"/"PN" initials. Identity-aware callers pass
+   * the unprefixed compact key here so key-fallback avatars keep distinct
+   * key-tail initials; authored display names keep their name initials.
+   */
+  initialsLabel?: string;
   className?: string;
   iconClassName?: string;
   imageClassName?: string;
@@ -46,6 +57,7 @@ export function ProfileAvatar({
   avatarUrl,
   avatarDataUrl,
   label,
+  initialsLabel,
   className,
   iconClassName,
   imageClassName,
@@ -54,7 +66,7 @@ export function ProfileAvatar({
   testId,
   untrusted = false,
 }: ProfileAvatarProps) {
-  const initials = getInitials(label);
+  const initials = getInitials(initialsLabel ?? label);
   const presentation = useAvatarPresentation(avatarUrl);
   const presentedAvatarUrl = presentation?.displayUrl ?? avatarUrl;
 
diff --git a/desktop/src/features/profile/ui/UserProfilePanel.tsx b/desktop/src/features/profile/ui/UserProfilePanel.tsx
index d060deb5323..bad18369fe3 100644
--- a/desktop/src/features/profile/ui/UserProfilePanel.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanel.tsx
@@ -77,7 +77,7 @@ import {
   resolveAgentInstruction,
   resolvePanelProfile,
   resolveProfileDisplayName,
-  truncatePubkey,
+  truncateNpub,
   type UserProfilePanelProps,
   useRetainedPersona,
 } from "@/features/profile/ui/UserProfilePanelUtils";
@@ -675,7 +675,7 @@ export function UserProfilePanel({
       return (
         ownerProfile?.nip05Handle?.trim() ||
         ownerProfile?.displayName?.trim() ||
-        truncatePubkey(ownerPubkey)
+        truncateNpub(ownerPubkey)
       );
     }
 
@@ -687,7 +687,7 @@ export function UserProfilePanel({
     return (
       currentProfile?.nip05Handle?.trim() ||
       currentProfile?.displayName?.trim() ||
-      truncatePubkey(currentPubkey)
+      truncateNpub(currentPubkey)
     );
   }, [
     currentProfileQuery.data,
diff --git a/desktop/src/features/profile/ui/UserProfilePanelUtils.ts b/desktop/src/features/profile/ui/UserProfilePanelUtils.ts
index be1a57c112e..e7d5a4d4ef8 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelUtils.ts
+++ b/desktop/src/features/profile/ui/UserProfilePanelUtils.ts
@@ -8,9 +8,9 @@ import type {
   RelayAgent,
   UpdateManagedAgentInput,
 } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 
-export { truncatePubkey };
+export { truncateNpub };
 
 export type ProfileChannelLink = {
   id: string;
@@ -237,7 +237,7 @@ export function resolveProfileDisplayName({
   return (
     profile?.displayName ??
     persona?.displayName ??
-    (pubkey ? truncatePubkey(pubkey) : "Agent")
+    (pubkey ? truncateNpub(pubkey) : "Agent")
   );
 }
 
@@ -252,7 +252,7 @@ export function resolveOwnerHandle(
   return (
     profile?.nip05Handle?.trim() ||
     profile?.displayName?.trim() ||
-    truncatePubkey(currentPubkey)
+    truncateNpub(currentPubkey)
   );
 }
 
diff --git a/desktop/src/features/profile/ui/UserProfilePopover.tsx b/desktop/src/features/profile/ui/UserProfilePopover.tsx
index 3fab7b8102e..c36b59e3af6 100644
--- a/desktop/src/features/profile/ui/UserProfilePopover.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePopover.tsx
@@ -30,7 +30,7 @@ import { ProfileAvatarWithStatus } from "@/features/profile/ui/ProfileAvatarWith
 import { useOpenAgentActivity } from "@/features/agents/useOpenAgentActivity";
 import { useProfilePanel } from "@/shared/context/ProfilePanelContext";
 import { cn } from "@/shared/lib/cn";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { useProfileInteractionActions } from "@/features/profile/ui/useProfileInteractionActions";
 
 import {
@@ -108,7 +108,7 @@ function HoverPubkeyName({
       <span
         className={`${TEXT_SWAP_BASE_CLASS} ${TEXT_SWAP_HIDDEN_CLASS} ${TEXT_SWAP_HOVER_VISIBLE_CLASS}`}
       >
-        {truncatePubkey(pubkey)}
+        {truncateNpub(pubkey)}
       </span>
     </span>
   );
@@ -297,7 +297,7 @@ function UserProfilePopoverBody({
       relayAgentsQuery.isPending ||
       managedAgentsQuery.isPending ||
       usersBatchQuery.isPending);
-  const displayName = profile?.displayName ?? truncatePubkey(pubkey);
+  const displayName = profile?.displayName ?? truncateNpub(pubkey);
   // Owner signal mirrors UserProfilePanel: a declared NIP-OA owner whose agent
   // runs elsewhere holds no local seckey, so key custody (`isOwner`) alone
   // wrongly hides the affordance from them — and gating on bot-ness alone shows
diff --git a/desktop/src/features/profile/ui/useProfileInteractionActions.ts b/desktop/src/features/profile/ui/useProfileInteractionActions.ts
index f5ee47a7702..1993188f319 100644
--- a/desktop/src/features/profile/ui/useProfileInteractionActions.ts
+++ b/desktop/src/features/profile/ui/useProfileInteractionActions.ts
@@ -21,7 +21,7 @@ import { useIdentityQuery } from "@/shared/api/hooks";
 import { sendChannelMessage } from "@/shared/api/tauri";
 import type { Channel, RelayEvent } from "@/shared/api/types";
 import { KIND_STREAM_MESSAGE } from "@/shared/constants/kinds";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 
 export type ProfileInteractionAction = "huddle" | "message" | "wave";
 
@@ -207,7 +207,7 @@ export function useProfileInteractionActions({
       const senderName =
         selfProfileQuery.data?.displayName?.trim() ||
         identity.displayName.trim() ||
-        truncatePubkey(identity.pubkey);
+        truncateNpub(identity.pubkey);
       const content = buildWaveMessageContent(senderName);
       const queryKey = channelMessagesKey(dm.id);
 
diff --git a/desktop/src/features/projects/ui/IssueAssigneesRow.tsx b/desktop/src/features/projects/ui/IssueAssigneesRow.tsx
index 54073bac5dd..71855770f27 100644
--- a/desktop/src/features/projects/ui/IssueAssigneesRow.tsx
+++ b/desktop/src/features/projects/ui/IssueAssigneesRow.tsx
@@ -13,7 +13,7 @@ import { useUserSearchQuery } from "@/features/profile/hooks";
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import type { UserSearchResult } from "@/shared/api/types";
 import { cn } from "@/shared/lib/cn";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import {
   Dialog,
@@ -37,7 +37,7 @@ function labelForPubkey(pubkey: string, profiles?: UserProfileLookup) {
   return (
     profile?.displayName?.trim() ||
     profile?.nip05Handle?.trim() ||
-    truncatePubkey(pubkey)
+    truncateNpub(pubkey)
   );
 }
 
@@ -45,7 +45,7 @@ function assigneeSearchLabel(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
@@ -383,7 +383,7 @@ export function IssueAssigneesRow({
                         </span>
                         <span className="block truncate text-xs text-muted-foreground">
                           {candidate.isAgent ? "Agent · " : ""}
-                          {truncatePubkey(candidate.pubkey)}
+                          {truncateNpub(candidate.pubkey)}
                         </span>
                       </span>
                     </button>
diff --git a/desktop/src/features/projects/ui/ProjectDetailFeedPanels.tsx b/desktop/src/features/projects/ui/ProjectDetailFeedPanels.tsx
index d960d3f09fc..bdb81011b3a 100644
--- a/desktop/src/features/projects/ui/ProjectDetailFeedPanels.tsx
+++ b/desktop/src/features/projects/ui/ProjectDetailFeedPanels.tsx
@@ -16,7 +16,7 @@ import { selectionItemFromCommit } from "@/features/projects/lib/projectSelectio
 import { commitShareLink } from "@/features/projects/lib/projectShareLinks";
 import { relativeTime } from "@/features/projects/lib/projectsViewHelpers";
 import type { ProjectRepoCommit } from "@/shared/api/types";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { BuzzLoadingState } from "@/shared/ui/BuzzLoadingState";
 import {
   resolveUserLabel,
@@ -129,7 +129,7 @@ export function ContributorsPanel({
         isAgent,
         label: profile
           ? resolveUserLabel({ profiles, pubkey })
-          : truncatePubkey(pubkey),
+          : truncateNpub(pubkey),
         profileLinked: true,
         pubkey,
         reviewCount: signedCounts.reviews,
diff --git a/desktop/src/features/projects/ui/ProjectPullRequestInlineComments.tsx b/desktop/src/features/projects/ui/ProjectPullRequestInlineComments.tsx
index 281aefe71be..fc64ffc6324 100644
--- a/desktop/src/features/projects/ui/ProjectPullRequestInlineComments.tsx
+++ b/desktop/src/features/projects/ui/ProjectPullRequestInlineComments.tsx
@@ -7,7 +7,7 @@ import type {
 } from "@/features/projects/projectPullRequests.mjs";
 import { relativeTime } from "@/features/projects/lib/projectsViewHelpers";
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { ProjectRichContent } from "./ProjectRichContent";
 
 function commentAuthor(
@@ -18,7 +18,7 @@ function commentAuthor(
   return (
     profile?.displayName?.trim() ||
     profile?.nip05Handle?.trim() ||
-    truncatePubkey(pubkey)
+    truncateNpub(pubkey)
   );
 }
 
diff --git a/desktop/src/features/projects/ui/ProjectPullRequestsPanel.tsx b/desktop/src/features/projects/ui/ProjectPullRequestsPanel.tsx
index b130bf552c5..9fe09f50cd4 100644
--- a/desktop/src/features/projects/ui/ProjectPullRequestsPanel.tsx
+++ b/desktop/src/features/projects/ui/ProjectPullRequestsPanel.tsx
@@ -33,7 +33,7 @@ import { canReviewProjectPullRequest } from "@/features/projects/pullRequestRevi
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { useIdentityQuery } from "@/shared/api/hooks";
 import type { ChannelMember } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import {
   ProjectFeedRow,
   ProjectFeedRowCluster,
@@ -70,7 +70,7 @@ function labelForPubkey(pubkey: string, profiles?: UserProfileLookup) {
   return (
     profile?.displayName?.trim() ||
     profile?.nip05Handle?.trim() ||
-    truncatePubkey(pubkey)
+    truncateNpub(pubkey)
   );
 }
 
diff --git a/desktop/src/features/projects/ui/PullRequestReviewersRow.tsx b/desktop/src/features/projects/ui/PullRequestReviewersRow.tsx
index fa5f205fabb..8b824f917d9 100644
--- a/desktop/src/features/projects/ui/PullRequestReviewersRow.tsx
+++ b/desktop/src/features/projects/ui/PullRequestReviewersRow.tsx
@@ -19,7 +19,7 @@ import { useUserSearchQuery } from "@/features/profile/hooks";
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import type { UserSearchResult } from "@/shared/api/types";
 import { cn } from "@/shared/lib/cn";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import {
   Dialog,
@@ -44,7 +44,7 @@ function labelForPubkey(pubkey: string, profiles?: UserProfileLookup) {
   return (
     profile?.displayName?.trim() ||
     profile?.nip05Handle?.trim() ||
-    truncatePubkey(pubkey)
+    truncateNpub(pubkey)
   );
 }
 
@@ -52,7 +52,7 @@ function reviewerSearchLabel(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
@@ -270,7 +270,7 @@ export function PullRequestReviewersRow({
                     </span>
                     <span className="block truncate text-xs text-muted-foreground">
                       {candidate.isAgent ? "Agent · " : ""}
-                      {truncatePubkey(candidate.pubkey)}
+                      {truncateNpub(candidate.pubkey)}
                     </span>
                   </span>
                 </button>
diff --git a/desktop/src/features/pulse/ui/AgentActivityCard.tsx b/desktop/src/features/pulse/ui/AgentActivityCard.tsx
index 30e8601912a..310820363e2 100644
--- a/desktop/src/features/pulse/ui/AgentActivityCard.tsx
+++ b/desktop/src/features/pulse/ui/AgentActivityCard.tsx
@@ -6,7 +6,7 @@ import { UserProfilePopover } from "@/features/profile/ui/UserProfilePopover";
 import type { UserProfileSummary } from "@/shared/api/types";
 import { Markdown } from "@/shared/ui/markdown";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 type AgentActivityCardProps = {
   group: AgentNoteGroup;
@@ -51,7 +51,7 @@ export function AgentActivityCard({
   agentStatus,
 }: AgentActivityCardProps) {
   const [expanded, setExpanded] = React.useState(false);
-  const displayName = profile?.displayName ?? truncatePubkey(group.pubkey);
+  const displayName = profile?.displayName ?? truncateNpub(group.pubkey);
   const avatarUrl = profile?.avatarUrl ?? null;
   const isSingleNote = group.notes.length === 1;
 
diff --git a/desktop/src/features/pulse/ui/NoteCard.tsx b/desktop/src/features/pulse/ui/NoteCard.tsx
index 96f25a6ede4..7ce04ce3dba 100644
--- a/desktop/src/features/pulse/ui/NoteCard.tsx
+++ b/desktop/src/features/pulse/ui/NoteCard.tsx
@@ -18,7 +18,7 @@ import { AnimatedCount } from "@/shared/ui/AnimatedCount";
 import { Markdown } from "@/shared/ui/markdown";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 export type NoteCardActions = {
   reply?: (
@@ -67,7 +67,7 @@ function ReplyParentContext({
   const parentDisplayName = parentNote
     ? (cachedProfile?.displayName ??
       fetchedProfile?.displayName ??
-      truncatePubkey(parentNote.pubkey))
+      truncateNpub(parentNote.pubkey))
     : null;
   const parentAvatarUrl =
     cachedProfile?.avatarUrl ?? fetchedProfile?.avatarUrl ?? null;
@@ -149,7 +149,7 @@ export function NoteCard({
   members = [],
   actions,
 }: NoteCardProps) {
-  const displayName = profile?.displayName ?? truncatePubkey(note.pubkey);
+  const displayName = profile?.displayName ?? truncateNpub(note.pubkey);
   const avatarUrl = profile?.avatarUrl ?? null;
   const [isReplyComposerOpen, setIsReplyComposerOpen] = React.useState(false);
   const actionButtonClass =
diff --git a/desktop/src/features/pulse/ui/PulseView.tsx b/desktop/src/features/pulse/ui/PulseView.tsx
index 2b595ed2ccb..01cd20d6225 100644
--- a/desktop/src/features/pulse/ui/PulseView.tsx
+++ b/desktop/src/features/pulse/ui/PulseView.tsx
@@ -30,7 +30,7 @@ import { Input } from "@/shared/ui/input";
 import { Skeleton } from "@/shared/ui/skeleton";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
 import { VirtualizedList } from "@/shared/ui/VirtualizedList";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 
 export type PulseTab =
   | "search"
@@ -225,7 +225,7 @@ export function PulseView({ currentPubkey }: PulseViewProps) {
     : null;
   const currentDisplayName =
     currentProfile?.displayName ??
-    (currentPubkey ? truncatePubkey(currentPubkey) : "You");
+    (currentPubkey ? truncateNpub(currentPubkey) : "You");
 
   const pulseMentionMembers = React.useMemo<ChannelMember[]>(() => {
     const members: ChannelMember[] = [];
diff --git a/desktop/src/features/search/ui/TopbarSearch.tsx b/desktop/src/features/search/ui/TopbarSearch.tsx
index 68e879a3033..5a032c780a4 100644
--- a/desktop/src/features/search/ui/TopbarSearch.tsx
+++ b/desktop/src/features/search/ui/TopbarSearch.tsx
@@ -20,7 +20,7 @@ import { HighlightedSearchText } from "@/features/search/ui/HighlightedSearchTex
 import { useSearchMenuKeyboardNavigation } from "@/features/search/ui/useSearchMenuKeyboardNavigation";
 import type { Channel, SearchHit, UserSearchResult } from "@/shared/api/types";
 import { cn } from "@/shared/lib/cn";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { Dialog, DialogContent, DialogTitle } from "@/shared/ui/dialog";
 import { useDeferredModalOpen } from "@/shared/ui/deferredModalOpen";
 import {
@@ -134,7 +134,7 @@ function getUserDisplayName(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
diff --git a/desktop/src/features/settings/ui/ModerationQueueCard.tsx b/desktop/src/features/settings/ui/ModerationQueueCard.tsx
index 58dbe87ab79..9bb5962585a 100644
--- a/desktop/src/features/settings/ui/ModerationQueueCard.tsx
+++ b/desktop/src/features/settings/ui/ModerationQueueCard.tsx
@@ -34,7 +34,7 @@ import {
   type SeverityTier,
 } from "@/features/settings/lib/moderationQueue";
 import { cn } from "@/shared/lib/cn";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub, truncatePubkey } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import {
   DropdownMenu,
@@ -195,14 +195,15 @@ const SEVERITY_BADGE: Record<SeverityTier, string> = {
 };
 
 function targetLabel(group: ModerationQueueGroup): string {
-  const short = truncatePubkey(group.target);
   switch (group.targetKind) {
     case "event":
-      return `Message ${short}`;
+      // An event id is not a pubkey identity: keep the generic hex form.
+      return `Message ${truncatePubkey(group.target)}`;
     case "pubkey":
-      return `Member ${short}`;
+      return `Member ${truncateNpub(group.target)}`;
     case "blob":
-      return `Attachment ${short}`;
+      // Blob ids are not pubkey identities either.
+      return `Attachment ${truncatePubkey(group.target)}`;
   }
 }
 
@@ -213,7 +214,7 @@ function ReporterLine({
   report: ModerationReport;
   displayName?: string | null;
 }) {
-  const who = displayName?.trim() || truncatePubkey(report.reporterPubkey);
+  const who = displayName?.trim() || truncateNpub(report.reporterPubkey);
   return (
     <div className="rounded-md border border-border/50 bg-background/50 px-2.5 py-1.5">
       <div className="flex flex-wrap items-center gap-1.5 text-xs">
@@ -476,9 +477,11 @@ function AuditRow({
   action: ModerationAction;
   actorName?: string | null;
 }) {
-  const who = actorName?.trim() || truncatePubkey(action.actorPubkey);
+  const who = actorName?.trim() || truncateNpub(action.actorPubkey);
+  // Actor and member targets are pubkey identities; a targeted event keeps
+  // the generic hex truncation for its event id.
   const targetShort = action.targetPubkey
-    ? truncatePubkey(action.targetPubkey)
+    ? truncateNpub(action.targetPubkey)
     : action.targetEventId
       ? truncatePubkey(action.targetEventId)
       : null;
diff --git a/desktop/src/features/sidebar/ui/ChannelActivityPopover.tsx b/desktop/src/features/sidebar/ui/ChannelActivityPopover.tsx
index 34fdba0bdfe..1eea8e21789 100644
--- a/desktop/src/features/sidebar/ui/ChannelActivityPopover.tsx
+++ b/desktop/src/features/sidebar/ui/ChannelActivityPopover.tsx
@@ -13,7 +13,7 @@ import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { useRemindLater } from "@/features/reminders/ui/RemindMeLaterProvider";
 import { useIdentityQuery } from "@/shared/api/hooks";
 import type { Channel, FeedItem, HomeFeedResponse } from "@/shared/api/types";
-import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { normalizePubkey, truncateNpub } from "@/shared/lib/pubkey";
 import { useNow } from "@/shared/lib/useNow";
 import { Markdown } from "@/shared/ui/markdown";
 import {
@@ -150,12 +150,15 @@ function ThreadPreviewRow({
 function WorkingAgentRow({
   avatarUrl,
   elapsed,
+  initialsLabel,
   name,
   onOpen,
   pubkey,
 }: {
   avatarUrl: string | null;
   elapsed: string;
+  /** Unprefixed key (or authored name) the avatar derives initials from. */
+  initialsLabel: string;
   name: string;
   onOpen: () => void;
   pubkey: string;
@@ -171,6 +174,7 @@ function WorkingAgentRow({
         avatarUrl={avatarUrl}
         className="h-9 w-9 shrink-0"
         displayName={name}
+        initialsLabel={initialsLabel}
         shape="squircle"
         size="md"
       />
@@ -192,7 +196,12 @@ function WorkingAgentRow({
   );
 }
 
-function WorkingAgentRows({
+/**
+ * Working-agent rows for the channel activity popover. Exported for consumer
+ * tests: it owns the generated `Agent npub1…` fallback label that flows into
+ * `UserAvatar` initials.
+ */
+export function WorkingAgentRows({
   activeWorking,
   channelId,
   onOpen,
@@ -212,14 +221,15 @@ function WorkingAgentRows({
 
   return activeWorking.agentPubkeys.map((pubkey, index) => {
     const profile = profiles?.[normalizePubkey(pubkey)];
-    const name =
-      profile?.displayName?.trim() ||
-      alignedAgentNames?.[index] ||
-      `Agent ${truncatePubkey(pubkey)}`;
+    const authoredName =
+      profile?.displayName?.trim() || alignedAgentNames?.[index];
+    const keyLabel = truncateNpub(pubkey);
+    const name = authoredName || `Agent ${keyLabel}`;
     return (
       <WorkingAgentRow
         avatarUrl={profile?.avatarUrl ?? null}
         elapsed={elapsed}
+        initialsLabel={authoredName || keyLabel}
         key={pubkey}
         name={name}
         onOpen={() => onOpen(pubkey, channelId)}
diff --git a/desktop/src/features/workflows/ui/WorkflowAuthorPicker.tsx b/desktop/src/features/workflows/ui/WorkflowAuthorPicker.tsx
index 9d6bdddc005..6550845295d 100644
--- a/desktop/src/features/workflows/ui/WorkflowAuthorPicker.tsx
+++ b/desktop/src/features/workflows/ui/WorkflowAuthorPicker.tsx
@@ -10,7 +10,7 @@ import {
 } from "@/features/profile/hooks";
 import { resolveUserLabel } from "@/features/profile/lib/identity";
 import { cn } from "@/shared/lib/cn";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { Input } from "@/shared/ui/input";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
 import {
@@ -348,7 +348,7 @@ function AuthorOption({
       <span className="min-w-0 max-w-full">
         <span className="block truncate text-sm font-medium">{label}</span>
         <span className="block truncate text-xs text-muted-foreground">
-          {truncatePubkey(candidate.pubkey)}
+          {truncateNpub(candidate.pubkey)}
         </span>
       </span>
       <Check
diff --git a/desktop/src/features/workflows/ui/workflowStepDescription.test.mjs b/desktop/src/features/workflows/ui/workflowStepDescription.test.mjs
index 83286334d80..bba5e719270 100644
--- a/desktop/src/features/workflows/ui/workflowStepDescription.test.mjs
+++ b/desktop/src/features/workflows/ui/workflowStepDescription.test.mjs
@@ -59,6 +59,30 @@ test("describes configured workflow steps on the canvas", () => {
     }),
     "“Build finished” to team-on-call",
   );
+  // A key destination renders its compact npub (npubEncode of the pinned
+  // hex key); a checksum-broken npub renders the neutral label, never the
+  // raw text as if it were a role.
+  const hexKey = "deadbeef".repeat(8);
+  const brokenNpub =
+    "npub1m6kmam774klwlh4dhmhaatd7al02m0h0m6kmam774klwlh4dhmhslezuzy";
+  assert.equal(
+    workflowStepDescription({
+      id: "dm",
+      action: "send_dm",
+      text: "Build finished",
+      to: hexKey,
+    }),
+    "“Build finished” to npub1m6k…zuz0",
+  );
+  assert.equal(
+    workflowStepDescription({
+      id: "dm",
+      action: "send_dm",
+      text: "Build finished",
+      to: brokenNpub,
+    }),
+    "“Build finished” to Unavailable",
+  );
   assert.equal(
     workflowStepDescription({
       id: "approval",
@@ -68,6 +92,15 @@ test("describes configured workflow steps on the canvas", () => {
     }),
     "“Ship the release?” from release-managers",
   );
+  assert.equal(
+    workflowStepDescription({
+      id: "approval",
+      action: "request_approval",
+      message: "Ship the release?",
+      from: hexKey,
+    }),
+    "“Ship the release?” from npub1m6k…zuz0",
+  );
   assert.equal(
     workflowStepDescription({
       id: "reaction",
diff --git a/desktop/src/features/workflows/ui/workflowStepDescription.ts b/desktop/src/features/workflows/ui/workflowStepDescription.ts
index 136ce026111..40697fe352f 100644
--- a/desktop/src/features/workflows/ui/workflowStepDescription.ts
+++ b/desktop/src/features/workflows/ui/workflowStepDescription.ts
@@ -1,4 +1,4 @@
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import {
   formatDurationSecondsVerbose,
   parseDurationSeconds,
@@ -20,11 +20,17 @@ function quoted(value: string | undefined): string | null {
   return normalized ? `“${normalized}”` : null;
 }
 
+// DM/approver references are pubkeys — 64-char hex in any case, or a
+// canonical lowercase npub — or freeform role/template text; only a key
+// identity renders as a key (an npub-shaped string that fails the shared
+// helper's checksum renders the neutral Unavailable, never raw text).
+const KEY_REFERENCE = /^(?:[0-9a-f]{64}|npub1[0-9a-z]+)$/i;
+
 function destination(value: string | undefined): string | null {
   const normalized = value?.trim();
   if (!normalized) return null;
-  return /^[0-9a-f]{64}$/i.test(normalized)
-    ? truncatePubkey(normalized)
+  return KEY_REFERENCE.test(normalized)
+    ? truncateNpub(normalized)
     : compact(normalized);
 }
 
diff --git a/desktop/src/features/workflows/ui/workflowTriggerDescription.test.mjs b/desktop/src/features/workflows/ui/workflowTriggerDescription.test.mjs
index 1f2d03b2382..9c96abd3539 100644
--- a/desktop/src/features/workflows/ui/workflowTriggerDescription.test.mjs
+++ b/desktop/src/features/workflows/ui/workflowTriggerDescription.test.mjs
@@ -170,6 +170,39 @@ test("describes selected trigger conditions on the workflow canvas", () => {
     ),
     "👾 reaction added by Carl to “hey yourself”",
   );
+
+  // Without a resolved label, an author renders its compact npub while the
+  // referenced message keeps the generic hex truncation — an event id, not
+  // a pubkey identity.
+  const unresolvedAuthor = "deadbeef".repeat(8);
+  assert.equal(
+    workflowTriggerDescription({
+      on: "message_posted",
+      filter: `trigger_author == "${unresolvedAuthor}"`,
+    }),
+    "Message posted by npub1m6k…zuz0",
+  );
+  assert.equal(
+    workflowTriggerDescription({
+      on: "message_posted",
+      filter: `trigger_author != "${unresolvedAuthor}"`,
+    }),
+    "Message posted by anyone except npub1m6k…zuz0",
+  );
+  assert.equal(
+    workflowTriggerDescription({
+      on: "reaction_added",
+      filter: `trigger_message_id == "${"b".repeat(64)}"`,
+    }),
+    "Reaction added to bbbbbbbb…bbbb",
+  );
+  assert.equal(
+    workflowTriggerDescription({
+      on: "reaction_added",
+      filter: `trigger_emoji == "👾" && trigger_author == "${unresolvedAuthor}" && trigger_message_id == "${"b".repeat(64)}"`,
+    }),
+    "👾 reaction added by npub1m6k…zuz0 to bbbbbbbb…bbbb",
+  );
 });
 
 test("compacts only an included emoji already rendered as the node icon", () => {
diff --git a/desktop/src/features/workflows/ui/workflowTriggerDescription.ts b/desktop/src/features/workflows/ui/workflowTriggerDescription.ts
index 51bba6c0102..a4927444974 100644
--- a/desktop/src/features/workflows/ui/workflowTriggerDescription.ts
+++ b/desktop/src/features/workflows/ui/workflowTriggerDescription.ts
@@ -1,4 +1,4 @@
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub, truncatePubkey } from "@/shared/lib/pubkey";
 import { parseConditionExpressions } from "./workflowConditionExpression";
 import { TRIGGER_LABELS } from "./workflowFormTypes";
 import type { ParsedConditionExpression } from "./workflowConditionExpression";
@@ -19,7 +19,9 @@ function authorReference(
   authorLoading?: boolean,
 ): string {
   if (authorLoading) return TRIGGER_AUTHOR_LOADING_LABEL;
-  return authorLabel ?? truncatePubkey(condition.value);
+  // The trigger author is a pubkey identity; the unresolved fallback renders
+  // the npub compact, never raw hex.
+  return authorLabel ?? truncateNpub(condition.value);
 }
 
 function quotedValue(value: string): string {
@@ -35,6 +37,8 @@ function messageReference(
   messageLoading?: boolean,
 ): string {
   if (messageLoading) return TRIGGER_MESSAGE_LOADING_LABEL;
+  // The referenced message is an event id, not a pubkey identity: it keeps
+  // the generic hex truncation.
   return messageLabel
     ? quotedValue(messageLabel)
     : truncatePubkey(condition.value);
diff --git a/desktop/src/shared/lib/initials.test.mjs b/desktop/src/shared/lib/initials.test.mjs
index 19e9f8dbcc8..634489b9245 100644
--- a/desktop/src/shared/lib/initials.test.mjs
+++ b/desktop/src/shared/lib/initials.test.mjs
@@ -19,4 +19,47 @@ describe("getInitials", () => {
   it("returns empty for a symbol-only name", () => {
     assert.equal(getInitials("()"), "");
   });
+
+  it("derives key-label initials from the compact key’s visible tail, not the npub prefix", () => {
+    // Compact npub labels every start with npub1: the tail is the only
+    // fragment that distinguishes one key-identified identity from another.
+    assert.equal(getInitials("npub1z59…zwkg"), "ZW");
+    assert.equal(getInitials("npub1m6k…zuz0"), "ZU");
+  });
+
+  it("derives full-npub initials from the same tail fragment", () => {
+    assert.equal(
+      getInitials(
+        "npub1z59jp0d24242424242424242424242424242424242424242zhwqnlzwkg",
+      ),
+      "ZW",
+    );
+  });
+
+  it("leaves authored names that merely resemble npubs on the name path", () => {
+    // Not a key-shaped label: wrong lengths, separators, or alphabet must
+    // keep the ordinary name derivation so an authored name is never
+    // re-derived as a key just for resembling one.
+    for (const [label, expected] of [
+      ["Npub1 Person", "NP"],
+      ["npub1cool handle", "NH"],
+      // Compact-label shape with a missing data character.
+      ["npub1ab…wxy", "NW"],
+      // Compact-label shape over letters outside the bech32 alphabet.
+      ["npub1bio…biob", "NB"],
+    ]) {
+      assert.equal(getInitials(label), expected);
+    }
+  });
+
+  it("requires a checksum-valid npub before deriving key-tail initials", () => {
+    // Same length and alphabet as a real npub, but the checksum does not
+    // decode: an authored lookalike must stay on the name path.
+    assert.equal(
+      getInitials(
+        "npub1z59jp0d24242424242424242424242424242424242424242zhwqnlzwkq",
+      ),
+      "N",
+    );
+  });
 });
diff --git a/desktop/src/shared/lib/initials.ts b/desktop/src/shared/lib/initials.ts
index 23dbf2ff93b..da5833086c0 100644
--- a/desktop/src/shared/lib/initials.ts
+++ b/desktop/src/shared/lib/initials.ts
@@ -1,5 +1,50 @@
+import { decode } from "nostr-tools/nip19";
+
+/**
+ * Key-form labels carry no name to abbreviate: their head is the constant
+ * `npub1` prefix, so name-derived initials would collapse every key-identified
+ * identity onto the same leading letter. A key's distinguishing fragment is
+ * its tail — the part a compact key actually shows — so derive initials from
+ * there and keep key-fallback avatars visually distinct.
+ *
+ * Detection is deliberately narrow so authored names never lose their name
+ * initials for merely resembling a key: a full label counts as a key only
+ * when it decodes as a checksum-valid npub of an identity-length key, and a
+ * compact label must match the exact `npub` + 4 + `…` + 4 truncation shape
+ * over the bech32 alphabet (the form `truncateNpub` emits). A display name
+ * that is a checksum-valid npub is indistinguishable from a real key by
+ * shape alone, and taking key-tail initials there is the safe side of that
+ * boundary.
+ */
+const BECH32_ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+const COMPACT_NPUB_KEY_LABEL = new RegExp(
+  `^npub1[${BECH32_ALPHABET}]{3}…[${BECH32_ALPHABET}]{4}$`,
+);
+const HEX_64_REGEX = /^[0-9a-f]{64}$/;
+
+function isFullNpubLabel(label: string): boolean {
+  try {
+    const decoded = decode(label);
+    return decoded.type === "npub" && HEX_64_REGEX.test(decoded.data);
+  } catch {
+    return false;
+  }
+}
+
+function keyTailInitials(name: string): string | null {
+  const trimmed = name.trim();
+  if (!COMPACT_NPUB_KEY_LABEL.test(trimmed) && !isFullNpubLabel(trimmed)) {
+    return null;
+  }
+  return trimmed.slice(-4, -2).toUpperCase();
+}
+
 /** Derive up to two uppercase initials from a display name. */
 export function getInitials(name: string): string {
+  const keyInitials = keyTailInitials(name);
+  if (keyInitials !== null) {
+    return keyInitials;
+  }
   return name
     .replace(/[^\p{L}\p{N}\s]/gu, " ")
     .trim()
diff --git a/desktop/src/shared/lib/mentionDisplay.test.mjs b/desktop/src/shared/lib/mentionDisplay.test.mjs
index 20e0f17eb0b..0f44d5131a2 100644
--- a/desktop/src/shared/lib/mentionDisplay.test.mjs
+++ b/desktop/src/shared/lib/mentionDisplay.test.mjs
@@ -1,21 +1,27 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { formatMentionDisplayLabel } from "./mentionDisplay.ts";
-import { truncatePubkey } from "./pubkey.ts";
+import {
+  formatLegacyMentionDisplayLabel,
+  formatMentionDisplayLabel,
+} from "./mentionDisplay.ts";
+import { truncateNpub, truncatePubkey } from "./pubkey.ts";
 
 const KEY = `150b20bd${"a".repeat(52)}15dc`;
+// npubEncode(KEY), pinned so a formatter regression cannot pass by
+// re-deriving the expectation from the code under test.
+const KEY_NPUB_COMPACT = "npub1z59…zwkg";
 
 test("compact mention display uses the member-list formatter and keeps collision suffixes", () => {
   for (const suffix of ["", " 2", " 10"]) {
     assert.equal(
       formatMentionDisplayLabel(`Bad Janet (${KEY})${suffix}`, KEY),
-      `Bad Janet (${truncatePubkey(KEY)})${suffix}`,
+      `Bad Janet (${truncateNpub(KEY)})${suffix}`,
     );
   }
-  assert.equal(formatMentionDisplayLabel(KEY, KEY), truncatePubkey(KEY));
+  assert.equal(formatMentionDisplayLabel(KEY, KEY), KEY_NPUB_COMPACT);
   assert.equal(
     formatMentionDisplayLabel(KEY.toUpperCase(), KEY),
-    truncatePubkey(KEY.toUpperCase()),
+    KEY_NPUB_COMPACT,
   );
 });
 
@@ -32,10 +38,23 @@ test("display leaves unbound, mismatched, malformed and ordinary labels literal"
     assert.equal(formatMentionDisplayLabel(label, key), label);
 });
 
+test("legacy display keeps the retired hex compaction byte-exact for clipboard validation", () => {
+  for (const suffix of ["", " 2", " 10"]) {
+    assert.equal(
+      formatLegacyMentionDisplayLabel(`Bad Janet (${KEY})${suffix}`, KEY),
+      `Bad Janet (${truncatePubkey(KEY)})${suffix}`,
+    );
+  }
+  assert.equal(formatLegacyMentionDisplayLabel(KEY, KEY), truncatePubkey(KEY));
+});
+
 test("matching compact keys do not become identity keys", () => {
   const other = KEY.replace("aaaa", "bbbb");
   assert.notEqual(KEY, other);
-  assert.equal(
+  // The two keys collide under the old hex first8…last4 truncation yet
+  // compact to distinguishable npubs: npub display keeps them apart.
+  assert.equal(truncatePubkey(KEY), truncatePubkey(other));
+  assert.notEqual(
     formatMentionDisplayLabel(`Scout (${KEY})`, KEY),
     formatMentionDisplayLabel(`Scout (${other})`, other),
   );
diff --git a/desktop/src/shared/lib/mentionDisplay.ts b/desktop/src/shared/lib/mentionDisplay.ts
index 10d15643ad4..ec8a199efad 100644
--- a/desktop/src/shared/lib/mentionDisplay.ts
+++ b/desktop/src/shared/lib/mentionDisplay.ts
@@ -1,17 +1,40 @@
-import { truncatePubkey } from "./pubkey";
+import { truncateNpub, truncatePubkey } from "./pubkey";
 
-/** Compact only a bound mention's key; its literal label remains authoritative. */
-export function formatMentionDisplayLabel(
+type KeyCompaction = (key: string) => string;
+
+function compactMentionDisplayLabel(
   label: string,
   pubkey: string | undefined,
+  compactKey: KeyCompaction,
 ): string {
   if (!pubkey || !/^[0-9a-f]{64}$/i.test(pubkey)) return label;
   if (label.toLowerCase() === pubkey.toLowerCase()) {
-    return truncatePubkey(label);
+    return compactKey(label);
   }
   const qualified = label.match(
     /^(.*) \(([0-9a-f]{64})\)((?: (?:[2-9]|[1-9][0-9]+))?)$/i,
   );
   if (qualified?.[2].toLowerCase() !== pubkey.toLowerCase()) return label;
-  return `${qualified[1]} (${truncatePubkey(qualified[2])})${qualified[3]}`;
+  return `${qualified[1]} (${compactKey(qualified[2])})${qualified[3]}`;
+}
+
+/** Compact only a bound mention's key; its literal label remains authoritative. */
+export function formatMentionDisplayLabel(
+  label: string,
+  pubkey: string | undefined,
+): string {
+  return compactMentionDisplayLabel(label, pubkey, truncateNpub);
+}
+
+/**
+ * The pre-npub key compaction a chip rendered before keys displayed as npub.
+ * Retired from rendering; kept byte-exact so clipboard validation can still
+ * recognize whole chips copied by an older Buzz, re-binding them to the exact
+ * identity their record declares instead of degrading them to plain text.
+ */
+export function formatLegacyMentionDisplayLabel(
+  label: string,
+  pubkey: string | undefined,
+): string {
+  return compactMentionDisplayLabel(label, pubkey, truncatePubkey);
 }
diff --git a/desktop/src/shared/ui/UserAvatar.tsx b/desktop/src/shared/ui/UserAvatar.tsx
index 1b47bc4c92c..0398ea2ccd9 100644
--- a/desktop/src/shared/ui/UserAvatar.tsx
+++ b/desktop/src/shared/ui/UserAvatar.tsx
@@ -35,6 +35,17 @@ function fallbackColorClass(displayName: string) {
 type UserAvatarProps = {
   avatarUrl: string | null;
   displayName: string;
+  /**
+   * Label used to derive fallback initials; defaults to `displayName`.
+   *
+   * Callers whose `displayName` is a generated role-prefixed key fallback
+   * ("Agent npub1abcd…wxyz") pass the unprefixed compact key here:
+   * word-initials would collapse every unnamed identity onto "AN"/"PN",
+   * while the compact key keeps distinct key-tail initials. Authored
+   * display names keep their name initials. The fallback color keeps
+   * hashing `displayName`, which still contains the key.
+   */
+  initialsLabel?: string;
   size?: UserAvatarSize;
   accent?: boolean;
   shape?: "circle" | "squircle";
@@ -47,6 +58,7 @@ type UserAvatarProps = {
 export function UserAvatar({
   avatarUrl,
   displayName,
+  initialsLabel,
   size = "md",
   accent = false,
   shape,
@@ -55,7 +67,7 @@ export function UserAvatar({
   imageDraggable,
   testId,
 }: UserAvatarProps) {
-  const initials = getInitials(displayName);
+  const initials = getInitials(initialsLabel ?? displayName);
   // Animated avatars show their static poster frame until hovered, then play
   // the animation.
   const animated = parseAnimatedAvatarUrl(avatarUrl);
diff --git a/desktop/src/shared/ui/markdown/useMessageLinkMetadata.ts b/desktop/src/shared/ui/markdown/useMessageLinkMetadata.ts
index 7a051743344..8977c1bc4c6 100644
--- a/desktop/src/shared/ui/markdown/useMessageLinkMetadata.ts
+++ b/desktop/src/shared/ui/markdown/useMessageLinkMetadata.ts
@@ -4,7 +4,7 @@ import type { ParsedMessageLink } from "@/features/messages/lib/messageLink";
 import { summarizeMessageLinkContent } from "@/features/messages/lib/messageLinkMetadata";
 import { getEventById } from "@/shared/api/tauri";
 import { getUserProfile } from "@/shared/api/tauriProfiles";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { isDefinitiveEventNotFound } from "@/shared/lib/eventLookupError";
 
 const MESSAGE_METADATA_RETRY_DELAY_MS = 750;
@@ -70,7 +70,7 @@ function fetchMetadata(
           author:
             profile?.displayName?.trim() ||
             profile?.nip05Handle?.trim() ||
-            truncatePubkey(event.pubkey),
+            truncateNpub(event.pubkey),
           createdAt: event.created_at,
           snippet: summarizeMessageLinkContent(event.content),
         };
diff --git a/desktop/src/shared/ui/markdownMentionDisplay.test.mjs b/desktop/src/shared/ui/markdownMentionDisplay.test.mjs
index bf96caeee00..5f9fe6b1126 100644
--- a/desktop/src/shared/ui/markdownMentionDisplay.test.mjs
+++ b/desktop/src/shared/ui/markdownMentionDisplay.test.mjs
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import React from "react";
 import { renderToStaticMarkup } from "react-dom/server";
-import { truncatePubkey } from "../lib/pubkey.ts";
+import { truncateNpub } from "../lib/pubkey.ts";
 import { createMarkdownComponents } from "./markdown.tsx";
 import { renderCachedMarkdown } from "./markdown/nodeCache.ts";
 import { MarkdownRuntimeContext } from "./markdown/runtimeContext.ts";
@@ -33,7 +33,7 @@ for (const agent of [false, true]) {
     );
     assert.equal(
       html.replace(/<[^>]+>/g, ""),
-      `Ask Scout (${truncatePubkey(KEY)}) 2`,
+      `Ask Scout (${truncateNpub(KEY)}) 2`,
     );
     assert.ok(html.includes(`data-mention-label="${label}"`));
     assert.ok(html.includes(`data-mention-pubkey="${KEY}"`));
diff --git a/desktop/tests/e2e/channel-activity-popover.spec.ts b/desktop/tests/e2e/channel-activity-popover.spec.ts
index 0e6caac7762..59d46804615 100644
--- a/desktop/tests/e2e/channel-activity-popover.spec.ts
+++ b/desktop/tests/e2e/channel-activity-popover.spec.ts
@@ -344,6 +344,12 @@ test.describe("channel activity hover preview", () => {
     await expect(
       popover.getByTestId(`channel-activity-agent-${AGENT_PUBKEY}`),
     ).toContainText("Charlie");
+    // The authored name also supplies the row avatar's initials.
+    await expect(
+      popover
+        .getByTestId(`channel-activity-agent-${AGENT_PUBKEY}`)
+        .getByText("C", { exact: true }),
+    ).toBeVisible();
     await expect(
       popover.getByTestId(`channel-activity-agent-${AGENT_PUBKEY}`),
     ).toContainText("Working");
@@ -372,6 +378,56 @@ test.describe("channel activity hover preview", () => {
     await expect(threadPanel).toContainText("direct thread link");
   });
 
+  test("unnamed working agents keep distinct key-tail initials, not AN", async ({
+    page,
+  }) => {
+    // npubEncode of the fixture keys: "a"×64 → npub1424…rcaj (tail RC),
+    // "b"×64 → npub1hwa…04hu (tail 04). Neither has a seeded profile, so
+    // the rows show the generated "Agent npub1…" fallback label.
+    const unnamedAgents = [
+      { initials: "RC", label: "Agent npub1424…rcaj", pubkey: "a".repeat(64) },
+      { initials: "04", label: "Agent npub1hwa…04hu", pubkey: "b".repeat(64) },
+    ];
+
+    await page.goto("/");
+    await page.waitForFunction(
+      () =>
+        typeof (window as Window & { __BUZZ_E2E_SEED_ACTIVE_TURNS__?: unknown })
+          .__BUZZ_E2E_SEED_ACTIVE_TURNS__ === "function",
+    );
+    for (const { pubkey } of unnamedAgents) {
+      await page.evaluate(
+        ({ agentPubkey, channelId }) => {
+          (
+            window as Window & {
+              __BUZZ_E2E_SEED_ACTIVE_TURNS__?: (input: {
+                agentPubkey: string;
+                channelId: string;
+                turnId: string;
+              }) => void;
+            }
+          ).__BUZZ_E2E_SEED_ACTIVE_TURNS__?.({
+            agentPubkey,
+            channelId,
+            turnId: "unnamed-agent-initials",
+          });
+        },
+        { agentPubkey: pubkey, channelId: CHANNEL_GENERAL },
+      );
+    }
+
+    const popover = await openActivityPopover(page);
+    for (const { initials, label, pubkey } of unnamedAgents) {
+      const row = popover.getByTestId(`channel-activity-agent-${pubkey}`);
+      await expect(row).toContainText(label);
+      // The avatar abbreviates its key's visible tail (UserAvatar's fallback
+      // settles after its 200ms delay; expect retries past it), never the
+      // "Agent" word initials of the prefixed label.
+      await expect(row.getByText(initials, { exact: true })).toBeVisible();
+      await expect(row.getByText("AN", { exact: true })).toHaveCount(0);
+    }
+  });
+
   test("removes the dot and preview after the final activity is read", async ({
     page,
   }) => {
diff --git a/desktop/tests/e2e/channels.spec.ts b/desktop/tests/e2e/channels.spec.ts
index f9fd6dca58b..371cffdfb0b 100644
--- a/desktop/tests/e2e/channels.spec.ts
+++ b/desktop/tests/e2e/channels.spec.ts
@@ -4176,8 +4176,26 @@ test("members sidebar virtualizes large channel rosters", async ({ page }) => {
   await expect(memberRows.first()).toBeVisible();
   expect(await memberRows.count()).toBeLessThan(50);
 
+  // Generated members have no display name, so the roster sorts them by
+  // their npub fallback label: these sequential pubkeys share a `npub1qqq…`
+  // prefix and order by the checksum tail, not their numeric value. Resolve
+  // a generated member from the rows the initial window actually rendered
+  // instead of assuming `pubkeys[0]` sorts into that window.
+  const generatedPubkeySet = new Set(pubkeys);
+  const renderedPubkeys = await memberRows.evaluateAll((rows) =>
+    rows.map(
+      (row) =>
+        (row as HTMLElement).dataset.testid?.slice("sidebar-member-".length) ??
+        "",
+    ),
+  );
+  const firstRenderedGeneratedPubkey = renderedPubkeys.find((pubkey) =>
+    generatedPubkeySet.has(pubkey),
+  );
+  expect(firstRenderedGeneratedPubkey).toBeTruthy();
+
   const firstGeneratedRow = memberList.getByTestId(
-    `sidebar-member-${pubkeys[0]}`,
+    `sidebar-member-${firstRenderedGeneratedPubkey}`,
   );
   await expect
     .poll(() =>
@@ -4214,8 +4232,24 @@ test("members sidebar virtualizes large channel rosters", async ({ page }) => {
     element.scrollTop = element.scrollHeight;
     element.dispatchEvent(new Event("scroll"));
   });
-  await expect(
-    memberList.getByTestId(`sidebar-member-${pubkeys.at(-1)}`),
+  // Fully scrolling must render the roster's true tail, and the tail
+  // endpoint must be known independently of whatever the virtual window
+  // happens to render. The sidebar's own roster accounting — the
+  // "Members · N" header — must read exactly the fixture-known total
+  // ("random" seeds alice, the mock identity, and bob; this test adds the
+  // 500 generated pubkeys on top), so fixture or classification drift
+  // fails loudly here instead of silently weakening the tail check.
+  const rosterCount = 3 + pubkeys.length;
+  await expect(memberList.getByText(/^Members · \d+$/)).toHaveText(
+    `Members · ${rosterCount}`,
+  );
+  // VirtualizedList stamps each rendered row with its item index, so the
+  // final item's row is a fixed target that no window sample can pick in
+  // its place: a virtualizer clamped mid-roster never renders it.
+  await expect(
+    memberList.locator(
+      `[data-index="${rosterCount - 1}"] > [data-testid^="sidebar-member-"]`,
+    ),
   ).toBeVisible();
 });
 
diff --git a/desktop/tests/e2e/huddle-transcription.spec.ts b/desktop/tests/e2e/huddle-transcription.spec.ts
index 7c56648654a..32b4bcde56a 100644
--- a/desktop/tests/e2e/huddle-transcription.spec.ts
+++ b/desktop/tests/e2e/huddle-transcription.spec.ts
@@ -4,6 +4,7 @@ import {
   KIND_HUDDLE_ENDED,
   KIND_HUDDLE_STARTED,
 } from "../../src/shared/constants/kinds";
+import { truncateNpub } from "../../src/shared/lib/pubkey";
 import { waitForAnimations } from "../helpers/animations";
 import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
 
@@ -11,6 +12,15 @@ const HUDDLE_CHANNEL_ID = "11111111-1111-4111-8111-111111111111";
 const HUDDLE_PARENT_ID = "9a1657ac-f7aa-5db0-b632-d8bbeb6dfb50";
 const HUDDLE_THREAD_ROOT_ID = "mock-general-welcome";
 
+/**
+ * Initials a key-fallback avatar shows: the two characters just before the
+ * compact npub label's visible tail — the fragment `getInitials` reads from
+ * a key label, whose unit suite pins the derivation itself.
+ */
+function keyTailInitials(pubkey: string) {
+  return truncateNpub(pubkey).slice(-4, -2).toUpperCase();
+}
+
 async function waitForMockLiveSubscription(
   page: import("@playwright/test").Page,
   channelName: string,
@@ -1075,10 +1085,19 @@ test("returns to the parent channel when leaving a huddle channel in view", asyn
 test("keeps the huddle avatar strip compact and exposes the full roster", async ({
   page,
 }) => {
-  const members = Array.from({ length: 11 }, (_, index) => ({
+  // One named member plus ten key-only members (hex 01..0a + "a"×62), with
+  // the last as the huddle bot. The generated keys' npub tails are what
+  // key-fallback avatars abbreviate: 01… → npub1qx4…x2tc → X2,
+  // 02… → npub1q24…levs → LE, 0a… → npub1p24…sqjt → SQ.
+  const namedMember = "77".repeat(32);
+  const unnamedMembers = Array.from({ length: 10 }, (_, index) => ({
     pubkey: `${(index + 1).toString(16).padStart(2, "0")}${"a".repeat(62)}`,
-    role: index === 10 ? ("bot" as const) : ("member" as const),
+    role: index === 9 ? ("bot" as const) : ("member" as const),
   }));
+  const members = [
+    { pubkey: namedMember, role: "member" as const },
+    ...unnamedMembers,
+  ];
 
   await installMockBridge(page, {
     huddle: {
@@ -1086,6 +1105,7 @@ test("keeps the huddle avatar strip compact and exposes the full roster", async
       ephemeralChannelId: HUDDLE_CHANNEL_ID,
       members,
     },
+    searchProfiles: [{ pubkey: namedMember, displayName: "Ada Lovelace" }],
   });
   await page.goto("/");
 
@@ -1100,13 +1120,44 @@ test("keeps the huddle avatar strip compact and exposes the full roster", async
   await expect(participantTrigger).toContainText("+2");
   await expect(page.getByTestId("profile-huddle-control")).toHaveCount(0);
 
+  // Strip avatars stay distinct: the named member keeps name initials
+  // (AL), and a key-only participant shows its npub's tail (X2), never the
+  // word initials of the "Participant npub1…" label (PN).
+  const stripAvatars = participantStrip.getByTestId(
+    "huddle-participant-avatar",
+  );
+  await expect(stripAvatars.first()).toHaveText("AL");
+  await expect(stripAvatars.nth(1)).toHaveText(
+    keyTailInitials(unnamedMembers[0].pubkey),
+  );
+
   await participantTrigger.click();
+  const roster = page
+    .getByRole("dialog")
+    .filter({ has: page.getByRole("heading", { name: "Participants" }) });
   await expect(
     page.getByRole("heading", { name: "Participants" }),
   ).toBeVisible();
+  const rosterRows = roster.getByRole("listitem");
+  // Visible labels keep their generated forms alongside the avatar initials.
+  await expect(rosterRows.filter({ hasText: "Ada Lovelace" })).toHaveCount(1);
+  await expect(
+    rosterRows.filter({
+      hasText: `Participant ${truncateNpub(unnamedMembers[0].pubkey)}`,
+    }),
+  ).toHaveCount(1);
+  const agentRow = rosterRows.filter({
+    hasText: `Agent ${truncateNpub(unnamedMembers[9].pubkey)}`,
+  });
+  await expect(agentRow).toHaveCount(1);
   await expect(
     page.getByRole("button", { name: /Remove Agent .* from huddle/ }),
   ).toHaveCount(1);
+  // The roster's agent avatar abbreviates its key tail (SQ), never the
+  // "Agent" word initials of the prefixed label (AN).
+  await expect(agentRow.getByTestId("huddle-participant-avatar")).toHaveText(
+    keyTailInitials(unnamedMembers[9].pubkey),
+  );
 });
 
 test("removes an agent from its menu without showing an extra participant control", async ({
diff --git a/desktop/tests/e2e/mention-recipients.spec.ts b/desktop/tests/e2e/mention-recipients.spec.ts
index 0e29ed49327..0b81596780f 100644
--- a/desktop/tests/e2e/mention-recipients.spec.ts
+++ b/desktop/tests/e2e/mention-recipients.spec.ts
@@ -1,5 +1,5 @@
 import { expect, test, type Page } from "@playwright/test";
-import { truncatePubkey } from "../../src/shared/lib/pubkey";
+import { truncateNpub } from "../../src/shared/lib/pubkey";
 import { waitForAnimations } from "../helpers/animations";
 import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
 
@@ -566,7 +566,7 @@ for (const { kind, scale } of [
       .last();
     await assertFits(markdown, "sent");
     const qualifiedChip = row.locator("[data-mention]").last();
-    await expect(qualifiedChip).toHaveText(`Scout (${truncatePubkey(SECOND)})`);
+    await expect(qualifiedChip).toHaveText(`Scout (${truncateNpub(SECOND)})`);
     await expect(qualifiedChip).toHaveAttribute(
       "data-mention-label",
       `Scout (${SECOND})`,
@@ -873,7 +873,7 @@ for (const mismatchedKey of [false, true]) {
       .getByTestId("message-row")
       .filter({ hasText: "qualified clipboard roundtrip" })
       .locator(`[data-mention-pubkey="${SECOND}"]`);
-    await expect(chip).toHaveText(`Scout (${truncatePubkey(SECOND)})`);
+    await expect(chip).toHaveText(`Scout (${truncateNpub(SECOND)})`);
     const flavors = await chip.evaluate((element) => {
       const range = document.createRange();
       range.selectNode(element);
@@ -956,7 +956,7 @@ for (const partial of [false, true]) {
       .filter({ hasText: "compact collision" });
     for (const key of keys) {
       const chip = row.locator(`[data-mention-pubkey="${key}"]`);
-      await expect(chip).toHaveText(`Scout (${truncatePubkey(key)})`);
+      await expect(chip).toHaveText(`Scout (${truncateNpub(key)})`);
       await expect(chip).toHaveAttribute("title", `Scout (${key})`);
       const flavors = await chip.evaluate((element, partial) => {
         const range = document.createRange();
diff --git a/desktop/tests/e2e/mentions.spec.ts b/desktop/tests/e2e/mentions.spec.ts
index e9248509fd1..ee3731d16d7 100644
--- a/desktop/tests/e2e/mentions.spec.ts
+++ b/desktop/tests/e2e/mentions.spec.ts
@@ -1,6 +1,6 @@
 import { expect, test } from "@playwright/test";
-import { npubEncode } from "nostr-tools/nip19";
 
+import { truncateNpub } from "../../src/shared/lib/pubkey";
 import { waitForAnimations } from "../helpers/animations";
 
 import {
@@ -4535,9 +4535,8 @@ test("clicking author name opens user profile panel", async ({ page }) => {
   // Click now opens the full profile panel instead of the popover
   const panel = page.getByTestId("user-profile-panel");
   await expect(panel).toBeVisible();
-  // The panel's public key row renders through the shared <PubKey> widget,
-  // which displays the canonical npub form — assert the npub prefix.
-  await expect(panel).toContainText(npubEncode(MOCK_VIEWER_PUBKEY).slice(0, 8));
+  await expect(panel).toContainText(truncateNpub(MOCK_VIEWER_PUBKEY));
+  await expect(panel).not.toContainText("deadbeefdeadbeef");
 });
 
 test("hovering avatar opens popover, clicking opens profile panel", async ({
@@ -4760,7 +4759,7 @@ test("agent profile popover falls back to the owner's pubkey", async ({
     profilePopover.getByTestId(
       `user-profile-popover-owner-${OWNED_AGENT_PROFILE_PUBKEY}`,
     ),
-  ).toHaveText("managed by 11111111…1111");
+  ).toHaveText(`managed by ${truncateNpub(CASEY_PROFILE_PUBKEY)}`);
 });
 
 test("human profile popover does not show an owner", async ({ page }) => {
diff --git a/desktop/tests/e2e/pubkey-display-screenshots.spec.ts b/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
index 81ff86c3299..8dbdbad005f 100644
--- a/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
+++ b/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
@@ -1,12 +1,13 @@
 import { expect, test } from "@playwright/test";
 import { npubEncode } from "nostr-tools/nip19";
 
+import { truncateNpub } from "../../src/shared/lib/pubkey";
+import { waitForAnimations } from "../helpers/animations";
 import {
   installMockBridge,
   openNewMessagePage,
   TEST_IDENTITIES,
 } from "../helpers/bridge";
-import { waitForAnimations } from "../helpers/animations";
 
 const SHOTS = "test-results/pubkey-display";
 
@@ -121,7 +122,7 @@ test("new-DM agent name swaps to its public key on name hover", async ({
     )
     .toBe(true);
   await expect(settledAgentNpub).not.toHaveCSS("opacity", "0");
-  await expect(settledAgentNpub).toHaveText("cafef00d…f00d");
+  await expect(settledAgentNpub).toHaveText(truncateNpub(AGENT_PUBKEY));
   await expect(
     settledAgentName.getByText("Pinky", { exact: true }),
   ).not.toHaveCSS("opacity", "1");
@@ -159,7 +160,7 @@ test("selected new-DM recipient can be verified again through search", async ({
   await charlieName.hover();
   await expect(charlieNpub).toHaveCSS("opacity", "1");
   await expect(charlieNpub).toHaveText(
-    `${TEST_IDENTITIES.charlie.pubkey.slice(0, 8)}…${TEST_IDENTITIES.charlie.pubkey.slice(-4)}`,
+    truncateNpub(TEST_IDENTITIES.charlie.pubkey),
   );
   await page.mouse.move(1_100, 500);
   await expect(charlieNpub).toHaveCSS("opacity", "0");
@@ -262,7 +263,7 @@ test("selected new-DM recipient can be verified again through search", async ({
   await charlieName.hover();
   await expect(charlieNpub).toHaveCSS("opacity", "1");
   await expect(charlieNpub).toHaveText(
-    `${TEST_IDENTITIES.charlie.pubkey.slice(0, 8)}…${TEST_IDENTITIES.charlie.pubkey.slice(-4)}`,
+    truncateNpub(TEST_IDENTITIES.charlie.pubkey),
   );
   await expect(charlieName.getByText("charlie", { exact: true })).toHaveCSS(
     "opacity",
diff --git a/desktop/tests/e2e/workflow-local-controls.spec.ts b/desktop/tests/e2e/workflow-local-controls.spec.ts
index 6a8319082c8..bf3aca2e2d2 100644
--- a/desktop/tests/e2e/workflow-local-controls.spec.ts
+++ b/desktop/tests/e2e/workflow-local-controls.spec.ts
@@ -1,6 +1,7 @@
 import { expect, test } from "@playwright/test";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
+import { truncateNpub } from "../../src/shared/lib/pubkey";
 import { waitForAnimations } from "../helpers/animations";
 import { installMockBridge } from "../helpers/bridge";
 
@@ -63,7 +64,9 @@ async function addMessageStep(
 ) {
   await dialog.getByRole("button", { name: "Add step", exact: true }).click();
   await page.getByRole("menuitem", { name: "Send Message" }).click();
-  await dialog.getByLabel("Message text").fill("Workflow notification");
+  await dialog
+    .locator('textarea[id^="wf-step-"][id$="-text"]')
+    .fill("Workflow notification");
 }
 
 async function createEnabled(
@@ -152,7 +155,7 @@ test("inserts template variables with keyboard control and restores the caret",
   await dialog.getByRole("button", { name: "Add step", exact: true }).click();
   await page.getByRole("menuitem", { name: "Send Message" }).click();
 
-  const textarea = dialog.getByLabel("Message text");
+  const textarea = dialog.locator('textarea[id^="wf-step-"][id$="-text"]');
   const listbox = page.getByRole("listbox");
   await textarea.fill("Hello {{trig");
   await expect(listbox).toBeVisible();
@@ -286,6 +289,7 @@ test("round-trips and reopens structured message-text conditions", async ({
 
   await dialog.getByRole("tab", { name: "Form" }).click();
   await openTriggerInspector(dialog);
+  await waitForAnimations(page);
   const matchControls = dialog.getByRole("group", { name: "Match" });
   const operatorButtons = matchControls.getByRole("button");
   const firstOperatorBox = await operatorButtons.nth(0).boundingBox();
@@ -640,11 +644,11 @@ test("round-trips manual author and reaction message IDs through save and reopen
   });
   await authorSearch.fill(author);
   await expect(
-    dialog.getByRole("option", { name: new RegExp(author.slice(0, 8)) }),
+    dialog.getByRole("option", { name: truncateNpub(author) }),
   ).toBeVisible();
   await authorSearch.press("Enter");
   await expect(
-    dialog.getByRole("option", { name: new RegExp(author.slice(0, 8)) }),
+    dialog.getByRole("option", { name: truncateNpub(author) }),
   ).toHaveAttribute("aria-selected", "true");
   await expect(dialog.getByRole("button", { name: "Create" })).toBeEnabled();
   await dialog.getByRole("tab", { name: "YAML" }).click();
@@ -663,7 +667,7 @@ test("round-trips manual author and reaction message IDs through save and reopen
   });
   await correctedAuthorSearch.fill(author);
   await expect(
-    dialog.getByRole("option", { name: new RegExp(author.slice(0, 8)) }),
+    dialog.getByRole("option", { name: truncateNpub(author) }),
   ).toBeVisible();
   await correctedAuthorSearch.press("Enter");
   await dialog
@@ -697,7 +701,7 @@ test("round-trips manual author and reaction message IDs through save and reopen
   await openTriggerInspector(reopened);
   await reopened.getByText("Author", { exact: true }).locator("..").click();
   await expect(
-    reopened.getByRole("option", { name: new RegExp(author.slice(0, 8)) }),
+    reopened.getByRole("option", { name: truncateNpub(author) }),
   ).toHaveAttribute("aria-selected", "true");
   await reopened.getByText("Message", { exact: true }).locator("..").click();
   await expect(
@@ -738,7 +742,7 @@ test("toggles selected author and message filters while preserving sibling condi
     .locator("..");
   await authorField.getByText("Author", { exact: true }).locator("..").click();
   const authorOption = dialog.getByRole("option", {
-    name: new RegExp(author.slice(0, 8)),
+    name: truncateNpub(author),
   });
   await expect(authorOption).toHaveAttribute("aria-selected", "true");
   await expect(
@@ -751,7 +755,7 @@ test("toggles selected author and message filters while preserving sibling condi
   });
   await authorSearch.fill(replacementAuthor);
   const replacementAuthorOption = dialog.getByRole("option", {
-    name: new RegExp(replacementAuthor.slice(0, 8)),
+    name: truncateNpub(replacementAuthor),
   });
   await expect(replacementAuthorOption).toBeVisible();
   await authorSearch.press("Enter");
diff --git a/desktop/tests/e2e/workflow-local-controls.spec.ts-snapshots/workflow-template-variable-autocomplete-smoke-darwin.png b/desktop/tests/e2e/workflow-local-controls.spec.ts-snapshots/workflow-template-variable-autocomplete-smoke-darwin.png
index 54cc63d5b2a520a9fe9aff54caff40b69d25909f..f0826431ce64832ad04ab2ecdc829a2eacba214d 100644
GIT binary patch
literal 103906
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
MGOE&5AIv`gA05Rw@&Et;

literal 104623
zcmZ^KWk6Kj_w^{E(nv~6OG*tL64Id3J>(EWcZUKBsFZYxl;j{ibmt5WLx*%r!%*-1
z9`*n2y<fP%%(>_6bN1eAt-Wu=8+8RdY)WhZ0Dz~YD5n7cV4`pD4?n(-{_&Dd`5pj3
z2vCxf*78o@&3I%=@`@_l`aEvf?|>%ne4*{($B)60zb&L+NfSPK@Z{}-CqKza9=!T#
zdav-^Gqv1v2DQ`^6Im5l#@%env@3I8UNDwVmi-yn+S>Y@yU%LTujP`(ek|XK0{yK2
zF6ZJL{(tw+XaM(c|NipK`2TlL*d2^B_#O$N#Q6Ksn0%#!`@-B^R6+ckW`F;t=$5N_
z4?a;_%p%QP!i%WowdDExpImyGC#|)?gU4@c9ZMleB2l0RX?D7MHD8^n`ShZ88nI%R
zcHr?|!v8)FX_w)Vbh>90Iib@ySI}R(L{0wtgo}AMv8|{CQw%zm;nWktMJyL3iy@2p
zp9Rs^%l6zHLK~@5jxKIp0@Xm?TIERrwTYCXq-|p`G_I{EJk?g(>PKF_PkEHt7k514
z_J{1IYDSO$t%vZ18E1fAYfVuCW}!FiW=W%6@{#@|x02bhp{;2VkQo}yF33SmTB4q?
z1Swvvwx`@kHup;Qbml5$!^5TdXF!)&Zfeu4UT|R`hUqAQr@c8sVI%Spg3r*QX$u;X
z^17;eXSa=eK$rWGhpTbZ?+01gm!;AV|IXp1bGxGtY?bcPz7QlEFiTJa&~Z@XV$&*T
zX;C_Jz1$2$_yfyv!@=Uch4TcXI_r`a5mql8@u>YzoP$#*ug`4NF`ob3ikB$*wx@HU
zG)oT}6giwZxKkQP%FUb)*YHDiY*JkV=A)W4J#B&RX|<BuNK)TD;#ST%E3xDmD@;fr
zMe%$F4C0?AEK=vMb;@;I`FD1~tMTe_rux5PiwSKybXvlVW{;3MKT@BLLL@geuy$0>
z4|K*jGYT))+g$UK!DX#>wLr)g2yr*{jXdjHioH&q*z)fn^fCY6)%wBE7|<Y>V_@`<
z#})+D-86+&;F_vUx1{FB(-%{;UooFTVxCUYkaE7yO2PhG)1FltUr(fVg=H#|uZQ{i
z3SxSNU3U<_bPscScxJpR*m8Wh^}m4ufF*``)%UBtplXJ$9c}#bP#mp`a;+9oq<t5}
zd9;<Xny)r*W|jR&ud*xOubj7XqNbl4al<O5QK7w}jPWQ-DdO@6C@a*YUxBR2+3O{+
z>c!u2FXF$f-vcXS;;7lBHXGps&U|SuImYxO*rG$<G5s9CBfYZcDT8PX^kYQ}Zz#8-
z2Bj@~3}?5KI52lV0q{?vQ)VmhM2C@N6Z?W+&Z?QJ7QdN4<ob7PShg%EnR=wFUEgA1
z+0V3^_&qJp&dsAdFHVcpwF4XfFe9ors;kxrEut)x5OEW$n>$O(_z1Z&FhZ_~9YS4W
zZsJ8bo(u$3*tzK1*FOHP6HhoRU*)G^e$n=K_N}AQ7`tTOYOw5|zet{@AN~|k_)!2c
zoHq~Y7EzfWSj|Z;?)7SCP`R102;Lj3`v7PVC{Hy=hE)ndut4JHm#$|9^y9Z<&o4dh
z;r*So;$m(Aq0N4BYx*pHsl{l$KoKEKM%R_jOZO{mynXUPYY2T0T;y|wlgNgoY_L^K
z^)@nNq@OjxeeQK<V3mV~ms3prpV<YUJbrB&^!UDTHn)a|BqJDhfS+{afn_?d>#?Ed
z$+1K@xS5uxOu9=wJovTAWuw_#`bAm;`)c(xTb(e@QzhyWj=!r^gl^&rU*!G74k6J=
z`0e=jur0~QHe;6O>l5E9Cxa(=SV^WO<d9@PQWq_T7XqSrG)*q?&ebXww3P}<qi{zF
zJ|sT;I~?6;-&0dHpXxLFSGVtU?WY~`Znb6fz8cZ=aZN-81m9h*p2(#}z9uuAlYFDe
zk2la<{UEFy{MshBZ@FiZx)bg}+MG&_BL6#@zmkwrd9EVKdq;=8;;mH2&G7XJkD1be
zpRLMIc9e7Z@?LYbXqO4lwH01wbtM+B8+<}e2uR6J6HP|M6{iB*b!|+~r)l11Cg1)Y
z@EJ{PX2nY!xfwP#7Z})vDL}&L+*S76hL1ckQoCjt2;$T(`DApi)l7NJC1y6pXPsb}
zW$;Ug1hHKK%}e9l1D&S;3m(~k{tow8`T2ceH5GR2ZF-i^df7o9nzycHI}C58<<v0X
z4rY)@P+SjKlU04jN9(;WOtIBIkk^Y6oPd>jrHB;feq9MxJaSqa1eLN7*9aLSEWN8$
zXdmrA`ZM?(gAL{W?-lwGfi5$wd|ve(Xc>!k>2ayOkw$Gg6$4%}Va=qy;;*MEm?||u
z(#jML)y~(m#0N!A^H}C*H2nj>9zYGWgWV3U9JxkIy4%Tbs8GksLiRpr!tM7>w$0$Z
zz>QGU{}L+N|H<AThZcNS>R}KGVGSJk@KP+lL;`neJTBEWBn%*!2j%X}yBS!G^hyNt
zjNPn!<5Ce`0@ieIy4HTHt}f=cLnbt^=Yobz+lKa=Zt17qwES5?uFAVeOT8Y>jL-MT
z4%-sn+eMnjZYc|C7jn;m_CpCEI;mi>U48PJpH>U(%f-B8@GWf}{*8NB6-H_f$HH&w
zQPk}j!gdKdQCCu2L1W}C)3xjueg9>yU?!sHkz?PO)TeH~WVzD^zp}4<-pkv-(5jD2
zG25h_=TW8My#Ea*L5;+=^|W+ueP%j~11<wmixH6Oo-%06%q>ahmL516%`KD}VhrSr
zA7hIH=(guHZ0L1m{$%T5xs?JI%~;xXmkB$1!Ov0Uh8Nw_Yge<BqkJKKeLz(_P9igx
z{aA|fxs?18=_dA#gq3Rp{qhptMs#*K3%PMH1bQZm=yv+s&t3#!Pd2vSRtHiU#Q4UX
z4ZpL0=r8%bYnt{yD+MzxGjXAy2Rz0{5m%FZvz1k)DlIyPt~jEtF1Xm_N~Luid?^Av
z<T-W;S5%xVFKKKz%={>sRH83b4~j2on1ciZrH9)F31^^5W1sj3iM%)!scdeo5K<<R
z`)7am0ayI=xtYl8Xox1e*qUGwj)zzWmQ@J27F*f_x@fA;`lKo$JJL}9XI%phQUOZ?
zHG_$WYu@*Dv2PqHO2@oXvI)u32|c3^Uk?g?LEZj*FZ+^w^#hk(Am^oYWa9A8|DLj>
zv%X$Da;JsWP#qi8#8QwxA>dbDT&+TpW<c%BZgwwy?rpbF@|(C|F};YdVVl58$pPCh
zC2CKeA#OT9CiM3+>vq9g;C(+5mR`JXkxCzqH}7LkxEl}dM14NOVk&>P<1m0^x7i2D
zW-<O*m8sAx`b8#Y_<Ki=*-^53RamQ$>f3<~AFp>F^hzE0&cAY@pD8in6D7?W5BdF)
z%gLq+%V2Ba>x>eFA-Hk(YCTF-*6fr|9*zq)%sGi);63<nSQpp#C;fOyZAE@!af!2L
zwdO_~4o~L>T{!1Vnb%9EHtWQf1lWS(p9eVPx+Y}N+DMKJj2@msN=2@W5Hh@h_Y?t1
z89Pr~>PrL)7R>8`n{z24Dm1^Sbb>+h|BWB>jIG$vDIM37fQS_1zSSG<4UN0h#c&&D
zt8%kG)Av_$FCUGx+NuIrby1=>y$T3rjjqz4iHBP=a@!`M^zScRZuCW$5l6M3R?E0I
zGAB8iOD+)-dta3Q*rb+Bh<;Q!Z_v4eJK+j<S9=>-<s-tHT^uE+&J=*RY(^;)xWzZ{
zllefH;PD4_{`<n0qe5lWLq~0EKYPaDTc7U5aH4a5zwy9Tf;!X@#}xMXwch$OWa&9M
zq7Tvi6xZ~Bj|p~H#Ks<4jhZ4!Xq&6;EPZ3c8$iG>ms=^#r?+A<=)v}0<k&!`ylu}&
z?9*)JSU>()I6(aiN^LHiuzm?lC~%}-1d7h{laN9Ah8|Vpn%(iX8kGM@JTL26L^K3M
zL<QFb%5&Pa>dL@fyLJqNDN(O-svRRu_N&9I<2dXe(@nj3(wu&2TR+Yn?38&@jc+a#
z^%Z;Lp)DRlqN^^&--x+9N6I>btp&-L3;o(gt0vNV=55N=Th&VVztHp)@C?u8cz+@8
znaZ6X1^h;^#0P?SW37n+NgZy5Lk!x$kE?XcUNI&;1mCWNXjTK%Q{_&?o?8!ohq)#6
zCbKCdv&!n}Jv2W5htvTw+`d?hf-Iu!M@L~Cy4<jH7BxhE@WXXU0`|U2jkf-KV7Lm|
z6QP`MK>p3?-=YdQc=q@Nf@&;-#+1UGW&`|fQ7!l6!AE&c-rjO;?-GvJI0|-by^C1?
zXKwUW=Moc+i^JGQl1a~?Iawlt*YS+Pf4N;BDl|E<o<FbzxX1Yj5LHdmI!Apo(BwKp
zGCzzvcH%*UXfppkYsu2~D==Cpl<5cP{7HS;#!!&qvP^<R=Hq`U`<Z~E>RNB6nBio4
zZpaHzv!d_RLc#;-G<UpRYSx6zau*<PTkIMjZ7VbEp`gXLFw~kTKd$Yma?cbG5S_XS
z?Dw&x0j!+9ni}}5IyWdF0S?X!!+iZ3d(3~_DY#RXPuOeUKZVaq#P94Ya>wI9xg=i=
zEL<f)8n+o9Wow_e59B;mIfL5XZ0Do$@S+`^J5&o9f#r`w@w@JQ(G5RpC1YcFN1PXk
zF$?bh+GI4nPQeeh{$m{gAWk}8H3f%^({&xbwYh22VjK}y-KSF6WyJT^)<BJ4fFCDu
zFch`ceoHD@E<%}XON*e!*nQFr)m3|DcS<M+=qZqPvRwaVS+w~3H||=0b#F2~)jy6C
zW8dE1e!Pwd+8$Rrk1_2-jI`QOf)LyCYS^kQ<@ssmy5SN%cD~7lE_nG6hJF3r(Wm;I
zM!D~6Hq1uaWk@puj|B1(ocShR_?+aQ<DBCBoim$)o}S)9<E46*<QgpjJoGt^@gz&p
zPb!y~_}<90x5KH)0^{SY6)I}hs~BnT-y`(jNu;im@<*gj@`$wCb-#6c#)GpDxH2g;
z5?Kj`&C=r&VP}xY=(e~3IrYAoPnKLh{rjL`5@rSl2FRp+Y;4lIeLUl7mZ3+J$yzPz
zjq<qx9{KLTF@(KtJ(!zT{gp-wB{CERq<aMrs1;wT!*nLx8n`BPwz;pTved_<dm}Gr
z$!S!__s=rU7`>SiR};m$H$>)2GG1Qs%NWG~Fb9JHabaoh!*y`JwdM(>48~3(R!Q2n
zF8{>OnB48gLy^{+@wI-38qGHinbMp1&gIsr{--J=Y#N9atpD3kM?kKK5=NF(kmRO`
z;|E4oxlOK{K_}yIY5+We-rjL175Z@9NGRv~n#{JYRV$Ge#+RXgT7YCZVe8pefO#71
zwKSIYzH0lbq2k56>X+HOK?3J~p8JWM_}+SYa<|u3|93j6<k#UTFH9O0S)AWs`mF%V
zJ4c(?EA&I<aNg@alY=S-F>6RczUNg1<$=#!g7?PtzL0nrHm|2PG$#Y`r_Tw=o|zge
z)%s`FfEe#8*3(7t;Q`YXq%nt!|IVi)ArlKD14Ef{16k6$1fmxtE@>K+dVL0Jt95(@
z*Fc2_X)HXNC|x)m=So2rBLU_8J&Oa;1!(n_cblV|u;L^2LGCilZM~L~QO+qVrrf{?
zBax{8i#<ZgswsT20PrFE)M~^m;amJ-(O9^<l^I#ses#J&V(+wDf`G?s(#ZC0b|6f9
zxj6c!swf}K2_AIwBGQ{hls3OJLq2Nso!jHJ?o0jf7ykq5+Co2w6(;>U^phQFWh;uG
zH$ak-a9K;ac0z+5S2Ysu_?B=vS_OGpmVa%ZD_Uvp`El4~)J(}PY-sd>D<@@$n4k`T
zP#`T<1;JC#r#uqm<h<qo1)QaaD~I0KcE7MbG`CUeRcaN?oPfSQNOWTrp(wn@bRG_Y
zvES+kaI8VvjKa&bnp_i^`DJyDpby;&t%`Aw+#P}VUv735mObM-I{1H5wf1Qie4!Re
z6>(eFU{<k&C({DYV8<IxCQg%_`g~T{x7bwSKb;Tb9D)vhZ~7K|IUj?N2KoKjnwP2a
z$kUgflc@31?FGcvzUFt|=dY!rPBxv^1zfSTxK5XU5kJ*#sd?&oN}pS_cVqBmz;l7C
z)|i^}(@cPdipqc*vUtM=Y<zx4$dF>cP~kB?d*C?J_{woK%G)W;&&0d=_0R7@mgO#5
zTH|X2y6(}L9M<ZIsotwW(Fe0ZrkevVBv377(o~H+&cEk;j;&x0X$@Js(_*)Okz269
zXW%ffOTanuqa_C-ft>?G_)Bb!<ozji<nCiLM?Ap#Z9kHyjxhk^ehP)|lK~@J7nXGh
zAGHD!J%3c|*#y6sox!nYtBZJ+rOfvEPg)76QIqnTzt6F}oE)`;r~R4J@vTAgQ2`xG
z61R3-o<QX~oaShI2NQ?v0&;ji(Noy<<cC&Ew8w!#sa?Woo-*%WyP=-B<E4j|#f7fJ
zNq05-j9f-o%v{b|-;*UUd42+Me|U6-yFamd-KpAb$WJHjAW}akIhxpfwyRv`W~*ab
z{nTtvYD(B@`erDzC(Ac++zCNBu}CRm)IZ<kcYf+)*18aI<tMcmv`_+~Al$vRe!>69
z^aBCyh53@=U!Q6%Rr^SJk^ewu_5r)eoo0{7d&gm)sJeK-z+ljt_2a9=gnp~<qt0o)
zaJDoHKg7ei7{pwsZ&Ubmmfi!c<?uXee(NEa|D|hedzjSSiR|nymthUu&tkz`2Fq#j
z=kawIj#o`{bfWABe1fL}xsDy+G3&wnChMWhtIhZ!QLjtT=laj05_5Y=wvrkt*Q2)>
zj}}MjjjLx)4QqFPPuF1~p`Zd(L8i}_T@ZV^uuB|j_o^K*9oREy?9?cN+OOH$0otj5
zIYHr3VL)qMw~%keyq2V5723+PSv;gKqHi&nq!#y9G+{sO?o3{Ymbz&ixTA&6f9s1M
zI>|gitAxBiE0`xVD+wfTPtGxM#N78~kQCnaYH78@r*A6Rq;6$)tbNb(`Ztr4{r2}>
zrfL0#yha}Hooo7@Z5tLyYx?T{IF2t+e|s}?O0}wO+~}=TlZ%WLr1Q^h2-yAj)=3jF
zAPchiW9#5?<rv{5QxoRby{)T4z00`rdLQ?8mtlk6#)ETqQ-{H7V@YBfhL)K%{3g@e
zi+SHuoSdt7Ld#b5TzM)FOjk$(Q)=v|<##5}=TgLUxxE6quxp3XBr*n*q=Igflaqr8
zXmk68<UilKO}nzc!At3WEj|zF8O%UqmA(wWfk}rd`<X_E@yD9&d$U2oT5Hu1WCge{
zP6~8;^XQftsQCS4EP6rA1637}Xwma!4FOT#l2g74ik9-((y&AWgZ7RNoe~4J0kIr~
zg`lixZZ6|`lC23TGVcAc9g3Mb7^Ie@UggecvdjU(USd$0$PM&6vtJuX$m7^ObceRo
z9(+ULQt%BYjLG=kW{fzEzFyshxsAKtpgw~FZn)Tv?_VBYHSxJ4UQ5kxw0A`jc<g(h
z&wG9H-*Gs%N+Y-@6@^szlzKGw;s`Ar+UKoBhpFWIixs+dMY=!6TKCuynj0y?1nSk<
zuw`VBY3wp9lN6--w7d`wSci8Icv}A511&fL=&cEm2o;>8CATjI>CyvaQ|l|faheqG
zGA7S&Bl&zBaHcpL5GL&1-Kl3#-Q?DvmUw=M`zrK58XRQk7EGG`mli6ll;cTN%}2}V
zc|{y|dxE$wS27#+{T(h8HCn166Gjcch7tzIV&PFAKR&Z?+p9kvcRfpo)#t}f88-R%
z(H(;WF1xI?MDC))RzD7=pN;)^0v!Xly~C_=(trJElz;C~)k&izS_;*2T6||v>pC6N
zhEdp-=F}vM8VgY3N(JVfmd)Swq9!1d{U{&=*?^-)3B<<1$>GSw8O(Y?m*Fyi(q56e
zN@lknyxrUBTb!ne6Pj%{p7p5=ys_%9-6xJ!4*FGSy~W9uCPXE<ONw$2=JuE?pyTCz
zBA8&Cy|E)1nkiNYLaAI_+;|B>4Mn^rtIS_T?M^p%4aa1s@LLz@)_(Ev*_rH1${6H`
zHfTbF>E8#^8ZGO@_6wi><~|Lf!0y!`hx@GGx>tx>b<Q}}4{nN@ibky!%M*B_uJWU5
zsEuibD}+D#C-P10cv${?)2ghcS#2z+0e>Lrbt|4yrS)9vhw1aZM|hiyMXxH~VIIY^
zo17uBizv?em#9T5G()~R_u%iPY&mded$cq+2|+=peUA>}$d%EOU1E&Hb)~hFX|3P+
zo|NaV@F~By>D|ZQ&J|zj4i-w?3*&O7gzTqQ9rde~twz6}*p(VuWA|#y0EC=oLfxxR
zejp!9On-+J#;=h!3oK!}R!YzkC{5pa?3p7~6mz~%OMY^1z9Ox2UE7YA@S~IPEHRj1
zr)xg<{MZp-RhvP(IgH9|P_#|rFg#00dh`|%sSQy)>{l^p>TVQw%|??0&aTErQy8~N
z<J4zGk-rID(M3ZJW05+Y&}NY>MqoWFw!aM+1|7<7ULJ5<Ls*$`o{KB)m+0<4X`2+b
zU^KO323v=Mg@VypXnio_Y7XYcB)v0Pm|=P~+n*F4Ci@{ey~Q~MyXmTV>F@_qQ+YVx
z5q__lD`*3L6M!t6{}4?r;=lT%<kRQRc)OkhI{dg-zq(YsYMU0zs{9~bsj~^WpVNR2
z;sNWsXy>Z3AF)S!s-<SF-L(H!MayK_>^I)e{#w)B&Fz#EMKd2XeTXa!?`~%UB?b(K
zdJ&K4g4l7OEuu^(Sb;)O)^BrsNs(LdqthLv(pfwpa0M~aa5pV0Ut3iuR^_DdV#FYO
z6^SKVmq*z5&rvZ69J(1ZFNSS0Wk$vi2f9ML0fs&qD+eDQl|DJXh&!ofc~EnHv4*WV
zF=sF^u5*uXHi)sy!?~J0A?X@skK7Ns-tMcq4(xxuDl6nL`dr~`w<4}8k25BO4d+!9
z*`Z!M5jmGe@?=*OY0fD!z9q=*<SC1QXBc+vyqDALA#qC;@taGR%YITXg8hmByEHNc
zg2ZS?$Z-Y+IZr6o-I*w5%!xvlExv5#;Agg}P8V^dmI{=q8A@i$2`J$NwRlPhPVSt4
zddFuzJ}aeq%P#jQ+27)rgo36mojynO6pdoo=K`rN;eO})vvod|UmH%hC-XV7_`PUt
zPw}XP(q5P9^Zz>+0ZjTB$67q5!fybOY!wwXtGo)@`5x>H4uR5a+j{83FYf^Zx=Q9j
zh@DQ00?vsdZTfrS7L(};w1L0RX47L^amZiLUn+!&86fb)i~L~~6nvH+BO@sVEqS&?
zTbfSzZ%^F#-yXM;UrEfbxPVy@ku*ZfDqsY|p29?bf=z~)ZkZBs&(Bbs(I5A)j5S&~
zbV>z<sD#+HE992j!vq~>()H`A`KIcOruooplIc7_6?uJm)MsG@@a&2tZSPpQA`Jbs
zzuaNslY2!>CFF2>Qh7LZzSSiYEUB#5>`I!Up1;CywmaPu+FfQ;_|C@+ks1S7sPY*I
zS4(5p`SEhWZ$%zY5peg@d1S<*2c5Gt3Ou>~*(TvP75~lwo_4Q>^fsJwhe{}r`1y1a
z6A^zy0mWpp*rnSKoBa;$&`M6ot&C7MhZ-$`*S=Px_fH72Ok(Wn5)+3!wwj8DnBQyR
zI_X36U}z(!L9XJ`TPEpZ9bWC7x(HBT6zij_yrd7F=!h8>l^DarG8E5FHD1gyJ9M`~
zKyl4UWsOKpn2b$gu(HaFBxPvt7|M`xdYwx`K`{**xI+U4zoo_Zfd%;%5M+_kqg(M)
z-O-;%B#6{x-k|~A5=)(DyvAnLMc@ZVALybJ29MFvwIx*`1se#_vOXMzS$r@6Ld229
ztO-(7QfBk0&zukJCIuRpXRm+sK2ak>HP9t1RrX#bxQvf3W$>S$t0Xa?y_U&jA-w8#
zxhKn3&0IK8AODY2DTameJ-ujQevo1|T|c@(3Q<#aT%}vE*X@1(V<Gk+wLvVu-oj`_
z1L(#puZKus$`|AFdK#``>P9NI$MH_{2on*{dX6OSkvdWIigReXIy?6kXOO6-h*ldt
zpRZl~w9^{f0oobe`<YU?Zok-^<C>=|=C#Lg9IuMx&5<9imp`@J5wiC$TZ}rN^Vm3C
z>A5rbsVv%kq&HfOUUj|e>9(=Mez9S}*{0B<_xax2p_Yr$VWhljnq;xf2t%<>sfY(k
zK&gkQD+)6+m1%z)2qB;mohz4?*#2ObD(EP%Rsh1M6EVnjUUsz_=m$ID)18?j6>1%?
z8l=a_NIB-3UB<}j0Tm`!CxPK%FQJ*QOO2|-Ghf{$Jse7r)LutLekjQFw(shnpb~Vf
zFFp+b+G#CTTE9?2?M_#I_JQQuzp0c5&g2dxLII_Hsreg<j)Jncf62B6M~xDd`7?JS
z%DFcuozE2!o&j7?U7RmJggi=PI*OW{UUSP%Z^=83sT(sw48}YfQj6oG7TgWoHSG&7
zc63T?V*BD*<~$TQG+In}aWwahV42&8Q@a!`7i##s`RIHFQoCqW$_elJLYKu0Im>Li
z+8!?xx!It@CgXhRw@7!ab84skg+}al0vV4iF}@o#WOQ5aZR2Fk(Ap{2H7PU5<5QYs
z4!Z4vM|?bBz%$Bo%|jU0#QkXY-qQGRw%42?z`OZ$ejTAz@tln@;vpW56vz5MEnr*e
zsw#{lS}TI6i*<xl(2<0gxYF))hBJk~);8cg7c0vO5f>H)Xrer5l3+Kiv1e6J_qUq*
z{a`kJ_wHBa>zP_enuNj`8mJgId6vF?j{<$UD?x`L&kt%;Y2>PWb@d6U#f9G3Clyme
ze+nspm>K6dx*oIN^*h9APek)nSL%F6CLJ!?=H*J$bK&L#&g%jiV<gj5aO(=jE8jgr
zu#`TWb9qBx15T))h3E^~(;9}S{_6GGXI^KDP2>ka&T9{P904P|yi8{mU<6V0J|2^x
zV4}PIvJB?hCk00aM#dpfonEeUcHNQUTMW^DiEQracI%;ZW@6#n6Rn7MWxuBmiF1#g
zW<GGAyd!xYBgG(|{uk$r3g6vcK{<sPEdq!^m^u}vm(jmQgy~gCRlcTf$E=!_h<KGf
zSpk~kGS2WIT_e`2c%bQy&-ES)cn$8x&naulms|^Kvrm_Y^P3_wH+!2MpO85CHI%V3
z%4ERAF;+y8xW;wubK>&iSScbZENvBBu7f4Fcx3|xa7SFGsYr5;ej+73y<`ally3UL
zAvIN9lK%{67k?#5SQ!u25Qj+26!>pWUFCH^!Bt{oqrDE+b){^NykKtY_CbqHyZM9y
zwQi<q7r)ZGzSQNqVjEkf`?-_qQRjwTi3+IUZE34>R|+PV>8$6J#ePAqhJQ5C;e~&i
z-b)~WYk#deerabQNS>i6Ugh2SUS>?25mCZ_^_mw#^5?Mt4KC}!bP6CU1I@qYjFr-~
zeD>QhJ&6xL-<+~tgyKX!14U4qZ0{1n66<!JCmz|{!;I(A<s#rTtSM`tODXH8#fQVJ
z2-4Jmz(!qWw?xBK{=p>uzVEM+E908;0Z7D?4)cMM-@TRw?YF1GXHW%sqvE~sB#nOs
zZpQ}_S=&!YNpJeB*X;`fviuUUPF2zZd?ko&a2BZ*JC!3?aYEXKx!rV89Y?{fUkxTZ
zU($<q7<|`Y#JLBT71r1`QCssp6M0!=DTYdE2(2m&N|+u9J*htb5f5pPSeH>N<{T|@
z+tDu9eCfvg%}0?R=dZNa%Jpu%Ndsfxej!NTC;qT9NG)rW=h|+(*T~SK=(!n3ezIFd
zn3W=w%*kMjY1#VD?yP*Fyfu98W>0kpvWK*6t@1NrRAbk6<HBEJxL4&N%JE?4_DEX2
zq?40F?<*G!GG!oYD$3?VdM&Sx^KZF@*a{eKlLhBN-vaYg6Bv+dC_a^A(Z1M>?+J`4
zv)EJA7k1lbEwQcF-9s@X>m2mPZ9{g=pt8{NuNA+3!PXgrQjS9fo@Bs*r$oZ)Kf!rn
zHD`uBGkA6I$S(JeLvN3s-BXcwhK1P}8@hkHUxE#(2XAGWSA{l_ah*n=wzV1kjoohR
z<dKnDZy1t@Bcw96QhQclKc~y@KaTQCa@w{|;;z{<n0T4zzU~-MoLR7LAhKp^9h>3I
zUs?68VXX|TI|DsH_=NmDKhF}rb>Ex?hU@<vzKg&r!QM_QEYb1w<baqMdWqT?P(9?Y
zhL(-dMyo4CGWBY?5d)pS0X#oHsKGTw@P*|4nAp8nmpWtyrzG0dDM&r&ciJpd4z&^j
z+K&vpPhAS<XV*J@2&lW{G(l}7md@53OeqbZvk|d}eRHD^hjz(Jm5HJRLqVtR|7P>j
zW=bDwKjL=`EPu^z&e5;041)GvapHs$wI!C2F6MfoHTOW6C?6}z#mh&wBfEphKAT8-
zAjal1jL73sprTpi_;p@h*DUP)0e=;aWX6_`B@Ecdg8`UR#ix<vGaZgWYY*kQt|)j)
z-oWkmuzp~XE}Fr-74mVk``-kDt9o<$7B34ye&Wt$Mk05}YMchPi-HynVk!y~%|llx
zNt=nRyfjrirr<;_Hy>z=!GUDDWv-)LTy^!!BtnoDoKh;JwS4&P{?uTQm3~XQzU!F5
zwDg8SObqz&$xA{n;gf-1p6gt6Bhls7fLp`BOw>+VPLENO?`P(??TI4yUFV>b(Y%2~
zF10i?bX{z4T7>e0<6<0<*<-^=k39CLLjDVj!F7FcBFDkxs5Aef4-Ihw&f&OE&{hQt
zJ%M;W0}5zUv@qPC;dqt;c}$*M?9yt)5<H2Q5r4%YI?|}&L}?WIQmpcB&a|tb)KH39
zuZiev&M9gZ-|5@fj_B0V{;FP?`unO=sk~we0>#^1gW}XggdY!}_4CFDx}d<l&qDeP
z5g$LIMMEfUv<Dia1U76UTz=&`NnU%~+uQH{HiL>E{eJ()VR9YO$g{&}RF$In*X#~y
zk?v!2_I{-pT!;opEx(1~-tJ+j5Bx)UIgjr*Qd0N%KEgfR0=1X8vxWI<F!L^$MWg(u
z<<Gp{pUmW_9%^^H8YJs>TkN=;<W0Z#2kyWpwVKPEq>}Bs1rXI|`u7Q(GqbgSLq|Ai
z_B0EpkqO-wf&D{h996J3ptM+S_|A6BTK&dD{yA66<=NF1zxAW}Q`ASHwSkIVDCusu
z^Vu%!-uv)$agRvmw3VLMZ*+CbOss@rW1T+hx0o@i&@us~Xs<3Wame);MBF!jZ+b0Q
zN35RB_77#=4ve7*tX9hd?KA(Q2vE>%Nb1`SckDkPT0>&87sM8vfFi}#+XO*{1iQz-
zSG^L-8YRwu_xO{J11<$aDYbc?`K4Ol@7xcgikM;?K6VN7k;us=EW+mz@fE!fMhw1N
z6cdLtsqI|RPBl15HJFW;yxj}AI%x2`L7}}$M#}EG6KX=o8=0qEb8~aPI9vN+)D=;W
zmicaI+>yp!bJ8zxnpn`B)J*6hYI!jI#?W%rD$$<Xq+ZVWm4ZTLTJN<K8Lepg9Qnow
z?Q1l1Tb<rOq4hSllblU1yVfP$GGi6@)#D}yL$m<PcPmKh*zy^@L<|tEo!)W5fAKh2
zE9y<rT=}|K1>Z}K6(j`980s1tuw<UeB-;;CIj?^o?IhsB(niD>ve)-ve7vbbzOo~0
zuat1<_Q{Ai(>;z4G>-~(d|-N!GE#YHdG*z+S3jv9&hL*MZGZ+|Fm;ECxvk^EzHn+E
zp^Bm9mSbpGY7p&nfbq}~_k>lmS>sef48E$J^a7MA7|=}|?Lly;hnix*(udk<LC?mC
zqr*nyQW2L93*BmITXGY{+E)L?n`hMwG&l)Y%KlW!0FFE4+YTA}*%5dZb2zSB&r3n(
z?BT@m0@^rWn!k+LXVP$cv8K^ID^DKxBeE1{4x7&wT!smWHxTW7!i~X<hJ%ntbo*yd
z6Rw(sKlWEm^#!VDiHx0x-8-cOI?Y`VjvO@75fcw|#`Kbdd@lzl&#N7gA=j<)i2bJm
ztJ)M~ViuFT8z6t%-MSZ)0uIyLnSMbTyc}&f!sw&M-*hzznfq?AhoYg|t~Z~s)4$u=
zSlLnrBQhI2=Y4&&_or;PFBh)FM(8sd+@l7Js#EyAOrkTJcGXaycaK_n?u=^0Gb>dd
z;?ttWUW_$gxQ^14&Q3TEuckS*B%NxFZ7n-i^`7hyp}uXbWkZ1tE1Aj@J24rOTWL=7
z#^|kR;W2ea_<o-C^7lSY43+r3nfz3vi)-Ir_QT2c)jPlLj24}e+*C>rstKo2^WI`;
zWvBC&#;WF!xKLnwk}Ln_(0ON{=7}A;n$Rj48ThRuJi1CK>Gl#i?=U;|7A-Z43JU7z
z$ji&e=_^AmJMv3S0s=z!Qd#y$^JR|3492w8Qm<)L9@e0^bbro-;gFMa=~LFDm<1iC
z`-xto;q}SzLhp|hYCw7w@t^RR7VRFQhPA8RmzgmPK1FC_bAlB_8;&GklS1(q`O+1~
zdVSLYrMN?O<j3<d&cMzTX1qK7cOuaR9A@_`zcLus>^enLx~%n+j)o4M`_!n~^6NTu
zf1*epHf8!0Map(Ga%C}?DR$o0V}V2V{I}kDS;6Zp{f5Afo`V)yU#H!T6{(xerdte<
zNsYbFj^Dnh-`U(XCeBd0<nhSW0jELZSIV#4+C{$A?1x6Juw!y|?V_ox>C6;9@U_Fj
zHEX8tSuKSoIth#wcHER22xMJMAkm<oTGW!T8lEARB)*ztJGST#!KINo+ZqR1$9y+z
zb~p3(PL~=p0NTY|%vE1y%{p<sPRspKYd^0nXe@4>^yt>__mY&~S?Grk=mnt>qeyht
z8x!|5zx^V^hO>gKXfgL*EJWVxKylik<hP8Q+A~#F1Lez3V0iM+0ojbT1&}q|f9dv$
z#s9W1^aZQL?KpoBS7sIvGU;tXrcr~YC4S478)&xldwK)ZDC*z2k>%gpsW(Y43-T*>
z>uJLPF(F|7YwTov<S$Hot9r()2EGPrT*SNF_~VfE(mi>?8_->H?<OnBI{kY7>%A8z
z)mPa=EDuk1{0>L+&LuB|bqCX3MUO&W5X@IvAMD72n$e-}5nX_cLKD!{d(>pPOXbf0
zYW_TH|4^=}-ebY%u0yjxy^=}VNv>AAjJ|1cFAb?(_Vzq$FO7JjW1VSh6uWkj)^~+3
zPlfqX?!REL1ZGe*MNneH_bl~{9tu-QnkQk`ujeLKxQQz<7feUDm5*ETX@P><)xBv=
zuUv(X(`tpf6qXEVj-QQ;RE!!_l6-Kt2%B|cWP7!SuJLJ1F96*psYmO_0#TCIU#KhA
zqar}@FTcy6RUf67I#8ViPEK~M66Y(l>S9I3C!^4OXiyl(yggY~?cdd(RiGXP0*sk7
z+*2ydD!8o&&-)T7GF{uykN904k)CTmp^Lt0oMj}Cnpojw*DcaBo7e`TnX}ErcYULR
z{|UQ$20*0%rF*Jj`D&Etf)H0`<!leFq^tX0WS*IsWDC!$D3WYuuQH?kEJZo*i{9l9
zOPE~5FLZ@Log9pV)_+|;Q67qt_9t<u<nPZdl8aAmh179hEVap={0chlvR0!M`i}UO
zBR}Ud)U@%!=vnpULCd4QY=<BxLy<5}i2yQ6a&DtdDQBLhxLlPyDT<+?+A)mtAk_55
z?G5UU3SWBPpu-r-v7wlic2Awo^NrcvEyn8N=#J;nI2)?b0&d7?b<-6^z8H9pfsW%U
z>u@FSuppF=0b+aN>U2+SP4@$?@9$VS?;61qKfP=_uEId2ZC&Wtv!B~Z%-TtbY{q;i
z-6vR2-UI$i!ixO8^o<&~{ar<e2<tqivUu*uKDJmRJ7H!`s^eg_medCi%Io!#F4mf_
zWSYJ_!wB9p?(ba_e-dDzFpoRrzfm^N%gc)vZ$W|K%fLoUdRk%`U4zc5NdaTBGJ}+m
zN~-~#3ON`3G7T7!E$m{5h?rO<e-oWj<32LX#;oq=sl*;uwKyL#__Rx1pWs}!R;(Yb
z4Fqu-kwgPn_I0NlM*nF6Xqyx}v9wG<2{PV^ZzD|tL^>;l9Q77o-*k60E|RO>2KFy^
zD3mD}w|MUPW*7kXjI}v*<1i0VUq9YiO`i@)RnhV&e&)@m^L2MW8I`)*9&V;l>gi8l
zmmIx`&_UND9H*AP=y1tgH*6iZ2lHDGHeZhd#6*S4vYgOj<GzF2P+HESKFk*{!yE;l
zE<I@GkAi%uF47)%E7Zt4LStj&mOx|C<+JBH>@m0Ep1XRm3aj|v*zsI*qbS=^YmV%e
zTS51;$O$`@E=bYh%&C|CbSu&8QTZ-~SFfxG5~pMxmwx}LYRCAe!)&d<&mHmBJXnhH
zghP3w9T_Id90Ruo;gXV?1oIy`YIIrX7c?McMAjko@sCKZqg4b#^vmb@0guF{KfjaH
zonTLpx|(8@(i}|BH~hi&Bu@#LmtxVNO*yMd!9OF_j_x>k)x#9S>x~Y`K^KP`x*!Up
z9N!6e3V-~(f->iA@%K}7sI$baWRea4cri4J+82}mMA;P3Gw8N4r0`0i+J1qvvl5Ld
zzJzu6YeP_Hbiy_-@6i6VhDh7k^IDKvS6)nDb7N^p7jesf3fZ)$9^wr*nOX#^yWR0x
z_I+o1?o)$9#+@k?B;9iFy&~N$-<l!W{k@qgd;)@?tu@_scyc16f+yL*kPu|D<bR^w
z2}Na*cA@Izes09doWo{MQRc_z=z1_yZoqb!L1F^h2b5T?`+wA96PL@$Y<rzArgZ{4
zb&9ovHYRg_fGW{ZpA{pWIWD8YQ)x%Cv-?QyFA8US_gILRJ+YxZ6G0Ii_F$6PPSZ=x
z#m}t_n9Zcu#+1LF^U|kLRN%|QR6nrkI)8?SsZ7Z?{R$0ntVB6GT(R?nT(m^Ss-B6?
zKDwFWus!C@#(YQh3`vLAB3I{Udtun5t_O&u7YDFoN&RoSB?j|{A!mCtHQZ>i*IlbB
z3#d%)IpIZ=iq@@TsgxwkuZn)ry&ixccEG3vf85PBF81X*OnirNP5hGb`~IxuEA;_u
zmUk6e!-Bc39i`QK&I$s}h<pO>cBc(<%NGaYqQAnLl%V1P-<<bQ9_McGWZs-Pl^`Cp
z1$z_@KGQQd`V36ch<W`a^hT$iz<{hA<Z^;p$6jUU@$ueVAx7VBVawoiy=N`6{eoEo
zi?e$&Xp-_j;k(XRdS<RdyX&w&*yJ+jbvuVqowL~$37R3Yen?>sCx3`*a?v2N!-uuS
z4%}hUzu}9mPiM}gY4BvNaT!(r)0*ihSrbrf>xh%Iqn^uO8CJG`_;^BvU_EKHRhe?p
z8FN>?F3(MKxEuC>A_^i^cjQ&Lm3D1*t1&%OekHW)GB&7`a?oy!!!MT=eo7%5N$`+G
zS}}hOKJ7LLs#`i`f4_fww#UHuqD2Ii!Ke_;$E$N(0Ll*=owZ(JF>3Zt$zA_K(=b!t
z{e=jTCOBQ;L6wr1Ynl@#t5*#EjHbRCSH!I9%~x#-fh`aISDHCP69lgO7#)`5ocV@8
z$-wsZS1P@WIqK`^YJm0Qxc356PRHw-D}J*zH5@DGz4@VCi9*-2ztD=wXECZ?Z&Ufg
z=KQvRxw_Gw0g{0X4hsRu4EVWKN{i`oW|QBRRd#`Xp*d!KxfwJ%=JNXs<4AOJC(wAb
zkFJo5D~WUlA{~$QS)boJpo`xNRL7H}RzWvt0Y7ngsMc}M;PQCG@BDqV*j!N7;=s|$
zkS1D=ZnW4KgtZJgv6{f+n3c84v<_zv^4~~E;A|JTbUcK)u3IYkh7}H-QVDTgx>4K+
z&R`YGt}ecRRO_&4QeyKK^>z7Ho#0@mCYJd<Hfh{<m7o+s<6B48UUbcAZHU2^^^fKv
zL{sS9^$FI$ObU|u?Hf9w;;O6pE6E+oLhC^a;G%RM8*}Ac`l{J}X5U;UTAW@totVCr
zdhHHPSe&soyQe(G8+t=p*88;E7~=<C0eOc>1Et<9XP(c^1bwj%v~aPmYfsxQ&M2F*
zf|vEnmHRYkV9iqeyvpJ3{EP<cOcO0fqv_{3WW3SoE+j)t!r8hwaleTvKGW}PD+v@(
zs{TITZR18A7%e`YlBwO)&1Ep}=7a`x#oDF2j*HFnO`oZN-c<@i*xHcKw8xnxyEpJL
zE<*u7bYZ}QO0d+Ra$)wM(JAW8yYBc)A{q(iEtax;PX9fAF+@ueSBFMR(gP<cmDcc7
zt^uv-DwiB|z?+}Q54d6BO1y=ssynSniWUA6#Y<I1(}*;uM){f|zXOc(+G5Ry$@j+f
zV*{>7xm#I57Yk48#|Mq;CyEx66H_XK;<;WJ*N+FaE}>lq%{(mU$U*piR^{+;QU){>
zq!m~SLlbRunY-;lP&3Ve6CDjrz+J#O%0nZ^w|eqiVz_ywW0h5Ev7oku`grmqy3b{9
zq9$PWEThrH;sPS8uK`-d-#dUzR9ub?o!QRq;`>HF8_EiUqpKJyNt_ecUnW8RBDRB{
z3ORkM>=)9n{Sy^?*KRN3hh%Io(S@8*g@;xHiMA8pMgEA3g|uQ3r17+6aQi%n1}c>s
z`b^aZ#O7u7dAz4aC-GOxB`%=(r(=1I=S?(L6(OW{%`WH)*RO`iv>`e!u?`4}%>clK
zFcMprB!T<Fu3mT>k_F7ELVoG<oQgswk)Jq?ete?|qap{XqrlxIB9#SquD@0b;VFE5
zssq{1N8^R|`ju9mcwf~B`KIydB;&XYC*`nmzl!=9$;r!icXr0`;m*C1Qg+o}W0K_*
z;0D2Dy4fV8&pDKCsKo-)Z#}U|*?TqK)de;~qrKzZkAy&hPrQ4r;yKVAQ@@J~iu0s)
zTeB32Ow9P7(od!dIngF624<c?I#8#PWNhsk@8<7zw}vmxL}Xnzhttq)Z-GDb=$onM
z#XR@7hhaEP6zHZ3O;|-l;`CqKTmeCH8-Al88r%xh{%V70%1^RIcSQ5eC$RY`;ih3v
zle8&6jwiv#Io6y0YT59N#d)r#e5KZvze%0bI2ien_mf@+mBa6+27ZP1ov!LpN&NNY
z!*QmVKR{wzNgP}WxM0sm%uyjjMw*#FB}U@Ka;nDWMB@yb^s$joTIUX99qt8=g{!2+
zJXR{fKXel&&V6~?S#51TLof27$P(Q<1|CYGn&Na?Xv~ps?AAc-y2NtrU$>l4r9ZDt
z>`i6H@u>;9Az?F`GCm&4Y&vMZdpk@k-y$OZgVKxm;+VOq-eqMSl#lpdv&K8xIBh~b
zy5|wh=u~X=z=O!Ud<BDZt*+D`7V@H*$L>TdLNsy#Q_O2?;T&e2<$pcWYIbY_Js*Iw
z2A%X-kK6xNc_DN2Uy#XtB9O4DY@<_O%y^)Xl94K{oJb`~o;{*f$Y=7l%_0cqY9`V)
zwEGbE0sg2(`~4|}8-qY7v%;RjI;#ePl^)DKnycyo(MCiVp}RdZIs)v?8fN^T7(ePO
zHZ6?%M8UtNTI8t2@(P>0NV7r5R6@UVSBKSbvP3#d>`5#=hKjh;C+a5agN48VUv$qw
zdY&Kc!2*{>IBw3O&(I4MqiZ<@g|Px69CEI}rQ0*KgR&V;UO%%qSh%@5JIF#yEbCme
zo0V~~9UnYw7Qg%<-BrQ1?grA$xqFJkaar_o+-$<1#R>h|4M-We%)fEXB8ghi;DCl1
z?#P4n;U)iir-;}XB?nZ0FvwoN-6*fXbq&KU^J6~PI}Yn-m$PjLC7%5wL8>nR!Mc_n
z&exp4>e9M{#uYZSn5<7N;_Lo9#tbr9YRx9yBwD@bw^2%hEAiiH1PFaKHa}Bl71ezp
zGXUhr0C0KqTFToPr?yJ=LDQXp9OYmokTF4A4m$<?Ft00rEdB6cIf(8Q^08Cv7tCOT
z^t+A;Q)Pv>EyH)i2kym<ql3w2N$~?E^quOeRc*<n;@l7*_zIzn%MWNp<k`eBECw8}
zg#;0l8Mc`1q426CJ$Jpo`~HuC&CgVCf6PMzr@tT!DAx!*^7e=w(tibjgwKbH{6r)Q
z2#md)?SpF3+8W;E*WFNQafgdOOm<Var!oS0d<wx1VArE9kH+8>c%fe-I@VO5;$$GM
zQYK>ImyixDNw%xhT;E-FjNMIa>UXyW1mA_CdFSwvX~9=&@Slf{64pEv#N=5%eB5S(
z%HnfOqRnIY$^tF*PvExvA_x|WebWta0}~9dX`J+T5#pD-H^P8^vDZ&uN)kKvT9>#W
zhVdM&ddc{voIlg+NGOh_i{0{g;jw$NnT4<@Jm`4vN8$tor+xPO#emR)rIKEjXjn!_
zsMcDfC6H<Le5CJ?_G|db#1x#cU1fbk8l}}_(oxI@GJHEc+Lpjw(~l(&eFqK?j7rIN
zm)%JH+M}v$RrVEX#lc_rZvN+_Bv#Gt?uhGi-tXW3J7egVz`zVmpoER-A~&&mok-4!
zDTm|woQxax6jeWe*{|ha*T917Xfg+}FN@0!2ks*W@SwW-ZHYLX-?PyQEUgey?Vc)R
z{x{EPOL$D#uUTigvgL$PUHnXN;+TCw<{3hW%jC^+0e_-F<;#C%rqW27JGhaZ&Zdds
zw5yt%RXFyW#{H&UmN?VLRn*rU%KZ<>B9nAXm;=yDOFfu!wFCm=e-f6~{}`v>cjs%h
zl||M`#KvtS@PFulE0!tmIL-{`MW2iuG5y&h^gFX^vZ$)WX^5KFYX9;s<tEkKkp~cG
z%RO6&?9oMfr<1i_qxI3&t4JM+GENexo?l-xsb@Lq7(AID8T(0pQv8$88nGapgOEdH
zB{usZX&S7mPNRK}QpMiZvcu_Fc|UJ=4CcR%{#(Xh8tsQFpuO%@fBa=vgtnsow^IF>
zWC>0rVMLmhAZOXAv=~LPz!thu9>VkF1P;vb+zB^p=Bu|_n~9t$4a{5Qc>PS(>OHR)
znGIO29&Uvz^w&@TXU)f=sz{x7xKLxt%?DQ@d?H>vBCqfj17*Fna@T};g%l#4l~kHt
zPJHr7F1Mle9Z`c<FAZr@i;$@b{pBm=YZyJ^t$&;t5VQT5q)&*mLHm1zA>cUp-OMUC
zTR+T@)=<_BmVf4gcsnpEHo3~#{HbBhz14>cnKY~aV;)Z}%)S82;_nau4GQ|m1*()w
zk;kGcORm2Tl+fj|Vr91jEeL|Pw>Zv<KVPtPE88+ce~dk%)viIzvDo3?SA}p|ra&#9
z)IvV%+c8w}w&GK2^3IjPz6g*W?#(K91vco|Jv4P`Oz-|^D1+RUCLg<^tapxC69%b8
z7>lgxvJ9Dz+9k^KKls=Geyxz3IR)O|Sa2nC=itl^sY+D^=IN(SyscRmP!KHyK^^UM
zd10~fzQI8u|FnQB6)cl^`@E>?3vdl*;><+)v#H&#@tW`{0qe(!P{t%^KK!wRNu>{&
zY<;uci*@OL^};my?YE8i5r@egGFx)q)irAaxktdd>@>*|3OR>2ZnF6vI=AItTk=m%
zAKyU85{PtYE6R*a=HbMp{E#@NV@xa8`(`4K;>`9*nxQEU2DRbj{A@M65C6TYG5S=<
zK=D}EuKm|j1xR&LTMxUvzG$l`Kal4<hHTCJF|V<3pVo`xj7P~z(;V*5%ca9jjf?Gi
za9(gez5xH*Dl=tM*-&7b(l=Yf$F^>srlP6{3|0Jca9$kP?g7uqzqhilkyGykfd-x2
zzg&aYNDaqOMNe(arnd7DkmP7p%vbR*R5+{y8O59u9*5{e!QxmdxZmZa2qdE4kjf6m
z)8~-;sV~5owe{>L0x#w5j4}(?Am<I}x#_?CrGFAc#5r(B>Z&aYbzOpf^4G~McN|=R
zh{E7&)B`TfuDIpkFv*=WLQ}D~$pRj)sH;xg!)AcR0wPa%h~qK%ZSnbQZ`TN0|Be@<
ztn`k`KL>9$wDKiR)}&wvB7wUL$`+(HuYy7f*y43$EX`!x>1P{GLj_pfr{CNZSK7>_
z2qha<0@4nLjWA!$GU#DS%ijIn!dA7OQY{SaouDU=X-2n*NLp*KIGGBZ0}&2x;$@c(
zHtd|!T#yNu#2G6-oT_!zOiKds$u3^7oizeCj7$mY&M~eZA88;o28x&))>*2|iTN8m
z0dsP@g+WAqT6RyVsQblR%`;8*ZA{g2o!52p;BTy++P$dEt>yCo)>6SsVF4L~Da!W|
zmU>m&seR5ig|5Jq@KoM4f`)&g1fYQ-t?gK(97P%l080y$i)hEPI2d&24g<%zk#8s8
z!?C&4%)ETLvcR9%to7t%3`=nnf@g|&b|r@YzIqD)$gs-YgZl${k^)P=wwV{;8lQ>1
zRKqFJDy;}w8M{qQ*O=n^zGsp*!hJut^qBE6<zIU{(h9W?Ho1`TdX+L~<Cx~l#NKeL
zr&OlqQ-$oM90jBVeXMh$u5v=za9xBM)*E8Ge6}6@`mZS;aEqg%9m=orTtoQn{i#l1
z18*gB*>JWfP9i49=5io;-uLvqiblu967zon`ehMowUW6|1X(MQA5Zypje|)Gc$6C4
ztSpRWC)hjCBdh9$_jhK`CSp}HsG&vwkEipFr~3W>|B=!_iV#AwvNzeGvI%kQV;-Bb
z_ef^;cB}~5Wbcvez4zYh*xTWE>HYou{MGGNj=Wy4>vcV^$Mf;HKZh4{WYQq^d`0!(
z4g5bi!b`hI^<Y?!x{OvlBU+-&OY{GKUpTL&(GodX$^I>}jk{tmt=vCj-i1goBDnDK
znRV!7P06-MUL<4O`}aa=WRf>GXCwrFmY_drGdfa0fcRjjUk2q@|HF@Wiz4HAKc}F|
zw@<GV%Y`2N`;SRb_q)+&!@zb;_ozds@TGu&K=4F4oz&tgS~=I}ujJyL7^U`g<?27a
zl_vz;cWL?iqT$~!|5A&>N*+Xzrdjp$^aSq2FiYA#DCIg1*D9y}-Ec22+ga%xL++a7
z^%uiF&BO39_yBI}!IO$Ltnl0K_SC@0f`KYYq<&=D82c(E^vP<IDK4$2+b~PTv6YS<
zhI5*=1|7^yNT=0xMn5I}@nX}3{b?xCzsvRcJLONj+n@Yw9b0_t*!DSQ(gU>a=&<8~
zU#rl!a8YUxF8sqhZ581LXu93!sKWgGs$8>7HTrSqqL780`>Kt%zjr0RCkT&E8?0N<
zGBUPAy!sU#)UQi1nHwUcYzmcxX@pu^`un~bC?{$+?|^X~jX80d*O_l<w_<DT=a6xA
z;lOj&aT{~+)?v3FHqH0kw+U1rG_Q=*YF1?C?<ULL2~3&F&V9k467ts&!$D`Yi*}@d
z*B8pcX2^<H_$%9p>(o;Vf2*6R$xPK5ah{{8`-()<9Wh_*irqVd21H-*WkP&=jXXpn
z?iEGpn}`VHGL-u0tFGe?KKckRzu+3KI6uOsFfy!WP(p2L624Mh+e~CW-+ErDhz#r_
zO9boE;XQ^45{q>-&W6~I>fcsedCwEb-dD8!384jBjN$1fb8i;ntZ4V~PX`Ko=`?&?
z%p};%>%T~!n~AEc5>AQYnXO7MOQlc;!|YxzX?LBL8UCgb%iegybu|7sFoxFffyZr`
z*O-3?Y-jVr3k0r*3up<`zl4TG`Ydl$9$!;GHKkW2;$<d_N9;=s*~;=9LgPby<#4Kz
zGM4ERo6zU&i|+~5$BSypuWX5U^RHk|*7&Rz*NIpXI=5Hg_KO1VE2O+cki&AVK(VRM
z_Z`0BaPg4~Z-90)r<WvJLJH%@x`I!66LJA?8k`vQakH${mQvV71A9{G10U|VXmWM#
z&lu$Yt3x0ZVPTNflTITH9gS~@J1TTKy!6mzkC;mXPTmb|??jyfA{kjfD#{eCO{l%z
z_#IWlS?ha3W}{Bn(N^jN|J&yvPly8&PCG2>>2Xva-%#JEtXdO@^uM|vL#Mc+koknW
zJI+|VZSo?X7k4u3VZl2-6E3@mBaa?~!9Tv-aY<HPpXL8QI|lMMI4VT<A<sUG`kx_!
z-=ZO%sg2!;yKz)S6T>p@hR9JnQ|jFGi!y^E-S=WshxA0#_U>E@)Cq#b<>2^p5Qe?%
z^?!vnWd43=4fmJFMKuf+eC4ECY{x7^?H62>$#%iDT1uE^?CKLw#J-KN>KSS4B0JqP
zKAd!Z>nE<rL>aR4sT2KGypmG>-%Aa0w}r)06&jH0%`DRIDvglONC{D<=q=AGD=UD}
zm^S3vxcoiw)HS&vX4l{>Ik5cFO$2#MyapP%`{w`cQ%~3*_Q@sg<+TY&6j~=1f}Uz1
zXXXL7Mq3uITfElCq4SHApVfnLLqFS5dD%%P_r^1S|IF;+T4sTmAn+NW!6?@&&>0co
z`R^?#Ar$kNiwpir?1xYHNOyRh;)Q7pgnR9pi!vpn(~eOWzNL-CZAZk>NeTucyThB|
z1;&G=uXNN)*3L)%hQBIBe2FIQa^r<~a&`gr$|Q+Rsr5%fHhD8^Z%V^kAI&Q3P3J!;
z{|S7ap!!Hi*dtBAvMV1&L^O&XZORNuo^I+<2d;W+5OSCtOrlipZ5%!tVdVRGe-j9o
z6=O&3wjS9#=;)AiHD>Lg?kGB?caDzzJ;QzBKif8WOhhp8|9fyG@XsE8bTE7sp%ZV(
z6zP-{y&`R>#q%8a=xVA>rZy497A@wD)ilkBcvSmzpmK~|31;S0Kq{9Qo^~O8{S{hF
z;-diWcS6Qm-vkqEuo5UeQ$bvRO0(LQ&ZXS^i^YFeKCJi~qo?xr@BZRxTf?4lgQSge
zKXX%Pb3d0j<oi`$IjuR)VcDQjcpz7Eg5(CflC%wlU6rn!8&&H`V05;hr1jP-@))eI
z+%{rn@DC;!5DAyt9GBb2*74M4@kfO8j=)pxm2gzAkoIo>uFKB~?-cj=ldT{%aQF}P
z_s>$vIN*>MR;yE2u4(Gks=2k(G{h8kC-NSOCGo4|D{e&VT77g{EhRVfE-~tJJ8cf_
zf)-5HSlxP?$TqLuu7%*VYk4qh2p#0Jfg}-$;6d<1m|NX^=zD{Yb57#lfhaNLGD({f
zd<nel#Vf$J%%D=bZpHCykSmej0hx3vJXvcuwXfeM9rb#k*l9?+Pk@w+Y%O62m~+-G
z*u_J(zwBh#taOKaqe0$^YJ!&4spH_s7hsQ`W_+;|=g-zS+NedRyW!gt=AJj$NTyUH
zML9;sz^IR~<9An!8kW%R5s)z`XZO2CT&M*RW?EwFUYhFh982P={yL1qpH5UzUH0OB
z&jua_w$c1KR<mABwG-mme2*KqtH1jtYrXd@aZhKaGUayE_Z{9WkBt4g=JS38+L<+u
z`-^GR9zd|W@aupn=PSn3hm!H1j7Rn*;*mz&bps7-&=EP^ZSq!QH;VCtRXHCA{BqeD
zuZo<_I#}+lGu+}<=eC&THvMb1I?DjfVypA11HE>j+AmYMoFIb(1IYx6Zd$&_Vlh0e
z8`~1J-+rF`C8u`R%TF$uFPcri73c%olXVGvbH8oI&iaHxw&)mDE6)a7zLWBo_9gLG
z%rRFV0Grfmd;DQj2q}1?|Mt|Q?rRfqyIwv%oXLX+Z~mNh%>S7B6|dpq!aKC>qU`GE
z=PAi(p+<?ezJuWnxN`!dNkR;+t5s`;*mc?E#-m3q?rs8Pp*1TYEqQA|0U8@#Td>8)
z24-~NxBKw=j_Rg5bd&x!F0#<+@E2#1$uNTBl%0!+RY{~D@nVTVG;>FxCXGS&GEo0p
zPp+9Y5@u@LF3<-T1NZ=wYj&}io>6;lW5`?euXioHuFmU3c_RAjoLAIQ7j|1C*`$>l
z19sJ@zy_Ydc(c(0%EG0D!ul+&T)2$Pw!UDpc8xo_(;r1hqyP<eyfCc(;gS#?tYCUE
z!{fwF_eYK2m~SYRmsDHG<q_q9&Y0EsnQ>_H^6NPd*i`i*yFW<wF)8OP7r#Gb0ZuAk
z)}(OaFbLVjf%Hs`;NT{*d>B4(H3uxjQa*EQHzLsYzDy$qeaXQ`hv+!=g0^RS*+aiJ
z*uM&W=hxt-#g-QxlSh|6mbS8WC^c?{KwfG)A3LSW?I6hOFHbVs+j+!8olM$u=j0Im
zRZHj&<))G@_i^0vfdbVhc*z-ksJ8pQS(`|+!ID(1H<}@KW~5N~CX7uCLvgq;^hGp<
z*x$px<6;L=KHEyOQ!*_w_prOb7wK6l>HoMW!%JB*GCST*>0ZJ@d!}KR09o^s$7~gN
zLYFJK5zeX|Dw9!^9$eAqYLAQ-kdLItYsFSyEpU!FRT6!+@Rhb%z#)kd#ek$UnX8#O
z)=d-}*5zxeSxcewh<TMBE#9+{Jne+&hl;Z(q`i5l<7D*VWIMA*Bb)UsgOCB_Pkd^S
z#>ef=IPRCIXElC?9{D<p%pX6zjKrnE=L3<0_T933toyBIVv_X{NrQ*kv=R_l^)sjS
zy{FlZD1U$dA9kN?k3g_B2b!y1{4OBaET-*-QR2uRdDJ*;G9-z#-yEj^-VvF1LPIq8
z#<6*55YNg=*OktINLr0DW9=dxG<6|YtL|`0@$BT;iRA>6hw9GWWo^;#-oGC}%#MBy
z;iOZn{5YBiUjogO0?o2kCeP;P<_5$bZ{4NrnKkaeYY5)<CiF6DN(WF3#so^Qj4<l+
z+%6sX7{#K-WAxD^g~ms0_aca%<nte1nflU@YO^iIO8L@!&0kq=Am*uDWsB5_e?)ZW
zxhH40&v!zTBte&x9|;r+!5c&W(*i&eZe+q{6^M*p-H&iH!oycz{Q3R+cc~C)n1HN}
zLMr03H??x^r{b>RWLp}1=To<)B?T+r<%vP(IWKg3j_RkSJyXC2(D_wB;bp#h*-JG!
zn$K&@Hw=oEtS0mK`33udp^kus>Wkz>1V&~?q`!UUoqP*HP%G?*aY@I-^d!_@T==(<
z?R;R56Z(L)lCM8^jhZOQt@Q@Mk7PO}ng$GDf$E4KqD4b<dn_TXY2^vI)o?Nin{hef
z3-Z0<Ijwgn?dXDfjNz7jBMd_yYOr)H4ZX@kN<dEyY7r-yxzet)05ZaAJVT-+GExSU
zrGxKD;E$QW!fuxPdfYeb2G9^J+Lf<Mw9hSkBkpd2L>`WvTM$)l+fw%DOACimb9Xv+
z>w(1#YbzO<AjWkvT7Ay~e(wop5C{A(lXeU|FPV1xdM%oMXS9W(e*SxV_iT)0&o|cS
zgyl1goR7wT&#j`ge>#`Z&B+~*h_CtOd(nEFqFcawqaJP&LZ0whHE<oYrTlUS8D(<U
zBa^b6Xz|(;(|GobCE?|t^1>B!Lzy@188RD+#RA7;L{z>G+tbIFUxjB$Q8c&D$-~f}
z>`x_&?z$7lb#=H`Ntk2|7viBYsq+qDa6}7tmHV%})un+`5_~Aaa^>DtuHs5oO%!+h
zLtKGz-FY5y3$_^~MpCI#+4dz0^4qmy(Fvir)gDL|!Ed-jhpm36y?4L5CNUXwXSaXx
zQ0LrUsa$3QtdRBfbwCw(t)A{Lu)Mp&zunvw%aA}J=9`t3r7MOJ%cS9(@dTKMH}}te
zmWBzX@ERer26jQ1d8H7aA%VvN_r{CLf#2Sk#l~3y?cY^6+R!*H&@xVSsB)OSDLOqw
zd8BYqUW*C2-y{+ABw&n2hV>%2%sOzXXFZILv>Zx7I=Iz-=Xz~0Lt5rr&WyW;6UN|k
zA&d`t_gEt%MuKF^U3Dfhu&h?44(Y$Ww69+taL0IbN~i9^MMJ}fOG^KJd>f%*lF93R
zeedPYg4|aw5Wd5sl@~hxyJQ_Z2Y)SDWKh2jd|cAUE~txRVFD(&%2!WdDJ~WPd-K_7
zoP%^UqlmNP!~y;sY90%ci2>G08paZh`!PuIZ1i-n1~nC8{p?zwJr3trFVlIbYZNKu
zfUJFid({#f2^`vHD}ngJuDd(nfpc&w8XE6wgVj22bjO!4-d%Roao#$_<i88?bo_zy
z#OQ{*Vl7g>-_JRkLD}`9gErZ{ybrACNN(@RVe$q_v~CE5;MC65c&;9G0-s<v-0pZL
zLQf?U9(NbbJPlVg_hImI-Us^1_)AWG#<v&NHwAh3EoGl<Z_kIkXRN?-dX({v2=X#t
zw`-C$^q1qnEBj7{hMtec9}8#KmS~x^PM|67ECjDV>YN8gFH_Wz1d*M8SQD=%7j{q6
z^6On#&;@yX;M=+|JAYKu)V@$?w{bGwt!7hhHK$Oen2}VojyEd^B8D$GObuQWhSAC+
zo$a>r)M}6&M$QA#9ydMEk(^KNYjrp{WCFI^XZs)r3wj=u*|5Qme06T4RJ0{RNSLbi
za=Xw%S7D)6-RRQ3c%fz$`}q`kAU*@)$3+It<q7#2G-gArV!Gg6KLnC+Ou`+0k;JnF
zbwan<>rdrAwVSRqu>qI`A_?@nM70DlKm3Om^TsLz-Bma!@0G9Rq~<M;A{{XX=oEIw
z2CF1^k6AHp?u4E2dMvmC@7&TPmJi19)?*@py=IVxacdHttOY%89O3cvo&o*sw|Ez@
z<C!tM_6V&qXA3}60Z(-bk31P}qrEqvMt~#NA#fTxHfPEL$H$mm9oT!Vut?O4biAGv
zrrsR(xpBMy$x$}rwwkbC@7En{h5;|6KaaT8WUUW@;*6cy7%|tPUAsDP%6pe?jfc*W
zvu*Bl%*m&oR!mvdSZw?4QacW}SG10=XoJWM6OH5@hy-X&UZO&UQv{sYHB>mD(?ttH
zDM1Y<ty%5u?V|TEuL?C{xlgBi6u$zyy0~`zbe$PtgY!jAZ#1QNjms2km?+f%ntj-5
zxD-ah9NOa|E9ux4k_QfJ{`RI-R>D}2u+f0Pz*oZDe$j^$RvfmV$G0<J36jayoX~>A
ziQ@R1G_tMPk(nPd8-w2W>y2rDT$oSag+J1#ty2MEO9}M0)>hydEd8AN6@*%g9Lh}G
zc$kp0?Fthm`rm7Og&@gqEVlvZpw>5>OPV0ZWFU`@>BwUrxCdGS38Ixa(IAc3874~~
zJi3$Y_7^k!{r4JOdn0K=Y^(-JW=?vx?(mxoR_gXU3$OQZN5LWKb_Lp1&YQy<cg``F
zyAsB<QdnTKfR3_D=rmmSTRTQH5p0a0==`7^XzM}Db#lnEZgV1ne#sH0xVQXJhjw1A
zgh`uh7_Gdb)UmnP+aHz!;B^%bpe=XbI~}Y(td4(uR4I<>aWGNYF?ZdcV|X~`Tb~Gu
zVgOG#Guh<Kv6?QbhjkSd6}@{8yL{?c6EEBNpWK7G2caUj)&y{zi-x0v&^Zs%Qjv^J
zJ7?jkLnOb(?`Ml0v}E4{18J(H4YR#6E_Ox^v)^hwr}A4?#}jIHUc$DLL-=CT2T=H-
zNo*~5#+S4$%}B?*ern5+VLV;b^tZ4cnATT=)NIz9C#7S%s~8wmDp4M1;<sl#&oExl
zPz2t*tj}P3dgX&zLgM{j>dBXO`hlgQIT;lLq!CBBDq(RmHcO#y@@fw5#<h{)ak4FF
zb7Br!`t;C(BjXD3c5FEKIH0r?U8V@)*zH^cQ#>%`xm}{7U>@-iiCMqTzHqV{)g^mf
z)KO5qhtN`-TlYUxgFrt2q*Hx)0~iTFi~}s*h}&j&T--Q-G}!e1)Yr32ys&%QZYH&O
zqe#Q(DHc&9@@r)T*Z8^WXPyVu_Jphtac{p3T*nxZ;7hkvI(Um{^If^eB8Kn-(H~VM
zkJuRsd7*`?Svs!&BO5@Pib}L6(g=yqK7@Tj>z-MR<u$v3pFI13;Amp0h!D9{Z=6Ol
zCO`g9HUN5@Vu5-5*L#?qcWT&xK{7DqqO1*ltvmjwS*+i438K=!m^y8nWm3~o1&N10
zf|K42Ak0%IaL15-HPkFnRA3n&jl?>K-v1hmJjp~#9!Cu6Z{j%&ol~uDooL-!lEiO-
zMGzPVIl_z+_w<EF;v~?zNy9rC2h0k!a#Upf|1yn14>!KvxAP=A4Q~l~RQ`-Tc5y=d
zf!N*u6Qva61e^}~FMxj*9C%Nsj(3~HN_%5@aHM(p1V4L#B_N3v;g>CnN8!ozJy!a-
z!)LY3hm{8__BnoUVJ003)EL@RU=Z@%?4c%g+KSp=U-*^*QXk(&n%1Tj2n7FKVmf(X
z`t6LOo5^%*`{B|R&7@TF!45+a|KZ;U(m31(_s2o^PCGi(-lxAo>Ir7JwBpzc&<ySQ
zb{U}kr|4Z_s$SO29o0Z{r$jt$3vmsbtylj(){}~lW_7Sd+DU0R?#{~@cC$(O8v7fY
zjX~;$+vM)tzwMlc;-L;W8QAB-vR(2cA_}SUqdRgtSQHx-(KVQhR!$}ZCs?r*n8xg7
z%AB(7(BOO~9H}w54KYBcy!{Hw*Q{Gb;RsLESixju%t1Vtn9G#)XeAc7^8P4B5#Gl>
zce^GB_Kn$kEe!`$VpRhU@c}(P*lVuW{+ur?^pdUyD(9xSmxnT1siL63s!s$lx&L5B
z14qycB}8dg6)2(-Q@C(Ue8<v}7r$kZ>#1Q5r$hW)ra%mnkK(E?ZXY}t%FQ0StjD(e
z=Y0hnz0i2o&{sD}PB0GppRDut0^aneMbPDV1^^0nDrQErL{LD}=uYOS0H-NirB+L3
z;A>Z}w~nrX&+cM^@3~r2{i7gX6t4fr+9+c<Z!imh1Oa^2tuE%l2{AJ&_nVncQ_*BV
zf#!Fpq?s7KMd7m!--tHf5#fIijKo}b9B+c<_lpzvleXRZ>%~KP0+ur-fP7iTu$rh2
zo_S}mew<i!xQzhS9VmG^B55n8@GyV{AdEEytLOUc9?>nK_*lA?k*6}E%6CW|LwIXg
zeasGU=Co-34leKMOvFCtW@I$%dcwT}SD?F-tW3b<q;At*{QT247A`mIfBins-xgC2
ztl=f%maCodhd)nSU!0xl08WlU4`5Bux}G0{%YGy1m<8YjeJ8HPx+v#Q@~^6(Dc2xa
zw==ntdMoRg48;WETat4Y-O4}9UTvW%XGe$o3@QbnO6)2TObNVU&r!*iVY&^303Tk7
ze}Kj<?Fl%fdlF_jjF7v?7;th=xY+6*F&hI}=qkyj4<Khc8ZtUt^kv9siFSLojutFW
zaJ<2G-9JxzAK0!XERV7S2Ik9C@|PJil?u&3moV&%3J3`AgSiPh&F*>ttQ4bF^7QGn
z8x$nf0cWZm_}o%>L22oBc{-M@yj7(w2&w>izZ=%`+`ENTuQe(xei4>fCaJq0n~hnt
z$Fb=H`!QfN+Tr=3cN5v<N?X$E*ry@#-x#g*b@r&@Kd?~wjE`%P(0Ed$+nl4PC@O7k
zHpcjfgg0h1Grv1yhGZ-HJM<G~-$dnv*MH8HZ0y0(QnKTd8ndzd*lgv^(QMSmwUFXu
zQ*Gjd&B})`ZNOD9U6BGVEa%PmH3F9N$oR(=SOKj7MN)fo&|l|rs#WPY@S=Dsw-4;e
z#=9fAW64{mud>@1poIqQVGAJHGw^#~(^vd-xKP9IXd$gd+MvhkP-bSTNW{&d1lU6b
z4mBHmzQ;~$*S}Dso|8Y{2>6v8Juo@tu<d%4ZNy_atqE+TiWyRh2?e1iKOUQmRm|PI
zab4CB4<R!fs5NnPJaZ7fdh>aYp%_FneLcW2M9ZcmGk7EB%b(cD4?)fvNCaxCR<~K)
za=Mfk__3(+?_)XpB<}(?8g6YwrGH3B8Z8JvNI6hjC{pj}K|F`O`(C`Km&WG-xO3T0
z42IE>Zc;6*Hf)MedcDk}eAXz#P6lfWyPp1dnm<u?L%7^=7HBm=u%{i2Ooj@nCpIuE
z^%A&rF%;u}#)3jDvNs?Fs#SACaU4e}egdk+GOMw2P@`Dyg5^ZOq&=CY7AY^}8frOE
z4#);m`ttS1y)M8$8Ht^>I)pPvsq3`7K5)rz$NOcG>Y-M|58y;h6Ow+$a@`d=7x8mT
z&ImtB)yh0Krsw*~?A+>*VA{b-<G?GHS%Zv#VDyK(mIDXwpzSHoc`i$ia=vInpWvKF
zM~X)ef}=w0(q1}-nG$ur=bhw>Mf|p=KKW|q{E)CWi65p269(^;|K<o(eoh5v3Z)(p
zg0UPab^?)05Jl{Y<srvkNB;i2@CO*L-GS9~xha{~rhJ0*l<`b|0E9BbGD!tj1rM{J
zezqV+>P&MJE3^BtfU00kwMIo2ciDrH9bc%bUnUDSSzDrvIoSe%WGBxrv0WKZJMcGZ
zn#yy18{6uXS_vW|c%(Y!(_|i(+E4X4+jqFglGaH@p`V>2rZj5B_0KedMbh7JjKBu>
zBL~A4=YMarwJ18R&9M{@)uPY)QRE)8wRT&(hc`b~K=lOjnXhrZ5-Q>-y`*CpMXrm?
z<rVkFe=q&&OAJo{>>Y|@X&<np!&Iql9OtglsXQH!ld{n_TNgz^MwY`r+@m|A%TaZL
z1zkUCN>rFM!Y->#kBQkMp#|!s`1m7vl1so!IcXvB1Jtom0a@EzW@8Fo%M5t05)F(1
zc|2R@piFfj?RaZsV|M4M7IXoeR6eOT=nkC)z_e=I>)^+xVlXm;(}_ZP7WEW9H|MDn
z(y8+JScmh@Xb|;>7HFn+wI}iOWW#cf90hKfQp&kwzSh)?mg&f7VpReORHqc=t?A3R
zlow|?x)f3pTndH5_3X)NnNIc@U&?C+TcX5$ooHr;8>joLm|fV+(Z}PvpiT|GNfhes
zT3mb39@Xw>0)j6?nUaiC{|$D~sm4inG@;nx@n|C7b>G_uF%vG+H#PcxC%4QWY#O&i
zQYNGraE-pArS1%;^wWxGFk+^8#-4vl{-*I8efenwbFerBkJo0|cru-hs5jl~M%^;g
z+tR_x%)xuc<)r-&p8V-S6<8g{GwBN6mZ1VyU8NfadxP-(#TKCM)`1+4(m6Orgo(&5
zYW7xqs<6*DauHIikh6eesQ29%Y_BQy4062cVO(m&d2t5S^w7Oze2+=^cwcI<E#K?5
zouNS$72cOzF(xN&c;2W&#@L0mYA;7G>%Nt_W7Z4CO!(_5wVIAHHd>;(W@t(Tv5R=m
z3$wkk@$>Vm=TEwu;~xIolQ)t98xD1LIQ(LwM0m80!~)(Ek)iK*8A{5}X89+UN<|Vv
zNT+Fh7?TgqHse{TeX7&oNOik`2?!F>e=_bGZRk)dGXpV(7Th#corNT%P^$uX_>K)o
zD~v~n-P&kYjKNm7&G`xVDcSq^7#X)$VzphX+m-;LN4?5<XZMh>_N4WehV_!aTBqqw
zit8To8vUj~yTpEfP`IOg28ir~K8Nj{G?IxRD3{98@UEwQ-EwfTpevSzgJLYceaSFo
z<t!kQLR<1{*gCaz{3Gmld~87RqDXb}WSSe{HXr$@Gvs4uEn-vQu@&=63SUEgB*Y!w
zlomT9S&{eIG=-z)RZ$hf==spg+ZyntRwM(oVAtbp1GGrg8+0S{!0~UgXn--6NeMBk
zOb><s>1EQ&p<<$zeg-Rb>?oM20b1tLZq*-)6%#?TUaNx;GqA?MRwuvbjNmkh0&hrQ
z-RA$YxSZrr8bwng3&gWxqdo#sQdy(eF`MhF^A!eYN2!Jfqx#kAx`TxE9H2W5Q2JF^
zxZx-lOcf2h$iAGx0RhkIw_aD^L7M;jMgRLVW*KcBlli2Yo79A66()q8Q<lxSwP7eZ
zKl2C+9tQivCGbw|SJHV!G(I-xPPiET?T#c2G|2~F1SChwb||d0sw0cIc%E|T$M&cN
zU9G7^aILDx{YjH5A03VoS8--s!Q<dpi)HeQ?_w#h)%(v0ATjpto1bw1LcLYP&3?eI
zlzfd}DuBlc-th^p1Dd=xo#AymNDEX~Da-?8@>{+WGC*_QJ>CT64GE8F|7vp0((d_e
zxkWu{L40sT>-zL;ry?45u*N<Z39`S^d(M;7He*pKnFzsBlbwoK%d2FMf-yiS92%LO
zS|zKFro7~1XFu@kh%{!=I>8aXt_2al`^bjfgXmljMov5!m+42?*fDrHfxjNBM_p=^
zng2HGoBi1q65d^)m|+d<{n^+~e<B-FM1AOlQMhDe1bBE1eO!RLmReZ1f6xyCq6pXP
zD<4<A%*BrdcOjp1BY<7PjVG_tIO8j++1O~k;z4I=e^7SW$40&H-`x-r1QzhXQ9En<
z9<AyJ?k6Sw$~TCuzY<>m5HXG8^Ij|j%$jF@biy52@}L=IsoF5R)$IH1shBnZ-|V-n
zr938QGd&MfKD<$Vcc*No&O(BSX56Cb&bjdU{0y-2pS$p@<=3P*=3P#d82yVfqfeDt
zh~24tdwm69T#u(O!8TW`&63^2LW58&0d0)i&XT(FP^SCxf***ucpT20lDi+oPamIX
zQ09K(rX3^QzxY@k@m~6xN<_}N5+LCy{cwJ+DT2I2toHWlz^{}BRPW`}r%zc<w!~8I
z0h92j<Xo_+60yGnOtz*}F~1J#OeF``EVI{utx>5wpi&S|e5!4fRnSzGcnt0B-wHlP
zC|$P((z(3nHY&sqHedDNCUiC%v<*e>uj7Ujs`rMbSF8LUQXw#omzeCeSm|~$pl&Um
zjHh5^zabbAJRg7g?>G|{6A%&tr)vUhqkWZ0GwY)cCmEm(hornw$kGwvb>y-IVV*Ev
zrA(|;>=0~H_Q(x6wqFeQV!v6Q%O$>vr<RTZ=c@CaS7x!vqM)O7#oXF$<~E&2i@oj8
z4tD+>rK|I?18q0$ERC8`5EK)w!i5Z?dwFo}m$=pNJ`=TR(%i2XF`G_subbdPYKhD>
z-C-d8ZMum6HG0@IXv}}5^hA-Ol~u3D=Op4QCoS$`z-Ldcve7&vxFCY#1d$f2ky$vI
z&(M+EWicZplWEHxx`yETRR~`V;8xP!@D0l4j>6*BFx4BRZ0;9;%P~eYRx|rOBVqjy
zP4P^v#2}Trpf25IhAv5rHueFB+!yP$UeeNJOF~S1`scP#M@Q9tz4z!_8`<~_#LL;(
zF9d97ukN8PPAn&CCz{0kgh@{CDRY~DWcka021z$8{ZXd-khFQHsakO|N1-O&D4w^F
zWkZFn?<tSbWf?;17j(Q{Pl{?LM**WKFnBcH-;SHywkL5;0*k!-1D=^8L^=h^h_HMx
z!DugqmL~%FSCM$m3tTjaU(eQ~yhDXD-jCXD_g@d(*ck$Byl)beUgW-NWJlJwZ7$4o
z6It<5*M7lFQnS_YRqOIsPM)PMc2)jXM0YIc^*21bHiExtuTD2JB|v*)4UAPnm}ts5
zc_|{!MkO9cl9-dhU+@0YO(32>Kw9a`YH3Qj`OJqCtB@BHT|jzId-nx&-`l=Dxnr^R
zGh)AY5ahk2Gg(GlBmxk<j3rS_C3-0<SumUDMbFXlM1S>sG>OLQ>R(}O61|q%9TSM|
z)heNWh+<gP)LRsZ92^T{SZ=z*b4RQ(jwAD}>*QA$H^lPZa!QFySj1IS3>w5z0Z_I9
z+3G!D=%kZW!aD3IQ;HzvzZeG@@0kG*kI^faukbkT0!#HWj7VbWO4A_M%C#x|l^S%l
zhzlEc155V3pautqbT-AEr1+w!7Gqs5#<<>GqRb;@=fAAY*{PCmJAbtHy3~o##`<2|
zn~!Nqj+wo#$rN^lcj&|yhu>~e^90lsXy*4Bzl&7;X&;dcLy$+4RIlo0J{qZd-m;Z)
zR~q^%u0vB*rXmuaU2mr)1IZf{=sN0OHP(|&FUMVS;Uc=uYrR4&js?{bJc={pyUQxU
z{0gT^SEC->yzeNXw*Xeph{b+eB1q((8Ncf(e4$8S+*8ILohKKQ*Wal5K!aC4!jihE
z+_nHopWSbyi*tF*`0F~lSarPC^r{eXFTg|*FQE(}p4s`TYMbpHgbVx#3~e;`?+}Qk
z1ctb{xXazJCh+l%OdtI9Jy)jRzw$1z#GsADh&e~ZQz)r~v*b<e7#5XwKO=qf{*%tB
zN>K@gA4%5(6E-r{v*v1vGHS|nNe7oon${OKe>1)sJRu=rSRzA%ynJ$wMl`JhKKbQw
z1Qpx!O@T&stCEdn>(mcbtw~likvzHfiy}6@=w|F_1SKt2Pq6cf&F>8-JYSWOUj3-w
z95pP;$YH};^uiYFtsaF7Ee(zDt^c9D0&}pjJ>vGoK27|M#&bneLS<Ek*DG8?Bx7RY
zU1Dlo=SEp6s}f%v8_^xozZG_q7>&^a1YZVYp2sK*X|73rLcJtKzZLgiuY1G{Hv*^O
zzhWa8F9&_wSZB(9#eUStEWKbvF}_iz7s<e&Rc@tOo<D_Q|4<`EjH}`~yvS1|?MIC&
zRm~j;723si(5xT`{QX-NgX|QTI&c#mno=gHD0J0~;G|%|bnTJN<EZ-7%5twiF&ar~
zxYI9!vCyA?!*F_Ya2*YPqllvBR5q%AHyD+LR!v{=Oh3j^HV6U_`KqkYD{}IC{%KD~
zgU07m9buB`Z=U@>rc{<?&>>WKgN;WD#IFA?aPS{ICQoW+%CQX5vNsx;Z~E(Avh`y#
z46{I9z7HdgbJe+hlY0*P|HSux<Y{n)iSyn^)YkKcm^bzz=;S^7I;+SjD<;Qyd#}o#
z244I%8lPAB;LOFi{~2>rWL4NmhFWyYZbq<#3-Xdw)QWMn)-#UeA^6u4W^W<h8u4Jv
z!GV4HQJL9xG2?iA>GBQ>(i2T0rM;=~?B%UNOF|=ky^eo%<z9Bc-^ZwEd$xQrfj~sK
zdMiX9GDv$s>iO>u$c77mJwEnFbQs2b!`lxmezU5N@#VfoMdLA|Do&fm3bZiQ<p~K$
z@tPqJ9*hS%xBuIo@Zl%MmW6r6B@2-b(j`+SUmRMzEiUq(8e-szr3Fo-OTu^tdF0gf
z#!Wcj%-RRPYBD7j{)k~<pIv<q@UWT_NdPS(MupmOfc@=EVVMJlp;`A+6hIL%Yh+^W
zq@l+$!M*^#62RBZ*%{^XtCxofCh~i@cZN1>&s4C`aF+wE$krU}YuVQ=B4P!w2FsN7
z^EKya7U(F@(*!R;VYLe)EdKsr^uq%*gKxJtLXky4LU!@S;!+BB{{H#21sXpd28Ws0
z5*q5WL##?X1JlkBDP~dB0+V;;!<lO!d{X(UO}4YYS4n$pK3e(ZI7hjog}P-5lyQ<@
z;q74}NP2*V^(H0v4+=`;U8`WJPvo@SlSZNg;*Z#3{5vbq{IK7d6$EfrMzvzjENE=?
zh56Op>f{0~vfeNXy^Fkwl+ctnK%ZQ;aQ+E21b{1bc?~jsjGUInqsecatTzie*x~Ja
zK)=C)Jh^iO-Q9O&#r^lhwwzrh$fZNdGw2+?!;}QWLUclua=-L2suusL<(e-iI2o!-
zoIqtUSw1q#ko>DV%@<tb`6c!xvuK}NwCnDe?4av$V{6v`w1D|qr^9|x`q<9%gB2#F
z>Zm#frPd&DAo&3h&#~@ThB>gT!>_^w;ZZvP1Q6ZPj*WxUV7>Av8suTWEdK2n({_q?
z{@DXMn@rl(K?1t$VJ3hH@B*nM0i;zq+B8Ez0>6KaibaEnet<XYfja?_z@%E0O9CPb
z1#zV^J2}==C3Te<y(+a=PqzN2`-&JgH;;FsYD6JZgOfQWy`Xxis1J8~@b|s{iB)F~
zEa1pX$@FV~F0@d)Ua#12iW|28jN2%7P(XnO*JOE>U#EhCLM-$9(E_!hB{uP6askKJ
zu-RHgR0J~kL1^V#FMqLN7d_5&y*?BWjOhE{+dI#@(`Xlf57er6JqMkq`;V_kUWcMV
z_FoF0e|>nnmeL=J5;T@uko*wEw%mZN%+v2MATgGuOkv_^xv$~UOT^6l6Vo59p%@>f
zeJsef`O1dpo;1FE5b($y&I8%xe(2RN0#Lr|KPU=2t#8&YD;-)|<CrU$dy4@mps)dz
z{EdgG3e>JiSFdM&9!v#aE_Q+L^k4xqj=kx07Dc4I=Jk&1xl7v5pMabjL_pI@;$Z9n
zysA|Hw;;>(P1=gSk(kIWmoSN7OJ7PIGhj{!ICAgaO+U#Xu`STh(2P7`vuQmHw8Wy$
z@(C-igB2VV=ll-V&2V3Uc>nljc~eaCLCWVH0iEVqm66N!$>kO3tF97;6krqm0g>qG
z5-V6fg3EL?ORj5q_m^g^W4L`Zqnh5zCKq6Iq;rF{{l;c>+l+FS@l#fqK#_IEBMW5J
z)Qs}GckfWucF3x&-rr00KiEluBorVLa`O+#DRI0WRPu%};AT&ghKoL1g=4$R%+Z9c
zQnjo2=~hNd9vc(4=`wyyWJJ4EmlVE5yYoP|fMUVQtBVT06}|A9%B=8wD}V3%gPf^X
zDpVBvBftuUL&o>a`SRKMN;iT_8YJ>3%PeG1M{PV{^A#0_hj0%j7_cVn0#O!L>DW<y
zOk(;e_rtL=y)u9jj8#6w<FT44*Iz5Js=rK5w+>irSymuqc|V93{{6)#nIyoTh@M^w
zA)O>YJDmdnU~tIRYrJ0!o{qPhf0<0*t6|dJo$PdOVO&#w1Wi?lc8*pKL6@1+9C}Cf
z`d4TRm)MXkKDLE?TzXpk%5SMi*5<xR<s3C_->z$}V-EDj&?oo(XjPIT%3lEa7KlPx
ztPXI0zxKDrF}Maj5i7kaOt;nmwILehMGO;SAY~rlBvyN1Z*eQ!YRW-en{~>lXL4=A
z$Q^O9#WUwFU-$uZvoC~i5|a>SpqXFVZoO-iQs8*GWA9f1UX;H@ebgFy@>R+n!R^sr
z+Aj0s{L9CA4u_Uo9}nLp`4a7@hJC^nRl?A%Ri?|=q+(ps-yp-$Qdr<*yKfw*V^f=!
zge#qGEDa%%p))QqR{iPTQx*9_aOsgdL7>{O@NhN{dgGt1W16@-2zM`0c|2KQ2g!iW
zU4wZ6g`a-^ae&EVq23OL@vQmA6)@?y26-JHn22`X`Hc5NxHPKM{r({Bz`y`ld)Jtt
z-ozbozdYHI!FE<=jXn=(QC^xo+UhCzviryxlT>vhD2Qv{+R}&8MIVbythkZ!`EQI+
zuCdIooT7;Ps@dvxk2Ce+v5BtDTbRC!6HPPHUU4PCTJ4xgS=A%&$@ms=U`G_&M7whH
zA0c9?`0TCqOcHAj^m$c(ens1(es;+d#mx=mjM&ZCP5@HU4_L_L6%`p_@jkjYPZN>F
zLvZ^>yMj_ZN!$1<!%rN=hQyjH!`R7bs;2p!xo7`jBk<`T-y-`J2_0!s4S4Z5wT6@h
zGWwp)%inZU`q+i^f7S1ONsd$XCct?6>LE(V4uE3%PMod*6wYI>*Lc!=Kw#ib92#Ws
z{+Y{t@RJ7bR&z-z^uJ$tBm!4CFoL%Tb>)4cM@4sQWhCmd#3qcs){PcGoXh{9O88tz
z?OpfEE2ip!$hPwLF=i6B%;zzRacJ|e?(K?5qJ&W9DZqbmv%Pc*0PG*DLCTam@Kzsu
z84XyR%Gu7O>LD)#O`*t%no!f6;k-6Q?4v$g(86L2zv8yK24`VVeo;MUD(HL?aWsAa
z?RjVL%cfij_JtoiCbC-%8?PLkvzNw5Tg>fr?|qtT>Yq-+oZMk(lhVq2WJ-(P`2O`o
zzUb2qK;)PzIX%pfj=ef+K4mxTv;{sj)FsYv)>OMTV&+R<r*dwj$19K>K)ar8@{k+N
zQ#0y`Hv_Z+L0ZtuV&wYm+%t(Ibn%TkLgDA!EwAFXxO(M|X1)Qp%+)!bKlnm)O6q1_
ziC?h5xloTR#8<ND3HaNxEfu4|NL@09c+g?(8$7O>?T4M=S@*yTL+Bg(DtFW6r@`uF
zRKy(r$r28`QSUo0Hy2@!g+ux66%?D5VMoMDUqcM-;k(;_%2l2BO(I;DxCensxKd8P
z%$!^8wVJF9uZ!(oSi7iGZIJAe!*S54(EXX0czJo{vb+1KLbn9)fs+9z(3DxT_Uw<R
z2sWa;Hdpo%n55x6W>fW)Zf8@+17w#tR}2gtadm}DVn<*0z}5tYZWIC3;3pzdyu;Rn
zpBmE>tG(Q(vgaMNJ@jSd;LYLpnA~LW0EvD>mX5g9sp{{OrOQW&*K_&GYy<N2)b!Z?
zT6V)An9y^Rnp^=;no#LjPRDgKz*7Srt1w(DID!D#?YAuO*@cgCZLR^gTIIsHs>zLu
zv!o3_S3qOhjST77Wj||DfMtk8C_m?U(HQ&Dof`L9$DHhWfY6oG;=s+$WSI-fH@LL_
z=5n&kv~#8WV1-8RV)deI3)pDlZ_CbXZ<=5dQh<`Gi|cX&n@Bnd;NmkmgfqJ#&k0Km
zdaqiH$j1O@TD}1dXk+{y3x9r4H1j!Z@1d3p*UP0kXZqUYr#<H9(;qHf9J#NS?Bn$&
z3p#8bnc!yKN`!sFGQH6pZT>tx>CXY*8uY%lWJ!2jFMFOg03>+(fIdJmeYzP1BWz~M
z-MZJq>r$MYkN9`<Kl?~=f#G5GE>nnKXUpDyd>%!Rk?|uj`MPSXLep@f+GNint~QY~
z)vh3kAAXB<bgBTf<Y;;o$HU;U^)OJ|IUnqc->wTxYP5(1DwSSGssoM4lm7I$;~_$N
zUd|G7R~8Wh&Ysa$xsDFPp1d<Ng`a7^iB>i5y2l-wQ(x+bul67qHEWN2yu4?k-JFkI
z7k?u`Nx6f%`Ys+yny`2N3zTO54JlEG`_Ca^7fn=+^TM?9$<uabW3TWk<?<1wmZRyv
zvGiW8A5Me5h{x&iUr+{LJa=gAo&Zg}eCSwITQ!mn6yJm?x$OppV_W;{pc*$HE9YV=
zwmy##UKgGOq7$$H9CmRIrJ@cC@sH#`H)8fFRefx_V=?LQY-uuxsASdkV4((hxiSq0
zA~G<qRp0Tc*hc^iJ!qhU=|BKo9at&}Jp;9?ZTKf7aK(|kUu}R2U7;tBw?XjOJVne8
z$72sUB_s1Og+n}qKAN6@MH`qm-m*WXr}%PbJStOhcd~daaSu9F3lBh^^q9cj@!Jd`
zP9*b*O6sfBziVmQI4p4z039Jz6_ao2sU`Q@mvpZ@6SytG9E4pYA_T_)JT;4;iRpa0
z<1ydZfY%nv1TB~Oiu&eGecR*+-tcW^=^L$gyVTdyZ*Kkre&L?CwPCw}*cW}U(z$4J
ze=h}$yH-R8lJ4P24LO$kMoWuyY#nNqWPr`oQdhCz2$re6L}1_bQ#^E~E5Tu}@j4|q
zVeeWzrPOqw)@s*C!axX&JUX(UEO%?uYY7zEU%w&SK6(p!Z7$^QqTIXS(;hAN5t8Wl
zvfcnI$H}k8Va4lfFsVX-kFVOOu>M4?{Wy3_F}6_ieHZZe*h3YCfy17h`>JPEHX%$0
z4s12({_>E^xmvRjXl_+0lQN>@+B(VXPnxm?r_#V?=95uPrB`OfloP%j*&gu)8@}*<
z1e^EJPVVz3GBL$8qDfq0WUVV~2a}AcJ&?~&I|YsP-m{|;<{EC^rfByaZBBUrA^(Vt
z*X<=~r&sFS6XEHdfw(x;3mx|j^26;!>f4s>+=edwGsZBFg<TufYTX&%U_b+!Sw+?W
zddTw&1*;%evk^p@nF?c11TP2rd?xzs6?K@IFkRNruaCcS1H-Z+X@Wt^^wkz7A$=5Z
zl-e=efG!yFM5{(%xM~O;Kmpy>P@%IgP`w~)z^qc*e)gN3RM>qH%mVTYb^U%lw<El_
z8>Cj!7K*BrT9LAGPvFsuGU+B@P&DXB=`x@NH1^mVWl1tWA0IctFPg!dBe=E00NBq7
zC}tb9U><SAIH2&uKqIx-aH||ZyTm{~CqizT=Q35Dx-+UQ7*^~cnYFpvxfE_Tqd)3s
z8yr}D7K7dW{>>l6&u{r(v%^~|-YD8GvY8petP8~}E(etB+D!T&5>x?o@>;b9bomXJ
z?wx>|=(<1A2AHQzf6?*m()RXPFXmm5yO`SuwGxk?WD@u#wylBqxk6{_N~Z?5^HN1A
z%wiaUAz8?Nnh-##jNUm`YQd@$eE{G^_G&W$j5~6>JaIrC2uGBG6E&E~<k##M`YBhX
z%yvT&n4FcmC<^Q4aQQ%oJeYWtwoE1(9E#LR;7s6vjlaz}1U#HqpgDjeL{{V6Qw=uG
z=;$MyTtG~+jRCenuu-_2xVs~F4`*UydE}FA)>y!#k|tIx#fG8GJ^|Y^|FJDMvu>C4
z#_T4ZIn*uoHejhWhF;mayN0~|=fQG^Y>(czLr}d*dR;!VvkV@<*1U`8>x{{lc?hMG
z@Oh4(GomjE3xx|xt(bPeD174!s(*78ZNGms#Y*A*-Y+Jk+}>rmLcH`THHPQ+C!{(t
z&k2~$BS)tkkQY~xp<wzSW4OL2!?e50wd?u1l6{qAN@gD*(gHh$^-8x%MQUeXtNag=
z*b7<plkJgMOFaV=c&GVdlRFtDTmm%e@iIppnCd~h)lrjq8QR*jYwiS{0)OA&xQ~mM
zEz)qg&}L7{H<mYc27sutC_CSon~03AYN5%Wx+N;ZXTZK)URly}fS<cu;B-hR0EQ=B
z1Z&tL2i?Hjl{<wu*+$7fg~kdrJm%1GxB&<i3M2n=yvcQ04EB$MCh=+>lP}O4FYk?*
zu7Z>|8wn?*<T*n{M1t8Zi*{s(vwoi>eZZ_R`}z6QeF3w@?*WmM<-70tkW;%J29T>?
zjc6Fz-|Q`>{O!yfsOiRklY6ilA#1C#6YO0p&2|u6QnB=sHv{cCbqzz!$Hd%IwT4?i
z&`{Yc0Ix)A7K;!(k~r-p<-fIWXc}7UkyKRvgiQ|oPYWnnnX%YuOw3WHZ@4_k0^<jQ
zoOZoWPG_VCp%^Q{M1lvKWoEJ(Gh#dOM0a*LFuwq22Jnc9-9&SnPhKtKg#yXFa7awc
zY{aV8dSugOYFd`w0U&8>uLi#ZdpI$e3gmQnb7pof#kaXHe!~N@8Og{IAO*ga`jM|H
z$mB(%nURXSk%-MeQi3RKH|tq8BN(pzAT#^W|ABE5@5NYNs#T4C^Sphlk$1e!1#uc>
zZ{6@OsDTT?jP<~vx%ubl2hyukX~-Jk!B8|Ekp?ODr-oO5TU&j}?#c4)Ie!`+51lPk
zqg;q%Cb=MafQe}r<Q80w-4#Qp@%xX((U-HJY^8PY6A;o6x?bk!JKj8Rj!L0?^~dnR
zQ4P84)$#H!(s&{b47ymxQR>;=XjpC!ck2&>dL-~PfQB~V>#&qbqxLvmWF8D`D9FlR
zTFWc#ZP#NviUw2xvo*WbOLZ0E0~UV)9x)qQ!96nya#IFt1zJmO?!#HS-hg}QQ7SHP
zjip{@?he9p;LRlr&eVWLmnw_f>UN2f_v!bYnNC1Kr<Lq4qzx(5%JsdZ3wxV!;d*|c
zAV`EcJT>D`?rhbqabgI9EE(qUgMb|P_|UQb60Qdhvyv_iLVC}%B!6OHua^gP-*rY_
zo{&0z>3_l(C?|fZeU!fFJPHgu0W!CB4=95iMmEd9VNDnedJ_H7<ni9o@l9)r_wo}`
z(jH3zLS{fu<CS)FjJvD_<%ylgxKtRnv{ec6M(<N3lM8o6t_*qkpa%mz=*+Yy*01|@
z9Mv;9bl|+*d8X;!ukAvJ;-`t6*xmLDla^uPFlcWC>Z0f0RuTXoOJXw$%Ds9pu6;lM
zi`B(3e5}&p9!izBXwZRMJ0f(|yvq0K)^Tf`8RZ9p;a9YHdIH}_Y@-W1c?%zSa{u*k
z_KyGQz)KjPHyk7`L*1k|`b1|2|19tOunK!_^mE?smCxFT-eQ*itY%43tYd%AU~Hn}
zwTfC=MaJ+Dj!}chOhITE_1}#D^joo@cnnk7Ocvj4M&Bio#tNvz&-6f2aY;htLB2uf
zX3eOV9p5UKpa;Y|#O`ufy<yf0q#|`3BW0TNXiNN>rqV;~c2Rc*5|5$6lNOgDNwyqp
z#*LUjs!9{<evw@54g^kMJ_xVfKJHe6Lzxl?89#c)<Gtt3>^m@tM4E#zlGKMSgx!`T
zL<wq3!nvCNl!`0c&#y*M?vASV)c6<JGe%V%02j`_vD6}am3y9BNPGEEhbD94d4I!h
zQoj12MW>h+dD2Z=8nibF6BF}S7mbI@0TkvaK*ncPD8v$`%MaAY_2P{zqZIeR>gtLe
zLBGeOAgRPUBeyeMmLM|^5W4w*{3Otah!W81<AH_HiZ23N%?_Dk7}_4W?v2C!m(h_N
z;*T2;54>Q80P46@n2N(kzImbg9WJ}^v!g{iCgR9WT%v{A4gGY`Bkk@83&q!)Cr9@o
z61Zr1*gnf2!+W1SEQqT8LE_@Qkq(u0iG7zX?yofWSM)>zmXsZ40yp#-jrx!&_o<J4
z0l%&!UP`@FpQ4W|$xJ)=3KkCg{w2wD<2f&?aJaE@0V34DONa`U`8bV;A2nDOd2nV3
zf4t8gF@KLM3mS?<zXmBqkRxn2W>U&5<sUl=NvbiHeZ2XdrB24DE4HxTdCr}KEG}<m
zAFsZ;W(NhfO{>ZD0gydOBc$-CcLmdaU?ujbx>JW7SfSk1=;<>C^>6<Owd=q2Q-V`I
z@6D$&O<iXq+9hnJ!St@1el8w-4#oZjpv}CriMtggOTRw?C}T10ha1av1#b*aODrcV
zpW^Xwg3Wjm42aaa*?wBJBVorAampM_JWPu&A~jcoG(QH`8F}GLO|gT|TcZG_bt%z*
zaZEH;Qg6RA30j?!ja`lc&Wd1+AN5o`+8*rXpTxbJ2kDexAK={@OL2!4?M+u5hF%wL
z)mb1#?%oCAk1&6eFmoHkLu~WOVk#LQ&*(oRJQFdiQ~{&g;$1)R9%)w4C`aUs&R27W
z`#|93{N~T4)DwP>R&!An*)T!Qo}|^di0!IGo`~2vIzE@2Aooa?B92S!YpZdv*{yRv
z&S6}Bk}@}R(Ikfx#bUJj6HFhBH&xEPIyx*BzEKyttZ-WDbmiJ<+m-N<dvQt^p8@o_
zy{#iP;cJ0>o3_V=*lqxvDV(ymk`AJ#VF}J2H7;P|RJ11{*;4k%x-&zZ{{$a@M~Fpa
zttX5^A}i=c4oeriOi0Meq7ufGHtYR8KR>NH_=h%d+Z`@gl-lQk3#%D$Apu@;5y(!A
zO4XlU_wn)Z`OXqdFE}j}Gzvg0*(;ClZ-fDF{HbFe|8367QzO%t#xp~K!CdDz9Wton
z27hr(F-I@uk=N+<&-4fIlcX|Z+Fz`TF<GN6<`R4pHE@@w4}0R<UYvFP{h?d1SYt;t
z+hblxlv3&aRy6eM<C(j1&pP(M-U^a;9KXg9{+8XUnW>=<{H?rtH=qzJ^A9k?f_{J`
zl2Z`V`kl>MC)df+De%T?yBm%JdshBjQTB)9oErOGlj*Dl&^O`pSP+f14DE^Iy38QF
zMDgjv!7JWK1{GeqK54gQfu^}|a$s;?pjlU~7TJ1KoTpx=G71>Z`KrIu$h62ozVv|E
zW4GRoIxzM@t>eYCE|@;a&gl#a_)=zALC|m(36E8bg*|f8?Rc}SbFm7HPFw7rD6y*F
zCyu7|5H<vL9xy}*1)P6O=BoR%jJgIP?Uk<B5_k_W5z#rw=VE!@Jowiwns4~<J$I00
zU;fn#oowTH!GXe~FFkBkaL(dXXO+%RTnna)R3<m<b6eIpHUtToKSr@RRMpotbsxAG
z|7tIx=8L_fiqCfE`CTzza=$e53=Fy9#KzP_LEfdP_IBzrV5JrYEAto5*i6kMf_4`1
zO@j6m(4Ghcb*g5m<HqG~5U>Q86xO3yG%HyR`WpeIwPSucf?66-4%4Re1v_KtWFrm~
z4VFRk0C)>PCO;D(W=Vxy4bD524dUJR27cM!;7ohW{WFZS=P7@O-+=7W;$KM@!i_#0
zFwOxOXVm9x#>yKiLR0pXWBvFV*d2A|k8#L(H&c5_H!jBV=RSfFhUd>D6e76<L0r9J
zPR0GeK{$-6{-)j~`?^`a^&04D9P-Cm3O^^EDdIrZOmgcHzU8mu&;}Vw!8za)|Iv3*
zz^^{*wnn;4cDlhckE}snxix+L7?FbZnevuT0))XQ$z<|EQE?}o<HgpF*$|_uX5y3F
z^Yl9FUw6L$g26L-iv#V~ODA=q{Yk!Y-jeB2qgD(sZ?t*obuff`cl>xcWlX=<AZcA5
z-YS2_4)U&4q}i?;i`2#PDXxnH;9x(v8Vi%B$(XF0qLf+w%Ll^8iF2#K@O*icJye(M
zlmphT?O={_j`?_{6KGzo_S{g4`C?IOdz7h1cMj_=i24A-@!?o}Nz7H%HqeA-Nd?&*
zkkbbLkEpkdi}L%vzlRW{MM6U9P&x#pk#3ak4(aZekd%^6m5}akLAtv`VCe1`xDS4Q
z-~T;NeR&OY#ktPjd#(4%WYTP~nk!|;XVkdq5y2|aY|d5ug9_lYZ`8{mZw5{`hYuHB
zvve21eLbbyY-+vRc*p=0X!-UY@t`U=1t9xgu(Oie1+S~){w}G;tv-PF=7%<80qdmL
zmnIOjrBPx0U59EE>y<!--RfVUbqDU|&FJ?C>yk!_x5$_;v-?wF^L%5Q3Ig}9lPAxd
z9{tu+2NkWV(K9qTug)~aSDkk!cs%Z|3OFpcXE|(U{P^s~_7%?E7~soCR-nQF67>>=
zDsx1M9Udao7pr~>J=-2<a5nb82(sB0`)fSTd#)qe%s*-SbexRUWLJ}}eH3lMBRY=o
z3Gax#IY%RREt(I1ie*QNWAC%v3J$sFm)tSuV$8pri%HEOh+wu)d^0He!&EE`jgj?~
zgc{jH*K8<*nsWM3hm4IaHp5Y$XAtP!z?k4qx?WhuUT<8U!)EV(9$qgYlVWyRRb_C?
zMHlb}<-*SR-<UPFgFy)(8*F3<c8G(N7W@4$;KkXUE(P>b#-obf5X`0~;0QQ<!4%!T
ztLD2u$KmlAbciAzG=SG<w6beLVx{%>%PAkF`=fTo;lX4iFq4L_SIK=(5l>9af}vQn
z8hL!8-f^U9`0kr|bRDl%N~KUT*}mq%o@#-bkyIk?#V;c$l_%#HM912wwAh%!6@1EX
z+9RA!57Low>?BvY`Fb=NnpxUZ@EmzmU~uQd;Z(hTd7}avrP<5j0Vy2j3&3{;dRxOV
z@Ats43i$H7HX=81)QG)nM@LrgnR&OgUz}wSpKV{61b*GsFl%dyUJ-nvR0$pui20Lz
z5}Z1dOZz`w{1sU{<7VniSPlYE5^5`J8ZzU3dB*epVqF$g0x)bmC7=CZMEEXUon9T2
zyX6TIT#d!3S5FokcuhHX{u*^ZSvQ~kG24%zht6MCsqcR`N)UuLMkqym0?d0*uqOaQ
zY~XDi2flKk$a4Q9oreXH95?PwOGb|XPQl3%m7icD1(GNX$)q}8!SC;$H>mjQNpYgn
z5idBqOl`UeXQ^DVUv5VeFBBMD_z+^q0ZbXvF?jX;c^*psR1B#<1oKJ|lC7{cEXc?A
z5}qI%_sw&7?}LSUdz_XV_nj&*Q&!2>&i}n%t5UaL1BSdT5TUuvvt)MA5zXBIE?(7Q
z-O~@7^8A@zeBd!;n9a_7_Q^4#_^H2(>$+l<3&v&dp_R46GNt+vd7Ekult|*`1A%@?
zU@`kIb>$hL?;0+4fpm(ftE+>^o*$SoE+wal#sn@u7&M|QU(WgtK>W^79Q6Drkdm7f
zE)R&E`7Qp|m4mf9F-ER8IT;HQUGQ4BNPUz-OtbovJXdWhr>(om3~}L95zKI}+kb6N
z=ngS--l<UUK($pBiOxol;35pUzwS?RHDZ6)hQ+3Z{&(eSVrZHUVOw+?nGXO<xf$!T
zzmmbkT7(9p8NXjrT=9YTJB#ol)rVvgT^!6$pO4Z4GWuQrw_az9={^AbzWWmNpbA-F
z>uCeAy+hyL;J}i{Nj>AG@wTxt@9zjDA({DZYqt-B)~<=OYzZ0^lh5=L5INWX(pqC=
z2GJUXBF7A;Q1e@2OVUPLh<#&&kUb&a4j&jMQ^Cf;;RWMf(Bp2t--!mUtw1BrcMu!r
zt>MQr4OYbX`y+`6kJKeZf~P1-D7R?(t!2jDR~XTmNVO_VQRA!U{8T~sP&yXKbHtc1
zh~GD1OqdBIo2KRZqH#P=0n6>XZ7@3F(F3NR6TCMOF*f$GVXFY>0{`HGLxMlX!dKn?
z=8b6g?A$Wy(79JVKEAKasSKOT=9LxVrG2`G;JCU9QO(r(cIVe1Br?S4LL^AESC-Fv
zy7h%fCAQoD^#bZ00ieTl{m1~&7(|Q(Als-nal=4d5i<S7o7<eN8IOg`?rl*iVokqC
z8glQCC|G~zM7#8*w7ZO+?i>HX&y`of0$O2H)BW)h*P!@B!0%xGF?SSNX9@}QYqI{6
z4#Y~mJ;QUyABiNbK_y(LoF7|lG1ZpG4#^hT!fI6=+yN@atXg;^VUcY(SK&8;Ytzr$
zRZ;0WVzUPn+jS2(>ZWm9g4Gy)=&KUxLY)`1$+eQzi+aqprc?L{26jz?)vO7oC>l>1
zf+~u$un{nX#VzzBkdc6VDA_d-F8W5j!bt-(jE<Hu{G4Re)d`wW81(AH{70UK3x*`|
zN|kBrmeFHZk)Mj9;mj<?(QHQ8%iW7&a15F$Qrd`Vrq&njZF{T0e*&UQzPK%knnd<7
zy92I|tPt||huFqzpzA>4Ljrk*dWI$2V#@+iq~>)!1Oj>DyD<1@o9_=wKuVp#^?;Rd
zuquGXFq0rP!k4gM{oruG{-=x^ce+fpY=56k!=-_Ry7X#n5dMup<k#rWGYQRx6o&QW
zi~1@RH1MVa9Oh+nD-Lw3-*d_Jg<`WB5gi<w;DOl1o-$8SWQJXGP*gXJ>J%AJA)L@)
z*W;-WaM7L--2)P^?VM^6FQ(=%JrQX=kwF_O3Fr-~e)$&9G;V>+pmctYajDnaeWQ*t
zev^L31fSBbZ{7^(`sGUOSg{^New~zzuQcP3g7MHHPeq5E5x3D41wn9Q5E>rv+nk}o
z3c-EoL9b8t)(f$$_1Vfm7`sbj+km{Ui8^7vag3Hvv6HWyQ<w88r|^<U62}6OYLToF
zYr+gYsxI$%!pY}kQ$3{GL*WSyix5AgUNH~ev%>I@PY^$h>_@Pp9U2Z5;v8y5O<;kN
zL-2$2`7TGLTJm*)vW7m^E%jt!D)LAl8OlK5OK5IhKLf1>chCCo<m*gE9Y!`S4gV40
zZB%aS`ql~tg`iuUXe(n=wS$!5a4=sbJyRw7nNIEv##4S;Nh_4%b@RH_4EnUsG}jFh
zcDSZkkQKYSJepaTW(eqFl1-C>2tJxiYn964?5Dg?zwTnQe|!FHm&4F-lDwQ%92gL*
zEJGthIn-E}l0Gr-hjH|?j!r1HK_pSO64XrHLE#c0i!WCf@PYuiTHEe_CWKAHzSutW
zBG?r=fI?C!PodFrYsdl&gF)SR{L=aUcMurqecJ$rGLUZ$f&{=Urv-L!3j$ab`8e#$
zU6=1cq${BLJq?Y%5B)-2rZ*T$)eWx&WyX0vmG)Os)&tj)sIFYMG#y!HK|LB)*q`(%
z>Wh05$vDxJ2_`)NRffBNm4#!Z6%50hKS3WTlP^9Hck0(vRgmZDfMoME{8Nk7;xl8o
zSA!uF!i}KqbQ+KM4j3=qSwpM9#H7o4!q(CE0qp!hgn4qGPU9s3$KUfu8Up$0^;Kwi
z;@xbkUS<{tRS&?zp91Ib6WEpcLDRL8&;1kg5;({k$)-b^1rFM>_@pqcH>K$LK62-M
za+O@FSG7OL1~g7T%0AiSXqqZ&ox*LChNU2tk<03LIJxw$MV`l2Te`QhLZ1^8Q*#Dg
z%Fx(ZMVO;@i>Gpy&4S4}`1noqK^e73-LKjk51S}I4IZ!2F1a6e)OC@bdmqf2gyRbV
zpmuEJDYlj{CW~WLX*`ZhT?3WL28%xPC0&~ANG<{c=5b2i35z2>l}KPJD@`{foV+cU
z-~#oKD?zl(93kAcQjJ6Ed0cNvXPUIbvohI|4HdCR)fv#8g#aHl?5xrrT(RDCdbQy^
z51<ql$mj~kXNEx=55Xo?<)>zKUWQi_XurQt1yNZWz$N@?@DL6EV*8Q;kBHNHvfc=}
zB3F-)vkB<vK=~or*zy3CX~+OL7a!P$n}rBh2ykrlHeI9jkhy~a<aX0WUxN2Z=;I`^
z^Gj05boIX1k1icct_79o9ks}{>Ns_GF`+7R7;59R?!Yh8m^lq8qj>86lbD>Rs@zpp
z#2OK=q2;Uzg)fbgx@?QMC1>u!SYNOz&(Mn_8=?Q>M+%`ncKvBHx6=Vl3pD@1tjh*8
zHv*_^v?D?2_DJnRTk!d=_wg((*j64~TV;Yf7s=ZF;LcqTZMp=|YKMTI?1RDYI^YC$
z4?#_2(z!X=wcR4>0&^VY-seDf__OQe7l4D<0k}QvM&R-yl@b&P4NkKsz@PGnt)x2U
zZd*A2)v^)5p%v3UsolcXj_1nV2GyK);+898iehQj<IXFs{zWoTZmP)0O{XsZj3M@Y
zs)*lUsIRlm8eMZ0``HWp|9;GtY}(l%h^FD5FVTSH$!C6SQZJv@dnF8{2n8hkE>2@y
z%QY6We4hl@XuW3Z*I>hZFsgXVsbBYCa2MBd?K2TFy<iQJjc=e@wxql+O@=}90aNP(
zF+V{eqnuUUy%uA=H4%V(amo9to;0o%wz`J3Y&rRZ&|3AEoz{4QE0A40g%b?t3VgQZ
zw`QXGNdk>m3DMD$P30gUCo>+gCgm4LZJbPadAm!7dAz#}PG6#@)Q8m3k>LEIVoU$W
zB_A9h8DwnutbZT6faZ^z89!qy2jVhd2WdWreyW$+FzQz5oE%=BcNJKuk87T-Gw1;M
zP^XrsfO5g8c|z;nWFnmyR!9>K_NGXxK=Z-OLz4??E(dl{2?BUK7&k_{2|sV+lhn~3
zQ$kx>nA@GR&T*_k(_DasL=4x|adzs;p+EcYo+npi@%3S|+8+ewlUXo%DT&5N<=5h@
zcLy;PHT1j4*EpcD+z*1-b>iMAb%6)thGTbpcNPFxu-wmq(h~3nlvzK?h4e6J9LSC)
zRRIdcJBAGcs1}}bOCOo>W$rndl45<dKxy^rL|F7EnN<r4`h>z5CVW=+=j@`t85VKt
zh?Ll0)zb*Y9*-0tf=M~}keQH)5s~0emD<|Yy93G#0Nf*4OL3V1x86*RwP&0-hRNWR
z^*o*0*^8=2md#lkOwWhk9n3%#50It;C9fSefaF-URD)I|3q%o@fh8A+KERa=K_)R)
ziUOGMqHzY+0;yHH_(CQ{KFfyRbTj)&nG`O&x;j3dPU!-s*|x`9F(&m>og|~hI~qm~
zXr%Z5mZ$8eKrEMv3sq>91qcWp*ZVsh1wr1kYOcQ)vOE_c@~c?4l9PwWqy4v7t8Dsx
z8|?ClbuvIIxmf_KArU@)jr066E9<cdC-wP!v)1(YQjE-#ac1DExzb*~2et3NYxft+
z|AHehD9BPqkNr>l)fhjIdwD~5l@-Ql8j)MJYIR^?D7TARecNCCE@z$;PjnkMQN<#b
zD7A>)$+x8h+(r2si360K%93ds_smg(WB*}vsltGQ==LhWb=hOHd6iP)PnQSqI$e2X
z>e_Q0%zTG|^LT?n-~>!X@J~)!1*{~;X(B(@P!Z1#t-n-{1A2ix5O4tSbd#lOo2Lo_
z5w|-tS#ZqjL+O@NY4yPdPKQ$_J5_{WjwswN!DTUbqB3q${X9iBCxfk$CA>a-BCu6f
z&Q;XXu|l`>`WZb`AdCZ@+dIa<&WuE#+>_rR17w17T-W_ZrNP+C_QUT6eA8Z%LEVAS
zAdC)rGdTyQfe05>_ILR#mgEun{r=48|3!tH6P|q3i2bG9Jd|)=$Yv%l#d`+it%Pi*
z1J5-xfvL1Nk;|43L%fB<6sTMPFwH88AG0X*Yv^~awmOOuYGds2L9*FDvgjx__G+nl
zo_tKS3h-p<j^{g*7S+U7%S~UYLHKEiX!UZ7H?PrvD?yQ7R+(?4=XfbsBTf7Jd;j>B
z`Xmh2_7d*+l6p?VrX>P^hs`B^{w7i96w*!nv{=K^9yWH5hg2G&HPs=xq8Z+}H|k99
zrBR@F`=Jp{r)pwQ#ZA4g-tE(?_cEex?-*C1JOd0#jTE8}4zJ`Twn+YaNEN?=A7zH3
z@v*zqClufhRe%ZVQt*x{gQ#INTo3kqxb@x9^*!_cY@_Rgzwh$H);I|M;RL-8Fs`$E
zo9WaqZ}M6rYcSchexyZvy^>8%+fh}w#J%o|yXdDXwVBEWwrDXU8oUaL9^*ly0yAz4
zHO*Rw6H1Ppm@mZHA<Y9>G$d?(#r1K<WN+O^et>P5U#QfdDDt+)XBCp4v{3KR%mppJ
zvJ^G|MfcC{rsZnSsNIhrL8CkUZt?{{V1SDiE%^;{LAY&coxeAnpc_w=6z3=-t(F*x
zZYr%cIFema4Ta-`=_nocVYf|m{zTg@vb;bMWq51G^Ww#K!iLqHMI`>Q+7#lXUh~fw
z92e90okLDQ=MFw(uRc^s#wZAS02#2*Nk~83RGOEPEXM9e-`qy78^=JA>W}XRg9h2N
z4HLcb)FSC(VV`ny*~Zov#7&L1DJ_NH6Hn0p)D=6csh|H45L^GVFbAcmh3xac#~mD=
zDx&z62%3L_#xLVwQ*3GL0zHw$Q(}811V;{<S=BZ=yo3_tGLFPjYnIe6C^@^>-HI}E
z6N97uDcqd1_{~!zrluQPitVH5@c&jea6lmnmM3M@R2&km7A5Y%${#9!CH5xCo%aWN
z%OJ7PqF9QH5jSYX@|@ml_O?x|=ok7Eek=}#cf{gaG)jiflD$assLd1nyI?lx{g$Qc
zKYtTA>eCn&Jz^E5akSoRw+%0mo%iIOrEV-LzxZRP)0jf*(@f;9o5xraE?B0M_{-Eq
z*>|<Yh5BQfQwG9vgtOxTcXsVuv!pC6bV?uYpJnRtkc4VatDr+cCK7b?(^Covj`SPx
z&wj9_I{Fb8{>_L-#n-6P*0EG&mQ5E5=1$cpM^B$Mt+GTcqjMOHC;K0}8|-r1Sle30
zrlohSEY&8()oZmY_cVsqM|76I?)_XJ(X+wAsX<#{`;r{uW171`e`2fwKl8k~A|@x8
zyPH5C{2Bi~p%g<@>M0H`#nC4D(($-Z)rAVY(jw79g{M{h><Qg0i6_onm1o5?r_%Fr
zC^Cc$c@NHgQ`&9+KYDxt5e>&hs=G{I;?qK(7j>MHxni7!Dnk{&Xp&Zk=b(AG(}5=^
zJ<VJ}xKjDt&aC!s32UqD8y!5vV(vJK{5_3FY5Bj;)5t3*oQp>DS1bmR?0s+3blg0T
zGV*!>sd9Ka7^=K}m2FOA*U~!ro2>ucL4i-BWFRu((>eah@$G&5!=<Q}H4f^3fEDcj
zK4f^$h6(g*kyI<m?ae6k;)(m|?qAq2OmO_)zxzE~wMWxO<8{WXH7O&gAddaJ;q&Ux
zysXTxF=tcOn<O}{o!5!~>jnJppzZcpCGnjAzfFUr`dMkn#EJb6?d2<e^jWn3eJiHd
zChZAj#BtV8;cwqL3g7L1TemCrxBo-(`+XxDfxAHCNr)rwjTFL*d<R5_|9$caC2E3$
zCgiC-r>sy0V*F7dc9zHcmr9>tttC4D-R5;-QY<J5%wH*{Y?2V=rGpv4E)X;A)Lzev
z5T67I?%&z8LtCX~tQJLGach7F9N+L<bKo8A_=WlSC4PX*+g~~Ke_sf!UXcG6uHfhN
zo=y1wom@X<^h-t{w18wwm<}cbf~@yn+f$$!0Saue9{fAf6ENHm@}T16bOAD>2EpSA
zFuy^#RNQzV@!c6V>CYzwLnLKc5Q{lmx%sYpodA-pv^AW$gt%4g2lwK*iFQYO@2eRA
zNoqv_53g;{ia&_;@~$wm6~vHDUCeazI8UiAZM~5O$+Y0NXB(bC`x|dFebGDgL4_>=
z+A!PycQDYeXorL5dxAqz9lKrHAn0y2f}qdX#u}s+hjTh>8$cFYx1VOhVgn~@aY40Z
zp~Uw>2!areNq)}jbLVz*n)hF^E)RICqR$y1LN_^^O8h_{`lvjj@@RIt{bl~(xz`Ki
z35WBy8nNBrG%NB)5_788`uv>U#Xv(FXG!LUY$N6SBoj<ldtQ<}mi|6<H2dQq7{>D7
zUzR;yYI{f$B`BS6SZ>q}T-xG0iOTkwOT&-*c(f{O@5^AhRF{WJWNtKwq~OdB7Y&Um
zpfv(5nYV4KCxPTMYytE~x#JQcUzs56AqgbFDf`@wK47?gX9nl_tuXM|H#oa*0X&J^
zwTmJU{u{s}*!3F~>UFSW_}px-nK3<L(26uF*`5*gzypZy-XwW|X3ZxTvwnQwUC;+_
zl3cel-^E87&?>D_sb1^X_BP1E+*SVa=FQn)48Lb0GB5jz#6ta#6|g$`^#T<d*!f8Y
zfGpf*LDMslMUrM8{v9x0c7P5L;s+Chk>dM>m|=d8Gq)PGLmvbr*hz=62aZ0O@pBhH
zcMF}zn+O7l0f4+i8o7lk6U*)|jm7HKH*?jNPQH8R9;|{akXrP!&BuJqoADMO*iGN0
z<;5#Lp1Z-(WnY*HX!8<2CB*!1XS;%*1<(Q6{(v$2w>P615RG*U#ho=RriygyK9B=*
z=<Q2Ed&7>dL1HfJ-1AmsESLS056er#`dhZoM-qzDdKEusk+R-Q*|#QK=oSX|S1dRP
z_Egm4>lH-)vhq|=`?se2pCh>wM9n5J=+yXh<ie0K)85&i^i39m{rLq*lV|rHQfW}m
z2b$kU2_zu=G6aErj->MK{(SAYrXxAmV!RK>fn4j-9?@k<*7Y4cJ!8&mR`dgo2=&rw
zOE)9KeEm)WUCnXBsnpw`j6j6{9_ZZ<*><Y{At4J4r+!YM{ec)1*>Mbh^}`4_Q$@ps
z(LtpDolJ-j9R&*fyA~(Zh1#Bg{q^?FN~rQLgksYLrg_VQs=$GNKST1R<ku%c7DzZA
z%aF9hxAyQ!ja0?UT4rs$=6`)`m{?yb2AduDzWjGcJHNgsWRcH@Ntvtc4WHg<ntw;t
zw<%3KQ$F4{nErULg+kr#kkeG*(iMXkzWU<de`%BBs~w8&1R&eLlDD{CFP_GXywcB+
z-~TpH1973Xo=W;zH3%^|Sc*`BupflkLFMnwG<q?XBSvI%4^Pg2{##texNN*-OiDuy
zLOS!nnN1+CFWhbD773S-)}wAA3&2s3gipH7*PH+5%%|;`s_S!Xtzte<v?h>VCW@v%
ze`Hbvv(!Nq|L-N9RHtI2to(L+$?m;6!6MUcofHz;KE*^7xxm=Tm>yT?5{Qm3(s@br
zuAGX@uU?_|d5b(l1*Iwmx!-=4v7A>ujw$tPKOOriZIoqw_?gfzQv?k9|9<E#l#Y{=
zlZJ*9VeyqjAPBNzghOF4fb5>d;IrppMAf_Or(C)9e{&dVvvF%f!uo}Uw(2$?YBE6L
zZyD8D4gVd(CQ0y>#Kg@5nRWx05QJUrQ?)q}@mJg$s#<4^wE8NR|Gp>N(aO><o0(7)
zR1z0%P9V8U?0Zx#2$-HMRNF4icw1&l$MR_<I(mnF)X1-%T6$49$pT|zdalEdV^A%N
zr(xQT-hw8j-_2YC!Y)%z566Hty6*mG#BdhRXXNpBNOsTcs0B-y_Qob#QGlc8e8;Na
zih}jU7iN2I{L=rlk~L%GxQJhtA!MmhBe6L5SxxB2G|Rf-J8BUdLfz|q6&2mm>UYjl
zOqQk25yJwNx*0Mw4$t%)-YX(M9zI*k>il-k5eAmiN5btRfdb{M8$fk(x3&m)M_+x5
z3GCJz)==LnjpOBrCzin={t>@Cq9<3pXWt}GP`Qmb-<X3?<fTi$HOGbg*3tC+*h2Ha
zom4jO0#_rD1LtY2ma$+xI<b3hBSS)-b==3`&_6roK^$-R4ieHD(deJeDYlxPRT9<E
zBX7=ymepBql^a}r5ej#;k#iqQNk{3ACLda$MbeB9x|%FPja*fd|M!O*t;>B}6UX>Z
znzfC7(-9RKY7pJRNnY28f~K#>obK42ZZcFPn!qykR|-JI)w>v-ExqIZZlv&N_Zm!g
zt_bvgA0&dJb3zFaAD?5tvoE}VW9~AKjzl$yz-teFtjWN@;D8J6^(y2oy^XrmWM_*G
zl01L*>~(pPUW)mF()y#b_NPkxKE$z=lF${Zpy)`Zfm8`C9s2JnAr3YW6>S4R*K}d{
ztDEy(DnD{>5vozv&Xn{G4WImY21L?tyAiKUUDm5w0b?M&^li-)Uzu9SzaWlmTVo3R
z^%el5qsZl7>+!?m33c+zS+vCLz|%9VDls*wV5{}gb0_>!bd4yX^<*&lPtSH+(Rh)l
zdcs7F=P54<sompgB7?0a9#1w6e%?nA@(>&F&+Z#T490sYNd8n`PMmh$zgzK|2mae`
zF3Hq@(_lqHBkfi7bKZH|!G(_{3%x@*vkr-cj$PjTH4ak*K2?tglq{X8)vlX;Lbho5
za4mA#6_m-HQ3i1lhZPWh9f-pFBx2UUO{Jz3M{XX>RLRAD-bcS(s1cf)tU2nhy+65s
z|Ef~0vgVt1!ioBhvAuv}>yU}s753vDL&hIaCjo&3++c`n+kPbv7D5~C=ScRNwYUEB
zlSbCSEUU!xfKsVa(?MM}u`|i*?D~3!RO@Ms70*yauRzf3E<vBR%O_`41cGe7(NWfq
zA3*~r>PKl(5<%%SS<_#@Z5R^(*K>9CvDT#G`&{#z-K;N={2Tb@Hb$%$@ao~7r9m7F
zYD$#e@fUdHP=_0ep|>_zL(Ubt^@@U)3oaq?k~L0cro;JE6h+B7C5*2aO~qry%lpU}
zf0Pi4H~D>|e5APnWwV%gU;PANa?+K5Zo2_wPqV>T4y~FZFrhXE`y~Bqc*t|AMdIJb
z{Fh~JSf}n^R1k{N7u1O2T#DI+XE24#hMFW3NKAusm#XS>^6Gg+^K}n06s7Pm$lW;T
zIjSoBlJS%=U}&-3@$_oU+D&%Hf2rqJsLfuB1V;er-aryL<+U&g)~xVZu{$3qq$O`V
zJ3GfVwacM&G;<7{;u783jV_T(7@xS^cW`HaQw3C-aQHK#3z40LvcjAZr^ZQfxgyXB
zS;%o9WGXnmPpeEL+cx_ARaSc~Y71lMxlk_j^>|_Nilt)|Q%S4RnmyX)WyboINf*-s
zaS<M>0u`nTKa7+A*!jJW1za8;w=Fv-r>cdwwl0+>gBgs(p}JrVa|UbJCj*AK#<AUV
zFf0hN*)<pYadmf%RyER^<OO(G!<kWF{v}y~#pf~Lspos!+z1773{&~r?b*$n$Ix4A
z)84dthYe|4bk7`+=nmj*dsiQ(ZE59-lp1M(KRfU4tiL_r%j0gzDT>yEZ%OCE?(QlS
z=$y-a)@W{)HS=7GxpX~qj6<I*>lNy*fezmsZ3?K`oy}`ilDTX%f-!cme4Qn8Ws?E^
zE~rg^1yRZly{y7zktnH=ox4yq<;-P~u*hm&HPkd+BaT|bg~@d@phh|^A5l%UsmkDw
zJbQ^aBASBw+STZ1s`tUeK=A;0C_)<m$L)1}y3v#IN&pM8O&HZJ!gW@~a=cBjz48bI
z^85p&58$eP_@&=&HCw?7rgEVwzZV+>yr$EODVX&RW(yA;hcB#VvNDPV0lnwZo;{S_
zdUXGV^zz{HZ`yWi9ah@SuG8~j1pu*fAMXMbC-+SlmLqgvv|PmVW@Rg1*L#acJkl+)
z!Q&DZ1;ovlwS?oH;KTuO%&WQDIR0<UYO46a2hxUcxm*jvd4cr4H-);tObv-0G#dO4
zFw#dh;Sx?yr9<gycu(Tn8>(CvmEii(M^v*bhEzh{xJK?fSLkU_M(pE`;?w<|v&f6p
zGru2%ND_3gY~@}6r1V)TAvQLk#K0{~z(ekO$N*bx8WbU0uPAwVpex@yKuk5Ga@_|+
z3eh%Sxf5i_3r5Aj1jo&xkI8&XDI5j!jTOediXfMRE{)IK;i{)ra<&00?P!wga@qAz
zhWX+r8(}@b;XGP^`(yy14sfVXeN#1>)IZKKDApZi+qUq7vI20vK2?HEDX@W~;`S&2
z8#s_trPf**LHvjzROQS=GT04}gznki<YKFld&e83s@f;zxx69)i;?NQsR-jXth9Ow
ze5xB?g3q3Wig)sn{_xab^F&)8&IET)on~Lv@WK;CAp|@6_qOmUXi)^ahtt73+d340
zNu2F3g_7!ia<P|l>*-~IWMcq8K$)#}{>J+t<Kkqqf0JZO<{TM|WM_PrkWR1JBl4c^
zz<QiV*0_77!dVNb=yGoO?f)7B0BGj^HLiCc6_)nJH0lkSAqCtm&<rIdF9kiqyBDrc
zfn0XB%3TJC?m>;VAPQosk~z?xUzXdLG<ynGy57pVb`}}5l>9_6uCzXNcwnawDsovt
zz<9<3tYg5ZNB$<2-c0^xCHWrXmLr-j(a9Dhay_?#x3k2#iox&I@z6SYx^P~lQ6}Wi
zSAUwu=N#(<r_o+TINWUp@~9LqNT<H0^Af)`f78G0dz#~!m`3rQZpoxy4V~a^;JpsC
zKlQSd8Vz{Hw@W2BcV`<9K?=vGX)tvG#u~~>0VNk#XJFLpU4{vv;jBgK5goyUZ3JSO
zmk3qp8VN`BrxeZl7p=Jkx|LJ@WpkL`j{oZg=r^ttYQyHd-`{-hv_F}6(_o#WR{#Wc
zxNj6^6kubiPhh7l9_KsfyU@<o53T=(`9MvvEw|DaPk$D?aw+hPghUlI*Pc^{#eMYp
zyWaa4LJqMJv!U0s0sb?|x>zPgm5M;m7lc5Ej;CE|!ykWGzx%b7tGF5H<$y*>E_Jd%
zb=G%f8B9r)KtxO?bTC6c2*8B<5mLD<g$<MNJ+o}V(n8{X^<Htvslj2R@53<IgV?-W
zP<gh2D|xr3noUPHr||r?=1j}$7L`vGP4SIMjqN4`QJ9nu-~zVJw%MH?G(kVKNTZ_e
za*Q8rp>e%&BkMt`80T5=vomXQ5QBThDQrt){Nzy3u5EY%eg&Tl<Y0rv)qVAP(<y3m
ze7O5|-}}s0=W(sf%Z$`(HCRiGqZz)pURrcrdVkKC!o{eWeZ=0JsaN-@_XLk#&%^z-
z)CQ2x_59q@I|6FLelbkCDGo;9?OP|oB7CcVnqUpwiy)4sO^#}me1wy4UD`K!$L1R!
z9NIP7UvfI0n-Ks6&c#XvBuS{*-Pj;~zTQ<c#81dr|Ec*3Facg_NdVPI-!~@jqmk7@
zwNg-(wHoKgN`^nN;dcN)F6F3hft&S8n<yvyX~B!uk|p)S3B9~HPMXm9hid^~-3;9U
zy43TH7nxY3*HdkYU&bD$z<kW-;XIM;$=hR)u5KQ)5xUk5dc<u9Wx9(zK>6(T@KZsv
z#_Fpe^<zZot>Z?K=&Lqw5^cP%(RRjfE(wcw=VKeY;ep&@BD;0rAlk9eY7jE8KkFCj
zQcP+9K@@rjxZGb>a4iEO6ngUKALk_3UL0UR$Z(x>hJk{|QyH)M%S!==Gms15)UTT>
zYu;+m0inY1)V;YXx2-h>mZf8NIoXRnE@uAuM=-4M&`Whv92^-gv*-%Qf)~*2M}$1h
z^HpKX`w0`I?<8+OGiR1TpRct|OmFNeVe@=d)z!Q`tu<1J;j!T#ugJxtVOgI%+-*7X
zqS(l&nYBWHia=K$jmynYB&!(3E15$JyOuOfta?R0jRULZ3iO1qW$X;vdEkY}aRiVH
z^cvLaT=t0`2{EGUslmLq_%MWo?W|tP+*%?eAs)(KHztNveBhsfXjaCK9S&}f-E=0l
zMZ3PDU<w(^RF8#LQAbtD#}tBiQHa8T@T>=nTuOAC#d9Om;@g9rm=}8}_6Q#tJ8}U_
zJcdR_i}7a{vE(919);W<X9SPiK%oK&3kd)F)cD!2rLXCZ%~5nZ6d=SEVfEDZS>Mj5
zhX*!8uAYMEn4^uoSx0~)K5^p%PqwRsbPsMRc!Xj_m6gBovL_^~w}^%U$~h1Tf;6SC
zj~jBb$!Ag0=!}SSwr3?Wp==#=giO?y1Yg-W|9-0hOrc8uRn;*RDT5BpBo0ghNO-?m
z31~`uM$PtF%(vXC;pkjd0Sn9vfB<bKBq5<e)&Tn4&r4qa8h?t+eFQS<5Z?R(H$M}4
zrxNlOj8iRv5TbI0x9sp%h6f>L9nVm&9`@3a^>M|BgUt>Vx0|`%gq>l2K3n1q!G(MO
z!3R(58KT&q&mm7y>EymGc^>L~Tgs+vz8q1sxqNUjb+sv_st<smxMylJc~(|drqX-f
z4&4rNkrb#oH|7WbQe_ltiiXn{whaX`XI7FF0wN;1{#TgDj~7xtD=w5H6q0UHVKOL<
z2HeVO$MJ~Zd~|wxr6ctoX=0pPN_ARccB))A|Betu#Y*Lj_1=!h9UPP}<wHr-=;~LI
z`^v(3X-;TYq^4NhIQdpK0I^8B-Xoq#Rw-BZeUEShmDoBvgbWh}3kwSc1v{BDS-{z%
zkJrEeNXY;}QnL%4@ZVYb%PKI8V1@FoCZ#Tgn>)soPG9F+N}t+y=O3c0)#qYH?53K1
zLwbWL7BZ4Hf6U*-#bW=}aJI0MMMS3p?;|j9&kF)0(LQ01IKGq{P)m9pt+aO>*-0ql
zHm?P)8r9BQhZ$l$eTsrfGf(^aX+0C1WJCxKS~{X}g1>AsTP!43=|jpyK0?fs$4*E{
zcPEV>hkG}HBZ{)>VwyhoO-^Gos#=?20S&B_Cc;4Ndq4UchCb!%k-K=N(wQ%GbYW!{
z*rAaxN80+pz<5hQr=iLL6De}|vhey^0ELp4cCW-aDYLT&jyT_PEw$EW)WinZ3>B$-
zJ(QT?A%9VX5&EzFx2xhft>=K06{KEq0RQB_2GVgn1V1j^;$us~ClksK$=o=4=HiNU
zrZ=rO={Cz_IdFO_Sb=X%bN4nt;rZtYXHc;U4Ka6Br+`X_O@axFpTA#;sO@5d9Hw>f
z*|rJ!wn{7XmRiGe4LaD<^O|%wPO`;*jRwW^#H&aIJO`n0Dk|Gll&~fA?eWEl`gkVm
zxs?@tBq6WQEg0MT7F3r0z7QdJ|G;mNIM1F5snw(NJx}TWY^#yQh>`Shc*sg!9Mvo)
zBP_3g?L<F6h1FDz1IK{SwLl|_ZSwDHV)K%P9YWp@Vmj>e2{8_6gc6X=-(viyj$P>6
z8^8EGD&3szn}y>`m+RcYZfkk6G?4Q<hPmU#Oy@jz*mi)pZi88UE3)i4A!HcaDK>@_
zuHh{<f*%mZ_dr4v0I6kUJ8`LmD&P^XD)h+<SC=Y^UsPcF9n}SE+YnrRuEs8dJt>xz
zvf2O!-f36bY<6UOCq>4r=hLe3XH&2ADI4at-w_`V6LnBY3Vq?5xxG9@e)1$&Doz|<
zlUdd%c;eL?^-}oZQlqS)^Rw+S=_dy-kTLIhJ(oTcbJ;}4X_x<|Ki`?ibrFxcg{`!H
zF;3?Ja==2RLf2Nf3ACA3+e2fiIK|b#(6~~a)}`BkOAuhgb=Hj?p%-M<pHgl29i9WM
z@A3h%BQ<BXH9++Ln|?#IHzcMNu#_t9=r?pNXT3nUI#{t1;!mNyr@B!G#>EPm9Gh+a
z0Wpu>SYw+9k5r(%5p!)b>|kys^xB_0=i+VtSY<~(I|o=XT(+=XV1JYn76HN!)n*Gk
zy0ZoeB%$B$ovNNZc@p}?d_1?_XYHmL{O+aZR8W~BwN(Z)rEkB*97St$grMj*OrT?8
z2IK8vg+ZIRMhtP<q@8f~HFL!cb2(k+`cq=C`ZbkeHucQ1D^26aGT>(z-V&<~cI80C
z(ch8*#?|{vbH<&-rB_{Ui!-3D+T?Iv5EX9}%(K}OG88S)+}c~dwPSooiqrp%P9xti
zs6*l_lX?}E#KoRioyR~1qh%#cq*(PtzEWtA=j8#TW>b~iZbF7!jO0)Z|2!y*fY03f
z;T~`q0F#OAxXHU)p4<=QW!+#@Q0<Yo-|0rx{&9FtGSTdCJ_nq}kNjt*<4s2Ocjh})
z0?h&;tA6Iw**=w~y%k2AOmF-iZf-N((O#$&D%R`!Cq})T+@+OEsnSj!)4hBu^jlc;
zeg9DI+x&6u2CwV6b7H_s5`gr-@Y_T=vDy;BfZIbTm+T~XQf6u{W??{C81E*#d<``g
zO}Q*S_XrbnwH$ii_9NDG5NUrj&?%lHd}u1E64$Ts@?g~4p?^X`V6K(#<XSxKmmVC4
z^XXJ^1mW0i_2mA%>z31n!+oM8*BGPO*O&Q9gqn$WlYI4hc7=M`AKu4)%aMs6NCgc1
zf<)cyiiIFle90J!KYR73mXp6Ss6xXF1`@f30jlg*zh6<oKCf$@bTXS%EY%dMP2<l^
zTIZb!=H{fRp&H{I-DVF)D8f>;r)`6iIk3kz+Z`(^t{5H`P8ZPwzSf5|CrCE_!Exfi
zE(x5ZdR=lGAn#Mc$zrk~tZ0bPT6D_7AEmt~wc!2Y-`$pJC&&67o1M1-Zw*`Fyy)oO
zb}g4>O(I6?4QoxmsL3C%PhE1Up2h>7IAEo!8v!?14NtOw#T>X>1x(i~Y1a{Mc}d<G
zb)f@s=AGlo#ORvOGMF~x$`VSYhp7O}P&&6~Ngc}1)E*GGG)fU<HjshS(W-H@k+^*i
z{601t?z(RNqURUsyyouRB|22`uL{@|2z2`T7hmx>1WE(&#m3zEuAc8DY~dQMmz9S4
zWe1#6_j(DxCtw@s{StzUMfAKpG;8ww3m%<oJ&%~<S*2c5CXFVy;~!!_<|!d4n7gze
zGr|uvJ=`H~G@S;QOc1hrzo?6~wNyxg@OawtbaXvDaVz%&5dlZiZ-&1!iakmBv0`xS
zM8+jtl_-@p#OPEuzYiR4x$4>HM!Inmsk(mu&Ipmg!N-T%*5s9>^R~cL6TiJt1mfPC
zLfe)`yHUv>Mo>STj^#+-FrITjjBwkX+UMBi6urdGilSIk2$HCe?A#n$^kmYdO5Ks}
zeg0?h_v^IAHFnR<!8o%OKOdk#;CH?Mt?<()Rlv~&9og%yvzOQPH`qekV3p-b#@v-!
z`zjgW4%3^ibzdKT@5s(+y)!*3%M=%{m4G~dNg?>tD~T^ifP*L<jBkc<sZgJ+)FYDa
zcZ;2pqa=hTjjDkh^eBrOLIlTTAAien+}$#5kx8~`G^bi*wt~5*MW$0pW<K0Shrdlt
zClv8WM2d;d;aE!8l&D<01aD_pX)q>f+Xqu?y)p^5!E6TbxflR8A^iG;GdzUgY~NMu
z;igfnk|x5lxU|~ppk4~Rw23D`n0PN6zt2qSoS@4d;^Jmc%%Y>pwjy<{&FyWe@4Zwe
zQ@Yj_tM{ixm)gU&cJ%GB$zQ7RHoH@{X|;BMfZ}|(+<JKakE@<4o5G`GC1ZF6E!N6c
z%K0&0jzcSr%d83-1PyW-oNE{R^P~INet}QZU5s&^!f@YgojF`Gz0^O7IJTq^0<1|m
z_^abkT?p}u$>0M#_FFa?<%;jB)?oxw{ge4$2y^Pb2&NVj-Ds5O_OUq{CReCmmh}uM
zSvBBJx&EAe+hV+ClO!jC?qo>I#wHyRRQA>Be1l$a?_lw1CashQ;;&<{OoWOKmJ7e=
zYklC(f8X5jCmfI4^J1ad^Kv{#hF+E5ivU=23Cm^GCLMk;jt9i`A1+jHj;vD7R+_{I
z(aPUR4EKUz1Ta0HT3o9&kwCx<WqZ67`15=g=Q1oe4un68Ncz|=Rh&=l&s%F&qoZI7
zIP9s9QJu+t(XDrwJoS@;?9JAeg0&FTfF?KZR_6m+u5G3d_$Lch^A+<c-fXV-#>VOA
zUI1n2WQE4~)<q9Q(obE1_l&iC)(Ui3&%Qr>deodq=$AJLE%wEL9n*RMuQ)#)6_qHi
zZk-#@0xM8bQVLvO{WOHy;kCYVyx0ps#?tjT7Q1LFGoC#uZ+%FncFYBtkm46Mo{Weq
zZ~O*aq7?i}#S4_%&b}BIM=Jk{8406$gXf<9t>+IMzIp1#nV513QI0rA9>k?6_~P&X
zdI2;&idMqA1zt+5$mIoxUmt`av<@VEb;C|3N!kfl?|9FYSj>L^KDc@9=hzxuX#O*p
zO5+8yjyR2CvLZEo(@B`RSR%F{`hy0;bdhc~Nd9o3Z}@F9UhpT{prcrhQMV?IsZQ$o
zbiv1F(@2Za{TNyO8z_@bMYa~Vcf<MtKs_9<-X6A0Rs6}$9~Y0f3(8P&h*;j6@W0qS
z_j>^8n4m{FQ9%HCv$yez*EJ4OqL~w0kUtNQy<Qu1V@DXf)5RZJw4FSSAyh)0J!sri
z{_@hbHj6YEz_Q^0_G~6oY3_qWTstErk=1tRDd*c`IfTa@&nyj=?=#O2=ev34UL#GF
zEK7R-%=9^7^~48)XjAB3J)rg&NA;yR6Wc5{Og5PtX()m~%?1vuDT~bm{)zgRBIFRV
z_gO{D6|aLQQ`l$J+1WVz^TP(VeIqqOl?NLkoDU&zJ}EiN!jAIkov%y>(_oTu=9$ii
zYHMqS1J)|JL@J^|Q*ykl(duBo(FGulY`aoP=>5tA?gXc*%A4SgH9$(j=ViD3cf$|j
z35Ma`%XC^(3_jO_#zb+gH=o#11V8qud<_db+grW3^xMvf0m*{Hgl9_$=G>*gE4zKN
z0d_BWQt2shE5rh(RyEq9$Nf}G*Uz!B&G*spJ5wT?l%{K?V5-I1y_)Y%rdgdz?zaLi
zi-I=jRJHhgRe4SerxGc>R5dh#>*ir&I$(1k={HII@<WnnrXE|{VqfD!sTn|C?o8(6
zS(3X2JME3Zx*}82pt6aFZNP?!1v}0|G4ch}Ycfyqm+!8abr|s6xP7%JFVoBqhtkWk
z$h_qR>{W8#IpW`*Nqzh2=C!`k9`M87QkBO2usX1QJ=URpchrO5VOUrx9Ca&jYvkiL
zEt_<t!@DcFNn0Yk0`a+I^%8By>%>9q=7e=+PM8#QxC-ZwN1U&y&goDxeLvKtQq?tq
zz0px)Z=7b{fDD^5_;zkzK4v={=J{~%4aEYXFm8tdOQdH9x3e$wZmYky=9l%be*LnO
z_!J%eh-i7^5KaX4d6Qtbx0@u3-XI1J)6Y%D*f@L8^ip+;uN><J+NfIUnq@m*yW|sv
zPb0@#!KdBgP_5I=<O_ohTki9y=4;q)SKuj2>Wr1TZY^9ya&_O|f3aHKDqmAp|0&;b
zj6>6MY+9SjbsqYB%McK#Z^nYx8ONCb8JdQ!RK2?4kLCWaCWTgoe0lWS6Y128bR_hb
zPOE>#c$6DL2XJ*$7b{(tc@MqGcwT+Ye0ObHO9JZ2sF(cGT5_q}o|7rnKc4Jfy7?_0
zaCh~AYg7}xG7IE)UUgtA<GYy`;kdPUdnq`dsqMYOEHI-KX2MsN21`7?G7|WfD5$8M
zYLQ&g(`kqrZqUhB8s8Id5~@Ev(3Q+R&&<3b5}_h6r-maE6S>+&aiAG+Bexf_+wTY2
zysTwjqxhAVc8#7clFwZ4)Ej$w7nSn0ZG#ySinQBH>!;P8ln>u&)<ezfe$x8+i8e!S
zNROmq@cvv?0yU}c85{~<>{mh9mG|7+d<6IiLS!kUXqz-v$06jy2WHQjB8t+-p00S*
zjrm-JMk2Fb4CCF^cn@ISIe)sm`K8zW^6v5j)r0mx8vCWeRYyKfx9!r&bTnyjBAv!(
zR6xjMxw<u2M!&hs@wyI<x-;oJBeZRuq;Bwb-?(ILefiF93j|_5ycA4H&P|v$4aZ}Q
zWfcjIX^ptoi#o{k5%^{Fr3UQt`V-$WTT4=8zFb)%ZBdxl<n=|vV<_|9EV*&E)Z%^G
zg#X!0CMT>E?A%2&H$SuPOpy7<kO#yVJf?2?5VIf5RTG1z=+?ur#QM*B*PXY{?cl}5
zB^HLOhq;$Y?Fa?bP8g4=m$EVyVOi$IAu%q&yPeu{pe_0y$5(x~di(Gb3DixuleHpS
z-txAKpc=y5nx+M-Lq=qHI!IfvKbu)j&Nw?G^3GZ)_;{^#*mQZGh@jUKfBI!r&_ptm
zT&sp*>IR*UNBS*Ryt+WiP@0N^jM&hFWpZUtuG_%pb&PNXh8GyMGv-%p(?s&TGc2ha
zs!i|+p-GY*a2E;?iR*C<8H@|BQi%tjW&{{IrokO=DjeiFG7}~XmP}|M1nD@QY4PC_
z5V!7F)`=~Z*>$|QY$t0BU=8u~&2(r|BC$`i>Fc7S^);WOI}y=N{5id`EbdES5=(iH
zm^c<s*xQq(zd3CJa)g$=k$GB21-u)atTk(mO;Zv<1;A-L7YGtDfbgE8r4dvwqWd2z
z0i3p0^84rhgwojM?Tp(K)K>-{K9K3q1UqzYymuP(Ia|F2{f6Di&A3F}0kuX`4Ewt(
z6^KNYzIBsz>eOt7vH8Ls2REg@Q_#w+Vzb4DoK{VkhA=*Zre>?|tK%@G>0a06hpWNF
zOy)FRN~JDzqb|9u-zXl6!#wPH@?Jk-yFgK#6MOgtgY;xSi<><+8q(sBEV{)pxthef
zF<j4{cd%Id0QMisfQF}_XS-<8o<<n2TU-X}EEQ)rYwZu!4mmbDyq8-`@e@U69Amw<
zuDd6Lt|Iw|=F<n>rPUS&#lu1iKf@&ikzO~vYafUv8v0<BYOromo;w-)LyLpm*qn7=
z<>LltfujTwjWB$0yJ6*1eLdl<SNGcSVI-Xr2yoF5DtS?L)R+3tY{?r#UludB5Xq{o
zI_&9952Z`vGs~+zJZ|kH2Gxnl<JF5kttRb)?j42sSa$xkz8hPe@ipL72>OsGst?7F
zzixHgX7jeFxj(OUQ~&P8JvMB(7r}fR_H`>oE`_Rhx3rqd(e1v-yrrtr{4@dV%f0T+
zTN8CXSfRp4R#F*!?tj$i!CpSszQY5AXe9}3M8y|QeYjqN-P$hHl>_NpZd9;mnd9^U
z)@&naU8b^mPj!4*1wbR|Mf$1&<=$A4FOeX;8_5|7<wdP~<>LsC+wo!njC;5Dzr8W)
z0_BQYzIKf2N868};q%jS;dG`+wNU;0-Pi_wzLv$!x?qvF>`E{8N<awi*HRjq9p|aU
zIkjA)vZ1(jv@qLKg3y<mH|dewW|&jBfkLz%o#!TPaZY}uUtUL`!IO>Z?|b94M}vZQ
z39Jt{E~TxUp1{g~ixqNY)K!@{&cUx?rd4C(h|{*7?{UG5jD*yc@{aZrjd`J&*kx0m
zfWzlvfm`F=u%!u18wO#*Oqv3oQ?C_LY2@teqSdDRcUvUgbwP18iMjzS-m84dse_F4
zmQI69b@p)!tqs+dm>`F}6H8=WrFbycZC_Te)<9`Z{Cu(DPcvA0<SV-{eDBPacP8?;
za-`zfa$ZM-giu*CjOC7bgLoD5@Ae%?ppew8^;v7=7u=co{wj2dS>V?A_N&fBHLJ(o
zp&;ff*~2B~mYZDXetb|*zjMB+k`<u6q)uq&JdkplBoT1yVQD{%>vAwW^6vcnp)l;l
zs6|OA3e<tU=HvQQ!hj}8>bt{EJ;!wScVx%U&n3x6k_0gz&o=8K;Go;fl$q<sYY;vG
z<AGpz<FE_OB*6z605Q_PkE4?Mv?}~0Z#V@8wgT5^i9IJ3IWmlz72mS|6iiy$F19eD
z7Akw3ANtmy@yjkB0<I>p<J##92BP~@X24af#E15#-|kFWf^B^~wQgz-7NAyni~QXT
zAHIph<{Et7Ci}1lYJa{shw*WW9OZ$am1L!&PuOhEz$`RdBqgGu4%$SXe$CpmV-veE
zZ;XPELhR^3!L8g7;Z>>h1#^GS>e^BZAe7#0{t!d;o;h9o`zLH~sq*k>^yg#HFRVIY
zg5K%xx^I<K%G>;HF}<=+tj$vROu8Nco6e_mb>R1HAqYr>PFu(%7L!@CA78R&V%>;0
z9UFTe1s=_s)xK*T_~Fkn?L7LU^XPQ~(BfN~3)o;hM{tTK{1a1&v0Xo5I9}_N>k0H6
zi(kJHK&bGG9N7ul-@t_!BOIp~_r~fpx%K{J+4g;aZK}?+>|5g8r`@e7P=fU4v3jH1
zEuuS<vl$i3sl|Hl?p3?Jxyo9*c6dF^mq!P@i^%AA4j?J7iqZS^=g((vH5pSlwlBBa
zg5|XE=~c7c%73)Cw=1hxidX;aR;aR=CkNe^>C)w2+S`-AgAAiOT>_{siTCvmmwuXw
z8h5tc!+NSu=k}@yD}Vp~-MM}N-fR!zn>N(pFTA(K_#^5?%YOhOwbfJuqxUZ}`D>-G
zh%~jcjx@%lL1Y3WRrUd)ae48tb!8Kbhtjt9YnS%sV7_OuK|zbJ&aU&6lQ<lqu1ot;
zrVQsMUa&uAXR6uL&F;G{XYVCr_^y!;)yRi07O@08Dz&h9%JUS=B9cjYu69Yq@A%wz
zB6d^?*Lz{YPLVPoY;dA*m=?I!auou#IOy)2_pa<)Bm0uby+J^s_&r-nRc*BZf&#=u
zC*l;so+*;DsQd+bBEewsw|pMg#Y>8np2f(<fW{0#m1D4Io9DRfwWV?`210238m+v5
z*A)xM6?E`<wPW;^!*Bg>PX9zl_uYCVSK}<M$?v*lujRn6VGWl+I)P0#wi#l=!#p}0
zIs|cYF@#)ojb|deZJ)%8_`Zx`R>;Woxzm;W0EVm&kA_D;r8wV*8MMPQSHAoF^>p1g
zPXOjMQYD2`6hy^o!S#vFs4o-L?9YQ@Vm^X?pj0}K${3ZD`oi(M!4i#HgR`0A?41XK
zOD)iOH+qeT@>#3aR?FMd1N$&AsMnQjt#^Lw^pm$n{%+tBAKUb0z2m0TaqM@8!+RK#
zoF+pWyNIfb<pQcVN6+pgL4kYmArcfWq4OOU3!@m(DTMdOTbR@Kv-1q)hbl7%dI2Bx
zP-mP_XfpwXwo98b;d@Ps*HC5(EAdv;16Z!FqoY?q6B)$ZGrg7i)KFy}MZznezF`>h
zZ3XllKwk?uY@5&D?jz|O19D-^oKzgmIhg+e9AZ4BCueEpm3TLpozcprlVFqF!}N`o
z)<6^b{=Qq3j`VIYaq8Q5-PziQ6%eiTD}Wt}_8Bw{(gl6}G1*vHj!rh{oyy~b&7|PS
z{0-9)#nyc>fmHP`7ieA==vJSAMsd+}OT8m-^tW5l$!0LvL<~L&Pl%QzW4FHl{ioV;
z@>vkbu%0=Y=Byavv|SW$DLj{9WMLr#n=pnF_cYV~Zxo(&Pq#^TIfAE!qsi=)GO~>p
znF>F1PsLW5kE@f)XK)61aDxrzW2cqPzxV|oYma7O$~m=z0M9uZNoF3=k9<+bQ+ph!
zH6fKLyjuyMWrc}e%a_jqpJ$c)v(uwE@|kxAYnL=?yr>zQMsrdn)n+athe*99rZufM
z3aX3eTga!xy8#|6f9NjA!??RsO3D0s<``$d>|ojV=;FZxq?0j$mwUxgC22U6^MAbn
z=GGsM{PpM**^a#xc)qe}&vnpb5=)bKyrD5h-9}5;`=7sB13z=+=0ILh9PNV<gvz*x
zmUPD^*R#<i%mI=iAmB}oglyKEHd{=y?GJh?x08-U2v2l}d>`&%XfMv|6?toH=~02u
zDTPfej8ft&hmHC}o`Hz^9gX{m@r2Iq1%o>yVrXDXv)~?V)$>|!KmzTo%T(b-(=JIS
z<d<Z$9k#~+Pu6r|oNz3aRFAZY&&lT1=zu~j%{j-=4%lF=PeJ?Q9RZlpxE5M5fOq_j
z+vV;ZKlfr|%Pg#zOAN*Q#JA><LFLC)-RMuzUcemfh3?OMFP_E+l-|<Etze}|q`lzY
z#P+yTqzV|?k_)0M#87ZM|73$?yZ~XSoyb<4sgxwL;?c~uBn|a=u})ywS4H<j?3ZC~
zd5sh)=v@RS(dPQL-+OO3>w<ubbpHRN>@CBh?D~G;K?Fnv6s5bRyHgq|=@N$S?hciZ
z4(aahZlsa!E~Oi!b1%G~>)!YCzWX`$vF8IHJY;5=InTBJ>zBvsKPtmrG~mC*L%1>8
zkaHn5hF?QN+u9(ty)hIp`|Yt`UYjpe`5xG<_m;n>Q8ly=@bN;y1M{L+G&V>vG-K8I
zwWdmM-^+C{^}9K6(zNw#sIgzU=tO<<{tJSADw(9A8Y<d4AQQsL@VHt<c4E;@Crmgj
zx{HcIkeRQV-A40+PAbznwZFeV$Tl*{rCaQhI)2J)KK82`z#Gy@JZC|rE!jVHEw2@F
zhk@!mIO`Cc->I79k>z1X?Tb>Kn4iu~W4?l<JZ<qp08{>}OXHi*A_r74f_hjO$%HT@
zicxVq(kptUsulVY1Vkt?(93A_696^?FY050zv@h~t-%MQq3;sk#Y9C@IBevV8$ItD
zKJhu-3x-{|0osMlWMO4%^f!s;y)RYknPKjhV>wW!x4^>7_k%>_OS5_YRQGF6UN^uE
zITSh`EVyj!d`jj%l$Wp9_4T+p>tg^FsnHZp2Y|GJHhOx1)6e!p@uewTmtmvZ1zmIi
zqP95E!)^Z-;Dwajt8YPw4uKzkljohE_(~*~Qh_>a!MNb{={EL6VLwE?x3`Jpvwsr_
z;v(0|tl*&l!5g!`f3&R&&85=2l=tD@h)9#;unWyjvPw$vXQ5o(x@Uq>6q1gBHSX=D
zV8xREsIAS^k2$9busf8_b_#-vni$YjP<~~$-(<;T(LIpJZZ#Co7_a#5?q;9M@k;O4
z8UVN}j4v(roSCw{2>wWd6K;uC<5ZPMBD5zMOp$n8PGnB8p-pvI;kW%(dOg9Z0x#B~
zj2ot2mE$-#Y!*4D&8{u|btO4BNt~5oSL;T@bbTP*`KzCw4CbFlnt&eKGM1IiY;@BG
zbJy8kMzqWXLFKT&kN8c$^~d?}-or2@4dSdkGSBqx-7{=Vz~EeeBzZbV-O>YR28P`C
zLV=-KhQj)50A1C8&If(U5JB#+1GxVR3L!9Ls(un+Gnr=R{^{R%v8P#Wn5+s|6Z*vm
zHp3?8OMsl)du@*yl<tQwdhA_(19Own+Bj3TY;1}4kJyLVmMFUM;x~c;GaE$9$i&0S
z-=Ce`fU{tMN^yHeE(pI&*}1sCLjZ>>TIH%|`A}E!Mo&iQ637i=hNN&89eOcdNPYa6
z)>`=ijF(U0;YCG6y12Lr0W>EtHhuB5unjGi^!=6~1Tk@qQl8;1@J|ZOv5oOl&L|t!
zo-a2<WU}}weas43;_rVcEPaTkp;X~@&qMIcWipv<qFl@{qu}BB%mw$EhGK9fO<Q`r
zoq(@OdG}V-t-<T!%M#OpYcKnkyjY!`(|EfL+JIFK*e2f1>+fa>hP9^(8N;YNrFGA>
z@9e*SPECL~*Sre^3l{2W7vu<6fI$D6g9Oe#34(x0YA&B84xAxpKnpNd^|m}90p0E0
z)2piMPn+&lrk~#1GFl|$GNxL9jHCx{hX%>bP%P%GTz`-PCz(v{P?048@SY8|_>^p1
z&Wdp=TZ1T4M6zS4P)1%old-x1vx}vNC6K*7?d|gg8ILoPLe`QhU#ZeHqTP3g#oTpe
zr4@{M<;pom92=Dk4o~%mW6r=D3OZCsh5@CwE7pvM13|>Ag=y1SfRRa|;e;jh6qp{I
z5F;tlZjU__g9x|_xVOH7fr07uK=T)XeEBL3MvbkeS6EmQ^2!^I=*y?&mXbK2Y3Cm7
z!VxxEKCrN`Oj)u$DbGPyj#iWXwtw?Y%jkha!^-_}t{iAuPvUgYwLjBfvEVW9?A7wP
zp3K*@1JUxNV#^-6iAL36?_~0LmAN7JD>$wHVGNub2yl7NFM!#+9Mfd6;%bDzYiA<c
z4UBI!hYM(^*u>qUPmXwW2E_y^h`CZn>bow~Mj+15XE+~41y32AkqO-Zw>a-~xD@py
z&b1K_*`Gdn!G8Ti!|@Ktxp$tL>LDT}{W@`|5OhKd_KaGn$1%78Z`@BP$B|Zv0e+10
zg={{3aaaFgD85#EB^H`1nOGya$-cCA>Sx5tNP5}s8&vW28h86!bxf7z?A}oXNoxq6
z7tkF%hHY4f?`wI5q^yF89JJD&4u;}Q6))H6j2ptY{qc1WR#uI(d>E7X_E(srl~FWb
z0i+E}U4Dj|6APwX?4wC&EQ2%~UMyPu@5X|oMPJjKDPFL`qq5gpEpxgZ;C@@e__H4E
ztKWVZeSLBrlBnxBCr07|kdE;jo#Dr+4*?FIOybvW-tXOMt4`}Y@F5gywn_+S3xMFy
zY>`{TTBq~9MQEn_B+Q*_zrNn7y|15NcS6tukf(Cm>Kona&6k--?&PXA+9JZke%XZQ
z`lAYW1e`^n>cdWd*pIQT4eEY7WZM{kN;G&{B2@bV@+}@vY+JkH$bAu^0bzQ6cY|+1
z;^zC&I^hHA2Gm`l+Nmb|;%Sl#8kX$zoSl<!nE+(GXit)DzMrr2=?fyRlXpJm$KbE$
ztunnOb(ROh8jLjiZR@*kBsKB&fl?kAlkuz}FuiN1Ei=BhKbFMd1I6cAAL7TH&iYTo
zH{y_4fsdXa`R*Va;}38|tDt)x&w2y#8!li$dGyu9KX53Yaj*HWhG;aMFOCoZXz9}C
zVHjwKKW5vC<Ux-X1Sqg}b60>(0fZZ&KHd4Nk*Nh1!(rI=r#18YSqoV$C(}>S7l@3Q
z_e$t9KT9~|il<0%WwgCHiSokYwFJqGpzx?4@c5HIqnEaq(B9O6&#mxIQgk6AvnMYM
z>zv-1<<XmlkHyi3k8J&2C<GP!#LkwL{$=mY2#?8w5sv77rrz7(k5a1D7{e$8FL!DD
zhag8hCCSpB@faMN{a06!P2Z1qcD9q2{iF3kMncMdg9OVc=xLj(#k<`NaXzq43_AwA
zqJ4&VBq<_LKtUi!!ABBDH^knlSMCbxJRI<^mVp`UPv66RqvO6SpcmJbOsuUL@_&iN
zo%nRpF3JNd;!)^8gP5?e=vbfsHbsWiU!l(MtHGw}IFYCCnv#UG4abA4N0%VtufWRp
zfsest5o{X0f)&QMNISqxqDpjThBxSWbz;yU8%<>(F8=IM+}2jvCbk`D&a!ev1PW#B
zy#TK}Uwhcw?(GdR25wDU!JTQY?{{EL`;|n}1BHYW&Xk$h6@%-$+VyU=!@uGPXnF_L
zt1U*dx`s3xXGv^!PPf54rHdE^hWf=Ohag@mK(txSR4HW|7K3gSLt3w5%^qwAY&xxm
zBpApqm{)D!rQb0ym`%}CSp%SEciM%}9|$(}gecw=UV8vRRea^9@uPT@W7zv^*LM?U
zbyh1jrwv83wRVsu4*17P=leYXN%yy>G+!^&|K64I0owUwE)R6cXTi4)kD0YaWXtaC
zr$C{)CkJu}4l`VsUo<6wsspmAlkKPn=UlgGehO(Fh<9$7KmALXmnqcpxgVnWJh*Z$
z1X9ZlZ5<N}-#{SvK7^s}m{?d2fl%sk6AC3NQX~lC%dsj>J3}Y>moNI`N&Gcd!8+DK
z(jISRzrSEJvYA@(wXH<ct*9gCS0LyXU2NH3f`;>I)PPKOhF8<Kl^$aE?POCHGnjVO
zAbup!SIdJ>t=SOIE%MfB$36=EAZlVDj@7?G1v7vEtoEBBpbt3<2rQ_mz#dpRb*f@N
zi;auBH@(&dq=ZDV19M@bxv@at%Z-c7wMux2MJk+^IAe)&q--3E0`P{4_fhDl(Q}}~
zOC6J6C*xhK{ndv*Qx-s@Qz%!doUN5#WgTJZtW{@SZqm;-sNT%CQ_EQKsELWhbk5eT
zhKhxmow@phGamz=i_Qi9VJsaqzR6&&t6N$_c%7_2X4-5b7~36CJhm)R(;hAcciqy8
zxz6#=t9RIeo~VH4)_sIs*X4L@eHjHu<^}K;<ailfEO`j|A?Lzzy`1d@T5FKoqtt5i
z2dvP6k^U$IWA9_!s!gls&M0J)>CBLE7$X%2ds5v+AH*w_E!K<Pz&N@oe!tNVgn?1S
z>=O7?X?;9~KA127Eqk|N`lXeiTR^w1_I(>$$_wfZjjDYTAM}9KwcZq37MAZV<-*1p
zq=batbUNw4h~ueKIlJ{;R|)QEvK9y|0lRwk8)R6*bep^D5WSvI3_8U&b<EdT^#CHx
z@O{x2IedMQ%xZz!eARP%%}i@=e9`cZ!pCWCt6U-~_iTUM?0(OL({@Y777T-c-pFyC
zqyn%<4DCz6M*+<>Z5;P+kSUl&OH%(ViOHk8<H)~C2M7m@hLh=wMnM<2=ka81>gj&7
z?(uE-NH{;abf^wg3+QJ0R!UnJj;Ff;|9fRJVFlDVtAqOXsoYLligh69(>EyAINfEO
z{PgfG<)^$&H(uk_Ml1L}(O!I9PIu#6_Bk(p^RMr)E^bnRl0N=+^HP@o%K37*b;Ks{
zF(Bxc%hkLji4%Pw<=!&Pvf^+3dsPi`7x78!>0>KM{&cWU-4~g5vuUfnE6Xr&u=_4|
z4QLwUj+{Z=dXHSXT-ns^g|mGio8AfFblu}X8!MbG(TfdKGLw#H6H=T%zc`<=SWfeN
zbK-xv>_v!;#df=?eug~=ty4X)T>2~mIQ<f#+!EFumfNl0vc`v6PCb`T7h&O%3)E`U
zX(IMOsnWRvXn+SI!U6>V!Zsi(T!TY7k&uQW&h_sA356WSBmJ_gJYBulwWCENDYr<F
zQV=M_`|ceB4b6ZwtXp$99K?GoZ5%F{rHC_i`{xF@jqF|1qk@gf-a(F2Ypj}P%Ox+M
zp7)G^0jW5eClcCaGoGum=>WS{Z+luAq3eS}kBzbMGuo%{TzGmX%-oK~DlMO8LDxMx
zNVYz<nt4kZi2%p#j~FgE1GG%Fbji$FvJav+HNjX4k>>N~!)C?mk9Fzb<XiRa*>nPT
zoR|4OSOBY$77!EV&w3yrzol2#AN^&(6x?qIasd?z*7~oY#MSP{zp@wT*SH*Sh3#3l
z2}bGRPxFbNnEc=>RLk@`d-T)P>3osIpqFEZi4I3wsMEP?a<Nq@{*<qOtXnu;5)}=S
zhOZrK>A<d>qjW+e*P!^#slmZyrplld2G&4&uK!Ta^J?q&{hDE;iQZ9fk!G#WwHXkJ
z-<bNU#Lz*Bo=f}?6~#n$SDn%HFSzGBS8=5nPUXGpa(Br;TFY06A`ebxIG;ZByBBYd
z<08L4e>j~lZBcD8)&iPazK0#0(cbz$7%?<)^I3AR_1pzb`r9X^2p%oA+n<5L?tw!$
zYkG0?3FUr4G<Au3O`b*KG~d>uO3h<t(0!^0<67c-EM|R7Mq9<}Q<GRAp|(8DD}_gS
zRP&yhD)}zuu=CJP6sRTp^mH|DqXB`XQ*!>XU0jnIYyO6do31?Cb4+2__+|iuX3^Jx
z{H-L8t5nv5fR<h%jxvxj!YGg%pdDJx0P4a4#AknogDFmdb(-VzwHHOG#bU1ReJf1r
zI9xN0d+xl(-SsIpsGPadYhe*wt^|ZhQ2h`<#-c#>BDplS`cTvjoLb9a+xxL7UCxUa
zqE}ZhFeD@a=wL9uQJkeotyDya%SLb^GUDfe&35N9VWn|DCrU5|>@^GzuX`k($KS4j
zadG@)vT(Y$70nFly4?lt&YwTme||qVU)`&>TSmgWzi;Gqz1X3AAu$l8q<TDg0!ZBE
zc{Mm5rg6goDwUd-lrtx#-xHZEa>6tw3$#LH4uQ?0FM=1RdDn4&Rw2ipa)&XUE?5R{
z&T95LHcz=x8Obax%v<XR$a<C^tg%qPJG<Z?-T!=Ayd_?s0GOZ50Oxx^xrAQ;p=oKp
zzwfb5-ziMe(PkDJwaPeq|2^yjTM^WMK!1l|w$8=uM=Z2^C80<7&-up%1O~6sIP;H{
zZ%wC?>wZ3G+%2p0i-qeaAc{*iV-+%IR<P}d%Y(imnV63Spu(f&3}fe86veju<aIR3
zr(|(tFs8h)w^(z4XKhF!KaAy?h$NR5Tq>PJhbM%2qzyndhg2%3+eJ#Vfiz+)lR+T%
zWMRp2-8a&AoaIy3Y$6e`pU8ZCe9DKI;^?iG${0LS7)+B|LJc^ts&ZwL(XmzG19Bu2
z*+@w*EAKsc=Z_mo(F&)M_`O;{Hx8+$a36s2_^wx)6DA8sZNU&DOyn|+B2DD6ePR&%
z&~K=qbWtcVJanv>FQ3Bc7Q=!%-ouwvJ-0y`8IO?F0U*bPG%Y+cBDK%#mP@zG^NS;9
z=qd|!HosHxxUH5Nn)PRG{X1*`67EVLQImx+qSK<;9NHK&i@U`mi}%JJ@15NZ!qXW%
zIpo)_+82&~wX=J+K8`<6*@I&jXZMCI&=QG%mVRmm=0R!srYxVXf+_$q%BH5EU!NaD
z(_5vi^+m<ft2hD?FSSas$!HTItn5p#mL?>UX%=_ZAd~@JCZENm6^=T!W+O<3e~V$B
z8K*;mB7m~jVEq@H%`_#Uwx_-ymbJuRAwj}NqF<ebx@cJ}H#lf~jmnZpzV`i84?<7{
z{ex%0dAj8-I%rq8IA|X50#hzP5PE^cDDRK)RMJ&NQpw5Y5LBSudG;jQc4-lNvLO75
z{FK3C1e|#Y?0#1o4&$A49Ce5#d7i;CS6u?mDQGlB7@V8$dF=yU>dZa1BrQCY^14;e
zl#oltQq`NDapAvl^8}hhfO`ek^YQwa$miP7H@%5rGWd|U%mEgcXdqV7WU<;9$bSRW
zG-Kr+^Kd-xLAlK=o7F7U$y?wkS5_o{(TRPio$WlD0fIAV$0}(-V6yNxT}I(&mRGy<
z$Dx{a#uA`4J#&5$XofmpYCM=Pzi*UDRQBSZ$WuPMv1%nBzCz(6QvTxVkpJL&@9XMd
zIvN8s3z_X;5TQ|T+5@WW0>y&PwoKGJu{mc0kDGfoy*Q*k6Dl1dQ`T=kt<a?=%>woJ
z%dG~^@aY(id_dlY{?K<hf*Pmm0T6V&*Z`aT5}i`(H3pIZ@mIdf)8pJINb+-@@h&l8
z(a2-T>6YMBSztaKfQVm`f&zQsSjG317*6FsRGtA8)UlUTk$mQmm0owx$jVWw*resi
z+6Cg9*iu!I7arG0Y3*9P%Nk|YHqi+V`Ot3&%3HicfcVd%+cvG<8PurD1F3?<e1(?D
z>cEy{K2il2UmIO8nZj(v_a~~h!T$Psp2z{41@HQ|Ea(G$>kHOr!d1CunJ*i~^9`Ky
zNV}6nUGmwYiwC?*Vd=B@R;>;|vjj%}3A33Z5b`&H9rU_k49v6jZmV4{C?hG12oF^2
zoK1i<a=in%T_YgmXQK@wc00WJa=ELAUQ$#a30qa?(=8HnXy@ysZ)nmKuEhwN9@HB{
zLlSGjyIM{2VU+$QVwFCmxokO-1!rP77x<y+proz;sz)|%CacQ~7T%L{;?xZbrI_Hp
z!wCTHQXVV>7xzbp`}5m*JFJ#K8#bs&c~*Z49ADKgyHmj1=_U&O(j&GbYOudS#%Glo
zpJ+OSaMDxxAT>Hooio8!^D&7vS;IJ?i12G=^~b0XoCNjCx8*rVT1Jq|wnev#Ew@m8
zhAXyHhj*^On*<$jk^QTwdzepOK*Fulqr7!}c;dJAK3(rYLGTPX=mv{@2L(C2`LzLJ
z5d74wJxX>O47uwk%_1g5#KdC?HeJuR{Yw#0TqvO}<*gy#g}#Emo6-E;dEn%}Eb>|=
zj<FvJL&V!WenSEJT3fY;UYZekK%m9ycB4&d;Ql~=B&mRyFynAb?50Q#bnO+({d{7(
zFYd(`3gZTX8%fjCC(K?6B|pd{AF!`fG8+wtVIO}fLx9s<zF!8&poDm>)x4ii?vv(-
z1r}0|PTeEUEjxRl-H(GV0|*rCsnAxwW}sed@c6~!)Kj-lu#4~q$P8c{8*d?FI^hlY
zjC*dJ;!9%2(1}LjhvZAHsE3@e7MY?BtOX9|qcr1B#209q-_FuC%(TL$b|c)-PngqJ
zJD8*$MkobB0)ZNh_imkCsWl(BK>W;OUo$*1Hr`f+`GWF$!47&vQ6W@BXKJwS?G(Nw
zq)<2YmzOYv<;Wj+Ab_!R6Xa8z(u#u;UpR>xYg?<uayGEDkXl+U)V<$P2|mdv{PPlP
ztlvf#!h^tK`mxk;aA&#%TB~)lF_>s{w_~7)sp7Z}bb|S?2@Ayl=AUHu?>bnjbo#wP
zdz#(k`FkVw&nD<QwF%m@$wAL7wUPx`h)i@KFFw|#>R=r3EB`r47aGfv-p%pldpLb_
zP0$Bxv|_SKDFzDCvWj$-Tc;9IDy9l`b|q`SS7-Y3VPtyZXyj?X_nM?X!bru{b~;oU
zPkJ(A@nf#aLC$7Jlm1CueV$3?XX1->Vn3xpEC*>{+C+P8$R(@;j8=pDI&!K*_>kZB
zc&=nTG2B~vhyW@&y5sSf!D?@|R6H>#8TjFO9tyicFS`um$%V`5YChO-W}gHIxtQ4k
z;G8Ho?vrmQRV^3XjwEBad`9{V)M8v8{pi3n%<z<=(`=AJmIl)*!D_}^<T5C7+3=GY
zdxPW-Hv{2{<3j9?FUdXcSj%+o0<%@&7#@^p{K{5oan4Jr^wQ4Sfee!ga=ZEC3j)vq
zyk0{7eQ$m8wod}FV-<$bM$qU>qrT!|qtgXYAE)4^$UK(+yhKFQf$+GbsDQXC=jQ^D
z9-C)X3R9*DWGIyizS!+b)qWD(wb4B$iU7P1G@zh+qRI@%5cOn+s&<j21m-AeWMm}v
zPpdtE9)W{%)Br*AVr>6cm!yvm3=vWKk00;TiPFJ*;BHQMN7cLVtnH7_mrO6-o#h~^
zMKMv4h*J;ajj-$}p&S+yahaz-&K`>+Qc!5xM^P#zO+P9`HaPzvmJH8@R}O~eehTS>
zQO<&}J$KMhs}9u3eRu)$5<hh!Uw)L9hbIY#|KeM3Z(eUNLl`F^1TxIIc9A14QNhmH
zE&!g>doxb8WrKAy`P3?Yqsp5#)+GGX_u}%RtsesoPnB5#E%ef+X0K}!Mww+cK+3I4
z_(egvT~^x@8*v5-3v6C`dtqUHVc|<4TLyGXaB#5wk?M1VhYkn?F*Pks;C=X~=Px^7
zJqCFYG75y62?Q4wd&MQ)tH`wP=6JH^9#y+G4)q!h;=&ficYH>&i=&q-|Mk*`4WV`m
zMQJo?C)mdi0x$c#fix#EEFSWRk%9-}GcVX?miXuDKNVFTRH9geoeei*h(+f(G2{3d
zPV^`P-;M+p5)Gi09WBuSlhePG!yxqUmSWI0=6Tw3=yxMu1ud&BXcb;p2d`F>hZ|1m
zs~CQ!*>v1c9(vs>#g?YFsm+9f@cge|54@%T4aZqo>$p_B0?xO!p&{<rE@M<nGpV1(
zx#Tr<KbFvnSxeD{9}%{{k5rrJa2P(S55Do1w5jQ_{DjGc%UC3?Xf0U*?_2!f(F+Ia
zy`+!Lof~6JK8q9>4_=Kh-KwtgC*-KHF-}ypGuUwb^GsHL1x9_DQs>$qG=(Of7n^1F
zbmu|KwI*05N>bp|Ev=Y&^;|e?OGp*&u=_Gh)L5GgMY=zZM}{cYA^k-zAD_qj@RGzk
znMp|@_;nMH7us}7f$n&JHtawlBDLyo(elCgx}R81#l50+*#or^KjSc{co1TUZw*tZ
zBsV$(`DU>Hc`w!-2rxAI?@-*?vh%TCS@g=5_&KOdVL#AF>9)*Cz1){FAe(1{D`SL~
ziIvbW-^Ab&7Y)M|x%C$0FgmyW^Ca$FP6%-bL>jm%cEr&15LS`(%rDZT)cA2xPx?;>
zr3MW2S<?H;jO^gGcX=cO-?jzn4j>GyS6fG;h3F8I{_`w+zm1+%JyTGonJr|IcJ5$H
z)Hzarqx!8?6q{ypq5EwK6IRS|4`nbdw^Ds{(d_A@qn3z40<#axKfk|%c9EvD{Io0r
zM%}R0wk9*cr}fhkl~j4Rh*<@^R~}UkkE4U-`fE<T6xxWf1U`FJ@-}%T5=@Qd5cq!u
zd4VVL9==S3n-e!Ri1+S|d)>$2o$NClXy;va+|!FtT+h`e12Z6uZBpVqNIH5=60Jtg
zH-@C$#o$fk{a=?cq%+h_a6`3BwI@(qGuv5voFx6K)WuG@g7bA@QCKi`6HI^2^`Nmb
zV@y&aR?uJE6>`}J;@3cD-$K#kE(!tPci+vSRI8~1i!bD~paEzQ{~N&J9^AHG1+fDy
z#cJw4_l$y1N*_1?k6G;2w0bO%`sD^8CnBeyhvM-sm6;TZ4u&Kh^!$SbsN-?E4ydnI
zJK~v5nAACM+rmRe<lKu^!n_q}2A>c9%uH$S)6Uhe#%iC+{5+#I%FH$Ysk3xpfqcDc
zVk)rb;9ob(Q55C4VU_8U`N2Rw5fM>^^;O^`(BrG|csT-xj)Bgw7O1{J{8K&~T{tb1
z%oo&!1Kv8b;lk5%#SxZ$8Pyr+{C&#NCMf~?x7F>8jz^x6b`8|FjyA;ui9xINF{+vG
zf8eLyZ(d^oAMy|+0GZi!#tT8oM$Hi|6Q7+jD$`%hpxA)Azhaj_<@LbduiiT~JZCVT
zxzSBWRdooLbKyB)!3gkI3rn`<>VKyV^Ba7N1j}~l{(Ou2D%vvp@!j^%6yEv$`Gdt*
zKr_(jv572s`l;13(=F_xaI!$9TKNu0V4c=?l&EeGC$`CHwe)0P4xh7IEX|cmvR@q?
zG`op>h{=SDT!#ycshBdKD%b~Q(gvKgYxJKobSKr(3ML5kyl%gKd)di4_4H@hTfrjX
z-wf1CRv*l*^UY>S6Q(j|!55DYmtrHJz=`}KL%7HQAo5A5SXd^t2+q`1{r+IKoK2Gm
z%FD|;$7>w>+(h?(!dDNZ{!jR-_<zS&Kdu7Vt$4}z{|R4Jr10|)=_y%s(=xjd?W-uA
zG8s|qCK{)_1IhwgXuj*ia7*}L%Y%*;6{SMDZLB5lR<8(=NiM+ALFHrt7*#-F2%0bd
z_ye=2U~b7GwNl|-|5kZMcuEw37q(KiD4sk`hiI_-*TWa3vKV+v^AEcc!!LPZEt8QS
z0awK=4U)frD=Pcz*ROe(9@4;p$xMZAvB}cl+b<Efv+W*KY_>#;@rG!PsnYxFexF@7
z^Q>B2SlQqnOrc$+gKixKn;AX`L^Zr2wuLo+{tWO4tLU9V>SWOjAg*rnh3!Bn9yf^L
zgE7+qG&rCYg3#$mCHZ!jou;ZJNWc9D=1S)H|A@H)1~XvI)B*_6Q9205{D9mtiPx#+
zh{5S_R+8x~s-;<lCWQbM`=lqUk8!V`8VI^vDmB6Y{8yq;y*C}vv2U0Y*IIk{PL=Rs
zAzlFps9FGjD5skLtFRwq7}}^SQSyoN#^bvF9S?92{UYlZMJAZr4mk&iw+@?|!^!vU
zLwh%~Q+oc8n>!TLHAN23_Ee3BIkt`Ih*N+~2&%hr|9JyGbYA9DxGL@QQy_RWUoP)g
zZ#9k}270PW<Qek+0%K*9`36xLxgGbBpFj899h7<R<3mca>{%%J;|bisVk`X=GX9Cs
zU<1;;(~jVwOShZ;T-Bjs<NG%|9vqjYeAn0G!w7fxJ)Mqtjo~od4%bptoOT;D4ncJm
zfZ<@(UP%MxsACpq2@ZSTB7l^ZABEt96+^=lot3^<)1U@Rtbuok4v<GiUr)2|ZHYWg
zI0*>}IXE~-Nl7QZ;*U+@7o#$%I=6@a0AHuy{~cE4qNWN&#V$xCg@sKHWlR?T@35-P
z3u=+Twf8^XS0E>gIPEXZ7fWsesZ;A{3oWw|WVU8Mby~f8Ac0JBo~_vAjm_ue|38v?
z(z#ntUkV}^iOpgLG`XF!*nm905(pkLcs#D{0Vz-RL#=+SkhD@n=TA-uXx6;|3H)aO
z_^F5xMcUmQh|dHn-dH*<)Sv$ER7#`(R<AYmAfNsj4zRc#VUB#Djs}Asw5gY<j<#E7
z+Ijr=vyD0|RTwi^soy8{U<Gso#ZX>*$f5o2SeZ#bh_(cg0dk%MfBMA;E-0cFq;V+l
z&-b}M{$$cmUMlf$^NM4UK+V}i;U3Mh=`aY|FaT<v0F51Ams&BW9etOJ<OBYY+vpEK
zS|(87JodHxP4_()a9T_t2`^ti?9EWJC$R|;Wbx{*<pK2~ohFCV!j>Eq2_M*yS<gGg
zlc~@=xMY%e`r4v?ESrRbfiPWA1(j(izJ<_t<gCbWbL5Fq(8`Q-xD#06aF05|tzzjk
zmaN(~K_@l&H|pnot2CMwYbwj0Dl6-^q{4a@UtLioW8R_L;f<m7fl!+$a-`oaF*M6g
zD=S7Wwn6I)^qA|L^q)x6sXNjE_$hF$M!I!k0PO^H#fP^S^0Z;~L5h?LDFBaEJvbk7
z19D=rLIz@{U*Lo=^z)WOVuwN^at+XuCgUexyoh4WeV%X6f6b!DJG#61WsEj9PeYex
zWT?Hw6I@u=<o;gp!%bs)2R~2)0RS}G*Pc{gdn#YE61X={v%68rPHV~$W|~3gIx|B2
zTGhwm59>+`H5OA@qafu!IF-TXVyXGm?==X^DIrZc!kw+uTsuB`bTQ(TXcbzCU)KWz
zIB~O@zWy3OJi8}@4$yW8z6IJc9O(ye!xV`q1oVqQ1b75oTS?8fseI^ibr-+BrFSS9
zzrZ!o_V{ee2bz=_z~>$HZ`d+%@1sc+2;Rv6O@+Jcmc)oV<lftzn^+-On3(Un?CimQ
z%TBX51U7`cV}OnJ+E&QRCUYgnnyrlIhMd@&jQf3k>NV9`YQ(K|QLQ_f0Gi)`6rb|q
zMZK`Z9E%Ac7q{x`H(hSP1VRU`XYx9?&)L+`sx&>D!=!RU9}}8WiT+R;DYvJ_$?-0(
zg=2;!0-%O}HtC<emI<70Fa?OUJ}Y~kN{_lTP_hDt^!?$!rPhtz8$^-k7zsQU4b}R4
zhh9}4#jL*%apeS|*X=TgOTX`ca74L8kw`X$T*&KIqNrL~!G(1iDa3GFL^hR=m-cjj
zF-VJYcyt;dWvvdoHSWMpOv`j7LUOu<PViK3(n2p<<zT5<vh*HUaG8z*I&Jd}ndNo6
ztb<^n1y^Ip5D1UN*XwL*)CLOv9~fuU=~nOOgzJ6;_`*YY*uxp!C};*^+dsp-*js9j
zy^@V2P45ask7sefRx7I97>Heej6>)4g4y-~!B0y~4w7#{Hi1F^RO?rKa+7kS!}~a#
zR93eGU}GZSvlWg}ESBE}D4y^^A+S!FoV%W^tP1%Sy2@kQZPM!B3njxz#uO8>$Jx{i
z3M!URsa0IAc8C$s3fGv&%aitQFE5{8IAVFzrcIMc@32^&9WEeBf+H<B?*}9JL+foF
zey!!7HjSEH-w?c+F47b`<SmW9z~f*@gB}7bQNv&BMi5|&+o);4%>xeS8B0k3(sh}l
zR6GKaAEm`=jVZ^36^y^h6^lNm9N(X+{EWuqJ#ZS0sIneKP1KFTW4BBK0}*ho&9qn~
z3g1`o$+_1*e~UeLmLO}VHZ|}b@4(ny&kXhmBv{H~L=3Arx2|o?nR{;Xy;5e-Y?C9&
zP{HK;d&L5KBNGnq^C*0N&xPVLyPk7<O8(0m0xh%2iW?0p(dkEckyfL8=e&5{zF?un
zPGz*+*U$Y%sWj#A>|ow&?7K-7tpguC+;;8=Td{`c$jxtnF-9oUfY_>l#bS-zsnyIL
zP&0lkSn>(vs+4LKKgUWLAOIeg<;~P{w~ITi?Xg@p>xUm=1T9t}jWs90NK7sruT|`L
z7ZA`JGnjba?1AtnD&_Ee3&`j{Oqxao6P=yu3_E2*V?i)VDBfJP`FKhTD|l@*eb;Z6
z&K?cwY-ZQM#5ZX=nTwGDFv8+95bGhXK3yCE7V|8i@gTF@df_@y%J0QxJrZ~PMm!Up
zCfuvD>@c%%A=|DehZZUuMebmK&CJDjaQ8S&$IxhaKK%Idy!5+dG}Ah;lP~OyaNh!_
z+v)zpY%CNdG&qn-p`erfOUtXm7Q9oDR8Lr~Vs+{^OAyP{Q8!AmSVLxUYdV==UoUv*
zwWGD&+cWT`NAx)7Bbvcr&Wz|jcj+G%7bBjjVE%-<H~hLJ_j=E@yIdiDUKyB)s@PL;
zHu*c|ntBP<!j<<Y?c`?~AZ<AS|MivBIXzZ=*m&xP>nkv6k$P|A9K2Qp2e3{7Vd1az
zllrd$RbS~)X8qEAmKz)j7G+Of=U&OHlaM=$EL=WUkWnb3xt#Oj6mZ_Ox)KO?aU(YP
z{5Fx_k3MrU7x_-ai(}jcZ47>h;;McJP=^NRZTYz>6JgX$vH5A=APj|E89cKWfcub&
zVKFK4SzxrjSmKp`e`+t1YfAv*`W|Q{1ucH2O#L^+Q3ycp27@J54^|*ugLla@Xh9IZ
zZof3&v`8;q#L4kQY=@)H>4A@OM%C%PRWJ|>nvHR|eC;G@t<_r@N@m#6MAfT~%T8SC
zxp(#AhXcgg+YoM}T-N`97Gr-r8=w?ojqVrn-?7e<<8d>|I&kCYy$i?^oP14YSU*9{
zI4BEK)R)|+$tC-vBGBFg&G3Gn)N9*6zG2#>Q?#SPL7LUUrszprEUPaB9wHp}%o7;}
zrS|411dVzk6jLx5WMO;Pt#7~3?jAM)K;m#DXXV*fQ6o+&QfNdl>-o$;3U_KJWYz$z
zNQJ=F0ZbR2m%(CSg#`+gVW6)8&MeM@+K4?)1CZ*ikJEq_8DX~nEC9{bYNYZzn}s_2
zdr)u%x5E(-6^lq}Pw0Jz+ICO+<K$zjU_u}?+Ow!9_uH3=@$R^GH9hy)O6fse+VP44
zPD#y)l226uy5P!yd3`H&;ZyD~JRXa%*yH|MB1G867zVT>gpZ^jG(D!cp~*YxfTSc<
zT)DcBKUjCCmYdz2fT-nX+Bn!4bEP7Fjii%+*@;rK;;EY_<;RuvZ3XfMG<g)NKM1H4
zV39kexp3cyhz}T#(zyLfgiOVm_lVpT_(A()HElaEiAE++h#FypSC~z7Rfq;za-#;S
zi+50;Si~ft)eqIEw}Hbj(l22VJa2nm47(9qa1_|Z<AQtobReFQ%#Xpu^y`%T7vfY>
zu%SXa2PEk?G7~j)z@^9KXxxJe1Lom)rfxN>Cm?O=$O@Y@_Zn?XB~Qy{)B1I`;GZ3r
zKNbyGrN%?zrqaxnx_uB+g=;3A2d;I7sK8i>>>>%dmvAp30dV+78QrE2W2}Le((gVL
zefgUIxtIBy4tQtaff(vNbHc>kbH@~PVU`EQ|4_UOjXo`<`dr#YsO{_4N@W6-E;qY=
zYpWjvrh*{YJ;nO=E7n2%ka}c90L~Pc(D{sjBV~qIivBNaI+%1fk$&rcArh$QPc5`S
zoc1e-gz$UCa;~<aer_VpvqY2o$Xf^N)k3aQvdN~Y3B6Q_<FV4@=chp;ICmfOKM2mm
zU#cM!ZTwW`=o9@-R}P96sbe;nj^aQaM=<8q)h}csz(J_}ee*~9);2WmFMXzHBoG|F
z6+EBa9dTBt^^lM)Hc+p0J*q6|;oZHSwlp{S9jRKq*2u&@qEs3_-tbnr{#i{{+|<HT
zhOp?E0su2)2whic70&^tz~lNVRxU#B*D7Eiwvxtbgp7_Efc2w)m>*=pC(bJqKUAK^
z{6$;@nuyM~c=)>^I4Ol6Q+Q6)9!4vrx$B-f<{9GCcs$Wgl&+p<X@T{KVOQdRi(_G2
zsUOAmD@BB`x*LsUdP)jyw@$i<pJ7}#U->L3NEYH9CX7*7B<vLvY#Bf=!~6H|J5Jm(
zDBCbXrQtkRM&m0B@W|npb59^+_CeEBn6uxFP1sa`6gFI#b<=WR3~K5}=T}hrv&6<n
z-2BwT*G_M_($-Fq!G=A8K+0b&I&0cGJz(;y^8syBnE1N~mOVG9y58THA#BNXelD8&
zw2avzngu%e&RDa`_6<j1k1+FO+@AQ$JEdN9@(Yzoz0`Qq>0G!R0y|}G>1UcJo*_AP
zzC{UGIY`B3-@IcozeGHJ0a;-lMO^7I3HkdGd4KhucSwX1jZB>m4)lKMf{nvF347+V
zfsx?4QYo##;!?kbT4!!-jDJK^VRG!Qe(nB2^j)=SGWrb2U`l%V%>)=vAp)lXqpjGf
z&pApAX;CTiwz|<C6@L)#%WtnTTAphIWRH<%Iw?oR?;Uf**w45h0Vt=FMZgSD8uz+C
z!B858)=*Afi4%9`)mXRd<lE*F;yCtR%oA-Gi0)VW(k-1J2P$okZd-!uiPIJ?=?>Di
zzaPmldI;m@no!9lC;ZG@M!Huqobvar4=fjs!SP|i-=Y;)OF0xQ<0Ge)Aa-ysAK)Ob
zVB2$%o;?GGif7NC2dY({?_6mWA&qTQGBJ%=)&_lgyhp&JQ;%nIhvd2T>)RgYPu~Ot
z^n7N6s|Sj-OTrG+<?J4QpSmpq%-@h9%yXmK2Ie^=08zdmOGTnO5*`^5@mqS%X0TYw
zM-osBID!0Ee+fcUI_Y7Gj%buOz7l_$ojWDwwf(3{y@9FSuvUfG`GL|uL^+94KN!__
zdq0px^EC6DKYqO7DPoK;QavLCBK*bPTLL!95ox7N%r}dkRZv=v1oL0v`{A#SkJUex
z&vg6gPiB|WSt~`CAV`$Wu_(;iQm8s<b|z~@?`j(fVk;o-sujIFjGNjC%X=?f$!T7Y
zabikUTEG=1U?mU?WB9xS?j3{>#E=IKqGMuS0<r1Qk@YBJ&#jn}(p(aYwXyNLU#WjD
z7Swkw2}FSrErGkTC7w!})26Q0L{{BHEFx$>`n%C6;@h%3k*HOd+n<H7VNbl=j5X6z
zstuQr+?6n9!3nb^cPZ{Sq56oFs}jYO1a&i&p#Zma6N&UnT3Xtp25<Hq2geK)Noptd
zl-WXNzWx4@00HSLn7U)Ng#v#*48PRb$SDa~o^^<d6)s8cL7#&i#0lf9LO7aaYb4gq
zLZcYyPAorem8YG5tF<`u;X!W!ai9y5h)RgQ2fka~uS1OXHP3!6G&+T46?Lp0dDs=)
zdXuQ9<)nGSK!#y};i3d+0xOkE6%JEqc%1Itf%Xq1xR%>ZTb_%9_>k*mA%E3dz5NEH
zsRtI%3hhx{S2-?+eHkcM#nH_1Z=}Q;(}|)<AovBfk>$q{5bBfAzV9jvlVr^W)GFy7
z4ud$x(^k5i-i6STP~YqINVQHL9QnA?S0UD9c!cX!uZDlwcu%yuB3dosYrmP-CPxJn
zM8G&wGCL6GV8=Z}L7{-MZy<@xFe|lqJ$N#R<v~HsNt<2Ue<)Qyx2;nv=Ss#J9^cLa
zxlpVxuiII@9mPP8Avo*;^o8a;nB!_W|NXN2ri0RO7+;ISE}I+GjjKL3yLp*y-)C^}
zyRX#C1*e+-6tBL#gm=(-aN4OlJd;hjl^thjG$nq2EF{nXT2i+@Y$=pTh&aZ33pBvN
zZy_@bzs(F%UYt<sjN_ypFcvY^j>uQC>L<r$(zo^=X(Z1PM1R5!L1uuoVFU}jX-qEp
z^Jt&I!gARh!drz0E&%Bdj8e;9rwqizpM#$i2u$V)8XM<*Y{k5L0dck@lul$ea=d6S
zD@)?EtwRHD8a^K4q$|<sAv^?+drCLag$4(+UFdvM$y}w!qeEs^VRl+C@=*y}dsv5I
zm@5cvBuW8YR~~vjLz*Y6D~J9eSo}ZC27!{;^Tvx;Ef^$y7yvXXn4*3UC=8j6hAMhQ
zYY=}idvfLxL*}-ZZ1;Cg&0(eLP2mM_T*{jApor5g898*(7U=nfwYtpqC3UmDqcq<g
zASz3*+8~hBSJ-hf#H0oiu;aY-jUa@*cKb6i&0dKF<|eW~Rk$7v)$XD#2;%kLe8yMk
z;$17a*){3y17$NF`@HrZIJZr7092guXm20Xs9kJ2D-|77k9N%-YZqx?c3Exj0s;jV
zv$N~G<?dc|P;od1qz9#nMd!O)HpN<p*1x-vs7M{An|p4u`&G!T;vLIv#?j?m`YP7X
zuvs(Vmv7Q)6}`1C)}y-zH7*XgSAfLYKF|Kf=muGi&%9Hdi@|hlu6j3PEjOa|-1$L>
ztKc<>SN?L{6*%QtKeXW6y8qsgW(w?YQO{Ox7VTFliljxkvk~5hm)`OQopXzr=MEro
z2RXT6?7ec4x*4!hjK_+<ym9?KXxSQq1+4}-ebu}4(E7RSun{ym-c8E~Jo;e$HumQj
zRCVshO>w(PoOYITFL~8{T7Iz?siiRIR_=;5{J5WMuNaJTSv&thk{Ms0#R5njM)udt
zk+Pg(CxMJ@Y>QQsT?Hi)Nc(2b)Ve;l`t^Yfq^q|Q*Q(m957_u+jCrca=SbF6W*r1<
zG&;OYTo5pdt}rv9C+O3v{QzE6G8-HKiO?+H;HszjD~cE9J#lHZU7!c6`AYrj^%+i2
zC?5T%Jnw1%9ocS{EQ-9qh$I7+5pJ_NQZ9tht1~0@t&sx<IhhZ8y`y?j<g&Z-xzo3^
z<F;!f$@(WM|FcZ@FJ#<c`QIVq`+e?)sl{faLky_Ljl}X2HTp0LBGQ%K*c#^fdNd$K
zE&=WhgqG<-*@?lwJa3BGx7%dEO<M31oZ3NByvq?gG!%>7=f1j8$EhoBbBW*r1ql%_
zGv^qoNS7yxhX+fIV!i;&lR!<zUT)9{affd@2x=i;+8HzHzg7Y%7(9-*opp#_-DUKy
zf>T8r{5pH3ybl*cxv3}><hk!aOmdA^O=HM7rFvHHLG#V82Zjx!C%itb4~*p?F=yh8
z0bss4FGef(xgFAdQQR&PYqej~ex!#z6YiC!(`ph%tGTTX`DEZK-i$eMC#@mZBMeTf
z1rvGPC)1-|QVH_8Itn{kGmTdK<Bk3qASXxhQI9K;c(EzhD%UES3@@GU)>|ySb7wN%
z^2Q<g<3s-suQQ)xds6#6;F?sbHe3WPo8zIzK06<WgE;(v|6JZ<M@y~IlLQFVpm^FY
zi$;F*)Ehjl#8@#3^$F~WMcS4>irC4M^%EoH`f+clu`3XX@Ce6rj;FE<abKm)3}mT-
z&BR?arBPVRxWZB57x_9Vuz6FF`bwdFJ$`YB0XgCs1(879j@$QOB+ZeHl|lF9);C^+
zmj-cms?F+XYT~)?xd_G(!({@iUSV$82TMpf?v0eV*H=8IzXLy9^hiE1(f$jFR!eJi
zJlvnkwgY(=%f`zwjEox3=KnuPw9e<j1m>`>1gwpRZ9cz5f`A-MDnaitE#<J{W!1J=
zAxW{hdQNkllIM0;lgpnqnPe_BJa{#)X{!Z7gv2b#`ig9c!f?LfJHZmA!f7V_9Vr9>
z-mKHZR`vU6%=2hojVTrC@2!q^*Xbl;0M3qLv9`ZKT@S&T8jfZ*0*YXh$yR^le!WaD
zHnAFW5DJpOVvs;Xqgl|&z1YBFK3B2q?enruFo!FDP~uIuynj1bb>&n-g_Jtl55@}k
z2t1B}_ev&}kJ<cE*2C>0G7*FWn2de3LDQmS*9%;dwE-y-u8pJ0Sq^S3^LmpfBGk$y
z^&U5D4m~3{s-1knn4DA|*Hw}jLwM}26DnW)KQ%jsJpHo(_X1-ezTEmCxU5kJkdc)&
z61;o>w2`50x{<j^6}|sJHqj?Te_FRJDwD);klAvF!<tv?d3G`o&qS+PBZ%A4B^et_
zn{+c?cF6y5Vz$GjvvM3Tq=gbN=@g5V79Zz5o%FT$Q+~j#*I8dsr{|{y-QN+qw5ZjW
z!Ywfi>evcrwo1cjgE(tptceBr*DM{nvA?A9hDpue_<KvrL%f#*me{$XM%EMR+A6vU
z`#xfHGt6>8Ryf!EiI(X!Ynqn5ho_5FrBGGgwv6u=kC91wp6xpUHdI!SWlA*9t4tq=
z2d9aoBWctsSWL!7Y*QBKdryF*+cSouR(0s^vz+IByU18P6K(@gz-6V1e5Qk*uhaXG
z8l82r`nYp?pNk*}yl}g~dxfS2c6*@tulkrR-^J^80j&1w;B?#IcrcTp7PU1;Dl$>O
z%T1|}<ID(6vD>8o`V>K|mcIT)xxh)By$T5S=;}DbVJlIs-k2}tqyM;KFnc*`x7mWj
zbsH7NPxbIY4W1`Yy&l!WKtWb0bZ?eUtL|Mtv%$a-a4-^Sob~&_=J^v(IU4@~xF7Q!
zUSgp&5ifQI$fW=;l?8VaGhb!NxjHNnjDkJ`Qso2Dej*^id0m~Y0B>N#PY0Yt5b%)+
zh%%6h>UOvU@U(A&rXhUxRTw+Q^vXr==qYWtD_*l4tM_l%8wfU&0u5(Yt?=N^B&PF|
zOD+_KH_ugdY;&NRzErwgWOt}?ljiQG(8>Zk>TVu7;^YKXD!UN3AA%Bv*kNN+PI-Z|
zo*`xm(xX|fewT0%9`x`!h<7KV#OMDI2KRqQ_a&V-RV-})WgC%cmQUi`WrnM+NH?>b
zLqkEohoA2v5i|&!-(w?~#*6bo5(tBb`dJy&>@pZM=c<T^et?~1cQ$m|BSM(R>)t&Y
zm=Fpa@CycW_;%8M+Ha4Eii$dHpZbmPqs}=1(-*({gBOt8KL8s;?^E=?DxM2gy$xKZ
z@SBT$>3*mO_ZmnFXFNOxax(CjXZQlVeXTE9Bc@cnvINBI=tk=U+#O)nmLE%zB{2h%
zW&gnfI!QsaeZtSgfvZm&ZJML4ZO%^L=66xib0|=P9Ci?VXuBy5$3T2ApNFeDAu}g*
ziDx3Y+<IvM#QlW(a+_cFf@malYNx|vPjD%LvW{>H*{F2>`!&fMrn+c!Tscpv*=M@%
z?bOP!gxvKSILn`@Y$S}tZ)dt#Yz#V7ki_mvis;aVB`KK`SIi9r8(?vnF9q9l#3YTe
zeX4)*cr3U?!m4y?Z+EApQ7vmbSagej0Ar+jk#U5CLN2fKk@lk&xCtz&;3^{2X)?e1
z31XtYwF5b@Igp``bm+rHZDaq395__<1#}?x5X46SCRXP@idoE2e(%x!8!%xf4KRGI
zDk1;VqgA0urP3JsSROSdm*eevAdn2{b2FI-h*eKR57=kq`axU`zuh_Rtan9{)@PP{
zg+`?fUlY||ez?<M=UHm>N<F^(3^b%;Zj>9+_h29&?o$Ah&HZK;CD5qVlw@3N!g_Tp
z0v<#Kh|SJ+LBw(pmp!oeI)e0>s9dQ`t#5}dSoRl7np9Oa^<cFJ7S8EHg?TP2K0|bR
zHBoT$F3f=4q22cd(~<sB2MqeN9u;ULo%zfAZ-$m@IhpH1k|a4^MOck;XJVweE<9Dl
zJEnoG=s4s6+X6IeX80rej{l$NJ4nRByuCvKQB{vY3z=rtm&2Jc#i|ZBQx=h>z+XnC
zUN;hM)w(nJr+LZaMmB*dq-MPj!#=SD5Lg7K_jT&Uu4Izv^hy=N3@B(N{{#FkEADCU
zQTZDuxzShbs~7jyixa*4{2IJ7z0iOF<LUAs-Znm9%h0MNb2Hd-f_k0WJOCRTxcsic
zH{Tk99RbqZXuT|MOx8+46#>~{Ik3GbqAs?mvsqnR4le=eaI@2))*$vIPpTGsuLg)q
zdF=qxv{)SEz_#%MgU%UQy~TP}_vd#?wO=_xjcgOYKNf0{cvuQ1?iUX8hY(R>|K_D6
z@H#PBULqJPJhwSSxjDVD-|1Z5_INji4$=?75eA#xiq>zh`+4<9rAjLBsDUt!G!Swv
zpDl%j`?gAFJO+3(6fk77RjAhnqZ0Ll%qxNATUw(<=8()RTyS8a!Q;^zH!*wM>eOH`
z80qU%=WjMUnHbZh-v4Isw@*&~!93;Cj#~E|=kGVp+Le4;v876^detLMxSKJ$bt&Op
zRWntdW`A4s!o!JNHY8bVXB8BgvRG&z^}O_5Kij(`Tk(0;KtNviJsZ;uZt;Hs?n8hQ
zFuJ=zFVFhoDYeBBmdYXV!5O5OO$my~0n*@6&^vbYzw!3SljGXque;M$!lI&MQG|M!
zeYwr9`>s<o@p_?9v`-+~9XOiGLre4JD-ZHscYxe|)7tqwX2G|Q8w8lyxNt+`6)4DM
zEt_)Ibk1>(W`S5lEaWnsgMc-mH~r!^nOg^JHQF{X&2>{t{;EU|oNbn|1X$g<698VR
z5#8=*lfaC67E5n1pa_l>eV;km8fm}Ew)Ecmg!;I~3g^fgVlA!z<|tM5XRfmW9^?(w
zzTHTkE;Ga+&#n0B%rn=u6kkC++q>RFCI2s$U$N2F(^B8H2pCkYd_+>qzuJf3G}fAG
zbgj$oooUuqI@kNb6p6o?kxaxMPb&P2fwYl~<h^g6V=V-c6pOC=AoL;StT0wiCveS^
z+O!ma?GHc#v=$8}veFh#PX}NYd4$@<ZszK))^D$hS6hG@l(WJ}Z}@HGvLzX*p?hB{
zX>VIkz;!@kpj$TJ@<8*7k#X|~#VW7+Ryg1{)hn$j47d8eQJ?i+2JNbN43}UHA5hF1
z0$Aox6p$P<y`rcKki}TXY;%`^#k2TwkMAw^2j4$exG`SW<m9#8zv>bpqI5AvaoLNO
zv2rb8vS8PqF4FJ<+Sm7~UR1E}fv-CSjGRLLp;g9HS@wOXG;(9*LXCjbuSaurILY@H
z%vyXh%nsBU38deaKVw}6E7(&NveN}MSD+Yc*&UcniCnxg9>jiPp<D*f6C^nO%DBIj
zTrf=oAXoqg{5mj>;`2zE5<Z=id{%{jgNv3e$|)R=|D@Qod$0NN|2#efhzaSsQH^8V
zN((VX_x>*P;9s4)dHf)b-SlQO*F^P!b>m4Wx>i%ta%POC=6`<+{Aj~T*lj04)K=Lx
zlljug^R_@&YNil#_ier&+Vm95@WvowSm$@KflR*6zsua?uX!CQKs2&TH$IKTCB;sE
z&WJ_KrzVG+dRxA7uw_~yZN{yIt8Mx|%2q>2`=3%?Nb0c~#EsOPZL;81rmH-yA*&CX
z?@e=HyiGzOv_SWr>h7MHGRbT_oH}!*0P`SajW1qNZ!_>y|Lf6))b%@^j=<whTguKf
zu}4=$K|bA+8EZEQ_&;AK1Ixak2{lsry>qlAOoB>wRyH}AOvdkF|8GSn!R6~Gw7z-i
zo=WA~QcYO}L-j84=`Pv#(ROSmbo&g2!~Hn=-83=-7V6ro1k}11fd(ns|9)xe1HLkp
zC#niGy5r9Ta}pV&8KzsRvW98Rxf<Lf^$dSk;_r?#M%`z-sp}{>!%5rJkQvZfjZ91^
z7N}3wyuLIKW@9S`RL;L1Z7R1CpUKuJ-snz#Z+Q~JsffTlsG)ORkmc#JRw<3~Bg+*n
z@#j~py(()~A-JHa0qz3?ZoM>z!|9QM>vNgaf5EKasXBud)A$gz<FnP6zoeXr8$?S%
z@221P+aFr1if-)8#d@-E&(=6D4x*`**P#@BJO1I<%{o!CO{5US^HLpNY<H-%0E^_?
zAcHZZHx~ZCzu44c<`-2P13n@NN-C`l@Z_BtSaC&L_odQu`w1bl+vS=%1^6#%$Dr|7
zrHZ35t3-CZ7REYyG-V7yN(WavPvQ=YNqlYITYS*}_n!+}i|D8}@I=+lO@HXZ47+XZ
zE)w2Rc>7vKDHFFKU9%p>T!E!=5%YCXkV;~S&soHejjEOn23<o?Gl((L4(q7i!K20+
z=Be!bsambGX^{KhAAqo=_eKgvKN9Dk*HPmqO#R-P{?=BRxN@Z4tU?g#EL+wRd)U3e
zUn63$QKVC!L<$Y_p#Jy*#qpL*wVxd*RArwRC$@CMUt8;@r(UH8G=2InRtLOs)c`rN
zZg4k7_aqo5lolAqRTq#wO_*>0lv2PpIMnf7iOy3=3B^lUgpGQ$vo&~nQ&9aP{7m^J
ztg4kSA`HzQl*qrH(9m6w6d;WM^%(u#wOh?dFq*_J<Qgboyx2L}874&9#q_@jd+V?$
zyQqD8C=(>4Q&Q<3B}BSWiJ?1&MrlM+2`MS5K~flCXz50}yAc5iDWxSOz70M+&-)&~
z_c*@&pK{NhyJp8)>pHKy61mIRatJ2#UFS39rMm15yx7k<sIcPJulI<F;^B(5EhVNo
zZJZ3356EZMW}>u8{j?3JzR$pNO3Urn$q_t%3dFmNK`3P-5-<t(z-E$rj)GfQ4``t5
zLF!Tak;{o&Gcuo?-`aU`h1=SHe9Acw2z3B@jSLb*-r9d$f7=j)_vmv1_7vq^8$U^k
zu_D4s;>n(PM`Fe*hBHLh7*Ao8K(c1(29HjZV}+vs^~*;v_e2%hYcX0o2@32a#KleL
z|1XvQ-DQ&!5J|aE`D4`MHxKi}zxwIb91Mxq*S;d@P1FLFNnq1atR63N6z*E>dg?et
zcnz{eq{se;8@FhAKaE&oft%kfSUaoI?5R>O?6WanL4Qh%+Zii8`V`MiuD#0wa-Z}6
zw?=ig!GNYMikAkIsnTPJEc_XcdHlLOgoLw(1m5lPr;jRj3wX|OYOlor{g=mntNG`x
znPeIO`k0?f{<%?Q2n@xbiTN+n-hB2uTmNpxa#G_Ocz6Ir8ZyXxbx1&5dR?M={aP}q
zh(IH8Le9#Y51cE^IfTlMfj@R6HQWnW5{>;e)Ix0+sY=|N>}v4xS^Lz9sx$_%d0l#`
zzieNwGazginUnve`Uh!`pF%E~{(yiSyaNDZd@p8PcE=jPlY_0r$loSe?OOy|v&3?n
zVNlHsbSLyWk31GFqKOOZREnnxKed;+*ENSxJj~t#MQSszYYnPB%ywceNq{vneoP#j
zj((vsuhmu^uDfayh<<efskp)BK$ThIZ#CPAt(4p`RE1UV6e;2YpA6u*I!N)QwK9r4
zy#{4MeNe&stN{(^Em;hz+BytmLYe?J0tl1TtVUl5+wZ6;uZ%a$5rK+G+Z_N=Qz<EZ
z<tABK=H)X(O+>UhCMyadk}m%72A~*iCn_&^rr&AnV1P1VRdGa-NA8_=ur=0DE>#g*
zx{Y*Zt;jPt1z_HB+lfc;6U>X7T$lUNSoPL(sds9L+w^BE6Z;f1o#+%Ls{~_6(p_3^
ziMm_<tY`5E^)-tu_p!K~n~BOBbVXsmFMoPIn-N1oE*oxO&d&44kBk&@{mG$S8Nqf0
zbXZ!$Opy%KyX*a>1AtbO{_(>ENIx(sC684+D?BR6TIxs>>IC`m6UUQyz(>@rUgTrB
z?tLyX$&*RklVpF~lK_;qk`851v*Xafd0flpp-lO{WFZ5$cz}F5{hs^c$?Ej$*6&BO
zX|x~|N7-C2OiNXH-sqbW;F-c_sj^cnCl&hVw4W3~1vNI!Cm*c<)dEN1_Q3a(z<(It
zck9+I?J}GBF2>#N4;+lQ00)%kaGlfjq|6>bPQA$Yr$PPl$tg+g_x;s$cqg_l*K2oB
zkJ0j;K`MlBvd%Tdxe*$9o=GBilp^SfVD#8<p?LfQkbv=UNjUV6t^9W!e$qrE`Ru+S
z+*zg1jGYwov}!<=tU7?J{hX<IQs<nr2o{{6a=!NITjb}g<@OZmQPg-gd?o-uI@A=4
z<aLyV$|(3QKwa0Abfm{C7lBqsuX;aK8kDd)fpU}@*G&~`mCS~*f`u>MxKh&6IHZr>
zz4x;NULl`$Kx$w}{cYfhXv{_BE6u~T_i4?a7LIn-zpzQ~EPBoVn3rgOcBrZtf&l<)
zuDK6}zVQ2@I9?tl&8XG6sGjd!_cN}zNyg@%i&sY+sIg+9H@7A}38#}RotYT3n@m#<
z*|xe!Ab@r@@c$D|wBiDwiGnZU5)u})Tm!45(Q_LUX?lPO3vhg3ON`&fo_C20xZWw4
zvE=f<>skpqi)^RQUgg8OK_Nz|?Jxq0-(@=Xv8tQ9;wl#K3Oo)Z9Mp<EueFGj3W>9X
zqe%KaUoqMu_<+~KMS)|dxC(xTps~g8v3woZ%^Al>YEyn|A;bW&4_s?7K7Z*9V^c+C
zJjn0|>L^LNkEPFlkvLEZd40z}!+Iv1!ZB#`zY16r<2Yd7lkD^Wqhs<#qo|fFXV*W#
z0Mn=%%LU9pl$8=WfBa)tU$;l*-<rTSId};t5ei%$?3YJ^x`}&ds()^ltwW#Br@pv$
zzPE4y{)<&NdoD91PS&wcujnP%-2gAJ8#NTt>3aZ{gK93e_?EX6@<VmD#rN&GiUG!I
ze~LF{waxrjF!ImL6W5KmF+P5BTnQ-QtZ^J3xe8e#DIW4KLdE@W6=>&QC!rMdU|?g*
z1712Zp_BmUGL?Dz$9sy$Yq?(}K!$4h`KY(chRskVEtUSVVgj-^9)P;aTwgn#&(%?n
z<Pff_Mhe1M+^v%yy^8X^|27<b;+;!*o6vN;vAkO1<3?)Hhc))Yo9LC8W8;(l_0H`h
z4NXg<thd5)6)Ze;S~(<(ys};@v!|NDdCQ7UkAgxj-x;@CfY3dS45Qei*m?!3ul^@a
zKyU2NkgTYvD3E4oh5~=S510}NK1<SrGSj1ajO#$X&mQa8VE6&paz?iN0L&Gr?KgS4
zlFKNf=PU_6$c?ZJiyMmiObA!QpPXiFf@xDeu5eFmvmV%)5VAXYeX2v{0G&gI$Qvpl
z9E@0K-f$7~r0WHI;LU{^FMNyh@CJV(;4HQ+u<h<(b^a4BJav7&_iI#@I7<9%Z&!@S
zfc=>Y*P}=AjHWBzInV3Ajsi-71)yz<zI^%IH*Plsw*Jtj+I8~`q(7OSCH1*^*;I4t
zAbZAV?<6$5v<HStzyTLXua`m9)=<SBPu-uVuI|^LS9DwF>#zacVoQgC+%a(E2r}Jb
z1s;@U1cdoId?9J}U-G9b4nQ3ts6w4Rk3XFC&H~EtctIs?KI@B=uXc^$U=&=5e7I?3
zm3Q?M9|%o?a5VB;^y&38v*WFeypdw@%{D6-%ab=!&tyo6mJH`Q=VS=js2*bw#T77!
z@N3h(>e>(|zs{9twXm9l?U{Gmpa$<t-*ZbQ9&Ke+sHYsK8j(_AQ^jIc3Q;d9jZG*o
z)bt^4`ZC$)7NdI@mvSbb2Gg$iG+<f_(zQ&FpO-6ID#!mvBiN&uj2}C8>RcuZlOvBl
znU8n<a6uy|5(50Nw6<p{0`%RT&mTLlmEuKYJ)>A!9YW&Vy!m@A{MF1j0I2k(JTb_0
zV019k+LIh-BSQ_}KL=|tf6fMS09v#MoHS;lsC_|?6<1J@PW9(c%IS5lD&uVr7Qhs5
z0vc(VJJjqCt;W^{&#-7{_g|l#U=3=Cg8JTIN$28pe_&-}!p>mp0yt^sbu+z!4np(d
zZ+sS)PNYI|XwuAfk)J=RF;4ygTGFf~P(K+}p5eb)f8;PdJKb5ESs!E|bH^J{0{wU4
z1-fN$;K0xv5dKlfaSaG;M2?&cYsRNPu<9HydY`Wny#3aR^oqExPeJmInyxtb&}(a)
zL06wyXL*;ifk~>)cyw)YIP`(*r1<Q&x)rI=;9!Co?$Cpd!(6QuD%nDjQyFYwG7rb+
zy%Xk+69s!V&fe;-o>iyap0kkQ>&Q5vM!Umu7ktcK8xH&aV8%r)3$x;~M!RzB+jwV%
z?|h+eJ}s&LUF9F%{2yUTI}w`jhX2Bpk=BCNeI8o+fa?O}S`l3O<sM5Q%PVOVW(6y^
zIaPQkH-!88_pk7(ZLN|YcaDq>=jn?NM+f;8e(}u!W9`hB^KZn&0%#@Oqf7~^#z3}&
z6|3hTrh%&eqZ1NgW*y{6*Qm9HPLvCspN@E;0%FAS>)LG91-hW?hs5bE#6#;^_g;4g
z`*ocRud2^xEA_x82fz#%mE}2cwAN>FPKzbC(>?#}v1p}F0K65*{=eAyU^ybTHS_Q-
zNE|9qaa_lxLh0wP0Yr4x9V+}vfHxlm^9ikL9A<fs`SN7tSI$=*BXuAH57m|`JWMDt
zUu9R?xez%3rHXR4sBfv|zD5Qx`Z1kXPP$+kctziTw!CkkKtO)n7|69BeV*k0qYihv
z!gg1<F7Fu)dz-^7m7#yXWJ_65+hZN&Jf1p*i1tSzuRNvRuu3iaLDA!gdSzdkAw7wM
ziuqdGC`Q#pYPeioTiIj~`u^AksMO9At@Kc`=$p+Lmy1|8LfPfW$ra`Jy~FJVJO3o1
zavEMckfHK+15@I!7j<NMZ=1cT%WPUv(-n5nUeo_~z40W4m{@i7y_BE8c0?l=R%qJ!
zJySjwueio}eMHb>PxCF3UB4q{9VF97b78d2(T|~n{L?>^4#dSJ-k`q)6L<ajZ&u}3
zJ(aWPXXe+nUIC%s;nu0E)Vz+Kpy%n&2pX@G1V5!1c_OL#h4b6`DFv~;i2BKVnKJGD
zRsRUI#y22}88zk%NM#p%gFk$aVdB1g=6#fta+*vE2(@bw(Rq&nvok<R=i2o^1_eaM
z@mAWNUo>C#bP?HOWoFfk?BOhF3)v2Ez%r+<VjVm1Fc4i9u4}Gw+T3;z?AyaOmo3C~
z?T@F$=v)9N6Xbq(s@$>;{?olMOeg$DmeK6N(W0vRx{7y8&Ex8jCNMz4a`n7{{wN5z
zbDtHN7m6svvNxR1iTP`EWy&Y)EcfappKIqMMrU6gV7OBS#&14kMWO1o%b0>F+;>N^
z^~>mKcyW{Qx=>-=o~UdAZ`nLl+Z$9T4b1szfA<m!f3JtXsK6sE0?xfz_${?QfqT2K
zK2>Jig6^Jg;W(Rv7XGnLw2bk{faW^V_EMxMD&8hY`S6<Qj|R=>M-#=MmYb0IL|qJQ
z-cH@OBI0(IDE>^#3V49m;BHcNeG<1x!2ex`>=g6=)FBhBrew%P6;(D{mt1H{jObn2
z@2SQSs)72Gg!OHM2K#0N??&h8?Y%b_j_>;D0^^<DSx*oC3x0xZ*Jt>6#d(GI`4>R1
zkg}syz>IjG8OKy5wG}On#C>1p$F>b@HLM$j_a!srqO}EG_e|>}Snsm~(N@T@({fKd
zf!>1pik{dEO*!cg(`wiAi=E55>;|Z-3h?tQsth;-N`4+w633?>78XJUitm`eTmXe$
zq1<tcPnYY{S&K!Stb70Q<&jXgLOqW`t-T!Roqv~3bGrOa<x_enParBwd)PU{06ktH
zU!!-R(O9cPLt>m~Jyg2qW4UbJ&^dzp;Ja*+`xs#(N=k;eSq(Z`l=l9}<tr~dKd}^k
zxh%Pvkj3dkHjaB$r~EmJ<8DrbN9(}A^UFfz%h+kqMeNieQ)AY><nF>SmhIPCMvz|u
zniXK?xeU^^pZx;D&jEw)PX~n)D+B%b6h0p7-nUe}45h>|gn#0yKm|v{+WY7@=19>O
zhtQuwKe`g=B?9&UP0TGzXB>Da7X3iKG53h15sABw^bIp0A+xc&$D={U-4BP9;M3%5
zVHQospJ~R`OE-_zkue4v|LTZnZTqDSeFN&RL6ov-IpM}!RwLMHfpUmv?OKITZ4>g>
zKw(HoEL-NEU?SEJ99m87)_ZRL;pgI#rVN%E72=6XorcRW^k-xa?ykS4Jpc410g6M#
za*h0oC`1UWsKBY}x3eTU`lBw|u2Z5$#Q;W~-;6LW-t%gz^j%RYNC|hSMjNNjwH^7>
z4JM!7(Pgh*gWkOHbR*WwK`bKTl|B|1WR4kvwvh{2rfmTQ+TU-*Zc5GHhHJC-vQ;pA
ziJI2DML6y)N?FQ1pfPw~N`?PLjg!1}opbNxzoD~x+^4FJZUqVg!&oo#5<U>cF-qZ!
z_4BZoFfA2iv1ssRkrI=AoVnBJe7m)}3t6?U+xzpc{@oDCjs}tS*b0AwQNK`w!G=%o
zp=2;tF`Q3wU9(|0p3%{XPsx%a(XI5dEHq-`c^<6;*xWD}yRE#i3BIN2hKa_;m7>!-
zqvJA$=h_!1x~n2(G#K)2r5wQ9FJ2r&(YS^?f#kcC?4VLACi}s4jI*r{^a)Ad`?oLt
zyoHS?Qq+r-l#;6Ijl_V+GCZPuzp|r%=9}nA4%xqTaY%$H{wo7H2>mT`AITe@Tfl?u
zrwfJ18L@G&C=(w0-}B<yat~8L*Mz}n?yI0fgrE5Z%4~7r#Z87|Mzq+;a@!2|FbodP
zc-U?hmtVi=6LMyh09S3e<MN1$5YI;v({nNBN4MZUM-kr7yE~+JxW+3Gl~p1<FKP#>
zS}u<l{b)$FPeMwXZMg>M3HhC%!nL0ph5FWT?jv$IwtXJ)<=e{?mxD;mBB{OV%DP|Q
z3U__iX%5DOGfN&a;@rf!=w$8<pZA7~(4^SG=4>D?cB5l>bK18W*AzZ3&#gMa#^+7k
za|TVKy;5(i#t2M!1Pk7TwG337@+Z4X;UB~7<xLL8OcN1hp1Esf$DN34m%v;f$-rss
z#?OFKC^}5{DV=U}2E@Yvk^T*+i+aTXu&)3qQC%&2I&|FtW$;d)W?Knjtq=ds-(QE^
zf$@_pp|}N}L>2h+>m56gZR9&ENCdQ)5qnQg#8;7jdFgkNHHpZ^AJWi08xl7(Oznk-
zT>2Lqxw-kdk>VM)ABsW<`1V%S1sL2vrLXjfb&HAlGWbYgc{G}Qf%UX;_&oN|?q%^*
z8tt;rZzp2y?<njz4z|BBR?bgyGcVy=LEA@mitr->P=^c}13ZtZXrwXJfPWCn{$-H}
zJD1iMr<@*ELoY%Ifv_$?j{Bp0<WBgjh@O)T%k%GGmhtLOu*+6{IFs8z_jJkXf&OXE
z{Y~|Q7rh!{3t5)qNJU20A*dTsV=O{fib9@@;Bqo)d{xKFBuTsZ5Ztl}NmFty&S_xy
zFmE_ou{VhP<Kts!P5WJl8qK>Mq9c{ljUm_||FcV1AK$+lh*0pSM)5j6qrnG<zEK%w
zN#%9YeQdtGM~{N~FyT$CTa|3cb-rs5+4vhJ8uy-zkA(|t7;H-N9*^Oo*<ja|WgE=w
z^MBxU<{U~Gt-9Olq3ovN|INrKqfsSKDdDGp4!k-hFIZ4rVj?tVS$QOY3E(s?Zp=$6
zY_`&ZM21+B0WLg<>;uXB)~%mUo=a>WhdjAcwAxC3fZ`_Cky&_xN@(n2_9oi>U_Crz
zAhqZ}7Wm!-|0))sJH2qbmcI@Lb94;o-53mh-hj$gzWj+s+)&mX7V9=@becC~uV67+
zw$I0Yj4gUX3uj(mK6TH><=$|YR@J?a2Hk=|x?409r%H`AgVqM(sN7X}Mtd;xH@lGM
z6C2Rp<<NdwMmB8Sww|E3VOy5He3AP+F{_W`r1Rbv`zqeFwfV$l&2^cR5lxo}g3B{h
zyj+RbF@*SFzJVQxpNjBY<P;9%;g-Z{{dWqyombaiO6J^Y{y1tbszMlJf0Vnu_x0Fs
zBY?h#F!#e)rKL?-B)^2THQjw;-aLa}EY^Kmk!p(|TLnh?^!D6qzqRi`WLH`uc5bab
zl-A8N^ez#lm~U4p7Nj(0VNq!W1cHPOEzglc_`|kUmS8=Y8bygR)?*f#>T2Xy80^5%
zsy;T{u=phS<B<4~Rq#J7iF<<i)^+OT?>PY&h%lY^b)7m!u@QFbz7j;}{&#?RQj%43
zd<x(3{v>&$H1em`ftUZWSukqn19os*e}C+&52j}ppk6EjYMkpFlPf5Z+=@?;uCe^C
zP2e)w*Lb~wq?`-5x6+ugj}$f>3SWyCXeUg(OS7unrF-T;6CXY|s%CV=(qqT=07}p(
zj2lZ=BEvf@J*L>2n^Su;QdOJ34U^YouW(uTTI<LhlCpjM@6eN5*;>W}>A!m@`2@ZA
zwqfs1yWq{jUxT+gt%KD^jUF|g#1yTLampF6lqBpDYr!}9M~he-ta1V};JV7WPjlF^
z#0cc5Lg&mi8!z5S2uFt`D7xRO#aR8*aVT_6bME6iSy{~>S&aObxv^T3Z2i-DT#nN8
zs@N1!6O{Yie)ny9vNE)?gm|*VhI%|D08be-HwYPa<1S9drU?O_386h(*3;g7Uyp3b
z217ffmfaZJu=-$6yy7df(!OZvb?PEI0%dy4OTJ0t-3~)Y@{@a>b;bg{M|&qN8xYoC
zw$&eaw+U7X{kYpB=@@dh8x=(!usnLG7CPzq7<Vu#b?W1O$I*cMJw*H8^yJGg?p4^_
z*rMW?=?@E(jc@w?ex!;Ric2^iL!J*Pl|&zwG1FmcbEb<6of_?p=LA$y!pX-Q+&^FQ
z>YpayNnlBQ>*23X?8ua0KitzMgF)d^l0GL1WT#-9zg-y$Uc#YpG!YBgtb?wy2afUv
z;*6`glL>kx`KFLuM3K+W;2G&BPQ%u6H*JzVsv1WnBbm<Db}^^--kDS2dMv+vbJQb4
z2SGqpadtHgIxF6uU(S}G^F|HZ6-NR#iApQt-MHI^i8G|hxs%S^d89;pM7n>Xu$OPe
z>$K`#?;bFxAZfXyuT`3=ayJ+y^CTKI7O(h--NqnMfLL=jM1-1@D&gW}L5ql2J|QPv
zmm#*mFYmd}@LjAAaV9~{Y2t#fV9QiQK(tqBF@rYdZ3|8F4troRNvF{@!cf+djg<Z#
zcVZYb>36-SCnzp2nv1!OvJs(ocQyMm+YUPRnb=l_guFBPal<f?y11u=dE!W0%6ZE&
zIFz<VF}@jzkw?l@RN%{QYgK)ciIpgV6Gbi4yI;oQU}=e>GylV10_~9T=wjei{TBs;
zCscpaklwsRwa($xdUz>|x+rf-O%F39=yj51nl1bT-+^~R<SlJrzn&wA>%9CbpRgt!
z#R4l{Z7U2Ds)vr2dS(ulbr>j><h1>|y!O9mNsoyTFy}TlmMuv7X!vV!jYr-7U0P!R
z1it*h$nmf+qRs)%NSp0!W~;h~tz9dqQGsIVF>C#ZJMoc4llQK14uaG=@84|kJ?RYl
zHDEWo%TGb}vFc;lHgmXa{M6ojO^<+QB(HL;>=xTH8_zWeYu~2<KcYNym$6YU+%$DR
z3`Kpel6U$)cz*VF+_h~cHM}~(!L%xlqhu_^_I#Z%7V&s~I#y!*s0ODxj)8`nhGLBd
z2ibRxVl{&HFGNL6Hnmi+Vs4Wy&RPFu0yJByGwXI?*{hC>TTtW}#^Vvej=nNN*0DLE
zm6qMjk^7Q;>R2{?WNhASxrbIt#lnlZ&NP$QHs#eV9=JQSGd2j?wyP%!AxV!5J_|#G
z@^j%@jA0vSWE<C0w4!1Y685@^LWs<%*?Y6+=-%wxx426{KcVxgKH=3kvVLF*GZ|>S
zIt$FF&SZK`rcbcA?gq!T-w&~XOEd?sSgdpC!i9}FeiiDf^L-MdmxvYC9;6JBK69|4
zevNtc+4NR#v>t4no_N}~3A7gcoOBu`Ej+B$KOc>gYmaB5^-hMCNEVN%fBk*q>JyS7
zoahrg)Z=A6quwxKqTJUQ+#jre)ohDRH34PO--gHg)P6M%V*@G2zf3u}ZdSIwFtKOD
zwx0RmH?r#L(tRe}GVm-gT7Pb;iUrMsY4xAaQiap|==qXe{XXwe@5-W2xaQx6{S6}l
zbb{C1TgaFPD(zM7kH@mwAzr>(aKWK;=E3xok(>W^<JQsU(@rL{PUp^FNR)2yca;kM
zDvYHlcl^%82WNGiu#$W}GugP0(8eyk#q1jkPSX|b$>(8S$u(y2h+}pioO#ys_}k);
zZYnp$pbS!eqPpaE4|&9TT?uoT$xMh_M;zJJcN#KY%Unr;xJ1?kED{N-WvldNGLh7Y
z|6-|4r!y_8H-)wcOQR?DcEHV2%c}A$RY)&K?Tb$jem8Eo*1|$(=1l9l^oCg!$3Pvn
z<X#_BpHSdNBt=rM!W%*~mZ9DUKdM7njs+&);o^O4c*F4OiwSaMK6N`U<zj3Y4+~;M
z^26A2j>BQm4y&xcoN;;x6XDeFnBJrkA+;9y?ha`fsO1}teWNtYA`0EmzUrdZuvpJ5
z=o$J1VJb&5TZO0df`+Si6=Zo`YJgXx;g}}zuy|6fjmn6=Ny|R$6IA*P)s_S&Bghk|
z)3-b$SJ44vp1;i}989tk3DLn?qd-^Xhw1W&lE-b*@_dT#*a*tRW{_ClmoVQ&*rWbX
z>m<@TLGe{9n{oX4R=oA2#;Yzo=v~m*vIGg-hX)#TPX%R9Q7HSY+eV|<^6EAj-kk?!
z);&y3F+UjsVHEvdjKiWK5G(uvHV@O8Z=-7C+>Hh3n#*tCMSpdjpwGj1%efdfcj{tp
z#={CU{I{HMP;Crs`dKml(O^7M_*DouKgN}V{kk4~-6ndMlAG4e@@^ohgpFpS2WgQ2
zgXWr{$t2H?X0!0W=f@_=NwDvy=B4<Sp?w(zA7iCH>hUxTq-T*YyJ6Uhj5y@SLN$fN
z>$jPtCRriEX^D}A$coJK!N5a#vJIZ4!c~!7lYy3aqpRy}lngRT@&^8E^w(qY{WtKG
z2kyj-yddn<7^TH3vMQNu?IS`)P~~MWo}tK}U1R6fwr{mD9aQl@gDr*1hl0gNs0ZAk
ziILkWJ}c>RfqT)hM@u`~0FT`yUPHiBBCR6I056y`THg5hjJ_q7D$K#lR;5mm*D&X6
z$7stv<6jIEFtzzp`A-wfKCt0?#ADpcVpl~+bM#*Rq7+(1@!b1`@fdR1hQ3DMrex80
zVI&Q=h;HGteNVaB$`ezRhLpNp{cE(R9YNUG)@Wez%`nnJ!F1l36o`8NwtL!Nm+$Pr
zAl7!%H4LV)ZTa(~QPMD{X$|*^biugdzU|srk3LkwS9wgST!bTvVOjADV`-tix%-!Y
zI)M0a9zMLLxtrF4!&n{gkzk4?BaGBqK}q2bn>jig?4(t)@#;vAmg{Ie*LS;~Tyu}$
zeXK?pxhx-O?!NqH1g^@Ucov*b)EZc6)~YngVn<wRNdrXte_P|jlRor((&}--N~n0a
zO!?#nx#Nn2#}TO^%Tg|3BJ5`3XDwAe5I8sg{01p&pP%r@@t2NW)2AFFY_zL8KgTL^
z!!Y+06|Wt$s(KpL0^?JuLg@{AXV4KfP1uzH4-KE69D<toQyMQ+p%QCa$_emco1RkF
z1haAm>I22Z9H{>bsZ3Ckl#_Aq@A3?so6n2GHHf2zI!RXWOFNuhjj~)QykZxIh7w^J
z??BJ5X~^($zG<_7Kll`jEy~D#8#w>*WxUAvQ9iUQV_i)S=eb>)UehJa9$Vo1>N{)9
zVDdiWFNS}IpW?fCdI*-=1;riJ$7a>Zqjd&6USUHJ;!LY1^f9RdGIZN<9K#xg2c`4O
zs*%*2HuPAw!y#&Vk0?s0?c>HnUo3yuc;=S5GsAL6saQx&kGc8pJ`0@p9P3#)nmQp_
zdERunu^LyW%KUt=pdz=TAwF9E3Y05mim;WgqUzdMoxUELBdqs_>`?pNMD+OkwdpY|
zDN>sAxqNo$ti~=z|BZFul-Ujh(L@wYO_4t8ejH}HN91c7A3(%(MR2r=gnB>kPd!xP
z1_gJ&`$=h0kX%0tio?q}#(H>hq(QA`nrnnTg<casnwA+MF`UVh^WyPW?eGr)=vNO9
z@3y$$@gk&VS%;XHoD9R&nJU*(`elidqn+rnhH0fr<sVk@l%qVko)e<UkNZZo2s&vJ
z$9|1a2o#fxtWo@QEu`9X%-e>c(iRE}<9DODdarhamfN-INnk#ljys6hVkQ;MRpXdN
zc6$7-7Cvc2*DzQ;DD~hs@Sw$3jS0pTJs7XNnHOYKhf1I9J?U562n}ant}4X#&)e=L
zObmDx@lUsq!w&i$jGi!^0$-x!KrI<ug>uDMhBfBCN^@00UTY#xH_l;2qP!dDn%pwK
z1+j|0@r|#$Pq96|1~B2dH@vSddQJ!oWf^2FYOaQ4ad{3r^p9n=xcPHwosz0G?$AI<
zoGSg6T?&{U&c6+|MHoNzF*R)(vJuvZmCo(BHdbO7d7j4-kA5}t0^Z^}B$0d~)YK)i
zF!;v@dHtUTRY7z}Oc${d!5X^fIz%!1X$?JarWTc-Ea<6MtAWE{8uST8f5vtUUJ>;8
z1fEgPCPV9b);2%ijmhj~N)xt>!iPk*1*2I8#=2G^MqfJKTrD;lWlpFuY>ZdbrBM1B
zkJq4I<334Ezpu)6D{M2#!<p7%8s_=0))5bfqdbQO{Sm^)MCvSz{>hjE?=qe-(lS=L
zWm)oXWa{GA=IR%<WSMJB(zp#z&3C?6%=qlz6|-S0kL<Yi?+)6Drj`DySinF(CF3t)
z^Q*_wkHtNeaZ}^(uI%DJ_3=uGszgS<aQ!>q2B8~J8iohCFF-KC&i8L~V~J<^jW3=`
z^bm*bvuQ%rXFdgfN4agAt9t}-LkYiuKw}Ev%xN^eyv?z)U-SC)7}jbQU%Eto0ZWqQ
z>Mm_#&vy(1|8y8pxvfWH75)LUo5l0!bD{@PN6u^Kc1>9Wjj%kabp{<Cb!&t|kmeYl
z<G*W|EgWyGB0l$|Aq}=1)S9{~{@nwXQgzz9@hIkCBdkOvw^@H@gh5zyPm*OVZL!V+
z!+*XCQh#@@|DCSu{`$!$OR!oZ4>n#is5gCJ(7XPPZ}<=YQfaID?@(_jyAclU)#*Vz
z+HtRIMn`r&on$R7#A`%Q-ss6JY|AV}#&bpDgy?*Mzg0I|w;5*fX_assM|fm^`EQV=
zGDm00wcCS1bOKN1Gf``g;`l9lSx(xe-;BdcB7cqUJ^B8CkP}DeZT9}_tgkT*%LToj
zvPoA{5#;dAGjvVz&xpX|rRq4&N0cbSO!uA=C1s*SrT$YJRj}j;X1rc%%w{pPmnnlX
zqRZvLA4Kua#1J;C>s*GtE-w2WwG^)MvOFIX+J>M`WT*sOeLq)XNaL$kQ<U>~oYzm3
zQVH+OX_*|&1ld7euwNftfHrPA{CnX<(pq{|n3+;|8eE0{>fuA`@#msLM;2*TC#}RG
zLQbI#;vH*5`&;HJ^^50g#~L3Z&N6%D&_mQTb;pATo5gQX%#YAr(_S$~3f#2~!Wj72
zfc-Zh2TsgqvxOS{C$zIL$IIW;8D${z;cXySZWC`g^Wy2$hKt@AA|Vx~hilz;<Yo4o
zEoPNYGj5=7zUA1$5QXf@3EwN#Zu{I80r&`in~(RQ0B#X}37dxw{T=P>*$1O(0+Q5h
zB1eV2Oi@OwD+}I46f}5wRw~tqs!w4)R<Ij}qikjlvc-qp_X*3N-st(KAD{sS`&a9}
zo}Qj~e_4QtDA1MrgF^j+++J7LsB@{G8}KwxJ#irH=95KPDG%LIc*-8QrWnTP(s5sz
zhY7OW97lvx^6!so3xfu;$m|+}BViHcZJWwQMDsvV07j3w(DxF^v{RbR!*-kyJUA15
zJp1oLY7ARG<BVaR`?@NNjmF$TMRda|tpC0YTfrisW0{TpcoviIr3T3b)rq-{#t`dD
z`8GBdh)&}$7KvmW-1uAz?k3GPxe#_|C3bB!LdPh>tML<3iI=aj76@@!{t{eQ@O}Ha
zJ=Ca6TY@ezr%3Xogpw=|fj^+T8Jv)~Cu2;`pojiHrpLS0ndFHOXuuf@yrUTTXf)sW
zgw!&bXaRpg0Uo5B7yo+CVtVftj)KN;p8DtP)DE$ZF^PYN8J`yxB7n4d#Hx@{U&aij
z&?<qx*-r30VrW#e(AZEznm2yOsui5=d+b|c{(v{GJ2;{ZS%8#QJj(B9wy}C~^;8-$
z9J%t#*czYQAKi0GFpjCOHn6UkKH89Rchm*N5UWo$+H~<88QBgB!U<wSf+P7uZtJw}
zh2W6&<WAWjA;h$U5%pJnoisNvXwsblq!m<TvJk~nqi2wrWljtffQ$;kF)f8@-e8$x
zg1pT(@UeKf$3k(wGbINZ*4fi<+(u8PkpB+Hmadoh-=BoBi_4OH3RY1<aMuklrq(W}
z^>Mo_m72k90Vj=~6V?I#qM5e!ko?eUxM7Kf!a-!tV`=huFSSGwgCbJJJh>;D?-`aq
zz2T>qzS`G8wy+wg40}f!5Oe{j1gIOq#J4mnYjx3u%(z^A5|l6nqucn6Q<au-e|V0S
zeNHEjzP_FhbkbxGZEdV2pIGl)hNCX7bqlQlvq&|>VLKP4NRyZwqBn|sL>bHcx=OaZ
z>g3j4jqzgCc3>Awr2&=99<n{QhqOpSv6|9v#uC;ci-^Srv3D+<)h?RPlS39C95O3R
zhIQBK9BWm6y{5Iv+`QGKB-MMXZ+!tEIn69gE7~G~)u6xzhhD4DM$xB*^#<?c*TjJa
z<6{H=ehfCG%++EY;?dNAXF(st+uxDLY7mAy25TKKD9~=5)2G)fCEd5ar;#A>s>)L_
zlV!L$g~&00L5UO3cml7^orR4yiGMc@X(9XH#ER>I*SLJrfV^oF+Er#xi<;dar|HiP
z+EWXVR5xv6YsQBoxE%|bh>GlRt;r`lYS9K$KT^w)G!hTy#((Mem@@QSW@Pwsb!v?s
z@9+E;gIH6uTlZzC1wYR_R+B;~DEVvc2=lI^F&p#ZL-Q+;=Fv#oeawN_)v%sdF?_9*
z*laC@*=dh<jsBek(IxI%ecO>fO2I;C)fzIPC$(<WQJXk~(Ka}!j>mYg7>Rt-D7m@K
zcJ0VYWjpxo7#k~*(#gAoh=^<dj%QdQ@_SB-L>D;;KCYC|H~~iq8I74~ZPh2;lm2p}
zQ)-Dun+~{|9oD~olUt_DoLw#BAdRjk#Em^8B?w)x<2i6I2tjz*+}VeP;(xhSl2AfJ
zRz2lZz+VBS1?Dz?+abnyWH_A<76(E-DD%BekmKE6R9gOM60#7sr!AlM_TS^ae7bGe
zNuQCflBZtO$o?s2KXMt=IQ`QLgqV+0!DDcT>z=yYk)I0t>zl#v>;HQf<6C?&PU1zE
zuI}_ZjC5W%e)?Mic9=!Pr|(l=Tz!kM&_|P(G|G@aBE;ji==3W_SN->6o`XXrEU^)q
z_Bpvy!>KyF2pP{_9onk{@OZ_=LHddRiTb0g4Hzhe?oe;7_)8W7hxk-3M~bJ;++P@7
zkr`F%XSsC_`}*OflP#$2<A1^NGB5dRgXPl_{IEDX;^n>+gf%&8{3LfZxzH=i5{1;#
z;FVI&mc*xEE!aJ-{+mj@`0j9-Jc8k8*C$Y3{CCrQV6X-CBHwgteLYOp<D`Og{!d)h
z0XS0Z#J#bh%lszC#zzB>{@r>&4*i~>Po#VC-$(sA9iq{L)TC+_$<60J`t&L3r)9zS
zu@5yp5)j^EnG#Cs%UEMFhT9w^hc$rmC9dFf{U8Pd&%^!P5dG6Q8PQynYSxZ@Lx#J+
zF+s^>d{1bmj5KeEzx7EP@!oYOPW0S_s=gEPmu22CrPhPX=vwmidmsYQk9lKGvq)Mb
zmy-D{)g9P-jO87T;v6W2rQxXtky#Iu_MjhetZz?1HZk?*fiL1WyX&|eCA210F6X9*
zR5`!#RKO1M>4ls06BVZ@U>N5vA||^CQv!}*{DB~2wD;srn%Sz%L<1^)iZ4-VcmrC~
zrN$9NG;_;kO-o_`1yAfrx2{6Cu;>^2+VQVX*0@dlU2(Wkr&>P`Z2khaXsb~-+-JX@
zf6=5e{BaF2n$OR`+Nm!d*Yy5DAeUc)!0|Y|f{fmotc2A?uV%{WagXU-i6d#Tvs{Z>
z;x0=LF<Q?@fh_)lh|49UXp>CC%g>WNT#rCHf_%$O&rh^Hw2kePcjwtCeagO2AUP3H
zrh+;E>m#R2UEn0RQq*iSe~8HP;s=W9UdKN84*xt^TI97qrq-<Pa!srT?i+CJVw!E-
z^_j5?1kYAjX{EH8fac8X0;83q#*01m#nv$GZ6-!uyU1>sg;uz~x(!0fG3lGEB6Z%a
z5)D-x<=%7oO^xV=W2pNXTiB0x&lhi9PTUb&X$nl$q*C|zz%3BH|FI?BQ*>7flK9C-
zX@4zL9V&f}SQ`ibzFqp11~)I~IJA*LSLx;k;ZPISvQiMAHbQ`D0<jxxkCu01I-Wa#
zP4nV?b*sm-!v=J;IXRObMJ?~XyAoS)OGG};HWqteRPZLr#OJ6^sUI_+Wa{fK)H*hF
z$U~Z5B(aDaY<(W&ljWqg8X8y)tF;V;!2b$ZwkXBoGN6g<JUmfokj7}*d-vw56wWAX
z*gg=QP-65{@ayXS$fzAtQ?Cs+?$T@Kh4*2#Rz93DZN3Gz?X>=|$m`vqkz;-kbw2tH
zEsZ9J_RIHbuIf#wUux>T$2GSCFfkzC35V)3ytLArB)HptpIZ+STRYV8%EVlk=flmX
z;C(2TPj*z?!$WVX&Anl+%1wWE`JnsRogz`Fz962L^B52}KEm7mDccmR$yt3e8<6LI
z@%+X~NzZa8{EZoQH5TvM^>HoL4$JJ3zvr42^-krorea?{<t1&rykqa>{NhkxM$On(
zfKWt%yu5zf{rq8G;Sk4CN(`I3501a85c~JIQL_%lGDT@Ki=UJ8Od{`xsS`?&S?e-&
zd$M{kF?O5$yB0f?_A!96jAtYBbFE=Rl?aiANMw-klrDtgceR&!R^m+C64!xGCJ|dx
zia*2Ho{bjb`@m@FFAVF@ifmMM7tA>`ml=5o4LoD%!*9Dd!HY)lSfoROhRTpEl5L4|
zfiBLx@H<)Q{)QS<YHUb~^I3sy<ri@-3ZtRVFn^ueuMFk(O1Y?vgamG-qM}6p1z*RL
zqIy<(-%|AdVqtJ>xpkQvrQE^eJZ}&o&xLr~w$`Fgd4|!Ls;ny}_g_2s$X(O9hFMcC
z>!86OP#JN?SeJ`Jgqa7ahn8xH-)05Xl62dpb`MQR|E*b}*@i(9iHjl!x)9Q#fl@+;
zi;~c02$bDe=p6rA(Uwm_4TQ;QVZuUw@efJbNU#7=6jS?c$5;6YmRXT^uHx@LcNO4f
zapDrf$G;$nuMqt3-c(yzqtA9!DDK@t=BQp_P2D5+wkN!v9feFk{=kl&8%yCPsJro2
zrzmD4K1#)t758Hg-@BS{wy<&?_Bd~szEgzKY+(<etSZ(glc|E6KMstyGD7bf3z#eI
zjB(sFRdQU3KHV9t7mg|IVx8`}XTfy+O#Hu<{`+NHt%<6$P&DX$F@k{4vc8!s65jk#
zIWDbJm9(yzn8d1>w?V{Meke3=KzyDBk(3aWzxRZpfQ+}S;3IbDjbP})r>j$f%x+0R
zgnqC``3?kQ=a-XJ!(c?Y5cQ7)6EFSPmy3OwSRKjoP|#ET3SZbS^yx7CMuY%Plw01D
z4{)vv?BQkenHW5w!mz<cBmPx9@P+)D6+2tpRV<(*PnI2(@SC%w!>|Nxytt#bF(=`b
zwx!fVFDV}O;``0p{E8+>0bY}BC8GacS|4u{pUi9UHtf2lC88!+^xAm3Z$edS{DNDO
zMIS<ZE4VD!@fqE4N#tIFfNQGQ(bZJHMaIE`aq=NbJju#Io*^p~mY|>-?2%e|V$ad#
zTQ~H)Tzx2gTIip%hRg*&vl`^QJ~3J9WS&6sb8Y_tVMzL@?ii^8!kMa+<Lctt8$+@^
z_|R<l%*(Tm%DUsN-R*qb{@rzi_b=Qqyt&7Gb@X9?G4?#ak`Becs}%w?`|tlgJjgbo
zfYrl0m__mFvLQ?_c$@xx5-r!M^&r+e9BtYiYgc=*IZJ{h6`XglCU>Q7o6~Oo0;J{O
zqsHJ&VyAy^y}94)og&!jtyNay^uY#cQ@-&p>E&-M!>%q;*z*Lhk=WlFQD3WeqC6v2
zG*BDdA;iwY3g<<<e%n*>oY%_A!KWDhYDEVE{rjOgEdr&~2k%TiNG5s6ZEI1m08$^x
zzIB%Y*$G>5X<o!=x52g6h%fHW+tr$%()h!Z9xWC8sGI)hA>2Dl)k@-#oy~e5p)>Y+
zE&wD^X8!Px6y8RyF)8fd*X8D3ETG2E*UU5A<)x+I-!J{jEYRJfZJf7^btrlHTKXJ{
zsi}RiY9e5RM*H~4bjEZ``BuA}1^^Ry;AgRw)+|$?SJT%xOb56a7u=HyI;mT*T$KcU
z84JT_#@^<ygFMD02|shV`yUc*x{x726y;1~cts%VN0Nv_?MHdSG<_mCm3U9+b1S`3
z)EMTl%1?yEd-h|}<G;HQVMo~=DM`tJH#2s)*w~7dD2WaYIxy$#c|3m}p`_dLr<{Fz
zHfI><{+V+Ot|eoEn#I}5SGQ*@sw^U#W<7aV{B;GCo)C~44SBssgJy6pqyX$?>wW+2
z_J9y;_XcPy^5#-53Oe;E?G3*j7H<|hR2n~5d<lglVnb!~xHW;Cz%xN4UGT!3#WOG0
zD9Qb6ncic4H|H*&xeq3m9!JzM&SDYf`&zC~=l*<Kz#Cc)<Bx+s(_Uk!mLuS+Yyh7u
z>=uk{igc}9C;;bJjizgTFL`5fZ0;FHi8vfotkC$n{gm!Byt(u(882OmZS{<`2{b18
z<u{)uSdl_9EB;~L4iXl2KI&XlFV0VC6tc%xXYToYJ6bJck8`HMJLRc)|I58M*k8Tt
zXY=;H2EPvgU_ilXCb_7VgZI)GZ;_9A$V+(%35k@3+t8s#CtK;M<bpBdvESnOiV0AY
zfrqo)cqyrU@A~TxgTH0kPM1FYFh3B?7_T+aP#wI-doz~uIM+($6!Dgd644XVYL<w+
z!Tf1<(xw(I=7|IRv%{Sgeh*XL4+wjru3R~T$pkkAKV|D@Om~Sr`{YhlcK0}L-n@yw
zyr}9`b3;qEkGE6Yoti-IEBa{z0Ils2iF<}!{=)8gNsw4NeIcf#JgL>s8f@j#i;2Wl
z9B<~<By?Zg_09@7JG_grP2g_X6~~$=ba1=BE_I-mt%~s7>y)oh-b1YnkS(p%&^?W^
z8^kd@9(+OG@Z)_^y);{pkEJDr4hifuaLwY*U{t03eme=}`v)aTpOzlfrv`hr7GGo9
z2T+>FQxB86fvdS3u%fR`K6~x|TlP<8-7xn+<W?3pnz`y$2mlAaQ~n!l-6pOM&SWM2
zESJ1F$A7%JlCE~xsL%RbfGpJWI(CM_qif$8_l5>;OL7kL-n0%2Je-Hryfc7@{uwoU
z5LZz^I}keEuos!OA1c)MeQ|ClBZNWwq_9h;bj6hVc5mq8uEC}NTiYIH%5hHGpGhN}
zLH)o@Qdx#1goZ&b%J2Bw1q(eePPXaos_OAq@1%=Id{2ztcrW>_eM7PM`6n)uT77EO
zBT#!AvCon$!HHL=2<qJ5Jt4pUYp|BXJ&5eLl8FV6ObIWhcFW@su#&|qZPvxRQ>6J~
zxtk{%o<Losm}<6S9?0e5Z@=-5=S;BYNn7;;I}(|MKQD_a-;Qwp6vK8i+`g&u)=3RD
zXb|zB()(QGa)^CbD0%-zio%Nah&5k&1Qzh9FuC_lf;0LzL-YeiLcU)RR&Mo|a$060
z)`*YS;{(O4mqX2$9Z?V5f5TxZ2eL4=MC5b!o!y@8nm*?De$?u{Us_66xI7HQIxS;D
z=j-XBV;@oa-|rmy&IL{2b1^k#sCo}jaAw=Mf++CPpK;y~{<5AvPQUF@czIKdXm#(#
zK1yAG7T6r}lcBT`SW1(=I~eF@XdyvL?l5C&M>qT6@M`X=HQ5~@h@{k`6%^Tc>Ae!X
zO)Dc{nenmoZ<20J+;{`sb&+G<_^8DE6whcIIOnj{i?{y<b=fVvks4}hgnxakzTXcr
zw;^AUAp6uUBeC=cm(uj&%I|J4iuIsRSdI&tqs2z!lZD5Zyw`e${0P;!g|Ar7rMmdF
z;i*D`CH!3}DnY%ds*SKQV0lTEfw?VDzPgUm{8l_B*H1x_XHp8A8uln9VJ6^+0@}Mc
z2GnyEPj`|R=Y?BEz<#Yqv^G#5`3T$h>41C7!#eY9t>uqlvbQu3P{HlU>a$VCJUYxm
z<B_4zE%>ric+$<HO6uiY*s$|*PFX0QrY?rHwr-!_;y}qOO8`$8E@nijvI{i+Gx6b_
z%U0UwoJrbQ^r3zEC8&tsaO`M!Lswhv<2tDcaha8S8=?Zq7ydbm?zrXA;vr=h9pzlh
zC*Qj<Qx}B|qUqm(4i`{gehkdhM@Bv?Yd`NvC;`^cM)tl;j{Cybsth_{1vUu)n)LaH
zKLBYgdap_q=JLQhwgv+?anFtwjtjxim7@)?{Ts{#_c<pWeG1(<5kKTQyd-|JJPj?A
z#yTiK3(<`g*P6c_43wD^(8+@0*aWkF(ZYbhz#pv7N8A%d9HFl{9@+1hPHN;{NM~cQ
z&yV5&)^N7kGck7aTa5<LJr}CyOZEHY4HPT5vgnqYCa}?R)&UK?TIK70ePtt{T>hJg
zFx=RQVWkpuWrr2e%>WS<%H>p=0%`|;7IKEsa8h}0&PF`|*!oKA>iL?V4S^fSh3n1l
zTu#}$pDXXFB183NH{t~xnSQgm<(q{_?ZRL2k0PHUM6Fdb<%x)0Du6sOM;ln_O*%@}
z^83wv$m=~oJ*`xWsjuLWu+`06YlR{?C-!&})BM@1HEqm0G~s#1aE#EiiNiwGU2SR}
zse%gTWok{`ts8(~b%(OZeUi@J8gQdtvm82q^nNib#<I6kyzqS<)WxsNKbdxIE0Rn8
zTBTEAa|S$r9=@1K4?Is2RGK;i%1+fxMLAr6D*6aUTV_>;*`0Cdx;k+5(5ZE*@;Dry
zJ-_FEc}p6jfv%<8a(o-uXEz6U)WBP#CWr4w<E@=F9Jp?LZ6&z-!gU=`o$GVe3oR#+
zo}-BUV;oY=Pwt~YzuEQu4dvwL{ndRjKpoTapp*G+<3zF391e8luE3w<S~69=V0Ke!
zOmhDBk#g~sDPeB))l(X1E;_Mmz;te|c3M&r#nex<TQl2IuS%wm(9fG0xgI}HHfnJI
zC_Z3<O>36{$?-Ft2dwZIugsz8&EFX%6fwYr%NH9q6hXu?9?x%1J(<BiT}rV(9iN`r
zHK=nAIG#Vhxs^QM<~e`epdl%V8KMfDux1wOa1;5gwv6j*(-$*Ib_bhXzy0x1Z!Nlz
z|6pNV3p+8xX2+$1zG1kKHMXFDi<Y`urj7qjA)7(*RJB~|t-|MtKod=f3pDb|^Dz#8
ze_xe6Cci&+#}%Fkcsb1omdW0UM0;dBad5P=tX1v7xWLp-b2n=wZ#vtscnIJ?4eEy~
zzazNp9m1+{4rm@t)T?S#k9ag_q=3n(1L{q|TVTICzOoZFcJ_KD;z0(|>&TW(pog)m
zUOq0#yf4{gI{;vOU1wh<7KAmNxNm_eqA%&m6W6n*7Y!8h8u<Win0YI4tYBj#ZRQ<K
z0OiDKIG2O<cpmrmL2=FbB#(L92M4q64&*nBS(l|De>Gcx_ED1=`N*^FsvUpQUdi1+
zF7_^?;sWXCIK4b8{k|iaJ$HKB$>QKR7AJQ&<Ec`2XA~2o!EvG(Ml0&+i_+OzFW8z|
z4rxQ|ndQWR_X~ZQ_JJys>&m|RVpHYnVQVEwB_@rY{3YOgWT#t_4ovKi_gAG(snm9W
zbU&v)Yg~!_gxhQHeFOAVWI2u{hJ`2j)Vz16mB#b1K6~qz(2QlXaFs#oQe&f!b8akv
zNppl8v^;w@fs2+?=_kl5u?YMkWmRgJjgtI>HR4x)v523ql_eOH*v3CxczWNb+n|Oy
z<mgQkO_8~ugfoCC1yL-(EyG=(JkZS^=)ivhv<FU}f4qU-|4yL$LR*-?F0sc{1E*yZ
zQ1nm>dW_&NrSi^zSx3lubqr;;3#xp9L~XSDP>ZwRp1@Ro`yU3^>wD`a>{%BCQ{#cg
zz2dBAtLcmitBR7;4uE6z?*7s5B%$fE$*1R7H|KhF&Z}P^6ntf{j%5SJ<#<dlH8m#!
z!V+^XJh4G5*qHU^GN`WwfBV4blveigm*Qs$%U5lA0tUF$DrNGSMzh|DfBba;Za9rq
zk);8MLyvYzyvUEN!RR*x8yhlX1*@#+36GZk25buM&uX3DQ@n-_`jUh)d{@6mcjfG4
z8_103>Hk~^7Xb(mY&{q4z@o=Gw`xxa<SGG^Qv3F5SBc906hnZe0Fd&`%)0YFV(>c)
zDJrUQIu$qx-0aXi{+|2g;frs_o;`)YfjrGBUk92MGVQ$n&|{)zw)6a{GL^e=&TY}q
z<xkhL6cfd6Z=P=c1R~T6>nUJ!F5NatvmhOfUhxaT5!yM)qJt!42QqXX)i&%=lp206
zu<3C+J>CZpIpz67?uObe@q!d@vbyue1_q0o`pL*uZN7+dszb|$x98O459gm*moTWy
z`O*kF_?_Ke>n45tG;YZ$N%2l};{HDH6OqQI*x52V#BJV>a~^rtEFZ&$PekN=ve*e+
z<w693ClHb<hE)f#imJJ>PxyQm4Wl^imCl{5%yNP42xKKD|L%a9r#e^Er;N~7Q*ec4
z)|qj$r;$DPudBNeJM*f>CihMv&E3j#g5er_ifVhBOLzIE<B>evyHWfHrOO{S5b4F{
z5B(BPU{xM_bICC4F?e58f(Z6rMD=#Z;bW(jmsa1RN3zDR1Jg1*{?%89vqCc~_3$vO
z_V5&okyL7;Gj7YS;=A{?DD4kBl%pzvGsEg_eJZM}SitljiT*MtMCus>ifgHVdnA0R
z%wMp~swc5wD{(UbxVKjTEJ^xHz|jV4PGVN=mid>Mm=l1OA!*&p0#nTy5AJJyQ8#J1
zKeZ3$gv?(Ye<KFEv<Yg!I%_cB7EC%-sf@uSpO%1#>VCNC_^-#Di$kM4ooN^1ISu1d
zkCT?5pF(?Lwi$piA_V5lu@tWz?#B%F!tNVxDxqLuck0|z87|`1pzz~ib}i7jF5WNH
zER)uKCE|FC*e&7L64&Fxlh=ng$i|HmIFcXQPENh>`PBumoFDT>fK}if(!-^w%<dfg
zNT=n2`DQ09g>&Xr{p$CbtVT24N9ID7GZnLI;-^>(Rf02R=9{1W9l=Ov*J~ib*#(#-
zotpaP#zf4D4(_rJ(QP7*$JqQ2Ol{ZI*;SCTgXzxGfSbZK({kq!c(?;M=?B{J!p_Hl
zjiMF)#H0<IVdVVJ=ExtK-?YV&*X3sJ&Qv=k*BH|3@z$J{Y&v;|oJG2R`zgoYNopYM
z4W-&mocTsucG7BoI*e4hi;sVSt4V~u0K(uNAe--wVOHWi9kV^>+LFa=VWK6<B8Eo8
z>^)hAo=vLhMc!&fJ>YO30dkOKMdMcb<R!KGU>2r_pC^y78$utZt>qp%$sSW53d`1(
z$KRJ5^o~yuJtkY``m?wY4qUAnV^_}wT{a}^g{xYd`97MoKYMp;uOLQ;Q3)YQiuxiZ
z2B0F+Mo|oRWOVN!aPHheLO<y!2*$D$k*<yupZ3kX7Hk;Qj}0YzINz641ndH(x(_y=
zq?Y6pHcHl2m$iqch-QU@iEyMqiyoqCb2&`8MKIZt?{Iz6Ndy!_0-J^t=<mfG)jtO`
zsZqc+-oX~FfZ}G<7l6w&sa_KjZ_<?PAy`zoLpcym{QKARv-hnh{vom~-M!B~hVs@d
zaaVci9b^Mn87ZWllXC|P$!(_uC6@>69)Ctj(iy;Vi;mzBklr#dW`B+Of8A;Fzoje}
zOxQUy)p<S?vUtj8IdZS?Roc_VVz%4B3{kf{)UF^30-W1??QX<zBrw5Ps^R(#Mt5UK
zI5f8aCtCcJ0Pqa#CTq2lze)=M;_XZ8mqVNXUrkpT7FE|pQ6v;;1SLd4x)f=NR|%z+
zu3_lz?(XjHW{9DChLSGnZmA)L8hYTHSHJiE;^D{KyYD&o?0weRYb|}0t=m$|G6jkc
zZ1CaB!y5#)OcoDn-?k}4rP**l?E^Fdua>~m@L2EGyHQ$<!x=)!=T&_DC_U7wpicDm
zW4eI3)ZO`)&>`BK7ayq;F<Q5_IVsfwzI@CL*vcG<@KuTU0ZqCx-XzTl7GZH}&5M4(
zt-_l7t)}yV^C~qkai>2kbESMk0v{zLLL)-7zP{dQwVX$E!J0F6E#Dn<$L|VLUBx@m
zk`5$hkk5ZMKHu&~P#NPd`aIJERbjRKOY{{E9vw~Q01`5AJVMqwu+wY0pj>89{!)5>
z@=Aw4P2jUQGe?$p5C6RLd;RG?8YO6MvC@J%);dR(v%ghFtniTWo6H08Ikzzc&ibMW
zlZojCDCGl#w>4LtQ1q52y6{Df6mIFHZCQ$;>lmfi&!nDUzB~an%JvTdYORD4W7>sK
zR%E9Tl+3t*)7=yBtyGs#?jotlnfHUxfr=$EDDoW$Rm`DuW|Hr3ZnG`D9~4`Z1{4aV
zmf9S{-H63L&AdECN#nTcmMo4-eYpl*x;YqEe}2$GU00&!o9nr6-<~rAn`}-{4giKy
zi3R@i7nc|95A(4Cjxe&bEjEpUs+g@4-z)yXSwC!phSvo|YeOn-<tUp1(-zF4Xli&K
zs?~Upy}WmpCC&aBkdSdCWAcUiwj?JKs7sHsje6GTrkn~)^WyGanU261VI&^9!E?oS
z@JQ{2O+N$Qak?F#ax1fHCEvyla5q8`)u>7_et9hPLn?_;*ljArO6dIa*^DmAm;q&s
zCxenQKMS5VpNTDOGw8I?rMf&s>W;WY?iwr?IZCS+qsae2{Ci>5QA&;-?*UNcD|j0T
zty%~QA_x=v3;TuQDsZ9{RWnd!Vlm#K*ucpq!^+|HII2ultvrXFtJnTp(b@gPSMq|L
z@2P3BD1C3#b%M{cEJ;s5YIjD<0A)c{#^gLDvn_`9KjJeY&i5v&uO96Qv^aY2kD&5=
zNHb4pw6F&lRi7CSsydZX627{I=XUqWXHecD-~aeRbB&_VN67Qld2GR)-C?u@lC3S4
zi~;i~d7fAgwI&y)`C_Yd&G|M*3Ux5mVk5*3K@OooEqKVgTKPD7*%p-ieXcMbrQlqh
zWIl>>yxvO6p^^Yo1WLqq1-9KsqqM6JCYtlJn$7lCQG9jdanXmh>dihBrI$uJjEs#L
zFWt7R`O9_9`Z^&h8U}8!wY7F|`wa8DcVa2sYvacsLK9M-XwX-28Z%5h%;9#=qRc$I
znw2AD)SUFYXzZD36>&AKd3xv~>i|Z-YQoba83K7~q|$|J^>|;S-h<>Ihw#40?jk%a
znY~?ivuM2ij#WWaq<ixfV)A`l>x^m4?%NkPWnQn~DXc(f#`BD#K-HmSV6|Cfy&Ot2
zVsEQNwYXttJ3N`)dLAYBJ(9tl{0C`$C)NMkVk&24?X8H%>E2GkVE?J*Y^gMA8?$0^
zDNr$z@U|PpN6+MUKl<%m+!l1&94qL0+EQ<RFJQFfCobL3O!@v8$By=Bxiy<c+>U5M
zG&oYN)=8-TqWd^|NEHM%hI^4(yWB40qg>}dI!?e*$-C5RS)kw=rT1}r#*q(SZilP8
z&Sbcvq$LjLaxGE&G1yFLy>4WdbI{4FM3kiXNB4$u2kUx|sO-DwDN_VU*{(f?g_Sje
zU0vkn7ztBmQ5?Zv^}Ym0nhP1D%%LuiDwo~+7v}3+aW>;a6}&%hg@L8=6SLN1*49w^
zxME?Arkg<k0mx^%4>FtoR$Bc)3HV&|ei?@_V))Y`X6PA8M><}EJ{hVy<}97e{B}!V
z;91S!o)0S1OW{kVPJWK7Mv>~(NjX9<gQ}wN@!k{DSDkc65H^Lq4=ThpuPt5S(JwOC
zUa3}pg9T?E1*HudBc^Gw&ll20zO@z3{-)S%)$0{&S~5||ihLw<3ZH9t7a9VZPy1P+
zL|7zKIRhDU<xA_0hPGw*=#x+)TbfDo_x6JBj}zDcW_>`4t?p#)VPnsiA5qfG)hb!<
zFL)cDaelg^-i%O285!Oh54ly#7;`l@m;YHrWBPN4);fXsQpxPgH@Fm%vly6|N^bRC
z4AhsTx$O{l&*Sz>k#g-;ukSi<*utB3Q?5~JC@5Ha-Wd3t<~EsYF+_JY9+rPf9po|D
z_|Oq8eE<7j3DZH3n}I&m0~nnIq1-WG7Z<I7m4hqqi&2s7q`S)f?6KiyXOvP-Lu;3n
zGwm1s#lwa`(x>$c0ZJindqv*SJgWbor}X71Vd5{HUnH90b0M7}VR~P_J!1?~qBA3`
z4&&)nGm&mBz<xJlxpc8|xV((Q9-ZNy+qYY{NDtvv>W{`oqZvCpuA^sO%R8eep((G-
zRM)Iw_mynwRm3Q~$!%+JNBHuZ+5>*;bz|&p<*<!^H{AX_?w;d5(E7m_?mfHQiY4;U
z>3yb1eU<tii4-}_7rDSk{o`8x;Vt&~`z-rhl=a!k*h7yzbaTvOk@~h*<i>IJICAy2
zvi+nR?mo8q;4VTECHkuy?z)O^u5{*u|Ii4$_P4&)m`?57M(%>W4lKQ|Djtxu)Z_C0
zbhkp@NWkhP#2c~mFfET&e@E?ol6=42y87{fD%0Nk@D}<&CVU0<KL5J%U<toE`)D7;
zaUZ7IMssisygqUc5+!Uq!oSztFF79v-m1AU+8iz*inDICTy9w&HfdK8nclA12dk5$
z!y0whWM0?p?7*BGWA4<m0K}a05t0@+zKBF2b7pU{V<v_++pyv^NfD!*vwh6{B+B}p
zUVu|qXiV@7WnTt4-_4Jnz&o2#l*hQPD4le8gzb&<hv}qq>2lIT29}wn1ay5I6Lx>_
zysS_W{lxq&6N}noZN(i9fP!>fgpucDuf48vKRX!AI?iU_cd<}=?d~>4?XS-EJ&_<g
z%3i&z4~Bccg5FP;srvcW8EgkryY2RV91Gykl=t`@t15gpT)Quu)s=>_<SW?w^{zs#
z3*AqLd~)37*cU77c7v>5XS$kLu;4Sz`pIc%^!=EAERnq6$&*>6W#Ek^%CKX2%DTAM
znBHx&pxUbD3~FCVeB@O5iLZ$Q>nLZxOP<d#Gd#H*2t!j{EL?aRMSNhnneIin%k|4T
zjkG91$^vXkcfo`^`yCwb$gkM{I~a#D%cHC7#LT(g&vveHeBTJz{02z;@25o;UkYN3
z7QVr@lq7Kfj8!R*-&h~rcB;Fe>z4*7@j^!(2?4WTvMQ#j*|R13-}ATJ(79TCX6OwC
ztrBl}EH`oxc1VWSJe_97Ysne`@BOI6unF^M$m&82mx9M{e9z2@Ju7p?l_Foinue_J
zjT2IDXHvFKLhl^r<{AEfHm#*5_vI)nCqR2B6>x-RuTnwOS#D*;_C0;v@a7BeZP%9l
zBDmJej36r`aMSDZ2(X~s1)bK#bjSaT9XqAYjr`VIO1Z9X`NYq8(uqawvK^t3?Xwjy
z>5%Iu`E`8XrHpyd@#9*#VQLfElhNq_R`YqSH7~{W`?TiaA6^m+7v51=mZBbK+p_H+
zD-z8z>~&Y!6X*l}bR2bzPH>GprSm&_vz|VBuI+lj4Srj7ma$-}kpgv}7-noSif^M_
zo-KD*WXYGJw5M}yZd+~YI@}%D-&{N08Ui&zj{`Y=9p$<^+ET6^f4!I}l>XC3R2BaZ
znqmvL=RrL|$BvIpTGS6IN-O1J76Z(I7Q^2mo({J)&d8l#!ffCj;<Mr6uMFi6_qTBT
zJeHRgsP(l7Kyxrwq1o641!UZese-lX{vAsn0NqleBcL%o*1vDGv$Hb+owBI?$Pr9e
zbrvwmrN2oXb=@-ZiAi&Vo$Bnz%jI4toQ&nzXLvTh0GCVlW2kLgme-Bx0<PaB#l=@#
z7*3uS9CEp$|A74Sz<d&2k?P;u{gVXULzDVnjmRoe9Ph8*J6Q@pcS=%)z*wN`(QQZ>
zKS}3bj6uVU0s6?AWXQo5hqvqZbPnj%M!dYRD+=V%!4B?ocW4P<3pxy{2=>IL)%9i%
zK~g~15?NHcK4Sl=!RB<kWTl(*pKjQ+%j)cCT}7>@%Pj{6QB2*!+u;zAt44OfLPIMv
zA6-}Jbt~NS((`f|D_C-Vk0r5wjZ1Ra{$^7lGOL4B938AuMyBnuj*{%ty+TD8xO%5}
zKS}CDtCgdX%<>ILHSdm~z;plJPWE%_-wk+&>sRTdC8+18-EK$%>H6y{6nJCS9Wj~{
zrPmbb-n~!#Fbcnte%PgcAb%g{^&b|%=etaskv1!G-_+2?KmO^k?UbrLTZH0KhTCH}
zjqYj}{2Co!kl=Ov65;v$O6j2u`}dW1qwloV9e#<VJ$o(nZ~3z3k<0zb9~0_vZP%2V
zE3{Erb>hCqW}b4m_^^bs8g4n4zn_<1YN^-kabV{}jW#k1?zNMB6Te!Q-dSK=FS2t>
zhH%08oIL$({mT#eQ<*xqq)wZ^N6=2BxHF1FV${3Yt9A7@lVynzu1BatB+?fh@2HgT
z53=uPM9ya#?=q>~9vFnLnI0RDq_@LZ9xhtF*DgKhlb7wsgw~0KdWTNihT@4yJ3y4t
zaDv2~-FV|S!t(R~Z`<GTd&B0Z;?RYfa(l*ORAl@(93}Hxxvnh<ZV_NtM49(SpZ7td
z*R8YHp+5BkDm|RWXS;2n%G@V%;lZzOCU`x!C|2)^z&B|k$J5b}3vP{XyDrmkfgRDd
zs{$G1$y1$c?#oThGlZbjQv&b<3gEij4uzy{eG6_pi)@Z2+*SB@_M^QIbZd7f#fA_}
zcL+THx)y2eg4_hVA8593rE|y?mr%XUc+B>iWYiBYS}0vXepe^+Y`(pfK0oS)MPpC9
zoyX9LUt|x@dYGWn@w8%*0{}VY{C^`r2B8+AgKAV!kzz!C+uHBvQWaV5UjhRf%#igq
z`+cqP6ySz#oHdQzpc4;6j<%oOTBov*@{lcA?@q(5EMN=zqrYHv$9z6adZ-VE?K`<u
zfb*2if}j<O_;~EgPzmkEUh_Ry9$|T4TXKadkV)<%hExHOAro=?!G^z{4&2u0A|u_l
zn>p^YuwK9U6D(Q>o{dVP13O=F{(I|Hs1Wr|+owlk5XP;?U>@yg1aCh(hw_AKPl-L`
z(zJ3#gR6m`ia2}baMCx7n%>yO63%8jU)$0<V1NIR-Fg87U)lXX)`QorNspgJb)Aig
z0NaJ48Juyjny5Fm3cw~mu9X6+<gX!#KP<k|L&b1Z(X+bWgy?3AW_ntfk@VOgWBSdj
z>JlfISw_>nVG9VwGXMXmJY?~2pjInwlEvBwuqyM{Kr?Y1)-~;Z`xj>!Q`T1;C>L0^
z+bj|rYdWpq0^Ym;^^dg>&}LnLK(_`KOYtLjWyq=RT$oI(?6TM1sP)6@!{r>@`^A5a
zKYXvUJTK-mex;>KT`sHJyVRl!es336hpbPhF0+7C>#QmHfKz5pK92pYM;yHDP%c@u
zwzsJ%j^N>);MiHCyBbSr6>GipyFL*F1=wpkx$(X4|9^Vz33k{1UU9be3Ub#bBf{dS
z!u~V10}!dwYaItkJa??LC&xa#t*=t^1j>f&ysTOJ`F-d88XxJ_d)^r(sq$5WyD-I!
z#`2pqi?&HNp@*&!`G*;J+X-qx{yT(dXni9nDPTN2yzPBy4rl+dDwCN!N}X`QA}M6r
zv9i*=lkP7^8h=GOn|eHR9MUN(l2+&m`{4TV!V|I-?%@{67S%8j2At-w+9;4F1UR2y
zdU(9;jfC}4yI$pTxDssT{1*scv*Z2@Vt;nFI6F6LIf+#^IS{uvV<q?IP%Ov^3u}GH
zip;Ca{3WWuu;;y7g1GO<-G%-Py@}Uu_2+X|>-OD`^IXEIF4CSaGiwF>{-?o;LfGZx
zqQd(!7wERW9sValpki7}!PYw(V93@QyB8|9Am~`hi&0##mJduL;+AFMpm&1*WKusL
zH2L1m>BK7+D!nWeqfFT^rF5T$nKZ0dW7IjpUy9dCn$JI4o{lHQ2ij}J8WX-;!g@dk
zA1yVD{`b<NWMa&+uZNBO4kjA+li((@<*ub34PV^2f4p8$1@rHyY(&zHH4;D4umJ@r
zr?)8Kw3J8HUnCOP`(&Cg&bYstW5unf=>y1MU8oQUU;v2=`*%{VDR^JkgAW1@BIDh(
z<UNlTM34jc9z)qzo9&n5U;iV?cjz{wfOlh&+xa(VN#{Zffp)+0D2jRdZm!KHPn$=q
zneWQUd7B%@gA={kpX$jzl`Cy+U}HmLd!_~gT+i@pRCGPJ%rG`|C*igk#<H@gF85P3
zr&C-jstvzUaiqlTG`TO$MmF<8PH=$_j@GSiThIQR<a0r9YJ?xI$3$)qYF!6a>cLJ=
zR>`_Svc*r{YtFNvwhr6$_%o%)^^Ctuyyyyf<wSP*JH*lA8G%;mMVm#4&PPtV`%qcT
zW01pVvqDw}H9oWTgeMk=$~s(|WGAtAO)`8oR9ouzmwmz~`|=()ht}@<n$YbsRQW3Q
z-)rX~6q`ZK)=FS|Wv?~h!d3t7Z1^W#Mq5l2x&6c=xsm8F<UT8scYB=~izsAClAop2
zuu!E6^u73*#wWC3>q*HoTC#f#thsuoFD><+>o0FvSLY?W3rHxa(jVez5&nv2bh20|
z(XgMG7o}t$Lbbh4W=8OlJNOS99Nt$aecETes2qEo>@|?sF?0lRc<S~aUyJ6mfT>XN
zVxzUlzh#WbgWwja@Z=X~eHdJBu4}?bwU-ZPY5I4YaOmpNqq(ieY99zy?|@{GRk_1e
ztufFUdzsQadD#;y50Vbq#gdA}BEWh{RBMnJMeE!Prl4=qx4=+89?A5Jc}>UNH`Vz(
z7o(3Wxj(6enQYDN9}f^`-;b<bjXZQWcgLBTOi$1!Z$4A_*_g!w?(4s``|S~hZH$yj
z=Z=LI)_4_VG-j+ZQwv02>lQPH;^T{0Qec%SQ(#YanWs=<PKYr-KSd<s16x)cRQcdU
zzL~y<U-jSWrHJxnmbtiX4&ZjXK)d~^h4%M2<Z8(ZFa8WnhmU2g*=!#c%whAV#^j9R
z>D_+qc=`TNu+)i=Zfu)t;O66|T~w-m>?Dc4bGNt@TQV6XF^*pOCCAcra;bXHdb4Z9
zGX^^PL^s8S00JblSfzLSdEhsSL!oOMC9d83-h@5Q^Ie3d@%d?7n02)!KrDAqQ$5~F
zS%vBCjF|#&0Y&I1CikU+W#S!mXqZ<5aT&tG^@5(qk%7&w&6yo3HejRe-j~Kk)ki+F
zJXwrY{$+6%r#hjZJ(^3+S=^ar$gYZ|3P5ck&w8$O7K14LyOdl+l`gi?k-KQ$Or#u9
z0n8i%1uI;VJ@QkLtAr|N)U%$h_0Js=F%DXluK7dP{k1Syf|-d^m0z{Vz`OD5v(jdq
zVRyY9b__E{1f7+(A7mE7A6segT(eb`d^sxlpwF68pc|T^MoAj)SYq@XHqDSaD5(ew
zA@ijWHyhHW<qXj@sXJ640X1_Z)B&YV7RT9&e%~l4rwB-rFN$UslP-XQn7pw*ftcGo
z@15K#xb0H9$l}4XA?EClwVk9B1Q}?5fa!1TB(LmLwtFx!TR#hYzKF>0U-WRbBkV&*
zwEBCa+UQYN$M|~pO-Fv36EffTrec+Ss$06D^`6b?`oi%G+AXD<g{MyslFrz)0e0fl
z{KnzbPf?mic2qW~G)N@)QdTo#HA?I#4M0g|;%WBepl79yWaGdF)-E9>8BC}7>ZicO
zkIV*^XL1fhmcP27=QeuWKC%P!s;P`6hxA@$FKyY9Os8P<JUwKiZzo$^cVw>=!u&?9
zgTGc@{Y>CZUQznWiyR^rpDAnM-S~D@H=eWeF6wki{i;SBKz17wm;c-;_+U)&9{poN
zYvQ{jrZvDl&fgjWZ-fxz{fHDWjkH@ay=3Rr@~bpbi1bS&d%m@N6yYPS!m^_8yAj)q
z5}8s(_5hWig*>(UdS;b$kM>VOTjID+W_yG?C`B_3QCjfz2Feya)gBx+YG0D{_sWmK
zxK@@g>*Q!l#YHRgjQB!K6Kx%9Ua3p-h>sK@EKY{2uN7Fb*iCzFf|xWLGFE!T_2M@?
z-q%=EC<Y9DIMWZdvk5>hP!_r89cumto2^N-S;y{d-`bJ3no3H^=@F@4xB4%?QNPTX
zw&qSNK1Upn-~VO6`A`|dc&w!u*{2E>Tass{;3dqj0WtLN_HS$)#+-xq2zHg^_=i?0
zu`>g}5&{e_EC%PW5R0zkeboeYhWS!=wJT%pKcFAB`N^B)y7F$*bBI2TKy-{~D`i?4
zdmxv9D;+v3t7$*J(AfeUMI<Y?wD?^^^_{YdWD?uXn7eV9d!^OHjv&a(^!tJtqtA3{
z#gw(JPyG2?HpfET_z_$l*LU#Az|woLC#2k+-_-du#CL^l0`7f!SjxC`zXh1$s6dYY
zO(pJ_)||e)putyr(!_dv9DH=Ps2=9YqSi_MHfNy&(2cY!C~@&Sn!HPr($h&!k^xPU
znkT|TB*};mu|_KrtBut+L(mg(ZQ?DIP-ea11#~bv@##By8;jQm_<n&b11(To8orrP
zGsc%=xbCwqiH%Mj3gjGx9~KLGofI{n2^BM|gOU~J*^c;I5<5SotYoJM+asf!`%gLD
z<x9e##!T21p7FBy;Wvf!uF#^)gSFqRJHKfc9jX-PYD0<gt-Nhrp3}ghiT->(b6=Af
zhp$~F#19%^&NjqSwO;VMpQWBFvF;05Xs=z;=D88j9WOU>mj<2^;6!i({Xi8R&>3rx
zD#~qfjC0N?Bu{lxvuDym53>CdXT)|)A7hXGIiJaDP9Oz`Y)JQ)1f0*|elm19%^}NN
zCCYq;gr;X@(Zdk^P4};Tv-l)~VMJ^d@d_cSm>Bu8Q-k3u9eOw(+g=u|^I1hTT|I<G
zgJugx=*ALM%j_J}@u5<;7Z^5PO+RG+YHXs-0gH~#dE~OmQ>nN4i>Kf>Af8G~hgeq^
z-!752Dqiy*MF0o~b3;hG2A?~OZb(C-qF7)dne~~Hg)~P`BonUvco}D&-Z%q*;LJ9i
zeNf9X4n{F6z+l+IC!wJ@UCBr#)d2lAgU0mY8g}_G@**St343ckNO|84fgcW(PpypV
z-Hko>uLXDxz4OPK&*A^Z!zKzj2afue*I>h(jn~Wyj1NgMWb|L;y!H7rcP_F;8GBv#
zq-)(A*T2^3^f_I;cGO<4+)h^4OyPxW-lb`2GG9kVE^kPyQg5sDZCTRlrC8=?nZ$Gs
zet@RxJ?C<Uj(^)u`6APKWjOoOL61z>K|?@5+MYdZ!hGi~sKzy25O{Q!-lj9b)KXc;
zQu<YagJ2<=dVTz*DZm)MR+ulY%+5&1(xlKLwxv;E2eI8^N#X|~{A=m6bv=^}Ea_}-
z!(O6{ZvVZG>%I!m`IxG#j(P|*9a1iz$2rO!-c8+SW3=Vszb9i!3`43>BylylGgP?t
zuzRdIyk>)uY$p3}L<(6^5JChZV6)Putk&dn8*a4+20WjK$VsSX_ZKC!)~h^N^LwgK
zmDO_3*s3uUYGHM)sh|JD0!#tXxD|*Pl;3M_yX0}4HP?Z<mVx3%kNn7J1*6)wS4Pvw
zKhx=^7=u%nUGV}ippux<^}0FKs@cL#g}V+O6}K@RKBgIQEBFC<`0AO?pHQm6!%J}4
z(B4-c1QAIMO6?Rc5MP#C0~Dc~nS>qNo*??fr(0QV&i+{veszu$!!zRC3u^D{4Ay()
zHOnk1xoucryeW;<IUoCS`*p}}??YbGYt;H|c_*r+<`r)i6vbuyfJlU^g-L{B9B|XA
z<>!d^nnlygO{ieDaAzt<0xNljn+vTu_GVQ;dd&x5<JH9z*q*PWiQcC?(|&}7p{%F+
zP~E+gL0co^)NyKT#l2k=>yZdj!DhTo=?Mq^G>5^TZto6g&3ClP@}okwLXHvGilw!1
zv^Zuqx#Hs#(+Y7mvV4UvNry*5*y_f?;BgYIuk2<zX0<j^HI1g}CXc`x8a=$#?$$A-
z6(K9{6R0^5ps6Pp+iPihF?X7`Kd6RbD>YkK`|qlq#23x>SblU_tgvhTV}BmeEQJ|0
z57EUPjh{B<5obn}K~N`pZrSG%2_bSLfdhqMV=W$vgWteZ>Z7qETc@<_5>_hGlXgk_
z#M~L2S5GpyJ)N_{#-$-UU-j{m2lE;J=C|Aazxgdsob)K+1|ZB}c_u!ZWcw(iE`2_|
zXyhCD*^}hPAMK60hcm?DMJB5+Mal^$Y19;PXsi^h7nKP*#vkF4&oxGBVu&w=oEKJx
z#!he+%uRm7Q;4szn*R6#cewOfeK;UU?c9kHgc+r$yjdX2P?prNwb>=-_?4tpV_qsl
zH#Kwwzw$seyFP5kfyA!DI1yUo4t35oNKTpT%$LgB?$*mrB2ZHlGjw{*|3UG%>$>Ar
zti1b=cJ)V!18;WAfWlLve`^pM?Kvsl(OvDdM5x0O%-M_OV@9*ZN&@<D5k78gYh-xK
zZ0HSQe9mzcL!LJ=IO!Ec-Y}VML9r{#e}54Z-WaJn_TvWg!|><l)crdkUjSFa$nWV~
zFY9b+-l0!~b5Ry4nYw4zZ2f!)C529wtjZVtH3Y_hdfM!TC+RVx%-S=l2df&RaYs?=
zV<&GuL?(1=D7L@*NEWDQ>=&iho(@=2U&fiQ!+9>6!-8nFdaPLJwZB92{~|G=G#z4z
zaXj@k|1_~tsXaek%`RP_Wvp0&FvfH+1<eSyCnpzI5&K0sZY<pdAhT&Hj%-Ndrg&#j
zK0`^hpftoEW|Y)#eCFkkiFd()^{OqbETS-TQHLa)n!MH@GWkS%(6vR(z_6@*tg8Ol
zk+Y)KQ&z72iD}tg1d9z*iaP7sDXw%jy>YEFFx>-U`+_53P=Aktu<ys-C%}tY?rH}i
zC{Z=JtffH7{rWpcm^WhYC03qEajE><;$+Gj?Y(7-dxcEwjBEkIzd&{e^dl{2anUeG
z&5xsrBv>+UYDb;4a|Lu2)M!*+ln<K%HXD*zPcdtW?@_R=7U5!6nlHZb$ixRLwYGOs
z;1SOkWB*p01BDuaf#S`S+*JcQrdA}RNovMP*(y`ucs0Y~>55bKG}dWbwjIiXGU8We
zJ!N9@JVa#6Y2N8UG!F6ApIGNuHEpJ=6=+i&)ib{zeydKgx2vJz3J)z>V4^>wzJzUX
zj%b&@t%0nsx2-L4UZKazHDZj{YQ4!I>YU}`{4WlBK4KTojj4Vjx;ERO)Iuj;R#HU|
zo8_wFm!11~Hr4;|GptHbm8e6j_hL$bW{YZ4>ReUD{>n<VfGaX?yE^Yol!%8rRdtXM
z*53Yt+I6am1znDz+uV$A$!6vH+D>I%Dj_cud1~A<!{QIaH?*l8+U<D_JQKUSO_H{r
z6}`%mIC6$yz1w$ElA|+J1Af_C*jMG6o(;c4q-5-mo(!ik9Y}AP?99qbX!z49D~=J#
zj8`dPh!As)H3wr^GuO_NSjRO_ee^NBxJkwSe@tGrT4?f~ZeqBC0z18-b&~keN9)50
z-7%E?=j}wT(5#-h7<8FEtG4kk@)K)~kzL%3V=DTw{twbqf!^b^PMP*Zq)P>spc~6~
zYwA+k)uq5h=xI_ZaccR~4x<Oo`ZP?7xO$VdrJ(+c?-*6$jJ)%|rVF)F8Khh#ujpj=
z5yH+NYPeOH>*LzC63mmT!D9)$@oM4nw^QscKhF~RCkfeD3~(BFUMR7Dc<dgKb>gvd
z_CWa{vqiop^&jExKx7DhSrov?mIST)XV*%rdy2I9!jh#y?H2=>H_>}gIZSa+Zx!c0
z)6~DfFt#GFGNnUhmtRU(@&<RpSy{|fEocATca80d0L`+|;SFSO)YqwRE7mekdElxv
z<@(1TcdCrbe3bXb>lBOZ#iP?5>XyqWF5@s*%IqzHd2^i>^<@gCERyd=d-AvwT7HPI
zGbu8MO@k!jU$n>FOTt)({$Yc~ZZh3&hnMwb$aI!_$Q=HI2B&j-ac$Qy(6y>~_c3|j
zH(sUafauS;6<SlwFh#NSljFN@NT=Kzs_C(_VefF!wV^6IFMAL8n<s9fgyr{9g@V&1
zS2F1Cs}jyhyB(8eFN6;TrmZ{g9V6{aU)N!fd`+Z~)j3+Yn&h$#GY^$T@-PW<CF(^z
zOPCbyje;78XUwbm=INF2=xz3<sehnc$N)|z)tF4>n;P-=Ye#6XzbMm-*P})+m0gV+
z1GX^5)lC(}QN<kq?XG=XEXzoqcznN}Q7v^Q>87z2?KwABt4Xxvn7?6G3{4N*p8wS3
zcF;KiU*PnbtXB|cPhg<=-u@@$lld@xZW`ATs>6Jp3H^?gI~>0IxoJpns|BOGRpJKq
zPw3%+i)Ip#GYaTZbsCfB#&`{24+wk2&xGYSz5vjK#fxMi%?|qrC%o{X_t-jm<_Pms
z4ku-rjW{yR20fK3sh=h9`85Wh1u#3g^~l>2p7fjcPDho^Y0YC!O{5VLL?hcB#j}lB
zJUCXG7&qTOpH+`eyvmo|O5$EtzLiNyP0#Gupu}Zv;Nav_IOiB&u_kcN&GGo+Y3)sX
zMcHhzGE4D!f05v$5Bt0iTYQ1-Z~jEJ_B^$Db+LrMak|4lmDjCJv%-Gho*G>^n7{bt
z?gV@PP9t-8>B}xJ?r$oGhb7ZpQme8Vb45SqHOA-zv(o8{9t2)=%-ck1myr?AN&2$H
zMSaD>1#Iv|Y?qZld6@Slf-=rO>tmEm`*8a=5~i|Hr7p}k@~iU}KZ-{v#zFKJ|Jm$k
z)d4@6QEstXnw}~1nYO2m9iuU5-UWijGWZ5?cc3zPJ^)ss5vIY6eWeYO-x?l5gq>QN
zo-IQSpZ(yC3{!i*?J(3kcg_oXid_deXl9$&#LT^Y{sh;dZO4kjE1r*eIAD(t;b`q!
zBG>77A^hORog250-yi{(Y4nGxU8m_^a%xKl2a>~RnwmQDerL=;VPXItIcD)&t>?_!
z=V929BR=9Mu;YJjkWS2|{%BG2oo&xVUlDFeZ9FZO8rJ==^E1`bfT5s6B_R__+-9&W
zfR-2JsNP7HPQtsQ1sES>_bhH|JWbmKOT$-a+EdFWR6({|!!F?|QKOB?-5Z{qKJlle
z`k?sp7nAA3NVeabS`r=C#>d4>82n0Od`)g{$_oyKyO{JZJO9K*<}Yf#Mz`tD)W^+P
zf6o+UC(Xh<gIP)z!@N@9FP^%^HO<w`3VDMy_c+&(L)<M4a|YYU$-u~R7#WH89_ww2
zUVME<Vlu&QlNPI=xX~SI)u<*);@AC5g@tH+CTgV#R<0(0nru~Gpgi6YIo%YewBB@D
z1qf}B<3=%THzcAhM7LY3pL_~`ZCW88@6upuy;+uDmjd=^dZ}v(66ul9+*#*~&!2lC
zmCz`kJIxb^Vf!I|U}=T&R?7nz?j6)SFJDtVHh@Gp*=}{<rb_WQiHNx5b*_HU`isHe
z4py75UB8MFKbNz-Y&xI-A{nG%BMsn}RYbv*2$O@*GLCtYN|-(yO2rBzLr^B0+lKYo
z$iQpI1)5S@(_4O;Pl*nsx%*=0m~^kijAzAec?&7N_Nlb3ZYv}dETw4<L+l2Gsk=&k
zWClv~p~0G_6V@#Z17$vPnWk0tHqtxjOL3-twInPV5870@WH|JyagEn|vCr%ILFj2z
zUgf31$yCN`>G#*4-<Bu*&|=U2eKT`mec{uY)j>y)cD9$S(s7eeIM;4R)fddWH=9^*
zlU6Lig_iuMo4DikCS43_r-n%AbP-CIqt0}75F<+^e-&ZfbLV%KZS*R`&RzKcbcLYz
z$rR|=X5xoq>HbQ`c%O<{v~;KfdJ~R@t6yQVsurT&0_zo)ymncHwo0K%KhPq)Aaaek
zVvi^ttzSyL;nH+v6(_$)b7b-K>kgUgEJv|To;mQpR|4%9z1St3HdES~>fJTL@#Qhi
z`?UPq9%#U9h)Az&Swq^TH|!3jo+#4Lskb?1f}uBCHF#CjS0|w-vw?OQ5_i+j+Qnoe
z@<K$`OXHqsUcJQW%yJtkH8msoGcgaazv7-}s`&%cwdJcZZf}2#DT4W<!O_DW0x#j#
zAYM<;hEfcMy%EbFt=B-Mb`9Ub>(SQHEx%zSjN<RRX0l$PXbo>naA_*b8TbB~+V!4<
z$u9WG`_8{(R<9vfMjw)Au?BDkb7!faddZ@bJ+dGiiR7ynFt>Ph!2M1`G_sJ__S|<`
zSdlKZ4%{fEtykZJwo6YfBy>OO6ki&b2?}-ne%jJ9<1ktT!b<YXk|f8Gryh}lZBOZJ
z5V1lUn5xJMRw>F3BuEu<-xA4@TkI>A9SaT&biZS7Uy+56f1~<858Em32fouHcZB)c
z?>@N^{+LK~ptGmP;1wYI+a&#=&dpoajaYFHqz2t{x5&)%%%y*f5fnk0cq4|KEKPAG
zLzFs;Z>8otpi;64IWWE+PVeC91|=;4>*?h51I%~<9gtb`Oh?+yVu;GGJ&^AZuazIB
z90lp2d1|AjfT-9^`RoLvGNwII`}S`TTZV!c1Vyw=4;{MxbS@fik6V7Ol3y}8v)Js<
z$U&-}S>t7>fi77a{9GOsAgrm^Y&c`C_eBZ1e%XMC`$4cX`DX7pr=J^|t0kc|t0=_&
z`EP4i$EZD@P+O(rel#X|${-}q(!i7MY$BP5X(hj8btKN^G$x^^CTF_e*wGC??*aiZ
zhFZIwjH)8?CT&vDwr}Xu+1Q#4>cV2qSF+e$;AMc>Exk6oi4G&zX?D*zUm1=2FhvGn
zwQjr+ORx;5x3YC{l!Oe^dc*mLJiS^&YBw7*resGssriUiJ?up@mPDB1fGJ4ZPE)ti
zzohRtF{M%lQsV`yc$wkt_T!B}KX>n;-Q+iSCT%iJQ|AJ5H83;vetqa;D@t2sxwcC+
z1NkdKG&C$eNwLpLe_Q%9STOBu2Zr}+Bh@>(67+~)bx~NZr`nQ-CF_50|M>9=He}XO
zU3iDNIU9b2n`BJ}?DppNt-wx_$9tc+csea{88X{zPH5VA!r4XsL~HNN%=TJ>XF$RO
zc&Yx`KsjjOib}92M7U}U88PfLgJxN2AYeSNxsqbh&rlKNx_#OM!ZmBKQR!l$PPtJd
zU?DbK9y2H6E8SM;Fu7X3{b%NYB?D8kqv+1#dO6~0$A`uo^Gs4TI61Djlk5RcQdwbQ
zI7#g3pYLraYY@21x7aVJKiT|Hy39ReKSQzX<Y9p|SkwpYk%%3OcWgiX7N##Zj`GN+
zqB!lXGB$qu3lQd+^wzZBfzCIXuftU}YzgjpyV2-YZxJ7DMs2h?q|N~-8hm+{$S4zK
z#m=ov4I^P1Cb}2&7&E=j^JSt2gYsS|j|r80yOF|7KRq-LuXZyx1vkZUD^by`x{KgO
z%lp;vKU@*feW%}+abu^qVfCB-xuAMVFU$th6LgsDow}TJ(bUT+q)Ik;bN*aM>+e_P
z-bJM8A{BCjpmTY%<ziw|389KAZlvAJj~KOSDg*)Er%%^-4-9JZ58XxzS1H09Cr#zd
zKP%$-R@Tjv@^{n|Z6o40N3MT!*)~0wtj&2BS}S~LK9c8)LR)<ksn1z&1xTAqUw>1A
zvLg(SJL=`L6AMkmo+?^zm#f~8X?a%Obh)4lB1WUf9*uH1E<KtaoZcZow<G_RQ@`}>
z8K_lFceyWU)*!U=LM?>#g|Eqwg4>@VSQGpJ&y<_1=zjV!e9GEbI8WC7OEALAcw6#j
zc875{4m|@VSa!KD0Lv&{9o@(txkezl*$Fym8)wBcN!c=4D`E@d-p_O#NfBLkr}y=3
zniSehD$S&gcIWKWJ-^NR0=D>V`$|x$qMm4`v*jiGKDER#SulimaV^nAl$38ogz?c1
z_O0UyNEN}`WiA$woU!UsM6pxXoC4P)+@&{a!=h+1)l)4<p#VSnMT!aNd%E`d>Aw%&
zajhFlU!Kw!Sp0nbgS+L=g+eB0=Wb06{jMGWeY)`h5L70z^Gt06J$<r_Q%%WMp}q70
z?ADhU+m?wg*w8BUV9L3hTn1J(mW$@k)cP8gR7y+Uv^TxDp^eEox#pmN(51oxV4+7a
z>T1*m4xLL%YB9yHm-~a!*6rT*$Kr{ZlU4!J$}OuYz%yXD2l0?DH%U58=(%I0TSo#1
zWo3lHpSNqXqF#wtv`v{Q_*@o{Jg7<Do-e@>2_GXue3E_9o`GRGdg4fmL8V1I4mH9V
zD+PKxJQAGqULeZK5WG3o8OAyirvi_05fRGP4G<iS)v*W7?o_<`(Mr(rCRQ(3+CVJv
z6`Tz_O;5TY$LkY=F2w|4>p<wP79x%wTj$^V`#`pSopkr*1(^E2%vxvc9Fw5)vHt>Q
zTq41c{owseU6wVmYZKNu`e>y}v+s4lP`De-C6~=%ee~ea$}=o0a7E-ynL>qT6Yahv
z^?B04CKlFHzbEJGrJ?jXo~5@E)gX6b7TuokO5InXxG`<C=BX7pFgn3zr$4b*IaAV5
zr_gsN^0KxX48C<TYIXHMq=oCu|5I<pbd?bZ|Bk%i*T!;T3jWnGU1Q5<jS)TCXU^#|
zNFYbd@bh?K+x1K|K;Jt8ZBz*9p~DtrC|jTLM1Xf8NA{z)<v(uCg*fctCV%c^b3e~Y
ze#>c4L2!PT79^hQUR!BQJ|>%c-TJGvZe@iveP?eUc-vm-I~g)+_Jxl_V6Jx_d#y+2
zHOcE*zpoC6fagWBQYl71-&?*wE-f;mp-YL-N*>i$>SUqxrMU7h7B2gXAOG6&JCxM@
zd%w!mU;goOdl3?Q80}FY-PftLW(kw&O_gmXY1P+#+i9A8ZtrbAI4X+jSewli064wE
ze^I<JHm3JUPVErmI<0zJp{s>HnV_9nWm!DoR{YcE#=&C8)%{h??i(LS&pBAVGiy_1
z8dBt1*x%$RMC2>OzlfrVp{@)OJbMaWP>_-M?$m~$(PMenHo?jsdfwsq1xrf_ZBEVJ
z*|-_9*mSK`W_i9y8QUbhV?A6M%|Ovf9?lf{g!i)H>u$vPR~1}r4$n)N_33<BHj)u7
zvt{#MPY=ji?!K(u{6XdUR4r&px0Q}sD%JBsz9x}>#3?SAyrWO@<ThH_esk5yqTIqO
ztp_t*;~(XFa<faGLSL?vmfTqvNJO7@=*v|NK*Rf-IrWM0bZI~R@ay)!v~x7H+ul0Z
z%W+EmsP!ph!MEW>1ss;&4gj!St75Odr6oa2Mo-h)n?gYUBVl%2nYzg5MdDI(!r468
zUq65U$j6l>rBWqt+IgxVqQFwa`>^nbx#WY?cOUOeSLs&_XISQHAsH`!S!@_`o-g{|
y#`kL>2U{!0Jpgs*hlkPUm!+sbF#pY==x8L1JZIvTq6Pmxm87_wSmhTTzyATNL=?yX


From 2226b6f95b0218d5ba896a8afa6ea217706cc8a3 Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 9 Sep 2026 14:08:01 -0400
Subject: [PATCH 06/19] fix(desktop): npub identity controls across profile,
 agents, and workflows (#7489)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖
## Summary

Building on #7488's npub foundation, this PR finishes the identity
display change for the controls where you actually manage people and
keys: profile, settings, agent access, and workflows. Everywhere in
these surfaces, an identity key shows — and copies — as its canonical
npub (npub is the human-readable encoding of a Nostr public key: the
compact `npub1j57...fjmv` form where space is tight, the full npub where
the whole key matters), and accepts npub as input.

After this change:

- Profile panel: the public-key row and the managed-by / declared-owner
copies show the full npub. If a key can't be encoded, you see
"Unavailable" with no copy button — never a raw or partial key.
- Settings: the identity card shows and copies the npub. The
hosted-communities account identity derives from the bound key
(`pubkey_hex`) — the same authority as the mismatch gate and hosted
operations — so the display can never disagree with what the app acts
on; an unusable hex falls back to a neutral label instead of rendering
the unverified server npub. The connected claim and a community's
Connect action require that same usable bound key to match the local one
— with no usable binding the card cannot claim connected or start
Connect, while the community list, linking, and delete/rebind recovery
stay available.
- Hosted create/onboarding: the account and device identity rows in the
create flow and owner onboarding derive from the same authoritative
fields (bound key / local key), with the same neutral fallback;
readiness requires a usable bound key that matches the local one.
- Respond-to allowlist (controls who may respond to an agent): entries
can be typed or pasted as hex or npub; both spellings of the same key
are recognized as one entry and dedupe. Search results, chips, and
remove buttons use the compact npub.
- Workflow key fields: to/from keys display as npubs in the form and
save back as canonical hex. Templates like `{{trigger.author}}`, roles,
and free text pass through untouched; placeholders accept both
spellings.
- Recipient and agent dialogs: the verify popover is npub-only (the
raw-hex line is gone); denied-membership screens never show a raw key.
- The Rust-side truncated display name (used for native surfaces) shows
the same compact npub, so those surfaces match the web UI.

Internal representation is unchanged: keys are still stored, sent, and
matched as canonical 64-character hex — npub is a display and input
spelling, normalized to hex at the boundary, so existing data and
integrations keep working. Bound-key usability and comparison use one
normalized form (trimmed, lowercased, 64 hex characters; npub rejected),
so padded or mixed-case spellings of the same key match. Display names,
private keys, and event IDs are untouched.

## Details

- `respondToAllowlist` / `RespondToField`: npub entries normalize to
canonical hex; cross-form dedupe; compact npub in rows and chips;
direct-add accepts npub and stores canonical hex.
- `workflowFormTypes` / `WorkflowStepCard`: hex → npub for display, npub
→ canonical hex on save; templates, roles, and free text pass through in
both directions (roundtrip-tested).
- `UserProfilePanelFields`, `ProfileSettingsCard`,
`HostedCommunitiesSettingsCard`, `MembershipDenied`,
`SelectedRecipientChip`, `AddAgentToChannelDialog`: npub display and
copy; invalid keys → "Unavailable" with no copy; hosted identity rows
derive from the bound `pubkey_hex` (create/onboarding rows from the
bound and local keys), never the unverified server npub;
connected/readiness/Connect gates use the same usable-bound-key
predicate, and the settings Connect invocation callback re-checks it
before starting.
- `src-tauri/src/commands/identity.rs`: `truncated_display_name`
compacts to the first 8 + last 4 characters of the npub (above a 12-char
threshold), mirroring `truncateNpub`.
- e2e: profile key rows and clipboard polls assert npub forms and
raw-hex suppression; the display-screenshots spec pins the npub-only
popover; hosted specs drive the real settings card, create flow, and
onboarding rows through their real providers, and the unlinked/npub-only
identity cases assert no connected claim and no Connect action.

### Related issue

- Fixes: N/A. No separate issue; the related work is the stack below.
- Stack: builds on #7488 (shared npub foundation), now merged; this PR
is rebased onto main and stands on its own.

### Testing

At head `303c90ffa` (base: main `bfc38485`; 24 files, +1125/−146):

- Focused unit suites (respondToAllowlist, workflowFormTypes,
hostedCommunityApi bound-key helpers) green; mutation-checked — dropping
allowlist canonicalization fails the dedupe case, and dropping bound-key
normalization fails the npub-in-hex and padded same-key cases.
- Full desktop unit suite 6,477/6,477, `desktop-typecheck`,
`desktop-check` (formatting fixed narrowly with `biome check --write` on
the touched files only), and a fresh E2E build at the current head; the
add-community + hosted-communities-settings specs 18/18 and onboarding
integration 69/69 on a fresh dedicated port, with focused new-case runs
4+4 covering padded same-key (ready, Connect kept — no false rebind) and
npub-in-hex (neutral label, recovery, no Connect) across the settings
card, create flow, and first-community onboarding, plus the
unlinked-account settings regression asserting Connect cannot occur.
- `cargo fmt`/clippy (both feature sets) and `cargo test identity` (71
pass) passed at the earlier full-change head; since then, the only
production changes in this PR's delta are the hosted identity display
authority and its fail-closed bound-key gating/normalization above
(base-side fixes carry #7488's receipts) — every other change is
test-only.

### Task provenance

Buzz channel: `1f0e4a3d-7e01-4efe-bb16-843b357f85c9`

Task:
buzz://message?channel=1f0e4a3d-7e01-4efe-bb16-843b357f85c9&id=86b34eb4bd84a1472419e9af22636c011c0fe273e3c196f967d7a36996e149b6

---------

Signed-off-by: Logan Johnson <loganj@squareup.com>
Co-authored-by: Larry <627498bd4bd1f281a16431e3c6cce3b5c25b6692798c78672298aefbf2f8f8b5@buzz.block.builderlab.xyz>
---
 desktop/scripts/check-pubkey-truncation.mjs   |   6 +-
 desktop/src-tauri/src/commands/identity.rs    |  35 ++-
 .../agents/lib/respondToAllowlist.test.mjs    |  23 +-
 .../features/agents/lib/respondToAllowlist.ts |  41 ++--
 .../agents/ui/AddAgentToChannelDialog.tsx     |  18 +-
 .../src/features/agents/ui/RespondToField.tsx |  41 ++--
 .../communities/hostedCommunityApi.test.mjs   |  98 ++++++++
 .../communities/hostedCommunityApi.ts         |  51 ++++
 .../ui/HostedCommunityCreateFlow.tsx          |  52 +++-
 .../ui/HostedCommunityOnboarding.tsx          |  64 +++--
 .../onboarding/ui/MembershipDenied.tsx        |  26 +-
 .../profile/ui/SelectedRecipientChip.tsx      |   3 -
 .../profile/ui/UserProfilePanelFields.tsx     |  23 +-
 .../ui/HostedCommunitiesSettingsCard.tsx      |  73 ++++--
 .../settings/ui/ProfileSettingsCard.tsx       |  10 +-
 .../workflows/ui/WorkflowStepCard.tsx         |   4 +-
 .../workflows/ui/workflowFormTypes.test.mjs   |  71 ++++++
 .../workflows/ui/workflowFormTypes.ts         |  36 ++-
 .../e2e/add-community-screenshots.spec.ts     | 137 ++++++++++-
 ...d-communities-settings-screenshots.spec.ts | 223 +++++++++++++++++-
 desktop/tests/e2e/onboarding.spec.ts          | 206 +++++++++++++++-
 desktop/tests/e2e/profile.spec.ts             |  11 +-
 .../e2e/pubkey-display-screenshots.spec.ts    |   9 +-
 scripts/check-pubkey-truncation-core.mjs      |  10 +-
 24 files changed, 1125 insertions(+), 146 deletions(-)
 create mode 100644 desktop/src/features/communities/hostedCommunityApi.test.mjs

diff --git a/desktop/scripts/check-pubkey-truncation.mjs b/desktop/scripts/check-pubkey-truncation.mjs
index d65db135454..67ce2a90910 100644
--- a/desktop/scripts/check-pubkey-truncation.mjs
+++ b/desktop/scripts/check-pubkey-truncation.mjs
@@ -6,8 +6,10 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(__dirname, "..");
 
 // Truncated pubkey prefixes are forgeable (vanity grinding), so all display
-// truncation goes through the canonical `truncatePubkey` / `<PubKey>` — this
-// guard keeps ad-hoc `pubkey.slice(0, N)` forms from fragmenting again.
+// truncation goes through the canonical `truncateNpub` (identity keys —
+// compact npub), `truncatePubkey` (generic hex identifiers such as event and
+// blob IDs), or `<PubKey>` — this guard keeps ad-hoc `pubkey.slice(0, N)`
+// forms from fragmenting again.
 const rules = [
   {
     root: "src",
diff --git a/desktop/src-tauri/src/commands/identity.rs b/desktop/src-tauri/src/commands/identity.rs
index ec2357b85e7..8852fcb7e01 100644
--- a/desktop/src-tauri/src/commands/identity.rs
+++ b/desktop/src-tauri/src/commands/identity.rs
@@ -11,19 +11,46 @@ use crate::{
     relay::{self, relay_api_base_url_with_override, relay_ws_url_with_override},
 };
 
-/// Encode `pubkey` as npub bech32 and truncate it for display: first 10 chars
-/// + "…" + last 4 chars. Returns the full bech32 when it is 16 chars or fewer.
+/// Encode `pubkey` as npub bech32 and truncate it for display: first 8
+/// chars, an ellipsis, then the last 4 chars, mirroring the frontend
+/// `truncateNpub` compact policy (`first8…last4` of the whole npub string).
+/// Returns the full bech32 when it is 12 chars or fewer, mirroring
+/// `truncatePubkey`'s short-string threshold.
 fn truncated_display_name(pubkey: &PublicKey) -> Result<String, String> {
     let bech32 = pubkey
         .to_bech32()
         .map_err(|error| format!("bech32 encode failed: {error}"))?;
-    Ok(if bech32.len() > 16 {
-        format!("{}…{}", &bech32[..10], &bech32[bech32.len() - 4..])
+    Ok(if bech32.len() > 12 {
+        format!("{}…{}", &bech32[..8], &bech32[bech32.len() - 4..])
     } else {
         bech32
     })
 }
 
+#[cfg(test)]
+mod truncated_display_name_tests {
+    use super::truncated_display_name;
+    use nostr::{PublicKey, ToBech32};
+
+    #[test]
+    fn compacts_to_first_8_and_last_4_of_the_npub() {
+        // Vector shared with the frontend `truncateNpub` tests; the expected
+        // form is derived from the encoded npub, not hardcoded, so the test
+        // asserts the compaction policy rather than one key's string.
+        let hex = "ea9b4d7a7a78a3e3729e5568b14d764d4962be0e1f20f749bcf8d9dbbf9a9328";
+        let pubkey = PublicKey::from_hex(hex).unwrap();
+        let npub = pubkey.to_bech32().unwrap();
+        let expected = format!("{}…{}", &npub[..8], &npub[npub.len() - 4..]);
+        assert_eq!(truncated_display_name(&pubkey).unwrap(), expected);
+        // 13 characters, matching the frontend compact form (the ellipsis is
+        // one char but three UTF-8 bytes, so count chars, not bytes).
+        assert_eq!(expected.chars().count(), 13);
+        assert!(expected.starts_with("npub1"));
+        // The compact form must not carry the raw hex key.
+        assert!(!expected.contains(hex));
+    }
+}
+
 #[tauri::command]
 pub fn get_identity(state: State<'_, AppState>) -> Result<IdentityInfo, String> {
     let keys = state.keys.lock().map_err(|error| error.to_string())?;
diff --git a/desktop/src/features/agents/lib/respondToAllowlist.test.mjs b/desktop/src/features/agents/lib/respondToAllowlist.test.mjs
index bbe07f72040..0d494652e74 100644
--- a/desktop/src/features/agents/lib/respondToAllowlist.test.mjs
+++ b/desktop/src/features/agents/lib/respondToAllowlist.test.mjs
@@ -6,6 +6,10 @@ import { mergeAllowlist, parsePubkeyInput } from "./respondToAllowlist.ts";
 const HEX_A = "a".repeat(64);
 const HEX_B = "b".repeat(64);
 const HEX_A_UPPER = "A".repeat(64);
+// Handoff vector, round-trip verified with nostr-tools nip19.
+const HEX = "ea9b4d7a7a78a3e3729e5568b14d764d4962be0e1f20f749bcf8d9dbbf9a9328";
+const HEX_NPUB =
+  "npub1a2d567n60z37xu57245tzntkf4yk90swrus0wjdulrvah0u6jv5qusyp60";
 
 test("parsePubkeyInput splits on commas, whitespace, and newlines", () => {
   const input = `${HEX_A}, ${HEX_B}\n${HEX_A_UPPER}`;
@@ -25,11 +29,15 @@ test("parsePubkeyInput surfaces invalid entries separately", () => {
   assert.deepEqual(result.invalid, ["notgood", "z".repeat(64)]);
 });
 
-test("parsePubkeyInput rejects npub-style strings (hex only)", () => {
-  const npub = `npub1${"a".repeat(59)}`;
-  const result = parsePubkeyInput(npub);
-  assert.deepEqual(result.valid, []);
-  assert.deepEqual(result.invalid, [npub]);
+test("parsePubkeyInput accepts npub entries, normalizes to hex, and dedupes across spellings", () => {
+  // One invalid npub-shaped token proves classification at this seam; the
+  // full codec negative matrix lives at the shared parser (nostrUtils).
+  const corrupt = `${HEX_NPUB.slice(0, -2)}qq`;
+  const result = parsePubkeyInput(
+    `${HEX_NPUB} ${HEX} ${HEX.toUpperCase()} ${corrupt}`,
+  );
+  assert.deepEqual(result.valid, [HEX]);
+  assert.deepEqual(result.invalid, [corrupt]);
 });
 
 test("parsePubkeyInput rejects wrong-length entries", () => {
@@ -60,3 +68,8 @@ test("mergeAllowlist skips invalid additions silently", () => {
   const merged = mergeAllowlist([HEX_A], ["not-hex", HEX_B]);
   assert.deepEqual(merged, [HEX_A, HEX_B]);
 });
+
+test("mergeAllowlist normalizes npub additions to canonical hex and dedupes", () => {
+  assert.deepEqual(mergeAllowlist([HEX_A], [HEX_NPUB]), [HEX_A, HEX]);
+  assert.deepEqual(mergeAllowlist([HEX], [HEX_NPUB]), [HEX]);
+});
diff --git a/desktop/src/features/agents/lib/respondToAllowlist.ts b/desktop/src/features/agents/lib/respondToAllowlist.ts
index c376aa1d1af..237a457cc30 100644
--- a/desktop/src/features/agents/lib/respondToAllowlist.ts
+++ b/desktop/src/features/agents/lib/respondToAllowlist.ts
@@ -5,9 +5,14 @@
  * `desktop/src-tauri/src/managed_agents/types.rs::validate_respond_to_allowlist`).
  * These helpers exist to give the UI immediate, inline feedback before the
  * round-trip, and to normalize input so the Rust validator sees clean data.
+ *
+ * Entry pieces may be 64-char hex pubkeys or bech32 `npub1…` strings; both are
+ * normalized to the canonical lowercase hex via the shared
+ * `parsePubkeyInput`, so npub and hex spellings of the same key dedupe to one
+ * entry (users copy npubs from profile/verify surfaces elsewhere in the app).
  */
 
-const HEX_64 = /^[0-9a-f]{64}$/i;
+import { parsePubkeyInput as parseCanonicalPubkey } from "@/shared/lib/nostrUtils";
 
 export type ParsedAllowlist = {
   /** Successfully parsed entries — lowercase hex, deduplicated, in order. */
@@ -22,9 +27,9 @@ export type ParsedAllowlist = {
  * pattern used by `ChannelMemberInviteCard` so users have one mental model.
  *
  * - Splits on `/[\s,]+/`.
- * - Trims and lowercases each entry.
- * - Validates each entry is exactly 64 hex chars.
- * - Deduplicates while preserving insertion order.
+ * - Accepts 64-char hex (any case) or `npub1…` bech32 per piece, normalizing
+ *   to the canonical lowercase hex pubkey.
+ * - Deduplicates the canonical form while preserving insertion order.
  */
 export function parsePubkeyInput(raw: string): ParsedAllowlist {
   const seen = new Set<string>();
@@ -33,14 +38,14 @@ export function parsePubkeyInput(raw: string): ParsedAllowlist {
   for (const piece of raw.split(/[\s,]+/)) {
     const trimmed = piece.trim();
     if (trimmed.length === 0) continue;
-    if (!HEX_64.test(trimmed)) {
+    const canonical = parseCanonicalPubkey(trimmed);
+    if (canonical === null) {
       invalid.push(trimmed);
       continue;
     }
-    const lower = trimmed.toLowerCase();
-    if (!seen.has(lower)) {
-      seen.add(lower);
-      valid.push(lower);
+    if (!seen.has(canonical)) {
+      seen.add(canonical);
+      valid.push(canonical);
     }
   }
   return { valid, invalid };
@@ -48,16 +53,20 @@ export function parsePubkeyInput(raw: string): ParsedAllowlist {
 
 /**
  * Merge an existing allowlist with newly-added pubkeys, normalizing and
- * deduplicating without reordering existing entries.
+ * deduplicating without reordering existing entries. Both hex and npub
+ * spellings normalize to the canonical hex, so the same key cannot enter
+ * twice regardless of the form it was added in.
  */
 export function mergeAllowlist(existing: string[], add: string[]): string[] {
-  const seen = new Set(existing.map((p) => p.toLowerCase()));
-  const out = [...existing.map((p) => p.toLowerCase())];
+  const normalize = (pubkey: string): string =>
+    parseCanonicalPubkey(pubkey) ?? pubkey.toLowerCase();
+  const out = existing.map(normalize);
+  const seen = new Set(out);
   for (const candidate of add) {
-    const lower = candidate.toLowerCase();
-    if (!HEX_64.test(lower) || seen.has(lower)) continue;
-    seen.add(lower);
-    out.push(lower);
+    const canonical = parseCanonicalPubkey(candidate);
+    if (canonical === null || seen.has(canonical)) continue;
+    seen.add(canonical);
+    out.push(canonical);
   }
   return out;
 }
diff --git a/desktop/src/features/agents/ui/AddAgentToChannelDialog.tsx b/desktop/src/features/agents/ui/AddAgentToChannelDialog.tsx
index 05441e86180..366a19d7ca3 100644
--- a/desktop/src/features/agents/ui/AddAgentToChannelDialog.tsx
+++ b/desktop/src/features/agents/ui/AddAgentToChannelDialog.tsx
@@ -9,7 +9,11 @@ import {
   useChannelsQuery,
 } from "@/features/channels/hooks";
 import type { Channel, ChannelRole, ManagedAgent } from "@/shared/api/types";
-import { normalizePubkey } from "@/shared/lib/pubkey";
+import {
+  canonicalNpub,
+  normalizePubkey,
+  UNAVAILABLE_KEY_LABEL,
+} from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import {
   Dialog,
@@ -87,6 +91,10 @@ export function AddAgentToChannelDialog({
     );
   }, [agent?.pubkey, membersQuery.data]);
 
+  // The agent's public key displays as its full canonical npub; an
+  // unencodable key renders the neutral label and is not copyable.
+  const agentNpub = agent?.pubkey ? canonicalNpub(agent.pubkey) : null;
+
   const selectedChannel =
     channels.find((channel) => channel.id === channelId) ?? null;
 
@@ -186,10 +194,12 @@ export function AddAgentToChannelDialog({
               </p>
               <div className="mt-3 flex items-center justify-between gap-3">
                 <code className="min-w-0 flex-1 break-all rounded-xl border border-border/70 bg-background/80 px-3 py-2 text-xs">
-                  {agent?.pubkey ?? "No agent selected"}
+                  {agent
+                    ? (agentNpub ?? UNAVAILABLE_KEY_LABEL)
+                    : "No agent selected"}
                 </code>
-                {agent ? (
-                  <CopyButton label="Copy pubkey" value={agent.pubkey} />
+                {agent && agentNpub ? (
+                  <CopyButton label="Copy pubkey" value={agentNpub} />
                 ) : null}
               </div>
             </div>
diff --git a/desktop/src/features/agents/ui/RespondToField.tsx b/desktop/src/features/agents/ui/RespondToField.tsx
index 400f93af7c5..d910bfc8a6f 100644
--- a/desktop/src/features/agents/ui/RespondToField.tsx
+++ b/desktop/src/features/agents/ui/RespondToField.tsx
@@ -4,7 +4,8 @@ import {
   mergeAllowlist,
   parsePubkeyInput,
 } from "@/features/agents/lib/respondToAllowlist";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { parsePubkeyInput as parseCanonicalPubkey } from "@/shared/lib/nostrUtils";
+import { truncateNpub } from "@/shared/lib/pubkey";
 import { PubKey } from "@/shared/ui/PubKey";
 import { useIsArchivedPredicate } from "@/features/identity-archive/hooks";
 import { useUserSearchQuery } from "@/features/profile/hooks";
@@ -59,7 +60,7 @@ function formatSearchUserName(user: UserSearchResult) {
   return (
     user.displayName?.trim() ||
     user.nip05Handle?.trim() ||
-    truncatePubkey(user.pubkey)
+    truncateNpub(user.pubkey)
   );
 }
 
@@ -69,7 +70,7 @@ function formatSearchUserSecondary(user: UserSearchResult) {
   if (displayName && nip05Handle) {
     return nip05Handle;
   }
-  return truncatePubkey(user.pubkey);
+  return truncateNpub(user.pubkey);
 }
 
 const RESPOND_TO_OPTIONS: PersonaDropdownOption[] = [
@@ -278,8 +279,6 @@ export function CreateAgentRespondToField({
   );
 }
 
-const HEX_64_RE = /^[0-9a-f]{64}$/i;
-
 function AllowlistPicker({
   allowlist,
   deferredQuery,
@@ -325,10 +324,12 @@ function AllowlistPicker({
 }) {
   const isPersona = variant === "persona";
 
-  // Detect if the query is a valid hex pubkey that's not already in the list.
-  const queryIsHexPubkey =
-    HEX_64_RE.test(deferredQuery) &&
-    !allowlist.some((p) => p.toLowerCase() === deferredQuery.toLowerCase());
+  // Detect if the query is a pubkey (npub or hex) not already in the list;
+  // direct entry offers the canonical hex for storage.
+  const queryPubkey = parseCanonicalPubkey(deferredQuery);
+  const queryIsDirectPubkey =
+    queryPubkey !== null &&
+    !allowlist.some((p) => p.toLowerCase() === queryPubkey);
 
   return (
     <div
@@ -382,12 +383,12 @@ function AllowlistPicker({
               >
                 <UserAvatar
                   avatarUrl={null}
-                  displayName={truncatePubkey(pubkey)}
+                  displayName={truncateNpub(pubkey)}
                   size="xs"
                 />
                 <PubKey pubkey={pubkey} />
                 <button
-                  aria-label={`Remove ${truncatePubkey(pubkey)}`}
+                  aria-label={`Remove ${truncateNpub(pubkey)}`}
                   className="text-muted-foreground transition-colors hover:text-foreground"
                   disabled={disabled}
                   onClick={() => onRemove(pubkey)}
@@ -435,22 +436,22 @@ function AllowlistPicker({
                   </button>
                 ))}
               </div>
-            ) : queryIsHexPubkey ? (
+            ) : queryIsDirectPubkey ? (
               <button
                 className="flex w-full items-center justify-between rounded-md px-2.5 py-1.5 text-left transition-colors hover:bg-accent hover:text-accent-foreground"
                 data-testid="agent-respond-to-add-raw-pubkey"
-                onClick={() => onAddRawPubkey(deferredQuery.toLowerCase())}
+                onClick={() => onAddRawPubkey(queryPubkey)}
                 type="button"
               >
                 <div className="flex items-center gap-2 min-w-0">
                   <UserAvatar
                     avatarUrl={null}
-                    displayName={truncatePubkey(deferredQuery)}
+                    displayName={truncateNpub(queryPubkey)}
                     size="xs"
                   />
                   <div className="min-w-0">
                     <p className="truncate text-sm font-medium leading-5">
-                      {truncatePubkey(deferredQuery)}
+                      {truncateNpub(queryPubkey)}
                     </p>
                     <p className="truncate text-xs text-muted-foreground">
                       Add pubkey directly
@@ -494,22 +495,22 @@ function AllowlistPicker({
               id="agent-respond-to-direct-panel"
             >
               <p className="text-xs text-muted-foreground">
-                One per line, or comma/space-separated. 64-char lowercase hex
-                only — npub decoding is not yet supported here.
+                One per line, or comma/space-separated. Each entry is an npub
+                (npub1…) or a 64-char hex public key.
               </p>
               <Textarea
                 className="min-h-20 font-mono text-xs"
                 data-testid="agent-respond-to-paste"
                 disabled={disabled}
                 onChange={(event) => onPasteTextChange(event.target.value)}
-                placeholder="abcdef0123…"
+                placeholder="npub1… or abcdef0123…"
                 value={pasteText}
               />
               {pasteInvalid.length > 0 ? (
                 <p className="text-xs text-destructive">
                   {pasteInvalid.length} entr
-                  {pasteInvalid.length === 1 ? "y is" : "ies are"} not 64-char
-                  hex and will be ignored.
+                  {pasteInvalid.length === 1 ? "y is" : "ies are"} not a valid
+                  npub or 64-char hex public key and will be ignored.
                 </p>
               ) : null}
               <div className="flex items-center justify-between gap-2">
diff --git a/desktop/src/features/communities/hostedCommunityApi.test.mjs b/desktop/src/features/communities/hostedCommunityApi.test.mjs
new file mode 100644
index 00000000000..0af05143dff
--- /dev/null
+++ b/desktop/src/features/communities/hostedCommunityApi.test.mjs
@@ -0,0 +1,98 @@
+/**
+ * Unit tests for the hosted-identity usable-bound-key predicate.
+ *
+ * Hosted surfaces gate connected/readiness/create/connect decisions on
+ * whether the identity payload carries an authoritative `pubkey_hex` that
+ * normalizes to a hex key — never on the mere presence of the identity
+ * object, and never on the display parser's npub-accepting domain. These
+ * tests pin the predicate's boundary semantics; the E2E specs assert the
+ * rendered fail-closed states through the real surfaces.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { npubEncode } from "nostr-tools/nip19";
+
+import {
+  normalizedBoundKeyHex,
+  usableBoundIdentityNpub,
+} from "./hostedCommunityApi.ts";
+
+const BOUND_HEX = "deadbeef".repeat(8);
+
+test("returns the canonical npub for a valid bound hex", () => {
+  assert.equal(
+    usableBoundIdentityNpub({ pubkey_hex: BOUND_HEX }),
+    npubEncode(BOUND_HEX),
+  );
+});
+
+test("normalizes mixed-case bound hex to the canonical npub", () => {
+  assert.equal(
+    usableBoundIdentityNpub({ pubkey_hex: BOUND_HEX.toUpperCase() }),
+    npubEncode(BOUND_HEX),
+  );
+});
+
+test("npub stored in pubkey_hex is never a usable hex binding", () => {
+  // A checksum-valid npub — even one spelling the very key this device
+  // signs with — is the display field's domain. Stored in the authoritative
+  // hex field it is not a hex key, so it must fail closed: never usable,
+  // never a comparison operand, never a pending-local bypass that reads the
+  // account as connected because the raw comparison was skipped.
+  assert.equal(normalizedBoundKeyHex(npubEncode(BOUND_HEX)), null);
+  assert.equal(
+    usableBoundIdentityNpub({ pubkey_hex: npubEncode(BOUND_HEX) }),
+    null,
+  );
+  // An all-uppercase NPUB spelling is equally rejected.
+  assert.equal(
+    normalizedBoundKeyHex(npubEncode(BOUND_HEX).toUpperCase()),
+    null,
+  );
+});
+
+test("same-key normalization: padded hex is the key it spells, on both sides", () => {
+  // Whitespace-padded, mixed-case hex normalizes to the identical value
+  // usability and comparisons use, so the same key never demands a
+  // delete/rebind of an identity the device already holds.
+  const padded = `  ${BOUND_HEX.toUpperCase()}  `;
+  assert.equal(normalizedBoundKeyHex(padded), BOUND_HEX);
+  assert.equal(normalizedBoundKeyHex(BOUND_HEX), BOUND_HEX);
+  assert.equal(
+    usableBoundIdentityNpub({ pubkey_hex: padded }),
+    npubEncode(BOUND_HEX),
+  );
+});
+
+test("returns null when the identity object is absent", () => {
+  assert.equal(usableBoundIdentityNpub(null), null);
+  assert.equal(usableBoundIdentityNpub(undefined), null);
+});
+
+test("returns null when the authoritative key field is missing or empty", () => {
+  // npub-only payload: the server-sent `npub` is an independent, unverified
+  // spelling and must never substitute for the authoritative key.
+  assert.equal(usableBoundIdentityNpub({ npub: npubEncode(BOUND_HEX) }), null);
+  assert.equal(usableBoundIdentityNpub({}), null);
+  assert.equal(usableBoundIdentityNpub({ pubkey_hex: "" }), null);
+});
+
+test("returns null when the authoritative key cannot encode a key", () => {
+  // Non-hex alphabet.
+  assert.equal(usableBoundIdentityNpub({ pubkey_hex: "zz".repeat(32) }), null);
+  // Valid hex alphabet, wrong length for an identity key.
+  assert.equal(usableBoundIdentityNpub({ pubkey_hex: "f".repeat(63) }), null);
+  assert.equal(usableBoundIdentityNpub({ pubkey_hex: "f".repeat(65) }), null);
+  // Whitespace is not an identity key.
+  assert.equal(usableBoundIdentityNpub({ pubkey_hex: "  " }), null);
+});
+
+test("the string normalizer rejects the same non-key values directly", () => {
+  assert.equal(normalizedBoundKeyHex(null), null);
+  assert.equal(normalizedBoundKeyHex(undefined), null);
+  assert.equal(normalizedBoundKeyHex("zz".repeat(32)), null);
+  assert.equal(normalizedBoundKeyHex("f".repeat(63)), null);
+  assert.equal(normalizedBoundKeyHex("f".repeat(65)), null);
+  assert.equal(normalizedBoundKeyHex("  "), null);
+});
diff --git a/desktop/src/features/communities/hostedCommunityApi.ts b/desktop/src/features/communities/hostedCommunityApi.ts
index 0aca17a17d9..ebf5857c6e2 100644
--- a/desktop/src/features/communities/hostedCommunityApi.ts
+++ b/desktop/src/features/communities/hostedCommunityApi.ts
@@ -1,5 +1,7 @@
 import { invoke } from "@tauri-apps/api/core";
 
+import { safeNpub } from "@/shared/lib/nostrUtils";
+
 export const HOSTED_COMMUNITY_SUFFIX = "communities.buzz.xyz";
 export const HOSTED_COMMUNITY_LIMIT = 5;
 export const VALID_HOSTED_COMMUNITY_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -90,6 +92,55 @@ export function hostedCommunityRelayUrl(community: HostedCommunity) {
   return host ? `wss://${host.replace(/^wss?:\/\//, "")}` : null;
 }
 
+const BOUND_KEY_HEX_REGEX = /^[0-9a-f]{64}$/;
+
+/**
+ * The ONE operational form of a hosted identity's bound key: the trimmed,
+ * lowercased `pubkey_hex` when that field carries a 64-character hex key,
+ * null otherwise.
+ *
+ * `pubkey_hex` is the authoritative field the mismatch gate and every
+ * hosted-community operation act on, so its accepted shape is defined here
+ * once and is hex-only. An `npub` spelling belongs to the server's separate
+ * display field: one stored in the hex field is not a hex key and fails
+ * closed here instead of widening the authorization domain beyond what
+ * comparisons see. Whitespace-padded or mixed-case hex normalizes to the
+ * identical value on both sides of every comparison, so a key that is the
+ * same after normalization never reads as a mismatch demanding a
+ * delete/rebind of an identity the device already holds. Consumers
+ * normalize the local key through this same function before comparing.
+ */
+export function normalizedBoundKeyHex(
+  value: string | null | undefined,
+): string | null {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  return BOUND_KEY_HEX_REGEX.test(normalized) ? normalized : null;
+}
+
+/**
+ * The canonical npub of the hosted identity's authoritative bound key, or
+ * null when the payload carries no key the app can act on.
+ *
+ * `pubkey_hex` is the field the mismatch gate and every hosted-community
+ * operation act on, and it is only usable when it normalizes to a hex key
+ * (`normalizedBoundKeyHex`) — the server-sent `npub` is an independent,
+ * unverified spelling and is never accepted in its place. The returned npub
+ * is derived from that same normalized key, so the displayed account
+ * identity can never disagree with the binding the decisions act on. Hosted
+ * surfaces derive their connected/readiness/create/connect gates from the
+ * normalized key instead of identity-object presence, so an identity payload
+ * without a usable authoritative key (missing, empty, invalid/non-hex,
+ * wrong-length, npub-only, or an npub stored in the hex field) fails closed
+ * into recovery rather than presenting the account as connected.
+ */
+export function usableBoundIdentityNpub(
+  identity: HostedNostrIdentity | null | undefined,
+): string | null {
+  const hex = normalizedBoundKeyHex(identity?.pubkey_hex);
+  return hex === null ? null : safeNpub(hex);
+}
+
 export function getBuilderlabAuth() {
   return invoke<BuilderlabAuth | null>("get_builderlab_auth");
 }
diff --git a/desktop/src/features/communities/ui/HostedCommunityCreateFlow.tsx b/desktop/src/features/communities/ui/HostedCommunityCreateFlow.tsx
index 2401f5dee81..b5aea196384 100644
--- a/desktop/src/features/communities/ui/HostedCommunityCreateFlow.tsx
+++ b/desktop/src/features/communities/ui/HostedCommunityCreateFlow.tsx
@@ -13,12 +13,14 @@ import {
   HOSTED_COMMUNITY_SUFFIX,
   hostedCommunityErrorMessage,
   hostedCommunityRelayUrl,
-  type BuilderlabAuth,
-  type HostedCommunity,
-  type HostedNostrIdentity,
   loadHostedCommunityAccount,
+  normalizedBoundKeyHex,
   startBuilderlabLogin,
+  usableBoundIdentityNpub,
   VALID_HOSTED_COMMUNITY_NAME,
+  type BuilderlabAuth,
+  type HostedCommunity,
+  type HostedNostrIdentity,
 } from "@/features/communities/hostedCommunityApi";
 import { useCommunityOnboarding } from "@/features/onboarding/communityOnboarding";
 import {
@@ -28,6 +30,7 @@ import {
 import { useIdentityQuery } from "@/shared/api/hooks";
 import { cn } from "@/shared/lib/cn";
 import { safeNpub } from "@/shared/lib/nostrUtils";
+import { UNAVAILABLE_KEY_LABEL } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import { Input } from "@/shared/ui/input";
 
@@ -147,14 +150,31 @@ export function HostedCommunityCreateFlow({
       setCommunities([]);
     });
 
-  const boundPubkey = identity?.pubkey_hex ?? null;
+  // Identity rows display npubs derived from the same key the mismatch gate
+  // and recovery actions act on: the account row from the authoritative
+  // bound `pubkey_hex` — the server-sent `npub` is an independent field that
+  // nothing on this path proves encodes the same key — and the device row
+  // from the local key. An unencodable or non-identity-length key renders the
+  // neutral label instead of leaking raw hex or the unverified npub. Both
+  // keys are compared in the one normalized hex form, so a padded or
+  // mixed-case spelling of the same key never reads as a mismatch, and an
+  // npub stored in the hex field is not a key at all.
+  const boundHex = normalizedBoundKeyHex(identity?.pubkey_hex);
+  const localHex = normalizedBoundKeyHex(localPubkey);
+  const localNpub = localHex === null ? null : safeNpub(localHex);
+  const boundNpub = usableBoundIdentityNpub(identity);
+  // The account is only usable to this flow when its authoritative
+  // `pubkey_hex` normalizes to a hex key: without that key the flow cannot
+  // establish which identity create/connect actions would affect. An
+  // identity payload without a usable authoritative key therefore counts as
+  // a mismatch that requires recovery — never as a connected, ready
+  // account.
+  const usableBoundIdentity = boundHex !== null;
   const identityMismatch = Boolean(
     identity &&
-      boundPubkey &&
-      localPubkey &&
-      boundPubkey.toLowerCase() !== localPubkey.toLowerCase(),
+      (!usableBoundIdentity ||
+        (boundHex !== null && localHex !== null && boundHex !== localHex)),
   );
-  const localNpub = localPubkey ? safeNpub(localPubkey) : null;
 
   const switchToDeviceIdentity = () =>
     run("Switching identity…", async () => {
@@ -190,7 +210,7 @@ export function HostedCommunityCreateFlow({
     normalizedName.length <= 63 &&
     VALID_HOSTED_COMMUNITY_NAME.test(normalizedName);
   const atCommunityLimit = communities.length >= HOSTED_COMMUNITY_LIMIT;
-  const ready = Boolean(auth && identity && !identityMismatch);
+  const ready = Boolean(auth && usableBoundIdentity && !identityMismatch);
 
   React.useEffect(() => {
     if (!ready || !normalizedName || !validName) {
@@ -222,7 +242,13 @@ export function HostedCommunityCreateFlow({
 
   const create = (event: React.FormEvent) => {
     event.preventDefault();
-    if (!validName || !identity || identityMismatch || atCommunityLimit) return;
+    if (
+      !validName ||
+      !usableBoundIdentity ||
+      identityMismatch ||
+      atCommunityLimit
+    )
+      return;
     void run("Creating community…", async () => {
       const available = await checkHostedCommunityName(normalizedName);
       if (available.error || !available.available) {
@@ -343,9 +369,11 @@ export function HostedCommunityCreateFlow({
           this device, or sign in with another account.
         </p>
         <div className="rounded-xl bg-muted/40 px-4 py-3 font-mono text-xs text-muted-foreground">
-          <p className="break-all">Account: {identity.npub ?? boundPubkey}</p>
+          <p className="break-all">
+            Account: {boundNpub ?? UNAVAILABLE_KEY_LABEL}
+          </p>
           <p className="mt-1 break-all">
-            This device: {localNpub ?? localPubkey}
+            This device: {localNpub ?? UNAVAILABLE_KEY_LABEL}
           </p>
         </div>
         {errorBox}
diff --git a/desktop/src/features/communities/ui/HostedCommunityOnboarding.tsx b/desktop/src/features/communities/ui/HostedCommunityOnboarding.tsx
index 1152cd8fec3..5f9578bf131 100644
--- a/desktop/src/features/communities/ui/HostedCommunityOnboarding.tsx
+++ b/desktop/src/features/communities/ui/HostedCommunityOnboarding.tsx
@@ -14,16 +14,19 @@ import {
   HOSTED_COMMUNITY_SUFFIX,
   hostedCommunityErrorMessage,
   hostedCommunityRelayUrl,
-  type BuilderlabAuth,
-  type HostedCommunity,
-  type HostedNostrIdentity,
   loadHostedCommunityAccount,
+  normalizedBoundKeyHex,
   startBuilderlabLogin,
+  usableBoundIdentityNpub,
   VALID_HOSTED_COMMUNITY_NAME,
+  type BuilderlabAuth,
+  type HostedCommunity,
+  type HostedNostrIdentity,
 } from "@/features/communities/hostedCommunityApi";
 import { useCommunityOnboarding } from "@/features/onboarding/communityOnboarding";
 import { useIdentityQuery } from "@/shared/api/hooks";
 import { safeNpub } from "@/shared/lib/nostrUtils";
+import { UNAVAILABLE_KEY_LABEL } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import { Card } from "@/shared/ui/card";
 import { Input } from "@/shared/ui/input";
@@ -195,14 +198,30 @@ export function HostedCommunityOnboarding({
       await loadAccount();
     });
 
-  const boundPubkey = identity?.pubkey_hex ?? null;
+  // Identity rows display npubs derived from the same key the mismatch gate
+  // and recovery actions act on: the account row from the authoritative
+  // bound `pubkey_hex` — the server-sent `npub` is an independent field that
+  // nothing on this path proves encodes the same key — and the device row
+  // from the local key. An unencodable or non-identity-length key renders the
+  // neutral label instead of leaking raw hex or the unverified npub. Both
+  // keys are compared in the one normalized hex form, so a padded or
+  // mixed-case spelling of the same key never reads as a mismatch, and an
+  // npub stored in the hex field is not a key at all.
+  const boundHex = normalizedBoundKeyHex(identity?.pubkey_hex);
+  const localHex = normalizedBoundKeyHex(localPubkey);
+  const localNpub = localHex === null ? null : safeNpub(localHex);
+  const boundNpub = usableBoundIdentityNpub(identity);
+  // The account only drives this flow when its authoritative `pubkey_hex`
+  // normalizes to a hex key: without that key the flow cannot establish
+  // which identity create/connect actions would affect. An identity payload
+  // without a usable authoritative key therefore counts as a mismatch that
+  // requires recovery — never as a linked, ready account.
+  const usableBoundIdentity = boundHex !== null;
   const identityMismatch = Boolean(
     identity &&
-      boundPubkey &&
-      localPubkey &&
-      boundPubkey.toLowerCase() !== localPubkey.toLowerCase(),
+      (!usableBoundIdentity ||
+        (boundHex !== null && localHex !== null && boundHex !== localHex)),
   );
-  const localNpub = localPubkey ? safeNpub(localPubkey) : null;
 
   const switchToDeviceIdentity = () =>
     run("Switching identity…", async () => {
@@ -244,7 +263,12 @@ export function HostedCommunityOnboarding({
   const hasCommunities = activeCommunities.length > 0;
 
   React.useEffect(() => {
-    if (!identity || identityMismatch || !normalizedName || !validName) {
+    if (
+      !usableBoundIdentity ||
+      identityMismatch ||
+      !normalizedName ||
+      !validName
+    ) {
       setCheckingName(false);
       return;
     }
@@ -269,7 +293,7 @@ export function HostedCommunityOnboarding({
       cancelled = true;
       window.clearTimeout(handle);
     };
-  }, [identity, identityMismatch, normalizedName, validName]);
+  }, [normalizedName, validName, usableBoundIdentity, identityMismatch]);
 
   const connect = (community: HostedCommunity, created = false) => {
     const relayUrl = hostedCommunityRelayUrl(community);
@@ -295,7 +319,13 @@ export function HostedCommunityOnboarding({
 
   const create = (event: React.FormEvent) => {
     event.preventDefault();
-    if (!validName || !identity || identityMismatch || atCommunityLimit) return;
+    if (
+      !validName ||
+      !usableBoundIdentity ||
+      identityMismatch ||
+      atCommunityLimit
+    )
+      return;
     void run("Creating community…", async () => {
       const available = await checkHostedCommunityName(normalizedName);
       if (available.error || !available.available) {
@@ -324,9 +354,11 @@ export function HostedCommunityOnboarding({
 
   const busy = action !== null;
   // The account is set up once we're signed in with a linked, matching
-  // identity. Until then the sign-in / link-identity modal drives the flow and
-  // the page behind it shows a blurred preview of where communities will land.
-  const ready = Boolean(auth && identity && !identityMismatch);
+  // identity — and a link is only usable when its authoritative `pubkey_hex`
+  // canonicalizes. Until then the sign-in / link-identity modal drives the
+  // flow and the page behind it shows a blurred preview of where
+  // communities will land.
+  const ready = Boolean(auth && usableBoundIdentity && !identityMismatch);
   const modalOpen = !loading && !ready;
 
   // Tell the parent once sign-in completes so it can reveal the stage page.
@@ -543,9 +575,9 @@ export function HostedCommunityOnboarding({
                 this device, or sign out to use a different email.
               </DialogDescription>
               <p className="mt-4 w-full break-all rounded-xl bg-[rgb(var(--buzz-hosted-community-identity-bg)/0.5)] px-4 py-3 text-left font-mono text-xs text-foreground">
-                Account: {identity.npub ?? boundPubkey}
+                Account: {boundNpub ?? UNAVAILABLE_KEY_LABEL}
                 <br />
-                This device: {localNpub ?? localPubkey}
+                This device: {localNpub ?? UNAVAILABLE_KEY_LABEL}
               </p>
               {errorBox ? <div className="mt-5 w-full">{errorBox}</div> : null}
               <div className="mt-6 flex flex-col items-stretch gap-2">
diff --git a/desktop/src/features/onboarding/ui/MembershipDenied.tsx b/desktop/src/features/onboarding/ui/MembershipDenied.tsx
index 3de6857d31b..4c60a8a4b41 100644
--- a/desktop/src/features/onboarding/ui/MembershipDenied.tsx
+++ b/desktop/src/features/onboarding/ui/MembershipDenied.tsx
@@ -2,7 +2,8 @@ import * as React from "react";
 import { Check, Copy, KeyRound, ShieldX, Ticket } from "lucide-react";
 
 import { useCommunityOnboarding } from "@/features/onboarding/communityOnboarding";
-import { nsecToNpub, pubkeyToNpub } from "@/shared/lib/nostrUtils";
+import { nsecToNpub } from "@/shared/lib/nostrUtils";
+import { canonicalNpub, UNAVAILABLE_KEY_LABEL } from "@/shared/lib/pubkey";
 import { Badge } from "@/shared/ui/badge";
 import { Button } from "@/shared/ui/button";
 import { Input } from "@/shared/ui/input";
@@ -29,17 +30,14 @@ export function MembershipDenied({
   onRetry,
   pubkey,
 }: MembershipDeniedProps) {
-  const npub = React.useMemo(() => {
-    if (!pubkey) {
-      return "Unknown public key";
-    }
-
-    try {
-      return pubkeyToNpub(pubkey);
-    } catch {
-      return pubkey;
-    }
-  }, [pubkey]);
+  // Full canonical npub; an unencodable identity renders the neutral label
+  // (never raw hex) and is never copyable.
+  const identityNpub = React.useMemo(
+    () => (pubkey ? canonicalNpub(pubkey) : null),
+    [pubkey],
+  );
+  const npub =
+    identityNpub ?? (pubkey ? UNAVAILABLE_KEY_LABEL : "Unknown public key");
   const [copied, setCopied] = React.useState(false);
   const [importError, setImportError] = React.useState<string | null>(null);
   const [isImportFormOpen, setIsImportFormOpen] = React.useState(false);
@@ -53,6 +51,7 @@ export function MembershipDenied({
   const communityOnboarding = useCommunityOnboarding();
 
   const handleCopy = React.useCallback(async () => {
+    if (!identityNpub) return;
     try {
       await writeTextToClipboard(npub);
       setCopied(true);
@@ -60,7 +59,7 @@ export function MembershipDenied({
     } catch {
       // Fallback: select the text so the user can copy manually
     }
-  }, [npub]);
+  }, [identityNpub, npub]);
 
   const handleImportKey = React.useCallback(async () => {
     if (!previewNpub) {
@@ -130,6 +129,7 @@ export function MembershipDenied({
               </code>
               <Button
                 className="shrink-0"
+                disabled={!identityNpub}
                 onClick={() => {
                   void handleCopy();
                 }}
diff --git a/desktop/src/features/profile/ui/SelectedRecipientChip.tsx b/desktop/src/features/profile/ui/SelectedRecipientChip.tsx
index f57f4a816e9..fb2adfbb9ee 100644
--- a/desktop/src/features/profile/ui/SelectedRecipientChip.tsx
+++ b/desktop/src/features/profile/ui/SelectedRecipientChip.tsx
@@ -118,9 +118,6 @@ export function SelectedRecipientChip({
               testId={testIds?.pubkey}
               variant="full"
             />
-            <p className="break-all font-mono text-xs text-muted-foreground">
-              {user.pubkey}
-            </p>
           </PopoverContent>
         </Popover>
       ) : (
diff --git a/desktop/src/features/profile/ui/UserProfilePanelFields.tsx b/desktop/src/features/profile/ui/UserProfilePanelFields.tsx
index 9ecdc476a1e..f8ad7701c1d 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelFields.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanelFields.tsx
@@ -11,7 +11,7 @@ import {
 } from "lucide-react";
 import * as React from "react";
 import { AgentStatusBadge } from "@/features/agents/ui/AgentStatusBadge";
-import { truncatePubkey } from "@/shared/lib/pubkey";
+import { canonicalNpub, truncateNpub } from "@/shared/lib/pubkey";
 import {
   HoverCopyIndicator,
   useCopyFeedback,
@@ -164,9 +164,12 @@ export function buildPublicFields({
   const fields: ProfileField[] = [];
 
   if (pubkey) {
+    const npub = canonicalNpub(pubkey);
     fields.push({
-      copyValue: pubkey,
-      displayValue: truncatePubkey(pubkey),
+      // Copy the full canonical npub; an identity that cannot be encoded is
+      // never copyable.
+      copyValue: npub ?? undefined,
+      displayValue: truncateNpub(pubkey),
       displayNode: (
         <PubKey
           interactive={false}
@@ -260,12 +263,18 @@ export function buildOwnerFields({
     : null;
 
   const ownerClickable = Boolean(onOpenProfile && ownerProfilePubkey);
+  // Non-clickable owner rows copy the owner's full npub (handle only when no
+  // key is known); an unencodable owner key copies nothing.
+  const ownerCopyKey = ownerProfilePubkey ?? ownerPubkey;
+  const ownerCopyValue = ownerClickable
+    ? undefined
+    : ownerCopyKey
+      ? (canonicalNpub(ownerCopyKey) ?? undefined)
+      : (ownerHandle ?? undefined);
 
   if (ownerDisplayName) {
     fields.push({
-      copyValue: ownerClickable
-        ? undefined
-        : (ownerProfilePubkey ?? ownerPubkey ?? ownerHandle ?? undefined),
+      copyValue: ownerCopyValue,
       displayValue: ownerDisplayName,
       displayNode: <span className="truncate">{ownerDisplayName}</span>,
       icon: UserRound,
@@ -308,7 +317,7 @@ export function buildOwnerFields({
     });
   } else if (ownerPubkey) {
     fields.push({
-      copyValue: ownerPubkey,
+      copyValue: canonicalNpub(ownerPubkey) ?? undefined,
       displayValue: "Declared owner verified",
       icon: UserRound,
       label: "Agent profile",
diff --git a/desktop/src/features/settings/ui/HostedCommunitiesSettingsCard.tsx b/desktop/src/features/settings/ui/HostedCommunitiesSettingsCard.tsx
index 74c9dcc9ecd..a9097671c06 100644
--- a/desktop/src/features/settings/ui/HostedCommunitiesSettingsCard.tsx
+++ b/desktop/src/features/settings/ui/HostedCommunitiesSettingsCard.tsx
@@ -19,6 +19,8 @@ import {
   HOSTED_COMMUNITY_SUFFIX as HOST_SUFFIX,
   hostedCommunityErrorMessage as errorMessage,
   hostedCommunityRelayUrl as relayUrl,
+  normalizedBoundKeyHex,
+  usableBoundIdentityNpub,
   type BuilderlabAuth,
   type HostedCommunityAvailabilityResponse as AvailabilityResponse,
   type HostedCommunitiesResponse as CommunitiesResponse,
@@ -30,8 +32,9 @@ import {
 } from "@/features/communities/hostedCommunityApi";
 import { CommunityIconSettingsCard } from "@/features/communities/ui/CommunityIconSettingsCard";
 import { useCommunities } from "@/features/communities/useCommunities";
-import { safeNpub } from "@/shared/lib/nostrUtils";
 import { useCommunityOnboarding } from "@/features/onboarding/communityOnboarding";
+import { safeNpub } from "@/shared/lib/nostrUtils";
+import { UNAVAILABLE_KEY_LABEL } from "@/shared/lib/pubkey";
 import {
   AlertDialog,
   AlertDialogAction,
@@ -205,15 +208,33 @@ export function HostedCommunitiesSettingsCard() {
   // to a different test identity). When that happens the community list and
   // Connect buttons operate on the *bound* npub's communities, so "Connect"
   // would drop you into a relay your local key isn't a member of. Detect it and
-  // block Connect + Create until the identities match.
-  const boundPubkey = identity?.pubkey_hex ?? null;
+  // block Connect + Create until the identities match. Both keys are compared
+  // in the one normalized hex form, so a padded or mixed-case spelling of
+  // the same key never reads as a mismatch, and an npub stored in the hex
+  // field is not a key at all.
+  // Identity rows display npubs; an unencodable or non-identity-length key
+  // renders the neutral label instead of leaking raw hex. The account's
+  // `pubkey_hex` is the authoritative binding key — the mismatch gate and
+  // every hosted-community operation act on it — so the displayed account
+  // npub is derived from it, not from the server-provided `npub` spelling.
+  // Nothing on this path proves the two fields encode the same key, and two
+  // individually valid but contradictory values must never make the screen
+  // show one identity while binding decisions act on another.
+  const boundHex = normalizedBoundKeyHex(identity?.pubkey_hex);
+  const localHex = normalizedBoundKeyHex(localPubkey);
+  const localNpub = localHex === null ? null : safeNpub(localHex);
+  const boundNpub = usableBoundIdentityNpub(identity);
+  // The account is only usable here when its authoritative `pubkey_hex`
+  // normalizes to a hex key: without that key this card cannot establish
+  // which identity the connected claim, Connect, and Create actions affect.
+  // An identity payload without a usable authoritative key therefore counts
+  // as a mismatch that requires recovery — never as a connected account.
+  const usableBoundIdentity = boundHex !== null;
   const identityMismatch = Boolean(
     identity &&
-      boundPubkey &&
-      localPubkey &&
-      boundPubkey.toLowerCase() !== localPubkey.toLowerCase(),
+      (!usableBoundIdentity ||
+        (boundHex !== null && localHex !== null && boundHex !== localHex)),
   );
-  const localNpub = localPubkey ? safeNpub(localPubkey) : null;
 
   const switchToDeviceIdentity = () =>
     run("Switching identity…", async () => {
@@ -324,7 +345,12 @@ export function HostedCommunitiesSettingsCard() {
   // Create (no separate "check" click). onChange clears the previous result, so
   // the indicator reflects the current input while typing.
   React.useEffect(() => {
-    if (!identity || identityMismatch || !normalizedName || !validName) {
+    if (
+      !usableBoundIdentity ||
+      identityMismatch ||
+      !normalizedName ||
+      !validName
+    ) {
       setCheckingName(false);
       return;
     }
@@ -352,13 +378,13 @@ export function HostedCommunitiesSettingsCard() {
       cancelled = true;
       window.clearTimeout(handle);
     };
-  }, [normalizedName, validName, identity, identityMismatch]);
+  }, [normalizedName, validName, usableBoundIdentity, identityMismatch]);
 
   const createCommunity = (event: React.FormEvent) => {
     event.preventDefault();
     if (
       !validName ||
-      !identity ||
+      !usableBoundIdentity ||
       identityMismatch ||
       communities.length >= MAX_COMMUNITIES
     )
@@ -522,12 +548,14 @@ export function HostedCommunitiesSettingsCard() {
                     <div className="flex flex-wrap gap-x-2">
                       <dt className="text-muted-foreground">Account uses</dt>
                       <dd className="font-mono">
-                        {identity.npub ?? boundPubkey}
+                        {boundNpub ?? UNAVAILABLE_KEY_LABEL}
                       </dd>
                     </div>
                     <div className="flex flex-wrap gap-x-2">
                       <dt className="text-muted-foreground">This device</dt>
-                      <dd className="font-mono">{localNpub ?? localPubkey}</dd>
+                      <dd className="font-mono">
+                        {localNpub ?? UNAVAILABLE_KEY_LABEL}
+                      </dd>
                     </div>
                   </dl>
                 </div>
@@ -548,8 +576,8 @@ export function HostedCommunitiesSettingsCard() {
               <div className="flex items-center gap-2 text-sm text-muted-foreground">
                 <CheckCircle2 className="h-4 w-4 text-emerald-500" /> Buzz
                 identity connected
-                {identity.npub ? (
-                  <span className="font-mono text-xs">{identity.npub}</span>
+                {boundNpub ? (
+                  <span className="font-mono text-xs">{boundNpub}</span>
                 ) : null}
               </div>
               <UnpairIdentityButton
@@ -593,12 +621,20 @@ export function HostedCommunitiesSettingsCard() {
                       key={community.id ?? community.normalized_host ?? index}
                       community={community}
                       busy={busy}
-                      canConnect={!identityMismatch}
+                      canConnect={usableBoundIdentity && !identityMismatch}
                       showIconPicker={
                         relayHost(relayUrl(community)) ===
                         relayHost(activeCommunity?.relayUrl)
                       }
                       onConnect={() => {
+                        // Invocation guard: the Connect affordance only
+                        // renders for a usable, matching binding, but this
+                        // callback is the last gate — a click that lands after
+                        // a refresh returned an absent or unusable identity
+                        // must not start onboarding either.
+                        if (!usableBoundIdentity || identityMismatch) {
+                          return;
+                        }
                         const url = relayUrl(community);
                         if (url)
                           onboarding.start({
@@ -641,7 +677,10 @@ export function HostedCommunitiesSettingsCard() {
                 aria-label="Community address"
                 autoComplete="off"
                 disabled={
-                  !identity || identityMismatch || busy || atCommunityLimit
+                  !usableBoundIdentity ||
+                  identityMismatch ||
+                  busy ||
+                  atCommunityLimit
                 }
                 maxLength={63}
                 onChange={(event) => {
@@ -675,7 +714,7 @@ export function HostedCommunitiesSettingsCard() {
             ) : null}
             <Button
               disabled={
-                !identity ||
+                !usableBoundIdentity ||
                 identityMismatch ||
                 !validName ||
                 availability === false ||
diff --git a/desktop/src/features/settings/ui/ProfileSettingsCard.tsx b/desktop/src/features/settings/ui/ProfileSettingsCard.tsx
index 64af0f3410a..b2aa03c0418 100644
--- a/desktop/src/features/settings/ui/ProfileSettingsCard.tsx
+++ b/desktop/src/features/settings/ui/ProfileSettingsCard.tsx
@@ -30,6 +30,7 @@ import {
 import { SettingsSectionHeader } from "./SettingsSectionHeader";
 import { SignOutSection } from "./SignOutSection";
 import { writeTextToClipboard } from "@/shared/lib/clipboard";
+import { canonicalNpub, UNAVAILABLE_KEY_LABEL } from "@/shared/lib/pubkey";
 
 type ProfileSettingsCardProps = {
   currentPubkey?: string;
@@ -302,7 +303,10 @@ export function ProfileSettingsCard({
     profile?.displayName ||
     fallbackDisplayName ||
     "Your profile";
-  const resolvedPubkey = profile?.pubkey ?? currentPubkey ?? "Unavailable";
+  // Identity details show and copy the full canonical npub; a key that
+  // cannot be encoded renders the neutral label and is never copyable.
+  const identityNpub = canonicalNpub(profile?.pubkey ?? currentPubkey ?? "");
+  const resolvedPubkey = identityNpub ?? UNAVAILABLE_KEY_LABEL;
   const nip05Handle = profile?.nip05Handle ?? "Not set";
   const emojiAvatarPreview = React.useMemo(
     () => parseEmojiAvatarDataUrl(avatarUrlDraft),
@@ -786,9 +790,7 @@ export function ProfileSettingsCard({
                               data-testid="profile-identity-details"
                             >
                               <IdentityRow
-                                copyValue={
-                                  profile?.pubkey ?? currentPubkey ?? undefined
-                                }
+                                copyValue={identityNpub ?? undefined}
                                 label="Public key"
                                 testId="profile-pubkey"
                                 value={resolvedPubkey}
diff --git a/desktop/src/features/workflows/ui/WorkflowStepCard.tsx b/desktop/src/features/workflows/ui/WorkflowStepCard.tsx
index 539edf2ba93..0e17ba544ee 100644
--- a/desktop/src/features/workflows/ui/WorkflowStepCard.tsx
+++ b/desktop/src/features/workflows/ui/WorkflowStepCard.tsx
@@ -218,7 +218,7 @@ function StepConfigFields({
               onChange={(event) =>
                 onUpdate({ ...step, to: event.target.value })
               }
-              placeholder="e.g. {{trigger.author}} or hex pubkey"
+              placeholder="e.g. {{trigger.author}}, npub1…, or hex pubkey"
               value={step.to ?? ""}
             />
           </div>
@@ -311,7 +311,7 @@ function StepConfigFields({
               onChange={(event) =>
                 onUpdate({ ...step, from: event.target.value })
               }
-              placeholder="Pubkey or role"
+              placeholder="npub1…, hex pubkey, or role"
               value={step.from ?? ""}
             />
           </div>
diff --git a/desktop/src/features/workflows/ui/workflowFormTypes.test.mjs b/desktop/src/features/workflows/ui/workflowFormTypes.test.mjs
index 958b276420c..0d974e5457d 100644
--- a/desktop/src/features/workflows/ui/workflowFormTypes.test.mjs
+++ b/desktop/src/features/workflows/ui/workflowFormTypes.test.mjs
@@ -315,3 +315,74 @@ test("absent reply_in_thread parses as false", () => {
   assert.equal(parsed.ok, true);
   assert.equal(parsed.state.steps[0].replyInThread, false);
 });
+
+// Handoff vectors, round-trip verified with nostr-tools nip19.
+const KEY_HEX =
+  "ea9b4d7a7a78a3e3729e5568b14d764d4962be0e1f20f749bcf8d9dbbf9a9328";
+const KEY_NPUB =
+  "npub1a2d567n60z37xu57245tzntkf4yk90swrus0wjdulrvah0u6jv5qusyp60";
+
+test("stored hex to/from keys display as npubs in the form", () => {
+  const parsed = yamlToFormState(
+    `name: Keys
+trigger: { on: message_posted }
+steps: [{ id: s1, action: send_dm, to: ${KEY_HEX}, text: hi }, { id: s2, action: request_approval, from: ${KEY_HEX}, message: ok }]
+`,
+  );
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.state.steps[0].to, KEY_NPUB);
+  assert.equal(parsed.state.steps[1].from, KEY_NPUB);
+});
+
+test("npub to/from keys serialize to canonical hex; other spellings pass through", () => {
+  const dm = formStateToYaml({
+    ...DEFAULT_FORM_STATE,
+    name: "Keys",
+    steps: [{ id: "s1", action: "send_dm", to: KEY_NPUB, text: "hi" }],
+  });
+  assert.match(dm, new RegExp(`to: ${KEY_HEX}`));
+  assert.doesNotMatch(dm, /npub1/);
+
+  const approval = formStateToYaml({
+    ...DEFAULT_FORM_STATE,
+    name: "Keys",
+    steps: [
+      { id: "s1", action: "request_approval", from: KEY_NPUB, message: "ok" },
+    ],
+  });
+  assert.match(approval, new RegExp(`from: ${KEY_HEX}`));
+
+  // A hex spelling serializes unchanged, and a corrupted-checksum npub is
+  // never bound as an identity — it stays exactly as the author wrote it
+  // for the YAML editor to surface.
+  const hexDm = formStateToYaml({
+    ...DEFAULT_FORM_STATE,
+    name: "Keys",
+    steps: [{ id: "s1", action: "send_dm", to: KEY_HEX, text: "hi" }],
+  });
+  assert.match(hexDm, new RegExp(`to: ${KEY_HEX}`));
+
+  const corrupt = `${KEY_NPUB.slice(0, -2)}qq`;
+  const corruptDm = formStateToYaml({
+    ...DEFAULT_FORM_STATE,
+    name: "Keys",
+    steps: [{ id: "s1", action: "send_dm", to: corrupt, text: "hi" }],
+  });
+  assert.match(corruptDm, new RegExp(`to: ${corrupt.replace(/\./g, "\\.")}`));
+});
+
+test("templates and roles pass through both directions untouched", () => {
+  const parsed = yamlToFormState(
+    `name: Keys
+trigger: { on: message_posted }
+steps: [{ id: s1, action: send_dm, to: "{{trigger.author}}", text: hi }, { id: s2, action: request_approval, from: manager, message: ok }]
+`,
+  );
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.state.steps[0].to, "{{trigger.author}}");
+  assert.equal(parsed.state.steps[1].from, "manager");
+
+  const reserialized = formStateToYaml(parsed.state);
+  assert.match(reserialized, /to: "\{\{trigger\.author\}\}"/);
+  assert.match(reserialized, /from: manager/);
+});
diff --git a/desktop/src/features/workflows/ui/workflowFormTypes.ts b/desktop/src/features/workflows/ui/workflowFormTypes.ts
index 345f7c71343..4340c295bd8 100644
--- a/desktop/src/features/workflows/ui/workflowFormTypes.ts
+++ b/desktop/src/features/workflows/ui/workflowFormTypes.ts
@@ -1,5 +1,10 @@
 import { stringify as yamlStringify, parse as yamlParse } from "yaml";
 
+import {
+  parsePubkeyInput as parseCanonicalPubkey,
+  safeNpub,
+} from "@/shared/lib/nostrUtils";
+
 import { cronExpressionError } from "./cronExpression";
 import {
   formatDurationSeconds,
@@ -116,6 +121,29 @@ export const ACTION_LABELS: Record<ActionType, string> = {
   set_channel_topic: "Set Channel Topic",
 };
 
+const EXACT_HEX_64 = /^[0-9a-fA-F]{64}$/;
+
+/**
+ * Display form of a DM recipient (`to`) or approver (`from`): an exact 64-char
+ * hex pubkey from stored YAML is shown as its npub; npubs, templates
+ * (`{{trigger.author}}`), roles, and any other free text pass through
+ * unchanged. Encoding failures (non-canonical hex) keep the stored value.
+ */
+function keyDisplayValue(value: string | undefined): string | undefined {
+  if (value === undefined || !EXACT_HEX_64.test(value)) return value;
+  return safeNpub(value.toLowerCase()) ?? value;
+}
+
+/**
+ * Storage form: an exact npub decodes back to the canonical hex pubkey so the
+ * wire YAML keeps its machine-readable hex contract. Hex, templates, roles,
+ * and any other free text pass through unchanged.
+ */
+function keyStorageValue(value: string): string {
+  if (!value.trim().toLowerCase().startsWith("npub1")) return value;
+  return parseCanonicalPubkey(value) ?? value;
+}
+
 function toHeaderRows(
   headers: unknown,
   stepId: string,
@@ -169,7 +197,7 @@ function actionFieldsForStep(step: StepFormState): Record<string, unknown> {
       if (step.replyInThread) fields.reply_in_thread = true;
       break;
     case "send_dm":
-      if (step.to) fields.to = step.to;
+      if (step.to) fields.to = keyStorageValue(step.to);
       if (step.text) fields.text = step.text;
       break;
     case "call_webhook":
@@ -182,7 +210,7 @@ function actionFieldsForStep(step: StepFormState): Record<string, unknown> {
       if (step.body) fields.body = step.body;
       break;
     case "request_approval":
-      if (step.from) fields.from = step.from;
+      if (step.from) fields.from = keyStorageValue(step.from);
       if (step.message) fields.message = step.message;
       if (step.timeout) fields.timeout = step.timeout;
       break;
@@ -624,14 +652,14 @@ export function yamlToFormState(
         text: step.text as string | undefined,
         channel: step.channel as string | undefined,
         replyInThread: step.reply_in_thread === true,
-        to: step.to as string | undefined,
+        to: keyDisplayValue(step.to as string | undefined),
         url: step.url as string | undefined,
         method: step.method as string | undefined,
         headers: toHeaderRows(step.headers, step.id),
         body: step.body as string | undefined,
         emoji: step.emoji as string | undefined,
         topic: step.topic as string | undefined,
-        from: step.from as string | undefined,
+        from: keyDisplayValue(step.from as string | undefined),
         message: step.message as string | undefined,
         timeout: step.timeout as string | undefined,
       });
diff --git a/desktop/tests/e2e/add-community-screenshots.spec.ts b/desktop/tests/e2e/add-community-screenshots.spec.ts
index 389e182e74f..3f1e332b090 100644
--- a/desktop/tests/e2e/add-community-screenshots.spec.ts
+++ b/desktop/tests/e2e/add-community-screenshots.spec.ts
@@ -1,4 +1,5 @@
-import { test } from "@playwright/test";
+import { expect, test } from "@playwright/test";
+import { npubEncode } from "nostr-tools/nip19";
 
 import { waitForAnimations } from "../helpers/animations";
 import { installMockBridge } from "../helpers/bridge";
@@ -45,6 +46,78 @@ test.beforeEach(async ({ page }) => {
   await page.getByTestId("community-rail-add").click();
 });
 
+test("identity: npub-only account key is recovery, never a ready create flow", async ({
+  page,
+}) => {
+  await installMockBridge(
+    page,
+    {
+      builderlabAuth: {
+        email: "old-owner@example.com",
+        expiresAt: "2099-01-01T00:00:00Z",
+      },
+      builderlabIdentity: {
+        // The identity object is present but carries no authoritative
+        // pubkey_hex — only the independent, unverified server npub.
+        npub: npubEncode("b".repeat(64)),
+      },
+    },
+    { skipCommunitySeed: true },
+  );
+  await page.reload();
+  await page.getByTestId("community-rail-add").click();
+  await page.getByTestId("add-community-create").click();
+  // Presence of the identity object must not read as a ready account: the
+  // mismatch recovery branch owns the create tab instead.
+  await expect(
+    page.getByText("This Builderlab account uses a different Buzz identity."),
+  ).toBeVisible();
+  await expect(page.getByText("Account: Unavailable")).toBeVisible();
+  await expect(
+    page.getByText(`This device: ${npubEncode(DEFAULT_MOCK_PUBKEY)}`),
+  ).toBeVisible();
+  // The create form — and with it the create action — stays unrendered.
+  await expect(page.getByTestId("hosted-community-create-name")).toHaveCount(0);
+  await expect(page.getByTestId("hosted-community-create-submit")).toHaveCount(
+    0,
+  );
+  // The unverified hosted npub spelling never renders.
+  await expect(page.getByText(npubEncode("b".repeat(64)))).toHaveCount(0);
+  // Recovery stays explicit.
+  await expect(
+    page.getByRole("button", { name: "Use this device" }),
+  ).toBeVisible();
+});
+
+test("identity: padded same-key hex is a ready create flow, not a mismatch", async ({
+  page,
+}) => {
+  await installMockBridge(
+    page,
+    {
+      builderlabAuth: {
+        email: "owner@example.com",
+        expiresAt: "2099-01-01T00:00:00Z",
+      },
+      builderlabIdentity: {
+        // This device's own key, padded and uppercased: the same key
+        // after normalization, so the account is ready — never a mismatch
+        // demanding a delete/rebind of the identity it already holds.
+        pubkey_hex: `  ${DEFAULT_MOCK_PUBKEY.toUpperCase()}  `,
+      },
+    },
+    { skipCommunitySeed: true },
+  );
+  await page.reload();
+  await page.getByTestId("community-rail-add").click();
+  await page.getByTestId("add-community-create").click();
+  // The create form — and with it the create action — is available.
+  await expect(page.getByTestId("hosted-community-create-name")).toBeVisible();
+  await expect(
+    page.getByText("This Builderlab account uses a different Buzz identity."),
+  ).toHaveCount(0);
+});
+
 test("capture: add-community choices", async ({ page }) => {
   const dialog = page.getByTestId("add-community-dialog");
   await dialog.waitFor();
@@ -71,3 +144,65 @@ test("capture: create a new community", async ({ page }) => {
   await waitForAnimations(page);
   await dialog.screenshot({ path: `${OUTDIR}/03-create.png` });
 });
+
+test("identity: create owner shows the bound key's npub, never the hosted npub or raw hex", async ({
+  page,
+}) => {
+  await installMockBridge(
+    page,
+    {
+      builderlabAuth: {
+        email: "old-owner@example.com",
+        expiresAt: "2099-01-01T00:00:00Z",
+      },
+      builderlabIdentity: {
+        pubkey_hex: "f".repeat(64),
+        npub: npubEncode("b".repeat(64)),
+      },
+    },
+    { skipCommunitySeed: true },
+  );
+  await page.reload();
+  await page.getByTestId("community-rail-add").click();
+  await page.getByTestId("add-community-create").click();
+  await expect(
+    page.getByText("This Builderlab account uses a different Buzz identity."),
+  ).toBeVisible();
+  await expect(
+    page.getByText(`Account: ${npubEncode("f".repeat(64))}`),
+  ).toBeVisible();
+  await expect(
+    page.getByText(`This device: ${npubEncode(DEFAULT_MOCK_PUBKEY)}`),
+  ).toBeVisible();
+  await expect(page.getByText(npubEncode("b".repeat(64)))).toHaveCount(0);
+  await expect(page.getByText("f".repeat(64))).toHaveCount(0);
+});
+
+test("identity: create owner renders the neutral label when the bound hex is unusable", async ({
+  page,
+}) => {
+  await installMockBridge(
+    page,
+    {
+      builderlabAuth: {
+        email: "old-owner@example.com",
+        expiresAt: "2099-01-01T00:00:00Z",
+      },
+      builderlabIdentity: {
+        // Valid hex alphabet, wrong length — unusable as an identity key.
+        pubkey_hex: "f".repeat(63),
+        npub: npubEncode("b".repeat(64)),
+      },
+    },
+    { skipCommunitySeed: true },
+  );
+  await page.reload();
+  await page.getByTestId("community-rail-add").click();
+  await page.getByTestId("add-community-create").click();
+  await expect(
+    page.getByText("This Builderlab account uses a different Buzz identity."),
+  ).toBeVisible();
+  await expect(page.getByText("Account: Unavailable")).toBeVisible();
+  await expect(page.getByText(npubEncode("b".repeat(64)))).toHaveCount(0);
+  await expect(page.getByText("f".repeat(63))).toHaveCount(0);
+});
diff --git a/desktop/tests/e2e/hosted-communities-settings-screenshots.spec.ts b/desktop/tests/e2e/hosted-communities-settings-screenshots.spec.ts
index 3ec6dc01c38..40ea5fd3703 100644
--- a/desktop/tests/e2e/hosted-communities-settings-screenshots.spec.ts
+++ b/desktop/tests/e2e/hosted-communities-settings-screenshots.spec.ts
@@ -1,4 +1,5 @@
-import { expect, test } from "@playwright/test";
+import { expect, test, type Page } from "@playwright/test";
+import { npubEncode } from "nostr-tools/nip19";
 
 import { waitForAnimations } from "../helpers/animations";
 import { installMockBridge } from "../helpers/bridge";
@@ -6,14 +7,28 @@ import { openSettings } from "../helpers/settings";
 
 const OUTDIR = "test-results/hosted-communities";
 const DEFAULT_MOCK_PUBKEY = "deadbeef".repeat(8);
+/** A second valid identity key, used only as a contradictory hosted npub. */
+const OTHER_HEX = "b".repeat(64);
 
-test.beforeEach(async ({ page }) => {
+/**
+ * Install the default hosted-communities fixture and open its settings
+ * section. `builderlabIdentity` overrides the bound account identity so a
+ * spec can drive independent — even contradictory — `pubkey_hex`/`npub`
+ * fields; the mock bridge passes both through verbatim, like the native
+ * command.
+ */
+async function openHostedCommunitiesSettings(
+  page: Page,
+  builderlabIdentity?: { npub?: string; pubkey_hex?: string } | null,
+) {
   await installMockBridge(page, {
     builderlabAuth: {
       email: "owner@example.com",
       expiresAt: "2099-01-01T00:00:00Z",
     },
-    builderlabIdentity: { pubkey_hex: DEFAULT_MOCK_PUBKEY },
+    builderlabIdentity: builderlabIdentity ?? {
+      pubkey_hex: DEFAULT_MOCK_PUBKEY,
+    },
     builderlabCommunities: [
       {
         id: "active-community",
@@ -29,8 +44,210 @@ test.beforeEach(async ({ page }) => {
   });
   await page.goto("/");
   await openSettings(page, "hosted-communities");
+}
+
+test.beforeEach(async ({ page }) => {
+  await openHostedCommunitiesSettings(page);
+});
+
+test("identity: mismatch rows follow pubkey_hex, never the hosted npub or raw hex", async ({
+  page,
+}) => {
+  await openHostedCommunitiesSettings(page, {
+    pubkey_hex: "f".repeat(64),
+    npub: npubEncode(OTHER_HEX),
+  });
+
+  await expect(
+    page.getByText("This account is connected to a different Buzz identity"),
+  ).toBeVisible();
+  const settingsView = page.getByTestId("settings-view");
+  await expect(
+    page
+      .getByText("Account uses", { exact: true })
+      .locator("xpath=following-sibling::dd[1]"),
+  ).toHaveText(npubEncode("f".repeat(64)));
+  await expect(
+    page
+      .getByText("This device", { exact: true })
+      .locator("xpath=following-sibling::dd[1]"),
+  ).toHaveText(npubEncode(DEFAULT_MOCK_PUBKEY));
+  // The independently valid but contradictory hosted npub, and the raw hex
+  // it would stand in for, must never render.
+  await expect(settingsView.getByText(npubEncode(OTHER_HEX))).toHaveCount(0);
+  await expect(settingsView.getByText("f".repeat(64))).toHaveCount(0);
+});
+
+test("identity: connected row follows pubkey_hex when the hosted npub encodes another key", async ({
+  page,
+}) => {
+  await openHostedCommunitiesSettings(page, {
+    pubkey_hex: DEFAULT_MOCK_PUBKEY,
+    npub: npubEncode(OTHER_HEX),
+  });
+
+  const connectedNpub = page
+    .getByText("Buzz identity connected")
+    .locator("span.font-mono");
+  await expect(connectedNpub).toHaveText(npubEncode(DEFAULT_MOCK_PUBKEY));
+  await expect(
+    page.getByTestId("settings-view").getByText(npubEncode(OTHER_HEX)),
+  ).toHaveCount(0);
+});
+
+test("identity: unusable bound hex renders the neutral label, not the hosted npub or raw hex", async ({
+  page,
+}) => {
+  await openHostedCommunitiesSettings(page, {
+    // Valid hex alphabet, wrong length — unusable as an identity key.
+    pubkey_hex: "f".repeat(63),
+    npub: npubEncode(OTHER_HEX),
+  });
+
+  await expect(
+    page.getByText("This account is connected to a different Buzz identity"),
+  ).toBeVisible();
+  const settingsView = page.getByTestId("settings-view");
+  await expect(
+    page
+      .getByText("Account uses", { exact: true })
+      .locator("xpath=following-sibling::dd[1]"),
+  ).toHaveText("Unavailable");
+  await expect(settingsView.getByText(npubEncode(OTHER_HEX))).toHaveCount(0);
+  await expect(settingsView.getByText("f".repeat(63))).toHaveCount(0);
+});
+
+test("identity: consistent hosted identity renders its canonical npub", async ({
+  page,
+}) => {
+  await openHostedCommunitiesSettings(page, {
+    pubkey_hex: DEFAULT_MOCK_PUBKEY,
+    npub: npubEncode(DEFAULT_MOCK_PUBKEY),
+  });
+
+  const connectedNpub = page
+    .getByText("Buzz identity connected")
+    .locator("span.font-mono");
+  await expect(connectedNpub).toHaveText(npubEncode(DEFAULT_MOCK_PUBKEY));
+});
+
+test("identity: unlinked account offers linking, never a connected claim", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    builderlabAuth: {
+      email: "owner@example.com",
+      expiresAt: "2099-01-01T00:00:00Z",
+    },
+    // No identity object at all: the account has not linked a Buzz key.
+    builderlabIdentity: null,
+    builderlabCommunities: [
+      {
+        id: "active-community",
+        name: "E2E Test",
+        normalized_host: "localhost:3000",
+      },
+    ],
+  });
+  await page.goto("/");
+  await openSettings(page, "hosted-communities");
+
+  await expect(
+    page.getByText("Link this account to your Buzz identity"),
+  ).toBeVisible();
+  await expect(page.getByText("Buzz identity connected")).toHaveCount(0);
+  // The seeded owned community still lists — every affordance that does
+  // not act on the binding stays available — but Connect is an action on
+  // the binding and cannot occur without a usable bound key: no row
+  // affordance, and no onboarding it could start.
+  await expect(page.getByTestId("hosted-community-row")).toHaveCount(1);
+  await expect(
+    page.getByRole("button", { name: "Connect", exact: true }),
+  ).toHaveCount(0);
+  // Creation stays unavailable: there is no authoritative key to bind the
+  // new community to.
+  await expect(page.getByLabel("Community address")).toBeDisabled();
+  await expect(
+    page.getByRole("button", { name: "Create and connect", exact: true }),
+  ).toBeDisabled();
+});
+
+test("identity: padded or mixed-case bound hex is the same key, not a mismatch", async ({
+  page,
+}) => {
+  await openHostedCommunitiesSettings(page, {
+    // The same key this device signs with, padded and uppercased. It
+    // normalizes to the local key on both sides of the comparison — never
+    // a mismatch demanding delete/rebind of an identity the device already
+    // holds.
+    pubkey_hex: `  ${DEFAULT_MOCK_PUBKEY.toUpperCase()}  `,
+  });
+
+  await expect(
+    page.getByText("This account is connected to a different Buzz identity"),
+  ).toHaveCount(0);
+  const connectedNpub = page
+    .getByText("Buzz identity connected")
+    .locator("span.font-mono");
+  await expect(connectedNpub).toHaveText(npubEncode(DEFAULT_MOCK_PUBKEY));
+  // A binding that is the same key after normalization keeps its Connect
+  // affordance — recovery is reserved for a binding that actually differs.
+  await expect(
+    page.getByRole("button", { name: "Connect", exact: true }).first(),
+  ).toBeVisible();
 });
 
+/**
+ * Identity payloads whose authoritative `pubkey_hex` cannot act as a key.
+ * Each is an identity *object* — so presence alone must never read as a
+ * connected, ready account — yet none carries a key the app can use.
+ */
+const UNUSABLE_BOUND_KEY_PAYLOADS: Array<
+  [label: string, payload: { npub?: string; pubkey_hex?: string }]
+> = [
+  ["missing key", {}],
+  ["non-hex key", { pubkey_hex: "zz".repeat(32) }],
+  ["npub-only key", { npub: npubEncode(OTHER_HEX) }],
+  // A checksum-valid npub stored in the hex field itself is not a hex
+  // key: it must fail closed like any other unusable spelling, never
+  // display as the account's authoritative key, and never read as a
+  // usable binding when the local comparison is skipped.
+  ["npub stored in the hex field", { pubkey_hex: npubEncode(OTHER_HEX) }],
+];
+
+for (const [label, payload] of UNUSABLE_BOUND_KEY_PAYLOADS) {
+  test(`identity: ${label} is recovery, never a connected account or actions`, async ({
+    page,
+  }) => {
+    await openHostedCommunitiesSettings(page, payload);
+
+    const settingsView = page.getByTestId("settings-view");
+    // No connected claim anywhere on the surface, despite the identity
+    // object being present.
+    await expect(page.getByText("Buzz identity connected")).toHaveCount(0);
+    // The mismatch recovery block owns the identity panel instead.
+    await expect(
+      page.getByText("This account is connected to a different Buzz identity"),
+    ).toBeVisible();
+    await expect(
+      page
+        .getByText("Account uses", { exact: true })
+        .locator("xpath=following-sibling::dd[1]"),
+    ).toHaveText("Unavailable");
+    // The unverified server-sent npub spelling never renders.
+    await expect(settingsView.getByText(npubEncode(OTHER_HEX))).toHaveCount(0);
+    // Connect stays unavailable for every owned community.
+    await expect(
+      page.getByRole("button", { name: "Connect", exact: true }),
+    ).toHaveCount(0);
+    // Creation stays unavailable: no key the new community would bind to.
+    await expect(page.getByLabel("Community address")).toBeDisabled();
+    await expect(
+      page.getByRole("button", { name: "Create and connect", exact: true }),
+    ).toBeDisabled();
+  });
+}
+
 test("capture: community icon picker sits beside its hosted community", async ({
   page,
 }) => {
diff --git a/desktop/tests/e2e/onboarding.spec.ts b/desktop/tests/e2e/onboarding.spec.ts
index 87a283e49af..eba3b099316 100644
--- a/desktop/tests/e2e/onboarding.spec.ts
+++ b/desktop/tests/e2e/onboarding.spec.ts
@@ -1,6 +1,6 @@
 import { hexToBytes } from "@noble/hashes/utils.js";
 import { expect, test, type Page } from "@playwright/test";
-import { nsecEncode } from "nostr-tools/nip19";
+import { nsecEncode, npubEncode } from "nostr-tools/nip19";
 
 import {
   installMockBridge,
@@ -1482,7 +1482,12 @@ test("first-community owner can replace a mismatched account identity", async ({
         email: "old-owner@example.com",
         expiresAt: "2099-01-01T00:00:00Z",
       },
-      builderlabIdentity: { pubkey_hex: "f".repeat(64) },
+      builderlabIdentity: {
+        pubkey_hex: "f".repeat(64),
+        // Contradiction: the server npub spells this device's key, not the
+        // bound pubkey_hex the mismatch gate and recovery actions use.
+        npub: npubEncode(BLANK_TYLER_IDENTITY.pubkey),
+      },
     },
     {
       relayWsUrl: "ws://localhost:3000",
@@ -1498,6 +1503,19 @@ test("first-community owner can replace a mismatched account identity", async ({
       name: "This account uses a different Buzz identity",
     }),
   ).toBeVisible();
+  // The account row must show the authoritative bound key's npub, never the
+  // contradictory hosted npub (which here spells the device key) or raw hex.
+  const identityRows = page.getByText(/^Account: npub1/);
+  await expect(identityRows).toContainText(
+    `Account: ${npubEncode("f".repeat(64))}`,
+  );
+  await expect(identityRows).toContainText(
+    `This device: ${npubEncode(BLANK_TYLER_IDENTITY.pubkey)}`,
+  );
+  await expect(identityRows).not.toContainText(
+    `Account: ${npubEncode(BLANK_TYLER_IDENTITY.pubkey)}`,
+  );
+  await expect(page.getByText("f".repeat(64))).toHaveCount(0);
   await page
     .getByRole("button", { name: "Use this device's identity" })
     .click();
@@ -1514,6 +1532,190 @@ test("first-community owner can replace a mismatched account identity", async ({
     );
 });
 
+test("first-community owner recovers from an npub-only account identity", async ({
+  page,
+}) => {
+  await seedActiveIdentity(page, BLANK_TYLER_IDENTITY);
+  await page.addInitScript((pubkey) => {
+    window.localStorage.setItem(
+      `buzz-machine-onboarding-complete.v2:${pubkey}`,
+      "true",
+    );
+  }, BLANK_TYLER_IDENTITY.pubkey);
+  await installMockBridge(
+    page,
+    {
+      builderlabAuth: {
+        email: "old-owner@example.com",
+        expiresAt: "2099-01-01T00:00:00Z",
+      },
+      builderlabIdentity: {
+        // Identity object present, but no authoritative pubkey_hex — only
+        // the independent server npub, spelled for a different key.
+        npub: npubEncode("f".repeat(64)),
+      },
+      builderlabCommunities: [
+        {
+          id: "owned-community",
+          name: "North Star",
+          normalized_host: "north-star.communities.buzz.xyz",
+        },
+      ],
+    },
+    {
+      relayWsUrl: "ws://localhost:3000",
+      skipOnboardingSeed: true,
+      skipCommunitySeed: true,
+    },
+  );
+  await page.goto("/");
+
+  await page.getByTestId("community-choice-create").click();
+  // Presence of the identity object must not read as a linked, ready
+  // account: the mismatch recovery modal drives the flow instead.
+  await expect(
+    page.getByRole("heading", {
+      name: "This account uses a different Buzz identity",
+    }),
+  ).toBeVisible();
+  await expect(
+    page.getByText(`Account: ${npubEncode("f".repeat(64))}`),
+  ).toHaveCount(0);
+  await expect(page.getByText("Account: Unavailable")).toBeVisible();
+  await expect(
+    page.getByText(`This device: ${npubEncode(BLANK_TYLER_IDENTITY.pubkey)}`),
+  ).toBeVisible();
+  // No create/connect surface is exposed behind the recovery modal.
+  await expect(page.getByTestId("hosted-community-create-surface")).toHaveCount(
+    0,
+  );
+  await expect(
+    page.getByRole("button", { name: "Connect", exact: true }),
+  ).toHaveCount(0);
+
+  // Recovery rebinds the device key and restores readiness.
+  await page
+    .getByRole("button", { name: "Use this device's identity" })
+    .click();
+  await expect
+    .poll(() => page.evaluate(() => window.__BUZZ_E2E_COMMANDS__ ?? []))
+    .toEqual(
+      expect.arrayContaining([
+        "delete_builderlab_nostr_identity",
+        "bind_builderlab_nostr_identity",
+      ]),
+    );
+  await expect(
+    page.getByRole("heading", { name: "Choose a community" }),
+  ).toBeVisible();
+  await expect(page.getByText("North Star")).toBeVisible();
+  await expect(
+    page.getByRole("button", { name: "Connect", exact: true }),
+  ).toBeVisible();
+});
+
+test("first-community owner never rebinds over a same-key spelling in the hex field", async ({
+  page,
+}) => {
+  await seedActiveIdentity(page, BLANK_TYLER_IDENTITY);
+  await page.addInitScript((pubkey) => {
+    window.localStorage.setItem(
+      `buzz-machine-onboarding-complete.v2:${pubkey}`,
+      "true",
+    );
+  }, BLANK_TYLER_IDENTITY.pubkey);
+  await installMockBridge(
+    page,
+    {
+      builderlabAuth: {
+        email: "old-owner@example.com",
+        expiresAt: "2099-01-01T00:00:00Z",
+      },
+      builderlabIdentity: {
+        // A checksum-valid npub stored in the authoritative hex field,
+        // spelling this very device's key. It is not a hex key: recovery
+        // owns the flow, the spelling never renders as the account's key,
+        // and no delete/rebind of the identity the device already holds
+        // is demanded for it.
+        pubkey_hex: npubEncode(BLANK_TYLER_IDENTITY.pubkey),
+      },
+      builderlabCommunities: [
+        {
+          id: "owned-community",
+          name: "North Star",
+          normalized_host: "north-star.communities.buzz.xyz",
+        },
+      ],
+    },
+    {
+      relayWsUrl: "ws://localhost:3000",
+      skipOnboardingSeed: true,
+      skipCommunitySeed: true,
+    },
+  );
+  await page.goto("/");
+
+  await page.getByTestId("community-choice-create").click();
+  await expect(
+    page.getByRole("heading", {
+      name: "This account uses a different Buzz identity",
+    }),
+  ).toBeVisible();
+  await expect(page.getByText("Account: Unavailable")).toBeVisible();
+  await expect(
+    page.getByText(`Account: ${npubEncode(BLANK_TYLER_IDENTITY.pubkey)}`),
+  ).toHaveCount(0);
+  await expect(
+    page.getByText(`This device: ${npubEncode(BLANK_TYLER_IDENTITY.pubkey)}`),
+  ).toBeVisible();
+  await expect(
+    page.getByRole("button", { name: "Connect", exact: true }),
+  ).toHaveCount(0);
+});
+
+test("first-community owner with a padded same-key hex is ready, not mismatched", async ({
+  page,
+}) => {
+  await seedActiveIdentity(page, BLANK_TYLER_IDENTITY);
+  await page.addInitScript((pubkey) => {
+    window.localStorage.setItem(
+      `buzz-machine-onboarding-complete.v2:${pubkey}`,
+      "true",
+    );
+  }, BLANK_TYLER_IDENTITY.pubkey);
+  await installMockBridge(
+    page,
+    {
+      builderlabAuth: {
+        email: "owner@example.com",
+        expiresAt: "2099-01-01T00:00:00Z",
+      },
+      builderlabIdentity: {
+        // The device's own key, padded and uppercased: the same key after
+        // normalization, so the account is ready — never a mismatch
+        // demanding a delete/rebind of the identity it already holds.
+        pubkey_hex: `  ${BLANK_TYLER_IDENTITY.pubkey.toUpperCase()}  `,
+      },
+    },
+    {
+      relayWsUrl: "ws://localhost:3000",
+      skipOnboardingSeed: true,
+      skipCommunitySeed: true,
+    },
+  );
+  await page.goto("/");
+
+  await page.getByTestId("community-choice-create").click();
+  await expect(
+    page.getByRole("heading", {
+      name: "This account uses a different Buzz identity",
+    }),
+  ).toHaveCount(0);
+  await expect(
+    page.getByRole("textbox", { name: "Community name" }),
+  ).toBeVisible();
+});
+
 test("first-community explains when the local identity belongs to another account", async ({
   page,
 }) => {
diff --git a/desktop/tests/e2e/profile.spec.ts b/desktop/tests/e2e/profile.spec.ts
index e47d75706cb..128152fbecf 100644
--- a/desktop/tests/e2e/profile.spec.ts
+++ b/desktop/tests/e2e/profile.spec.ts
@@ -491,7 +491,14 @@ test("updates the relay-backed profile from settings", async ({ page }) => {
 
   await expect(page.getByTestId("profile-identity-details")).toBeHidden();
   await expandIdentity(page);
-  await expect(page.getByTestId("profile-pubkey")).toContainText("deadbeef");
+  // The mock identity pubkey is "deadbeef" repeated 8×; its canonical npub
+  // is npub1m6kmam774…zuz0, so the identity row shows the npub, not the hex.
+  await expect(page.getByTestId("profile-pubkey")).toContainText(
+    npubEncode("deadbeef".repeat(8)).slice(0, 8),
+  );
+  await expect(page.getByTestId("profile-pubkey")).not.toContainText(
+    "deadbeefdeadbeef",
+  );
   await expect(page.getByTestId("profile-nip05")).toContainText("Not set");
 
   await page.getByTestId("profile-metadata-edit").click();
@@ -1483,7 +1490,7 @@ test("renders agent profile ingress subviews from the Playwright mock bridge", a
   await expect(publicKeyCopy).toHaveAttribute("data-copied", "true");
   await expect
     .poll(() => page.evaluate(() => navigator.clipboard.readText()))
-    .toBe(agentPubkey);
+    .toBe(npubEncode(agentPubkey));
   await expect(page.getByTestId("user-profile-agent-instruction")).toHaveCount(
     0,
   );
diff --git a/desktop/tests/e2e/pubkey-display-screenshots.spec.ts b/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
index 8dbdbad005f..64532a07dfa 100644
--- a/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
+++ b/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
@@ -191,11 +191,10 @@ test("selected new-DM recipient can be verified again through search", async ({
   await charlieNameTrigger.click();
   await expect(charlieKeyPopover).toBeVisible();
   await expect(charliePubkey).toContainText("npub1");
-  // The shared PubKey widget is npub-only — no hex text or hex copy row in
-  // the widget itself. (D1a boundary: the chip's legacy raw-hex popover line
-  // is removed with the chip change in the descendant slice.)
-  await expect(charliePubkey).not.toContainText(TEST_IDENTITIES.charlie.pubkey);
-  await expect(charlieKeyPopover).toContainText(TEST_IDENTITIES.charlie.pubkey);
+  // The verify popover is npub-only — the raw hex line is gone.
+  await expect(charlieKeyPopover).not.toContainText(
+    TEST_IDENTITIES.charlie.pubkey,
+  );
   await waitForAnimations(page);
   await page.getByTestId("new-message-page").screenshot({
     path: `${SHOTS}/new-dm-selected-recipient-key.png`,
diff --git a/scripts/check-pubkey-truncation-core.mjs b/scripts/check-pubkey-truncation-core.mjs
index 627e4dea82b..5d5bf702560 100644
--- a/scripts/check-pubkey-truncation-core.mjs
+++ b/scripts/check-pubkey-truncation-core.mjs
@@ -6,9 +6,11 @@ import path from "node:path";
  *
  * A truncated pubkey prefix is forgeable by vanity-grinding, so display
  * truncation must be consistent and centralized: the canonical
- * `truncatePubkey` in `shared/lib/pubkey.ts` (or the `<PubKey>` component,
- * which also offers full-key reveal + copy). Ad-hoc `pubkey.slice(0, N)`
- * display forms fragmented into five formats before this guard existed.
+ * `truncateNpub` (identity keys — compact npub) and `truncatePubkey`
+ * (generic hex identifiers such as event/blob IDs) in
+ * `shared/lib/pubkey.ts` (or the `<PubKey>` component, which also offers
+ * full-key reveal + copy). Ad-hoc `pubkey.slice(0, N)` display forms
+ * fragmented into five formats before this guard existed.
  *
  * It flags `.slice(` / `.substring(` / `.slice(0` template-truncations applied
  * to identifiers that look like a pubkey/npub, outside the canonical module.
@@ -97,7 +99,7 @@ export async function runPubkeyTruncationCheck({
   if (violations.length > 0) {
     console.error(
       `${label}: found ${violations.length} hand-rolled pubkey truncation(s).\n` +
-        `Use \`truncatePubkey\` from shared/lib/pubkey (or the <PubKey> component) instead.\n` +
+        `Use \`truncateNpub\` (identity) or \`truncatePubkey\` (event/blob IDs) from shared/lib/pubkey (or the <PubKey> component) instead.\n` +
         `Genuine non-display uses can be allowlisted in ${scriptPath}.\n`,
     );
     for (const violation of violations) {

From 82656ffea080cc28cec9163ebbf7d1c6be327e43 Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 9 Sep 2026 14:08:24 -0400
Subject: [PATCH 07/19] fix(mobile): standardize public-key identity display on
 npub (#7493)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖

## Summary

In the mobile app, anyone who hasn't set a display name shows up as a
raw 64-character hex key (e.g. `3a5d4f9c…`) — unreadable, and
unrecognizable as the same identity across screens. Profile and Settings
also let you copy that raw hex. Nostr public keys have a standard
readable form — `npub1…`, the same encoding other Nostr apps and our
desktop app already display. This PR makes every mobile identity surface
render npub instead:

- **Unnamed people everywhere** — message and thread authors, reactions,
typing indicators, member lists, channel details, DM headers and tiles,
inbox, search, forum cards, Pulse notes and reply context, mention
suggestions, and invite rows — now show a compact npub label: first 8 +
last 4 characters of the full npub joined by an ellipsis
(`npub1abcd…wxyz`), the same truncation desktop uses. Previously these
showed truncated raw hex.
- **DM fallback avatars and blank names** — 1:1 DM tiles and headers key
their fallback avatar to the same non-self counterpart the label names,
including self-first participant order; a self-DM keeps its
hex-key-derived initial. Blank or whitespace-only display names fall
back to the compact npub instead of rendering empty, while nonblank
authored names render verbatim (padding included).
- **Profile sheet → "Copy public key"** now copies the full canonical
npub — never raw hex. When the identity string isn't a valid public key,
the copy tile is disabled, so a malformed key never reaches the
clipboard.
- **Settings → Identity (pubkey)** displays and copies the full npub; an
invalid identity reads "Identity unavailable" with copy disabled.
- **Invalid identities never leak truncated raw hex** into the UI
anywhere — they render a neutral "Unknown identity" label.
- **Unchanged on purpose:** display names and verified handles (NIP-05 —
the `name@domain` badge) still render as before. Unnamed avatars keep
distinct per-key initials, derived from the underlying hex key rather
than the npub — otherwise every unnamed key would render the same "N"
initial. Event IDs are not public keys, so they keep their hex
truncation (in Pulse's "Replying to", the parent author shows npub while
an event-id fallback still shows hex). The nevent share link, private
keys, and internal hex storage are untouched. Inputs that accept a key
(invite/member entry) accept both hex and npub and keep working in hex
internally.

### Related issue

N/A. Searched open issues/PRs for npub identity display on mobile —
closest related: none found. Desktop's parallel npub standardization
lives in the stacked desktop PRs (#7488 foundation, #7489 controls,
#7495 display surfaces); this is the independent mobile slice (based
directly on `main`, not on those branches).

### Testing

At exact head `5a620e420a1fd57d9d8011ac26434eed32fcf765` (base: `main`
`44316ff72`; 40 files, +1,345/−154):

- Full mobile suite: 2,098 tests passing (`cd mobile && flutter test`);
`flutter analyze` clean; `dart format --set-exit-if-changed .` clean —
the same checks CI runs.
- Widget/unit coverage at production seams: compact labels and hex-keyed
avatar initials for DM headers/tiles, member rows, mention suggestions,
and Pulse reply context; DM fallback avatars keyed to the labeled
counterpart (self-first order and self-DMs); blank/whitespace
display-name npub fallback with nonblank authored labels verbatim,
including the Activity inbox sender and profile-sheet heading (each with
its own empty/whitespace production-seam regression); full-npub copy and
disabled-copy semantics in profile and settings; invalid-key
suppression; and hex↔npub input round-trips.

Verified via unit and widget tests — no device/simulator validation is
claimed.

### Task provenance

Buzz channel: `1f0e4a3d-7e01-4efe-bb16-843b357f85c9`

Task:
buzz://message?channel=1f0e4a3d-7e01-4efe-bb16-843b357f85c9&id=86b34eb4bd84a1472419e9af22636c011c0fe273e3c196f967d7a36996e149b6

---------

Signed-off-by: Logan Johnson <loganj@squareup.com>
Co-authored-by: Larry <627498bd4bd1f281a16431e3c6cce3b5c25b6692798c78672298aefbf2f8f8b5@buzz.block.builderlab.xyz>
---
 .../activity/activity_page/inbox_row.dart     |   4 +-
 .../channels/channel_detail_page/app_bar.dart |   9 +-
 .../channels/channel_details_page.dart        |  11 +-
 .../channels/channel_management_provider.dart |  27 +-
 .../channels/channels_page/channel_tile.dart  |   9 +-
 .../channels/compose_bar/suggestions.dart     |   5 +-
 .../features/channels/dm_channel_labels.dart  |  50 +++
 .../lib/features/channels/members_sheet.dart  |   7 +-
 .../channels/mentions/mention_candidates.dart |   3 +-
 .../channels/mentions/mention_ranking.dart    |  13 +-
 .../lib/features/channels/reaction_row.dart   |   5 +-
 .../lib/features/forum/forum_post_card.dart   |   8 +-
 .../lib/features/forum/forum_thread_page.dart |  10 +-
 .../features/invites/invite_create_page.dart  |   1 +
 .../person_invite_section.dart                |   8 +-
 .../invites/invite_create_provider.dart       |  37 +-
 .../features/profile/user_profile_sheet.dart  |  14 +-
 .../features/pulse/agent_activity_card.dart   |   6 +-
 .../lib/features/pulse/compose_note_page.dart |  13 +-
 mobile/lib/features/pulse/note_card.dart      |  22 +-
 mobile/lib/features/search/search_page.dart   |   2 +-
 .../lib/features/settings/settings_page.dart  |   1 +
 .../settings_page/connection_section.dart     |  16 +-
 .../mentions/agent_identity_provider.dart     |   4 +-
 mobile/lib/shared/profile/user_profile.dart   |  27 +-
 mobile/lib/shared/utils/string_utils.dart     |  55 ++-
 .../features/activity/activity_page_test.dart |  73 +++-
 .../channels/channel_detail_page_test.dart    | 353 +++++++++++++++++-
 .../channel_management_provider_test.dart     |  63 ++++
 .../features/channels/channels_page_test.dart | 190 +++++++++-
 .../features/channels/compose_bar_test.dart   |  40 ++
 .../mentions/mention_candidates_test.dart     |  11 +-
 .../features/forum/forum_widgets_test.dart    |  11 +-
 .../invites/invite_create_page_test.dart      |   5 +-
 .../profile/profile_provider_test.dart        |   5 +-
 .../pulse/compose_note_page_test.dart         |  68 +++-
 .../test/features/pulse/note_card_test.dart   | 167 +++++++++
 .../settings/connection_section_test.dart     |  20 +-
 .../shared/profile/user_profile_test.dart     |  36 ++
 .../test/shared/utils/string_utils_test.dart  |  90 +++++
 40 files changed, 1345 insertions(+), 154 deletions(-)
 create mode 100644 mobile/test/shared/profile/user_profile_test.dart
 create mode 100644 mobile/test/shared/utils/string_utils_test.dart

diff --git a/mobile/lib/features/activity/activity_page/inbox_row.dart b/mobile/lib/features/activity/activity_page/inbox_row.dart
index 1252968baf2..cb19e65b07a 100644
--- a/mobile/lib/features/activity/activity_page/inbox_row.dart
+++ b/mobile/lib/features/activity/activity_page/inbox_row.dart
@@ -80,7 +80,9 @@ class _InboxRow extends HookConsumerWidget {
         pubkey: ref.watch(userCacheProvider.select((cache) => cache[pubkey])),
     };
     final profile = profiles[senderPubkey];
-    final senderLabel = profile?.displayName ?? shortPubkey(item.item.pubkey);
+    // The shared label contract: blank cached names (empty or whitespace-only
+    // are relay-valid) fall back to the compact npub, never a blank sender.
+    final senderLabel = profile?.label ?? shortPubkey(item.item.pubkey);
     final profileMentionNames = {
       for (final pubkey in mentionPubkeys)
         if (profiles[pubkey]?.displayName?.trim().isNotEmpty == true)
diff --git a/mobile/lib/features/channels/channel_detail_page/app_bar.dart b/mobile/lib/features/channels/channel_detail_page/app_bar.dart
index 5ea4c041d78..2914184729e 100644
--- a/mobile/lib/features/channels/channel_detail_page/app_bar.dart
+++ b/mobile/lib/features/channels/channel_detail_page/app_bar.dart
@@ -238,11 +238,14 @@ class _DmAppBarTitle extends ConsumerWidget {
                 .contains(otherPubkey)) ||
         profile?.ownerPubkey != null;
     final animatedAvatar = parseAnimatedAvatarUrl(avatarUrl);
+    // Keyed to the hex public key when the participant is unnamed and the
+    // profile isn't cached — the compact-npub participant label would
+    // otherwise render `N` for every unnamed DM counterpart. Selection skips
+    // the current user like the header label does, so the initial always
+    // identifies the same counterpart the label names.
     final initial =
         profile?.initial ??
-        (channel.participants.isNotEmpty
-            ? channel.participants.first[0].toUpperCase()
-            : '?');
+        dmAvatarInitial(channel, currentPubkey: currentPubkey);
     final presenceLabel = switch (presence) {
       'online' => 'Online',
       'away' => 'Away',
diff --git a/mobile/lib/features/channels/channel_details_page.dart b/mobile/lib/features/channels/channel_details_page.dart
index d86c01de7a2..a626f0dc4fa 100644
--- a/mobile/lib/features/channels/channel_details_page.dart
+++ b/mobile/lib/features/channels/channel_details_page.dart
@@ -655,11 +655,18 @@ class _ChannelMemberPreviewRow extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final isSelf = member.pubkey.toLowerCase() == currentPubkey?.toLowerCase();
+    final hasName = displayName?.trim().isNotEmpty == true;
     final label = isSelf
         ? 'You'
-        : displayName?.trim().isNotEmpty == true
+        : hasName
         ? displayName!.trim()
         : member.labelFor(currentPubkey);
+    // Self/named initials come from the visible label; unnamed members stay
+    // keyed to the hex public key so the compact-npub label doesn't render
+    // `N` for everyone.
+    final initial = isSelf || hasName
+        ? label[0].toUpperCase()
+        : (member.pubkey.isNotEmpty ? member.pubkey[0].toUpperCase() : '?');
     final roleLabel = _channelMemberRoleLabel(member.role);
     final titleStyle = context.textTheme.bodyLarge;
     final roleStyle = context.textTheme.bodySmall?.copyWith(
@@ -671,7 +678,7 @@ class _ChannelMemberPreviewRow extends StatelessWidget {
         imageUrl: avatarUrl,
         radius: 20,
         backgroundColor: context.colors.primaryContainer,
-        fallback: Text(label.isEmpty ? '?' : label[0].toUpperCase()),
+        fallback: Text(initial),
         isAgent: member.isBot,
       ),
       title: Text.rich(
diff --git a/mobile/lib/features/channels/channel_management_provider.dart b/mobile/lib/features/channels/channel_management_provider.dart
index 6fad4ecc4a4..36e640b411c 100644
--- a/mobile/lib/features/channels/channel_management_provider.dart
+++ b/mobile/lib/features/channels/channel_management_provider.dart
@@ -10,6 +10,7 @@ import '../../shared/custom_emoji/custom_emoji_provider.dart';
 import '../../shared/crypto/nip_oa.dart';
 import '../../shared/mentions/agent_identity_provider.dart';
 import '../../shared/relay/relay.dart';
+import '../../shared/utils/string_utils.dart';
 import '../profile/profile_provider.dart';
 import 'channel.dart';
 import 'channel_metadata_updates.dart';
@@ -35,10 +36,7 @@ class AddMembersException implements Exception {
   const AddMembersException(this.failures);
 
   String get message => failures.entries
-      .map(
-        (entry) =>
-            '${entry.key.length > 8 ? '${entry.key.substring(0, 8)}…' : entry.key}: ${entry.value}',
-      )
+      .map((entry) => '${shortPubkey(entry.key)}: ${entry.value}')
       .join('; ');
 
   @override
@@ -71,7 +69,7 @@ class ChannelMember {
     if (displayName case final name? when name.trim().isNotEmpty) {
       return name.trim();
     }
-    return pubkey.length > 8 ? '${pubkey.substring(0, 8)}…' : pubkey;
+    return shortPubkey(pubkey);
   }
 }
 
@@ -175,7 +173,7 @@ class DirectoryUser {
     if (nip05 != null && nip05.isNotEmpty) {
       return nip05;
     }
-    return pubkey.length > 8 ? '${pubkey.substring(0, 8)}…' : pubkey;
+    return shortPubkey(pubkey);
   }
 
   String get secondaryLabel {
@@ -183,11 +181,22 @@ class DirectoryUser {
     if (nip05 != null && nip05.isNotEmpty && nip05 != label) {
       return nip05;
     }
-    return pubkey.length > 16 ? '${pubkey.substring(0, 16)}…' : pubkey;
+    // The primary label is already the compact key when no name or NIP-05
+    // exists; a second key-shaped line would only duplicate it.
+    final display = displayName?.trim();
+    return display != null && display.isNotEmpty ? shortPubkey(pubkey) : '';
   }
 
-  /// First visible character used when no avatar image is available.
-  String get initial => label.isNotEmpty ? label[0].toUpperCase() : '?';
+  /// Avatar initial — name-derived when available, otherwise keyed to the
+  /// hex public key so unnamed identities keep distinct initials (a compact
+  /// npub would render `N` for everyone).
+  String get initial {
+    final display = displayName?.trim();
+    if (display != null && display.isNotEmpty) return display[0].toUpperCase();
+    final nip05 = nip05Handle?.trim();
+    if (nip05 != null && nip05.isNotEmpty) return nip05[0].toUpperCase();
+    return pubkey.isNotEmpty ? pubkey[0].toUpperCase() : '?';
+  }
 }
 
 /// Whether the mobile DM directory should show local preview identities.
diff --git a/mobile/lib/features/channels/channels_page/channel_tile.dart b/mobile/lib/features/channels/channels_page/channel_tile.dart
index b94be1951f4..e060e9e9ac4 100644
--- a/mobile/lib/features/channels/channels_page/channel_tile.dart
+++ b/mobile/lib/features/channels/channels_page/channel_tile.dart
@@ -191,11 +191,14 @@ class _DmAvatar extends ConsumerWidget {
     }
 
     final avatarUrl = profile?.avatarUrl;
+    // Keyed to the hex public key when the counterpart is unnamed and the
+    // profile isn't cached — the compact-npub participant label would
+    // otherwise render `N` for every unnamed DM counterpart. Selection skips
+    // the current user like the row label does, so the initial always
+    // identifies the same counterpart the label names.
     final initial =
         profile?.initial ??
-        (channel.participants.isNotEmpty
-            ? channel.participants.first[0].toUpperCase()
-            : '?');
+        dmAvatarInitial(channel, currentPubkey: currentPubkey);
     return SizedBox(
       width: _kDmAvatarSize,
       height: _kDmAvatarSize,
diff --git a/mobile/lib/features/channels/compose_bar/suggestions.dart b/mobile/lib/features/channels/compose_bar/suggestions.dart
index e6bee4515ba..31e57c85f02 100644
--- a/mobile/lib/features/channels/compose_bar/suggestions.dart
+++ b/mobile/lib/features/channels/compose_bar/suggestions.dart
@@ -47,7 +47,10 @@ class _MentionSuggestions extends StatelessWidget {
                 radius: 18,
                 backgroundColor: context.colors.primaryContainer,
                 fallback: Text(
-                  name[0].toUpperCase(),
+                  // Name-derived for named candidates; keyed to the hex
+                  // public key for unnamed ones so the compact-npub label
+                  // doesn't render `N` for everyone.
+                  candidate.initial,
                   style: context.textTheme.labelMedium?.copyWith(
                     color: context.colors.onPrimaryContainer,
                     fontWeight: FontWeight.w600,
diff --git a/mobile/lib/features/channels/dm_channel_labels.dart b/mobile/lib/features/channels/dm_channel_labels.dart
index 809b00876f7..51e75730589 100644
--- a/mobile/lib/features/channels/dm_channel_labels.dart
+++ b/mobile/lib/features/channels/dm_channel_labels.dart
@@ -54,6 +54,56 @@ String resolveDmChannelDisplayLabel(Channel channel, {String? currentPubkey}) {
       : channel.name;
 }
 
+/// Avatar initial for the DM's visible counterpart.
+///
+/// Mirrors [resolveDmChannelDisplayLabel]'s participant selection: the
+/// first participant that is not [currentPubkey], since member order does
+/// not guarantee the counterpart is listed first — otherwise the avatar
+/// could identify the current user while the label beside it identifies
+/// the counterpart. When every participant is the current user (a
+/// self-DM), the label names the current user too, so the avatar keys off
+/// that same first participant instead of its label's first character.
+///
+/// A resolved display name keeps its name-derived initial. A label that
+/// fell back to the compact npub form of the participant's key is keyed to
+/// the hex public key instead — the npub form starts with `npub1`, so every
+/// unnamed participant would otherwise render `N`.
+String dmAvatarInitial(Channel channel, {String? currentPubkey}) {
+  final normalizedCurrent = currentPubkey?.toLowerCase();
+  var index = 0;
+  while (normalizedCurrent != null &&
+      index < channel.participantPubkeys.length &&
+      channel.participantPubkeys[index].toLowerCase() == normalizedCurrent) {
+    index++;
+  }
+
+  if (index >= channel.participantPubkeys.length) {
+    // No participant pubkeys (labels only): fall back to the first
+    // participant label, like the channel label does when the non-self
+    // list is empty.
+    if (channel.participantPubkeys.isEmpty) {
+      final label = channel.participants.isNotEmpty
+          ? channel.participants.first
+          : '';
+      return label.isNotEmpty ? label[0].toUpperCase() : '?';
+    }
+    // Keys exist but every participant is the current user (a self-DM):
+    // the label names the current user, so key the avatar to that same
+    // first participant with the shared provenance rule below — the hex
+    // key for a compact npub label, the authored name otherwise.
+    index = 0;
+  }
+
+  final pubkey = channel.participantPubkeys[index];
+  final label = index < channel.participants.length
+      ? channel.participants[index]
+      : shortPubkey(pubkey);
+  if (pubkey.isNotEmpty && label == shortPubkey(pubkey)) {
+    return pubkey[0].toUpperCase();
+  }
+  return label.isNotEmpty ? label[0].toUpperCase() : '?';
+}
+
 List<Channel> sortDmChannelsByDisplayLabel(
   Iterable<Channel> channels, {
   String? currentPubkey,
diff --git a/mobile/lib/features/channels/members_sheet.dart b/mobile/lib/features/channels/members_sheet.dart
index 568737362f1..ba720a408e9 100644
--- a/mobile/lib/features/channels/members_sheet.dart
+++ b/mobile/lib/features/channels/members_sheet.dart
@@ -221,7 +221,12 @@ class _MemberTile extends ConsumerWidget {
         : (profile?.displayName?.trim().isNotEmpty == true
               ? profile!.displayName!.trim()
               : member.labelFor(currentPubkey));
-    final initial = label.substring(0, 1).toUpperCase();
+    // Named members initial from their name; unnamed ones stay keyed to the
+    // hex public key so the compact-npub label doesn't render `N` for all.
+    final hasName = profile?.displayName?.trim().isNotEmpty == true;
+    final initial = isSelf || hasName
+        ? label[0].toUpperCase()
+        : (member.pubkey.isNotEmpty ? member.pubkey[0].toUpperCase() : '?');
     final showManagementActions = canManage && !isSelf && !member.isOwner;
     final showMenu = showManagementActions || onViewActivity != null;
 
diff --git a/mobile/lib/features/channels/mentions/mention_candidates.dart b/mobile/lib/features/channels/mentions/mention_candidates.dart
index 6f3bae57a27..2187fedd73a 100644
--- a/mobile/lib/features/channels/mentions/mention_candidates.dart
+++ b/mobile/lib/features/channels/mentions/mention_candidates.dart
@@ -1,5 +1,6 @@
 import '../../../shared/mentions/agent_identity_provider.dart';
 import '../../../shared/profile/user_profile.dart';
+import '../../../shared/utils/string_utils.dart';
 import '../channel_management_provider.dart';
 import 'mention_ranking.dart';
 
@@ -35,7 +36,7 @@ String? formatOwnerLabel(
   if (name != null && name.isNotEmpty) return name;
   final handle = profile?.nip05Handle?.trim();
   if (handle != null && handle.isNotEmpty) return handle;
-  return '${ownerPubkey.substring(0, 8)}…';
+  return shortPubkey(ownerPubkey);
 }
 
 /// Assemble the full mention candidate list: channel members first-class,
diff --git a/mobile/lib/features/channels/mentions/mention_ranking.dart b/mobile/lib/features/channels/mentions/mention_ranking.dart
index 0d0875f0ee5..7706df4bdfc 100644
--- a/mobile/lib/features/channels/mentions/mention_ranking.dart
+++ b/mobile/lib/features/channels/mentions/mention_ranking.dart
@@ -1,5 +1,7 @@
 import 'package:flutter/foundation.dart';
 
+import '../../../shared/utils/string_utils.dart';
+
 /// A mention autocomplete candidate. Mirrors the desktop's
 /// `MentionCandidateForRanking` (desktop/src/features/messages/lib/mentionRanking.ts).
 @immutable
@@ -27,7 +29,16 @@ class MentionCandidate {
   String get label {
     final name = displayName?.trim();
     if (name != null && name.isNotEmpty) return name;
-    return pubkey.length >= 8 ? pubkey.substring(0, 8) : pubkey;
+    return shortPubkey(pubkey);
+  }
+
+  /// Avatar initial: display-name-derived, or keyed to the hex public key
+  /// so unnamed identities keep distinct initials (a compact npub would
+  /// render `N` for everyone).
+  String get initial {
+    final name = displayName?.trim();
+    if (name != null && name.isNotEmpty) return name[0].toUpperCase();
+    return pubkey.isNotEmpty ? pubkey[0].toUpperCase() : '?';
   }
 }
 
diff --git a/mobile/lib/features/channels/reaction_row.dart b/mobile/lib/features/channels/reaction_row.dart
index f5d0066bad7..1b30fea3a2b 100644
--- a/mobile/lib/features/channels/reaction_row.dart
+++ b/mobile/lib/features/channels/reaction_row.dart
@@ -13,6 +13,7 @@ import '../../shared/emoji/native_emoji_glyph.dart';
 import '../../shared/emoji/positive_emoji.dart';
 import '../../shared/profile/user_cache_provider.dart';
 import '../../shared/profile/user_profile.dart';
+import '../../shared/utils/string_utils.dart';
 import 'channel_management_provider.dart';
 import 'emoji_picker.dart';
 import 'recent_emoji_provider.dart';
@@ -451,9 +452,7 @@ class _ReactorTile extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final displayName =
-        profile?.label ??
-        (pubkey.length >= 8 ? '${pubkey.substring(0, 8)}...' : pubkey);
+    final displayName = profile?.label ?? shortPubkey(pubkey);
     final about = profile?.about;
 
     return ListTile(
diff --git a/mobile/lib/features/forum/forum_post_card.dart b/mobile/lib/features/forum/forum_post_card.dart
index 0a2d2de3e89..9ec9a3afb1d 100644
--- a/mobile/lib/features/forum/forum_post_card.dart
+++ b/mobile/lib/features/forum/forum_post_card.dart
@@ -10,6 +10,7 @@ import '../../shared/widgets/avatar_image.dart';
 import '../../shared/widgets/modal_presentation.dart';
 import '../channels/message_content.dart';
 import '../../shared/profile/user_cache_provider.dart';
+import '../../shared/utils/string_utils.dart';
 import '../profile/user_profile_sheet.dart';
 import '../../shared/profile/user_profile.dart';
 import 'forum_models.dart';
@@ -53,7 +54,7 @@ class ForumPostCard extends HookConsumerWidget {
     final profile =
         ref.watch(userCacheProvider.select((cache) => cache[pk])) ??
         ref.read(userCacheProvider.notifier).get(pk);
-    final displayName = profile?.label ?? _shortPubkey(post.pubkey);
+    final displayName = profile?.label ?? shortPubkey(post.pubkey);
     final isAgent =
         ref.watch(agentMentionPubkeysProvider(post.channelId)).contains(pk) ||
         profile?.ownerPubkey != null;
@@ -345,11 +346,6 @@ class _PostAvatar extends StatelessWidget {
   }
 }
 
-String _shortPubkey(String pubkey) {
-  if (pubkey.length > 12) return '${pubkey.substring(0, 8)}\u2026';
-  return pubkey;
-}
-
 Map<String, String> _buildMentionNames(
   List<String> mentionPubkeys,
   Map<String, UserProfile> userCache,
diff --git a/mobile/lib/features/forum/forum_thread_page.dart b/mobile/lib/features/forum/forum_thread_page.dart
index f8c1d904bda..298630b42c8 100644
--- a/mobile/lib/features/forum/forum_thread_page.dart
+++ b/mobile/lib/features/forum/forum_thread_page.dart
@@ -16,6 +16,7 @@ import '../../shared/widgets/modal_presentation.dart';
 import '../channels/compose_bar.dart';
 import '../channels/message_content.dart';
 import '../../shared/profile/user_cache_provider.dart';
+import '../../shared/utils/string_utils.dart';
 import '../../shared/profile/user_profile.dart';
 import '../profile/user_profile_sheet.dart';
 import 'forum_models.dart';
@@ -332,7 +333,7 @@ class _OriginalPost extends ConsumerWidget {
     final profile =
         ref.watch(userCacheProvider.select((cache) => cache[pk])) ??
         ref.read(userCacheProvider.notifier).get(pk);
-    final displayName = profile?.label ?? _shortPubkey(post.pubkey);
+    final displayName = profile?.label ?? shortPubkey(post.pubkey);
 
     final userCache = ref.watch(userCacheProvider);
     final agentMentionPubkeys = agentPubkeysWithProfileOwners(
@@ -434,7 +435,7 @@ class _ReplyRow extends ConsumerWidget {
     final profile =
         ref.watch(userCacheProvider.select((cache) => cache[pk])) ??
         ref.read(userCacheProvider.notifier).get(pk);
-    final displayName = profile?.label ?? _shortPubkey(reply.pubkey);
+    final displayName = profile?.label ?? shortPubkey(reply.pubkey);
 
     final userCache = ref.watch(userCacheProvider);
     final agentMentionPubkeys = agentPubkeysWithProfileOwners(
@@ -670,8 +671,3 @@ Map<String, String> _buildMentionNames(
   }
   return names;
 }
-
-String _shortPubkey(String pubkey) {
-  if (pubkey.length > 12) return '${pubkey.substring(0, 8)}\u2026';
-  return pubkey;
-}
diff --git a/mobile/lib/features/invites/invite_create_page.dart b/mobile/lib/features/invites/invite_create_page.dart
index 7e6b63e20f7..5f19a99c104 100644
--- a/mobile/lib/features/invites/invite_create_page.dart
+++ b/mobile/lib/features/invites/invite_create_page.dart
@@ -9,6 +9,7 @@ import '../../shared/clipboard_utils.dart';
 import '../../shared/community/community_membership_provider.dart';
 import '../../shared/relay/relay.dart';
 import '../../shared/theme/theme.dart';
+import '../../shared/utils/string_utils.dart';
 import '../../shared/widgets/app_list.dart';
 import '../../shared/widgets/app_list_card.dart';
 import '../../shared/widgets/buzz_action_tile.dart';
diff --git a/mobile/lib/features/invites/invite_create_page/person_invite_section.dart b/mobile/lib/features/invites/invite_create_page/person_invite_section.dart
index ea118e44e0b..42482c002d6 100644
--- a/mobile/lib/features/invites/invite_create_page/person_invite_section.dart
+++ b/mobile/lib/features/invites/invite_create_page/person_invite_section.dart
@@ -199,7 +199,7 @@ class _InviteeResolutionCard extends StatelessWidget {
               ),
             ),
             title: const Text('Resolving profile'),
-            subtitle: Text(shortCommunityInviteNpub(pubkey)),
+            subtitle: Text(shortPubkey(pubkey)),
           ),
         ],
       ),
@@ -208,7 +208,7 @@ class _InviteeResolutionCard extends StatelessWidget {
           AppListRow(
             key: Key('community-invite-resolution-error-$pubkey'),
             title: 'Could not resolve profile',
-            subtitle: shortCommunityInviteNpub(pubkey),
+            subtitle: shortPubkey(pubkey),
             trailing: TextButton(
               onPressed: onRetry,
               child: const Text('Retry'),
@@ -223,7 +223,7 @@ class _InviteeResolutionCard extends StatelessWidget {
               AppListRow(
                 key: Key('community-invite-unresolved-$pubkey'),
                 title: 'Invalid npub',
-                subtitle: shortCommunityInviteNpub(pubkey),
+                subtitle: shortPubkey(pubkey),
               ),
             ],
           );
@@ -234,7 +234,7 @@ class _InviteeResolutionCard extends StatelessWidget {
           children: [
             AppListRow(
               key: Key('community-invite-resolved-$pubkey'),
-              title: shortCommunityInviteNpub(invitee.pubkey),
+              title: shortPubkey(invitee.pubkey),
               trailing: FilledButton(
                 key: const Key('community-invite-submit'),
                 onPressed: isSubmitting ? null : () => onInvite(invitee),
diff --git a/mobile/lib/features/invites/invite_create_provider.dart b/mobile/lib/features/invites/invite_create_provider.dart
index 5a6eaf2b74b..88c06f847bf 100644
--- a/mobile/lib/features/invites/invite_create_provider.dart
+++ b/mobile/lib/features/invites/invite_create_provider.dart
@@ -8,6 +8,7 @@ import 'package:nostr/nostr.dart' as nostr;
 import 'package:share_plus/share_plus.dart';
 
 import '../../shared/community/community_membership_provider.dart';
+import '../../shared/utils/string_utils.dart';
 import '../../shared/relay/relay.dart';
 
 /// The default lifetime of a newly minted community invite link.
@@ -112,36 +113,28 @@ class CommunityInviteDirectoryUser {
     if (display != null && display.isNotEmpty) return display;
     final nip05 = nip05Handle?.trim();
     if (nip05 != null && nip05.isNotEmpty) return nip05;
-    return shortCommunityInvitePubkey(pubkey);
+    return shortPubkey(pubkey);
   }
 
   /// A supporting identity label distinct from [label].
   String get secondaryLabel {
     final nip05 = nip05Handle?.trim();
     if (nip05 != null && nip05.isNotEmpty && nip05 != label) return nip05;
-    return pubkey.length > 16 ? '${pubkey.substring(0, 16)}…' : pubkey;
+    // The primary label is already the compact key when no name or NIP-05
+    // exists; a second key-shaped line would only duplicate it.
+    final display = displayName?.trim();
+    return display != null && display.isNotEmpty ? shortPubkey(pubkey) : '';
   }
 
-  /// The uppercase first character of [label], or `?` when unavailable.
-  String get initial => label.isEmpty ? '?' : label[0].toUpperCase();
-}
-
-/// Abbreviates a hexadecimal public key for compact display.
-String shortCommunityInvitePubkey(String pubkey) =>
-    pubkey.length > 8 ? '${pubkey.substring(0, 8)}…' : pubkey;
-
-/// Encodes and abbreviates a hexadecimal public key as an npub.
-String shortCommunityInviteNpub(String pubkey) {
-  try {
-    final npub = nostr.Nip19.encode(
-      prefix: nostr.Nip19Prefix.npub,
-      data: pubkey,
-    );
-    return npub.length > 20
-        ? '${npub.substring(0, 12)}…${npub.substring(npub.length - 6)}'
-        : npub;
-  } catch (_) {
-    return shortCommunityInvitePubkey(pubkey);
+  /// Avatar initial — name-derived when available, otherwise keyed to the
+  /// hex public key so unnamed identities keep distinct initials (a compact
+  /// npub would render `N` for everyone).
+  String get initial {
+    final display = displayName?.trim();
+    if (display != null && display.isNotEmpty) return display[0].toUpperCase();
+    final nip05 = nip05Handle?.trim();
+    if (nip05 != null && nip05.isNotEmpty) return nip05[0].toUpperCase();
+    return pubkey.isNotEmpty ? pubkey[0].toUpperCase() : '?';
   }
 }
 
diff --git a/mobile/lib/features/profile/user_profile_sheet.dart b/mobile/lib/features/profile/user_profile_sheet.dart
index 63b0eddeef8..97af99fa00a 100644
--- a/mobile/lib/features/profile/user_profile_sheet.dart
+++ b/mobile/lib/features/profile/user_profile_sheet.dart
@@ -83,14 +83,23 @@ class UserProfileSheet extends HookConsumerWidget {
     final copied = useState(false);
     final isOpeningDirectMessage = useState(false);
 
-    final displayName = profile?.displayName;
+    // Canonical npub for the copy action; null when [pubkey] is not a valid
+    // identity, in which case the copy tile is disabled — an invalid key is
+    // never placed on the clipboard.
+    final npub = fullNpub(pubkey);
+
+    // Routed through the shared label so a blank cached name (empty or
+    // whitespace-only, relay-valid) falls back to the compact npub instead
+    // of an empty heading.
+    final displayName = profile?.label;
     final avatarUrl = profile?.avatarUrl;
     final nip05 = profile?.nip05Handle;
     final initial =
         profile?.initial ?? (pubkey.isNotEmpty ? pubkey[0].toUpperCase() : '?');
 
     Future<void> copyPublicKey() async {
-      await Clipboard.setData(ClipboardData(text: pubkey));
+      if (npub == null) return;
+      await Clipboard.setData(ClipboardData(text: npub));
       if (!context.mounted) return;
       copied.value = true;
       _showProfileCopyToast(context);
@@ -239,6 +248,7 @@ class UserProfileSheet extends HookConsumerWidget {
                                 ? LucideIcons.check
                                 : LucideIcons.key,
                             label: copied.value ? 'Copied' : 'Copy public key',
+                            isEnabled: npub != null,
                             onTap: copyPublicKey,
                           ),
                         ),
diff --git a/mobile/lib/features/pulse/agent_activity_card.dart b/mobile/lib/features/pulse/agent_activity_card.dart
index f844244cc94..d5af2b3046f 100644
--- a/mobile/lib/features/pulse/agent_activity_card.dart
+++ b/mobile/lib/features/pulse/agent_activity_card.dart
@@ -6,6 +6,7 @@ import 'package:lucide_icons_flutter/lucide_icons.dart';
 import '../../shared/theme/theme.dart';
 import '../../shared/widgets/avatar_image.dart';
 import '../../shared/profile/user_cache_provider.dart';
+import '../../shared/utils/string_utils.dart';
 import 'note_card.dart';
 import 'pulse_models.dart';
 
@@ -27,7 +28,7 @@ class AgentActivityCard extends HookConsumerWidget {
     final profile =
         ref.watch(userCacheProvider.select((cache) => cache[group.pubkey])) ??
         ref.read(userCacheProvider.notifier).get(group.pubkey);
-    final name = profile?.label ?? _shortPubkey(group.pubkey);
+    final name = profile?.label ?? shortPubkey(group.pubkey);
 
     return Column(
       children: [
@@ -173,6 +174,3 @@ class AgentActivityCard extends HookConsumerWidget {
     );
   }
 }
-
-String _shortPubkey(String pubkey) =>
-    pubkey.length <= 8 ? pubkey : '${pubkey.substring(0, 8)}…';
diff --git a/mobile/lib/features/pulse/compose_note_page.dart b/mobile/lib/features/pulse/compose_note_page.dart
index d4654c2fc71..9564b10cfa7 100644
--- a/mobile/lib/features/pulse/compose_note_page.dart
+++ b/mobile/lib/features/pulse/compose_note_page.dart
@@ -10,6 +10,7 @@ import '../../shared/widgets/frosted_scaffold.dart';
 import '../channels/message_content.dart';
 import '../profile/profile_provider.dart';
 import '../../shared/profile/user_cache_provider.dart';
+import '../../shared/utils/string_utils.dart';
 import 'note_card.dart';
 import 'pulse_actions.dart';
 import 'pulse_models.dart';
@@ -166,7 +167,7 @@ class _ReplyContext extends ConsumerWidget {
     final profile =
         ref.watch(userCacheProvider.select((cache) => cache[pubkey])) ??
         ref.read(userCacheProvider.notifier).get(pubkey);
-    final displayName = profile?.label ?? _shortPubkey(pubkey);
+    final displayName = profile?.label ?? shortPubkey(pubkey);
 
     return Padding(
       padding: const EdgeInsets.fromLTRB(Grid.gutter, Grid.xs, Grid.gutter, 0),
@@ -191,7 +192,12 @@ class _ReplyContext extends ConsumerWidget {
                 radius: 18,
                 backgroundColor: context.colors.primaryContainer,
                 fallback: Text(
-                  (profile?.initial ?? displayName[0]).toUpperCase(),
+                  // Name-derived when the profile is cached; keyed to the
+                  // hex public key when it isn't, so the compact-npub
+                  // fallback label doesn't render `N` for every unnamed
+                  // author.
+                  profile?.initial ??
+                      (pubkey.isNotEmpty ? pubkey[0].toUpperCase() : '?'),
                   style: context.textTheme.labelMedium?.copyWith(
                     color: context.colors.onPrimaryContainer,
                   ),
@@ -260,7 +266,4 @@ class _ReplyContext extends ConsumerWidget {
       ),
     );
   }
-
-  String _shortPubkey(String pubkey) =>
-      pubkey.length >= 8 ? '${pubkey.substring(0, 8)}...' : pubkey;
 }
diff --git a/mobile/lib/features/pulse/note_card.dart b/mobile/lib/features/pulse/note_card.dart
index 30294a988f4..769240d3da0 100644
--- a/mobile/lib/features/pulse/note_card.dart
+++ b/mobile/lib/features/pulse/note_card.dart
@@ -11,6 +11,7 @@ import '../channels/channel_detail_page.dart';
 import '../channels/channel_management_provider.dart';
 import '../channels/message_content.dart';
 import '../../shared/profile/user_cache_provider.dart';
+import '../../shared/utils/string_utils.dart';
 import '../profile/user_profile_sheet.dart';
 import 'compose_note_page.dart';
 import 'pulse_actions.dart';
@@ -43,7 +44,7 @@ class NoteCard extends HookConsumerWidget {
     final profile =
         ref.watch(userCacheProvider.select((cache) => cache[pubkey])) ??
         ref.read(userCacheProvider.notifier).get(pubkey);
-    final displayName = profile?.label ?? _shortPubkey(pubkey);
+    final displayName = profile?.label ?? shortPubkey(pubkey);
     final effectiveUpvoted =
         pendingUpvote.value ?? reaction.reactedByCurrentUser;
     final effectiveCount = _effectiveCount(reaction, pendingUpvote.value);
@@ -70,7 +71,11 @@ class NoteCard extends HookConsumerWidget {
               radius: 18,
               backgroundColor: context.colors.primaryContainer,
               fallback: Text(
-                (profile?.initial ?? displayName[0]).toUpperCase(),
+                // Name-derived when the profile is cached; keyed to the hex
+                // public key when it isn't, so the compact-npub fallback
+                // label doesn't render `N` for every unnamed author.
+                profile?.initial ??
+                    (pubkey.isNotEmpty ? pubkey[0].toUpperCase() : '?'),
                 style: context.textTheme.labelMedium?.copyWith(
                   color: context.colors.onPrimaryContainer,
                 ),
@@ -150,7 +155,7 @@ class NoteCard extends HookConsumerWidget {
                 if (note.replyParentId != null) ...[
                   const SizedBox(height: 2),
                   Text(
-                    'Replying to ${_shortPubkey(note.replyParentAuthor ?? note.replyParentId!)}',
+                    'Replying to ${_replyTargetLabel(note)}',
                     style: context.textTheme.labelSmall?.copyWith(
                       color: context.colors.onSurfaceVariant,
                     ),
@@ -313,8 +318,15 @@ class _ActionButton extends StatelessWidget {
 String _shareUri(UserNote note) =>
     'nostr:${nostr.Nip19.encodeShareableIdentifiers(prefix: nostr.Nip19Prefix.nevent, data: note.id, author: note.pubkey, kind: 1)}';
 
-String _shortPubkey(String pubkey) =>
-    pubkey.length <= 8 ? pubkey : '${pubkey.substring(0, 8)}…';
+/// Compact label for a note's reply target: the parent author's public key
+/// (npub form) when known, otherwise the parent event id. Event ids are not
+/// public keys — they stay hex-truncated and out of the npub contract.
+String _replyTargetLabel(UserNote note) {
+  final author = note.replyParentAuthor;
+  if (author != null) return shortPubkey(author);
+  final eventId = note.replyParentId!;
+  return eventId.length <= 8 ? eventId : '${eventId.substring(0, 8)}…';
+}
 
 String formatPulseRelativeTime(int createdAt) {
   final date = DateTime.fromMillisecondsSinceEpoch(createdAt * 1000);
diff --git a/mobile/lib/features/search/search_page.dart b/mobile/lib/features/search/search_page.dart
index 507e05fb2cc..b66a72a7098 100644
--- a/mobile/lib/features/search/search_page.dart
+++ b/mobile/lib/features/search/search_page.dart
@@ -728,7 +728,7 @@ class _PeopleSection extends ConsumerWidget {
               key: ValueKey('search-person-leading-${user.pubkey}'),
               imageUrl: user.avatarUrl,
               radius: 20,
-              fallback: Text(user.label.substring(0, 1).toUpperCase()),
+              fallback: Text(user.initial),
               isAgent: user.isAgent,
             ),
             title: Text(
diff --git a/mobile/lib/features/settings/settings_page.dart b/mobile/lib/features/settings/settings_page.dart
index b5faa970a19..3253e2212e3 100644
--- a/mobile/lib/features/settings/settings_page.dart
+++ b/mobile/lib/features/settings/settings_page.dart
@@ -14,6 +14,7 @@ import '../../shared/clipboard_utils.dart';
 import '../../shared/community/community_membership_provider.dart';
 import '../../shared/push/push_bridge.dart';
 import '../../shared/relay/relay.dart';
+import '../../shared/utils/string_utils.dart';
 import '../pairing/pairing_provider.dart';
 import '../../shared/theme/theme.dart';
 import '../../shared/widgets/app_list.dart';
diff --git a/mobile/lib/features/settings/settings_page/connection_section.dart b/mobile/lib/features/settings/settings_page/connection_section.dart
index 6e7592440a5..7e14fb559c5 100644
--- a/mobile/lib/features/settings/settings_page/connection_section.dart
+++ b/mobile/lib/features/settings/settings_page/connection_section.dart
@@ -121,12 +121,16 @@ class _IdentityRow extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final privHex = nostr.Nip19.decode(payload: nsec).data;
-    final pubkey = privHex.isNotEmpty ? nostr.Keys(privHex).public : 'unknown';
+    final npub = privHex.isNotEmpty
+        ? fullNpub(nostr.Keys(privHex).public)
+        : null;
 
+    // The full npub is the canonical copy/share form (never raw hex); an
+    // invalid identity is surfaced as unavailable and never copied.
     return Semantics(
       button: true,
       label: 'Copy identity public key',
-      value: pubkey,
+      value: npub ?? 'Identity unavailable',
       child: AppListRow(
         icon: LucideIcons.key,
         title: 'Identity (pubkey)',
@@ -135,9 +139,11 @@ class _IdentityRow extends StatelessWidget {
           size: 18,
           color: context.colors.onSurfaceVariant,
         ),
-        onTap: () async {
-          await copyToClipboard(context, pubkey, message: 'Pubkey copied');
-        },
+        onTap: npub == null
+            ? null
+            : () async {
+                await copyToClipboard(context, npub, message: 'Pubkey copied');
+              },
       ),
     );
   }
diff --git a/mobile/lib/shared/mentions/agent_identity_provider.dart b/mobile/lib/shared/mentions/agent_identity_provider.dart
index 35c063d13d9..d4d5b237ae8 100644
--- a/mobile/lib/shared/mentions/agent_identity_provider.dart
+++ b/mobile/lib/shared/mentions/agent_identity_provider.dart
@@ -6,6 +6,7 @@ import 'package:hooks_riverpod/hooks_riverpod.dart';
 
 import '../../shared/crypto/nip_oa.dart';
 import '../../shared/relay/relay.dart';
+import '../../shared/utils/string_utils.dart';
 
 /// A relay agent parsed from its kind:10100 agent-profile event.
 ///
@@ -158,8 +159,7 @@ Map<String, String> mentionNamesWithDirectoryLabels({
   return names;
 }
 
-String _agentFallbackLabel(String pubkey) =>
-    pubkey.length >= 8 ? pubkey.substring(0, 8) : pubkey;
+String _agentFallbackLabel(String pubkey) => shortPubkey(pubkey);
 
 /// Readiness and refresh state for a channel's live membership subscription.
 class ChannelMembershipUpdateState {
diff --git a/mobile/lib/shared/profile/user_profile.dart b/mobile/lib/shared/profile/user_profile.dart
index abc915437bd..8e16b06dfd9 100644
--- a/mobile/lib/shared/profile/user_profile.dart
+++ b/mobile/lib/shared/profile/user_profile.dart
@@ -1,5 +1,7 @@
 import 'package:flutter/foundation.dart';
 
+import '../utils/string_utils.dart';
+
 @immutable
 class UserProfile {
   final String pubkey;
@@ -31,15 +33,26 @@ class UserProfile {
     nip05Handle: json['nip05_handle'] as String?,
   );
 
-  /// Short label: display name, or first 8 chars of pubkey.
-  String get label =>
-      displayName ??
-      '${pubkey.length >= 8 ? pubkey.substring(0, 8) : pubkey}...';
+  /// Short label: display name, or the compact npub form of the public key.
+  ///
+  /// Blank display names (empty or whitespace-only) fall back to the compact
+  /// npub too — relay profiles can carry them — so a valid identity never
+  /// renders an empty label, like [initial]. Nonblank names render as
+  /// authored: trim only tests blankness, so authored padding survives
+  /// (unlike [initial], which reads the trimmed padding).
+  String get label {
+    final name = displayName;
+    return name != null && name.trim().isNotEmpty ? name : shortPubkey(pubkey);
+  }
 
   /// First letter for fallback avatar.
-  String get initial =>
-      (displayName?.isNotEmpty == true ? displayName! : pubkey)[0]
-          .toUpperCase();
+  String get initial {
+    final name = displayName?.trim();
+    if (name != null && name.isNotEmpty) return name[0].toUpperCase();
+    // Hex-derived (not npub-derived) so unnamed identities keep distinct
+    // initials instead of every npub rendering `N`.
+    return pubkey.isNotEmpty ? pubkey[0].toUpperCase() : '?';
+  }
 }
 
 /// Optional profile handle shown beside a message author's display name.
diff --git a/mobile/lib/shared/utils/string_utils.dart b/mobile/lib/shared/utils/string_utils.dart
index e821b30d522..b9fb720b51b 100644
--- a/mobile/lib/shared/utils/string_utils.dart
+++ b/mobile/lib/shared/utils/string_utils.dart
@@ -1,5 +1,52 @@
-/// Truncates a hex pubkey to the first 8 characters with an ellipsis.
-String shortPubkey(String pubkey) {
-  if (pubkey.length > 12) return '${pubkey.substring(0, 8)}\u2026';
-  return pubkey;
+import 'package:nostr/nostr.dart' as nostr;
+
+/// Neutral label rendered when an identity string cannot be read as a Nostr
+/// public key — malformed identities never leak truncated raw hex into the UI.
+const String unknownIdentityLabel = 'Unknown identity';
+
+final RegExp _hexPubkeyPattern = RegExp(r'^[0-9a-fA-F]{64}$');
+
+/// The canonical full NIP-19 npub for [identity], or null when [identity] is
+/// not a valid public key.
+///
+/// Accepts both canonical public-key forms — a 64-character hex key (any
+/// case) or an `npub1…` string — and returns the full canonical npub.
+/// Already-npub input round-trips through the codec so the result is always
+/// the canonical lowercase encoding. Internal storage stays hex; the npub is
+/// the user-facing display/copy form. Invalid input returns null (never a
+/// passthrough of the raw string) so callers can suppress copy actions.
+String? fullNpub(String identity) {
+  final trimmed = identity.trim();
+  try {
+    if (_hexPubkeyPattern.hasMatch(trimmed)) {
+      return _encodeNpub(trimmed.toLowerCase());
+    }
+    final decoded = nostr.Nip19.decode(payload: trimmed);
+    if (decoded.prefix != nostr.Nip19Prefix.npub ||
+        !_hexPubkeyPattern.hasMatch(decoded.data)) {
+      return null;
+    }
+    return _encodeNpub(decoded.data.toLowerCase());
+  } catch (_) {
+    return null;
+  }
+}
+
+String _encodeNpub(String hexPubkey) =>
+    nostr.Nip19.encode(prefix: nostr.Nip19Prefix.npub, data: hexPubkey);
+
+/// The canonical compact public-key label: the first 8 and last 4 characters
+/// of the full npub joined by an ellipsis — the same truncation desktop uses
+/// for identity surfaces.
+///
+/// A compact label is a recognition aid, never a verification path; copy
+/// actions expose the full npub via [fullNpub]. Accepts hex or npub input
+/// (already-npub input yields the same label as its underlying key).
+/// Returns [unknownIdentityLabel] when [identity] is not a valid public key.
+String shortPubkey(String identity) {
+  final npub = fullNpub(identity);
+  if (npub == null) return unknownIdentityLabel;
+  return npub.length <= 12
+      ? npub
+      : '${npub.substring(0, 8)}…${npub.substring(npub.length - 4)}';
 }
diff --git a/mobile/test/features/activity/activity_page_test.dart b/mobile/test/features/activity/activity_page_test.dart
index 767e15278f9..9fe4a1e2a9c 100644
--- a/mobile/test/features/activity/activity_page_test.dart
+++ b/mobile/test/features/activity/activity_page_test.dart
@@ -32,7 +32,7 @@ void main() {
   final testMention = FeedItem(
     id: 'm1',
     kind: 9,
-    pubkey: 'alice_pk',
+    pubkey: 'a11ce00000000000000000000000000000000000000000000000000000000000',
     content: 'Hey check this out',
     createdAt: now - 120,
     channelId: 'ch1',
@@ -101,11 +101,13 @@ void main() {
   ];
 
   final testUsers = <String, UserProfile>{
-    'alice_pk': const UserProfile(
-      pubkey: 'alice_pk',
-      displayName: 'Alice',
-      nip05Handle: 'alice@example.com',
-    ),
+    'a11ce00000000000000000000000000000000000000000000000000000000000':
+        const UserProfile(
+          pubkey:
+              'a11ce00000000000000000000000000000000000000000000000000000000000',
+          displayName: 'Alice',
+          nip05Handle: 'alice@example.com',
+        ),
     'bob_pk': const UserProfile(pubkey: 'bob_pk', displayName: 'Bob'),
     'agent_pk': const UserProfile(pubkey: 'agent_pk', displayName: 'Scout'),
   };
@@ -407,7 +409,8 @@ void main() {
         eventId: 'm1',
         channelId: 'ch1',
         preview: 'Follow up',
-        authorPubkey: 'alice_pk',
+        authorPubkey:
+            'a11ce00000000000000000000000000000000000000000000000000000000000',
       ),
       note: null,
       createdAt: now - 60,
@@ -536,6 +539,44 @@ void main() {
     );
   });
 
+  testWidgets('blank cached sender names fall back to the compact npub', (
+    tester,
+  ) async {
+    // Relay profiles can cache blank display names (empty and
+    // whitespace-only) unchanged, so the sender must resolve through the
+    // shared nonblank-name label contract: the row shows the compact npub
+    // of the a11ce key instead of a blank author label. Binds the production
+    // seam — the sender resolves through the user cache exactly as the live
+    // page does. Keyed remounts keep each ProviderScope (and its user-cache
+    // override) fresh between scenarios, so each iteration actually
+    // consumes its own blank-name fixture.
+    const sender =
+        'a11ce00000000000000000000000000000000000000000000000000000000000';
+    for (final blankName in const ['', '   ']) {
+      await tester.pumpWidget(
+        KeyedSubtree(
+          key: ValueKey('blank-sender-${blankName.length}'),
+          child: await buildTestable(
+            users: {
+              ...testUsers,
+              sender: UserProfile(pubkey: sender, displayName: blankName),
+            },
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      expect(find.text(blankName), findsNothing);
+      expect(
+        find.descendant(
+          of: find.byKey(const ValueKey('inbox-row-m1')),
+          matching: find.text('npub15yw…ccpw'),
+        ),
+        findsOneWidget,
+      );
+    }
+  });
+
   testWidgets('directory-known Activity authors use agent avatars', (
     tester,
   ) async {
@@ -574,7 +615,8 @@ void main() {
     FeedItem dmMessage(String id, int age) => FeedItem(
       id: id,
       kind: 9,
-      pubkey: 'alice_pk',
+      pubkey:
+          'a11ce00000000000000000000000000000000000000000000000000000000000',
       content: 'dm body $id',
       createdAt: now - age,
       channelId: 'dm1',
@@ -678,7 +720,8 @@ void main() {
     final threadMention = FeedItem(
       id: 'reply-event',
       kind: 9,
-      pubkey: 'alice_pk',
+      pubkey:
+          'a11ce00000000000000000000000000000000000000000000000000000000000',
       content: 'Reply in a thread',
       createdAt: DateTime.now().millisecondsSinceEpoch ~/ 1000,
       channelId: 'ch1',
@@ -931,14 +974,20 @@ void main() {
     );
   });
 
-  testWidgets('falls back to short pubkey when user not cached', (
+  testWidgets('falls back to a compact npub when user is not cached', (
     tester,
   ) async {
     await tester.pumpWidget(await buildTestable(users: const {}));
     await tester.pumpAndSettle();
 
-    // Sender label falls back to the (short) pubkey.
-    expect(find.text('alice_pk'), findsOneWidget);
+    // Sender label falls back to the compact npub of the author's key.
+    expect(
+      find.text(
+        'a11ce00000000000000000000000000000000000000000000000000000000000',
+      ),
+      findsNothing,
+    );
+    expect(find.text('npub15yw\u2026ccpw'), findsOneWidget);
     expect(find.text('Alice'), findsNothing);
   });
 }
diff --git a/mobile/test/features/channels/channel_detail_page_test.dart b/mobile/test/features/channels/channel_detail_page_test.dart
index 2bd6face240..23f547dbad0 100644
--- a/mobile/test/features/channels/channel_detail_page_test.dart
+++ b/mobile/test/features/channels/channel_detail_page_test.dart
@@ -576,10 +576,87 @@ void main() {
       expect(name.style?.fontWeight, FontWeight.w500);
       expect(presence.style?.fontSize, 14);
       expect(presence.style?.fontWeight, FontWeight.w400);
+      // Named counterpart: the avatar initial comes from the authored name.
+      expect(_dmHeaderAvatarInitial(tester), 'A');
       expect(find.byTooltip('View members'), findsNothing);
       expect(find.byTooltip('Start Huddle'), findsOneWidget);
     });
 
+    testWidgets('keys unnamed DM header avatars to the hex participant key', (
+      tester,
+    ) async {
+      // A valid unnamed counterpart: the compact-npub label would render `N`
+      // for every unnamed DM, so the header avatar stays keyed to the hex
+      // public key instead.
+      const a11ce =
+          'a11ce00000000000000000000000000000000000000000000000000000000000';
+      final dmChannel = Channel(
+        id: _channelId,
+        name: 'DM',
+        channelType: 'dm',
+        visibility: 'private',
+        description: 'Direct message',
+        createdBy: 'self',
+        createdAt: DateTime(2025),
+        memberCount: 2,
+        participants: [shortPubkey(a11ce), 'Self'],
+        participantPubkeys: const [a11ce, 'self'],
+        isMember: true,
+      );
+
+      await tester.pumpWidget(
+        _buildTestable(messages: const [], channel: dmChannel),
+      );
+      await tester.pumpAndSettle();
+
+      expect(
+        tester.widget<Text>(find.byKey(const ValueKey('dm-header-name'))).data,
+        shortPubkey(a11ce),
+      );
+      // The named counterpart in the test above keeps its authored initial
+      // ('A' from 'Alice'); this unnamed one gets the hex-key-derived 'A',
+      // not the `N` its npub label starts with.
+      expect(_dmHeaderAvatarInitial(tester), 'A');
+    });
+
+    testWidgets('keys DM header fallback avatars to the non-self counterpart', (
+      tester,
+    ) async {
+      // Member order does not guarantee the counterpart is listed first:
+      // the current user (self, from the fake profile) comes FIRST, so an
+      // avatar keyed to the first participant would render the current
+      // user's initial while the header label names the counterpart.
+      const b0b =
+          'b0b0000000000000000000000000000000000000000000000000000000000000';
+      final dmChannel = Channel(
+        id: _channelId,
+        name: 'DM',
+        channelType: 'dm',
+        visibility: 'private',
+        description: 'Direct message',
+        createdBy: 'self',
+        createdAt: DateTime(2025),
+        memberCount: 2,
+        participants: ['Self', shortPubkey(b0b)],
+        participantPubkeys: const ['self', b0b],
+        isMember: true,
+      );
+
+      await tester.pumpWidget(
+        _buildTestable(messages: const [], channel: dmChannel),
+      );
+      await tester.pumpAndSettle();
+
+      // Label and avatar agree on the counterpart's key: the compact npub
+      // names the unnamed counterpart, and the avatar initial is keyed to
+      // that same hex key — never the current user's `S`.
+      expect(
+        tester.widget<Text>(find.byKey(const ValueKey('dm-header-name'))).data,
+        shortPubkey(b0b),
+      );
+      expect(_dmHeaderAvatarInitial(tester), 'B');
+    });
+
     testWidgets('uses a fallback squircle for bot-role DM participants', (
       tester,
     ) async {
@@ -2291,16 +2368,36 @@ void main() {
     testWidgets('previews five members before an icon-free See all row', (
       tester,
     ) async {
+      // Valid fixture keys whose npub encodings were verified against the
+      // NIP-19 codec independently of the code under test.
+      const a11ce =
+          'a11ce00000000000000000000000000000000000000000000000000000000000';
+      const carol =
+          'c010100000000000000000000000000000000000000000000000000000000000';
       await tester.pumpWidget(
         _buildTestable(
           messages: const [],
+          users: {
+            carol: const UserProfile(pubkey: carol, displayName: 'Carol'),
+          },
           members: [
             ChannelMember(
               pubkey: 'self',
               role: 'owner',
               joinedAt: DateTime(2025),
             ),
-            for (var index = 0; index < 5; index++)
+            ChannelMember(
+              pubkey: a11ce,
+              role: 'member',
+              joinedAt: DateTime(2025),
+            ),
+            ChannelMember(
+              pubkey: carol,
+              role: 'member',
+              joinedAt: DateTime(2025),
+              displayName: 'Carol',
+            ),
+            for (var index = 0; index < 3; index++)
               ChannelMember(
                 pubkey: 'member-$index',
                 role: 'member',
@@ -2360,6 +2457,31 @@ void main() {
       );
       expect(tester.getSize(seeAllRow).height, 40 + (Grid.xxs * 2));
 
+      // Identity display in the preview rows: unnamed members keep distinct
+      // hex-keyed avatar initials (the compact-npub label would render `N`
+      // for everyone), while self and named rows keep their label initials.
+      final unnamedRow = find.byKey(ValueKey('channel-details-member-$a11ce'));
+      expect(
+        find.descendant(
+          of: unnamedRow,
+          matching: find.textContaining(shortPubkey(a11ce)),
+        ),
+        findsOneWidget,
+      );
+      expect(_previewRowAvatarInitial(tester, a11ce), 'A');
+      final namedRow = find.byKey(ValueKey('channel-details-member-$carol'));
+      expect(
+        find.descendant(of: namedRow, matching: find.textContaining('Carol')),
+        findsOneWidget,
+      );
+      expect(_previewRowAvatarInitial(tester, carol), 'C');
+      final selfRow = find.byKey(const ValueKey('channel-details-member-self'));
+      expect(
+        find.descendant(of: selfRow, matching: find.textContaining('You')),
+        findsOneWidget,
+      );
+      expect(_previewRowAvatarInitial(tester, 'self'), 'Y');
+
       await tester.ensureVisible(seeAllRow);
       await tester.pumpAndSettle();
       await tester.tap(seeAllRow);
@@ -5287,11 +5409,12 @@ void main() {
       expect(find.text('Alice'), findsNWidgets(2));
     });
 
-    testWidgets('shows pubkey fallback when no profile', (tester) async {
+    testWidgets('shows compact npub fallback when no profile', (tester) async {
       final messages = [
         _textMsg(
           id: 'msg1',
-          pubkey: 'abcdef1234567890',
+          pubkey:
+              'abcdef0000000000000000000000000000000000000000000000000000000000',
           content: 'Hi',
           createdAt: 1000,
         ),
@@ -5301,8 +5424,8 @@ void main() {
       await tester.pumpAndSettle();
 
       expect(findRichText('Hi'), findsOneWidget);
-      // Should show first 8 chars of pubkey + ellipsis
-      expect(find.text('abcdef12…'), findsOneWidget);
+      // Should show the compact npub form of the author's public key
+      expect(find.text('npub140x…etzk'), findsOneWidget);
     });
   });
 
@@ -8363,21 +8486,60 @@ void main() {
     testWidgets('opens a profile sheet from a membership system avatar', (
       tester,
     ) async {
-      await tester.pumpWidget(
-        _buildTestable(
+      const alicePubkey =
+          'a11ce00000000000000000000000000000000000000000000000000000000000';
+      const bobPubkey =
+          'b0b0000000000000000000000000000000000000000000000000000000000000';
+      // Not a valid hex public key — the sheet must surface a neutral label
+      // and refuse to copy it rather than leaking the raw string.
+      const invalidPubkey = 'bob-not-a-real-pubkey';
+      final clipboardTexts = <String>[];
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+          .setMockMethodCallHandler(SystemChannels.platform, (call) async {
+            if (call.method == 'Clipboard.setData') {
+              clipboardTexts.add((call.arguments as Map)['text'] as String);
+            }
+            return null;
+          });
+      addTearDown(
+        () => TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+            .setMockMethodCallHandler(SystemChannels.platform, null),
+      );
+
+      // Both scenarios share this sheet workflow — a keyed remount so the
+      // second [ProviderScope] (and its user-cache override) is fresh.
+      Widget sheetHost(
+        String scenario,
+        String target, {
+        Map<String, UserProfile> users = const {},
+      }) => KeyedSubtree(
+        key: ValueKey('sheet-$scenario'),
+        child: _buildTestable(
           messages: [
             _systemMsg(
-              id: 'sys-membership-avatar',
+              id: 'sys-membership-avatar-$scenario',
               payload: {
                 'type': 'member_joined',
-                'actor': 'alice',
-                'target': 'bob',
+                'actor': alicePubkey,
+                'target': target,
               },
             ),
           ],
+          users: users,
+        ),
+      );
+
+      // A valid identity: the sheet copies the full canonical npub.
+      await tester.pumpWidget(
+        sheetHost(
+          'valid',
+          bobPubkey,
           users: {
-            'alice': const UserProfile(pubkey: 'alice', displayName: 'Alice'),
-            'bob': const UserProfile(pubkey: 'bob', displayName: 'Bob'),
+            alicePubkey: const UserProfile(
+              pubkey: alicePubkey,
+              displayName: 'Alice',
+            ),
+            bobPubkey: const UserProfile(pubkey: bobPubkey, displayName: 'Bob'),
           },
         ),
       );
@@ -8387,15 +8549,11 @@ void main() {
       await tester.pumpAndSettle();
 
       expect(find.text('Copy public key'), findsOneWidget);
-      expect(find.text('alice'), findsNothing);
+      // The full hex key is never rendered in the sheet.
+      expect(find.text(alicePubkey), findsNothing);
+      expect(find.text(bobPubkey), findsNothing);
       expect(find.byType(UserProfileSheet), findsOneWidget);
 
-      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-          .setMockMethodCallHandler(SystemChannels.platform, (_) async => null);
-      addTearDown(
-        () => TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
-            .setMockMethodCallHandler(SystemChannels.platform, null),
-      );
       await tester.ensureVisible(find.text('Copy public key'));
       await tester.pumpAndSettle();
       final copyAction = find
@@ -8408,6 +8566,68 @@ void main() {
       await tester.pump();
       await tester.pump();
       expect(find.text('Public key copied'), findsOneWidget);
+      // The clipboard receives the full canonical npub — never the raw hex.
+      expect(clipboardTexts, [
+        'npub1kzcqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq0euyv8',
+      ]);
+
+      await tester.tap(find.byTooltip('Close sheet'));
+      await tester.pumpAndSettle();
+
+      // An invalid identity through the same workflow: neutral label,
+      // disabled copy, and no second clipboard write.
+      await tester.pumpWidget(
+        sheetHost(
+          'invalid',
+          invalidPubkey,
+          users: {
+            alicePubkey: const UserProfile(
+              pubkey: alicePubkey,
+              displayName: 'Alice',
+            ),
+          },
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.byType(CircleAvatar));
+      await tester.pumpAndSettle();
+
+      expect(find.text('Copy public key'), findsOneWidget);
+      // Malformed identity → neutral label, never truncated raw input.
+      expect(
+        find.descendant(
+          of: find.byType(UserProfileSheet),
+          matching: find.text('Unknown identity'),
+        ),
+        findsOneWidget,
+      );
+      expect(find.text(invalidPubkey), findsNothing);
+      // The copy tile is disabled and exposes no tap handler.
+      final disabledCopyAction = find
+          .ancestor(
+            of: find.text('Copy public key'),
+            matching: find.byType(GestureDetector),
+          )
+          .last;
+      expect(tester.widget<GestureDetector>(disabledCopyAction).onTap, isNull);
+      final copySemantics = find
+          .ancestor(
+            of: find.text('Copy public key'),
+            matching: find.byType(Semantics),
+          )
+          .first;
+      expect(
+        tester.widget<Semantics>(copySemantics).properties.enabled,
+        isFalse,
+      );
+
+      await tester.tap(disabledCopyAction, warnIfMissed: false);
+      await tester.pump();
+      await tester.pump();
+      expect(find.text('Public key copied'), findsNothing);
+      // The valid scenario's npub is still the only clipboard write.
+      expect(clipboardTexts, hasLength(1));
 
       await tester.tap(find.byTooltip('Close sheet'));
       await tester.pumpAndSettle();
@@ -8416,6 +8636,79 @@ void main() {
       expect(tester.takeException(), isNull);
     });
 
+    testWidgets(
+      'profile sheet heading falls back to the compact npub for blank cached names',
+      (tester) async {
+        const alicePubkey =
+            'a11ce00000000000000000000000000000000000000000000000000000000000';
+        const bobPubkey =
+            'b0b0000000000000000000000000000000000000000000000000000000000000';
+
+        // The membership row opens the sheet for the joined member (bob).
+        // His cached display name is relay-valid but blank (empty and
+        // whitespace-only), so the heading must resolve through the shared
+        // nonblank-name label contract — the compact npub of the b0b key,
+        // never a blank heading. Keyed remounts keep each ProviderScope
+        // (and its user-cache override) fresh between scenarios.
+        for (final blankName in const ['', '   ']) {
+          await tester.pumpWidget(
+            KeyedSubtree(
+              key: ValueKey('blank-name-sheet-${blankName.length}'),
+              child: _buildTestable(
+                messages: [
+                  _systemMsg(
+                    id: 'sys-membership-blank-${blankName.length}',
+                    payload: {
+                      'type': 'member_joined',
+                      'actor': alicePubkey,
+                      'target': bobPubkey,
+                    },
+                  ),
+                ],
+                users: {
+                  alicePubkey: const UserProfile(
+                    pubkey: alicePubkey,
+                    displayName: 'Alice',
+                  ),
+                  bobPubkey: UserProfile(
+                    pubkey: bobPubkey,
+                    displayName: blankName,
+                  ),
+                },
+              ),
+            ),
+          );
+          await tester.pumpAndSettle();
+
+          await tester.tap(find.byType(CircleAvatar));
+          await tester.pumpAndSettle();
+
+          expect(find.byType(UserProfileSheet), findsOneWidget);
+          expect(
+            find.descendant(
+              of: find.byType(UserProfileSheet),
+              matching: find.text(blankName),
+            ),
+            findsNothing,
+          );
+          expect(
+            find.descendant(
+              of: find.byType(UserProfileSheet),
+              matching: find.text('npub1kzc…uyv8'),
+            ),
+            findsOneWidget,
+          );
+          // The full hex key is never rendered either.
+          expect(find.text(bobPubkey), findsNothing);
+
+          await tester.tap(find.byTooltip('Close sheet'));
+          await tester.pumpAndSettle();
+        }
+
+        expect(tester.takeException(), isNull);
+      },
+    );
+
     testWidgets('opens a profile sheet from a huddle system avatar', (
       tester,
     ) async {
@@ -14895,3 +15188,25 @@ class _TestNavigatorObserver extends NavigatorObserver {
     super.didPush(route, previousRoute);
   }
 }
+
+/// Avatar fallback initial in the DM header — asserts at the production
+/// seam (the masked `dm-header-avatar` badge), not the label helper.
+String _dmHeaderAvatarInitial(WidgetTester tester) {
+  final avatar = find.byKey(const ValueKey('dm-header-avatar'));
+  final initial = tester.widget<Text>(
+    find.descendant(of: avatar, matching: find.byType(Text)),
+  );
+  return initial.data!;
+}
+
+/// Avatar fallback initial in the channel-details member preview row keyed
+/// to [pubkey] — asserts at the production seam (the rendered
+/// `_ChannelMemberPreviewRow`), not the label helper.
+String _previewRowAvatarInitial(WidgetTester tester, String pubkey) {
+  final row = find.byKey(ValueKey('channel-details-member-$pubkey'));
+  final avatar = find.descendant(of: row, matching: find.byType(AvatarImage));
+  final initial = tester.widget<Text>(
+    find.descendant(of: avatar, matching: find.byType(Text)),
+  );
+  return initial.data!;
+}
diff --git a/mobile/test/features/channels/channel_management_provider_test.dart b/mobile/test/features/channels/channel_management_provider_test.dart
index 04b8c166718..69f588622b6 100644
--- a/mobile/test/features/channels/channel_management_provider_test.dart
+++ b/mobile/test/features/channels/channel_management_provider_test.dart
@@ -81,6 +81,69 @@ void main() {
     expect(users.first.avatarUrl, 'https://example.com/alice.png');
   });
 
+  group('identity labels', () {
+    // Valid fixture keys whose npub encodings were verified against the
+    // NIP-19 codec independently of the code under test.
+    const alicePubkey =
+        'a11ce00000000000000000000000000000000000000000000000000000000000';
+    const bobPubkey =
+        'b0b0000000000000000000000000000000000000000000000000000000000000';
+
+    test('member labels honor "You", authored names, and npub fallback', () {
+      final unnamed = ChannelMember(
+        pubkey: alicePubkey,
+        role: 'member',
+        joinedAt: DateTime.fromMillisecondsSinceEpoch(0),
+      );
+      final named = ChannelMember(
+        pubkey: alicePubkey,
+        role: 'member',
+        joinedAt: DateTime.fromMillisecondsSinceEpoch(0),
+        displayName: '  Alice  ',
+      );
+
+      // Unnamed members fall back to the compact npub …
+      expect(unnamed.labelFor(null), 'npub15yw…ccpw');
+      // … but only the member's own identity is "You" — never the caller's key.
+      expect(unnamed.labelFor(alicePubkey), 'You');
+      expect(unnamed.labelFor(alicePubkey.toUpperCase()), 'You');
+      expect(unnamed.labelFor(bobPubkey), 'npub15yw…ccpw');
+      // An authored display name wins over every fallback.
+      expect(named.labelFor(bobPubkey), 'Alice');
+    });
+
+    test(
+      'directory labels keep names, one-line npub fallbacks, and initials',
+      () {
+        final unnamed = DirectoryUser(pubkey: alicePubkey);
+        final alsoUnnamed = DirectoryUser(pubkey: bobPubkey);
+        final named = DirectoryUser(
+          pubkey: alicePubkey,
+          displayName: 'Alice',
+          nip05Handle: 'alice@example.com',
+        );
+
+        // Unnamed: the primary label is already the compact key, so a
+        // second key-shaped line would only duplicate it.
+        expect(unnamed.label, 'npub15yw…ccpw');
+        expect(unnamed.secondaryLabel, '');
+        // Initials stay hex-derived — a compact npub would render `N` for all.
+        expect(unnamed.initial, 'A');
+        expect(alsoUnnamed.initial, 'B');
+        // Named: the authored name leads, the handle keys the second line.
+        expect(named.label, 'Alice');
+        expect(named.secondaryLabel, 'alice@example.com');
+        expect(named.initial, 'A');
+      },
+    );
+
+    test('add-members failures identify the member by compact npub', () {
+      const failure = AddMembersException({alicePubkey: 'not a member'});
+
+      expect(failure.message, 'npub15yw…ccpw: not a member');
+    });
+  });
+
   test('propagates archived state from kind:39000 archived tag', () {
     // Regression: previously this mapping ignored the `archived` tag, so
     // `Channel.mergeDetails` would clear the archived flag the list provider
diff --git a/mobile/test/features/channels/channels_page_test.dart b/mobile/test/features/channels/channels_page_test.dart
index 44f8714c64f..6293ae373e9 100644
--- a/mobile/test/features/channels/channels_page_test.dart
+++ b/mobile/test/features/channels/channels_page_test.dart
@@ -19,6 +19,7 @@ import 'package:buzz/features/channels/unread_badge/observed_unread_event.dart';
 import 'package:buzz/features/profile/profile_avatar.dart';
 import 'package:buzz/features/profile/profile_provider.dart';
 import 'package:buzz/shared/profile/user_profile.dart';
+import 'package:buzz/shared/utils/string_utils.dart';
 import 'package:buzz/shared/auth/auth.dart';
 import 'package:buzz/shared/community/community_icon_provider.dart';
 import 'package:buzz/shared/relay/relay.dart';
@@ -42,11 +43,14 @@ void main() {
     Gradient? topSectionGradient,
     ValueChanged<double>? onSettingsTransitionProgress,
     ValueListenable<int>? tabReselection,
+    _FakeProfileNotifier? profile,
   }) {
     return ProviderScope(
       overrides: [
-        // Provide a fake profile and presence so the avatar doesn't hit the network.
-        profileProvider.overrideWith(() => _FakeProfileNotifier()),
+        // Provide a fake profile and presence so the avatar doesn't hit the
+        // network. [profile] swaps the current user for tests keyed to a
+        // different identity (the page reads its pubkey from profileProvider).
+        profileProvider.overrideWith(() => profile ?? _FakeProfileNotifier()),
         presenceProvider.overrideWith(() => _FakePresenceNotifier()),
         communityIconProvider.overrideWith((ref, relayUrl) async {
           onCommunityIconLoad?.call(relayUrl);
@@ -124,17 +128,51 @@ void main() {
       createdBy: 'abc',
       createdAt: DateTime(2025),
       memberCount: 2,
-      participants: const ['Test', 'Alice'],
-      participantPubkeys: const ['aabb', 'alice'],
+      participants: const ['Alice', 'Test'],
+      participantPubkeys: const ['alice', 'aabb'],
       isMember: true,
     ),
   ];
 
   testWidgets('shows grouped channel list when data loads', (tester) async {
+    // Valid fixture keys whose npub encodings were verified against the
+    // NIP-19 codec independently of the code under test.
+    const a11ce =
+        'a11ce00000000000000000000000000000000000000000000000000000000000';
+    const b0b =
+        'b0b0000000000000000000000000000000000000000000000000000000000000';
+    final unnamedDm = Channel(
+      id: 'dm-unnamed',
+      name: 'DM',
+      channelType: 'dm',
+      visibility: 'open',
+      description: 'Direct message',
+      createdBy: 'aabb',
+      createdAt: DateTime(2025),
+      memberCount: 2,
+      participants: [shortPubkey(a11ce), 'Test'],
+      participantPubkeys: const [a11ce, 'aabb'],
+      isMember: true,
+    );
+    final groupDm = Channel(
+      id: 'dm-group',
+      name: 'Group DM',
+      channelType: 'dm',
+      visibility: 'open',
+      description: 'Direct message',
+      createdBy: 'aabb',
+      createdAt: DateTime(2025),
+      memberCount: 3,
+      participants: [shortPubkey(a11ce), shortPubkey(b0b), 'Test'],
+      participantPubkeys: const [a11ce, b0b, 'aabb'],
+      isMember: true,
+    );
     await tester.pumpWidget(
       buildTestable(
         overrides: [
-          channelsProvider.overrideWith(() => _FakeNotifier(testChannels)),
+          channelsProvider.overrideWith(
+            () => _FakeNotifier([...testChannels, unnamedDm, groupDm]),
+          ),
         ],
       ),
     );
@@ -153,6 +191,26 @@ void main() {
     expect(find.byIcon(LucideIcons.arrowUpDown), findsNothing);
     expect(find.byTooltip('DMs options'), findsOneWidget);
 
+    // DM identity display: the unnamed counterpart tile renders its
+    // compact npub label, but its avatar initial stays keyed to the hex
+    // public key — never the `N` the npub label starts with. The named
+    // tile keeps its authored initial from the positional participant
+    // label even without a cached profile.
+    expect(find.text(shortPubkey(a11ce)), findsOneWidget);
+    expect(_dmTileAvatarInitial(tester, shortPubkey(a11ce)), 'A');
+    expect(_dmTileAvatarInitial(tester, 'Alice'), 'A');
+    // A multi-counterpart DM still takes the group count badge — the
+    // single-counterpart avatar above is not shared with it.
+    final groupTile = _dmTileFor('${shortPubkey(a11ce)}, ${shortPubkey(b0b)}');
+    expect(
+      find.descendant(of: groupTile, matching: find.byType(AvatarImage)),
+      findsNothing,
+    );
+    expect(
+      find.descendant(of: groupTile, matching: find.text('2')),
+      findsOneWidget,
+    );
+
     await tester.tap(find.byTooltip('Channels options'));
     await tester.pumpAndSettle();
     expect(find.text('Sort: Recent'), findsOneWidget);
@@ -195,6 +253,103 @@ void main() {
     expect(sectionTitle.style?.fontWeight, FontWeight.w600);
   });
 
+  testWidgets('keys DM tile fallback avatars to the non-self counterpart', (
+    tester,
+  ) async {
+    // Valid fixture keys whose npub encodings were verified against the
+    // NIP-19 codec independently of the code under test. The current user
+    // (aabb, from the fake profile) is listed FIRST — member order does
+    // not guarantee the counterpart is first — so an avatar that keys off
+    // the first participant would identify the current user while the
+    // label beside it identifies the counterpart.
+    const b0b =
+        'b0b0000000000000000000000000000000000000000000000000000000000000';
+    final selfFirstUnnamedDm = Channel(
+      id: 'dm-self-first-unnamed',
+      name: 'DM',
+      channelType: 'dm',
+      visibility: 'open',
+      description: 'Direct message',
+      createdBy: 'aabb',
+      createdAt: DateTime(2025),
+      memberCount: 2,
+      participants: ['Test', shortPubkey(b0b)],
+      participantPubkeys: const ['aabb', b0b],
+      isMember: true,
+    );
+    final selfFirstNamedDm = Channel(
+      id: 'dm-self-first-named',
+      name: 'DM',
+      channelType: 'dm',
+      visibility: 'open',
+      description: 'Direct message',
+      createdBy: 'aabb',
+      createdAt: DateTime(2025),
+      memberCount: 2,
+      participants: const ['Test', 'Dana'],
+      participantPubkeys: const ['aabb', b0b],
+      isMember: true,
+    );
+    await tester.pumpWidget(
+      buildTestable(
+        overrides: [
+          channelsProvider.overrideWith(
+            () => _FakeNotifier([selfFirstUnnamedDm, selfFirstNamedDm]),
+          ),
+        ],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    // Label and avatar agree on the counterpart's key: the compact npub
+    // names the unnamed counterpart, and the avatar initial is keyed to
+    // that same hex key — never the current user's `A`.
+    expect(find.text(shortPubkey(b0b)), findsOneWidget);
+    expect(_dmTileAvatarInitial(tester, shortPubkey(b0b)), 'B');
+    // A named counterpart listed second keeps its authored initial too —
+    // `D`, not its key's `B`, proves the name is the initial's source.
+    expect(_dmTileAvatarInitial(tester, 'Dana'), 'D');
+  });
+
+  testWidgets('keys the self-DM tile avatar to the current user key', (
+    tester,
+  ) async {
+    // A self-DM lists only the current user, so the tile label falls back
+    // to the sole participant — the compact npub of the current user's
+    // own key.
+    const b0b =
+        'b0b0000000000000000000000000000000000000000000000000000000000000';
+    final selfDm = Channel(
+      id: 'dm-self',
+      name: 'DM',
+      channelType: 'dm',
+      visibility: 'open',
+      description: 'Direct message',
+      createdBy: b0b,
+      createdAt: DateTime(2025),
+      memberCount: 1,
+      participants: [shortPubkey(b0b)],
+      participantPubkeys: const [b0b],
+      isMember: true,
+    );
+    await tester.pumpWidget(
+      buildTestable(
+        // The tile reads the current user's pubkey from profileProvider, so
+        // the self-DM needs the fake profile keyed to the same participant.
+        profile: _FakeProfileNotifier(pubkey: b0b),
+        overrides: [
+          channelsProvider.overrideWith(() => _FakeNotifier([selfDm])),
+        ],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    // The compact-npub label and its avatar identify the same key: the
+    // hex-key initial `B`, never the `N` the npub label starts with.
+    expect(find.text(shortPubkey(b0b)), findsOneWidget);
+    expect(_dmTileAvatarInitial(tester, shortPubkey(b0b)), 'B');
+  });
+
   testWidgets('sizes the community header for accessible text', (tester) async {
     await tester.pumpWidget(
       buildTestable(
@@ -2517,9 +2672,15 @@ class _ReconnectingRelaySession extends RelaySessionNotifier {
 }
 
 class _FakeProfileNotifier extends ProfileNotifier {
+  _FakeProfileNotifier({this.pubkey = 'aabb'});
+
+  /// Current-user pubkey; the default keeps the historical 'aabb' fake used
+  /// by the other tile tests. The display name stays 'Test'.
+  final String pubkey;
+
   @override
   Future<UserProfile?> build() async =>
-      const UserProfile(pubkey: 'aabb', displayName: 'Test');
+      UserProfile(pubkey: pubkey, displayName: 'Test');
 }
 
 class _FakePresenceNotifier extends PresenceNotifier {
@@ -2578,3 +2739,20 @@ ObservedUnreadEvent _observed({
   channelType: 'stream',
   isThreadedReply: isThreadedReply,
 );
+
+/// The channel tile (its `InkWell`) that renders [labelText] as its row
+/// label.
+Finder _dmTileFor(String labelText) => find
+    .ancestor(of: find.text(labelText), matching: find.byType(InkWell))
+    .first;
+
+/// Avatar fallback initial for the DM tile rendering [labelText] — asserts at
+/// the production seam (the tile's `_DmAvatar`), not the label helper.
+String _dmTileAvatarInitial(WidgetTester tester, String labelText) {
+  final tile = _dmTileFor(labelText);
+  final avatar = find.descendant(of: tile, matching: find.byType(AvatarImage));
+  final initial = tester.widget<Text>(
+    find.descendant(of: avatar, matching: find.byType(Text)),
+  );
+  return initial.data!;
+}
diff --git a/mobile/test/features/channels/compose_bar_test.dart b/mobile/test/features/channels/compose_bar_test.dart
index 23b19d95577..b8025112a25 100644
--- a/mobile/test/features/channels/compose_bar_test.dart
+++ b/mobile/test/features/channels/compose_bar_test.dart
@@ -26,7 +26,9 @@ import 'package:buzz/shared/custom_emoji/custom_emoji_provider.dart';
 import 'package:buzz/shared/mentions/agent_identity_provider.dart';
 import 'package:buzz/shared/relay/relay.dart';
 import 'package:buzz/shared/theme/theme.dart';
+import 'package:buzz/shared/utils/string_utils.dart';
 import 'package:buzz/shared/widgets/anchored_popover_menu.dart';
+import 'package:buzz/shared/widgets/avatar_image.dart';
 import 'package:buzz/shared/widgets/mobile_tab_footer_backdrop.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
@@ -1643,6 +1645,12 @@ void main() {
       addTearDown(() {
         if (!pendingMembers.isCompleted) pendingMembers.complete(const []);
       });
+      // Valid fixture keys whose npub encodings were verified against the
+      // NIP-19 codec independently of the code under test.
+      const a11ce =
+          'a11ce00000000000000000000000000000000000000000000000000000000000';
+      const b0b =
+          'b0b0000000000000000000000000000000000000000000000000000000000000';
       await tester.pumpWidget(
         _buildComposeBar(
           uploadService: _testUploadService(nostr.Keys.generate().nsec),
@@ -1654,6 +1662,17 @@ void main() {
               joinedAt: DateTime.fromMillisecondsSinceEpoch(1000),
               displayName: 'Alice',
             ),
+            ChannelMember(
+              pubkey: a11ce,
+              role: 'member',
+              joinedAt: DateTime.fromMillisecondsSinceEpoch(2000),
+            ),
+            ChannelMember(
+              pubkey: b0b,
+              role: 'member',
+              joinedAt: DateTime.fromMillisecondsSinceEpoch(3000),
+              displayName: 'Carol',
+            ),
           ],
           channels: [_makeCurrentChannel()],
           onSend:
@@ -1675,6 +1694,13 @@ void main() {
         findsOneWidget,
       );
       expect(find.text('Alice'), findsOneWidget);
+      // The unnamed member renders its compact npub label, but its avatar
+      // initial stays keyed to the hex public key — never the `N` the npub
+      // label starts with. A named member keeps its authored initial even
+      // though its key would render `B`.
+      expect(find.text(shortPubkey(a11ce)), findsOneWidget);
+      expect(_suggestionAvatarInitial(tester, shortPubkey(a11ce)), 'A');
+      expect(_suggestionAvatarInitial(tester, 'Carol'), 'C');
     });
 
     testWidgets('dismisses mention suggestions in the selection frame', (
@@ -5555,6 +5581,20 @@ List<({String text, TextStyle style})> _flattenStyledTextSpans(
   return result;
 }
 
+/// Avatar fallback initial rendered for the mention suggestion row titled
+/// [labelText] — asserts at the production seam, not the model getter.
+String _suggestionAvatarInitial(WidgetTester tester, String labelText) {
+  final row = find.ancestor(
+    of: find.text(labelText),
+    matching: find.byType(ListTile),
+  );
+  final avatar = find.descendant(of: row, matching: find.byType(AvatarImage));
+  final initial = tester.widget<Text>(
+    find.descendant(of: avatar, matching: find.byType(Text)),
+  );
+  return initial.data!;
+}
+
 Channel _makeCurrentChannel({
   String channelType = 'stream',
   String visibility = 'open',
diff --git a/mobile/test/features/channels/mentions/mention_candidates_test.dart b/mobile/test/features/channels/mentions/mention_candidates_test.dart
index 9694d68535d..9a0b655f4bf 100644
--- a/mobile/test/features/channels/mentions/mention_candidates_test.dart
+++ b/mobile/test/features/channels/mentions/mention_candidates_test.dart
@@ -19,8 +19,9 @@ ChannelMember member(String pubkey, {String role = 'member'}) {
 }
 
 void main() {
-  test('role-only agent mentions fall back to a pubkey prefix label', () {
-    const pubkey = 'deadbeef0123456789';
+  test('role-only agent mentions fall back to a compact npub label', () {
+    const pubkey =
+        'deadbeef00000000000000000000000000000000000000000000000000000000';
 
     expect(
       mentionNamesWithDirectoryLabels(
@@ -29,7 +30,7 @@ void main() {
         directoryDisplayNames: const {},
         agentMentionPubkeys: const {pubkey},
       ),
-      const {pubkey: 'deadbeef'},
+      const {pubkey: 'npub1m6k\u20263kf3'},
     );
   });
 
@@ -61,14 +62,14 @@ void main() {
       expect(formatOwnerLabel(userPubkey, userPubkey, const {}), 'you');
     });
 
-    test('prefers display name, then handle, then pubkey prefix', () {
+    test('prefers display name, then handle, then compact npub', () {
       final profiles = {
         ownerPubkey: UserProfile(pubkey: ownerPubkey, displayName: 'Wes'),
       };
       expect(formatOwnerLabel(ownerPubkey, userPubkey, profiles), 'Wes');
       expect(
         formatOwnerLabel(ownerPubkey, userPubkey, const {}),
-        '${'d' * 8}\u2026',
+        'npub1mhw\u2026dmpv',
       );
     });
 
diff --git a/mobile/test/features/forum/forum_widgets_test.dart b/mobile/test/features/forum/forum_widgets_test.dart
index 338dbf36ac3..2d220265302 100644
--- a/mobile/test/features/forum/forum_widgets_test.dart
+++ b/mobile/test/features/forum/forum_widgets_test.dart
@@ -208,13 +208,18 @@ void main() {
       expect(find.text('Hello forum'), findsOneWidget);
     });
 
-    testWidgets('shows truncated pubkey when no profile', (tester) async {
+    testWidgets('shows compact npub when no profile', (tester) async {
       await tester.pumpWidget(
-        _buildPostCard(post: _makePost(pubkey: 'abcdef1234567890')),
+        _buildPostCard(
+          post: _makePost(
+            pubkey:
+                'abcdef0000000000000000000000000000000000000000000000000000000000',
+          ),
+        ),
       );
       await tester.pumpAndSettle();
 
-      expect(find.text('abcdef12\u2026'), findsOneWidget);
+      expect(find.text('npub140x\u2026etzk'), findsOneWidget);
     });
 
     testWidgets('uses directory classification for uncached author avatar', (
diff --git a/mobile/test/features/invites/invite_create_page_test.dart b/mobile/test/features/invites/invite_create_page_test.dart
index 9aecfd10e50..5e6970151c5 100644
--- a/mobile/test/features/invites/invite_create_page_test.dart
+++ b/mobile/test/features/invites/invite_create_page_test.dart
@@ -5,6 +5,7 @@ import 'package:buzz/features/invites/invite_create_provider.dart';
 import 'package:buzz/shared/community/community_membership_provider.dart';
 import 'package:buzz/shared/relay/relay.dart';
 import 'package:buzz/shared/theme/theme.dart';
+import 'package:buzz/shared/utils/string_utils.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
@@ -162,7 +163,7 @@ void main() {
       find.byKey(const Key('community-invite-resolved-$pastedPubkey')),
       findsOneWidget,
     );
-    expect(find.text(shortCommunityInviteNpub(pastedPubkey)), findsOneWidget);
+    expect(find.text(shortPubkey(pastedPubkey)), findsOneWidget);
     expect(find.text('Resolved person'), findsNothing);
     expect(find.text('person@example.com'), findsNothing);
     expect(
@@ -270,7 +271,7 @@ void main() {
       findsOneWidget,
     );
     expect(find.text('Profile not found'), findsNothing);
-    expect(find.text(shortCommunityInviteNpub(pastedPubkey)), findsOneWidget);
+    expect(find.text(shortPubkey(pastedPubkey)), findsOneWidget);
     expect(find.byKey(const Key('community-invite-submit')), findsOneWidget);
 
     await tester.tap(find.byKey(const Key('community-invite-submit')));
diff --git a/mobile/test/features/profile/profile_provider_test.dart b/mobile/test/features/profile/profile_provider_test.dart
index 5638656b715..93c68cfa202 100644
--- a/mobile/test/features/profile/profile_provider_test.dart
+++ b/mobile/test/features/profile/profile_provider_test.dart
@@ -7,6 +7,7 @@ import 'package:buzz/shared/profile/user_cache_provider.dart';
 import 'package:buzz/shared/profile/user_profile.dart';
 import 'package:buzz/shared/relay/relay.dart';
 import 'package:buzz/shared/theme/theme.dart';
+import 'package:buzz/shared/utils/string_utils.dart';
 import 'package:flutter/widgets.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
@@ -106,7 +107,9 @@ void main() {
     expect(content, {'about': 'Building Buzz'});
     final profile = container.read(profileProvider).requireValue!;
     expect(profile.displayName, isNull);
-    expect(profile.label, '${keys.public.substring(0, 8)}...');
+    // The exact compact label is pinned; its npub shape is covered by the
+    // shared string_utils vectors.
+    expect(profile.label, shortPubkey(keys.public));
   });
 
   test('malformed profile metadata can be repaired by an edit', () async {
diff --git a/mobile/test/features/pulse/compose_note_page_test.dart b/mobile/test/features/pulse/compose_note_page_test.dart
index 7b2e7480ac3..d0650a5bc5e 100644
--- a/mobile/test/features/pulse/compose_note_page_test.dart
+++ b/mobile/test/features/pulse/compose_note_page_test.dart
@@ -6,6 +6,7 @@ import 'package:buzz/shared/profile/user_profile.dart';
 import 'package:buzz/features/pulse/compose_note_page.dart';
 import 'package:buzz/features/pulse/pulse_models.dart';
 import 'package:buzz/shared/theme/theme.dart';
+import 'package:buzz/shared/widgets/avatar_image.dart';
 
 class _FakeUserCacheNotifier extends UserCacheNotifier {
   final Map<String, UserProfile> _users;
@@ -13,6 +14,9 @@ class _FakeUserCacheNotifier extends UserCacheNotifier {
 
   @override
   Map<String, UserProfile> build() => _users;
+
+  @override
+  UserProfile? get(String pubkey) => _users[pubkey.toLowerCase()];
 }
 
 void main() {
@@ -28,16 +32,20 @@ void main() {
     Widget home, {
     TextScaler textScaler = TextScaler.noScaling,
     String displayName = 'Alice',
+    Map<String, UserProfile>? users,
   }) {
     return ProviderScope(
       overrides: [
         userCacheProvider.overrideWith(
-          () => _FakeUserCacheNotifier({
-            'alice_pk': UserProfile(
-              pubkey: 'alice_pk',
-              displayName: displayName,
-            ),
-          }),
+          () => _FakeUserCacheNotifier(
+            users ??
+                {
+                  'alice_pk': UserProfile(
+                    pubkey: 'alice_pk',
+                    displayName: displayName,
+                  ),
+                },
+          ),
         ),
       ],
       child: MaterialApp(
@@ -62,6 +70,8 @@ void main() {
     expect(find.text('Alice'), findsOneWidget); // author name in the row
     expect(find.textContaining('original note being replied to'), findsWidgets);
     expect(find.text('Reply'), findsOneWidget); // action button label
+    // Named parent: the preview avatar initial comes from the authored name.
+    expect(_replyPreviewAvatarInitial(tester, 'Replying to Alice'), 'A');
   });
 
   testWidgets('reply preview constrains its timestamp at large text sizes', (
@@ -167,4 +177,50 @@ void main() {
     final dividerTop = tester.getRect(find.byType(Divider)).top;
     expect(dividerTop - labelTop, lessThan(220));
   });
+
+  testWidgets('reply preview keys unnamed parent authors to their hex key', (
+    tester,
+  ) async {
+    const a11ce =
+        'a11ce00000000000000000000000000000000000000000000000000000000000';
+
+    final unnamedParentNote = UserNote(
+      id: 'note-unnamed-parent',
+      pubkey: a11ce,
+      createdAt: DateTime.now().millisecondsSinceEpoch ~/ 1000 - 120,
+      content: 'The original note being replied to',
+      tags: const [],
+    );
+
+    await tester.pumpWidget(
+      buildTestable(
+        ComposeNotePage(replyTo: unnamedParentNote),
+        users: const {},
+      ),
+    );
+    await tester.pump();
+
+    expect(find.text('Replying to npub15yw\u2026ccpw'), findsOneWidget);
+    expect(
+      _replyPreviewAvatarInitial(tester, 'Replying to npub15yw\u2026ccpw'),
+      'A',
+    );
+  });
+}
+
+/// Avatar fallback initial in the reply-context preview, located by the
+/// `Replying to` label it renders beside — the parent author's avatar, not
+/// the composer's.
+String _replyPreviewAvatarInitial(WidgetTester tester, String replyingLabel) {
+  final preview = find
+      .ancestor(of: find.text(replyingLabel), matching: find.byType(Column))
+      .first;
+  final avatar = find.descendant(
+    of: preview,
+    matching: find.byType(AvatarImage),
+  );
+  final initial = tester.widget<Text>(
+    find.descendant(of: avatar, matching: find.byType(Text)),
+  );
+  return initial.data!;
 }
diff --git a/mobile/test/features/pulse/note_card_test.dart b/mobile/test/features/pulse/note_card_test.dart
index 2b59d1838d3..baa4fbe2dd3 100644
--- a/mobile/test/features/pulse/note_card_test.dart
+++ b/mobile/test/features/pulse/note_card_test.dart
@@ -3,6 +3,7 @@ import 'package:buzz/shared/profile/user_profile.dart';
 import 'package:buzz/features/pulse/note_card.dart';
 import 'package:buzz/features/pulse/pulse_models.dart';
 import 'package:buzz/shared/theme/theme.dart';
+import 'package:buzz/shared/widgets/avatar_image.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
@@ -127,4 +128,170 @@ void main() {
     expect(find.text('2m'), findsOneWidget);
     expect(tester.takeException(), isNull);
   });
+
+  testWidgets(
+    'reply targets and author identities render npub keys, hex event ids, '
+    'and keyed avatar initials',
+    (tester) async {
+      const b0b =
+          'b0b0000000000000000000000000000000000000000000000000000000000000';
+      const a11ce =
+          'a11ce00000000000000000000000000000000000000000000000000000000000';
+      const parentEventId =
+          'feedbeef00000000000000000000000000000000000000000000000000000000';
+
+      UserNote noteOf(String id, List<List<String>> tags) => UserNote(
+        id: id,
+        pubkey: b0b,
+        createdAt: DateTime.utc(2025, 9, 30, 12).millisecondsSinceEpoch ~/ 1000,
+        content: 'A reply',
+        tags: tags,
+      );
+
+      final scenarios =
+          <
+            ({
+              String id,
+              List<List<String>> tags,
+              Map<String, UserProfile> users,
+              String authorLabel,
+              String? replyLabel,
+              int npubLabelCount,
+              String avatarInitial,
+            })
+          >[
+            // `p`-tagged parent: the reply target is a public key, so it renders
+            // the compact npub — a second npub beside the unnamed author's own.
+            (
+              id: 'reply-parent-author',
+              tags: [
+                ['e', parentEventId, '', 'reply'],
+                ['p', a11ce],
+              ],
+              users: const {},
+              authorLabel: 'npub1kzc\u2026uyv8',
+              replyLabel: 'Replying to npub15yw\u2026ccpw',
+              npubLabelCount: 2,
+              avatarInitial: 'B',
+            ),
+            // No `p` tag — the parent author is unknown, so the reply target
+            // falls back to the parent event id, which is not a public key: it
+            // keeps its hex truncation and stays out of the npub contract.
+            (
+              id: 'reply-parent-event',
+              tags: [
+                ['e', parentEventId, '', 'reply'],
+              ],
+              users: const {},
+              authorLabel: 'npub1kzc\u2026uyv8',
+              replyLabel: 'Replying to feedbeef\u2026',
+              npubLabelCount: 1,
+              avatarInitial: 'B',
+            ),
+            // Cached author: the authored name wins for both the label and the
+            // avatar initial.
+            (
+              id: 'cached-named-author',
+              tags: const [],
+              users: {
+                b0b: const UserProfile(pubkey: b0b, displayName: 'Carol'),
+              },
+              authorLabel: 'Carol',
+              replyLabel: null,
+              npubLabelCount: 0,
+              avatarInitial: 'C',
+            ),
+            // Cached blank display names (empty or whitespace-only — relay
+            // profiles can carry both) must fall back to the compact npub
+            // for the label instead of rendering an empty author row.
+            (
+              id: 'cached-blank-name-author',
+              tags: const [],
+              users: {b0b: const UserProfile(pubkey: b0b, displayName: '')},
+              authorLabel: 'npub1kzc\u2026uyv8',
+              replyLabel: null,
+              npubLabelCount: 1,
+              avatarInitial: 'B',
+            ),
+            (
+              id: 'cached-whitespace-name-author',
+              tags: const [],
+              users: {b0b: const UserProfile(pubkey: b0b, displayName: '   ')},
+              authorLabel: 'npub1kzc\u2026uyv8',
+              replyLabel: null,
+              npubLabelCount: 1,
+              avatarInitial: 'B',
+            ),
+          ];
+
+      for (final scenario in scenarios) {
+        // Each scenario remounts its own ProviderScope: Riverpod keeps an
+        // updated scope's container, so an already-initialized user cache
+        // would otherwise serve the first scenario's overrides.
+        await tester.pumpWidget(
+          KeyedSubtree(
+            key: ValueKey(scenario.id),
+            child: ProviderScope(
+              overrides: [
+                userCacheProvider.overrideWith(
+                  () => _FakeUserCacheNotifier(scenario.users),
+                ),
+              ],
+              child: MaterialApp(
+                theme: AppTheme.light(),
+                home: Scaffold(
+                  body: NoteCard(
+                    note: noteOf(scenario.id, scenario.tags),
+                    reaction: const PulseReactionState(
+                      count: 0,
+                      reactedByCurrentUser: false,
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        expect(
+          find.text(scenario.authorLabel),
+          findsOneWidget,
+          reason: scenario.id,
+        );
+        expect(
+          find.textContaining('npub'),
+          findsNWidgets(scenario.npubLabelCount),
+          reason: scenario.id,
+        );
+        if (scenario.replyLabel != null) {
+          expect(
+            find.text(scenario.replyLabel!),
+            findsOneWidget,
+            reason: scenario.id,
+          );
+        }
+        // Unnamed authors key the avatar initial to the hex public key
+        // (never the `N` every npub label starts with); a cached profile
+        // switches it to the authored-name initial.
+        expect(
+          _noteCardAvatarInitial(tester),
+          scenario.avatarInitial,
+          reason: scenario.id,
+        );
+        expect(tester.takeException(), isNull, reason: scenario.id);
+      }
+    },
+  );
+}
+
+/// Avatar fallback initial of the single rendered [NoteCard] — asserts at
+/// the production seam (the rendered card), not the model getter.
+String _noteCardAvatarInitial(WidgetTester tester) {
+  final card = find.byType(NoteCard);
+  final avatar = find.descendant(of: card, matching: find.byType(AvatarImage));
+  final initial = tester.widget<Text>(
+    find.descendant(of: avatar, matching: find.byType(Text)),
+  );
+  return initial.data!;
 }
diff --git a/mobile/test/features/settings/connection_section_test.dart b/mobile/test/features/settings/connection_section_test.dart
index b8e3464c2e9..2eb8304fe56 100644
--- a/mobile/test/features/settings/connection_section_test.dart
+++ b/mobile/test/features/settings/connection_section_test.dart
@@ -53,9 +53,27 @@ void main() {
     final expectedPubkey = nostr.Keys(
       '1111111111111111111111111111111111111111111111111111111111111111',
     ).public;
+    // Keys('1'×64).public ↔ this npub — the NIP-19 canonical vector for the
+    // identity row, hardcoded so the codec itself stays under test.
+    const expectedNpub =
+        'npub1fu64hh9hes90w2808n8tjc2ajp5yhddjef0ctx4s7zmsgp6cwx4qgy4eg9';
     expect(find.text('Connected to'), findsNothing);
     expect(find.text('https://relay.test'), findsNothing);
+    // Neither the raw hex key nor the full npub is rendered visually — the
+    // full npub is exposed through a11y and the clipboard only.
     expect(find.text(expectedPubkey), findsNothing);
+    expect(find.text(expectedNpub), findsNothing);
+    // The identity row's a11y value carries the full npub (not raw hex).
+    expect(
+      find.ancestor(
+        of: find.text('Identity (pubkey)'),
+        matching: find.byWidgetPredicate(
+          (widget) =>
+              widget is Semantics && widget.properties.value == expectedNpub,
+        ),
+      ),
+      findsOneWidget,
+    );
     final copy = tester.getRect(find.byIcon(LucideIcons.copy));
     final chevron = tester.getRect(find.byIcon(LucideIcons.chevronRight).first);
     expect(copy.center.dx, closeTo(chevron.center.dx, 0.5));
@@ -63,7 +81,7 @@ void main() {
     await tester.tap(find.text('Identity (pubkey)'));
     await tester.pump();
     expect(clipboardCall?.method, 'Clipboard.setData');
-    expect(clipboardCall?.arguments, {'text': expectedPubkey});
+    expect(clipboardCall?.arguments, {'text': expectedNpub});
     expect(find.text('Pubkey copied'), findsOneWidget);
   });
 
diff --git a/mobile/test/shared/profile/user_profile_test.dart b/mobile/test/shared/profile/user_profile_test.dart
new file mode 100644
index 00000000000..a2e9117936a
--- /dev/null
+++ b/mobile/test/shared/profile/user_profile_test.dart
@@ -0,0 +1,36 @@
+import 'package:buzz/shared/profile/user_profile.dart';
+import 'package:buzz/shared/utils/string_utils.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('UserProfile label and initial', () {
+    // Valid fixture key whose npub encoding was verified against the NIP-19
+    // codec independently of the code under test.
+    const b0b =
+        'b0b0000000000000000000000000000000000000000000000000000000000000';
+
+    // Relay profiles can carry a blank `display_name` (empty or
+    // whitespace-only) and reach the cache unchanged, so both accessors must
+    // reject blank names and fall back to the key instead of rendering an
+    // empty label. Nonblank names render as authored: `label` only tests
+    // blankness with trim, while `initial` reads the trimmed padding.
+    final cases = <({String? displayName, String label, String initial})>[
+      (displayName: null, label: shortPubkey(b0b), initial: 'B'),
+      (displayName: '', label: shortPubkey(b0b), initial: 'B'),
+      (displayName: '   ', label: shortPubkey(b0b), initial: 'B'),
+      (displayName: 'Carol', label: 'Carol', initial: 'C'),
+      (displayName: ' Carol ', label: ' Carol ', initial: 'C'),
+    ];
+
+    for (final testCase in cases) {
+      test('displayName ${testCase.displayName ?? '(null)'}', () {
+        final profile = UserProfile(
+          pubkey: b0b,
+          displayName: testCase.displayName,
+        );
+        expect(profile.label, testCase.label);
+        expect(profile.initial, testCase.initial);
+      });
+    }
+  });
+}
diff --git a/mobile/test/shared/utils/string_utils_test.dart b/mobile/test/shared/utils/string_utils_test.dart
new file mode 100644
index 00000000000..f5188c2a680
--- /dev/null
+++ b/mobile/test/shared/utils/string_utils_test.dart
@@ -0,0 +1,90 @@
+import 'package:buzz/features/invites/invite_create_provider.dart';
+import 'package:buzz/shared/utils/string_utils.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:nostr/nostr.dart' as nostr;
+
+/// Tests for the npub identity helpers shared by every mobile surface.
+///
+/// The canonical vector comes from the NIP-19 specification itself, so these
+/// tests fail if the encoding (or the truncation policy) drifts — they never
+/// re-derive expectations from the codec under test.
+void main() {
+  const canonicalHex =
+      '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d';
+  const canonicalNpub =
+      'npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6';
+  const canonicalCompact = 'npub180c\u2026h6w6';
+
+  group('fullNpub', () {
+    test('canonicalizes every accepted input wrapper', () {
+      // Every accepted wrapper — lowercase hex, uppercase hex, whitespace-
+      // padded, and an already-npub key — converges on the canonical npub.
+      final inputs = <String>[
+        canonicalHex,
+        canonicalHex.toUpperCase(),
+        '  $canonicalHex \n',
+        canonicalNpub,
+      ];
+      for (final input in inputs) {
+        expect(fullNpub(input), canonicalNpub, reason: input);
+      }
+    });
+
+    test('rejects malformed identities without echoing them back', () {
+      expect(fullNpub(''), isNull);
+      expect(fullNpub('unknown'), isNull);
+      // Wrong-length hex.
+      expect(fullNpub('a' * 63), isNull);
+      expect(fullNpub('a' * 65), isNull);
+      // Hex-length but not hex.
+      expect(fullNpub('z' * 64), isNull);
+      // Not decodable bech32.
+      expect(fullNpub('npub1garbage'), isNull);
+      // Mixed-case bech32 is invalid by checksum.
+      final mixedCase =
+          '${canonicalNpub.substring(0, 20)}'
+          '${canonicalNpub.substring(20).toUpperCase()}';
+      expect(fullNpub(mixedCase), isNull);
+      // Valid NIP-19 forms that are not public keys stay out of the npub
+      // contract instead of leaking their payload.
+      final nsec = nostr.Nip19.encode(
+        prefix: nostr.Nip19Prefix.nsec,
+        data: canonicalHex,
+      );
+      expect(fullNpub(nsec), isNull);
+      final note = nostr.Nip19.encode(
+        prefix: nostr.Nip19Prefix.note,
+        data: canonicalHex,
+      );
+      expect(fullNpub(note), isNull);
+    });
+  });
+
+  group('shortPubkey', () {
+    test('renders the compact npub label — first 8 … last 4', () {
+      expect(shortPubkey(canonicalHex), canonicalCompact);
+    });
+
+    test('is idempotent for already-npub input', () {
+      expect(shortPubkey(canonicalNpub), canonicalCompact);
+    });
+
+    test('returns the neutral label for invalid identities', () {
+      expect(shortPubkey(''), unknownIdentityLabel);
+      expect(shortPubkey('not-a-key'), unknownIdentityLabel);
+      expect(shortPubkey('npub1garbage'), unknownIdentityLabel);
+      expect(shortPubkey('n' * 64), unknownIdentityLabel);
+    });
+  });
+
+  group('copy to paste roundtrip', () {
+    test('a copied npub parses back to the original hex key', () {
+      final copied = fullNpub(canonicalHex);
+      // The invite input accepts what the profile/settings copy actions put
+      // on the clipboard — the mobile copy/paste contract.
+      expect(parseCommunityInvitePubkey(copied!), canonicalHex);
+      // Hex input keeps working unchanged.
+      expect(parseCommunityInvitePubkey(canonicalHex), canonicalHex);
+    });
+  });
+}

From ad9591c43bdb7e221ee93964b09d5dadf820497f Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 9 Sep 2026 16:32:10 -0400
Subject: [PATCH 08/19] fix(desktop): order unnamed roster members by full
 canonical npub (#7503)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖

## Summary

- Channel members appear in the Members sidebar. A member who has never
set a display name is listed under an abbreviated form of their public
key (npub), and the sidebar previously sorted those unnamed members by
that short label. Short labels are not unique — different keys can share
one — so the order of unnamed members could look arbitrary or unstable.
Unnamed members now sort by their full public key, so the order is
deterministic.
- When two members display the same name, the previous tiebreak was
membership order (who joined first), which is not visible to a reader
and can shift as roster data loads in. The tiebreak is now the full
public key, so identical display names always land in the same order.
- Nothing gets noisier on screen: the full key is used only for sorting,
and the sidebar still shows the compact abbreviated form. Priorities are
unchanged — authored (custom) names still outrank fallback labels, and
role/current-user grouping still applies.
- Scope is the desktop app's Members sidebar and member management: the
two existing sort comparators. Mobile and other lists in the app are
untouched.

### Related issue

Based on #7495 (introduced the abbreviated npub labels this follows up
on). The original five presentation PRs remain independently reviewable.
No closer duplicate found.

### Testing

- 6469 desktop unit tests, typecheck, and check pass.
- The 3 existing consumer-seam E2E tests still pass; a new E2E test
asserts the sidebar lists unnamed members in full-key order, with
fixture members deliberately inserted in the opposite order so incoming
membership order cannot mask the sort.
- Negative check: reverting only this change makes the new ordering
assertion fail, so it genuinely binds the new sort.
- CI has not run on this PR yet.

Buzz provenance: channel 1f0e4a3d-7e01-4efe-bb16-843b357f85c9 / task
340c3de9b27dbedb8453c0c7652220f9080d30fcc70a7c4f6e27fdd4fa378056

---------

Signed-off-by: Logan Johnson <loganj@squareup.com>
Co-authored-by: Larry <627498bd4bd1f281a16431e3c6cce3b5c25b6692798c78672298aefbf2f8f8b5@buzz.block.builderlab.xyz>
---
 .github/workflows/_ci-desktop.yml             |   5 +-
 .../channels/lib/memberUtils.test.mjs         | 121 ++++++++++++++++++
 .../src/features/channels/lib/memberUtils.ts  |  62 ++++++++-
 .../features/channels/ui/MembersSidebar.tsx   |   7 +-
 desktop/tests/e2e/channels.spec.ts            |  65 +++++++++-
 5 files changed, 253 insertions(+), 7 deletions(-)
 create mode 100644 desktop/src/features/channels/lib/memberUtils.test.mjs

diff --git a/.github/workflows/_ci-desktop.yml b/.github/workflows/_ci-desktop.yml
index 108e18a2152..15893a1cb4e 100644
--- a/.github/workflows/_ci-desktop.yml
+++ b/.github/workflows/_ci-desktop.yml
@@ -24,7 +24,10 @@ jobs:
   desktop-core:
     name: Desktop Core
     runs-on: ubuntu-latest
-    timeout-minutes: 45
+    # The compiled-flag verification step rebuilds the workspace for each
+    # BUZZ_BUILD_* state and runs the full suite under all three compile
+    # states; the complete recipe needs ~46m, so budget 60m.
+    timeout-minutes: 60
     if: github.event_name == 'push' || inputs.desktop || inputs.desktop_rust || inputs.rust
     permissions:
       contents: read
diff --git a/desktop/src/features/channels/lib/memberUtils.test.mjs b/desktop/src/features/channels/lib/memberUtils.test.mjs
new file mode 100644
index 00000000000..751e7d415e2
--- /dev/null
+++ b/desktop/src/features/channels/lib/memberUtils.test.mjs
@@ -0,0 +1,121 @@
+import { strict as assert } from "node:assert";
+import test from "node:test";
+
+import { canonicalNpub, truncateNpub } from "@/shared/lib/pubkey";
+import { compareMembersByRole, formatMemberName } from "./memberUtils.ts";
+
+// Sequential-value pubkeys, the same shape as the members-sidebar e2e
+// roster fixture: every full npub shares the `npub1qqq…` head, so the
+// compact label is decided by the checksum tail while the full npub
+// diverges mid-key. These two keys disagree between the two orders.
+const V5_HEX =
+  "0000000000000000000000000000000000000000000000000000000000000005";
+const V5_NPUB =
+  "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzsfj2hcx";
+const V24_HEX =
+  "0000000000000000000000000000000000000000000000000000000000000018";
+const V24_NPUB =
+  "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqvq532w5c";
+
+function member(pubkey, overrides = {}) {
+  return {
+    pubkey,
+    role: "member",
+    isAgent: false,
+    joinedAt: "2026-09-08T00:00:00Z",
+    displayName: null,
+    ...overrides,
+  };
+}
+
+function rosterOrder(members, currentPubkey) {
+  return [...members]
+    .sort((left, right) => compareMembersByRole(left, right, currentPubkey))
+    .map((item) => item.pubkey);
+}
+
+test("unnamed members order by full canonical npub, not the compact label", () => {
+  assert.equal(canonicalNpub(V5_HEX), V5_NPUB);
+  assert.equal(canonicalNpub(V24_HEX), V24_NPUB);
+  // Compact labels order V5 first (`…2hcx` < `…2w5c`); the full npubs
+  // disagree (`…vq53…` < `…zsfj…`). Ordering follows the full key.
+  assert.ok(truncateNpub(V5_HEX).localeCompare(truncateNpub(V24_HEX)) < 0);
+  assert.ok(V24_NPUB.localeCompare(V5_NPUB) < 0);
+
+  const v5 = member(V5_HEX);
+  const v24 = member(V24_HEX);
+
+  assert.deepEqual(rosterOrder([v5, v24]), [V24_HEX, V5_HEX]);
+  assert.deepEqual(rosterOrder([v24, v5]), [V24_HEX, V5_HEX]);
+
+  // The compact 8+4 label stays the display form.
+  assert.equal(formatMemberName(v5), "npub1qqq…2hcx");
+  assert.equal(formatMemberName(v24), "npub1qqq…2w5c");
+
+  // Authored names still order against npub surfaces as before.
+  const bob = member("0".repeat(64), { displayName: "Bob" });
+  assert.deepEqual(rosterOrder([v5, bob, v24]), [
+    "0".repeat(64),
+    V24_HEX,
+    V5_HEX,
+  ]);
+});
+
+test("duplicate authored names tie-break by the full identity key", () => {
+  const lowHexName = member(V5_HEX, { displayName: "Ada" });
+  const highHexName = member(V24_HEX, { displayName: "Ada" });
+
+  // Same name, distinct keys: the tie breaks by canonical npub (which
+  // reverses the raw hex order of these two keys), in both input orders.
+  assert.deepEqual(rosterOrder([lowHexName, highHexName]), [V24_HEX, V5_HEX]);
+  assert.deepEqual(rosterOrder([highHexName, lowHexName]), [V24_HEX, V5_HEX]);
+});
+
+test("role precedence still outranks the name stage", () => {
+  const owner = member("1".repeat(64), { role: "owner", displayName: "Zed" });
+  const admin = member("2".repeat(64), { role: "admin", displayName: "Yan" });
+  const plain = member("3".repeat(64), { role: "member", displayName: "Xan" });
+  const guest = member("4".repeat(64), { role: "guest", displayName: "Wes" });
+  const bot = member("5".repeat(64), { role: "bot", displayName: "Ann" });
+
+  assert.deepEqual(rosterOrder([bot, guest, plain, admin, owner]), [
+    "1".repeat(64),
+    "2".repeat(64),
+    "3".repeat(64),
+    "4".repeat(64),
+    "5".repeat(64),
+  ]);
+});
+
+test("the current member still sorts first in compareMembersByRole", () => {
+  const current = member(V24_HEX);
+  const owner = member("1".repeat(64), { role: "owner", displayName: "Ada" });
+
+  assert.deepEqual(rosterOrder([owner, current], V24_HEX), [
+    V24_HEX,
+    "1".repeat(64),
+  ]);
+  assert.ok(compareMembersByRole(current, owner, V24_HEX) < 0);
+  assert.ok(compareMembersByRole(owner, current, V24_HEX) > 0);
+
+  // Without a current pubkey, roles lead again.
+  assert.ok(compareMembersByRole(current, owner) > 0);
+});
+
+test("invalid keys keep the neutral surface and break ties deterministically", () => {
+  const first = member("not-a-key");
+  const second = member("zzz-definitely-not-a-key");
+
+  // Both render the neutral label — never raw input — and the label
+  // collision breaks by the normalized key, not incoming order.
+  assert.equal(formatMemberName(first), "Unavailable");
+  assert.equal(formatMemberName(second), "Unavailable");
+  assert.deepEqual(rosterOrder([second, first]), [
+    "not-a-key",
+    "zzz-definitely-not-a-key",
+  ]);
+  assert.deepEqual(rosterOrder([first, second]), [
+    "not-a-key",
+    "zzz-definitely-not-a-key",
+  ]);
+});
diff --git a/desktop/src/features/channels/lib/memberUtils.ts b/desktop/src/features/channels/lib/memberUtils.ts
index 10ad4b7ff0a..401fc1f51cb 100644
--- a/desktop/src/features/channels/lib/memberUtils.ts
+++ b/desktop/src/features/channels/lib/memberUtils.ts
@@ -1,5 +1,10 @@
 import type { ChannelMember } from "@/shared/api/types";
-import { truncateNpub } from "@/shared/lib/pubkey";
+import {
+  canonicalNpub,
+  normalizePubkey,
+  truncateNpub,
+  UNAVAILABLE_KEY_LABEL,
+} from "@/shared/lib/pubkey";
 
 export const roleOrder: Record<ChannelMember["role"], number> = {
   owner: 0,
@@ -20,6 +25,59 @@ export function formatMemberName(
   return member.displayName ?? truncateNpub(member.pubkey);
 }
 
+/**
+ * Ordering surface for a member's name: the authored name when present,
+ * else the FULL canonical npub. Separate from `formatMemberName` — the
+ * compact `npub1abcd…wxyz` label is display-only, and ordering on it would
+ * collapse two distinct identities that merely share a prefix and tail.
+ * Undisplayable keys keep the neutral label as their surface, exactly as
+ * they render.
+ */
+function memberNameSurface(member: ChannelMember): string {
+  return (
+    member.displayName ?? canonicalNpub(member.pubkey) ?? UNAVAILABLE_KEY_LABEL
+  );
+}
+
+/**
+ * Full identity key used to break name-surface ties: the canonical npub of
+ * a valid identity, else the normalized raw key so every tie is decided.
+ * An ordering key only — never rendered or copied.
+ */
+function memberIdentityKey(member: ChannelMember): string {
+  return canonicalNpub(member.pubkey) ?? normalizePubkey(member.pubkey);
+}
+
+/**
+ * Shared name/key ordering authority for the roster comparators.
+ *
+ * Authored names keep the existing `localeCompare` semantics; unnamed
+ * members order by their full canonical npub (the compact label stays
+ * display-only); collation-equal surfaces — duplicate authored names,
+ * matching labels, invalid keys — break by full identity key, so the
+ * incoming membership-event order is never the tie policy. Comparators
+ * layer their own role/current-user precedence around this stage; this
+ * helper owns only the name ordering.
+ */
+export function compareMemberNames(
+  left: ChannelMember,
+  right: ChannelMember,
+): number {
+  const surfaceDelta = memberNameSurface(left).localeCompare(
+    memberNameSurface(right),
+  );
+  if (surfaceDelta !== 0) {
+    return surfaceDelta;
+  }
+
+  const leftKey = memberIdentityKey(left);
+  const rightKey = memberIdentityKey(right);
+  if (leftKey === rightKey) {
+    return 0;
+  }
+  return leftKey < rightKey ? -1 : 1;
+}
+
 export function compareMembersByRole(
   left: ChannelMember,
   right: ChannelMember,
@@ -35,5 +93,5 @@ export function compareMembersByRole(
   if (roleDelta !== 0) {
     return roleDelta;
   }
-  return formatMemberName(left).localeCompare(formatMemberName(right));
+  return compareMemberNames(left, right);
 }
diff --git a/desktop/src/features/channels/ui/MembersSidebar.tsx b/desktop/src/features/channels/ui/MembersSidebar.tsx
index 3c9afbfaeca..2a125e0d014 100644
--- a/desktop/src/features/channels/ui/MembersSidebar.tsx
+++ b/desktop/src/features/channels/ui/MembersSidebar.tsx
@@ -16,7 +16,10 @@ import {
 } from "@/features/agents/lib/agentAutocompleteEligibility";
 import { useIsArchivedPredicate } from "@/features/identity-archive/hooks";
 import { useClassifiedMembers } from "@/features/channels/lib/useClassifiedMembers";
-import { formatMemberName } from "@/features/channels/lib/memberUtils";
+import {
+  compareMemberNames,
+  formatMemberName,
+} from "@/features/channels/lib/memberUtils";
 import {
   canAddChannelMembers,
   PRIVATE_CHANNEL_ADD_DENIED_MESSAGE,
@@ -120,7 +123,7 @@ function compareMembersForModal(
   if (currentPubkey && left.pubkey === currentPubkey) return -1;
   if (currentPubkey && right.pubkey === currentPubkey) return 1;
 
-  return formatMemberName(left).localeCompare(formatMemberName(right));
+  return compareMemberNames(left, right);
 }
 
 type MembersSidebarProps = {
diff --git a/desktop/tests/e2e/channels.spec.ts b/desktop/tests/e2e/channels.spec.ts
index 371cffdfb0b..b7cf2c23cbf 100644
--- a/desktop/tests/e2e/channels.spec.ts
+++ b/desktop/tests/e2e/channels.spec.ts
@@ -27,6 +27,15 @@ const OWNED_RELAY_AGENT_PUBKEY =
   "a1b2c3d4e5f60718293a4b5c6d7e8f90112233445566778899aabbccddeeff00";
 const DM_RELAY_AGENT_PUBKEY =
   "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+// Unnamed roster fixtures whose two plausible orders disagree (the e2e twin
+// of the memberUtils unit pair): both keys share the `npub1qqq…` head, so
+// the compact display labels order V5 first (`…2hcx` < `…2w5c`) while the
+// full canonical npubs order V24 first (`…vq53…` < `…zsfj…`). Only the
+// full-npub order is correct for the roster.
+const UNNAMED_MEMBER_V5_PUBKEY =
+  "0000000000000000000000000000000000000000000000000000000000000005";
+const UNNAMED_MEMBER_V24_PUBKEY =
+  "0000000000000000000000000000000000000000000000000000000000000018";
 
 type MockFeedWindow = Window & {
   __BUZZ_E2E_EMIT_MOCK_MESSAGE__?: (input: {
@@ -4177,8 +4186,9 @@ test("members sidebar virtualizes large channel rosters", async ({ page }) => {
   expect(await memberRows.count()).toBeLessThan(50);
 
   // Generated members have no display name, so the roster sorts them by
-  // their npub fallback label: these sequential pubkeys share a `npub1qqq…`
-  // prefix and order by the checksum tail, not their numeric value. Resolve
+  // their full canonical npub: these sequential pubkeys share an
+  // `npub1qqq…` head and diverge mid-key, while the compact label's
+  // checksum tail is display-only and decides nothing. Resolve
   // a generated member from the rows the initial window actually rendered
   // instead of assuming `pubkeys[0]` sorts into that window.
   const generatedPubkeySet = new Set(pubkeys);
@@ -4253,6 +4263,57 @@ test("members sidebar virtualizes large channel rosters", async ({ page }) => {
   ).toBeVisible();
 });
 
+test("members sidebar orders unnamed members by full canonical npub", async ({
+  page,
+}) => {
+  await page.goto("/");
+  const channelId = await page
+    .getByTestId("channel-random")
+    .getAttribute("data-channel-id");
+  if (!channelId) {
+    throw new Error("Random channel id missing.");
+  }
+
+  // Added in the opposite of the expected order, so incoming membership
+  // order can never satisfy the assertion on its own.
+  await invokeMockCommand(page, "add_channel_members", {
+    channelId,
+    pubkeys: [UNNAMED_MEMBER_V5_PUBKEY, UNNAMED_MEMBER_V24_PUBKEY],
+    role: "member",
+  });
+
+  await openMembersSidebar(page, "random");
+  // "random" seeds alice, the mock identity, and bob, so the two unnamed
+  // fixtures round out a five-row roster that the initial virtual window
+  // renders entirely — both fixtures are visible without scrolling.
+  await expect(
+    page.getByTestId(`sidebar-member-${UNNAMED_MEMBER_V24_PUBKEY}`),
+  ).toBeVisible();
+  await expect(
+    page.getByTestId(`sidebar-member-${UNNAMED_MEMBER_V5_PUBKEY}`),
+  ).toBeVisible();
+
+  // The compact labels (`npub1qqq…2hcx` < `npub1qqq…2w5c`) would order V5
+  // first; the full canonical npubs disagree and order V24 first. The
+  // rendered roster must follow the full key, not the display label.
+  const renderedOrder = await page
+    .getByTestId("members-sidebar-people")
+    .locator('[data-index] > [data-testid^="sidebar-member-"]')
+    .evaluateAll((rows) =>
+      rows.map(
+        (row) =>
+          (row as HTMLElement).dataset.testid?.slice(
+            "sidebar-member-".length,
+          ) ?? "",
+      ),
+    );
+  const v24Position = renderedOrder.indexOf(UNNAMED_MEMBER_V24_PUBKEY);
+  const v5Position = renderedOrder.indexOf(UNNAMED_MEMBER_V5_PUBKEY);
+  expect(v24Position).toBeGreaterThanOrEqual(0);
+  expect(v5Position).toBeGreaterThanOrEqual(0);
+  expect(v24Position).toBeLessThan(v5Position);
+});
+
 test("opening a human-only members sidebar skips managed runtime discovery", async ({
   page,
 }) => {

From 12023a3cba60e9a6336bf790bf3565b271af929f Mon Sep 17 00:00:00 2001
From: Stephen DeLorme <stephen@d.elor.me>
Date: Wed, 9 Sep 2026 18:32:37 -0400
Subject: [PATCH 09/19] fix(desktop): require a Codex adapter with Astra
 support (#7427)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Buzz considers codex-acp 1.6.2 current because the supported adapter
floor is still 1.1.7. That adapter bundles Codex 0.148.0, so updating a
separate Codex CLI to 0.153.4 leaves managed agents on the older runtime
and unable to use GPT-6 Astra.

Raise the supported adapter floor to the published 1.10.0 release, which
depends on `@openai/codex ^0.153.3`. Existing discovery and installation
code then classifies older adapters as outdated and offers the managed
reinstall path. Update the availability and install-plan regressions to
cover the observed 1.6.2 installation and the new minimum.

This follows the existing version-floor policy. It does not
automatically update a running installation: the user must complete
Buzz’s offered adapter upgrade. Future upstream compatibility changes
may require another floor update.

### Related issue

No exact duplicate found in searches for Astra, CODEX_PATH, bundled
Codex, outdated runtime, and codex-acp 1.10. Related: #3097 raised the
older floor to 1.1.7 (already present on main); #2422 covers lost error
details for runtime mismatches. Neither resolves this version gap.

Originating conversation:
buzz://message?channel=3286cd76-f83e-4c7d-8317-10a16580744d&id=8b79a73078217222b870fff144c27e7d27bcd5a67c966869c18fe726db716898

### Testing

- Isolated npm install of codex-acp 1.10.0 resolved bundled Codex
0.153.4, with no CODEX_PATH override.
- Live macOS ACP probe: initialize protocol v1 → session/new → select
gpt-6-astra[medium] → prompt. Received `OK` and `stopReason: end_turn`;
usage metadata confirms gpt-6-astra.
- Existing adapter 1.6.2 initialized but advertised no Astra model in
the same probe.
- Desktop Rust formatting and `git diff --check` pass.
- `just desktop-tauri-test`: 3,266 passed, 20 ignored, zero failures
across the Desktop workspace and integration tests.
- Workspace and Desktop Clippy, frontend static checks, and `just
file-size-check` pass.
- Repository `just ci`: still running the remaining
mobile/build/workspace-test stages.

The installed Buzz app and managed adapter were not replaced or
restarted. The live check validates the new adapter/runtime path; a
complete packaged Desktop upgrade workflow remains untested.

Signed-off-by: Stephen DeLorme <stephen@d.elor.me>
---
 .../src-tauri/src/commands/agent_discovery.rs |  6 ++---
 .../src-tauri/src/managed_agents/discovery.rs |  6 +++--
 .../src/managed_agents/discovery/tests.rs     | 23 +---------------
 .../discovery/tests/codex_version.rs          | 27 +++++++++++++++++++
 4 files changed, 35 insertions(+), 27 deletions(-)

diff --git a/desktop/src-tauri/src/commands/agent_discovery.rs b/desktop/src-tauri/src/commands/agent_discovery.rs
index ccca7c4abfa..99dcc98145a 100644
--- a/desktop/src-tauri/src/commands/agent_discovery.rs
+++ b/desktop/src-tauri/src/commands/agent_discovery.rs
@@ -1167,7 +1167,7 @@ mod tests {
         // Simulate the minimum supported adapter version.
         std::fs::write(
             &bin,
-            "#!/bin/sh\necho '@agentclientprotocol/codex-acp 1.1.7'\nexit 0\n",
+            "#!/bin/sh\necho '@agentclientprotocol/codex-acp 1.10.0'\nexit 0\n",
         )
         .expect("write script");
         std::fs::set_permissions(&bin, std::fs::Permissions::from_mode(0o755))
@@ -1189,10 +1189,10 @@ mod tests {
 
         let dir = tempfile::tempdir().unwrap();
         let bin = dir.path().join("codex-acp");
-        // A 1.x adapter below MIN_CODEX_ACP_VERSION must still be reinstalled.
+        // The observed adapter bundles Codex 0.148.x and must be upgraded.
         std::fs::write(
             &bin,
-            "#!/bin/sh\necho '@agentclientprotocol/codex-acp 1.1.5'\nexit 0\n",
+            "#!/bin/sh\necho '@agentclientprotocol/codex-acp 1.6.2'\nexit 0\n",
         )
         .expect("write script");
         std::fs::set_permissions(&bin, std::fs::Permissions::from_mode(0o755))
diff --git a/desktop/src-tauri/src/managed_agents/discovery.rs b/desktop/src-tauri/src/managed_agents/discovery.rs
index 531ae335ce5..e4b87e7557a 100644
--- a/desktop/src-tauri/src/managed_agents/discovery.rs
+++ b/desktop/src-tauri/src/managed_agents/discovery.rs
@@ -783,12 +783,14 @@ pub(crate) fn classify_runtime(
 /// The oldest `codex-acp` version supported by Buzz managed agents.
 ///
 /// Older 1.x adapters are detected successfully, but can still bundle a Codex runtime
-/// that does not reliably give `buzz` CLI subprocesses outbound relay access.
+/// that cannot use newer models. Adapter 1.6.2 bundles Codex 0.148.x, which rejects
+/// GPT-6 Astra even when the separately installed Codex CLI has been updated.
+/// Published adapter 1.10.0 depends on `@openai/codex ^0.153.3`.
 ///
 /// Bump policy: raise this only when a newer adapter fixes a defect that breaks managed
 /// agents, and only to a version already published on npm — every user below the floor is
 /// offered a reinstall on their next discovery pass.
-pub(crate) const MIN_CODEX_ACP_VERSION: (u64, u64, u64) = (1, 1, 7);
+pub(crate) const MIN_CODEX_ACP_VERSION: (u64, u64, u64) = (1, 10, 0);
 
 /// Probe the full version of a `codex-acp` binary by running `--version`.
 ///
diff --git a/desktop/src-tauri/src/managed_agents/discovery/tests.rs b/desktop/src-tauri/src/managed_agents/discovery/tests.rs
index dc155d82f5b..f13a2d20bdf 100644
--- a/desktop/src-tauri/src/managed_agents/discovery/tests.rs
+++ b/desktop/src-tauri/src/managed_agents/discovery/tests.rs
@@ -684,7 +684,7 @@ fn codex_adapter_availability_available_for_minimum_supported_binary() {
     let bin = dir.join("codex-acp");
     std::fs::write(
         &bin,
-        "#!/bin/sh\necho '@agentclientprotocol/codex-acp 1.1.7'\nexit 0\n",
+        "#!/bin/sh\necho '@agentclientprotocol/codex-acp 1.10.0'\nexit 0\n",
     )
     .expect("write script");
     std::fs::set_permissions(&bin, std::fs::Permissions::from_mode(0o755)).expect("chmod script");
@@ -721,27 +721,6 @@ fn codex_adapter_availability_outdated_for_0x_binary() {
     );
 }
 
-#[cfg(unix)]
-#[test]
-fn codex_adapter_availability_outdated_for_older_1x_binary() {
-    use std::os::unix::fs::PermissionsExt;
-
-    let dir = tempfile::tempdir().expect("temp dir");
-    let bin = dir.path().join("codex-acp");
-    std::fs::write(
-        &bin,
-        "#!/bin/sh\necho '@agentclientprotocol/codex-acp 1.1.5'\nexit 0\n",
-    )
-    .expect("write script");
-    std::fs::set_permissions(&bin, std::fs::Permissions::from_mode(0o755)).expect("chmod script");
-
-    assert_eq!(
-        codex_adapter_availability(&bin),
-        AcpAvailabilityStatus::AdapterOutdated,
-        "a 1.x adapter below the floor must be offered an upgrade"
-    );
-}
-
 /// The strict three-component parse fails closed: a version Buzz cannot compare
 /// against the floor is treated as outdated rather than assumed current.
 #[cfg(unix)]
diff --git a/desktop/src-tauri/src/managed_agents/discovery/tests/codex_version.rs b/desktop/src-tauri/src/managed_agents/discovery/tests/codex_version.rs
index 82bfd27f325..19053865cbe 100644
--- a/desktop/src-tauri/src/managed_agents/discovery/tests/codex_version.rs
+++ b/desktop/src-tauri/src/managed_agents/discovery/tests/codex_version.rs
@@ -46,3 +46,30 @@ fn probe_codex_acp_version_uses_augmented_path_for_env_shebang_interpreter() {
         "the injected augmented PATH should allow /usr/bin/env to find node"
     );
 }
+
+#[cfg(unix)]
+#[test]
+fn codex_adapter_availability_outdated_for_older_1x_binary() {
+    use super::super::{codex_adapter_availability, codex_adapter_is_outdated};
+    use crate::managed_agents::AcpAvailabilityStatus;
+    use std::os::unix::fs::PermissionsExt;
+
+    for version in ["1.1.5", "1.1.7", "1.6.2", "1.9.0"] {
+        let dir = tempfile::tempdir().expect("temp dir");
+        let bin = dir.path().join("codex-acp");
+        std::fs::write(
+            &bin,
+            format!("#!/bin/sh\necho '@agentclientprotocol/codex-acp {version}'\nexit 0\n"),
+        )
+        .expect("write script");
+        std::fs::set_permissions(&bin, std::fs::Permissions::from_mode(0o755))
+            .expect("chmod script");
+
+        assert_eq!(
+            codex_adapter_availability(&bin),
+            AcpAvailabilityStatus::AdapterOutdated,
+            "adapter {version} must be offered an upgrade"
+        );
+        assert!(codex_adapter_is_outdated(&bin));
+    }
+}

From 051c3a270be9c73da9ab06700bcab7d5552fceaa Mon Sep 17 00:00:00 2001
From: Diem Nguyen <ngthuydiem@users.noreply.github.com>
Date: Wed, 9 Sep 2026 16:52:35 -0700
Subject: [PATCH 10/19] fix(buzz-acp): report missing models without retrying
 (#7538)

## Summary

When an agent reports model-not-found, Buzz retries the unavailable
model and delays the failure reply until retries are exhausted. Stop
retrying this error and immediately post a threaded recovery notice. The
notice tells users to select a different model in agent settings, save,
restart the agent to apply the configuration, and re-send their request.

This adds one error-handling branch and regression coverage in
`buzz-acp`. It matches `-32002` errors containing `model not found`.
Other resource-not-found errors, such as stale sessions, retain the
existing retry behavior. Detailed error events remain available for
diagnosis. The existing restart policy is unchanged.

### Related issue

None found in existing issue/PR searches for model-not-found recovery.

### Testing

Playwright captured and visually checked the thread UI with seeded
conversation data and the exact recovery text. The check opens the
request's thread, confirms no reply before the failure, injects the
notice, and verifies the full text is visible. [Before/after
screenshots](https://github.com/block/buzz/pull/7538#issuecomment-5608196506)
show the corrected save-and-restart instructions. These are local test
captures, not a deployed provider recovery flow.

Generated with Codex

---------

Signed-off-by: Diem Nguyen <diem@squareup.com>
---
 crates/buzz-acp/src/lib.rs | 207 +++++++++++++++++++++++++++++++++++--
 1 file changed, 200 insertions(+), 7 deletions(-)

diff --git a/crates/buzz-acp/src/lib.rs b/crates/buzz-acp/src/lib.rs
index cc2952a2f8d..ab7233d4930 100644
--- a/crates/buzz-acp/src/lib.rs
+++ b/crates/buzz-acp/src/lib.rs
@@ -4783,6 +4783,23 @@ fn handle_prompt_result(
                 } else {
                     hard_timeout_fate_suffix = Some(" — requeued for retry (recently active)");
                 }
+            } else if matches!(
+                &result.outcome,
+                PromptOutcome::Error(acp::AcpError::AgentError { code: -32002, message })
+                    if message.contains("model not found")
+            ) {
+                // Retrying the same missing model cannot repair its configuration.
+                tracing::warn!(
+                    channel_id = %batch.channel_id,
+                    events = batch.events.len(),
+                    "dead-lettering batch immediately — model not found"
+                );
+                let content = "⚠️ I couldn't process the last request: the configured model \
+                    wasn't found at the provider's endpoint. Open agent settings, select a \
+                    different model from the dropdown, and save your changes. Restart the agent \
+                    to apply the new configuration, then re-send your request."
+                    .to_string();
+                spawn_failure_notice(rest_client, &batch, content);
             } else if matches!(&result.outcome, PromptOutcome::Error(e) if is_auth_error(e)) {
                 // Auth errors are non-retryable: the token won't self-repair
                 // between retries, so requeueing only wastes attempt slots and
@@ -11012,10 +11029,192 @@ mod error_outcome_emission_tests {
         );
     }
 
+    #[tokio::test]
+    async fn model_not_found_posts_recovery_notice_without_retrying() {
+        use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let rest = relay::RestClient {
+            http: reqwest::Client::new(),
+            base_url: format!("http://{}", listener.local_addr().unwrap()),
+            keys: Keys::generate(),
+            auth_tag_json: None,
+        };
+        let keys = Keys::generate();
+        let root = nostr::EventId::from_byte_array([0xaa; 32]);
+        let parent = nostr::EventId::from_byte_array([0xbb; 32]);
+        let event = EventBuilder::new(Kind::Custom(9), "test")
+            .tags([
+                nostr::Tag::parse(["e", &root.to_hex(), "", "root"]).unwrap(),
+                nostr::Tag::parse(["e", &parent.to_hex(), "", "reply"]).unwrap(),
+            ])
+            .sign_with_keys(&keys)
+            .unwrap();
+        let channel_id = uuid::Uuid::new_v4();
+        let batch = FlushBatch {
+            channel_id,
+            scope: scope::SessionScope::Conversation { channel_id },
+            events: vec![BatchEvent {
+                event,
+                prompt_tag: "test".into(),
+                received_at: std::time::Instant::now(),
+            }],
+            cancelled_events: vec![],
+            cancel_reason: None,
+        };
+
+        let raw_error = r#"llm model not found: (gpt-6-astra) 404 Not Found: {"error_code":"NOT_FOUND","message":"'gpt-6-astra' does not exist."}"#;
+        let model_error = AcpError::AgentError {
+            code: -32002,
+            message: raw_error.to_string(),
+        };
+        let expected_error = model_error.to_string();
+        let observer = ObserverHandle::in_process();
+
+        let agent = dummy_agent(0).await;
+        let mut pool = AgentPool::from_slots(vec![None]);
+        let task_id = pool.join_set.spawn(async {}).id();
+        pool.task_map_mut().insert(
+            task_id,
+            crate::pool::TaskMeta {
+                agent_index: 0,
+                channel_id: None,
+                scope: None,
+                turn_id: "test-turn-id".to_string(),
+                recoverable_batch: None,
+                control_tx: None,
+                steer_tx: None,
+                successful_steer_deliveries: HashSet::new(),
+            },
+        );
+        let mut queue = EventQueue::new(config::DedupMode::Queue);
+        let config = test_config();
+        let mut heartbeat_in_flight = false;
+        let removed_channels = std::collections::HashSet::new();
+        let mut crash_history = vec![SlotCircuit {
+            crash_times: Vec::new(),
+            open_until: None,
+            respawn_in_flight: false,
+        }];
+        let (respawn_tx, _respawn_rx) = mpsc::channel(8);
+        let mut respawn_tasks = tokio::task::JoinSet::new();
+        let result = PromptResult {
+            agent,
+            source: PromptSource::Channel(scope::SessionScope::Conversation { channel_id }),
+            turn_id: "test-turn-id".to_string(),
+            outcome: PromptOutcome::Error(model_error),
+            batch: Some(batch),
+        };
+        handle_prompt_result(
+            &mut pool,
+            &mut queue,
+            &config,
+            result,
+            &mut heartbeat_in_flight,
+            &removed_channels,
+            &mut crash_history,
+            &respawn_tx,
+            &mut respawn_tasks,
+            Some(observer.clone()),
+            Some(&rest),
+        );
+
+        // The batch must not be requeued: pending_channels returns 0.
+        assert_eq!(
+            queue.pending_channels(),
+            0,
+            "model-not-found must stop immediately — batch must not be requeued"
+        );
+        assert_eq!(
+            queue.queued_event_count(channel_id),
+            0,
+            "model-not-found must stop immediately — no events should be pending"
+        );
+
+        assert!(
+            pool.agents_mut()[0].is_some(),
+            "healthy process remains reusable"
+        );
+        assert!(respawn_tasks.is_empty());
+        let errors: Vec<_> = observer
+            .snapshot()
+            .into_iter()
+            .filter(|event| event.kind == "turn_error")
+            .collect();
+        assert_eq!(errors.len(), 1);
+        assert_eq!(errors[0].payload["code"], -32002);
+        assert_eq!(errors[0].payload["error"], expected_error);
+
+        // Capture the real signed notice sent by handle_prompt_result, without a live relay.
+        let notice: nostr::Event = tokio::time::timeout(Duration::from_secs(3), async {
+            let (socket, _) = listener.accept().await.unwrap();
+            let mut reader = BufReader::new(socket);
+            let mut line = String::new();
+            reader.read_line(&mut line).await.unwrap();
+            assert_eq!(line, "POST /events HTTP/1.1\r\n");
+            let mut content_length = None;
+            for _ in 0..64 {
+                line.clear();
+                assert_ne!(reader.read_line(&mut line).await.unwrap(), 0);
+                if line == "\r\n" {
+                    break;
+                }
+                if let Some(value) = line.to_ascii_lowercase().strip_prefix("content-length:") {
+                    content_length = Some(value.trim().parse::<usize>().unwrap());
+                }
+            }
+            let size = content_length.expect("request Content-Length");
+            assert!(size < 65536);
+            let mut body = vec![0; size];
+            reader.read_exact(&mut body).await.unwrap();
+            reader
+                .get_mut()
+                .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}")
+                .await
+                .unwrap();
+            serde_json::from_slice(&body).unwrap()
+        })
+        .await
+        .expect("failure notice must be posted on the first failure");
+        notice.verify().unwrap();
+        assert_eq!(notice.pubkey, rest.keys.public_key());
+        assert_eq!(notice.kind, Kind::Custom(9));
+        assert_eq!(
+            notice.content,
+            "⚠️ I couldn't process the last request: the configured model wasn't found at the provider's endpoint. Open agent settings, select a different model from the dropdown, and save your changes. Restart the agent to apply the new configuration, then re-send your request."
+        );
+        let tags = serde_json::to_value(&notice.tags).unwrap();
+        assert!(tags
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|tag| tag[0] == "h" && tag[1] == channel_id.to_string()));
+        let threading = queue::parse_thread_tags(&notice);
+        assert_eq!(threading.root_event_id, Some(root.to_hex()));
+        assert_eq!(threading.parent_event_id, Some(parent.to_hex()));
+    }
+
     /// A non-auth application error (e.g. usage credits) must still follow the
     /// standard requeue path so today's behavior is unchanged.
     #[tokio::test]
     async fn non_auth_application_error_is_requeued() {
+        assert_application_error_is_requeued(acp::AcpError::AgentError {
+            code: -32000,
+            message: "Usage credits required for 1M context".to_string(),
+        })
+        .await;
+    }
+
+    #[tokio::test]
+    async fn non_model_resource_not_found_is_requeued() {
+        assert_application_error_is_requeued(acp::AcpError::AgentError {
+            code: -32002,
+            message: "Resource not found: session no longer exists".to_string(),
+        })
+        .await;
+    }
+
+    async fn assert_application_error_is_requeued(error: acp::AcpError) {
         let keys = nostr::Keys::generate();
         let event = nostr::EventBuilder::new(nostr::Kind::Custom(9), "test")
             .sign_with_keys(&keys)
@@ -11033,12 +11232,6 @@ mod error_outcome_emission_tests {
             cancel_reason: None,
         };
 
-        // Usage-credits error — AgentError but NOT an auth error.
-        let usage_error = acp::AcpError::AgentError {
-            code: -32000,
-            message: "Usage credits required for 1M context".to_string(),
-        };
-
         let agent = dummy_agent(0).await;
         let mut pool = AgentPool::from_slots(vec![None]);
         let task_id = pool.join_set.spawn(async {}).id();
@@ -11070,7 +11263,7 @@ mod error_outcome_emission_tests {
             agent,
             source: PromptSource::Channel(scope::SessionScope::Conversation { channel_id }),
             turn_id: "test-turn-id".to_string(),
-            outcome: PromptOutcome::Error(usage_error),
+            outcome: PromptOutcome::Error(error),
             batch: Some(batch),
         };
         handle_prompt_result(

From cec5c8fd9280d30f56effac701e1e19d5cfe6fea Mon Sep 17 00:00:00 2001
From: cynfria <yescynthia@gmail.com>
Date: Thu, 10 Sep 2026 10:00:15 -0700
Subject: [PATCH 11/19] fix(desktop): let inbox title and message author names
 truncate under narrow panes (#7550)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary

Fixes two instances of the same dead-truncate pattern in the desktop
app, where a flex item's implicit `min-width: auto` prevented `truncate`
from engaging, so long text painted over adjacent controls instead of
ellipsizing:

- **Inbox detail title** (`InboxDetailPane.tsx`): the clickable
context-title button sized to its text instead of shrinking with the
pane, overlapping the header controls (open-in-channel, members, huddle,
more menu). Fixed by adding `max-w-full`.
- **Message author names** (`MessageHeader.tsx` /
`UserProfilePopover.tsx`): the `UserProfilePopover` inline-flex trigger
wrapper refused to shrink below the name's nowrap width, running long
author names under the hover action bar and off the pane edge. Fixed by
adding a `triggerClassName` prop to `UserProfilePopover` and passing
`min-w-0 max-w-full` at the author call site.

Two other suspected instances (project file breadcrumb, drafts pane
title) were stress-tested and already truncate correctly — no change.

### Related issue

N/A — none found.

### Testing

- New Playwright regression tests for both fixes
(`inbox-title-overlap.spec.ts`, `message-author-overlap.spec.ts`,
registered in the smoke project), each proven to discriminate: they fail
with the fix reverted (real measured overlap) and assert the ellipsis
actually engages with non-zero title width, so they can't pass
vacuously.
- Typecheck, lint, and full desktop unit suite green (pre-push hooks);
full desktop e2e smoke suite run earlier: 1402 passed, 3 pre-existing
unrelated failures (each fails identically with the fix reverted).

**Inbox title — before** (long title paints under the header controls):

![Inbox title before: title text overlaps the header control
icons](https://github.com/user-attachments/assets/d5a10f98-114f-4466-8012-468616b82807)

**Inbox title — after** (truncates with ellipsis, controls stay clear):

![Inbox title after: title truncates with an ellipsis before the
controls](https://github.com/user-attachments/assets/80520f7c-1120-4dbc-929d-1ef5eceb874b)

**Author name — before** (long name runs past the header row edge):

![Author name before: name glyphs bleed past the action
bar](https://github.com/user-attachments/assets/be9743ae-ef51-4db0-8c46-a0649e98f0d5)

**Author name — after** (clean cutoff):

![Author name after: name truncates cleanly inside the header
row](https://github.com/user-attachments/assets/24cc0412-ca99-40c4-add6-13380b3ae065)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Signed-off-by: cynfria <yescynthia@gmail.com>
Signed-off-by: Tree Trunks <6ba22921d9dc2ad0aa6ecdf63787ddd24726e266d866da31af69f2e4e146ace5@buzz.block.builderlab.xyz>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: Tree Trunks <6ba22921d9dc2ad0aa6ecdf63787ddd24726e266d866da31af69f2e4e146ace5@buzz.block.builderlab.xyz>
---
 desktop/playwright.config.ts                  |   2 +
 .../src/features/home/ui/InboxDetailPane.tsx  |   2 +-
 .../features/messages/ui/MessageActionBar.tsx |   5 +
 .../features/messages/ui/MessageHeader.tsx    |   1 +
 .../src/features/messages/ui/MessageRow.tsx   |  20 ++-
 .../profile/ui/UserProfilePopover.tsx         |   9 +
 .../shared/layout/observeElementBlockSize.ts  |  32 ++++
 .../shared/layout/useMeasuredCssVariable.ts   |  30 +++-
 desktop/tests/e2e/inbox-title-overlap.spec.ts | 146 ++++++++++++++++
 .../tests/e2e/message-author-overlap.spec.ts  | 159 ++++++++++++++++++
 10 files changed, 398 insertions(+), 8 deletions(-)
 create mode 100644 desktop/tests/e2e/inbox-title-overlap.spec.ts
 create mode 100644 desktop/tests/e2e/message-author-overlap.spec.ts

diff --git a/desktop/playwright.config.ts b/desktop/playwright.config.ts
index aad2580dad0..76f27b6176d 100644
--- a/desktop/playwright.config.ts
+++ b/desktop/playwright.config.ts
@@ -142,6 +142,8 @@ export default defineConfig({
         "**/drafts-screenshots.spec.ts",
         "**/drafts-all-fix-screenshots.spec.ts",
         "**/inbox-refactor-screenshots.spec.ts",
+        "**/inbox-title-overlap.spec.ts",
+        "**/message-author-overlap.spec.ts",
         "**/buzz-theme-screenshots.spec.ts",
         "**/appearance-previews.spec.ts",
         "**/channel-sort.spec.ts",
diff --git a/desktop/src/features/home/ui/InboxDetailPane.tsx b/desktop/src/features/home/ui/InboxDetailPane.tsx
index 0360c1d9ad0..7b40d452ee5 100644
--- a/desktop/src/features/home/ui/InboxDetailPane.tsx
+++ b/desktop/src/features/home/ui/InboxDetailPane.tsx
@@ -567,7 +567,7 @@ function InboxMessageDetailPane({
                   {canOpenChannel && contextChannelId ? (
                     <h2 className="min-w-0">
                       <button
-                        className="block min-w-0 text-left text-sm font-semibold leading-5 tracking-tight text-foreground hover:underline focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+                        className="block min-w-0 max-w-full text-left text-sm font-semibold leading-5 tracking-tight text-foreground hover:underline focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
                         data-testid="home-inbox-context-title"
                         onClick={() =>
                           onOpenContext(
diff --git a/desktop/src/features/messages/ui/MessageActionBar.tsx b/desktop/src/features/messages/ui/MessageActionBar.tsx
index 7a000913e93..082cb0b126d 100644
--- a/desktop/src/features/messages/ui/MessageActionBar.tsx
+++ b/desktop/src/features/messages/ui/MessageActionBar.tsx
@@ -396,6 +396,7 @@ function isCustomEmojiShortcode(emoji: string) {
 export const MessageActionBar = React.memo(function MessageActionBar({
   channelId,
   message,
+  ref,
   onDelete,
   onEdit,
   onFollowThread,
@@ -417,6 +418,9 @@ export const MessageActionBar = React.memo(function MessageActionBar({
    *  action is hidden (callers like the home inbox that lack the context). */
   channelId?: string | null;
   message: TimelineMessage;
+  /** Attached to the root element so hosts can measure the rail's rendered
+   *  footprint (e.g. to reserve its width in the message-header layout). */
+  ref?: React.Ref<HTMLDivElement>;
   onDelete?: (message: TimelineMessage) => void;
   onEdit?: (message: TimelineMessage) => void;
   onFollowThread?: (message: TimelineMessage) => void;
@@ -514,6 +518,7 @@ export const MessageActionBar = React.memo(function MessageActionBar({
           : "",
       )}
       data-testid={`message-action-bar-${message.id}`}
+      ref={ref}
     >
       <div className="overflow-hidden rounded-full border border-border/70 bg-background/95 shadow-xs backdrop-blur-sm supports-[backdrop-filter]:bg-background/85">
         <div className="flex items-center gap-0.5 p-1">
diff --git a/desktop/src/features/messages/ui/MessageHeader.tsx b/desktop/src/features/messages/ui/MessageHeader.tsx
index c74bb6706a5..eb22a249c5d 100644
--- a/desktop/src/features/messages/ui/MessageHeader.tsx
+++ b/desktop/src/features/messages/ui/MessageHeader.tsx
@@ -129,6 +129,7 @@ export function MessageAuthorIdentity({
           pubkey={pubkey}
           role={role}
           botIdenticonValue={displayName}
+          triggerClassName="min-w-0 max-w-full"
         >
           <button
             className="truncate rounded leading-message-author focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring"
diff --git a/desktop/src/features/messages/ui/MessageRow.tsx b/desktop/src/features/messages/ui/MessageRow.tsx
index facf56277d2..75b7d0d3391 100644
--- a/desktop/src/features/messages/ui/MessageRow.tsx
+++ b/desktop/src/features/messages/ui/MessageRow.tsx
@@ -34,6 +34,7 @@ import {
 } from "@/shared/constants/kinds";
 import { getConfigNudgeAuthorPubkey } from "@/features/messages/ui/configNudgeAuthPubkey";
 import { cn } from "@/shared/lib/cn";
+import { useMeasuredCssVariable } from "@/shared/layout/useMeasuredCssVariable";
 import { normalizePubkey } from "@/shared/lib/pubkey";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
 import { useChannelNavigation } from "@/shared/context/ChannelNavigationContext";
@@ -214,6 +215,19 @@ export const MessageRow = React.memo(
     } = useReactionHandler(message, onToggleReaction);
     const { openReminder, activeReminderEventIds } = useRemindLater();
     const hasActiveReminder = activeReminderEventIds.has(message.id);
+    // The hover/focus action rail is absolutely positioned over the row, so it
+    // takes no layout space of its own. Measure its rendered footprint and
+    // reserve it in the message-header row (see `headerNode`) so a long author
+    // name ellipsizes before the rail instead of painting underneath it. The
+    // reservation is unconditional — the rail appears on hover AND
+    // focus-within, and padding must not reflow the header mid-interaction.
+    const articleRef = React.useRef<HTMLElement | null>(null);
+    const actionRailMeasureRef = useMeasuredCssVariable({
+      cssVariable: "--message-action-rail-width",
+      dimension: "inline",
+      resetValue: "0px",
+      targetRef: articleRef,
+    });
     const handleRemindLater = React.useCallback(
       (msg: TimelineMessage) => {
         openReminder({
@@ -565,6 +579,7 @@ export const MessageRow = React.memo(
       >
         <MessageActionBar
           channelId={channelId}
+          ref={actionRailMeasureRef}
           isFollowingThread={isFollowingThread}
           isUnread={isUnread}
           message={message}
@@ -639,7 +654,9 @@ export const MessageRow = React.memo(
       ) : null;
 
     const headerNode = isDisplayedAsContinuation ? null : (
-      <MessageHeaderRow>
+      // pe reserves the measured action-rail footprint (0px until measured) so
+      // header content ends before the rail's left edge in every rail state.
+      <MessageHeaderRow className="pe-[var(--message-action-rail-width,0px)]">
         {message.pubkey ? (
           <MessageAuthorWithIndicators
             authorName={message.author}
@@ -892,6 +909,7 @@ export const MessageRow = React.memo(
           data-message-id={message.id}
           data-testid="message-row"
           onAnimationEnd={handleEntranceAnimationEnd}
+          ref={articleRef}
         >
           {isThreadReplyLayout ? (
             <>
diff --git a/desktop/src/features/profile/ui/UserProfilePopover.tsx b/desktop/src/features/profile/ui/UserProfilePopover.tsx
index c36b59e3af6..7edeb286a8d 100644
--- a/desktop/src/features/profile/ui/UserProfilePopover.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePopover.tsx
@@ -49,6 +49,13 @@ type UserProfilePopoverProps = {
   children: React.ReactNode;
   pubkey: string;
   triggerElement?: "div" | "span";
+  /**
+   * Extra classes for the inline-flex trigger wrapper. The wrapper is a flex
+   * item at most call sites, and its `min-width: auto` refuses to shrink below
+   * the nowrap width of truncating children — pass `min-w-0 max-w-full` when
+   * the trigger wraps truncating text so the ellipsis can engage.
+   */
+  triggerClassName?: string;
   /** Accessible name for interactive trigger content that is visually hidden. */
   triggerAriaLabel?: string;
   /** Set false when the trigger is inside another interactive control. */
@@ -129,6 +136,7 @@ export function UserProfilePopover({
   children,
   pubkey,
   triggerElement = "div",
+  triggerClassName,
   triggerAriaLabel,
   enableProfilePanel = true,
   enableHoverPopover = true,
@@ -213,6 +221,7 @@ export function UserProfilePopover({
           onMouseLeave={handleMouseLeave}
           className={cn(
             "inline-flex",
+            triggerClassName,
             canOpenProfilePanel && "cursor-pointer [&_*]:cursor-pointer",
           )}
         >
diff --git a/desktop/src/shared/layout/observeElementBlockSize.ts b/desktop/src/shared/layout/observeElementBlockSize.ts
index c067e853413..bbd41da8a60 100644
--- a/desktop/src/shared/layout/observeElementBlockSize.ts
+++ b/desktop/src/shared/layout/observeElementBlockSize.ts
@@ -29,3 +29,35 @@ export function observeElementBlockSize(
     observer.disconnect();
   };
 }
+
+/**
+ * Reads the inline size from a ResizeObserver entry, preferring border-box
+ * size when available.
+ */
+export function readElementInlineSize(entry: ResizeObserverEntry): number {
+  return entry.borderBoxSize?.[0]?.inlineSize ?? entry.contentRect.width;
+}
+
+/**
+ * Invokes `onSize` immediately and whenever the observed element's inline size
+ * changes. Returns a cleanup function that disconnects the observer.
+ */
+export function observeElementInlineSize(
+  element: HTMLElement,
+  onSize: (size: number) => void,
+): () => void {
+  onSize(element.getBoundingClientRect().width);
+
+  if (typeof ResizeObserver === "undefined") {
+    return () => {};
+  }
+
+  const observer = new ResizeObserver(([entry]) => {
+    onSize(readElementInlineSize(entry));
+  });
+  observer.observe(element);
+
+  return () => {
+    observer.disconnect();
+  };
+}
diff --git a/desktop/src/shared/layout/useMeasuredCssVariable.ts b/desktop/src/shared/layout/useMeasuredCssVariable.ts
index c20b34b92a2..3a321001cea 100644
--- a/desktop/src/shared/layout/useMeasuredCssVariable.ts
+++ b/desktop/src/shared/layout/useMeasuredCssVariable.ts
@@ -1,9 +1,14 @@
 import * as React from "react";
 
-import { observeElementBlockSize } from "./observeElementBlockSize";
+import {
+  observeElementBlockSize,
+  observeElementInlineSize,
+} from "./observeElementBlockSize";
 
 type UseMeasuredCssVariableArgs = {
   cssVariable: string;
+  /** Which box dimension to observe. Defaults to `"block"` (height). */
+  dimension?: "block" | "inline";
   enabled?: boolean;
   resetKey?: unknown;
   resetValue: string;
@@ -11,9 +16,9 @@ type UseMeasuredCssVariableArgs = {
 };
 
 /**
- * Observes an element's block size and writes it as a CSS custom property on a
- * target element. Uses `useLayoutEffect` so the first measurement happens
- * before paint.
+ * Observes an element's block (or inline) size and writes it as a CSS custom
+ * property on a target element. Uses `useLayoutEffect` so the first
+ * measurement happens before paint.
  *
  * Returns a callback ref for the source element. Attach it instead of a ref
  * object so the measurement re-runs when the source mounts later than this
@@ -22,6 +27,7 @@ type UseMeasuredCssVariableArgs = {
 export function useMeasuredCssVariable({
   targetRef,
   cssVariable,
+  dimension = "block",
   resetValue,
   resetKey,
   enabled = true,
@@ -53,13 +59,25 @@ export function useMeasuredCssVariable({
       targetEl.style.setProperty(cssVariable, `${px}px`);
     };
 
-    const disconnect = observeElementBlockSize(sourceEl, applySize);
+    const observe =
+      dimension === "inline"
+        ? observeElementInlineSize
+        : observeElementBlockSize;
+    const disconnect = observe(sourceEl, applySize);
 
     return () => {
       disconnect();
       targetEl.style.setProperty(cssVariable, resetValue);
     };
-  }, [sourceEl, targetRef, cssVariable, resetValue, resetKey, enabled]);
+  }, [
+    sourceEl,
+    targetRef,
+    cssVariable,
+    dimension,
+    resetValue,
+    resetKey,
+    enabled,
+  ]);
 
   return setSourceEl;
 }
diff --git a/desktop/tests/e2e/inbox-title-overlap.spec.ts b/desktop/tests/e2e/inbox-title-overlap.spec.ts
new file mode 100644
index 00000000000..d0161bdbbca
--- /dev/null
+++ b/desktop/tests/e2e/inbox-title-overlap.spec.ts
@@ -0,0 +1,146 @@
+/**
+ * Regression test: a long inbox detail title must truncate instead of
+ * running underneath the header controls (open-in-channel, members,
+ * huddle, more menu) when the detail pane is narrow.
+ *
+ * Run: pnpm build:e2e && pnpm exec playwright test --project=smoke \
+ *        tests/e2e/inbox-title-overlap.spec.ts
+ * Output: test-results/inbox-title-overlap/
+ */
+import { expect, test } from "@playwright/test";
+
+import type { RelayEvent } from "../../src/shared/api/types";
+import { waitForAnimations } from "../helpers/animations";
+import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
+
+const SHOTS = "test-results/inbox-title-overlap";
+
+const ENGINEERING_CHANNEL_ID = "1c7e1c02-87bb-5e88-b2da-5a7a9432d0c9";
+
+type MockWindow = Window & {
+  __BUZZ_E2E_EMIT_MOCK_MESSAGE__?: (input: {
+    channelName: string;
+    content: string;
+    parentEventId?: string | null;
+    pubkey?: string;
+    mentionPubkeys?: string[];
+    id?: string;
+  }) => RelayEvent;
+  __BUZZ_E2E_PUSH_MOCK_FEED_ITEM__?: (item: {
+    category: "mention" | "needs_action" | "activity" | "agent_activity";
+    channel_id: string | null;
+    channel_name: string;
+    content: string;
+    created_at: number;
+    id: string;
+    kind: number;
+    pubkey: string;
+    tags: string[][];
+  }) => unknown;
+};
+
+test.describe("inbox detail title overflow", () => {
+  // Narrow window matching the report; the list pane is widened to its
+  // resizable maximum so the detail pane is squeezed to its 300px minimum
+  // and "Message in #engineering" cannot fit next to the header controls.
+  test.use({ viewport: { width: 1046, height: 838 } });
+
+  test("long title truncates instead of overlapping header controls", async ({
+    page,
+  }) => {
+    await page.addInitScript(() => {
+      window.sessionStorage.setItem(
+        "buzz.desktop.home-inbox-list-width",
+        "520",
+      );
+    });
+    await installMockBridge(page, { mode: "mock" });
+
+    await page.goto("/", { waitUntil: "domcontentloaded" });
+    await expect(page.getByTestId("home-inbox-list")).toBeVisible({
+      timeout: 10_000,
+    });
+    await page.waitForFunction(() => {
+      const win = window as MockWindow;
+      return (
+        typeof win.__BUZZ_E2E_EMIT_MOCK_MESSAGE__ === "function" &&
+        typeof win.__BUZZ_E2E_PUSH_MOCK_FEED_ITEM__ === "function"
+      );
+    });
+
+    const mentionId = "ab".repeat(32);
+    await page.evaluate(
+      ({ channelId, currentPubkey, id, senderPubkey }) => {
+        const win = window as MockWindow;
+        const emit = win.__BUZZ_E2E_EMIT_MOCK_MESSAGE__;
+        const push = win.__BUZZ_E2E_PUSH_MOCK_FEED_ITEM__;
+        if (!emit || !push) {
+          throw new Error("Mock bridge helpers are not installed.");
+        }
+        const event = emit({
+          channelName: "engineering",
+          content:
+            "Hey, can you look at the release checklist before tomorrow?",
+          id,
+          mentionPubkeys: [currentPubkey],
+          pubkey: senderPubkey,
+        });
+        push({
+          category: "mention",
+          channel_id: channelId,
+          channel_name: "engineering",
+          content: event.content,
+          created_at: event.created_at,
+          id: event.id,
+          kind: event.kind,
+          pubkey: event.pubkey,
+          tags: event.tags,
+        });
+      },
+      {
+        channelId: ENGINEERING_CHANNEL_ID,
+        currentPubkey: TEST_IDENTITIES.tyler.pubkey,
+        id: mentionId,
+        senderPubkey: TEST_IDENTITIES.alice.pubkey,
+      },
+    );
+
+    const row = page.getByTestId(`home-inbox-item-${mentionId}`);
+    await expect(row).toBeVisible();
+    await row.click();
+
+    const detail = page.getByTestId("home-inbox-detail");
+    await expect(detail).toBeVisible();
+    const title = detail.getByTestId("home-inbox-context-title");
+    await expect(title).toHaveText("Message in #engineering");
+    await waitForAnimations(page);
+
+    const titleBox = await title.boundingBox();
+    const controlsBox = await detail
+      .getByTestId("home-inbox-open-context")
+      .boundingBox();
+    if (!titleBox || !controlsBox) {
+      throw new Error("Header title or controls not rendered.");
+    }
+
+    // Guard against a vacuous pass: the title must still render with real
+    // width, and the squeeze must actually engage — the inner span's
+    // ellipsis is active only when its content overflows. If layout
+    // constants or fonts ever change so the full title fits, this fails
+    // loudly instead of silently no longer testing truncation.
+    expect(titleBox.width).toBeGreaterThan(0);
+    const isTruncated = await title.evaluate((element) => {
+      const span = element.querySelector("span");
+      return span ? span.scrollWidth > span.clientWidth : false;
+    });
+    expect(isTruncated).toBe(true);
+
+    await page.screenshot({
+      clip: { height: 96, width: 1046, x: 0, y: 0 },
+      path: `${SHOTS}/01-header.png`,
+    });
+
+    // The title's right edge must stop short of the first header control.
+    expect(titleBox.x + titleBox.width).toBeLessThanOrEqual(controlsBox.x + 1);
+  });
+});
diff --git a/desktop/tests/e2e/message-author-overlap.spec.ts b/desktop/tests/e2e/message-author-overlap.spec.ts
new file mode 100644
index 00000000000..b17bd6ce0b2
--- /dev/null
+++ b/desktop/tests/e2e/message-author-overlap.spec.ts
@@ -0,0 +1,159 @@
+/**
+ * Regression test: a long message-author display name must truncate instead
+ * of running past the message header into the timeline edge and the hover
+ * action bar. The author button sits inside the UserProfilePopover trigger
+ * wrapper — a flex item whose `min-width: auto` refused to shrink below the
+ * nowrap width of the name, so the button's `truncate` never engaged.
+ *
+ * Run: pnpm build:e2e && pnpm exec playwright test --project=smoke \
+ *        tests/e2e/message-author-overlap.spec.ts
+ * Output: test-results/message-author-overlap/
+ */
+import { expect, test } from "@playwright/test";
+
+import { waitForAnimations } from "../helpers/animations";
+import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
+
+const SHOTS = "test-results/message-author-overlap";
+
+// Long single-word name: no break opportunities, so the nowrap min-content
+// width far exceeds the header row at a 900px viewport.
+const LONG_AUTHOR_NAME =
+  "Alexandrina-Wolfeschlegelsteinhausenbergerdorff-Keihanaikukauakahihuliheekahaunaele-The-Magnificent-Third";
+
+const MESSAGE_CONTENT = "Author-name truncation regression probe";
+
+test.describe("message author name overflow", () => {
+  test.use({ viewport: { width: 900, height: 700 } });
+
+  test("long author name truncates instead of overflowing the header row", async ({
+    page,
+  }) => {
+    await installMockBridge(page, {
+      mode: "mock",
+      searchProfiles: [
+        {
+          pubkey: TEST_IDENTITIES.alice.pubkey,
+          displayName: LONG_AUTHOR_NAME,
+        },
+      ],
+    });
+
+    await page.goto("/", { waitUntil: "domcontentloaded" });
+    await page.getByTestId("channel-general").click();
+    await expect(page.getByTestId("chat-title")).toHaveText("general");
+    await page.waitForFunction(
+      () => typeof window.__BUZZ_E2E_EMIT_MOCK_MESSAGE__ === "function",
+    );
+    await page.evaluate(
+      ({ pubkey, content }) => {
+        window.__BUZZ_E2E_EMIT_MOCK_MESSAGE__?.({
+          channelName: "general",
+          content,
+          pubkey,
+        });
+      },
+      { content: MESSAGE_CONTENT, pubkey: TEST_IDENTITIES.alice.pubkey },
+    );
+
+    const row = page
+      .getByTestId("message-row")
+      .filter({ hasText: MESSAGE_CONTENT });
+    await expect(row).toBeVisible();
+    const author = row.getByTestId("message-author");
+    await expect(author).toHaveText(LONG_AUTHOR_NAME);
+    await waitForAnimations(page);
+
+    // The ellipsis carrier is the popover-trigger <button> around the author
+    // span — `truncate` on the inline span itself cannot clip.
+    const button = author.locator("xpath=ancestor::button[1]");
+    await expect(button).toBeVisible();
+
+    const buttonBox = await button.boundingBox();
+    const headerBox = await row.getByTestId("message-header").boundingBox();
+    if (!buttonBox || !headerBox) {
+      throw new Error("Author button or message header not rendered.");
+    }
+
+    // Guard against a vacuous pass: the author must still render with real
+    // width, and the squeeze must actually engage — the button's ellipsis is
+    // active only when its content overflows. If layout constants or fonts
+    // ever change so the full name fits, this fails loudly instead of
+    // silently no longer testing truncation.
+    expect(buttonBox.width).toBeGreaterThan(0);
+    const isTruncated = await button.evaluate(
+      (element) => element.scrollWidth > element.clientWidth,
+    );
+    expect(isTruncated).toBe(true);
+
+    await page.screenshot({
+      clip: {
+        height: 72,
+        width: 900,
+        x: 0,
+        y: Math.max(0, headerBox.y - 12),
+      },
+      path: `${SHOTS}/01-author-header.png`,
+    });
+
+    // The name's right edge must stay inside the header row instead of
+    // running under the pane edge / hover action bar.
+    expect(buttonBox.x + buttonBox.width).toBeLessThanOrEqual(
+      headerBox.x + headerBox.width + 1,
+    );
+
+    // The action rail (reactions/reply controls) is absolutely positioned OVER
+    // the row and appears on hover and on focus-within. In both states the
+    // author's painted box must end before the rail's left edge — a name that
+    // merely stays inside the header can still be painted over by the rail.
+    const actionBar = row.locator('[data-testid^="message-action-bar-"]');
+
+    const expectAuthorClearOfActionBar = async (state: string) => {
+      // Playwright's toBeVisible() passes at opacity 0; the rail's shown/hidden
+      // states are driven by opacity, so assert the computed style directly.
+      await expect(actionBar).toHaveCSS("opacity", "1");
+      const authorBox = await button.boundingBox();
+      const actionBarBox = await actionBar.boundingBox();
+      if (!authorBox || !actionBarBox) {
+        throw new Error(`Author or action bar not rendered on ${state}.`);
+      }
+      expect(actionBarBox.width).toBeGreaterThan(0);
+      // The squeeze must still be a real ellipsis, not a vacuous fit.
+      const stillTruncated = await button.evaluate(
+        (element) => element.scrollWidth > element.clientWidth,
+      );
+      expect(stillTruncated).toBe(true);
+      expect(authorBox.x + authorBox.width).toBeLessThanOrEqual(actionBarBox.x);
+    };
+
+    // Pointer hover.
+    await row.hover();
+    await waitForAnimations(page);
+    await page.screenshot({
+      clip: {
+        height: 72,
+        width: 900,
+        x: 0,
+        y: Math.max(0, headerBox.y - 12),
+      },
+      path: `${SHOTS}/02-author-header-hovered.png`,
+    });
+    await expectAuthorClearOfActionBar("hover");
+
+    // Reset the pointer, then re-reveal the rail via keyboard focus-within.
+    await page.mouse.move(0, 0);
+    await expect(actionBar).toHaveCSS("opacity", "0");
+    await button.focus();
+    await waitForAnimations(page);
+    await page.screenshot({
+      clip: {
+        height: 72,
+        width: 900,
+        x: 0,
+        y: Math.max(0, headerBox.y - 12),
+      },
+      path: `${SHOTS}/03-author-header-focused.png`,
+    });
+    await expectAuthorClearOfActionBar("focus-within");
+  });
+});

From 00209076c7a10d9e4a475466c313e8ebecf041f5 Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Thu, 10 Sep 2026 14:20:56 -0400
Subject: [PATCH 12/19] fix(relay): reject presence updates when Redis storage
 fails (#7532)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Summary
- Reject kind:20001 presence events with `OK false` / `error: presence
storage unavailable` when Redis SET or DEL fails, before publishing,
local fan-out, or local-event marking.
- Preserve the producer contract needed by snapshot-confirming
consumers: delivered live presence must follow successful mutation of
the Redis state read by snapshots.
- Classify those backend rejections with the existing `IngestError`
taxonomy so a presence storage outage counts as
`buzz_events_rejected_total{transport="ws",reason="error"}`, not client
`reason="invalid"`; genuine client-input refusals (verification failure,
membership gates) stay `invalid`, and every wire message is an unchanged
fixed sanitized string (review follow-up, no protocol wording change).
- Add actual `handle_event` integration coverage for rejected
online/offline transitions, healthy online→offline
accepted/stored/fanned-out behavior, and the rejection-counter routing
on storage failure with an invalid-signature control.

This is standalone on main; it does not depend on the mobile
implementation. Deploy this relay prerequisite before relying on #7526's
snapshot-confirmation policy. Existing
pubsub-failure-after-successful-storage behavior and disconnect TTL
cleanup are deliberately unchanged. A storage error may be an ambiguous
write outcome, not a rollback guarantee; the rejected event is not
published by this handler. Clients may retry the generic `error:`
rejection. Desktop's 60s heartbeat retries non-offline presence, not
every explicit offline transition.

### Related issue
Addresses the relay prerequisite identified in [#7526 review
5157607827](https://github.com/block/buzz/pull/7526#pullrequestreview-5157607827).
Searched open presence/storage PRs; no duplicate relay storage-error
rejection fix found. #7382/#7383/#7526 heads and bases are unchanged.

### Testing
Exact head: `389174df29cc02d0f885c03209eff661d8bb2ec0` (+380/-13; 393
total), one commit `389174df2` on top of the reviewed `c031d6eb1`
(DCO-signed; base `bfc384855889432df4a333a0edf3080f332ee169` unchanged).

- PASS: `cargo fmt --all -- --check`, `cargo clippy -p buzz-relay
--all-targets -- -D warnings`, `git diff --check`, `just
file-size-check`, PostgreSQL discovery validation — all run at the exact
final head with a clean tree before and after.
- PASS: documented native `scripts/postgres-test-run.sh -p buzz-relay
--lib --tests`: **89/89** actual integration tests, including the four
presence cases (online/offline storage rejection, healthy
online→offline, and the new rejection-classification case). Owned
PostgreSQL 17/Redis on isolated loopback ports, schema plus
reconciliation applied; no shared development database.
- PASS: explicit `cargo test -p buzz-relay presence_storage -- --ignored
--nocapture`: **4/4**, not skipped.
- Full isolated relay crate suite at the final head (`cargo nextest run
-p buzz-relay --lib --tests`): **1062 run: 1062 passed, 94 skipped**.
The previously failing
`api::mesh_demo::tests::demo_join_forwarded_arm_round_trips_echo` passed
in this run (1.5s); it is a known timing-sensitive main baseline failure
tracked open in #7140 and untouched by this PR, so this single passing
run is reported as-is and does not claim environmental clearance or
close #7140. No full-suite-green claim is made beyond this run.
- Mobile is untouched; #7526's existing 2090-test/format/analyze
evidence remains scoped to its unchanged head. Its separate Desktop
Smoke E2E (2) failure remains red; no CI retries requested.

[Production-seam regression
coverage](https://github.com/block/buzz/blob/389174df29cc02d0f885c03209eff661d8bb2ec0/crates/buzz-relay/src/handlers/event.rs#L1491-L1803):
the metric case drives real `handle_event` traffic against a genuinely
dead Redis endpoint with a seeded active PostgreSQL community and a
registered presence watcher, asserts the storage rejection counts
`reason="error"` while a tampered-signature control through the same
dispatcher arm stays `reason="invalid"`, and re-asserts the rejected
ACK, no fan-out, and no local-event marker. Counter assertions use a
thread-local recorder guard held across `.await` points (the buzz-db
counter-test convention) inside the per-process nextest postgres-ci
lane, so no parallel test can race the counter snapshot.

No UI change or screenshot. Local logs and reproducible service/gate
scripts are retained under
`WORK_LOGS/MOBILE_FEEDBACK_PRESENCE_20260909/relay_prerequisite/metric_correction/`
in the engineering workspace. This PR is a review candidate, not merge
clearance.

Causal checks: restoring only the pre-fix production mutation block
makes both original rejection tests fail (`OK true` instead of `false`);
healthy success still passes. Reverting only the typed classification
(mapping the ephemeral `Internal` arm back to `invalid`) makes the new
metric regression fail with the outage counted as `[("ws","invalid",2)]`
instead of `[("ws","error",1),("ws","invalid",1)]`. The unchanged mesh
echo case also failed 504/200 with the main-production block restored in
the prior run, supporting its separation from this change without
claiming environmental clearance. Candidate source restored
byte-for-byte after each mutation. Repository-wide `just ci` was not
rerun; the scoped relay gates above are the new evidence.

---------

Signed-off-by: Logan Johnson <loganj@squareup.com>
---
 crates/buzz-relay/src/handlers/event.rs | 393 +++++++++++++++++++++++-
 1 file changed, 380 insertions(+), 13 deletions(-)

diff --git a/crates/buzz-relay/src/handlers/event.rs b/crates/buzz-relay/src/handlers/event.rs
index 66a8ff9e7c0..082522b1238 100644
--- a/crates/buzz-relay/src/handlers/event.rs
+++ b/crates/buzz-relay/src/handlers/event.rs
@@ -743,8 +743,21 @@ pub async fn handle_event(event: Event, conn: Arc<ConnectionState>, state: Arc<A
             Ok(()) => {
                 conn.send(RelayMessage::ok(&event_id_hex, true, ""));
             }
-            Err(message) => {
-                reject("invalid");
+            Err(e) => {
+                // Rejections carry the ingest taxonomy so backend failures
+                // count as `error` — a Redis presence-storage outage is a
+                // server fault, not client misbehavior — while genuine
+                // client-input rejections (bad signature, non-member
+                // sender) stay `invalid`. The ephemeral handler only emits
+                // fixed, sanitized message strings, so unlike the
+                // persistent arm below, `Internal` text is safe to forward
+                // verbatim.
+                let (message, reason) = match e {
+                    IngestError::Rejected(message) => (message, "invalid"),
+                    IngestError::AuthFailed(message) => (message, "auth"),
+                    IngestError::Internal(message) => (message, "error"),
+                };
+                reject(reason);
                 conn.send(RelayMessage::ok(&event_id_hex, false, &message));
             }
         }
@@ -792,6 +805,12 @@ pub async fn handle_event(event: Event, conn: Arc<ConnectionState>, state: Arc<A
 }
 
 /// Handle ephemeral events (kind 20000–29999) — WS-only, never stored.
+///
+/// Rejections are typed with the ingest taxonomy: [`IngestError::Rejected`]
+/// is a client-input refusal (stays `invalid` in the rejection counter),
+/// while [`IngestError::Internal`] is a backend failure — e.g. a Redis
+/// presence-storage outage — which the dispatcher counts as `error`. Every
+/// message is a fixed, sanitized string that is forwarded verbatim.
 async fn handle_ephemeral_event(
     event: Event,
     conn_id: uuid::Uuid,
@@ -799,15 +818,15 @@ async fn handle_ephemeral_event(
     auth_pubkey: nostr::PublicKey,
     conn: Arc<ConnectionState>,
     state: Arc<AppState>,
-) -> Result<(), String> {
+) -> Result<(), IngestError> {
     let event_clone = event.clone();
     let event_id = event.id.to_hex();
     let verify_result = tokio::task::spawn_blocking(move || verify_event(&event_clone)).await;
 
     match verify_result {
         Ok(Ok(())) => {}
-        Ok(Err(e)) => return Err(format!("invalid: {e}")),
-        Err(_) => return Err("error: internal error".to_string()),
+        Ok(Err(e)) => return Err(IngestError::Rejected(format!("invalid: {e}"))),
+        Err(_) => return Err(IngestError::Internal("error: internal error".to_string())),
     }
 
     // Special handling for presence events (kind:20001).
@@ -829,16 +848,45 @@ async fn handle_ephemeral_event(
             raw
         };
 
+        // Presence mutation is the inclusion contract for the live fan-out
+        // below: a client that observes the fanned-out event treats a later
+        // snapshot as reflecting it (see `synthesize_presence` in
+        // `api/bridge.rs`, which reads Redis). If the mutation failed we
+        // published nothing — so we must also fan out nothing and reject the
+        // ACK, or a snapshot later "confirms" stale storage over a live event
+        // the sender believes was delivered.
         if status == "offline" {
-            let _ = state
+            if let Err(e) = state
                 .pubsub
                 .clear_presence(&conn.tenant, &auth_pubkey)
-                .await;
-        } else {
-            let _ = state
-                .pubsub
-                .set_presence(&conn.tenant, &auth_pubkey, &status)
-                .await;
+                .await
+            {
+                warn!(
+                    conn_id = %conn_id,
+                    event_id = %event_id,
+                    "Presence clear failed, refusing publish and fan-out: {e}"
+                );
+                // Internal, not Rejected: a storage outage is a server
+                // failure, so the dispatcher must count it under the
+                // `error` reason, not as client-invalid input.
+                return Err(IngestError::Internal(
+                    "error: presence storage unavailable".to_string(),
+                ));
+            }
+        } else if let Err(e) = state
+            .pubsub
+            .set_presence(&conn.tenant, &auth_pubkey, &status)
+            .await
+        {
+            warn!(
+                conn_id = %conn_id,
+                event_id = %event_id,
+                "Presence set failed, refusing publish and fan-out: {e}"
+            );
+            // Internal for the same reason as the clear arm above.
+            return Err(IngestError::Internal(
+                "error: presence storage unavailable".to_string(),
+            ));
         }
 
         // Presence is a channel-less ephemeral event. After updating Redis
@@ -848,8 +896,12 @@ async fn handle_ephemeral_event(
 
     // Check channel membership before publishing other ephemeral events.
     if let Some(ch_id) = super::ingest::extract_channel_id(&event) {
+        // Membership refusals are client-input rejections, and the shared
+        // gate's message text is surfaced verbatim exactly as before this
+        // typed classification; no behavior change on this path.
         super::ingest::check_channel_membership(&conn.tenant, &state, ch_id, &pubkey_bytes, None)
-            .await?;
+            .await
+            .map_err(IngestError::Rejected)?;
 
         // Mark as local before Redis publish to prevent double-delivery when
         // the event comes back through the Redis subscriber loop.
@@ -1435,6 +1487,321 @@ mod tests {
         );
     }
 
+    // PostgreSQL/Redis tests are discovered by the isolated postgres-ci lane.
+    mod presence_storage_postgres_tests {
+        use super::*;
+        use buzz_core::{CommunityId, TenantContext};
+        use nostr::Filter;
+
+        async fn exercise(storage_available: bool, statuses: &[&str]) {
+            let redis_url = std::env::var("REDIS_URL").expect("test Redis URL required");
+            // Pick an unused local endpoint for a real connection failure.
+            let dead_socket = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+            let dead_port = dead_socket.local_addr().unwrap().port();
+            drop(dead_socket);
+            let dead_url = format!("redis://127.0.0.1:{dead_port}");
+            let state = fanout_access::test_state_with_redis_url(if storage_available {
+                &redis_url
+            } else {
+                &dead_url
+            })
+            .await;
+            let pool = sqlx::PgPool::connect(&state.config.database_url)
+                .await
+                .unwrap();
+            let community_uuid = Uuid::new_v4();
+            let host = format!("presence-storage-{}.example", community_uuid.simple());
+            sqlx::query("INSERT INTO communities (id, host) VALUES ($1, $2)")
+                .bind(community_uuid)
+                .bind(&host)
+                .execute(&pool)
+                .await
+                .expect("seed active community");
+            let tenant = TenantContext::resolved(CommunityId::from_uuid(community_uuid), host);
+            let keys = Keys::generate();
+            let (send_tx, mut send_rx) = mpsc::channel(10);
+            let (ctrl_tx, _ctrl_rx) = mpsc::channel(10);
+            let conn = Arc::new(crate::connection::ConnectionState {
+                conn_id: Uuid::new_v4(),
+                tenant: tenant.clone(),
+                remote_addr: "127.0.0.1:1234".parse().unwrap(),
+                auth_state: RwLock::new(crate::connection::AuthState::Authenticated(
+                    buzz_auth::AuthContext {
+                        pubkey: keys.public_key(),
+                        scopes: vec![],
+                        channel_ids: None,
+                        auth_method: buzz_auth::AuthMethod::Nip42,
+                        agent_owner_pubkey: None,
+                    },
+                )),
+                subscriptions: Arc::new(Mutex::new(HashMap::new())),
+                send_tx,
+                ctrl_tx,
+                cancel: CancellationToken::new(),
+                backpressure_count: Arc::new(AtomicU8::new(0)),
+                grace_limit: 3,
+            });
+            let watcher = Uuid::new_v4();
+            let (tx, mut rx) = mpsc::channel(10);
+            let (ctrl, _ctrl_rx) = mpsc::channel(10);
+            state.conn_manager.register(
+                watcher,
+                tx,
+                ctrl,
+                None,
+                CancellationToken::new(),
+                tenant.community(),
+                Arc::new(AtomicU8::new(0)),
+                Arc::new(Mutex::new(HashMap::new())),
+                3,
+            );
+            state.sub_registry.register_scoped(
+                tenant.community(),
+                watcher,
+                "presence".into(),
+                vec![Filter::new().kind(Kind::Custom(KIND_PRESENCE_UPDATE as u16))],
+                None,
+            );
+            // Online followed by offline also proves DEL removes an existing value.
+            for &status in statuses {
+                let event = EventBuilder::new(Kind::Custom(KIND_PRESENCE_UPDATE as u16), status)
+                    .sign_with_keys(&keys)
+                    .unwrap();
+                super::super::handle_event(event.clone(), conn.clone(), state.clone()).await;
+                let axum::extract::ws::Message::Text(text) = send_rx.try_recv().expect("ACK")
+                else {
+                    panic!("expected text ACK");
+                };
+                let ack: serde_json::Value = serde_json::from_str(&text).unwrap();
+                assert_eq!(ack[0], "OK");
+                assert_eq!(ack[1], event.id.to_hex());
+                assert_eq!(ack[2], storage_available);
+                if storage_available {
+                    assert_eq!(ack[3], "");
+                    let stored = state
+                        .pubsub
+                        .get_presence(&tenant, &keys.public_key())
+                        .await
+                        .unwrap();
+                    assert_eq!(stored.as_deref(), (status != "offline").then_some(status));
+                    let axum::extract::ws::Message::Text(text) =
+                        rx.try_recv().expect("live fanout")
+                    else {
+                        panic!("expected text event");
+                    };
+                    let frame: serde_json::Value = serde_json::from_str(&text).unwrap();
+                    assert_eq!(frame[0], "EVENT");
+                    assert_eq!(frame[2]["id"], event.id.to_hex());
+                } else {
+                    assert_eq!(ack[3], "error: presence storage unavailable");
+                    assert!(state
+                        .local_event_ids
+                        .get(&(tenant.community(), event.id.to_bytes()))
+                        .is_none());
+                }
+                assert!(rx.try_recv().is_err(), "no extra or rejected-event fanout");
+                assert!(send_rx.try_recv().is_err(), "exactly one ACK");
+            }
+            sqlx::query("DELETE FROM communities WHERE id = $1")
+                .bind(community_uuid)
+                .execute(&pool)
+                .await
+                .unwrap();
+        }
+
+        #[tokio::test]
+        #[ignore = "requires PostgreSQL and Redis"]
+        async fn rejects_online_when_presence_storage_fails() {
+            exercise(false, &["online"]).await;
+        }
+
+        #[tokio::test]
+        #[ignore = "requires PostgreSQL and Redis"]
+        async fn rejects_offline_when_presence_storage_fails() {
+            exercise(false, &["offline"]).await;
+        }
+
+        #[tokio::test]
+        #[ignore = "requires PostgreSQL and Redis"]
+        async fn accepts_stores_and_fans_out_online_and_offline() {
+            exercise(true, &["online", "offline"]).await;
+        }
+
+        /// Production-seam regression for the rejection classification: a
+        /// Redis presence-storage outage must count as a server `error`,
+        /// never as client `invalid`, while a genuinely invalid event
+        /// through the same seam stays `invalid`. Both rejections still ACK
+        /// `false` with no fan-out and no local-event marker (the shared
+        /// storage guard is unchanged); only the counter routing is under
+        /// test here.
+        ///
+        /// The recorder guard form (not `metrics::with_local_recorder`,
+        /// whose closure cannot host an await) keeps the thread-local
+        /// recorder installed across the `.await` points of this
+        /// single-threaded test runtime — the same convention as the
+        /// buzz-db route-decision counter tests. The isolated postgres-ci
+        /// lane runs each test in its own nextest process, so no parallel
+        /// test can race this counter snapshot.
+        #[tokio::test]
+        #[ignore = "requires PostgreSQL"]
+        async fn counts_presence_storage_failure_as_error_not_invalid() {
+            // Pick an unused local endpoint for a real connection failure.
+            let dead_socket = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+            let dead_port = dead_socket.local_addr().unwrap().port();
+            drop(dead_socket);
+            let dead_url = format!("redis://127.0.0.1:{dead_port}");
+            let state = fanout_access::test_state_with_redis_url(&dead_url).await;
+            let pool = sqlx::PgPool::connect(&state.config.database_url)
+                .await
+                .unwrap();
+            let community_uuid = Uuid::new_v4();
+            let host = format!("presence-metrics-{}.example", community_uuid.simple());
+            sqlx::query("INSERT INTO communities (id, host) VALUES ($1, $2)")
+                .bind(community_uuid)
+                .bind(&host)
+                .execute(&pool)
+                .await
+                .expect("seed active community");
+            let tenant = TenantContext::resolved(CommunityId::from_uuid(community_uuid), host);
+            let keys = Keys::generate();
+            let (send_tx, mut send_rx) = mpsc::channel(10);
+            let (ctrl_tx, _ctrl_rx) = mpsc::channel(10);
+            let conn = Arc::new(crate::connection::ConnectionState {
+                conn_id: Uuid::new_v4(),
+                tenant: tenant.clone(),
+                remote_addr: "127.0.0.1:1234".parse().unwrap(),
+                auth_state: RwLock::new(crate::connection::AuthState::Authenticated(
+                    buzz_auth::AuthContext {
+                        pubkey: keys.public_key(),
+                        scopes: vec![],
+                        channel_ids: None,
+                        auth_method: buzz_auth::AuthMethod::Nip42,
+                        agent_owner_pubkey: None,
+                    },
+                )),
+                subscriptions: Arc::new(Mutex::new(HashMap::new())),
+                send_tx,
+                ctrl_tx,
+                cancel: CancellationToken::new(),
+                backpressure_count: Arc::new(AtomicU8::new(0)),
+                grace_limit: 3,
+            });
+            // Same watcher registration as the ACK/fan-out cases, proving
+            // the storage failure still reaches no subscriber while its
+            // rejection is counted under `error`.
+            let watcher = Uuid::new_v4();
+            let (tx, mut rx) = mpsc::channel(10);
+            let (ctrl, _ctrl_rx) = mpsc::channel(10);
+            state.conn_manager.register(
+                watcher,
+                tx,
+                ctrl,
+                None,
+                CancellationToken::new(),
+                tenant.community(),
+                Arc::new(AtomicU8::new(0)),
+                Arc::new(Mutex::new(HashMap::new())),
+                3,
+            );
+            state.sub_registry.register_scoped(
+                tenant.community(),
+                watcher,
+                "presence".into(),
+                vec![Filter::new().kind(Kind::Custom(KIND_PRESENCE_UPDATE as u16))],
+                None,
+            );
+
+            let valid = EventBuilder::new(Kind::Custom(KIND_PRESENCE_UPDATE as u16), "online")
+                .sign_with_keys(&keys)
+                .unwrap();
+            // Invalid control through the same production seam: identical
+            // event, signature no longer verifies. The id is unchanged (it
+            // does not cover the signature), so ACKs are told apart by
+            // order and message text below.
+            use nostr::JsonUtil as _;
+            let mut json: serde_json::Value =
+                serde_json::from_str(&valid.as_json()).expect("parse event json");
+            json["sig"] = serde_json::Value::String("0".repeat(128));
+            let tampered = nostr::Event::from_json(json.to_string()).expect("parse tampered");
+
+            let recorder = metrics_util::debugging::DebuggingRecorder::new();
+            let snapshotter = recorder.snapshotter();
+            let acks: Vec<serde_json::Value> = {
+                let _guard = metrics::set_default_local_recorder(&recorder);
+                super::super::handle_event(valid.clone(), conn.clone(), state.clone()).await;
+                super::super::handle_event(tampered, conn.clone(), state.clone()).await;
+                (0..2)
+                    .map(|_| {
+                        let axum::extract::ws::Message::Text(text) =
+                            send_rx.try_recv().expect("ACK")
+                        else {
+                            panic!("expected text ACK");
+                        };
+                        serde_json::from_str(&text).unwrap()
+                    })
+                    .collect()
+            };
+
+            // Storage failure: rejected ACK, no fan-out frame, no marker.
+            assert_eq!(acks[0][0], "OK");
+            assert_eq!(acks[0][1], valid.id.to_hex());
+            assert_eq!(acks[0][2], false);
+            assert_eq!(acks[0][3], "error: presence storage unavailable");
+            // Invalid control through the same dispatcher arm.
+            assert_eq!(acks[1][0], "OK");
+            assert_eq!(acks[1][1], valid.id.to_hex());
+            assert_eq!(acks[1][2], false);
+            assert!(
+                acks[1][3].as_str().unwrap().starts_with("invalid:"),
+                "tampered control must stay an invalid rejection, got: {}",
+                acks[1][3]
+            );
+            assert!(rx.try_recv().is_err(), "no fan-out for either rejection");
+            assert!(send_rx.try_recv().is_err(), "exactly two ACKs");
+            assert!(state
+                .local_event_ids
+                .get(&(tenant.community(), valid.id.to_bytes()))
+                .is_none());
+
+            let mut rejections: Vec<(String, String, u64)> = snapshotter
+                .snapshot()
+                .into_vec()
+                .into_iter()
+                .filter(|(key, ..)| key.key().name() == "buzz_events_rejected_total")
+                .map(|(key, _, _, value)| {
+                    let metrics_util::debugging::DebugValue::Counter(count) = value else {
+                        panic!("buzz_events_rejected_total must be a counter");
+                    };
+                    let labels: Vec<_> = key.key().labels().collect();
+                    let label = |name: &str| {
+                        labels
+                            .iter()
+                            .find(|l| l.key() == name)
+                            .map(|l| l.value().to_owned())
+                            .unwrap_or_default()
+                    };
+                    (label("transport"), label("reason"), count)
+                })
+                .collect();
+            rejections.sort();
+            assert_eq!(
+                rejections,
+                vec![
+                    ("ws".to_owned(), "error".to_owned(), 1),
+                    ("ws".to_owned(), "invalid".to_owned(), 1),
+                ],
+                "storage outage must count as reason=\"error\" and the tampered \
+                 control as reason=\"invalid\"; got {rejections:?}"
+            );
+
+            sqlx::query("DELETE FROM communities WHERE id = $1")
+                .bind(community_uuid)
+                .execute(&pool)
+                .await
+                .unwrap();
+        }
+    }
+
     mod pubsub_fanout {
         use std::collections::HashMap;
         use std::sync::atomic::AtomicU8;

From 092c6a7277698bd373ccbc1d008fc1507094ae74 Mon Sep 17 00:00:00 2001
From: Taylor Ho <taylorkmho@gmail.com>
Date: Thu, 10 Sep 2026 15:42:10 -0700
Subject: [PATCH 13/19] fix(markdown): align mention chip wrapping (#7501)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

**Category:** fix
**User Impact:** Human and agent mentions now break across lines with
the same cloned chip treatment as repository and permalink chips while
preserving the conversation text rhythm.

**Problem:** Profile-backed rendered mentions sat inside an
`inline-flex` popover trigger, unlike entity chips, so the wrapper
interfered with true inline fragmentation. The browser-layout test
measured text-range rows rather than the painted chip rectangles,
allowing touching decorations to pass as “separate” fragments.

**Solution:** Keep the profile trigger interactive but override its
layout to true `inline`, then give mention fragments 18px computed
leading inside the message’s 20px prose rhythm. Chromium paints each
fragment at 17px and advances it by 20px, leaving a visible gap between
cloned rounded rectangles. The browser test now measures the chip’s own
`getClientRects()` and asserts fragment count, height, gap, and step;
entity links retain their existing 22px leading.

<details>
<summary>File changes</summary>

**desktop/src/features/profile/ui/UserProfilePopover.tsx**
Allows inline consumers to override the trigger wrapper’s layout without
changing other profile-popover call sites.

**desktop/src/shared/styles/globals/markdown.css**
Keeps one shared wrapping-chip mechanic and gives mention decorations
enough room to separate visibly within 20px prose.

**desktop/src/shared/ui/markdown.test.mjs**
Pins both rendered mentions and entity links to the shared wrapping-chip
contract.

**desktop/src/shared/ui/markdown/MarkdownMention.tsx**
Makes the profile-popover trigger truly inline so the nested mention
chip can fragment with surrounding prose.

**desktop/src/shared/ui/mentionChip.ts**
Keeps `wrapping-inline-chip` as the single contract for fragmenting
decorated chips.

**desktop/tests/e2e/mentions.spec.ts**
Measures the painted chip rectangles, requires a positive fragment gap,
and verifies the inline trigger remains mouse- and keyboard-operable.

**desktop/tests/e2e/navigation.spec.ts**
Keeps a wrapped repository chip as the control, asserting its existing
22px line height and fragment advance.

</details>

## Reproduction steps

1. Open a channel in Buzz Desktop using dark theme.
2. Send a message containing a human mention and another containing an
agent mention; both chips should remain aligned with adjacent text on a
20px line.
3. Render a collision-qualified mention in a narrow message width; it
should break into separately decorated fragments exactly like another
wrapping chip, while each fragment follows the 20px prose rhythm.
4. Render a long repository or permalink chip in the same constrained
width; it should retain its roomier 22px fragment spacing.

## Screenshot

The dark-theme production renderer shows the real qualified label (`bob
(npub1hv3…tpuc)`) at an 8rem width. The two lines now paint as visibly
separate rounded fragments rather than one continuous rectangle.

![Qualified human mention wrapping into two visibly separate rounded
fragments in the dark-theme Buzz
timeline](https://github.com/user-attachments/assets/ee6e7be5-937e-4022-9c82-cf71f8203470)

## Validation

At commit `2b063e1b4ade30e11f1616269ad4ba4190366885`:

- Pre-push desktop gates — file-size check, Biome/checks, typecheck, and
6,483 unit tests passed
- `pnpm --dir desktop build` — passed
- Focused Playwright coverage for single-line agent mention, single-line
human mention, wrapped qualified mention including keyboard profile
activation, and timeline mention click — 4 passed
- `git diff --check` — passed

---------

Signed-off-by: Taylor Ho <taylorkmho@gmail.com>
Co-authored-by: Rizz <rizz@agents.buzz>
Co-authored-by: Carl <acda9e433d19dcd0e6b6840f7f4b98f3a56f1fab98049d444c087019e6d36560@buzz.block.builderlab.xyz>
---
 .../profile/ui/UserProfilePopover.tsx         |   7 +-
 .../src/shared/styles/globals/markdown.css    |   6 +
 desktop/src/shared/ui/markdown.test.mjs       |   1 +
 .../shared/ui/markdown/MarkdownMention.tsx    |   1 +
 desktop/tests/e2e/mentions.spec.ts            | 113 +++++++++++++++++-
 desktop/tests/e2e/navigation.spec.ts          |  27 ++++-
 6 files changed, 145 insertions(+), 10 deletions(-)

diff --git a/desktop/src/features/profile/ui/UserProfilePopover.tsx b/desktop/src/features/profile/ui/UserProfilePopover.tsx
index 7edeb286a8d..62ec0d49285 100644
--- a/desktop/src/features/profile/ui/UserProfilePopover.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePopover.tsx
@@ -50,10 +50,9 @@ type UserProfilePopoverProps = {
   pubkey: string;
   triggerElement?: "div" | "span";
   /**
-   * Extra classes for the inline-flex trigger wrapper. The wrapper is a flex
-   * item at most call sites, and its `min-width: auto` refuses to shrink below
-   * the nowrap width of truncating children — pass `min-w-0 max-w-full` when
-   * the trigger wraps truncating text so the ellipsis can engage.
+   * Extra classes for the trigger wrapper, which defaults to inline-flex.
+   * Use `min-w-0 max-w-full` when truncating flex content must shrink, or
+   * `inline` when prose content must fragment across lines.
    */
   triggerClassName?: string;
   /** Accessible name for interactive trigger content that is visually hidden. */
diff --git a/desktop/src/shared/styles/globals/markdown.css b/desktop/src/shared/styles/globals/markdown.css
index 251fdb525c2..bf6eeb64312 100644
--- a/desktop/src/shared/styles/globals/markdown.css
+++ b/desktop/src/shared/styles/globals/markdown.css
@@ -100,6 +100,12 @@
   white-space: normal;
 }
 
+/* Mentions use the prose rhythm while retaining cloned chip decoration. */
+.message-markdown [data-mention].wrapping-inline-chip {
+  padding-block: 0;
+  line-height: calc(var(--conversation-message-line-height) - 2px);
+}
+
 .message-markdown .mention-chip.buzz-link-unavailable,
 .message-markdown .mention-chip.buzz-link-unavailable:hover,
 .message-markdown .mention-chip.buzz-link-deleted,
diff --git a/desktop/src/shared/ui/markdown.test.mjs b/desktop/src/shared/ui/markdown.test.mjs
index 08861a4daa1..83af8b78572 100644
--- a/desktop/src/shared/ui/markdown.test.mjs
+++ b/desktop/src/shared/ui/markdown.test.mjs
@@ -1400,6 +1400,7 @@ test("resolved human mentions replace the authored at-sign with the shared icon"
   );
 
   assert.match(html, /data-mention=""/);
+  assert.match(html, /wrapping-inline-chip/);
   assert.match(
     html,
     /inline-chip-leading-fragment[^>]*inline-chip-icon-human[^>]*>alice<\/span>/,
diff --git a/desktop/src/shared/ui/markdown/MarkdownMention.tsx b/desktop/src/shared/ui/markdown/MarkdownMention.tsx
index 4928de95137..9d9f59ad60f 100644
--- a/desktop/src/shared/ui/markdown/MarkdownMention.tsx
+++ b/desktop/src/shared/ui/markdown/MarkdownMention.tsx
@@ -77,6 +77,7 @@ export function createMarkdownMention(interactive: boolean) {
         pubkey={pubkey}
         role={isAgentMention ? "bot" : undefined}
         triggerElement="span"
+        triggerClassName="inline"
       >
         {mentionNode}
       </UserProfilePopover>
diff --git a/desktop/tests/e2e/mentions.spec.ts b/desktop/tests/e2e/mentions.spec.ts
index ee3731d16d7..40a132e6df9 100644
--- a/desktop/tests/e2e/mentions.spec.ts
+++ b/desktop/tests/e2e/mentions.spec.ts
@@ -1,4 +1,4 @@
-import { expect, test } from "@playwright/test";
+import { expect, test, type Locator } from "@playwright/test";
 
 import { truncateNpub } from "../../src/shared/lib/pubkey";
 import { waitForAnimations } from "../helpers/animations";
@@ -88,6 +88,43 @@ const JOIN_COLLAPSE_CAPTURE_WIDTH = 560;
 const JOIN_COLLAPSE_CAPTURE_HEIGHT = 260;
 const JOIN_COLLAPSE_CAPTURE_VERTICAL_PADDING = 24;
 
+async function timelineChipLayout(chip: Locator) {
+  return chip.evaluate((element) => {
+    const paragraph = element.closest("p");
+    if (!paragraph) throw new Error("Timeline chip is missing its paragraph");
+    const chipBounds = element.getBoundingClientRect();
+    const paragraphBounds = paragraph.getBoundingClientRect();
+    const chipFragmentRects = Array.from(element.getClientRects())
+      .filter((rect) => rect.width > 0 && rect.height > 0)
+      .sort((a, b) => a.top - b.top);
+    const chipStyle = getComputedStyle(element);
+    return {
+      boxDecorationBreak:
+        chipStyle.getPropertyValue("box-decoration-break") ||
+        chipStyle.getPropertyValue("-webkit-box-decoration-break"),
+      chipHeight: chipBounds.height,
+      chipLineHeight: Number.parseFloat(chipStyle.lineHeight),
+      fragmentCount: chipFragmentRects.length,
+      fragmentGap:
+        chipFragmentRects.length > 1
+          ? Math.round(chipFragmentRects[1].top - chipFragmentRects[0].bottom)
+          : null,
+      fragmentHeight:
+        chipFragmentRects.length > 0
+          ? Math.round(chipFragmentRects[0].height)
+          : null,
+      fragmentStep:
+        chipFragmentRects.length > 1
+          ? Math.round(chipFragmentRects[1].top - chipFragmentRects[0].top)
+          : null,
+      paragraphHeight: paragraphBounds.height,
+      paragraphLineHeight: Number.parseFloat(
+        getComputedStyle(paragraph).lineHeight,
+      ),
+    };
+  });
+}
+
 /** Locator scoped to the mention autocomplete dropdown inside the composer. */
 function autocomplete(page: import("@playwright/test").Page) {
   return page
@@ -1583,6 +1620,19 @@ test("selecting a persona mention creates a channel agent before sending and sta
     .locator("[data-mention].agent-mention-highlight", { hasText: "Fizz" });
   await expect(mentionChip).toBeVisible();
   await expect(mentionChip).toHaveText("Fizz");
+  await expect(mentionChip).toHaveClass(/wrapping-inline-chip/);
+  const timelineLayout = await timelineChipLayout(mentionChip);
+  expect(timelineLayout).toMatchObject({
+    boxDecorationBreak: "clone",
+    chipHeight: 17,
+    chipLineHeight: 18,
+    fragmentCount: 1,
+    fragmentGap: null,
+    fragmentHeight: 17,
+    fragmentStep: null,
+    paragraphHeight: 20,
+    paragraphLineHeight: 20,
+  });
 });
 
 test("selecting a persona mention reuses an existing persona agent", async ({
@@ -4518,6 +4568,67 @@ test("mention text is highlighted in sent messages", async ({ page }) => {
   await expect(mentionChip).toBeVisible();
   await expect(mentionChip).toHaveText("bob");
   await expect(mentionChip).toHaveClass(/inline-chip-icon-human/);
+  await expect(mentionChip).toHaveClass(/wrapping-inline-chip/);
+
+  const timelineLayout = await timelineChipLayout(mentionChip);
+  expect(timelineLayout).toMatchObject({
+    boxDecorationBreak: "clone",
+    chipHeight: 17,
+    chipLineHeight: 18,
+    fragmentCount: 1,
+    fragmentGap: null,
+    fragmentHeight: 17,
+    fragmentStep: null,
+    paragraphHeight: 20,
+    paragraphLineHeight: 20,
+  });
+});
+
+test("qualified mentions wrap without changing message line rhythm", async ({
+  page,
+}) => {
+  const pubkey = TEST_IDENTITIES.bob.pubkey;
+  const qualifiedLabel = `bob (${pubkey})`;
+
+  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", `@${qualifiedLabel}`, {
+    mentionPubkeys: [pubkey],
+  });
+  await waitForTimelineSettled(page);
+
+  const row = page.getByTestId("message-row").filter({ hasText: "bob" }).last();
+  await row.evaluate((element) => {
+    const prose = element.querySelector<HTMLElement>(".message-markdown");
+    if (!prose)
+      throw new Error("Qualified mention is missing its prose wrapper");
+    prose.style.width = "8rem";
+  });
+  const mentionChip = row.locator("[data-mention]", { hasText: "bob" });
+  await expect(mentionChip).toHaveText(/bob \(npub1hv3…tpuc\)/);
+  await expect(mentionChip).toHaveClass(/wrapping-inline-chip/);
+
+  const layout = await timelineChipLayout(mentionChip);
+  expect(layout.boxDecorationBreak).toBe("clone");
+  expect(layout.chipLineHeight).toBe(18);
+  expect(layout.fragmentCount).toBe(2);
+  expect(layout.fragmentHeight).toBe(17);
+  expect(layout.fragmentGap).toBeGreaterThanOrEqual(1);
+  expect(layout.fragmentStep).toBe(20);
+  expect(layout.paragraphLineHeight).toBe(20);
+  expect(layout.chipHeight).toBeLessThanOrEqual(
+    layout.fragmentCount * layout.paragraphLineHeight,
+  );
+
+  const trigger = mentionChip.locator("xpath=..");
+  await expect(trigger).toHaveCSS("display", "inline");
+  await expect(trigger).toHaveAttribute("role", "button");
+  await trigger.focus();
+  await expect(trigger).toBeFocused();
+  await trigger.press("Enter");
+  await expect(page.getByTestId("user-profile-panel")).toBeVisible();
 });
 
 test("clicking author name opens user profile panel", async ({ page }) => {
diff --git a/desktop/tests/e2e/navigation.spec.ts b/desktop/tests/e2e/navigation.spec.ts
index d19849ea17c..6f6d1f28401 100644
--- a/desktop/tests/e2e/navigation.spec.ts
+++ b/desktop/tests/e2e/navigation.spec.ts
@@ -577,21 +577,38 @@ test("composer Buzz chip labels wrap without orphaning their icons", async ({
     name: "Open repository relaytoolsobservabilityconsole-main",
   });
   await expect(sentChip).toBeVisible();
+  await expect(sentChip).toHaveClass(/wrapping-inline-chip/);
   await sentChip.evaluate((element) => {
     const container = element.parentElement;
     if (container) container.style.width = "220px";
   });
-  const fragmentRects = await sentChip.evaluate((element) =>
-    Array.from(element.getClientRects(), (rect) => ({
+  const fragmentMetrics = await sentChip.evaluate((element) => {
+    const chipStyle = getComputedStyle(element);
+    const rects = Array.from(element.getClientRects(), (rect) => ({
       bottom: rect.bottom,
       height: rect.height,
       left: rect.left,
       right: rect.right,
       top: rect.top,
       width: rect.width,
-    })).filter((rect) => rect.width > 0 && rect.height > 0),
-  );
-  expect(fragmentRects.length).toBeGreaterThanOrEqual(2);
+    })).filter((rect) => rect.width > 0 && rect.height > 0);
+    const fragmentTops = Array.from(
+      new Set(rects.map((rect) => Math.round(rect.top))),
+    ).sort((a, b) => a - b);
+    return {
+      boxDecorationBreak:
+        chipStyle.getPropertyValue("box-decoration-break") ||
+        chipStyle.getPropertyValue("-webkit-box-decoration-break"),
+      fragmentStep:
+        fragmentTops.length > 1 ? fragmentTops[1] - fragmentTops[0] : null,
+      lineHeight: Number.parseFloat(chipStyle.lineHeight),
+      rects,
+    };
+  });
+  expect(fragmentMetrics.boxDecorationBreak).toBe("clone");
+  expect(fragmentMetrics.lineHeight).toBe(22);
+  expect(fragmentMetrics.fragmentStep).toBe(22);
+  expect(fragmentMetrics.rects.length).toBeGreaterThanOrEqual(2);
 
   const tooltip = page.getByRole("tooltip");
   await sentChip.focus();

From 813bbd14121edacc6cb4733301a3af12131aa10e Mon Sep 17 00:00:00 2001
From: Salman Mohammed <smohammed@squareup.com>
Date: Thu, 10 Sep 2026 21:38:42 -0400
Subject: [PATCH 14/19] fix(acp): integrate the Buzz Pi adapter fork (#7552)

## Summary

PR #7335 worked around missing Pi adapter support by generating a
private Pi launcher and injecting Buzz's standing prompt and skills at
process launch. The Buzz Pi fork now carries the required adapter
extensions, so this removes that launcher and returns prompt
construction to the normal ACP session path while retaining the
base-prompt composition introduced by #7335.

The Pi preset now installs `salman1993/pi-acp` and launches its renamed
`buzz-pi-acp` binary. Buzz adds `-- --skill
<harness-cwd>/.agents/skills` only when launching that binary, sends the
complete composed prompt as the `_meta.systemPrompt` replacement string
on `session/new` only when `initialize.agentInfo.name` is `buzz-pi-acp`,
and sends the scoped title alongside it as `_meta.sessionTitle`. The
fork identity is treated as system-prompt capable regardless of its
reported ACP protocol version, which prevents duplicate legacy
user-message framing. Upstream `pi-acp` does not receive either
fork-specific behavior. Observer transcript projection accepts the
string, `{ replace }`, and `{ append }` metadata forms.

The fork now stores restore metadata in one atomic file per session
under `~/.pi/buzz-pi-acp/sessions/`. This prevents concurrent Buzz
workers from overwriting another session's prompt or title. The fix
landed in
[salman1993/pi-acp#9](https://github.com/salman1993/pi-acp/pull/9).

This supersedes the closed #7508. No agent-configuration rules changed;
this changes the Buzz Pi adapter contract and launch arguments.

### Related issue

#7329

### Testing

Installed fork commit `09cf07e436b8f18e52401558f988f31a15702313` through
the documented Git URL. The installed bundle matched the committed
`dist/index.js` byte for byte and contained the `~/.pi/buzz-pi-acp`
metadata path. The fork's 106 non-skipped tests, typecheck, and lint
pass.

Ran the ignored real-Pi integration test through Buzz's production
session composer. The test exercised the renamed package,
`agentInfo.name`, and the new per-session metadata store. Base, persona,
team, core-memory, huddle, canvas, and skill markers each appeared once
after switching sessions and again after restarting the adapter, while
the other session and Pi's native default prompt were absent.

Added regression coverage proving `buzz-pi-acp` receives fork-specific
system-prompt metadata and managed skills while upstream `pi-acp` does
not. `just ci` passes.

Generated with Codex

---------

Signed-off-by: Salman Mohammed <smohammed@squareup.com>
---
 crates/buzz-acp/TESTING.md                    |  58 +++
 crates/buzz-acp/src/acp.rs                    | 153 ++-----
 .../buzz-acp/src/acp/system_prompt_tests.rs   | 154 +++++++
 crates/buzz-acp/src/lib.rs                    |  65 +--
 crates/buzz-acp/src/pi_launcher.rs            | 380 ------------------
 crates/buzz-acp/src/pool.rs                   |  65 +--
 crates/buzz-acp/src/pool/pi_prompt_tests.rs   | 371 +++++++++++++++++
 .../buzz-acp/src/pool/system_prompt_tests.rs  |  78 ++++
 .../src/managed_agents/discovery/presets.rs   |  26 +-
 .../src/managed_agents/env_vars/tests.rs      |   8 -
 .../src/managed_agents/reserved_env_keys.rs   |   3 -
 .../agents/ui/agentSessionTranscript.ts       |  13 +-
 .../ui/agentSessionTranscriptPi.test.mjs      |  71 ++++
 .../settings/ui/harnessCatalogCopy.test.mjs   |   2 +-
 .../settings/ui/harnessCatalogCopy.ts         |   4 +-
 15 files changed, 812 insertions(+), 639 deletions(-)
 create mode 100644 crates/buzz-acp/TESTING.md
 create mode 100644 crates/buzz-acp/src/acp/system_prompt_tests.rs
 delete mode 100644 crates/buzz-acp/src/pi_launcher.rs
 create mode 100644 crates/buzz-acp/src/pool/pi_prompt_tests.rs
 create mode 100644 crates/buzz-acp/src/pool/system_prompt_tests.rs
 create mode 100644 desktop/src/features/agents/ui/agentSessionTranscriptPi.test.mjs

diff --git a/crates/buzz-acp/TESTING.md b/crates/buzz-acp/TESTING.md
new file mode 100644
index 00000000000..8c8fcbee49a
--- /dev/null
+++ b/crates/buzz-acp/TESTING.md
@@ -0,0 +1,58 @@
+# Pi adapter integration
+
+Buzz's Pi preset uses [salman1993/pi-acp](https://github.com/salman1993/pi-acp).
+Requires Node.js 22 or newer. Install Pi and configure its model provider,
+then install the adapter directly from the fork:
+
+```sh
+npm install -g @earendil-works/pi-coding-agent
+pi
+npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main
+```
+
+Restart Buzz, then select **Pi** as the agent harness. Buzz starts `buzz-pi-acp`
+automatically. Run the same adapter install command again to update it.
+The unscoped `npm install -g pi-acp` command installs the upstream package,
+without these extensions. Use fresh sessions to replace old user-framed
+standing instructions.
+
+Buzz adds `-- --skill <harness-cwd>/.agents/skills` when launching `buzz-pi-acp`.
+An existing separator and explicit Pi options are preserved. Managed agents
+run from the Buzz nest (normally `~/.buzz`): Desktop sets the `buzz-acp` child
+CWD through `default_agent_workdir()`, and adapters inherit it. The default
+skill directory is that launch workspace's `.agents/skills`. Standalone CLI
+launches use the caller's working directory.
+The path is fixed at adapter launch and applies to every Pi subprocess.
+
+The full composed session prompt is sent as a replacement string through the
+provisional `session/new.params._meta.systemPrompt` field. Buzz recognizes
+`buzz-pi-acp` by the agent name returned during initialization, regardless of
+protocol version. Upstream `pi-acp` does not receive this fork-specific metadata.
+No custom capability negotiation or legacy Pi prompt fallback is used.
+Session titles continue to use `_meta.sessionTitle`.
+
+## Validation
+
+Activate Hermit from the Buzz repository root, then run the package tests:
+
+```sh
+. ./bin/activate-hermit
+cargo test -p buzz-acp
+```
+
+To exercise the real adapter through Buzz's production session composer:
+
+```sh
+BUZZ_TEST_PI_ACP=/absolute/pi-acp/dist/index.js \
+  cargo test -p buzz-acp real_pi_preserves -- --ignored
+```
+
+This test requires Node and Pi on PATH. It isolates HOME and Pi settings,
+disables extensions and context files, and uses a synthetic transcript without
+model calls. It inspects Pi's effective prompt through RPC HTML export after
+switching sessions and restarting the adapter. Base, persona, team, core memory,
+huddle, canvas, and the extra skill must each appear once, without another
+session's instructions or Pi's default coding preamble.
+
+HTML export reports the exporting process's current system prompt. It cannot
+recover a historical prompt from an old transcript alone.
diff --git a/crates/buzz-acp/src/acp.rs b/crates/buzz-acp/src/acp.rs
index 0d87bca028c..cd049830688 100644
--- a/crates/buzz-acp/src/acp.rs
+++ b/crates/buzz-acp/src/acp.rs
@@ -22,6 +22,9 @@ use crate::usage::{
 /// Lines exceeding this limit are rejected to prevent OOM from rogue agents.
 const MAX_LINE_SIZE: usize = 10_000_000; // 10 MB
 
+/// Package and binary name used by Buzz's Pi ACP fork.
+pub(crate) const BUZZ_PI_ACP_NAME: &str = "buzz-pi-acp";
+
 /// An MCP server configuration passed to `session/new`.
 ///
 /// Corresponds to the `McpServerStdio` variant in the ACP schema.
@@ -460,8 +463,17 @@ impl AcpClient {
         use std::process::Stdio;
 
         let mut cmd = tokio::process::Command::new(command);
-        cmd.args(args)
-            .stdin(Stdio::piped())
+        cmd.args(args);
+        if crate::config::normalize_agent_command_identity(command) == BUZZ_PI_ACP_NAME {
+            if !args.iter().any(|arg| arg == "--") {
+                cmd.arg("--");
+            }
+            // Desktop launches buzz-acp in the Buzz nest; adapters inherit that
+            // workspace. Keep managed skills tied to launch CWD across sessions.
+            cmd.arg("--skill")
+                .arg(std::env::current_dir()?.join(".agents/skills"));
+        }
+        cmd.stdin(Stdio::piped())
             .stdout(Stdio::piped())
             // Inherit stderr so agent logs are visible in the harness terminal.
             .stderr(Stdio::inherit())
@@ -637,14 +649,16 @@ impl AcpClient {
     ///
     /// - `None` — no system-prompt field in the request (legacy framing).
     /// - `Some(SystemPromptTransport::Field(text))` — bare `systemPrompt` field
-    ///   (ACP protocol v2, buzz-agent, goose unused).
+    ///   (ACP protocol v2, buzz-agent; goose unused).
+    /// - `Some(SystemPromptTransport::PiMeta(text))` — `_meta.systemPrompt`
+    ///   as a replacement string for the Buzz pi-acp fork.
     /// - `Some(SystemPromptTransport::ClaudeMeta(text))` — `_meta.systemPrompt`
     ///   as `{"append": text}`, keeping claude-agent-acp's native preset intact.
     ///
     /// `session_title` rides in `_meta.sessionTitle` when `Some`; `_meta` is
     /// omitted entirely otherwise, since adapters may distinguish an absent
-    /// member from a null one. When both `ClaudeMeta` and `session_title` are
-    /// present the two `_meta` members are merged into a single object.
+    /// member from a null one. Metadata prompt transports and the title are
+    /// merged into a single object.
     ///
     /// Callers use [`extract_model_config_options`] and [`extract_model_state`]
     /// to pull model info from the raw result.
@@ -663,6 +677,9 @@ impl AcpClient {
             Some(SystemPromptTransport::Field(sp)) => {
                 params["systemPrompt"] = serde_json::Value::String(sp.to_owned());
             }
+            Some(SystemPromptTransport::PiMeta(sp)) => {
+                params["_meta"]["systemPrompt"] = serde_json::Value::String(sp.to_owned());
+            }
             Some(SystemPromptTransport::ClaudeMeta(sp)) => {
                 // Merge into _meta so sessionTitle (set below) is not clobbered.
                 params["_meta"]["systemPrompt"] = serde_json::json!({ "append": sp });
@@ -670,7 +687,7 @@ impl AcpClient {
             None => {}
         }
         if let Some(title) = session_title {
-            // Merge — _meta may already carry systemPrompt from ClaudeMeta above.
+            // Merge — _meta may already carry a system prompt from an adapter extension.
             params["_meta"]["sessionTitle"] = serde_json::Value::String(title.to_owned());
         }
         let result = self.send_request("session/new", params).await?;
@@ -2131,9 +2148,9 @@ pub struct SessionNewResponse {
 
 /// How to deliver a system prompt on `session/new`.
 ///
-/// The two variants match the two mechanisms supported by current adapters:
-///
 /// - **`Field`** — bare `systemPrompt` field (ACP protocol v2, buzz-agent).
+/// - **`PiMeta`** — `_meta.systemPrompt: text`, used by the Buzz pi-acp fork
+///   to replace Pi's native system prompt.
 /// - **`ClaudeMeta`** — `_meta.systemPrompt: {"append": text}`, used by
 ///   `claude-agent-acp` to append to the adapter's own native system prompt
 ///   while keeping its tool-use preset intact.
@@ -2141,6 +2158,8 @@ pub struct SessionNewResponse {
 pub enum SystemPromptTransport<'a> {
     /// Deliver as a bare top-level `systemPrompt` field.
     Field(&'a str),
+    /// Deliver as `_meta.systemPrompt: text`.
+    PiMeta(&'a str),
     /// Deliver as `_meta.systemPrompt: {"append": text}`.
     ClaudeMeta(&'a str),
 }
@@ -3631,123 +3650,7 @@ mod tests {
 
     // ── claude-agent-acp _meta.systemPrompt transport ─────────────────────
 
-    #[tokio::test]
-    async fn session_new_full_sends_claude_meta_system_prompt_when_claude_meta_transport() {
-        // When ClaudeMeta transport is requested, the prompt must appear as
-        // _meta.systemPrompt: {"append": text} — never as a bare systemPrompt field.
-        let script = r#"
-            read -t 2 _init
-            echo '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":1,"agentCapabilities":{}}}'
-            read -t 2 REQ
-            echo '{"jsonrpc":"2.0","id":1,"result":{"sessionId":"ses_claude","_receivedRequest":'"$REQ"'}}'
-            sleep 1
-        "#;
-        let mut client = spawn_script(script).await;
-        client
-            .initialize()
-            .await
-            .expect("initialize should succeed");
-
-        let resp = client
-            .session_new_full(
-                "/tmp",
-                vec![],
-                Some(SystemPromptTransport::ClaudeMeta("Be concise")),
-                None,
-            )
-            .await
-            .expect("session_new_full should succeed");
-
-        let received = &resp.raw["_receivedRequest"];
-        assert!(
-            received["params"].get("systemPrompt").is_none(),
-            "bare systemPrompt must not be present for ClaudeMeta transport"
-        );
-        assert_eq!(
-            received["params"]["_meta"]["systemPrompt"]["append"].as_str(),
-            Some("Be concise"),
-            "_meta.systemPrompt.append must carry the prompt text"
-        );
-    }
-
-    #[tokio::test]
-    async fn session_new_full_merges_claude_meta_and_session_title_into_single_meta_object() {
-        // Both ClaudeMeta prompt and session_title must coexist under _meta —
-        // the prompt must not clobber sessionTitle or vice versa.
-        let script = r#"
-            read -t 2 _init
-            echo '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":1,"agentCapabilities":{}}}'
-            read -t 2 REQ
-            echo '{"jsonrpc":"2.0","id":1,"result":{"sessionId":"ses_merged","_receivedRequest":'"$REQ"'}}'
-            sleep 1
-        "#;
-        let mut client = spawn_script(script).await;
-        client
-            .initialize()
-            .await
-            .expect("initialize should succeed");
-
-        let resp = client
-            .session_new_full(
-                "/tmp",
-                vec![],
-                Some(SystemPromptTransport::ClaudeMeta("Be concise")),
-                Some("Fizz · #buzz-dev"),
-            )
-            .await
-            .expect("session_new_full should succeed");
-
-        let received = &resp.raw["_receivedRequest"];
-        assert_eq!(
-            received["params"]["_meta"]["systemPrompt"]["append"].as_str(),
-            Some("Be concise"),
-            "_meta.systemPrompt.append must be present"
-        );
-        assert_eq!(
-            received["params"]["_meta"]["sessionTitle"].as_str(),
-            Some("Fizz · #buzz-dev"),
-            "_meta.sessionTitle must be present alongside systemPrompt"
-        );
-    }
-
-    // ── Goose-native steer scaffold (PR follow-up to #1160) ──────────────
-
-    /// Helper: spawn an inert `cat` subprocess so we have a real AcpClient
-    /// to drive `handle_session_update` against. `cat` never writes back,
-    /// which is fine — these tests don't read from the agent, they just
-    /// feed JSON into the parser.
-    async fn spawn_inert_client() -> AcpClient {
-        AcpClient::spawn("cat", &[], &[], false)
-            .await
-            .expect("spawn cat as inert client")
-    }
-
-    /// Build a `session/update` JSON-RPC notification carrying a
-    /// `session_info_update` with the given `_meta.goose.activeRunId` value.
-    /// Pass `None` to omit the `activeRunId` field entirely.
-    ///
-    /// `_meta` is nested inside the `update` object (per the ACP
-    /// `SessionInfoUpdate` schema), matching what goose and buzz-agent
-    /// emit on the wire.
-    fn session_info_update_msg(active_run_id: Option<serde_json::Value>) -> serde_json::Value {
-        let mut goose = serde_json::Map::new();
-        if let Some(v) = active_run_id {
-            goose.insert("activeRunId".to_string(), v);
-        }
-        let mut meta = serde_json::Map::new();
-        meta.insert("goose".to_string(), serde_json::Value::Object(goose));
-        serde_json::json!({
-            "jsonrpc": "2.0",
-            "method": "session/update",
-            "params": {
-                "sessionId": "test-session",
-                "update": {
-                    "sessionUpdate": "session_info_update",
-                    "_meta": serde_json::Value::Object(meta),
-                },
-            }
-        })
-    }
+    include!("acp/system_prompt_tests.rs");
 
     #[tokio::test]
     async fn active_run_id_sets_on_string() {
diff --git a/crates/buzz-acp/src/acp/system_prompt_tests.rs b/crates/buzz-acp/src/acp/system_prompt_tests.rs
new file mode 100644
index 00000000000..b90893e8f50
--- /dev/null
+++ b/crates/buzz-acp/src/acp/system_prompt_tests.rs
@@ -0,0 +1,154 @@
+#[tokio::test]
+async fn session_new_full_sends_pi_replacement_prompt_in_meta() {
+    let script = r#"
+            read -t 2 _init
+            echo '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":1,"agentCapabilities":{}}}'
+            read -t 2 REQ
+            echo '{"jsonrpc":"2.0","id":1,"result":{"sessionId":"ses_pi","_receivedRequest":'"$REQ"'}}'
+            sleep 1
+        "#;
+    let mut client = spawn_script(script).await;
+    client
+        .initialize()
+        .await
+        .expect("initialize should succeed");
+
+    let resp = client
+        .session_new_full(
+            "/tmp",
+            vec![],
+            Some(SystemPromptTransport::PiMeta("Buzz instructions")),
+            Some("Pi · #buzz-dev"),
+        )
+        .await
+        .expect("session_new_full should succeed");
+
+    let received = &resp.raw["_receivedRequest"];
+    assert!(received["params"].get("systemPrompt").is_none());
+    assert_eq!(
+        received["params"]["_meta"]["systemPrompt"].as_str(),
+        Some("Buzz instructions")
+    );
+    assert_eq!(
+        received["params"]["_meta"]["sessionTitle"].as_str(),
+        Some("Pi · #buzz-dev")
+    );
+}
+
+#[tokio::test]
+async fn session_new_full_sends_claude_meta_system_prompt_when_claude_meta_transport() {
+    // When ClaudeMeta transport is requested, the prompt must appear as
+    // _meta.systemPrompt: {"append": text} — never as a bare systemPrompt field.
+    let script = r#"
+            read -t 2 _init
+            echo '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":1,"agentCapabilities":{}}}'
+            read -t 2 REQ
+            echo '{"jsonrpc":"2.0","id":1,"result":{"sessionId":"ses_claude","_receivedRequest":'"$REQ"'}}'
+            sleep 1
+        "#;
+    let mut client = spawn_script(script).await;
+    client
+        .initialize()
+        .await
+        .expect("initialize should succeed");
+
+    let resp = client
+        .session_new_full(
+            "/tmp",
+            vec![],
+            Some(SystemPromptTransport::ClaudeMeta("Be concise")),
+            None,
+        )
+        .await
+        .expect("session_new_full should succeed");
+
+    let received = &resp.raw["_receivedRequest"];
+    assert!(
+        received["params"].get("systemPrompt").is_none(),
+        "bare systemPrompt must not be present for ClaudeMeta transport"
+    );
+    assert_eq!(
+        received["params"]["_meta"]["systemPrompt"]["append"].as_str(),
+        Some("Be concise"),
+        "_meta.systemPrompt.append must carry the prompt text"
+    );
+}
+
+#[tokio::test]
+async fn session_new_full_merges_claude_meta_and_session_title_into_single_meta_object() {
+    // Both ClaudeMeta prompt and session_title must coexist under _meta —
+    // the prompt must not clobber sessionTitle or vice versa.
+    let script = r#"
+            read -t 2 _init
+            echo '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":1,"agentCapabilities":{}}}'
+            read -t 2 REQ
+            echo '{"jsonrpc":"2.0","id":1,"result":{"sessionId":"ses_merged","_receivedRequest":'"$REQ"'}}'
+            sleep 1
+        "#;
+    let mut client = spawn_script(script).await;
+    client
+        .initialize()
+        .await
+        .expect("initialize should succeed");
+
+    let resp = client
+        .session_new_full(
+            "/tmp",
+            vec![],
+            Some(SystemPromptTransport::ClaudeMeta("Be concise")),
+            Some("Fizz · #buzz-dev"),
+        )
+        .await
+        .expect("session_new_full should succeed");
+
+    let received = &resp.raw["_receivedRequest"];
+    assert_eq!(
+        received["params"]["_meta"]["systemPrompt"]["append"].as_str(),
+        Some("Be concise"),
+        "_meta.systemPrompt.append must be present"
+    );
+    assert_eq!(
+        received["params"]["_meta"]["sessionTitle"].as_str(),
+        Some("Fizz · #buzz-dev"),
+        "_meta.sessionTitle must be present alongside systemPrompt"
+    );
+}
+
+// ── Goose-native steer scaffold (PR follow-up to #1160) ──────────────
+
+/// Helper: spawn an inert `cat` subprocess so we have a real AcpClient
+/// to drive `handle_session_update` against. `cat` never writes back,
+/// which is fine — these tests don't read from the agent, they just
+/// feed JSON into the parser.
+async fn spawn_inert_client() -> AcpClient {
+    AcpClient::spawn("cat", &[], &[], false)
+        .await
+        .expect("spawn cat as inert client")
+}
+
+/// Build a `session/update` JSON-RPC notification carrying a
+/// `session_info_update` with the given `_meta.goose.activeRunId` value.
+/// Pass `None` to omit the `activeRunId` field entirely.
+///
+/// `_meta` is nested inside the `update` object (per the ACP
+/// `SessionInfoUpdate` schema), matching what goose and buzz-agent
+/// emit on the wire.
+fn session_info_update_msg(active_run_id: Option<serde_json::Value>) -> serde_json::Value {
+    let mut goose = serde_json::Map::new();
+    if let Some(v) = active_run_id {
+        goose.insert("activeRunId".to_string(), v);
+    }
+    let mut meta = serde_json::Map::new();
+    meta.insert("goose".to_string(), serde_json::Value::Object(goose));
+    serde_json::json!({
+        "jsonrpc": "2.0",
+        "method": "session/update",
+        "params": {
+            "sessionId": "test-session",
+            "update": {
+                "sessionUpdate": "session_info_update",
+                "_meta": serde_json::Value::Object(meta),
+            },
+        }
+    })
+}
diff --git a/crates/buzz-acp/src/lib.rs b/crates/buzz-acp/src/lib.rs
index ab7233d4930..6c272187f3c 100644
--- a/crates/buzz-acp/src/lib.rs
+++ b/crates/buzz-acp/src/lib.rs
@@ -5,7 +5,6 @@ mod config;
 mod engram_fetch;
 mod filter;
 mod observer;
-mod pi_launcher;
 mod pool;
 mod pool_lifecycle;
 mod prompt_framing;
@@ -2511,49 +2510,6 @@ async fn tokio_main() -> Result<()> {
 
     tracing::info!("buzz-acp starting: {}", config.summary());
 
-    let cwd = current_working_directory()?;
-    let base_prompt_content = config.base_prompt_content.take();
-    let base_prompt = if config.no_base_prompt {
-        None
-    } else {
-        // Build standing context once under the configured policy, before any
-        // agent process starts. Pi consumes this through its native
-        // `--system-prompt`; other ACP agents consume the same bytes through
-        // session/new or legacy first-turn framing.
-        Some(
-            config.session_policy.append_session_model(
-                base_prompt_content
-                    .as_deref()
-                    .unwrap_or(include_str!("base_prompt.md")),
-            ),
-        )
-    };
-    // PI_ACP_PI_COMMAND is Buzz-owned. Strip stale/user-provided copies from
-    // every adapter before optionally installing Buzz's generated Pi launcher.
-    config
-        .persona_env_vars
-        .retain(|(key, _)| !key.eq_ignore_ascii_case(pi_launcher::PI_ACP_PI_COMMAND_ENV));
-    let managed_skills_dir = std::path::Path::new(&cwd).join(".agents/skills");
-    let inherited_pi_command_is_set =
-        std::env::var_os(pi_launcher::PI_ACP_PI_COMMAND_ENV).is_some();
-    let (pi_launch_override, base_prompt) = pi_launcher::PiLaunchOverride::prepare(
-        &config.agent_command,
-        base_prompt,
-        &managed_skills_dir,
-        inherited_pi_command_is_set,
-    )
-    .context("failed to prepare Pi launch overrides")?;
-    if let Some(prepared) = pi_launch_override.as_ref() {
-        config.persona_env_vars.push((
-            pi_launcher::PI_ACP_PI_COMMAND_ENV.to_string(),
-            prepared.launcher_path().to_string_lossy().into_owned(),
-        ));
-        tracing::info!(
-            skills_dir = %managed_skills_dir.display(),
-            "configured Pi to consume Buzz standing context and managed skills through native CLI flags"
-        );
-    }
-
     let observer = config
         .relay_observer
         .then(observer::ObserverHandle::in_process);
@@ -2802,6 +2758,8 @@ async fn tokio_main() -> Result<()> {
         );
     }
 
+    let base_prompt_content = config.base_prompt_content.take();
+    let cwd = current_working_directory()?;
     let ctx = Arc::new(PromptContext {
         mcp_servers: build_mcp_servers(&config),
         initial_message: config.initial_message.clone(),
@@ -2812,7 +2770,20 @@ async fn tokio_main() -> Result<()> {
         system_prompt: config.system_prompt.clone(),
         session_title: config.session_title.clone(),
         team_instructions: config.team_instructions.clone(),
-        base_prompt,
+        base_prompt: if config.no_base_prompt {
+            None
+        } else {
+            // Build standing context once under the configured policy, before
+            // any session/new. Both modern ACP and legacy first-turn framing
+            // consume this same assembled base (including custom base files).
+            Some(
+                config.session_policy.append_session_model(
+                    base_prompt_content
+                        .as_deref()
+                        .unwrap_or(include_str!("base_prompt.md")),
+                ),
+            )
+        },
         heartbeat_prompt: config.heartbeat_prompt.clone(),
         cwd,
         rest_client: relay.rest_client(),
@@ -4166,10 +4137,6 @@ async fn tokio_main() -> Result<()> {
     // for the background task to finish, rather than aborting immediately (#40).
     relay.shutdown().await;
 
-    // Pi may restore subprocesses throughout the pool lifetime. Remove its
-    // private prompt and launcher only after every adapter has shut down.
-    drop(pi_launch_override);
-
     tracing::info!("buzz-acp stopped");
     Ok(())
 }
diff --git a/crates/buzz-acp/src/pi_launcher.rs b/crates/buzz-acp/src/pi_launcher.rs
deleted file mode 100644
index 892500bb200..00000000000
--- a/crates/buzz-acp/src/pi_launcher.rs
+++ /dev/null
@@ -1,380 +0,0 @@
-//! Pi-specific native launcher setup.
-//!
-//! `pi-acp` does not currently consume ACP `session/new.systemPrompt`, but it
-//! does let callers replace the `pi` executable through
-//! `PI_ACP_PI_COMMAND`. For Pi sessions, Buzz points that variable at a
-//! private launcher which adds `--system-prompt <file>` and the canonical Buzz
-//! `--skill <directory>` before forwarding the adapter's RPC/session arguments
-//! unchanged.
-
-use std::fs::{self, OpenOptions};
-use std::io::{self, Write};
-use std::path::{Path, PathBuf};
-
-#[cfg(unix)]
-use std::ffi::OsStr;
-
-use uuid::Uuid;
-
-pub(crate) const PI_ACP_PI_COMMAND_ENV: &str = "PI_ACP_PI_COMMAND";
-
-/// Files backing the Pi launcher for one `buzz-acp` process.
-///
-/// The guard must live as long as the ACP pool because `pi-acp` may start or
-/// restore Pi subprocesses after its own initialization.
-pub(crate) struct PiLaunchOverride {
-    directory: PathBuf,
-    launcher: PathBuf,
-}
-
-impl PiLaunchOverride {
-    /// Prepare a Pi launcher when the configured ACP adapter is `pi-acp`.
-    ///
-    /// Returns the prompt that still needs ordinary ACP delivery. For Pi, the
-    /// base prompt moves into Pi's native system role and is therefore removed
-    /// from first-turn user framing. Other adapters receive it unchanged.
-    pub(crate) fn prepare(
-        agent_command: &str,
-        base_prompt: Option<String>,
-        managed_skills_dir: &Path,
-        inherited_pi_command_is_set: bool,
-    ) -> io::Result<(Option<Self>, Option<String>)> {
-        if crate::config::normalize_agent_command_identity(agent_command) != "pi-acp" {
-            return Ok((None, base_prompt));
-        }
-
-        if inherited_pi_command_is_set {
-            return Err(io::Error::new(
-                io::ErrorKind::AlreadyExists,
-                "PI_ACP_PI_COMMAND is managed by Buzz; unset it before starting a managed Pi agent",
-            ));
-        }
-
-        // Buzz owns PI_ACP_PI_COMMAND and always uses it to point pi-acp at
-        // this generated launcher. The launcher resolves the ordinary `pi`
-        // command from Buzz's effective PATH.
-        let prepared = Self::create("pi", base_prompt.as_deref(), managed_skills_dir)?;
-        Ok((Some(prepared), None))
-    }
-
-    pub(crate) fn launcher_path(&self) -> &Path {
-        &self.launcher
-    }
-
-    fn create(
-        pi_command: &str,
-        prompt: Option<&str>,
-        managed_skills_dir: &Path,
-    ) -> io::Result<Self> {
-        let directory = std::env::temp_dir().join(format!(
-            "buzz-acp-pi-launcher-{}-{}",
-            std::process::id(),
-            Uuid::new_v4()
-        ));
-        create_private_directory(&directory)?;
-
-        let prompt_path = directory.join("SYSTEM.md");
-        let launcher = directory.join(launcher_file_name());
-        // Construct the cleanup guard before either file write. Any later `?`
-        // drops it, so a partial setup cannot strand the private prompt file.
-        let prepared = Self {
-            directory,
-            launcher,
-        };
-
-        if let Some(prompt) = prompt {
-            write_private_file(&prompt_path, prompt.as_bytes(), false)?;
-        }
-
-        let script = launcher_script(
-            pi_command,
-            prompt.map(|_| prompt_path.as_path()),
-            managed_skills_dir,
-        )?;
-        write_private_file(&prepared.launcher, script.as_bytes(), true)?;
-
-        Ok(prepared)
-    }
-}
-
-impl Drop for PiLaunchOverride {
-    fn drop(&mut self) {
-        if let Err(error) = fs::remove_dir_all(&self.directory) {
-            if error.kind() != io::ErrorKind::NotFound {
-                tracing::warn!(
-                    path = %self.directory.display(),
-                    %error,
-                    "failed to remove temporary Pi launcher"
-                );
-            }
-        }
-    }
-}
-
-#[cfg(unix)]
-fn create_private_directory(path: &Path) -> io::Result<()> {
-    use std::os::unix::fs::DirBuilderExt;
-
-    let mut builder = fs::DirBuilder::new();
-    builder.mode(0o700).create(path)
-}
-
-#[cfg(not(unix))]
-fn create_private_directory(path: &Path) -> io::Result<()> {
-    fs::create_dir(path)
-}
-
-fn write_private_file(path: &Path, content: &[u8], executable: bool) -> io::Result<()> {
-    let mut options = OpenOptions::new();
-    options.write(true).create_new(true);
-
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::OpenOptionsExt;
-        options.mode(if executable { 0o700 } else { 0o600 });
-    }
-
-    #[cfg(not(unix))]
-    let _ = executable;
-
-    let mut file = options.open(path)?;
-    file.write_all(content)?;
-    file.sync_all()
-}
-
-#[cfg(unix)]
-fn launcher_file_name() -> &'static str {
-    "pi-with-buzz-context"
-}
-
-#[cfg(windows)]
-fn launcher_file_name() -> &'static str {
-    "pi-with-buzz-context.cmd"
-}
-
-#[cfg(not(any(unix, windows)))]
-fn launcher_file_name() -> &'static str {
-    "pi-with-buzz-context"
-}
-
-#[cfg(unix)]
-fn launcher_script(
-    pi_command: &str,
-    prompt_path: Option<&Path>,
-    managed_skills_dir: &Path,
-) -> io::Result<String> {
-    let system_prompt_arg = match prompt_path {
-        Some(prompt_path) => format!(" --system-prompt {}", shell_quote(prompt_path.as_os_str())?),
-        None => String::new(),
-    };
-    Ok(format!(
-        "#!/bin/sh\nexec {}{} --skill {} \"$@\"\n",
-        shell_quote(OsStr::new(pi_command))?,
-        system_prompt_arg,
-        shell_quote(managed_skills_dir.as_os_str())?,
-    ))
-}
-
-#[cfg(unix)]
-fn shell_quote(value: &OsStr) -> io::Result<String> {
-    let value = value.to_str().ok_or_else(|| {
-        io::Error::new(
-            io::ErrorKind::InvalidData,
-            "Pi launcher paths must be valid UTF-8",
-        )
-    })?;
-    Ok(format!("'{}'", value.replace('\'', "'\"'\"'")))
-}
-
-#[cfg(windows)]
-fn launcher_script(
-    pi_command: &str,
-    prompt_path: Option<&Path>,
-    managed_skills_dir: &Path,
-) -> io::Result<String> {
-    let system_prompt_arg = match prompt_path {
-        Some(prompt_path) => {
-            let prompt_path = prompt_path.to_str().ok_or_else(|| {
-                io::Error::new(
-                    io::ErrorKind::InvalidData,
-                    "Pi launcher paths must be valid UTF-8",
-                )
-            })?;
-            format!(" --system-prompt \"{}\"", batch_escape(prompt_path))
-        }
-        None => String::new(),
-    };
-    let managed_skills_dir = managed_skills_dir.to_str().ok_or_else(|| {
-        io::Error::new(
-            io::ErrorKind::InvalidData,
-            "Pi skill paths must be valid UTF-8",
-        )
-    })?;
-    Ok(format!(
-        "@echo off\r\n\"{}\"{} --skill \"{}\" %*\r\nexit /b %ERRORLEVEL%\r\n",
-        batch_escape(pi_command),
-        system_prompt_arg,
-        batch_escape(managed_skills_dir),
-    ))
-}
-
-#[cfg(windows)]
-fn batch_escape(value: &str) -> String {
-    value.replace('%', "%%").replace('"', "\"\"")
-}
-
-#[cfg(not(any(unix, windows)))]
-fn launcher_script(
-    _pi_command: &str,
-    _prompt_path: Option<&Path>,
-    _managed_skills_dir: &Path,
-) -> io::Result<String> {
-    Err(io::Error::new(
-        io::ErrorKind::Unsupported,
-        "Pi launch overrides are unsupported on this platform",
-    ))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn non_pi_adapter_keeps_base_prompt_for_acp_delivery() {
-        let base = Some("Buzz base".to_string());
-        let (prepared, remaining) =
-            PiLaunchOverride::prepare("goose", base.clone(), Path::new("/unused/skills"), true)
-                .expect("prepare");
-        assert!(prepared.is_none());
-        assert_eq!(remaining, base);
-    }
-
-    #[test]
-    fn pi_adapter_rejects_inherited_pi_command() {
-        let error = PiLaunchOverride::prepare(
-            "pi-acp",
-            Some("Buzz base".to_string()),
-            Path::new("/unused/skills"),
-            true,
-        )
-        .err()
-        .expect("inherited PI_ACP_PI_COMMAND must be rejected");
-
-        assert_eq!(error.kind(), io::ErrorKind::AlreadyExists);
-        assert!(error.to_string().contains("managed by Buzz"));
-    }
-
-    #[test]
-    fn disabled_base_prompt_still_creates_pi_skills_launcher() {
-        let (prepared, remaining) =
-            PiLaunchOverride::prepare("pi-acp", None, Path::new("/unused/skills"), false)
-                .expect("prepare");
-        let prepared = prepared.expect("Pi skills launcher");
-        assert!(remaining.is_none());
-        assert!(!prepared.directory.join("SYSTEM.md").exists());
-
-        #[cfg(unix)]
-        assert!(fs::read_to_string(prepared.launcher_path())
-            .expect("read launcher")
-            .contains("--skill '/unused/skills'"));
-    }
-
-    #[test]
-    fn pi_adapter_moves_buzz_base_out_of_ordinary_acp_delivery() {
-        let base = crate::scope::SessionPolicy::Thread
-            .append_session_model(include_str!("base_prompt.md"));
-        let (prepared, remaining) = PiLaunchOverride::prepare(
-            "/opt/bin/pi-acp",
-            Some(base.clone()),
-            Path::new("/buzz/.agents/skills"),
-            false,
-        )
-        .expect("prepare");
-        let prepared = prepared.expect("Pi launcher");
-
-        assert!(remaining.is_none());
-        assert_eq!(
-            fs::read_to_string(prepared.directory.join("SYSTEM.md")).expect("read prompt"),
-            base
-        );
-        assert!(base.contains("each thread gets its own"));
-
-        #[cfg(unix)]
-        assert!(fs::read_to_string(prepared.launcher_path())
-            .expect("read launcher")
-            .contains("exec 'pi'"));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn pi_launcher_replaces_system_prompt_and_forwards_adapter_args() {
-        use std::os::unix::fs::PermissionsExt;
-        use std::process::Command;
-
-        let fixture_dir =
-            std::env::temp_dir().join(format!("buzz-acp-pi-system-prompt-test-{}", Uuid::new_v4()));
-        create_private_directory(&fixture_dir).expect("create fixture dir");
-        let capture_path = fixture_dir.join("args.txt");
-        let fake_pi = fixture_dir.join("fake-pi");
-        let managed_skills_dir = fixture_dir.join("managed skills");
-        let fake_script = format!(
-            "#!/bin/sh\nprintf '%s\\n' \"$@\" > {}\n",
-            shell_quote(capture_path.as_os_str()).expect("quote capture path")
-        );
-        write_private_file(&fake_pi, fake_script.as_bytes(), true).expect("write fake pi");
-
-        let prepared = PiLaunchOverride::create(
-            fake_pi.to_str().expect("UTF-8 fake Pi path"),
-            Some("Buzz base\n\n## Session Model\nThread scoped"),
-            &managed_skills_dir,
-        )
-        .expect("prepare Pi launcher");
-        let prompt_path = prepared.directory.join("SYSTEM.md");
-
-        let status = Command::new(prepared.launcher_path())
-            .args(["--mode", "rpc", "--session", "/tmp/session.jsonl"])
-            .status()
-            .expect("run launcher");
-        assert!(status.success());
-        assert_eq!(
-            fs::read_to_string(&capture_path).expect("read captured args"),
-            format!(
-                "--system-prompt\n{}\n--skill\n{}\n--mode\nrpc\n--session\n/tmp/session.jsonl\n",
-                prompt_path.display(),
-                managed_skills_dir.display(),
-            )
-        );
-        assert_eq!(
-            fs::read_to_string(&prompt_path).expect("read system prompt"),
-            "Buzz base\n\n## Session Model\nThread scoped"
-        );
-        assert_eq!(
-            fs::metadata(&prompt_path)
-                .expect("prompt metadata")
-                .permissions()
-                .mode()
-                & 0o777,
-            0o600
-        );
-        assert_eq!(
-            fs::metadata(prepared.launcher_path())
-                .expect("launcher metadata")
-                .permissions()
-                .mode()
-                & 0o777,
-            0o700
-        );
-        assert_eq!(
-            fs::metadata(&prepared.directory)
-                .expect("directory metadata")
-                .permissions()
-                .mode()
-                & 0o777,
-            0o700
-        );
-
-        drop(prepared);
-        assert!(!prompt_path.exists());
-        fs::remove_dir_all(fixture_dir).expect("remove fixture dir");
-    }
-}
diff --git a/crates/buzz-acp/src/pool.rs b/crates/buzz-acp/src/pool.rs
index dbeafedda70..250221badca 100644
--- a/crates/buzz-acp/src/pool.rs
+++ b/crates/buzz-acp/src/pool.rs
@@ -32,7 +32,7 @@ use uuid::Uuid;
 use crate::acp::{
     extract_model_config_options, extract_model_state, extract_thought_level_config_id,
     model_in_catalog, resolve_model_switch_method, AcpClient, AcpError, EnvVar, McpServer,
-    ModelSwitchMethod, StopReason, SystemPromptTransport,
+    ModelSwitchMethod, StopReason, SystemPromptTransport, BUZZ_PI_ACP_NAME,
 };
 use crate::config::{compose_scoped_session_title, DedupMode, PermissionMode};
 use crate::observer;
@@ -299,7 +299,7 @@ fn has_system_prompt_support(
 ) -> bool {
     if agent_name == "goose" {
         goose_system_prompt_supported == Some(true)
-    } else if agent_name == CLAUDE_AGENT_ACP_NAME {
+    } else if agent_name == BUZZ_PI_ACP_NAME || agent_name == CLAUDE_AGENT_ACP_NAME {
         true
     } else {
         protocol_version >= 2
@@ -312,7 +312,11 @@ fn session_new_system_prompt<'a>(
     agent_name: &str,
     prompt: Option<&'a str>,
 ) -> Option<SystemPromptTransport<'a>> {
-    if is_goose || (protocol_version < 2 && agent_name != CLAUDE_AGENT_ACP_NAME) {
+    if is_goose {
+        None
+    } else if agent_name == BUZZ_PI_ACP_NAME {
+        prompt.map(SystemPromptTransport::PiMeta)
+    } else if protocol_version < 2 && agent_name != CLAUDE_AGENT_ACP_NAME {
         None
     } else if agent_name == CLAUDE_AGENT_ACP_NAME {
         prompt.map(SystemPromptTransport::ClaudeMeta)
@@ -5485,56 +5489,7 @@ mod tests {
         assert_eq!(composed, "<base>\nbe helpful\n</base>\n\ntick");
     }
 
-    #[test]
-    fn goose_uses_system_prompt_only_after_custom_method_succeeds() {
-        assert!(!has_system_prompt_support(2, "goose", None));
-        assert!(!has_system_prompt_support(2, "goose", Some(false)));
-        assert!(has_system_prompt_support(2, "goose", Some(true)));
-        assert!(has_system_prompt_support(1, "goose", Some(true)));
-        assert!(has_system_prompt_support(2, "buzz-agent", None));
-        // Goose never receives system prompt via session/new (uses post-hoc method).
-        assert_eq!(
-            session_new_system_prompt(true, 2, "goose", Some("instructions")),
-            None
-        );
-        // Protocol-v2 non-goose gets Field transport.
-        assert_eq!(
-            session_new_system_prompt(false, 2, "buzz-agent", Some("instructions")),
-            Some(SystemPromptTransport::Field("instructions"))
-        );
-        // Protocol-v1 non-goose, non-claude gets None (legacy user-message framing).
-        assert_eq!(
-            session_new_system_prompt(false, 1, "codex", Some("instructions")),
-            None
-        );
-        // claude-agent-acp gets ClaudeMeta transport regardless of protocol version.
-        assert_eq!(
-            session_new_system_prompt(false, 1, CLAUDE_AGENT_ACP_NAME, Some("instructions")),
-            Some(SystemPromptTransport::ClaudeMeta("instructions"))
-        );
-        assert_eq!(
-            session_new_system_prompt(true, 1, CLAUDE_AGENT_ACP_NAME, Some("instructions")),
-            None,
-            "goose path must never produce a transport even when agent_name matches"
-        );
-    }
-
-    #[test]
-    fn claude_agent_acp_has_system_prompt_support_regardless_of_protocol_version() {
-        // claude-agent-acp declares protocolVersion:1 but supports _meta.systemPrompt;
-        // has_system_prompt_support must return true so user-message framing is suppressed.
-        assert!(has_system_prompt_support(1, CLAUDE_AGENT_ACP_NAME, None));
-        assert!(has_system_prompt_support(2, CLAUDE_AGENT_ACP_NAME, None));
-    }
-
-    #[test]
-    fn old_zed_adapter_name_falls_through_to_protocol_version_gate() {
-        // The renamed @zed-industries package predates the _meta.systemPrompt support,
-        // so it must not be treated as capable and stays on legacy user-message framing.
-        let old_name = "@zed-industries/claude-code-acp";
-        assert!(!has_system_prompt_support(1, old_name, None));
-        assert!(has_system_prompt_support(2, old_name, None));
-    }
+    include!("pool/system_prompt_tests.rs");
 
     #[test]
     fn test_initial_message_legacy_agent_without_base_is_unchanged() {
@@ -11214,3 +11169,7 @@ done"#
         );
     }
 }
+
+#[cfg(all(test, unix))]
+#[path = "pool/pi_prompt_tests.rs"]
+mod pi_prompt_tests;
diff --git a/crates/buzz-acp/src/pool/pi_prompt_tests.rs b/crates/buzz-acp/src/pool/pi_prompt_tests.rs
new file mode 100644
index 00000000000..a918e3decb6
--- /dev/null
+++ b/crates/buzz-acp/src/pool/pi_prompt_tests.rs
@@ -0,0 +1,371 @@
+use super::*;
+use std::os::unix::fs::PermissionsExt;
+
+fn owned_pi(acp: AcpClient, protocol_version: u32) -> OwnedAgent {
+    OwnedAgent {
+        index: 0,
+        acp,
+        state: SessionState::default(),
+        model_capabilities: None,
+        desired_model: None,
+        model_overridden: false,
+        desired_model_request_id: None,
+        desired_model_pending_ack: false,
+        startup_effort: None,
+        agent_name: BUZZ_PI_ACP_NAME.into(),
+        goose_system_prompt_supported: None,
+        protocol_version,
+    }
+}
+
+fn fixture_dir() -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!("buzz pi transport {}", Uuid::new_v4()));
+    std::fs::create_dir_all(&dir).unwrap();
+    dir
+}
+
+fn script_at(dir: &std::path::Path, script: &str) -> std::path::PathBuf {
+    let path = dir.join(BUZZ_PI_ACP_NAME);
+    std::fs::write(&path, format!("#!/bin/bash\n{script}\n")).unwrap();
+    std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o700)).unwrap();
+    path
+}
+
+#[tokio::test]
+async fn pi_composed_prompt_uses_meta_without_capability_negotiation() {
+    for version in [1, 2] {
+        let dir = fixture_dir();
+        let init = serde_json::json!({"jsonrpc":"2.0", "id":0, "result": {
+            "protocolVersion":version, "agentInfo":{"name":"buzz-pi-acp", "version":"fixture"}, "agentCapabilities":{}
+        }});
+        let path = script_at(
+            &dir,
+            &format!(
+                r#"
+            printf '%s\n' "$@" > '{dir}/args'
+            read -r request
+            echo '{init}'
+            read -r request
+            printf '%s\n' "$request" > '{dir}/request'
+            echo '{{"jsonrpc":"2.0","id":1,"result":{{"sessionId":"fixture"}}}}'
+            read -r request
+        "#,
+                dir = dir.display()
+            ),
+        );
+        let mut acp = AcpClient::spawn(path.to_str().unwrap(), &[], &[], false)
+            .await
+            .unwrap();
+        acp.initialize().await.unwrap();
+        let mut agent = owned_pi(acp, version);
+        assert!(agent.has_system_prompt_support());
+        let mut ctx = tests::make_prompt_context_no_owner();
+        ctx.base_prompt = Some("BUZZ_BASE".into());
+        ctx.system_prompt = Some("BUZZ_PERSONA".into());
+        ctx.team_instructions = Some("BUZZ_TEAM".into());
+        ctx.session_title = Some("Pi fixture".into());
+        let core = "<core-memory>BUZZ_CORE</core-memory>";
+        let canvas = "<channel-canvas>BUZZ_CANVAS</channel-canvas>";
+        create_session_and_apply_model(
+            &mut agent,
+            &ctx,
+            Some(core),
+            NewSessionChannelContext {
+                huddle_instructions: Some("BUZZ_HUDDLE"),
+                canvas: Some(canvas),
+                name: Some("channel"),
+                scope: None,
+                channel_type: None,
+            },
+        )
+        .await
+        .unwrap();
+        agent.acp.shutdown().await;
+        let request: serde_json::Value =
+            serde_json::from_str(&std::fs::read_to_string(dir.join("request")).unwrap()).unwrap();
+        let params = &request["params"];
+        assert!(params.get("systemPrompt").is_none());
+        assert!(params["_meta"]["sessionTitle"]
+            .as_str()
+            .unwrap()
+            .contains("Pi fixture"));
+        let standing = crate::queue::StandingContext {
+            base_prompt: ctx.base_prompt.as_deref(),
+            system_prompt: ctx.system_prompt.as_deref(),
+            team_instructions: ctx.team_instructions.as_deref(),
+            agent_core: Some(core),
+            huddle_instructions: Some("BUZZ_HUDDLE"),
+            agent_canvas: Some(canvas),
+        };
+        let user = prepend_standing_for_legacy(2, &standing, "EVENT");
+        for marker in [
+            "BUZZ_BASE",
+            "BUZZ_PERSONA",
+            "BUZZ_TEAM",
+            "BUZZ_CORE",
+            "BUZZ_HUDDLE",
+            "BUZZ_CANVAS",
+        ] {
+            assert_eq!(
+                params["_meta"]["systemPrompt"]
+                    .as_str()
+                    .unwrap()
+                    .matches(marker)
+                    .count(),
+                1
+            );
+            assert!(!user.contains(marker));
+        }
+
+        let args = std::fs::read_to_string(dir.join("args")).unwrap();
+        assert_eq!(
+            args,
+            format!(
+                "--\n--skill\n{}\n",
+                std::env::current_dir()
+                    .unwrap()
+                    .join(".agents/skills")
+                    .display()
+            )
+        );
+        std::fs::remove_dir_all(dir).unwrap();
+    }
+}
+
+#[tokio::test]
+async fn pi_launch_preserves_existing_skills_in_explicit_workspace() {
+    const FIXTURE_ENV: &str = "BUZZ_TEST_PI_LAUNCH_WORKSPACE";
+    if let Some(dir) = std::env::var_os(FIXTURE_ENV) {
+        let path = std::path::PathBuf::from(dir).join(BUZZ_PI_ACP_NAME);
+        let mut client = AcpClient::spawn(
+            path.to_str().unwrap(),
+            &["--".into(), "--skill".into(), "/extra skills".into()],
+            &[],
+            false,
+        )
+        .await
+        .unwrap();
+        tokio::time::timeout(std::time::Duration::from_secs(5), client.initialize())
+            .await
+            .unwrap()
+            .unwrap_err();
+        client.shutdown().await;
+        return;
+    }
+
+    let dir = fixture_dir();
+    let workspace = dir.join("chosen workspace");
+    std::fs::create_dir_all(workspace.join(".agents/skills")).unwrap();
+    // Canonicalize macOS's /var -> /private/var before comparing with getcwd.
+    let workspace = workspace.canonicalize().unwrap();
+    script_at(
+        &dir,
+        r#"printf '%s\n' "$@" > "$(dirname "$0")/args"
+pwd -P > "$(dirname "$0")/cwd""#,
+    );
+    // Re-enter only this test in a separate process so parallel tests never
+    // share a mutated CWD. This models Desktop setting its harness child's CWD.
+    let output = tokio::time::timeout(
+        std::time::Duration::from_secs(20),
+        tokio::process::Command::new(std::env::current_exe().unwrap())
+            .args([
+                "--exact",
+                "pool::pi_prompt_tests::pi_launch_preserves_existing_skills_in_explicit_workspace",
+                "--nocapture",
+            ])
+            .kill_on_drop(true)
+            .env(FIXTURE_ENV, &dir)
+            .current_dir(&workspace)
+            .output(),
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    assert!(
+        output.status.success(),
+        "child failed: {}\n{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert_eq!(
+        std::fs::read_to_string(dir.join("cwd")).unwrap().trim(),
+        workspace.to_str().unwrap()
+    );
+    assert_eq!(
+        std::fs::read_to_string(dir.join("args")).unwrap(),
+        format!(
+            "--\n--skill\n/extra skills\n--skill\n{}\n",
+            workspace.join(".agents/skills").display()
+        )
+    );
+    std::fs::remove_dir_all(dir).unwrap();
+}
+
+#[tokio::test]
+async fn upstream_pi_acp_launch_does_not_receive_managed_skills() {
+    let dir = fixture_dir();
+    let path = dir.join("pi-acp");
+    std::fs::write(
+        &path,
+        format!(
+            r#"#!/bin/bash
+printf '%s' "$*" > '{dir}/args'
+read -r request
+echo '{{"jsonrpc":"2.0","id":0,"result":{{"protocolVersion":1,"agentInfo":{{"name":"pi-acp","version":"fixture"}},"agentCapabilities":{{}}}}}}'
+read -r request
+"#,
+            dir = dir.display()
+        ),
+    )
+    .unwrap();
+    std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o700)).unwrap();
+
+    let mut client = AcpClient::spawn(path.to_str().unwrap(), &[], &[], false)
+        .await
+        .unwrap();
+    client.initialize().await.unwrap();
+    client.shutdown().await;
+
+    assert_eq!(std::fs::read_to_string(dir.join("args")).unwrap(), "");
+    std::fs::remove_dir_all(dir).unwrap();
+}
+
+#[tokio::test]
+#[ignore = "requires BUZZ_TEST_PI_ACP pointing to a built fork and Pi on PATH"]
+async fn real_pi_preserves_buzz_prompt_and_launch_skills_on_restore() {
+    use base64::Engine;
+    let adapter = std::env::var("BUZZ_TEST_PI_ACP").expect("set BUZZ_TEST_PI_ACP");
+    let dir = fixture_dir();
+    let home = dir.join("home");
+    let workspace = dir.join("workspace");
+    let skill = dir.join("extra skills");
+    for path in [&home, &workspace, &skill] {
+        std::fs::create_dir_all(path).unwrap();
+    }
+    std::fs::write(
+        skill.join("SKILL.md"),
+        "---\nname: buzz-fixture\ndescription: BUZZ_SKILL_MARKER\n---\nSynthetic instructions.\n",
+    )
+    .unwrap();
+    let path = script_at(&dir, &format!(
+        "export HOME='{}' PI_CODING_AGENT_DIR='{}/agent' ANTHROPIC_API_KEY=synthetic-test-key PI_ACP_PI_COMMAND=pi\nexec node '{}' \"$@\"",
+        home.display(), dir.display(), adapter.replace('\'', "'\\''")
+    ));
+    let args = vec![
+        "--".into(),
+        "--offline".into(),
+        "--no-extensions".into(),
+        "--no-context-files".into(),
+        "--skill".into(),
+        skill.to_string_lossy().into_owned(),
+    ];
+    let mut acp = AcpClient::spawn(path.to_str().unwrap(), &args, &[], false)
+        .await
+        .unwrap();
+    acp.initialize().await.unwrap();
+    let mut agent = owned_pi(acp, 1);
+    assert!(agent.has_system_prompt_support());
+    let mut ctx = tests::make_prompt_context_no_owner();
+    ctx.cwd = workspace.to_string_lossy().into_owned();
+    ctx.base_prompt = Some("BUZZ_BASE".into());
+    ctx.system_prompt = Some("BUZZ_PERSONA".into());
+    ctx.team_instructions = Some("BUZZ_TEAM".into());
+    ctx.session_title = Some("Pi fixture".into());
+    let id = create_session_and_apply_model(
+        &mut agent,
+        &ctx,
+        Some("<core-memory>BUZZ_CORE</core-memory>"),
+        NewSessionChannelContext {
+            huddle_instructions: Some("BUZZ_HUDDLE"),
+            canvas: Some("<channel-canvas>BUZZ_CANVAS</channel-canvas>"),
+            name: None,
+            scope: None,
+            channel_type: None,
+        },
+    )
+    .await
+    .unwrap();
+    let metadata = std::fs::read_dir(home.join(".pi/buzz-pi-acp/sessions"))
+        .unwrap()
+        .find_map(|entry| {
+            let contents = std::fs::read_to_string(entry.ok()?.path()).ok()?;
+            let metadata: serde_json::Value = serde_json::from_str(&contents).ok()?;
+            (metadata["session"]["sessionId"].as_str() == Some(id.as_str())).then_some(metadata)
+        })
+        .expect("adapter should persist metadata for the new session");
+    let transcript = metadata["session"]["sessionFile"].as_str().unwrap();
+    let timestamp = "2026-01-01T00:00:00.000Z";
+    std::fs::create_dir_all(std::path::Path::new(transcript).parent().unwrap()).unwrap();
+    std::fs::write(transcript, format!("{}\n{}\n",
+        serde_json::json!({"type":"session","version":3,"id":id,"timestamp":timestamp,"cwd":ctx.cwd}),
+        serde_json::json!({"type":"message","id":"00000001","parentId":null,"timestamp":timestamp,"message":{"role":"user","content":[{"type":"text","text":"fixture"}],"timestamp":1767225600000u64}})
+    )).unwrap();
+    agent
+        .acp
+        .session_new_full(
+            &ctx.cwd,
+            vec![],
+            Some(SystemPromptTransport::PiMeta("OTHER_SESSION")),
+            None,
+        )
+        .await
+        .unwrap();
+    for restart in [false, true] {
+        if restart {
+            agent.acp.shutdown().await;
+            agent.acp = AcpClient::spawn(path.to_str().unwrap(), &args, &[], false)
+                .await
+                .unwrap();
+            agent.acp.initialize().await.unwrap();
+        }
+        agent
+            .acp
+            .session_prompt_with_idle_timeout(
+                &id,
+                "/export",
+                Duration::from_secs(15),
+                Duration::from_secs(30),
+            )
+            .await
+            .unwrap();
+        let html =
+            std::fs::read_to_string(workspace.join(format!("pi-session-{id}.html"))).unwrap();
+        let encoded = html
+            .split("id=\"session-data\"")
+            .nth(1)
+            .unwrap()
+            .split_once('>')
+            .unwrap()
+            .1
+            .split("</script>")
+            .next()
+            .unwrap()
+            .trim();
+        let data: serde_json::Value = serde_json::from_slice(
+            &base64::engine::general_purpose::STANDARD
+                .decode(encoded)
+                .unwrap(),
+        )
+        .unwrap();
+        let prompt = data["systemPrompt"].as_str().unwrap();
+        for marker in [
+            "BUZZ_BASE",
+            "BUZZ_PERSONA",
+            "BUZZ_TEAM",
+            "BUZZ_CORE",
+            "BUZZ_HUDDLE",
+            "BUZZ_CANVAS",
+            "BUZZ_SKILL_MARKER",
+        ] {
+            assert_eq!(
+                prompt.matches(marker).count(),
+                1,
+                "{marker}, restart={restart}"
+            );
+        }
+        assert!(!prompt.contains("OTHER_SESSION"));
+        assert!(!prompt.contains("You are an expert coding assistant"));
+    }
+    agent.acp.shutdown().await;
+    std::fs::remove_dir_all(dir).unwrap();
+}
diff --git a/crates/buzz-acp/src/pool/system_prompt_tests.rs b/crates/buzz-acp/src/pool/system_prompt_tests.rs
new file mode 100644
index 00000000000..223065decbc
--- /dev/null
+++ b/crates/buzz-acp/src/pool/system_prompt_tests.rs
@@ -0,0 +1,78 @@
+#[test]
+fn goose_uses_system_prompt_only_after_custom_method_succeeds() {
+    assert!(!has_system_prompt_support(2, "goose", None));
+    assert!(!has_system_prompt_support(2, "goose", Some(false)));
+    assert!(has_system_prompt_support(2, "goose", Some(true)));
+    assert!(has_system_prompt_support(1, "goose", Some(true)));
+    assert!(has_system_prompt_support(2, "buzz-agent", None));
+    // Goose never receives system prompt via session/new (uses post-hoc method).
+    assert_eq!(
+        session_new_system_prompt(true, 2, "goose", Some("instructions")),
+        None
+    );
+    // Protocol-v2 non-goose gets Field transport.
+    assert_eq!(
+        session_new_system_prompt(false, 2, "buzz-agent", Some("instructions")),
+        Some(SystemPromptTransport::Field("instructions"))
+    );
+    // Protocol-v1 non-goose, non-claude gets None (legacy user-message framing).
+    assert_eq!(
+        session_new_system_prompt(false, 1, "codex", Some("instructions")),
+        None
+    );
+    // claude-agent-acp gets ClaudeMeta transport regardless of protocol version.
+    assert_eq!(
+        session_new_system_prompt(false, 1, CLAUDE_AGENT_ACP_NAME, Some("instructions")),
+        Some(SystemPromptTransport::ClaudeMeta("instructions"))
+    );
+    assert_eq!(
+        session_new_system_prompt(true, 1, CLAUDE_AGENT_ACP_NAME, Some("instructions")),
+        None,
+        "goose path must never produce a transport even when agent_name matches"
+    );
+}
+
+#[test]
+fn claude_agent_acp_has_system_prompt_support_regardless_of_protocol_version() {
+    // claude-agent-acp declares protocolVersion:1 but supports _meta.systemPrompt;
+    // has_system_prompt_support must return true so user-message framing is suppressed.
+    assert!(has_system_prompt_support(1, CLAUDE_AGENT_ACP_NAME, None));
+    assert!(has_system_prompt_support(2, CLAUDE_AGENT_ACP_NAME, None));
+}
+
+#[test]
+fn old_zed_adapter_name_falls_through_to_protocol_version_gate() {
+    // The renamed @zed-industries package predates the _meta.systemPrompt support,
+    // so it must not be treated as capable and stays on legacy user-message framing.
+    let old_name = "@zed-industries/claude-code-acp";
+    assert!(!has_system_prompt_support(1, old_name, None));
+    assert!(has_system_prompt_support(2, old_name, None));
+}
+
+#[test]
+fn pi_prompt_support_uses_metadata_regardless_of_protocol_version() {
+    for version in [1, 2] {
+        assert!(has_system_prompt_support(version, BUZZ_PI_ACP_NAME, None));
+        assert_eq!(
+            session_new_system_prompt(false, version, BUZZ_PI_ACP_NAME, Some("instructions")),
+            Some(SystemPromptTransport::PiMeta("instructions"))
+        );
+        assert_eq!(
+            session_new_system_prompt(false, version, BUZZ_PI_ACP_NAME, None),
+            None
+        );
+    }
+}
+
+#[test]
+fn upstream_pi_acp_does_not_receive_fork_specific_prompt_metadata() {
+    assert!(!has_system_prompt_support(1, "pi-acp", None));
+    assert_eq!(
+        session_new_system_prompt(false, 1, "pi-acp", Some("instructions")),
+        None
+    );
+    assert_eq!(
+        session_new_system_prompt(false, 2, "pi-acp", Some("instructions")),
+        Some(SystemPromptTransport::Field("instructions"))
+    );
+}
diff --git a/desktop/src-tauri/src/managed_agents/discovery/presets.rs b/desktop/src-tauri/src/managed_agents/discovery/presets.rs
index b184559c157..68763d9aaad 100644
--- a/desktop/src-tauri/src/managed_agents/discovery/presets.rs
+++ b/desktop/src-tauri/src/managed_agents/discovery/presets.rs
@@ -107,13 +107,13 @@ pub(super) const PRESET_HARNESSES: &[PresetHarness] = &[
     PresetHarness {
         id: "pi",
         label: "Pi",
-        command: "pi-acp",
+        command: "buzz-pi-acp",
         args: &[],
-        install_instructions_url: "https://github.com/svkozak/pi-acp",
-        install_hint: "Install the Pi ACP adapter with npm install -g pi-acp.",
+        install_instructions_url: "https://github.com/salman1993/pi-acp",
+        install_hint: "Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Buzz, then select Pi as the agent harness. Run the same install command again to update the adapter.",
         underlying_cli: Some("pi"),
         underlying_cli_install_hint: Some(
-            "Install Pi with npm install -g --ignore-scripts @earendil-works/pi-coding-agent.",
+            "Install Pi with `npm install -g @earendil-works/pi-coding-agent`, then run `pi` to configure its model provider.",
         ),
         underlying_cli_install_instructions_url: Some(
             "https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent",
@@ -404,17 +404,17 @@ mod tests {
             .expect("Pi preset should be present");
 
         assert_eq!(preset.label, "Pi");
-        assert_eq!(preset.command, "pi-acp");
+        assert_eq!(preset.command, "buzz-pi-acp");
         assert!(preset.args.is_empty());
         assert_eq!(preset.underlying_cli, Some("pi"));
 
         let available = preset_catalog_entry(preset, |command| match command {
-            "pi-acp" => Some(PathBuf::from("/usr/local/bin/pi-acp")),
+            "buzz-pi-acp" => Some(PathBuf::from("/usr/local/bin/buzz-pi-acp")),
             "pi" => Some(PathBuf::from("/usr/local/bin/pi")),
             _ => None,
         });
         assert_eq!(available.availability, AcpAvailabilityStatus::Available);
-        assert_eq!(available.command.as_deref(), Some("pi-acp"));
+        assert_eq!(available.command.as_deref(), Some("buzz-pi-acp"));
         assert!(available.default_args.is_empty());
         assert!(available.install_hint.is_empty());
         assert!(available.requires_external_cli);
@@ -434,21 +434,21 @@ mod tests {
         assert!(adapter_missing.default_args.is_empty());
         assert_eq!(
             adapter_missing.install_hint,
-            "Install the Pi ACP adapter with npm install -g pi-acp."
+            "Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Buzz, then select Pi as the agent harness. Run the same install command again to update the adapter."
         );
         assert_eq!(
             adapter_missing.install_instructions_url,
-            "https://github.com/svkozak/pi-acp"
+            "https://github.com/salman1993/pi-acp"
         );
 
         let cli_missing = preset_catalog_entry(preset, |command| {
-            (command == "pi-acp").then(|| PathBuf::from("/usr/local/bin/pi-acp"))
+            (command == "buzz-pi-acp").then(|| PathBuf::from("/usr/local/bin/buzz-pi-acp"))
         });
         assert_eq!(cli_missing.availability, AcpAvailabilityStatus::CliMissing);
-        assert_eq!(cli_missing.command.as_deref(), Some("pi-acp"));
+        assert_eq!(cli_missing.command.as_deref(), Some("buzz-pi-acp"));
         assert_eq!(
             cli_missing.install_hint,
-            "Install Pi with npm install -g --ignore-scripts @earendil-works/pi-coding-agent."
+            "Install Pi with `npm install -g @earendil-works/pi-coding-agent`, then run `pi` to configure its model provider."
         );
         assert_eq!(
             cli_missing.install_instructions_url,
@@ -462,7 +462,7 @@ mod tests {
         );
         assert_eq!(
             not_installed.install_hint,
-            "Install Pi with npm install -g --ignore-scripts @earendil-works/pi-coding-agent. Install the Pi ACP adapter with npm install -g pi-acp."
+            "Install Pi with `npm install -g @earendil-works/pi-coding-agent`, then run `pi` to configure its model provider. Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Buzz, then select Pi as the agent harness. Run the same install command again to update the adapter."
         );
     }
 
diff --git a/desktop/src-tauri/src/managed_agents/env_vars/tests.rs b/desktop/src-tauri/src/managed_agents/env_vars/tests.rs
index 7aa886c672a..dc38c3d126f 100644
--- a/desktop/src-tauri/src/managed_agents/env_vars/tests.rs
+++ b/desktop/src-tauri/src/managed_agents/env_vars/tests.rs
@@ -145,14 +145,6 @@ fn reserved_keys_include_agent_owner_for_legacy_records() {
     assert!(merged.is_empty());
 }
 
-#[test]
-fn reserved_keys_include_pi_acp_command() {
-    assert!(is_reserved_env_key("PI_ACP_PI_COMMAND"));
-    let agent = map(&[("PI_ACP_PI_COMMAND", "/tmp/custom-pi")]);
-    let merged = merged_user_env(&BTreeMap::new(), &agent);
-    assert!(merged.is_empty());
-}
-
 #[test]
 fn reserved_keys_include_respond_to_gate() {
     // Respond-to mode + allowlist control who the agent answers.
diff --git a/desktop/src-tauri/src/managed_agents/reserved_env_keys.rs b/desktop/src-tauri/src/managed_agents/reserved_env_keys.rs
index 107171b3d47..c01d29f3c2a 100644
--- a/desktop/src-tauri/src/managed_agents/reserved_env_keys.rs
+++ b/desktop/src-tauri/src/managed_agents/reserved_env_keys.rs
@@ -41,9 +41,6 @@ pub(crate) const RESERVED_ENV_KEYS: &[&str] = &[
     "BUZZ_ACP_AGENT_COMMAND",
     "BUZZ_ACP_AGENT_ARGS",
     "BUZZ_ACP_MCP_COMMAND",
-    // pi-acp's executable override is reserved for Buzz's generated launcher,
-    // which injects the managed system prompt and skills.
-    "PI_ACP_PI_COMMAND",
     // Control-plane parallelism: the Desktop resolves the effective
     // worker-pool size (applying any per-harness cap) and writes it into
     // launch.policy_env. A user-supplied BUZZ_ACP_AGENTS would bypass the
diff --git a/desktop/src/features/agents/ui/agentSessionTranscript.ts b/desktop/src/features/agents/ui/agentSessionTranscript.ts
index e3f0448bd19..ffc7f522037 100644
--- a/desktop/src/features/agents/ui/agentSessionTranscript.ts
+++ b/desktop/src/features/agents/ui/agentSessionTranscript.ts
@@ -872,13 +872,16 @@ export function processTranscriptEvent(
     } else if (event.kind === "acp_write" && method === "session/new") {
       // The base + persona prompts ride session/new's systemPrompt, framed by
       // the harness as <base>/<agent-instructions>/<core-memory>/<channel-canvas>.
-      // claude-agent-acp uses _meta.systemPrompt.append instead; both paths
-      // produce the same standalone card (turnId: null, acpSource "session/new");
+      // ACP adapters may use a replacement string or a replace/append object
+      // under _meta.systemPrompt. All paths produce the same standalone card
+      // (turnId: null, acpSource "session/new");
       // the bare field takes precedence when both are present.
       const params = asRecord(payload.params);
-      const metaPrompt = asString(
-        asRecord(asRecord(params._meta).systemPrompt).append,
-      );
+      const metaSystemPrompt = asRecord(params._meta).systemPrompt;
+      const metaPrompt =
+        asString(metaSystemPrompt) ??
+        asString(asRecord(metaSystemPrompt).replace) ??
+        asString(asRecord(metaSystemPrompt).append);
       const systemPrompt = asString(params.systemPrompt) ?? metaPrompt;
       if (systemPrompt) {
         const sections = parseSystemPromptSections(systemPrompt);
diff --git a/desktop/src/features/agents/ui/agentSessionTranscriptPi.test.mjs b/desktop/src/features/agents/ui/agentSessionTranscriptPi.test.mjs
new file mode 100644
index 00000000000..6a4451ca7cd
--- /dev/null
+++ b/desktop/src/features/agents/ui/agentSessionTranscriptPi.test.mjs
@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { buildTranscript } from "./agentSessionTranscript.ts";
+
+test("Pi metadata replacement prompt produces a standalone system prompt card", () => {
+  const events = [
+    {
+      seq: 1,
+      timestamp: "2026-09-09T00:00:00Z",
+      kind: "acp_write",
+      agentIndex: 0,
+      channelId: "11111111-1111-1111-1111-111111111111",
+      sessionId: "pi-session",
+      turnId: "turn-1",
+      payload: {
+        method: "session/new",
+        params: {
+          _meta: {
+            sessionTitle: "Pi fixture",
+            systemPrompt:
+              "<base>\nBuzz base\n</base>\n\n<agent-instructions>\nPersona\n</agent-instructions>",
+          },
+        },
+      },
+    },
+  ];
+  const cards = buildTranscript(events).filter(
+    (item) => item.acpSource === "session/new",
+  );
+  assert.equal(cards.length, 1);
+  assert.equal(cards[0].turnId, null);
+  assert.deepEqual(
+    cards[0].sections.map((section) => section.body),
+    ["Buzz base", "Persona"],
+  );
+});
+
+test("Pi metadata replace object produces a standalone system prompt card", () => {
+  const events = [
+    {
+      seq: 1,
+      timestamp: "2026-09-09T00:00:00Z",
+      kind: "acp_write",
+      agentIndex: 0,
+      channelId: "11111111-1111-1111-1111-111111111111",
+      sessionId: "pi-session",
+      turnId: "turn-1",
+      payload: {
+        method: "session/new",
+        params: {
+          _meta: {
+            sessionTitle: "Pi fixture",
+            systemPrompt: {
+              replace:
+                "<base>\nBuzz base\n</base>\n\n<agent-instructions>\nPersona\n</agent-instructions>",
+            },
+          },
+        },
+      },
+    },
+  ];
+  const cards = buildTranscript(events).filter(
+    (item) => item.acpSource === "session/new",
+  );
+  assert.equal(cards.length, 1);
+  assert.equal(cards[0].turnId, null);
+  assert.deepEqual(
+    cards[0].sections.map((section) => section.body),
+    ["Buzz base", "Persona"],
+  );
+});
diff --git a/desktop/src/features/settings/ui/harnessCatalogCopy.test.mjs b/desktop/src/features/settings/ui/harnessCatalogCopy.test.mjs
index 86a3f6b760f..d1ce150b858 100644
--- a/desktop/src/features/settings/ui/harnessCatalogCopy.test.mjs
+++ b/desktop/src/features/settings/ui/harnessCatalogCopy.test.mjs
@@ -6,6 +6,6 @@ import { harnessDescription } from "./harnessCatalogCopy.ts";
 test("Pi catalog entry has its curated product description", () => {
   assert.equal(
     harnessDescription("pi"),
-    "A minimal terminal coding harness, connected through the pi-acp adapter.",
+    "A minimal terminal coding harness, connected through the buzz-pi-acp adapter.",
   );
 });
diff --git a/desktop/src/features/settings/ui/harnessCatalogCopy.ts b/desktop/src/features/settings/ui/harnessCatalogCopy.ts
index f91dada83fc..ed8299ebe89 100644
--- a/desktop/src/features/settings/ui/harnessCatalogCopy.ts
+++ b/desktop/src/features/settings/ui/harnessCatalogCopy.ts
@@ -27,8 +27,8 @@ const HARNESS_DESCRIPTIONS: Record<string, string> = {
   cursor: "Cursor's coding agent, connected to Buzz through its ACP server.",
   // Source: https://github.com/can1357/oh-my-pi
   omp: "A terminal coding agent with integrated development tools.",
-  // Sources: https://pi.dev/docs/latest, https://github.com/svkozak/pi-acp
-  pi: "A minimal terminal coding harness, connected through the pi-acp adapter.",
+  // Sources: https://pi.dev/docs/latest, https://github.com/salman1993/pi-acp
+  pi: "A minimal terminal coding harness, connected through the buzz-pi-acp adapter.",
   // Source: https://build.x.ai (docs unavailable during research; kept
   // deliberately conservative).
   grok: "xAI's coding agent, connected to Buzz through its ACP entrypoint.",

From 6146c4fd16f734b525f9ac31e1a3433ccc1ec96f Mon Sep 17 00:00:00 2001
From: Wes <wesbillman@users.noreply.github.com>
Date: Fri, 11 Sep 2026 08:10:43 -0700
Subject: [PATCH 15/19] feat(git): add default-branch management to relay and
 CLI (#7562)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Authored by Brain and opened on behalf of Wes (`wesbillman`).

## Summary

Add `buzz repos default-branch get/set` and the relay operation it
needs. Git push changes branch tips but cannot select the server's
symbolic HEAD. This selects an existing branch without deleting
branches, moving refs, or changing packs.

- Reuse immutable Git manifests and captured-ETag CAS; concurrent
pushes/default changes conflict, including stale no-ops.
- Require request-specific NIP-98, body binding, fail-closed replay
protection, host tenancy, current channel membership and
repository-management authority. Push/project roles alone are
insufficient.
- Send the CLI mutation once, without redirects; ambiguous delivery
retains the observed digest and is non-retryable.
- Document the narrow HTTP exception to Nostr-first, delegation scope
and admission-time ACL revocation. Kind:30618 remains derived; the
manifest CAS is authoritative.
- Register the Postgres/Redis/MinIO route and fresh-clone tests in the
existing Backend Integration lane.

## Review fixes — `7457bda50afa6b52e36315572fa96928b2e21db6`

- Reject signed valueless `payload` tags when verifying a body; preserve
the shared verifier's intentional absent-payload compatibility. The real
settings route now proves 401, unchanged manifest pointer, and unchanged
kind:30618 event IDs for malformed and other invalid credentials.
- Require a nonempty returned branch and `head == refs/heads/{branch}`;
SET additionally requires the returned branch to equal the attempted
branch. Malformed/mismatched mutation responses remain non-retryable
`DeliveryUnknown`, retaining the attempted branch and original digest.
Invalid reads fail before any POST.
- Strengthen the later-push/fresh-clone regression to select
`release/v1` while `main` exists.

## Verification

At `7457bda50afa6b52e36315572fa96928b2e21db6`:
- Full pre-push passed (all 14 Rust test groups, serialized Tauri
tests/clippy, file-size and branch-skew gates; 522 seconds). No hooks
disabled.
- All four isolated Postgres/Redis/MinIO settings tests pass, including
real Smart HTTP `ls-remote --symref` and fresh clone on `release/v1`.
- All 15 focused NIP-98 verifier tests and three default-branch CLI
tests pass; malformed credentials and missing-branch responses were
reproduced failing before the fixes.
- Five targeted mutants are killed: restoring the valueless-payload
bypass, weakening canonical HEAD validation, accepting an empty branch,
dropping requested-branch confirmation, and omitting hydrated HEAD for
the selected non-main branch. Mutations ran in a separate worktree and
target directory; original patch bytes were verified restored.
- `cargo clippy -p buzz-auth -p buzz-cli -p buzz-relay --all-targets --
-D warnings`, formatting, diff and file-size checks pass on the fixed
tree.

Earlier validation at `bb195b140`: seven Git authorization database
regressions and 28 existing transport tests passed (three infrastructure
cases in that module not selected); four mutations killed
management/replay/CAS/redirect regressions. Full pre-push passed with
`RUST_TEST_THREADS=1` (all 14 Rust groups, Tauri clippy and 3,173 tests,
size/branch-skew gates). Serial execution avoids an unrelated
process-global Desktop discovery counter flake; no hooks disabled or
Desktop changes.

Carl and Jude's review findings are addressed in the new head; **fresh
reviewer and exact-head security confirmation remain required**. The
earlier source review is not approval of this revision. No claim of
green new-head CI.

## Rollout

Merge and **deploy the relay support first**, then build/use the updated
CLI and explicitly set/verify the desired default. No schema migration.
This PR does not deploy anything or change a live repository.

Originating conversation (channel
`8e2fda80-9142-4df8-8e14-da288bea6471`):

buzz://message?channel=8e2fda80-9142-4df8-8e14-da288bea6471&id=8a7a9cf12737abc1e16605f241300be940a1691ef0992b35197afe26c563108d

---------

Signed-off-by: Brain <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
Co-authored-by: Brain <1a02c72794dcd0f07058a353bc3a81f4028b8c77c92c87fce6d5c8b85970a20b@buzz.block.builderlab.xyz>
---
 .github/workflows/_ci-relay.yml               |  13 +
 crates/buzz-auth/src/nip98.rs                 |  28 +-
 crates/buzz-cli/README.md                     |  27 +
 crates/buzz-cli/src/client.rs                 |  50 +
 crates/buzz-cli/src/commands/mod.rs           |   1 +
 .../src/commands/repo_default_branch.rs       | 314 +++++++
 crates/buzz-cli/src/commands/repos.rs         |   3 +
 crates/buzz-cli/src/lib.rs                    |  37 +-
 crates/buzz-relay/src/api/git/hydrate.rs      |   2 +-
 crates/buzz-relay/src/api/git/mod.rs          |   1 +
 crates/buzz-relay/src/api/git/settings.rs     | 418 +++++++++
 .../buzz-relay/src/api/git/settings_tests.rs  | 880 ++++++++++++++++++
 crates/buzz-relay/src/api/git/transport.rs    |  13 +-
 docs/git-on-object-storage.md                 |  55 ++
 14 files changed, 1830 insertions(+), 12 deletions(-)
 create mode 100644 crates/buzz-cli/src/commands/repo_default_branch.rs
 create mode 100644 crates/buzz-relay/src/api/git/settings.rs
 create mode 100644 crates/buzz-relay/src/api/git/settings_tests.rs

diff --git a/.github/workflows/_ci-relay.yml b/.github/workflows/_ci-relay.yml
index 97d32f912c7..5a8011539ae 100644
--- a/.github/workflows/_ci-relay.yml
+++ b/.github/workflows/_ci-relay.yml
@@ -484,6 +484,19 @@ jobs:
           VALUES ('00000000-0000-4000-8000-00000000c0de', 'localhost:3000')
           ON CONFLICT (lower(host)) DO NOTHING
           ;"
+      - name: Git default-branch route and clone regressions
+        env:
+          # The preceding step already applied and reconciled schema/schema.sql.
+          BUZZ_TEST_SCHEMA_MODE: desired
+          BUZZ_TEST_DATABASE_URL: postgres://buzz:${{ env.BUZZ_TEST_POSTGRES_PASSWORD }}@localhost:5432/buzz
+          BUZZ_TEST_REDIS_URL: redis://localhost:6379
+          BUZZ_TEST_S3_ENDPOINT: http://localhost:9000
+          BUZZ_TEST_S3_BUCKET: buzz-media
+        run: |
+          cargo nextest run \
+            --archive-file target/ci/backend-integration-tests.tar.zst \
+            -E 'package(buzz-relay) and test(/api::git::settings::tests::external_infra::/)' \
+            --run-ignored ignored-only
       - name: Workflow message provenance unit tests
         # The relay's workflow_sink suite is not selected by the infra-free
         # unit job. Its ignored database cases run in the isolated PostgreSQL
diff --git a/crates/buzz-auth/src/nip98.rs b/crates/buzz-auth/src/nip98.rs
index d3ece3fdfc2..a5ed98167cb 100644
--- a/crates/buzz-auth/src/nip98.rs
+++ b/crates/buzz-auth/src/nip98.rs
@@ -161,9 +161,11 @@ pub fn verify_nip98_event(
             )));
         }
     }
-    let payload_tag = event.tags.find(TagKind::Payload).and_then(|t| t.content());
-
-    if let (Some(payload_hex), Some(body_bytes)) = (payload_tag, body) {
+    // Keep a present-but-malformed tag distinct from an absent (optional) tag.
+    if let (Some(payload_tag), Some(body_bytes)) = (event.tags.find(TagKind::Payload), body) {
+        let payload_hex = payload_tag.content().ok_or_else(|| {
+            AuthError::Nip98Invalid("payload tag is missing its SHA-256 hash".to_string())
+        })?;
         let computed: [u8; 32] = Sha256::digest(body_bytes).into();
         let computed_hex = hex::encode(computed);
         if computed_hex != payload_hex {
@@ -313,6 +315,26 @@ mod tests {
         assert!(matches!(result, Err(AuthError::Nip98Invalid(_))));
     }
 
+    #[test]
+    fn payload_tag_without_hash_rejected_with_body() {
+        let keys = Keys::generate();
+        for payload in [vec!["payload"], vec!["payload", ""]] {
+            let json = make_nip98_event_raw_tags(
+                &keys,
+                vec![
+                    nostr::Tag::parse(["u", TEST_URL]).unwrap(),
+                    nostr::Tag::parse(["method", TEST_METHOD]).unwrap(),
+                    nostr::Tag::parse(payload).unwrap(),
+                ],
+            );
+            let result = verify_nip98_event(&json, TEST_URL, TEST_METHOD, Some(b"some body"));
+            assert!(
+                matches!(result, Err(AuthError::Nip98Invalid(_))),
+                "{result:?}"
+            );
+        }
+    }
+
     #[test]
     fn payload_tag_absent_with_body_passes() {
         // Contract: the shared verifier does NOT require a payload tag even when
diff --git a/crates/buzz-cli/README.md b/crates/buzz-cli/README.md
index ef9ce7c7921..85a04b47120 100644
--- a/crates/buzz-cli/README.md
+++ b/crates/buzz-cli/README.md
@@ -168,6 +168,7 @@ stored rules in `validation_error` so an owner can remove and repair them.
 | `repos` | `create` | Announce a git repository (NIP-34) |
 | | `get` | Get a repository announcement |
 | | `list` | List repository announcements |
+| | `default-branch get/set` | Read or select an existing default branch (requires relay support) |
 | | `protect list` | List branch and tag protection rules |
 | | `protect set` | Create or replace a protection rule |
 | | `protect remove` | Remove a protection rule |
@@ -196,3 +197,29 @@ stdout: raw relay JSON
 stderr: {"error": "category", "message": "detail"}
 exit:   0=ok  1=user  2=network  3=auth  4=other  5=write conflict
 ```
+
+
+### Default branch
+
+After deploying relay support, select an existing published branch without
+renaming or deleting any branch:
+
+```bash
+buzz repos default-branch get --owner <owner-hex> --id my-repo
+buzz repos default-branch set --owner <owner-hex> --id my-repo --branch main
+# For an explicitly reviewed version, use the manifest digest returned by get:
+buzz repos default-branch set --owner <owner-hex> --id my-repo --branch main \
+  --expected-manifest <manifest-digest>
+```
+
+`--owner` defaults to the signing identity, not an agent's attested human owner.
+`set` without `--expected-manifest` reads the current version first. Success
+returns `branch`, `head`, `manifest` and `changed`; `get` omits `changed`.
+A stale version returns conflict (exit 5). Ambiguous write failures return
+`delivery_unknown` with `retryable:false` and the original digest: **read before
+retrying**, and do not blindly re-run against a newly fetched version.
+
+The signer must be a current channel member and a repository manager, directly
+or through an unrestricted, valid NIP-OA owner attestation; permission to push is
+not permission to change the default. See the
+[protocol and authorization contract](../../docs/git-on-object-storage.md#default-branch-management).
diff --git a/crates/buzz-cli/src/client.rs b/crates/buzz-cli/src/client.rs
index 75c87aa427f..6ade19f1cad 100644
--- a/crates/buzz-cli/src/client.rs
+++ b/crates/buzz-cli/src/client.rs
@@ -911,6 +911,56 @@ impl BuzzClient {
         .await
     }
 
+    /// Send a state-changing JSON command exactly once. Ambiguous delivery
+    /// never invites an automatic re-run with a newly observed version.
+    pub async fn post_json_once_authed(
+        &self,
+        path: &str,
+        body: &serde_json::Value,
+    ) -> Result<String, CliError> {
+        let url = format!("{}{path}", self.relay_url);
+        let body = serde_json::to_vec(body).map_err(|e| CliError::Other(e.to_string()))?;
+        let auth = sign_nip98(&self.keys, "POST", &url, Some(&body))?;
+        let unknown = |detail: String| CliError::DeliveryUnknown(detail);
+        let http = reqwest::Client::builder()
+            .redirect(reqwest::redirect::Policy::none())
+            .timeout(env_duration_secs("BUZZ_TIMEOUT_SECS", 30))
+            .connect_timeout(env_duration_secs("BUZZ_CONNECT_TIMEOUT_SECS", 15))
+            .build()?;
+        let response = self
+            .with_auth_tag(
+                http.post(&url)
+                    .header("Authorization", auth)
+                    .header("Content-Type", "application/json")
+                    .body(body),
+            )
+            .send()
+            .await
+            .map_err(|e| {
+                if e.is_connect() || e.is_builder() {
+                    CliError::Network(e)
+                } else {
+                    unknown(e.to_string())
+                }
+            })?;
+        let status = response.status();
+        let body = response.text().await.map_err(|e| unknown(e.to_string()))?;
+        let message = extract_relay_message_field(&body).unwrap_or_else(|| body.clone());
+        if status.is_server_error()
+            || status.is_redirection()
+            || (status.as_u16() == 429 && !message.starts_with("rate-limited:"))
+        {
+            return Err(unknown(format!("HTTP {}: {message}", status.as_u16())));
+        }
+        if !status.is_success() {
+            return Err(CliError::Relay {
+                status: status.as_u16(),
+                body: message,
+            });
+        }
+        Ok(body)
+    }
+
     /// Submit a signed Nostr event via POST /events.
     ///
     /// For non-idempotent moderation command kinds (9040–9044), an ambiguous
diff --git a/crates/buzz-cli/src/commands/mod.rs b/crates/buzz-cli/src/commands/mod.rs
index 7ed03f9d060..fed35ec201e 100644
--- a/crates/buzz-cli/src/commands/mod.rs
+++ b/crates/buzz-cli/src/commands/mod.rs
@@ -16,6 +16,7 @@ pub mod pr;
 pub mod project_channel;
 pub mod projects;
 pub mod reactions;
+mod repo_default_branch;
 pub mod repos;
 pub mod social;
 pub mod upload;
diff --git a/crates/buzz-cli/src/commands/repo_default_branch.rs b/crates/buzz-cli/src/commands/repo_default_branch.rs
new file mode 100644
index 00000000000..23aba9f5426
--- /dev/null
+++ b/crates/buzz-cli/src/commands/repo_default_branch.rs
@@ -0,0 +1,314 @@
+//! Thin client for the relay's CAS-backed default-branch operation.
+
+use serde::Deserialize;
+use serde_json::{json, Value};
+
+use crate::{client::BuzzClient, error::CliError, ReposDefaultBranchCmd};
+
+#[derive(Deserialize)]
+struct DefaultBranch {
+    branch: String,
+    head: String,
+    manifest: String,
+}
+
+fn parse_snapshot(raw: &str) -> Result<Value, CliError> {
+    let value: Value = serde_json::from_str(raw).map_err(|_| {
+        CliError::Other("relay did not return default-branch JSON; it may need updating".into())
+    })?;
+    let snapshot: DefaultBranch = serde_json::from_value(value.clone()).map_err(|_| {
+        CliError::Other(
+            "relay response is missing default-branch state; it may need updating".into(),
+        )
+    })?;
+    crate::validate::validate_hex64(&snapshot.manifest)?;
+    if snapshot.branch.is_empty() || snapshot.head != format!("refs/heads/{}", snapshot.branch) {
+        return Err(CliError::Other("relay returned an invalid HEAD".into()));
+    }
+    Ok(value)
+}
+
+fn classify(error: CliError) -> CliError {
+    match error {
+        CliError::Relay { status: 409, body } => CliError::Conflict(body),
+        CliError::Relay { status: 401 | 403, body } => CliError::Auth(body),
+        CliError::Relay { status: 400, body } => CliError::Usage(body),
+        CliError::Relay { status: 404, body } => CliError::NotFound(format!("{body}; check repository access and that this relay supports default-branch management")),
+        other => other,
+    }
+}
+
+pub(super) async fn dispatch(
+    command: ReposDefaultBranchCmd,
+    client: &BuzzClient,
+) -> Result<(), CliError> {
+    let (id, owner, update) = match command {
+        ReposDefaultBranchCmd::Get { id, owner } => (id, owner, None),
+        ReposDefaultBranchCmd::Set {
+            id,
+            owner,
+            branch,
+            expected_manifest,
+        } => (id, owner, Some((branch, expected_manifest))),
+    };
+    crate::validate::validate_repo_id(&id)?;
+    let owner = owner.unwrap_or_else(|| client.keys().public_key().to_hex());
+    crate::validate::validate_hex64(&owner)?;
+    let path = format!("/git/{owner}/{id}/default-branch");
+    let result = match update {
+        None => parse_snapshot(&client.get_authed(&path).await.map_err(classify)?)?,
+        Some((branch, expected)) => {
+            let expected = match expected {
+                Some(digest) => {
+                    crate::validate::validate_hex64(&digest)?;
+                    digest
+                }
+                None => {
+                    let raw = client.get_authed(&path).await.map_err(classify)?;
+                    let snapshot = parse_snapshot(&raw)?;
+                    snapshot["manifest"]
+                        .as_str()
+                        .ok_or_else(|| CliError::Other("missing manifest".into()))?
+                        .to_string()
+                }
+            };
+            let uncertain = |detail: String| {
+                CliError::DeliveryUnknown(format!(
+                "{detail}; attempted branch {branch:?} against manifest {expected}. Read the current default branch before deciding what to do; do not blindly re-run set without --expected-manifest {expected}"
+            ))
+            };
+            let raw = client
+                .post_json_once_authed(
+                    &path,
+                    &json!({"branch": branch, "expected_manifest": expected}),
+                )
+                .await
+                .map_err(|e| match e {
+                    CliError::DeliveryUnknown(detail) => uncertain(detail),
+                    other => classify(other),
+                })?;
+            let result = parse_snapshot(&raw).map_err(|e| uncertain(e.to_string()))?;
+            if !result["changed"].is_boolean() || result["branch"].as_str() != Some(branch.as_str())
+            {
+                return Err(uncertain(
+                    "relay did not confirm the default-branch update".into(),
+                ));
+            }
+            result
+        }
+    };
+    println!("{result}");
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::{
+        body::{Body, Bytes},
+        http::{HeaderMap, Response, StatusCode},
+        routing::get,
+        Router,
+    };
+    use base64::Engine;
+    use clap::Parser;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::{Arc, Mutex};
+
+    #[test]
+    fn default_branch_cli_parses_get_and_set() {
+        for operation in [
+            vec!["get", "--id", "demo"],
+            vec![
+                "set",
+                "--id",
+                "demo",
+                "--branch",
+                "release/v1",
+                "--expected-manifest",
+                &"a".repeat(64),
+            ],
+        ] {
+            let mut args = vec!["buzz", "repos", "default-branch"];
+            args.extend(operation);
+            assert!(crate::Cli::try_parse_from(args).is_ok());
+        }
+        assert!(crate::Cli::try_parse_from([
+            "buzz",
+            "repos",
+            "default-branch",
+            "set",
+            "--id",
+            "demo"
+        ])
+        .is_err());
+    }
+
+    #[tokio::test]
+    async fn default_branch_reads_validate_state_before_any_mutation() {
+        for (branch, head, valid) in [
+            (Some("release/v1"), "refs/heads/release/v1", true),
+            (None, "refs/heads/main", false),
+            (Some("main"), "refs/tags/main", false),
+            (Some("main"), "refs/heads/other", false),
+            (Some(""), "refs/heads/", false),
+        ] {
+            let posts = Arc::new(AtomicUsize::new(0));
+            let post_count = posts.clone();
+            let keys = nostr::Keys::generate();
+            let path = format!("/git/{}/demo/default-branch", keys.public_key().to_hex());
+            let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+            let url = format!("http://{}", listener.local_addr().unwrap());
+            let route = get(move || async move {
+                axum::Json(json!({"branch":branch, "head":head, "manifest":"a".repeat(64)}))
+            })
+            .post(move || {
+                post_count.fetch_add(1, Ordering::SeqCst);
+                async { StatusCode::INTERNAL_SERVER_ERROR }
+            });
+            let app = Router::new().route(&path, route);
+            let server = tokio::spawn(async { axum::serve(listener, app).await.unwrap() });
+            let client = BuzzClient::new(url, keys, None, None).unwrap();
+            let result = dispatch(
+                ReposDefaultBranchCmd::Get {
+                    id: "demo".into(),
+                    owner: None,
+                },
+                &client,
+            )
+            .await;
+            assert_eq!(result.is_ok(), valid, "{branch:?} {head}: {result:?}");
+            if !valid {
+                let error = dispatch(
+                    ReposDefaultBranchCmd::Set {
+                        id: "demo".into(),
+                        owner: None,
+                        branch: "main".into(),
+                        expected_manifest: None,
+                    },
+                    &client,
+                )
+                .await
+                .unwrap_err();
+                assert!(
+                    !matches!(error, CliError::DeliveryUnknown(_)),
+                    "no mutation attempted: {error}"
+                );
+            }
+            assert_eq!(posts.load(Ordering::SeqCst), 0);
+            server.abort();
+        }
+    }
+
+    #[tokio::test]
+    async fn default_branch_command_binds_observed_digest_and_does_not_retry_or_follow_redirects() {
+        let valid = json!({"head":"refs/heads/main", "branch":"main", "manifest":"b".repeat(64), "changed":true});
+        let mut no_op = valid.clone();
+        no_op["changed"] = json!(false);
+        no_op["manifest"] = json!("a".repeat(64));
+        let mut cases = vec![(200u16, valid.clone(), true), (200, no_op, true)];
+        for status in [307, 308, 409, 500, 502, 503, 504] {
+            cases.push((status, json!({"error":"test outcome"}), false));
+        }
+        for (field, value) in [
+            ("branch", None),
+            ("branch", Some(json!(""))),
+            ("head", Some(json!("refs/tags/main"))),
+            ("head", Some(json!("refs/heads/other"))),
+            ("manifest", Some(json!("not-a-digest"))),
+            ("changed", None),
+        ] {
+            let mut invalid = valid.clone();
+            if let Some(value) = value {
+                invalid[field] = value;
+            } else {
+                invalid.as_object_mut().unwrap().remove(field);
+            }
+            cases.push((200, invalid, false));
+        }
+        let mut other_branch = valid;
+        other_branch["branch"] = json!("other");
+        other_branch["head"] = json!("refs/heads/other");
+        cases.push((200, other_branch, false));
+        for (status, reply, success) in cases {
+            let posts = Arc::new(AtomicUsize::new(0));
+            let gets = Arc::new(AtomicUsize::new(0));
+            let captured = Arc::new(Mutex::new(None));
+            let keys = nostr::Keys::generate();
+            let owner = keys.public_key().to_hex();
+            let path = format!("/git/{owner}/demo/default-branch");
+            let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+            let url = format!("http://{}", listener.local_addr().unwrap());
+            let expected_url = format!("{url}{path}");
+            let get_count = gets.clone();
+            let post_count = posts.clone();
+            let capture = captured.clone();
+            let route = get(move || {
+                get_count.fetch_add(1, Ordering::SeqCst);
+                async { axum::Json(json!({"head":"refs/heads/legacy", "branch":"legacy", "manifest":"a".repeat(64)})) }
+            }).post(move |headers: HeaderMap, body: Bytes| {
+                let post_count = post_count.clone();
+                let capture = capture.clone();
+                let expected_url = expected_url.clone();
+                let reply = reply.clone();
+                async move {
+                    post_count.fetch_add(1, Ordering::SeqCst);
+                    let auth = headers["authorization"].to_str().unwrap().strip_prefix("Nostr ").unwrap();
+                    let event = String::from_utf8(base64::engine::general_purpose::STANDARD.decode(auth).unwrap()).unwrap();
+                    let event: nostr::Event = serde_json::from_str(&event).unwrap();
+                    event.verify().unwrap();
+                    assert!(event.tags.iter().any(|t| t.as_slice() == ["u", &expected_url]));
+                    assert!(event.tags.iter().any(|t| t.as_slice() == ["method", "POST"]));
+                    use sha2::Digest;
+                    let digest = hex::encode(sha2::Sha256::digest(&body));
+                    assert!(event.tags.iter().any(|t| t.as_slice() == ["payload", &digest]));
+                    *capture.lock().unwrap() = Some(serde_json::from_slice::<Value>(&body).unwrap());
+                    Response::builder().status(status).header("location", "/redirect-target")
+                        .body(Body::from(reply.to_string())).unwrap()
+                }
+            });
+            let redirected = posts.clone();
+            let app = Router::new().route(&path, route).route(
+                "/redirect-target",
+                axum::routing::post(move || {
+                    redirected.fetch_add(1, Ordering::SeqCst);
+                    async { StatusCode::OK }
+                }),
+            );
+            let server = tokio::spawn(async { axum::serve(listener, app).await.unwrap() });
+            let client = BuzzClient::new(url, keys, None, None).unwrap();
+            let result = crate::commands::repos::dispatch(
+                crate::ReposCmd::DefaultBranch(ReposDefaultBranchCmd::Set {
+                    id: "demo".into(),
+                    owner: None,
+                    branch: "main".into(),
+                    expected_manifest: None,
+                }),
+                &client,
+            )
+            .await;
+            assert_eq!(gets.load(Ordering::SeqCst), 1);
+            assert_eq!(
+                posts.load(Ordering::SeqCst),
+                1,
+                "HTTP {status} must not cause another POST"
+            );
+            assert_eq!(
+                *captured.lock().unwrap(),
+                Some(json!({"branch":"main", "expected_manifest":"a".repeat(64)}))
+            );
+            match status {
+                200 if success => assert!(result.is_ok(), "{result:?}"),
+                409 => assert!(matches!(result, Err(CliError::Conflict(_)))),
+                _ => {
+                    let error = result.unwrap_err();
+                    assert!(matches!(error, CliError::DeliveryUnknown(_)), "{error}");
+                    assert!(!crate::error::is_retryable_error(&error));
+                    assert!(error.to_string().contains(&"a".repeat(64)));
+                    assert!(error.to_string().contains("attempted branch \"main\""));
+                }
+            }
+            server.abort();
+        }
+    }
+}
diff --git a/crates/buzz-cli/src/commands/repos.rs b/crates/buzz-cli/src/commands/repos.rs
index 886d6e04192..3e6b0ac15cf 100644
--- a/crates/buzz-cli/src/commands/repos.rs
+++ b/crates/buzz-cli/src/commands/repos.rs
@@ -442,6 +442,9 @@ pub async fn dispatch(cmd: crate::ReposCmd, client: &BuzzClient) -> Result<(), C
         ReposCmd::Get { id, owner } => cmd_get_repo(client, &id, owner.as_deref()).await,
         ReposCmd::List { owner, limit } => cmd_list_repos(client, owner.as_deref(), limit).await,
         ReposCmd::Bind { id, channel } => cmd_bind_repo(client, &id, &channel).await,
+        ReposCmd::DefaultBranch(command) => {
+            super::repo_default_branch::dispatch(command, client).await
+        }
         ReposCmd::Protect(command) => match command {
             ReposProtectCmd::List { id } => cmd_protect_list(client, &id).await,
             ReposProtectCmd::Set {
diff --git a/crates/buzz-cli/src/lib.rs b/crates/buzz-cli/src/lib.rs
index 3f2bea73979..dfb75e487f0 100644
--- a/crates/buzz-cli/src/lib.rs
+++ b/crates/buzz-cli/src/lib.rs
@@ -1237,6 +1237,38 @@ pub enum ReposCmd {
     /// Manage branch and tag protection rules on one of your repositories.
     #[command(subcommand)]
     Protect(ReposProtectCmd),
+    /// Inspect or change the relay-hosted repository's default branch.
+    #[command(subcommand)]
+    DefaultBranch(ReposDefaultBranchCmd),
+}
+
+/// Commands for the authoritative Git default branch, not announcement metadata.
+#[derive(Subcommand)]
+pub enum ReposDefaultBranchCmd {
+    /// Read the default branch and observed manifest version.
+    Get {
+        /// Repository identifier.
+        #[arg(long)]
+        id: String,
+        /// Repository owner (64-char hex). Defaults to your signing identity.
+        #[arg(long)]
+        owner: Option<String>,
+    },
+    /// Select an existing branch without moving or deleting any refs.
+    Set {
+        /// Repository identifier.
+        #[arg(long)]
+        id: String,
+        /// Repository owner (64-char hex). Defaults to your signing identity.
+        #[arg(long)]
+        owner: Option<String>,
+        /// Short branch name, e.g. main or release/v1 (not refs/heads/main).
+        #[arg(long)]
+        branch: String,
+        /// Manifest digest returned by get. Omit to read it before updating.
+        #[arg(long)]
+        expected_manifest: Option<String>,
+    },
 }
 
 /// Commands for inspecting and changing repository protection rules.
@@ -2399,12 +2431,13 @@ mod tests {
         );
         assert_eq!(
             names(&cmd, "repos"),
-            vec!["bind", "create", "get", "list", "protect"]
+            vec!["bind", "create", "default-branch", "get", "list", "protect"]
         );
         let repos = cmd
             .get_subcommands()
             .find(|subcommand| subcommand.get_name() == "repos")
             .expect("repos command");
+        assert_eq!(names(repos, "default-branch"), vec!["get", "set"]);
         let protect = repos
             .get_subcommands()
             .find(|subcommand| subcommand.get_name() == "protect")
@@ -2476,7 +2509,7 @@ mod tests {
             ("pr", 5),
             ("projects", 8),
             ("reactions", 3),
-            ("repos", 5),
+            ("repos", 6),
             ("social", 7),
             ("upload", 1),
             ("users", 5),
diff --git a/crates/buzz-relay/src/api/git/hydrate.rs b/crates/buzz-relay/src/api/git/hydrate.rs
index 3ce809d18f7..080bbd5c1cc 100644
--- a/crates/buzz-relay/src/api/git/hydrate.rs
+++ b/crates/buzz-relay/src/api/git/hydrate.rs
@@ -243,7 +243,7 @@ pub async fn hydrate_for_write(
 ///
 /// `Ok(None)` if the pointer is absent (caller decides 404 vs first-push
 /// per call site). `Err(_)` on any below-pointer failure.
-async fn load_pointer(
+pub(super) async fn load_pointer(
     store: &GitStore,
     ctx: &TenantContext,
     owner: &str,
diff --git a/crates/buzz-relay/src/api/git/mod.rs b/crates/buzz-relay/src/api/git/mod.rs
index dd69d7dc36e..1db75ce39c5 100644
--- a/crates/buzz-relay/src/api/git/mod.rs
+++ b/crates/buzz-relay/src/api/git/mod.rs
@@ -30,6 +30,7 @@ pub mod manifest;
 pub mod manifest_event;
 pub mod pack_cache;
 pub mod policy;
+mod settings;
 pub mod store;
 pub mod transport;
 
diff --git a/crates/buzz-relay/src/api/git/settings.rs b/crates/buzz-relay/src/api/git/settings.rs
new file mode 100644
index 00000000000..2e1f99811f6
--- /dev/null
+++ b/crates/buzz-relay/src/api/git/settings.rs
@@ -0,0 +1,418 @@
+//! Default-branch management of the authoritative Git manifest.
+//!
+//! This is a Git control-plane operation, not a replaceable announcement:
+//! the pointer CAS is the commit point, shared with receive-pack. A separate
+//! strict NIP-98 request prevents reusable Smart HTTP credentials authorizing
+//! metadata changes (URL, method, payload and replay are all checked).
+
+use std::sync::Arc;
+
+use axum::{
+    body::Bytes,
+    extract::{DefaultBodyLimit, Path, State},
+    http::{header, HeaderMap, StatusCode},
+    response::{IntoResponse, Response},
+    routing::get,
+    Json, Router,
+};
+use buzz_core::TenantContext;
+use serde::Deserialize;
+use serde_json::{json, Value};
+
+use super::{
+    binding::{resolve_repo_binding, RepoBinding},
+    hydrate::load_pointer,
+    manifest::{is_safe_refname, pointer_key, Manifest},
+    manifest_event::{build_ref_state_event, RefStateInputs},
+    store::{CasOutcome, ETag, GitStore, Precond},
+    transport::{authorize_git_read, deny_banned_git_principal, validate_repo_id},
+};
+use crate::{
+    api::{api_error, bridge, relay_members},
+    state::AppState,
+};
+
+fn error(status: StatusCode, message: &str) -> Response {
+    api_error(status, message).into_response()
+}
+
+fn backend(error: impl std::fmt::Display) -> Response {
+    tracing::error!(%error, "git settings backend failure");
+    self::error(
+        StatusCode::INTERNAL_SERVER_ERROR,
+        "git settings backend unavailable; read the default branch before retrying",
+    )
+}
+
+fn conflict() -> Response {
+    error(
+        StatusCode::CONFLICT,
+        "repository changed concurrently; read the latest manifest and retry",
+    )
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct SetDefaultBranch {
+    branch: String,
+    expected_manifest: String,
+}
+
+/// A loaded snapshot cannot be rebound to another pointer or refreshed at CAS.
+struct DefaultBranchSnapshot {
+    pointer: String,
+    etag: ETag,
+    digest: String,
+    manifest: Manifest,
+}
+
+impl DefaultBranchSnapshot {
+    async fn load(
+        store: &GitStore,
+        tenant: &TenantContext,
+        owner: &str,
+        repo: &str,
+    ) -> Result<Self, Response> {
+        let (etag, digest, manifest) = load_pointer(store, tenant, owner, repo)
+            .await
+            .map_err(backend)?
+            .ok_or_else(|| {
+                error(
+                    StatusCode::NOT_FOUND,
+                    "repository has no published Git state; push a branch first",
+                )
+            })?;
+        Ok(Self {
+            pointer: pointer_key(tenant.community(), owner, repo),
+            etag,
+            digest,
+            manifest,
+        })
+    }
+
+    fn response(&self) -> Value {
+        json!({"branch": self.manifest.head.strip_prefix("refs/heads/"), "head": self.manifest.head, "manifest": self.digest})
+    }
+
+    async fn set(
+        mut self,
+        store: &GitStore,
+        request: SetDefaultBranch,
+    ) -> Result<(Self, bool), Response> {
+        if self.digest != request.expected_manifest {
+            return Err(conflict());
+        }
+        let head = format!("refs/heads/{}", request.branch);
+        if request.branch.is_empty()
+            || request.branch.len() > 1024
+            || request.branch.starts_with('-')
+            || !is_safe_refname(&head)
+            || request.branch.ends_with('.')
+            || request
+                .branch
+                .split('/')
+                .any(|part| part.starts_with('.') || part.ends_with(".lock"))
+        {
+            return Err(error(
+                StatusCode::BAD_REQUEST,
+                "invalid branch name; use a short branch name such as main or release/v1",
+            ));
+        }
+        if !self.manifest.refs.contains_key(&head) {
+            return Err(error(
+                StatusCode::BAD_REQUEST,
+                "default branch must name an existing published branch",
+            ));
+        }
+        let changed = self.manifest.head != head;
+        if changed {
+            self.manifest.head = head;
+            self.manifest.parent = Some(self.digest.clone());
+            self.manifest.validate().map_err(backend)?;
+            let bytes = self.manifest.canonical_bytes().map_err(backend)?;
+            let key = store.put_manifest(&bytes).await.map_err(backend)?;
+            self.digest = key
+                .strip_prefix("manifests/")
+                .ok_or_else(|| backend("invalid manifest key"))?
+                .to_string();
+        }
+        // Even a no-op checks the observed ETag: concurrent deletion/push must
+        // not be reported as a successful setting of a now-missing branch.
+        match store
+            .put_pointer(
+                &self.pointer,
+                self.digest.as_bytes(),
+                Precond::IfMatch(self.etag.clone()),
+            )
+            .await
+            .map_err(backend)?
+        {
+            CasOutcome::Won(etag) => self.etag = etag,
+            CasOutcome::LostRace => return Err(conflict()),
+        }
+        Ok((self, changed))
+    }
+}
+
+struct SettingsAuth {
+    tenant: TenantContext,
+    caller: nostr::PublicKey,
+    delegated_owner: Option<nostr::PublicKey>,
+}
+
+async fn authenticate(
+    state: &Arc<AppState>,
+    headers: &HeaderMap,
+    path: &str,
+    body: Option<&[u8]>,
+) -> Result<SettingsAuth, Response> {
+    let host = headers
+        .get(header::HOST)
+        .and_then(|h| h.to_str().ok())
+        .unwrap_or("");
+    let tenant = crate::tenant::bind_community(&state.db, host)
+        .await
+        .map_err(|_| error(StatusCode::NOT_FOUND, "repository not found"))?;
+    let url = bridge::nip98_expected_url(&state.config.relay_url, &tenant, path);
+    let auth = bridge::verify_bridge_auth_with_options(
+        headers,
+        if body.is_some() { "POST" } else { "GET" },
+        &url,
+        body,
+        true,
+        body.is_some(),
+    )
+    .map_err(IntoResponse::into_response)?;
+    bridge::enforce_http_admission(state, &tenant, &auth.pubkey)
+        .await
+        .map_err(IntoResponse::into_response)?;
+    bridge::check_nip98_replay(state, &tenant, auth.event_id_bytes)
+        .await
+        .map_err(IntoResponse::into_response)?;
+    let tag = relay_members::extract_auth_tag_header(headers);
+    relay_members::enforce_relay_membership(
+        state,
+        tenant.community(),
+        auth.pubkey.as_bytes(),
+        tag,
+        auth.signed_created_at,
+    )
+    .await
+    .map_err(IntoResponse::into_response)?;
+    deny_banned_git_principal(
+        &state.db,
+        tenant.community(),
+        &auth.pubkey,
+        tag,
+        auth.signed_created_at,
+    )
+    .await?;
+    // Admission ignores kind= restrictions by design (NIP-AA). Repository
+    // management must not turn a message-only credential into write authority.
+    // This HTTP operation has no event kind: only kind-unrestricted credentials
+    // may inherit management authority. Temporal clauses are still enforced.
+    let delegated_owner = tag
+        .filter(|tag| {
+            serde_json::from_str::<Vec<String>>(tag)
+                .ok()
+                .and_then(|parts| parts.get(2).cloned())
+                .is_some_and(|conditions| {
+                    !conditions
+                        .split('&')
+                        .any(|clause| clause.starts_with("kind="))
+                })
+        })
+        .and_then(|tag| {
+            relay_members::extract_nip_oa_owner(
+                auth.pubkey.as_bytes(),
+                Some(tag),
+                auth.signed_created_at,
+            )
+        });
+    Ok(SettingsAuth {
+        tenant,
+        caller: auth.pubkey,
+        delegated_owner,
+    })
+}
+
+async fn authorize_management(
+    state: &AppState,
+    auth: &SettingsAuth,
+    repo: &nostr::Event,
+) -> Result<(), Response> {
+    let RepoBinding::Bound(channel) = resolve_repo_binding(repo) else {
+        return Err(error(StatusCode::NOT_FOUND, "repository not found"));
+    };
+    let community = auth.tenant.community();
+    let bound = state
+        .db
+        .get_channel(community, channel)
+        .await
+        .map_err(backend)?;
+    if bound.archived_at.is_some() {
+        return Err(error(
+            StatusCode::FORBIDDEN,
+            "channel is archived (read-only)",
+        ));
+    }
+    let named_manager = |key: &nostr::PublicKey| {
+        *key == repo.pubkey
+            || repo.tags.iter().any(|tag| {
+                let values = tag.as_slice();
+                values.first().is_some_and(|name| name == "maintainers")
+                    && values
+                        .iter()
+                        .skip(1)
+                        .any(|value| nostr::PublicKey::parse(value).ok().as_ref() == Some(key))
+            })
+    };
+    // Direct authority is independent of an optional owner credential.
+    if named_manager(&auth.caller)
+        || state
+            .db
+            .is_agent_owner(community, repo.pubkey.as_bytes(), auth.caller.as_bytes())
+            .await
+            .map_err(backend)?
+    {
+        return Ok(());
+    }
+    if let Some(principal) = &auth.delegated_owner {
+        let role = state
+            .db
+            .get_member_role(community, channel, principal.as_bytes())
+            .await
+            .map_err(backend)?;
+        if role.is_some_and(|r| r.parse::<buzz_core::channel::MemberRole>().is_ok())
+            && (named_manager(principal)
+                || state
+                    .db
+                    .is_agent_owner(community, repo.pubkey.as_bytes(), principal.as_bytes())
+                    .await
+                    .map_err(backend)?)
+        {
+            return Ok(());
+        }
+    }
+    Err(error(
+        StatusCode::FORBIDDEN,
+        "only the repository owner or a named maintainer may change its default branch",
+    ))
+}
+
+async fn get_default_branch(
+    State(state): State<Arc<AppState>>,
+    Path((owner, repo)): Path<(String, String)>,
+    headers: HeaderMap,
+) -> Result<Json<Value>, Response> {
+    let path = format!("/git/{owner}/{repo}/default-branch");
+    let repo_name = validate_repo_id(&owner, &repo)?;
+    let auth = authenticate(&state, &headers, &path, None).await?;
+    authorize_git_read(
+        &state.db,
+        auth.tenant.community(),
+        &auth.caller,
+        &owner,
+        repo_name,
+    )
+    .await?;
+    let snapshot =
+        DefaultBranchSnapshot::load(&state.git_store, &auth.tenant, &owner, repo_name).await?;
+    Ok(Json(snapshot.response()))
+}
+
+async fn set_default_branch(
+    State(state): State<Arc<AppState>>,
+    Path((owner, repo)): Path<(String, String)>,
+    headers: HeaderMap,
+    body: Bytes,
+) -> Result<Json<Value>, Response> {
+    let path = format!("/git/{owner}/{repo}/default-branch");
+    let repo_name = validate_repo_id(&owner, &repo)?;
+    let auth = authenticate(&state, &headers, &path, Some(&body)).await?;
+    let announcement = authorize_git_read(
+        &state.db,
+        auth.tenant.community(),
+        &auth.caller,
+        &owner,
+        repo_name,
+    )
+    .await?;
+    authorize_management(&state, &auth, &announcement).await?;
+    let request: SetDefaultBranch = serde_json::from_slice(&body).map_err(|_| {
+        error(
+            StatusCode::BAD_REQUEST,
+            "expected branch and expected_manifest strings",
+        )
+    })?;
+    let snapshot =
+        DefaultBranchSnapshot::load(&state.git_store, &auth.tenant, &owner, repo_name).await?;
+    let serving_write = buzz_deletion::acquire_serving_write(
+        &state.db,
+        auth.tenant.community(),
+        "git_default_branch",
+    )
+    .await
+    .map_err(|_| {
+        error(
+            StatusCode::SERVICE_UNAVAILABLE,
+            "community writes are fenced",
+        )
+    })?;
+    serving_write.verify().await.map_err(backend)?;
+    let (snapshot, changed) = serving_write
+        .protect(snapshot.set(&state.git_store, request))
+        .await
+        .map_err(backend)??;
+    let publication = async {
+        if changed {
+            let actor = auth.caller.to_hex();
+            let event = build_ref_state_event(
+                &RefStateInputs {
+                    repo_id: repo_name,
+                    head: &snapshot.manifest.head,
+                    refs: &snapshot.manifest.refs,
+                    actor_pubkey_hex: &actor,
+                },
+                &state.relay_keypair,
+            )
+            .map_err(backend)?;
+            let (stored, inserted) = state
+                .db
+                .insert_event_with_serving_write_guard(serving_write.lease(), &event, None)
+                .await
+                .map_err(backend)?;
+            if inserted {
+                crate::handlers::event::fan_out_event_to_local_subscribers(
+                    &state,
+                    auth.tenant.community(),
+                    &stored,
+                )
+                .await;
+            }
+        }
+        Ok::<(), Response>(())
+    }
+    .await;
+    serving_write.finish().await.map_err(backend)?;
+    // Publication failure is not mistaken for a rolled-back manifest.
+    if publication.is_err() {
+        return Err(error(StatusCode::INTERNAL_SERVER_ERROR, "default branch committed but notification failed; read the current default branch before retrying"));
+    }
+    let mut response = snapshot.response();
+    response["changed"] = json!(changed);
+    Ok(Json(response))
+}
+
+pub(super) fn router() -> Router<Arc<AppState>> {
+    Router::new()
+        .route(
+            "/git/{owner}/{repo}/default-branch",
+            get(get_default_branch).post(set_default_branch),
+        )
+        .layer(DefaultBodyLimit::max(4096))
+}
+
+#[cfg(test)]
+#[path = "settings_tests.rs"]
+mod tests;
diff --git a/crates/buzz-relay/src/api/git/settings_tests.rs b/crates/buzz-relay/src/api/git/settings_tests.rs
new file mode 100644
index 00000000000..55c04dddcf7
--- /dev/null
+++ b/crates/buzz-relay/src/api/git/settings_tests.rs
@@ -0,0 +1,880 @@
+//! Live route/store/clone regressions. Require explicit isolated service URLs;
+//! never fall back to a developer's Desktop database.
+
+mod external_infra {
+    use super::super::*;
+    use axum::{
+        body::{to_bytes, Body},
+        http::Request,
+    };
+    use base64::Engine;
+    use buzz_core::channel::MemberRole;
+    use nostr::{EventBuilder, Keys, Kind, Tag};
+    use sha2::{Digest, Sha256};
+    use tower::ServiceExt;
+
+    struct Fixture {
+        state: Arc<AppState>,
+        pool: sqlx::PgPool,
+        tenant: TenantContext,
+        owner: Keys,
+        member: Keys,
+        maintainer: Keys,
+        channel: uuid::Uuid,
+        repo: String,
+        scratch: tempfile::TempDir,
+    }
+
+    impl Fixture {
+        async fn new() -> Self {
+            let database_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+                .expect("explicit isolated BUZZ_TEST_DATABASE_URL");
+            let redis_url = std::env::var("BUZZ_TEST_REDIS_URL")
+                .expect("explicit isolated BUZZ_TEST_REDIS_URL");
+            let endpoint = std::env::var("BUZZ_TEST_S3_ENDPOINT")
+                .expect("explicit isolated BUZZ_TEST_S3_ENDPOINT");
+            let scratch = tempfile::tempdir().unwrap();
+            let mut config = crate::config::Config::from_env().unwrap();
+            config.database_url = database_url;
+            config.redis_url = redis_url;
+            config.relay_url = "ws://127.0.0.1".into();
+            config.require_relay_membership = false;
+            config.git_repo_path = scratch.path().to_path_buf();
+            config.git_pack_cache_path = scratch.path().join("cache");
+            config.media.s3_endpoint = endpoint;
+            config.media.s3_bucket =
+                std::env::var("BUZZ_TEST_S3_BUCKET").unwrap_or_else(|_| "buzz-git".into());
+            config.media.s3_access_key = "buzz_dev".into();
+            config.media.s3_secret_key = "buzz_dev_secret".into();
+            let pool = sqlx::PgPool::connect(&config.database_url).await.unwrap();
+            let db = buzz_db::Db::from_pool(pool.clone());
+            // CI provisions schema/schema.sql with pgschema before this suite.
+            // Only migration-backed local fixtures own the migration lifecycle.
+            if std::env::var("BUZZ_TEST_SCHEMA_MODE").as_deref() != Ok("desired") {
+                db.migrate().await.unwrap();
+            }
+            let redis_pool = deadpool_redis::Config::from_url(&config.redis_url)
+                .create_pool(Some(deadpool_redis::Runtime::Tokio1))
+                .unwrap();
+            let pubsub = Arc::new(
+                buzz_pubsub::PubSubManager::new(&config.redis_url, redis_pool.clone())
+                    .await
+                    .unwrap(),
+            );
+            let audit = buzz_audit::AuditService::new(pool.clone());
+            let auth = buzz_auth::AuthService::new(config.auth.clone());
+            let search = buzz_search::SearchService::new(pool.clone());
+            let workflow = Arc::new(buzz_workflow::WorkflowEngine::new(
+                db.clone(),
+                buzz_workflow::WorkflowConfig::default(),
+            ));
+            let media = buzz_media::MediaStorage::new(&config.media).unwrap();
+            let (state, _) = AppState::new(
+                config,
+                db,
+                redis_pool,
+                audit,
+                pubsub,
+                auth,
+                search,
+                workflow,
+                Keys::generate(),
+                media,
+            );
+            let state = Arc::new(state);
+            let host = format!("settings-{}.example", uuid::Uuid::new_v4().simple());
+            let community = state
+                .db
+                .ensure_configured_community(&host)
+                .await
+                .unwrap()
+                .id;
+            let tenant = TenantContext::resolved(community, &host);
+            let owner = Keys::generate();
+            let member = Keys::generate();
+            let maintainer = Keys::generate();
+            let channel = uuid::Uuid::new_v4();
+            state
+                .db
+                .ensure_user(community, owner.public_key().as_bytes())
+                .await
+                .unwrap();
+            state
+                .db
+                .create_channel_with_id(
+                    community,
+                    channel,
+                    &format!("settings-{channel}"),
+                    buzz_db::channel::ChannelType::Stream,
+                    buzz_db::channel::ChannelVisibility::Open,
+                    None,
+                    owner.public_key().as_bytes(),
+                    None,
+                )
+                .await
+                .unwrap();
+            for (key, role) in [
+                (&member, MemberRole::Admin),
+                (&maintainer, MemberRole::Member),
+                (&owner, MemberRole::Owner),
+            ] {
+                state
+                    .db
+                    .ensure_user(community, key.public_key().as_bytes())
+                    .await
+                    .unwrap();
+                state
+                    .db
+                    .add_member(
+                        community,
+                        channel,
+                        key.public_key().as_bytes(),
+                        role,
+                        Some(owner.public_key().as_bytes()),
+                    )
+                    .await
+                    .unwrap();
+            }
+            let repo = format!("repo-{}", uuid::Uuid::new_v4().simple());
+            let announcement = EventBuilder::new(Kind::Custom(30617), "")
+                .tags([
+                    Tag::parse(["d", &repo]).unwrap(),
+                    Tag::parse(["buzz-channel", &channel.to_string()]).unwrap(),
+                    Tag::parse(["maintainers", &maintainer.public_key().to_hex()]).unwrap(),
+                ])
+                .sign_with_keys(&owner)
+                .unwrap();
+            state
+                .db
+                .insert_event(community, &announcement, None)
+                .await
+                .unwrap();
+            let f = Self {
+                state,
+                pool,
+                tenant,
+                owner,
+                member,
+                maintainer,
+                channel,
+                repo,
+                scratch,
+            };
+            f.seed_git().await;
+            f
+        }
+
+        fn path(&self) -> String {
+            format!(
+                "/git/{}/{}/default-branch",
+                self.owner.public_key().to_hex(),
+                self.repo
+            )
+        }
+
+        async fn snapshot(&self) -> DefaultBranchSnapshot {
+            DefaultBranchSnapshot::load(
+                &self.state.git_store,
+                &self.tenant,
+                &self.owner.public_key().to_hex(),
+                &self.repo,
+            )
+            .await
+            .unwrap()
+        }
+
+        async fn seed_git(&self) {
+            let source = self.scratch.path().join("source");
+            std::fs::create_dir(&source).unwrap();
+            git(&source, &["init", "--initial-branch=legacy"]).await;
+            git(&source, &["config", "user.name", "Git settings test"]).await;
+            git(
+                &source,
+                &["config", "user.email", "git-settings@example.invalid"],
+            )
+            .await;
+            git(&source, &["commit", "--allow-empty", "-m", "legacy"]).await;
+            git(&source, &["branch", "main"]).await;
+            git(&source, &["checkout", "main"]).await;
+            std::fs::write(source.join("main.txt"), b"selected branch\n").unwrap();
+            git(&source, &["add", "main.txt"]).await;
+            git(&source, &["commit", "-m", "main"]).await;
+            git(&source, &["checkout", "legacy"]).await;
+            super::super::super::cas_publish::cas_publish(
+                &self.state.git_store,
+                &self.tenant,
+                &source,
+                &self.owner.public_key().to_hex(),
+                &self.repo,
+                &super::super::super::cas_publish::ParentState::fresh(),
+                limits(0),
+            )
+            .await
+            .unwrap();
+        }
+
+        async fn call(
+            &self,
+            key: &Keys,
+            body: Option<Value>,
+            tag: Option<&str>,
+        ) -> (StatusCode, Value) {
+            let body = body.map(|value| value.to_string());
+            let method = if body.is_some() { "POST" } else { "GET" };
+            let path = self.path();
+            let token = token(
+                key,
+                method,
+                &format!("http://{}{path}", self.tenant.host()),
+                body.as_deref(),
+            );
+            let mut request = Request::builder()
+                .method(method)
+                .uri(&path)
+                .header("host", self.tenant.host())
+                .header("authorization", token);
+            if let Some(tag) = tag {
+                request = request.header("x-auth-tag", tag);
+            }
+            let request = request.body(Body::from(body.unwrap_or_default())).unwrap();
+            response(
+                super::super::super::transport::git_router(self.state.clone())
+                    .oneshot(request)
+                    .await
+                    .unwrap(),
+            )
+            .await
+        }
+
+        async fn set(&self, key: &Keys, branch: &str, tag: Option<&str>) -> (StatusCode, Value) {
+            let digest = self.snapshot().await.digest;
+            self.call(
+                key,
+                Some(json!({"branch": branch, "expected_manifest": digest})),
+                tag,
+            )
+            .await
+        }
+
+        async fn add(&self, key: &Keys) {
+            self.state
+                .db
+                .ensure_user(self.tenant.community(), key.public_key().as_bytes())
+                .await
+                .unwrap();
+            self.state
+                .db
+                .add_member(
+                    self.tenant.community(),
+                    self.channel,
+                    key.public_key().as_bytes(),
+                    MemberRole::Bot,
+                    Some(self.owner.public_key().as_bytes()),
+                )
+                .await
+                .unwrap();
+        }
+    }
+
+    fn limits(parent_hydrated_bytes: u64) -> super::super::super::cas_publish::PublishLimits {
+        super::super::super::cas_publish::PublishLimits {
+            parent_hydrated_bytes,
+            max_pack_bytes: 1024 * 1024,
+            max_repo_bytes: 2 * 1024 * 1024,
+        }
+    }
+
+    async fn git(path: &std::path::Path, args: &[&str]) -> String {
+        let mut command = tokio::process::Command::new("git");
+        command.current_dir(path).args(args);
+        super::super::super::transport::harden_git_env(&mut command);
+        let result = command.output().await.unwrap();
+        assert!(
+            result.status.success(),
+            "git {args:?}: {}",
+            String::from_utf8_lossy(&result.stderr)
+        );
+        String::from_utf8(result.stdout).unwrap()
+    }
+
+    fn token(keys: &Keys, method: &str, url: &str, body: Option<&str>) -> String {
+        token_with_payload(
+            keys,
+            method,
+            url,
+            body.map(|body| Tag::parse(["payload", &hex::encode(Sha256::digest(body))]).unwrap()),
+        )
+    }
+
+    fn token_with_payload(keys: &Keys, method: &str, url: &str, payload: Option<Tag>) -> String {
+        let mut tags = vec![
+            Tag::parse(["u", url]).unwrap(),
+            Tag::parse(["method", method]).unwrap(),
+            Tag::parse(["nonce", &uuid::Uuid::new_v4().to_string()]).unwrap(),
+        ];
+        if let Some(payload) = payload {
+            tags.push(payload);
+        }
+        let event = EventBuilder::new(Kind::Custom(27235), "")
+            .tags(tags)
+            .sign_with_keys(keys)
+            .unwrap();
+        format!(
+            "Nostr {}",
+            base64::engine::general_purpose::STANDARD.encode(serde_json::to_vec(&event).unwrap())
+        )
+    }
+
+    async fn response(response: Response) -> (StatusCode, Value) {
+        let status = response.status();
+        let bytes = to_bytes(response.into_body(), 1024 * 1024).await.unwrap();
+        (
+            status,
+            serde_json::from_slice(&bytes)
+                .unwrap_or_else(|_| json!({"error": String::from_utf8_lossy(&bytes)})),
+        )
+    }
+
+    #[tokio::test]
+    #[ignore = "requires isolated Postgres, Redis and MinIO"]
+    async fn default_branch_route_permissions_and_protocol() {
+        let f = Fixture::new().await;
+        let before = f.snapshot().await;
+        assert_eq!(
+            f.call(&f.member, None, None).await.1["head"],
+            "refs/heads/legacy"
+        );
+        assert_eq!(
+            f.set(&f.member, "main", None).await.0,
+            StatusCode::FORBIDDEN,
+            "push-capable channel admin is not a repo manager"
+        );
+        assert_eq!(
+            f.set(&Keys::generate(), "main", None).await.0,
+            StatusCode::NOT_FOUND
+        );
+        for branch in [
+            "",
+            "absent",
+            "../main",
+            "refs/heads/main",
+            "main.lock",
+            "bad\nref",
+            "main/",
+            "-main",
+            ".main",
+        ] {
+            assert_eq!(
+                f.set(&f.owner, branch, None).await.0,
+                StatusCode::BAD_REQUEST,
+                "{branch:?}"
+            );
+        }
+        assert_eq!(
+            f.snapshot().await.digest,
+            before.digest,
+            "denials do not write"
+        );
+        let result = f.set(&f.maintainer, "main", None).await;
+        assert_eq!(result.0, StatusCode::OK, "{result:?}");
+        assert_eq!(result.1["changed"], true);
+        let after = f.snapshot().await;
+        assert_eq!(after.manifest.head, "refs/heads/main");
+        assert_eq!(after.manifest.refs, before.manifest.refs);
+        assert_eq!(after.manifest.packs, before.manifest.packs);
+        assert_eq!(after.manifest.parent.as_ref(), Some(&before.digest));
+        let result = f.set(&f.owner, "main", None).await;
+        assert_eq!(result.0, StatusCode::OK);
+        assert_eq!(result.1["changed"], false);
+        assert_eq!(f.snapshot().await.digest, after.digest);
+        assert_eq!(
+            f.call(
+                &f.owner,
+                Some(json!({"branch":"legacy", "expected_manifest": before.digest})),
+                None
+            )
+            .await
+            .0,
+            StatusCode::CONFLICT
+        );
+        let notification_query = buzz_db::EventQuery {
+            kinds: Some(vec![30618]),
+            d_tag: Some(f.repo.clone()),
+            global_only: true,
+            ..buzz_db::EventQuery::for_community(f.tenant.community())
+        };
+        let events = f.state.db.query_events(&notification_query).await.unwrap();
+        let event_ids: Vec<_> = events.iter().map(|e| e.event.id).collect();
+        assert!(
+            events.iter().any(|e| e
+                .event
+                .tags
+                .iter()
+                .any(|t| t.as_slice() == ["HEAD", "ref: refs/heads/main"])),
+            "committed default notification: {events:?}"
+        );
+
+        // Strict credentials: each mutated property must be rejected at the real route.
+        let body = json!({"branch":"legacy", "expected_manifest": after.digest}).to_string();
+        let path = f.path();
+        let url = format!("http://{}{path}", f.tenant.host());
+        let requests = [
+            token_with_payload(
+                &f.owner,
+                "POST",
+                &url,
+                Some(Tag::parse(["payload"]).unwrap()),
+            ),
+            token_with_payload(
+                &f.owner,
+                "POST",
+                &url,
+                Some(Tag::parse(["payload", ""]).unwrap()),
+            ),
+            token(&f.owner, "GET", &url, Some(&body)),
+            token(&f.owner, "POST", &url, None),
+            token(&f.owner, "POST", &url, Some("{}")),
+            token(
+                &f.owner,
+                "POST",
+                &url.replace(f.tenant.host(), "other.example"),
+                Some(&body),
+            ),
+            token(
+                &f.owner,
+                "GET",
+                url.trim_end_matches("/default-branch"),
+                None,
+            ),
+        ];
+        for token in requests {
+            let request = Request::builder()
+                .method("POST")
+                .uri(&path)
+                .header("host", f.tenant.host())
+                .header("authorization", token)
+                .body(Body::from(body.clone()))
+                .unwrap();
+            let status = super::super::super::transport::git_router(f.state.clone())
+                .oneshot(request)
+                .await
+                .unwrap()
+                .status();
+            assert_eq!(status, StatusCode::UNAUTHORIZED);
+            assert_eq!(
+                f.snapshot().await.digest,
+                after.digest,
+                "auth denial changed pointer"
+            );
+            let denied_events = f.state.db.query_events(&notification_query).await.unwrap();
+            assert_eq!(
+                denied_events.iter().map(|e| e.event.id).collect::<Vec<_>>(),
+                event_ids,
+                "auth denial published kind:30618"
+            );
+        }
+        let reusable = token(&f.owner, "GET", &url, None);
+        for expected in [StatusCode::OK, StatusCode::UNAUTHORIZED] {
+            let request = Request::builder()
+                .uri(&path)
+                .header("host", f.tenant.host())
+                .header("authorization", &reusable)
+                .body(Body::empty())
+                .unwrap();
+            assert_eq!(
+                super::super::super::transport::git_router(f.state.clone())
+                    .oneshot(request)
+                    .await
+                    .unwrap()
+                    .status(),
+                expected
+            );
+        }
+        let other_host = format!("other-{}.example", uuid::Uuid::new_v4());
+        f.state
+            .db
+            .ensure_configured_community(&other_host)
+            .await
+            .unwrap();
+        let token = token(&f.owner, "GET", &format!("http://{other_host}{path}"), None);
+        let request = Request::builder()
+            .uri(&path)
+            .header("host", &other_host)
+            .header("authorization", token)
+            .body(Body::empty())
+            .unwrap();
+        assert_eq!(
+            super::super::super::transport::git_router(f.state.clone())
+                .oneshot(request)
+                .await
+                .unwrap()
+                .status(),
+            StatusCode::NOT_FOUND
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires isolated Postgres, Redis and MinIO"]
+    async fn default_branch_delegation_and_revocation() {
+        let f = Fixture::new().await;
+        let agent = Keys::generate();
+        f.add(&agent).await;
+        let tag = buzz_sdk::nip_oa::compute_auth_tag(&f.owner, &agent.public_key(), "").unwrap();
+        assert_eq!(f.set(&agent, "main", None).await.0, StatusCode::FORBIDDEN);
+        let limited =
+            buzz_sdk::nip_oa::compute_auth_tag(&f.owner, &agent.public_key(), "kind=1").unwrap();
+        assert_eq!(
+            f.set(&agent, "main", Some(&limited)).await.0,
+            StatusCode::FORBIDDEN
+        );
+        let expired =
+            buzz_sdk::nip_oa::compute_auth_tag(&f.owner, &agent.public_key(), "created_at<1")
+                .unwrap();
+        assert_eq!(
+            f.set(&agent, "main", Some(&expired)).await.0,
+            StatusCode::FORBIDDEN
+        );
+        assert_eq!(f.set(&agent, "main", Some(&tag)).await.0, StatusCode::OK);
+        // Optional credential does not take direct authority away.
+        let absent_owner = Keys::generate();
+        let own_tag =
+            buzz_sdk::nip_oa::compute_auth_tag(&absent_owner, &f.owner.public_key(), "").unwrap();
+        assert_eq!(
+            f.set(&f.owner, "legacy", Some(&own_tag)).await.0,
+            StatusCode::OK
+        );
+        // A human can administer a repository announced by their managed agent.
+        f.state
+            .db
+            .set_agent_owner(
+                f.tenant.community(),
+                f.owner.public_key().as_bytes(),
+                f.member.public_key().as_bytes(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(f.set(&f.member, "main", None).await.0, StatusCode::OK);
+        f.state
+            .db
+            .add_member(
+                f.tenant.community(),
+                f.channel,
+                f.maintainer.public_key().as_bytes(),
+                MemberRole::Owner,
+                Some(f.owner.public_key().as_bytes()),
+            )
+            .await
+            .unwrap();
+        f.state
+            .db
+            .remove_member(
+                f.tenant.community(),
+                f.channel,
+                f.owner.public_key().as_bytes(),
+                f.owner.public_key().as_bytes(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(
+            f.set(&agent, "legacy", Some(&tag)).await.0,
+            StatusCode::FORBIDDEN
+        );
+        assert_eq!(
+            f.set(&f.owner, "legacy", None).await.0,
+            StatusCode::NOT_FOUND
+        );
+        // Durable ban cascades even when the signer has independent maintainer rights.
+        let ban_tag =
+            buzz_sdk::nip_oa::compute_auth_tag(&f.member, &f.maintainer.public_key(), "").unwrap();
+        f.state
+            .db
+            .ban_community_member(
+                f.tenant.community(),
+                f.member.public_key().as_bytes(),
+                f.member.public_key().as_bytes(),
+                Some("test"),
+                None,
+            )
+            .await
+            .unwrap();
+        assert_eq!(
+            f.set(&f.maintainer, "legacy", Some(&ban_tag)).await.0,
+            StatusCode::FORBIDDEN
+        );
+        sqlx::query("UPDATE channels SET archived_at = NOW() WHERE community_id = $1 AND id = $2")
+            .bind(f.tenant.community().as_uuid())
+            .bind(f.channel)
+            .execute(&f.pool)
+            .await
+            .unwrap();
+        assert_eq!(
+            f.set(&f.maintainer, "legacy", None).await.0,
+            StatusCode::FORBIDDEN
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires isolated Postgres, Redis and MinIO"]
+    async fn default_branch_push_races_and_fresh_clone() {
+        let f = Fixture::new().await;
+        let a = f.snapshot().await;
+        let b = f.snapshot().await;
+        let old_digest = a.digest.clone();
+        let (_, changed) = a
+            .set(
+                &f.state.git_store,
+                SetDefaultBranch {
+                    branch: "main".into(),
+                    expected_manifest: old_digest.clone(),
+                },
+            )
+            .await
+            .unwrap();
+        assert!(changed);
+        let loser = b
+            .set(
+                &f.state.git_store,
+                SetDefaultBranch {
+                    branch: "legacy".into(),
+                    expected_manifest: old_digest,
+                },
+            )
+            .await
+            .err()
+            .unwrap();
+        assert_eq!(
+            loser.status(),
+            StatusCode::CONFLICT,
+            "stale no-op must CAS too"
+        );
+        // Snapshot a push before the metadata update; it must not restore stale HEAD.
+        let options = || super::super::super::hydrate::HydrationOptions {
+            pack_cache: &f.state.git_pack_cache,
+            scratch_dir: f.scratch.path(),
+            max_pack_bytes: 1024 * 1024,
+            max_repo_bytes: 2 * 1024 * 1024,
+        };
+        let (push, parent) = super::super::super::hydrate::hydrate_for_write(
+            &f.state.git_store,
+            &f.tenant,
+            &f.owner.public_key().to_hex(),
+            &f.repo,
+            options(),
+        )
+        .await
+        .unwrap();
+        assert_eq!(f.set(&f.owner, "legacy", None).await.0, StatusCode::OK);
+        let result = super::super::super::cas_publish::cas_publish(
+            &f.state.git_store,
+            &f.tenant,
+            push.path(),
+            &f.owner.public_key().to_hex(),
+            &f.repo,
+            &parent,
+            limits(push.hydrated_bytes()),
+        )
+        .await;
+        assert!(matches!(
+            result,
+            Err(super::super::super::cas_publish::CasError::Conflict { .. })
+        ));
+        // Other direction: a push deletes the candidate after settings loaded it.
+        let stale = f.snapshot().await;
+        let digest = stale.digest.clone();
+        let (push, parent) = super::super::super::hydrate::hydrate_for_write(
+            &f.state.git_store,
+            &f.tenant,
+            &f.owner.public_key().to_hex(),
+            &f.repo,
+            options(),
+        )
+        .await
+        .unwrap();
+        git(push.path(), &["update-ref", "-d", "refs/heads/main"]).await;
+        super::super::super::cas_publish::cas_publish(
+            &f.state.git_store,
+            &f.tenant,
+            push.path(),
+            &f.owner.public_key().to_hex(),
+            &f.repo,
+            &parent,
+            limits(push.hydrated_bytes()),
+        )
+        .await
+        .unwrap();
+        assert_eq!(
+            stale
+                .set(
+                    &f.state.git_store,
+                    SetDefaultBranch {
+                        branch: "main".into(),
+                        expected_manifest: digest
+                    }
+                )
+                .await
+                .err()
+                .unwrap()
+                .status(),
+            StatusCode::CONFLICT
+        );
+        assert!(!f
+            .snapshot()
+            .await
+            .manifest
+            .refs
+            .contains_key("refs/heads/main"));
+        // Restore main and add release/v1, then select the non-main branch so
+        // Git's initial-branch default cannot mask a lost hydrated HEAD.
+        let (push, parent) = super::super::super::hydrate::hydrate_for_write(
+            &f.state.git_store,
+            &f.tenant,
+            &f.owner.public_key().to_hex(),
+            &f.repo,
+            options(),
+        )
+        .await
+        .unwrap();
+        let main = git(&f.scratch.path().join("source"), &["rev-parse", "main"]).await;
+        git(push.path(), &["update-ref", "refs/heads/main", main.trim()]).await;
+        git(
+            push.path(),
+            &["update-ref", "refs/heads/release/v1", main.trim()],
+        )
+        .await;
+        super::super::super::cas_publish::cas_publish(
+            &f.state.git_store,
+            &f.tenant,
+            push.path(),
+            &f.owner.public_key().to_hex(),
+            &f.repo,
+            &parent,
+            limits(push.hydrated_bytes()),
+        )
+        .await
+        .unwrap();
+        assert_eq!(f.set(&f.owner, "release/v1", None).await.0, StatusCode::OK);
+        let (push, parent) = super::super::super::hydrate::hydrate_for_write(
+            &f.state.git_store,
+            &f.tenant,
+            &f.owner.public_key().to_hex(),
+            &f.repo,
+            options(),
+        )
+        .await
+        .unwrap();
+        git(
+            push.path(),
+            &["update-ref", "refs/heads/later", main.trim()],
+        )
+        .await;
+        super::super::super::cas_publish::cas_publish(
+            &f.state.git_store,
+            &f.tenant,
+            push.path(),
+            &f.owner.public_key().to_hex(),
+            &f.repo,
+            &parent,
+            limits(push.hydrated_bytes()),
+        )
+        .await
+        .unwrap();
+        assert_eq!(f.snapshot().await.manifest.head, "refs/heads/release/v1");
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        // Add a reachable host alias for the same tenant solely in this fixture.
+        sqlx::query("UPDATE communities SET host = $1 WHERE id = $2")
+            .bind(addr.to_string())
+            .bind(f.tenant.community().as_uuid())
+            .execute(&f.pool)
+            .await
+            .unwrap();
+        let router = super::super::super::transport::git_router(f.state.clone());
+        let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
+        let repo_url = format!(
+            "http://{addr}/git/{}/{}",
+            f.owner.public_key().to_hex(),
+            f.repo
+        );
+        let auth = format!(
+            "http.extraHeader=Authorization: {}",
+            token(&f.owner, "GET", &repo_url, None)
+        );
+        let refs = git(
+            f.scratch.path(),
+            &["-c", &auth, "ls-remote", "--symref", &repo_url, "HEAD"],
+        )
+        .await;
+        assert!(refs.contains("ref: refs/heads/release/v1\tHEAD"), "{refs}");
+        git(
+            f.scratch.path(),
+            &["-c", &auth, "clone", &repo_url, "clone"],
+        )
+        .await;
+        assert_eq!(
+            git(&f.scratch.path().join("clone"), &["symbolic-ref", "HEAD"])
+                .await
+                .trim(),
+            "refs/heads/release/v1"
+        );
+        assert_eq!(
+            std::fs::read(f.scratch.path().join("clone/main.txt")).unwrap(),
+            b"selected branch\n"
+        );
+        server.abort();
+    }
+
+    struct UnavailableReplayGuard;
+
+    impl buzz_auth::Nip98ReplayGuard for UnavailableReplayGuard {
+        fn try_mark_in_scope<'a>(
+            &'a self,
+            _scope: &'a str,
+            _event_id: &'a nostr::EventId,
+            _ttl_secs: u64,
+        ) -> std::pin::Pin<
+            Box<dyn std::future::Future<Output = Result<bool, buzz_auth::AuthError>> + Send + 'a>,
+        > {
+            Box::pin(async {
+                Err(buzz_auth::AuthError::Nip98Invalid(
+                    "injected backend failure".into(),
+                ))
+            })
+        }
+    }
+
+    #[tokio::test]
+    #[ignore = "requires isolated Postgres, Redis and MinIO"]
+    async fn default_branch_replay_outage_and_deletion_fail_closed() {
+        let mut f = Fixture::new().await;
+        let before = f.snapshot().await.digest;
+        let original = f.state.clone();
+        let mut state = (*original).clone();
+        state.nip98_replay = Arc::new(UnavailableReplayGuard);
+        f.state = Arc::new(state);
+        for body in [
+            None,
+            Some(json!({"branch":"main", "expected_manifest":before})),
+        ] {
+            let (status, body) = f.call(&f.owner, body, None).await;
+            assert_eq!(status, StatusCode::UNAUTHORIZED, "{body}");
+            assert!(body.to_string().contains("replay check unavailable"));
+        }
+        assert_eq!(f.snapshot().await.digest, before);
+        f.state = original;
+        // Enter the deletion executor's transaction scope in this disposable
+        // fixture; the DB correctly rejects unfenced ad-hoc state changes.
+        let mut tx = f.pool.begin().await.unwrap();
+        sqlx::query("SELECT set_config('buzz.deletion_executor_community', $1, true), set_config('buzz.deletion_fence_generation', '0', true)")
+            .bind(f.tenant.community().to_string())
+            .execute(&mut *tx).await.unwrap();
+        sqlx::query("UPDATE communities SET deletion_state = 'quiescing' WHERE id = $1")
+            .bind(f.tenant.community().as_uuid())
+            .execute(&mut *tx)
+            .await
+            .unwrap();
+        tx.commit().await.unwrap();
+        assert_ne!(f.set(&f.owner, "main", None).await.0, StatusCode::OK);
+        assert_eq!(f.snapshot().await.digest, before);
+    }
+}
diff --git a/crates/buzz-relay/src/api/git/transport.rs b/crates/buzz-relay/src/api/git/transport.rs
index 638e3c7156b..704bbf1c1d6 100644
--- a/crates/buzz-relay/src/api/git/transport.rs
+++ b/crates/buzz-relay/src/api/git/transport.rs
@@ -247,7 +247,7 @@ impl axum::extract::FromRequestParts<Arc<AppState>> for GitAuth {
 /// Cascades to the proven NIP-OA owner, matching the NIP-42 gate in
 /// `handlers::auth`: banning a human must also revoke their agents, or the ban
 /// is bypassable by cloning and pushing through an agent key.
-async fn deny_banned_git_principal(
+pub(super) async fn deny_banned_git_principal(
     db: &buzz_db::Db,
     community: buzz_core::CommunityId,
     pubkey: &nostr::PublicKey,
@@ -362,7 +362,7 @@ fn git_expected_url(
 /// repo root — but the *name* validation stays because owner/repo are
 /// still used as object-store key components via `manifest::pointer_key`.
 #[allow(clippy::result_large_err)] // Response is the natural error type for axum handlers
-fn validate_repo_id<'a>(owner: &str, repo: &'a str) -> Result<&'a str, Response> {
+pub(super) fn validate_repo_id<'a>(owner: &str, repo: &'a str) -> Result<&'a str, Response> {
     // Owner must be exactly 64 lowercase hex chars.
     if owner.len() != 64
         || !owner
@@ -483,13 +483,13 @@ fn hydrate_error_to_response(owner: &str, repo: &str, err: HydrateError) -> Resp
 /// — so the remediation body leaks nothing, and only the author can rebind
 /// (kind:30617 is keyed by `(author, d)`). A *broken* binding stays generic
 /// even for the author: ambiguity fails closed.
-async fn authorize_git_read(
+pub(super) async fn authorize_git_read(
     db: &buzz_db::Db,
     community: buzz_core::CommunityId,
     caller: &nostr::PublicKey,
     owner_hex: &str,
     repo_name: &str,
-) -> Result<(), Response> {
+) -> Result<nostr::Event, Response> {
     fn denied() -> Response {
         (StatusCode::NOT_FOUND, "repository not found").into_response()
     }
@@ -552,7 +552,7 @@ async fn authorize_git_read(
         .get_member_role(community, channel_id, &caller.to_bytes())
         .await
     {
-        Ok(role) if read_role_allows(role.as_deref()) => Ok(()),
+        Ok(role) if read_role_allows(role.as_deref()) => Ok(repo_event.event),
         Ok(_) => Err(denied()),
         Err(e) => {
             error!(repo = %repo_name, error = %e, "git read gate: role lookup failed (deny)");
@@ -2118,6 +2118,7 @@ pub fn git_router(state: Arc<AppState>) -> Router {
         .route("/git/{owner}/{repo}/info/refs", get(info_refs))
         .route("/git/{owner}/{repo}/git-upload-pack", post(upload_pack))
         .route("/git/{owner}/{repo}/git-receive-pack", post(receive_pack))
+        .merge(super::settings::router())
         .layer(RequestBodyLimitLayer::new(body_limit))
         .with_state(state)
 }
@@ -3305,7 +3306,7 @@ mod sec005_postgres_tests {
     /// can assert on the exact bytes a git client would see. A blind
     /// `.is_err()` cannot distinguish the generic 404 from the remediation
     /// 404 — and that distinction IS the security property.
-    async fn denial_parts(result: Result<(), Response>) -> (StatusCode, String) {
+    async fn denial_parts<T: std::fmt::Debug>(result: Result<T, Response>) -> (StatusCode, String) {
         let response = result.expect_err("expected a denial");
         let status = response.status();
         let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
diff --git a/docs/git-on-object-storage.md b/docs/git-on-object-storage.md
index 1d87720edc7..f97cbff5de6 100644
--- a/docs/git-on-object-storage.md
+++ b/docs/git-on-object-storage.md
@@ -133,6 +133,61 @@ with the relay event published best-effort afterward — so making manifest-CAS
 commit, with the event derived from it, is the change, not just a storage swap.
 See §Implementation Correspondence.)
 
+### Default-branch management
+
+`buzz repos default-branch get/set` reads or changes the published manifest's
+symbolic `head`. It selects an **existing** `refs/heads/<branch>`; it never moves
+branch tips, creates/deletes refs, or changes packs. A subsequent push preserves
+that HEAD while the branch exists, and fresh clones check it out.
+
+This is a narrow, intentional exception to the Nostr-first API preference:
+`GET`/`POST /git/{owner}/{repo}/default-branch` completes against the host-local
+Git pointer transaction. A kind:30617 metadata edit is not equivalent: normal
+event ingest persists before side effects and duplicate acknowledgements do not
+rerun them. A new signed command/result lifecycle could drive the same CAS, but
+adds a second completion/retry protocol for this one Git-host operation. Repo
+metadata and ACLs remain in Nostr; kind:30618 remains a derived notification,
+never authoritative Git state. This exception is not a general repository-settings
+HTTP API.
+
+- Both methods require request-specific NIP-98 (exact host-derived URL/method,
+  timestamp, signature, shared fail-closed replay check). POST also requires a
+  payload hash. Reusable Smart HTTP credentials are insufficient.
+- GET requires current membership of the channel bound by the current 30617
+  announcement. POST additionally requires a non-archived channel and the repo
+  author, a named maintainer, or the recorded human owner of an agent-authored
+  repo. Push permission, channel admin status and project membership alone do
+  not grant management. Relay admission and signer/attested-owner bans apply.
+- An agent may inherit management from a verified NIP-OA owner who is also a
+  current channel member and manager. Kind-restricted credentials cannot grant
+  this HTTP authority (there is no event kind); temporal restrictions still
+  apply. Direct signer authority does not depend on an optional owner's channel
+  membership. A stored agent-owner relationship is an ownership lookup, not a
+  live delegation credential.
+- Authorization is **admission-time**: later membership/maintainer removal,
+  rebinding or archival does not cancel an already admitted write. This is
+  narrower than the vision's instantaneous-revocation aspiration. The shared
+  serving-write lease separately fences community deletion through the write.
+
+GET returns `{branch, head, manifest}`. POST accepts only
+`{branch, expected_manifest}` (maximum 4096 bytes) and returns the same snapshot
+plus `changed`. The caller's digest must match the loaded pointer. A changed
+manifest records the prior digest as its parent, then commits with that pointer's
+observed ETag. Even a no-op checks the ETag. A concurrent push or default change
+returns 409 instead of silently reloading and overwriting it.
+
+The pointer CAS is the commit point. Notification failure after commit returns
+an explicit error, not a rollback claim. The CLI sends POST once, with redirects
+disabled. Ambiguous delivery (including server errors or a lost response) is
+non-retryable `delivery_unknown` and retains the original expected digest. Read
+current state before deciding on another write; blindly running `set` without
+`--expected-manifest` would observe a fresh version and can override someone
+else's later decision. A conflict is exit code 5.
+
+Deploy relay support **before** using an updated CLI against that relay. This
+requires no schema migration and changes no live repository merely by deploying.
+See the [CLI examples](../crates/buzz-cli/README.md#default-branch).
+
 ## Axioms
 
 The protocol's safety is proved *relative to* the following properties of the

From 9847b0967d72adbd50b4acae31d318575a962c07 Mon Sep 17 00:00:00 2001
From: Wes <wesbillman@users.noreply.github.com>
Date: Fri, 11 Sep 2026 08:11:05 -0700
Subject: [PATCH 16/19] test(desktop): isolate login-shell probe measurements
 (#7570)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Pinky, acting on Wes’s behalf.

## Summary

Fix a pre-existing false-failure mechanism in the login-shell discovery
tests, independently of the thread-window work.

- Run the two process-global-counter assertions in separate, bounded
libtest processes. The global counter still sees all of each test’s
auth/worker threads; no production discovery or cache behavior changes.
- Require exact test selection, successful child exit, and a completion
receipt after the assertion body. Reject counter resets outside
isolation.
- Keep the cold/repeated cheap-discovery zero assertions and
forced-discovery positive control unchanged. Add parent-probe exclusion
and own-worker controls.

Three test-only files, +103/-4. Base
`00209076c7a10d9e4a475466c313e8ebecf041f5`; head
`07f8e86c58a0aa5378537a3daa4610361fdbad55`.

## Reproduction and causal checks

On the main-based source, cheap discovery alone counted 0. Running the
existing missing-binary version test on another thread inside the
measurement interval made the repeated-cheap assertion fail with 1. This
reproduces interference, not the exact scheduling/caller behind the
original full-suite failure. The counter measures `run_in_login_shell`
invocations, not exact OS process counts.

Mutation checks:
- Removing isolation fails the measurement guard.
- Removing the real production `record()` call fails the original forced
positive control (0).
- A reviewer-identified early-return mutation initially survived; the
final helper owns the assertion closure instead. Deleting that
invocation now fails the external worker assertion (0 vs 1).

Independent read-only review by Brain found no remaining blocking
finding at the final head.

## Validation at the final head

- **Full `just ci`: passed.** Desktop Tauri: 3,175 passed, 19 ignored;
desktop JS: 6,488 passed; mobile: 2,098 passed. Remaining Rust unit,
formatting/lint/static, and desktop/web build lanes passed. An initial
five-minute tool timeout interrupted compilation; the subsequent
complete run used a longer deadline, not altered gates.
- **Normal pre-commit and pre-push hooks: passed.** Push includes
default + mesh Tauri Clippy, complete Tauri workspace tests, size and
branch-scope checks. No bypass.
- **Real local relay, following `TESTING.md`: passed.** Built release
`buzz-relay`, `buzz`, and `buzz-admin` from this head. Fresh isolated
Postgres/Redis, additive migrations, dedicated loopback ports,
disposable NIP-98 identity; health, create channel, signed root/reply
send, exact-ID get, and thread retrieval passed. Relay and both owned
containers stopped afterward. Dev auth-token mode follows the guide; not
a production-auth or thread-window/native UI acceptance claim.

## Scope and limits

This is process/cache isolation, not a filesystem sandbox. The existing
bounded-command helper bounds child runtime/output; its Unix
process-group behavior does not guarantee ownership of nested probe
groups. Existing individual probe deadlines remain unchanged.

No UI change, screenshots, thread-window commits, feature enablement,
merge, or deployment included.

Originating conversation:
buzz://message?channel=0b73400d-6922-4fe3-9b97-454da04d011b&id=984528c883faa8829971d19394870f0f2d543d5c1950565fd55ffddc1b8d8022

Signed-off-by: Pinky <5f5ab050ec58ae208332edd544ebf705221e24c1b86d82a6ca07038a7a8f6ac9@buzz.block.builderlab.xyz>
Co-authored-by: Pinky <5f5ab050ec58ae208332edd544ebf705221e24c1b86d82a6ca07038a7a8f6ac9@buzz.block.builderlab.xyz>
---
 .../discovery/login_shell_spawn_probe.rs      | 87 +++++++++++++++++++
 .../discovery/tests/forced_discovery.rs       |  9 +-
 .../tests/managed_path_resolution.rs          | 11 ++-
 3 files changed, 103 insertions(+), 4 deletions(-)

diff --git a/desktop/src-tauri/src/managed_agents/discovery/login_shell_spawn_probe.rs b/desktop/src-tauri/src/managed_agents/discovery/login_shell_spawn_probe.rs
index a716dee9f56..ad3a4dad23d 100644
--- a/desktop/src-tauri/src/managed_agents/discovery/login_shell_spawn_probe.rs
+++ b/desktop/src-tauri/src/managed_agents/discovery/login_shell_spawn_probe.rs
@@ -13,9 +13,96 @@ pub(crate) fn record() {
 }
 
 pub(crate) fn reset() {
+    #[cfg(unix)]
+    assert!(
+        is_isolated_process(),
+        "counter measurements must run in an isolated test process"
+    );
     COUNT.store(0, Ordering::SeqCst);
 }
 
 pub(crate) fn count() -> usize {
     COUNT.load(Ordering::SeqCst)
 }
+
+#[cfg(unix)]
+const CHILD_TEST: &str = "BUZZ_LOGIN_SHELL_PROBE_TEST";
+
+#[cfg(unix)]
+fn is_isolated_process() -> bool {
+    std::thread::current()
+        .name()
+        .is_some_and(|name| std::env::var(CHILD_TEST).as_deref() == Ok(name))
+}
+
+/// Run a counter-owning test body alone in a fresh libtest process.
+///
+/// The counter deliberately stays process-wide: discovery's auth workers must
+/// count too. A voluntary PATH lock cannot exclude unrelated, unlocked probe
+/// callers in the full suite. Process isolation excludes those callers without
+/// changing production code or requiring new workers to inherit test context.
+/// Call while holding the PATH lock so the child inherits stable environment.
+#[cfg(unix)]
+pub(crate) fn run_in_isolated_process(test: impl FnOnce()) {
+    use std::process::Command;
+    use std::time::Duration;
+
+    let thread = std::thread::current();
+    let name = thread.name().expect("libtest names its test threads");
+    let completed = format!("completed isolated login-shell probe test: {name}");
+    if is_isolated_process() {
+        test();
+        // Receipt only after the assertion body returns, never on entry.
+        println!("{completed}");
+        return;
+    }
+
+    let mut command = Command::new(std::env::current_exe().expect("test executable"));
+    command
+        .args(["--exact", name, "--nocapture", "--test-threads=1"])
+        .env(CHILD_TEST, name);
+    let output = super::bounded_command::output_with_timeout(command, Duration::from_secs(300))
+        .expect("isolated probe test must finish within five minutes and the output cap");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        output.status.success() && stdout.lines().any(|line| line.contains(&completed)),
+        "isolated probe test {name} failed or did not run: {}\n{stdout}\n{stderr}",
+        output.status
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn isolated_counter_excludes_parent_probes_but_counts_own_workers() {
+    let _guard = crate::managed_agents::lock_path_mutex();
+    let probe_on_worker = || {
+        std::thread::spawn(|| {
+            // A real production probe, independent of the shared PATH cache.
+            super::find_via_login_shell("buzz-absent-probe-isolation-xyzzy")
+        })
+        .join()
+        .expect("probe worker must finish")
+    };
+    if !is_isolated_process() {
+        assert!(probe_on_worker().is_none());
+        assert!(count() >= 1, "parent worker must reach the real probe");
+    }
+    run_in_isolated_process(|| {
+        // Before reset: unrelated parent probes must not enter this process.
+        assert_eq!(count(), 0, "the child must start with its own counter");
+        reset();
+        assert!(probe_on_worker().is_none());
+    });
+    if is_isolated_process() {
+        // Outside the closure so omitting its invocation cannot pass this test.
+        assert_eq!(count(), 1, "the child's assertion body and worker must run");
+    }
+}
+
+#[cfg(unix)]
+#[test]
+#[should_panic(expected = "counter measurements must run in an isolated test process")]
+fn reset_rejects_unisolated_measurement() {
+    reset();
+}
diff --git a/desktop/src-tauri/src/managed_agents/discovery/tests/forced_discovery.rs b/desktop/src-tauri/src/managed_agents/discovery/tests/forced_discovery.rs
index cfbad365e3a..4b2ed0e908f 100644
--- a/desktop/src-tauri/src/managed_agents/discovery/tests/forced_discovery.rs
+++ b/desktop/src-tauri/src/managed_agents/discovery/tests/forced_discovery.rs
@@ -108,6 +108,14 @@ fn forced_discovery_probes_auth_but_cheap_discovery_reuses_cached_status() {
 #[cfg(unix)]
 #[test]
 fn cheap_discovery_reports_absent_before_any_forced_probe() {
+    let _path_guard = crate::managed_agents::lock_path_mutex();
+    super::super::login_shell_spawn_probe::run_in_isolated_process(
+        cheap_discovery_reports_absent_before_any_forced_probe_body,
+    );
+}
+
+#[cfg(unix)]
+fn cheap_discovery_reports_absent_before_any_forced_probe_body() {
     use crate::managed_agents::custom_harnesses::registry_test_lock;
     use crate::managed_agents::discovery::{
         clear_resolve_cache, discover_acp_runtimes_from, login_shell_spawn_probe,
@@ -115,7 +123,6 @@ fn cheap_discovery_reports_absent_before_any_forced_probe() {
     use crate::managed_agents::{AcpAvailabilityStatus, AuthStatus};
     use std::os::unix::fs::PermissionsExt;
 
-    let _path_guard = crate::managed_agents::lock_path_mutex();
     let _registry_guard = registry_test_lock();
 
     let dir = tempfile::tempdir().expect("tempdir");
diff --git a/desktop/src-tauri/src/managed_agents/discovery/tests/managed_path_resolution.rs b/desktop/src-tauri/src/managed_agents/discovery/tests/managed_path_resolution.rs
index aab5cd45298..dce4c2910cb 100644
--- a/desktop/src-tauri/src/managed_agents/discovery/tests/managed_path_resolution.rs
+++ b/desktop/src-tauri/src/managed_agents/discovery/tests/managed_path_resolution.rs
@@ -126,6 +126,14 @@ fn resolve_command_prefers_buzz_managed_npm_shim_over_path() {
 #[cfg(unix)]
 #[test]
 fn cheap_discovery_never_spawns_login_shell_even_when_cold() {
+    let _path_guard = crate::managed_agents::lock_path_mutex();
+    super::super::login_shell_spawn_probe::run_in_isolated_process(
+        cheap_discovery_never_spawns_login_shell_even_when_cold_body,
+    );
+}
+
+#[cfg(unix)]
+fn cheap_discovery_never_spawns_login_shell_even_when_cold_body() {
     use crate::managed_agents::custom_harnesses::registry_test_lock;
     use crate::managed_agents::discovery::{
         clear_resolve_cache, discover_acp_runtimes_from, login_shell_spawn_probe,
@@ -133,9 +141,6 @@ fn cheap_discovery_never_spawns_login_shell_even_when_cold() {
     use std::fs;
     use tempfile::tempdir;
 
-    // Serialize with every other test that spawns a login shell: the spawn
-    // counter and the PATH/login-shell caches are process-global.
-    let _path_guard = crate::managed_agents::lock_path_mutex();
     let _registry = registry_test_lock();
 
     // A custom harness whose command cannot resolve anywhere, so the resolver

From f3408fc62045654183c704ceba2076b529a8140c Mon Sep 17 00:00:00 2001
From: Wes <wesbillman@users.noreply.github.com>
Date: Fri, 11 Sep 2026 08:11:39 -0700
Subject: [PATCH 17/19] fix(desktop): isolate quota backoff and reuse channel
 discovery rosters (#6998)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Pinky, an AI agent, is updating this PR on Wes's behalf.

## Targeted repair, not a startup rewrite

This replaces the previous readiness/replay candidate. Current head:
**`83ac81ff6ae439b0e68f4a3dafd4b2af6dbadcdb`**, two independent commits
on main base `3c7f288c60d67df78577b237e27c3dfc8831aaa1`:

1. **`0b6681de2` — keep quota backoff on its transport.** HTTP 429s
retain native HTTP backoff without arming the renderer WebSocket gate.
WebSocket quota/concurrency CLOSED retains its retry deadline without
damping HTTP's separate quota. The explicit `rate-limited: shared
admission unavailable` signal still damps HTTP too. Reuse existing
all-channel live streams for Home mention invalidation instead of a
second per-channel mention subscription; retain kind, recipient, self,
membership, replay-deduplication, notification and unread boundaries.
2. **`83ac81ff6` — reuse complete membership rosters within each channel
fetch.** Discovery already returns full paginated rosters. Retain those
results and request only uncovered directory/pending-owner channel IDs.
Skip empty fallback filters and preserve covered counts/pubkeys if that
tolerant fallback fails. The next fetch reads current membership again;
there is no persistent cache or new invalidation state.

No send-route, AUTH-readiness, replay-ordering, scheduler, pacing, relay
policy, dependency, or authorization changes. Refresh triggers and
activity batching stay unchanged. Independent tracing did not establish
a safe-to-delete duplicate normal-startup refresh; recovery
invalidations at different replay stages are not interchangeable.

**Size:** 18 files, +1,066/-350 overall; nine production paths +76/-205
(**129 fewer production lines**). The roster follow-up itself touches
only `fetch.rs` (+31/-14) and its new 378-line regression file. Test
bulk is not new startup machinery.

## Comparative roster measurement

Actual native HTTP fetch code against a synthetic Axum loopback fixture:
265 channels × 100 members, deterministic signed events, debug build.
Seven iterations per condition; medians below exclude the first warm-up.
Baseline is `0b6681de2` production fetch, candidate is `83ac81ff6`
production fetch, with the same temporary benchmark harness.

| Measure | Baseline | Candidate |
| --- | ---: | ---: |
| HTTP reads per fetch | 7 | 6 |
| JSON response-body bytes per fetch | 4,803,136 | 2,453,380 |
| Median, no artificial request delay | 262.9 ms | 149.3 ms |
| Median, 25 ms artificial delay per request | 376.7 ms | 282.7 ms |

Channel/member assertions and output hash (`fa7cc551bc855e4d`) match
throughout. This removes **one batched roster request**, not 265
requests. The measured ~43%/~25% reductions describe this large-roster
synthetic fixture, **not production startup latency**. Activity requests
run concurrently with roster enrichment, so real savings vary. Counts
now use the discovery snapshot rather than a later reread within that
same non-atomic fetch.

## Verification

At pushed head **`83ac81ff6`**:

- All enabled pre-push gates passed without bypass: `push-head-scope`,
`branch-skew`, `desktop-check`, `file-size-check`, `desktop-typecheck`,
`desktop-test`, `desktop-tauri-checks` (native fmt/Clippy/tests).
- Full Desktop frontend suite: **6,457 passed**, zero failures; separate
tooling suite: **10 passed**.
- Full native Desktop workspace: **3,276 passed**, zero failures, 20
ignored, across unit/integration/doc bins. The main native lib accounts
for 3,175 passed / 19 ignored; this is not 3,276 lib tests.
- `pnpm build` passed the protected-feature artifact matrix; `pnpm
build:e2e` also passed. Existing chunk-size/dynamic-import warnings
remain. No full repository `just ci` run locally.
- **130 selected headless mock-bridge smoke cases passed across two
runs**: messaging, reconnect, reconnect affordances, inbox live updates,
sidebar snapshots, send-channel binding, boot splash. The first
invocation hit the shell's 300-second limit after 117 passes and no
failures; all remaining 13 passed in a separate invocation. This is not
a claim the interrupted invocation completed.
- Six new tests invoke production `fetch_channels` through the real
native HTTP client and cover 265/501-channel pagination (including
same-timestamp continuation), exact requests, complete/deduplicated
rosters, directory/pending fallback, hidden DMs, repeated
membership/identity/relay changes, empty lists and errors.
- Falsification in an isolated source copy: restoring the redundant
baseline fetch fails four roster regressions; removing missing-roster
fallback fails two. Restored candidate passes all six. Earlier transport
mutations fail HTTP→WS coupling, WS→HTTP coupling, omitted shared-outage
damping and duplicate-mention regressions. No mutation was applied to
the committed worktree.
- Brain's independent static reviews found no blockers in the transport
repair or immutable roster patch. Source tracing confirms relay
discovery serializes complete rosters, not projected matching p-tags.
This was source review, not independent test execution or approval.

### Hosted CI

[CI run
34185670504](https://github.com/block/buzz/actions/runs/34185670504)
**completed successfully** for this head. GitHub checked out merge ref
`25bcf09627e129887481d4441a1af3c6cb0af1ff`; its Git tree is identical to
`83ac81ff6` (`49a01f3c2ebf4e547bbe3cd31406f984ac6cefe8`), verified
through the GitHub Git API. The final PR rollup has 33 successful checks
and 28 skipped, with none failing or pending.

- Desktop Core passed frontend/native suites and compiled-feature
verification. Windows Rust tests, Windows Desktop build, macOS
`.app`/`.dmg` build, all four smoke shards and both relay-backed E2E job
shards passed, as did Rust lint, DCO, Semgrep and zizmor.
- Browser job totals: **1,620 passed, 13 flaky cases passing automatic
retry #1, five skipped, zero terminal failures**. Smoke accounts for
1,389 passed / 12 flaky / three skipped; integration jobs report 231
passed / one flaky / two skipped. No manual CI reruns or source changes
to obtain green.
- The retries cover channel-browser, empty-edit, huddle menu,
runtime-install, overscroll, onboarding avatar, video attachment and
workflow UI assertions. They are disclosed, not collectively declared
unrelated. The video case reaches the changed real TS all-channel hook
despite mocking native I/O: independent tracing found no regression
mechanism or blocker, but the missing second-video player remains
**unexplained**, and an indirect timing effect is not excluded. The
self-authored, unmentioned event cannot use either the new mention
branch or the removed old mention handler as a delivery path. A passing
retry does not diagnose its cause.
- The separate “Desktop Release Candidate” check skipped its validation
step; it is not additional release validation. Codex security review was
skipped, not passed.

## Remaining acceptance limits

Wes's earlier manual trial of the transport-only candidate reported
improvement; relay readback found both a top-level message and a thread
reply. That was not a fingerprinted or timed trial of the new roster
commit. The remaining few-second top-level send wait is
**unattributed**, and this PR does not claim to resolve every startup
delay.

No visible app launch, relaunch, laptop input automation, or production
test messages during this follow-up. Local native tests use fixtures;
browser suites do not run the Tauri backend. CI building an app does not
validate bundled macOS alerts or inactive-channel notification delivery.
Those bundled real-workflow checks remain outstanding. No visual UI
changes or screenshots; no approval or merge performed.

Originating conversation:
buzz://message?channel=5b130804-d759-40ad-a564-d64cc907fa8e&id=cb432417e290e06a1842639cfe0268f9d43d186defbcb59260930d129a26af83

---------

Signed-off-by: Pinky <5f5ab050ec58ae208332edd544ebf705221e24c1b86d82a6ca07038a7a8f6ac9@buzz.block.builderlab.xyz>
Co-authored-by: Pinky <5f5ab050ec58ae208332edd544ebf705221e24c1b86d82a6ca07038a7a8f6ac9@buzz.block.builderlab.xyz>
---
 .../src-tauri/src/commands/channels/fetch.rs  |  45 ++-
 .../src/commands/channels/fetch_tests.rs      | 378 +++++++++++++++++
 desktop/src-tauri/src/egress_guard_tests.rs   |   1 +
 desktop/src-tauri/src/native_relay_client.rs  |  13 +-
 .../src/native_relay_client_tests.rs          |   6 +-
 .../native_relay_client_transport_tests.rs    | 169 ++++++++
 desktop/src-tauri/src/relay.rs                |   8 +-
 desktop/src-tauri/src/relay/tests.rs          |   2 +-
 desktop/src-tauri/src/relay_admission.rs      |   7 +-
 .../channels/useLiveChannelUpdates.test.mjs   | 380 ++++++++++++++++++
 .../channels/useLiveChannelUpdates.ts         | 142 +------
 desktop/src/shared/api/relayChannelFilters.ts |  15 -
 .../api/relayClientPublishRejection.test.mjs  |  58 +++
 desktop/src/shared/api/relayClientSession.ts  |  11 -
 .../shared/api/relayRateLimitGate.test.mjs    |  23 --
 desktop/src/shared/api/relayRateLimitGate.ts  |  16 +-
 desktop/src/shared/api/tauri.test.mjs         | 118 ------
 desktop/src/shared/api/tauri.ts               |  24 +-
 18 files changed, 1066 insertions(+), 350 deletions(-)
 create mode 100644 desktop/src-tauri/src/commands/channels/fetch_tests.rs
 create mode 100644 desktop/src-tauri/src/native_relay_client_transport_tests.rs
 create mode 100644 desktop/src/features/channels/useLiveChannelUpdates.test.mjs

diff --git a/desktop/src-tauri/src/commands/channels/fetch.rs b/desktop/src-tauri/src/commands/channels/fetch.rs
index 36c24a35b7d..993d40807e2 100644
--- a/desktop/src-tauri/src/commands/channels/fetch.rs
+++ b/desktop/src-tauri/src/commands/channels/fetch.rs
@@ -186,9 +186,9 @@ pub(super) enum DirectoryScope {
 /// - Phase 1 (parallel): member-chain (kind:39002→kind:39000), the non-member
 ///   metadata source (pending-owned ids when member-only, else the all-open
 ///   kind:39000 scan), and the hidden-DM snapshot (kind:30622).
-/// - Phase 2 (parallel): member counts (kind:39002 batch) and last-message
-///   timestamps (bounded per-channel human-visible activity batches), fanned
-///   out over the merged set. Member-count failures degrade to zero; timestamp
+/// - Phase 2 (parallel): missing member counts (kind:39002 batch) and last-message
+///   timestamps (bounded per-channel human-visible activity batches). Reuse the
+///   member-chain rosters; missing-count failures degrade to zero. Timestamp
 ///   failures abort so cached recency is never replaced by a false
 ///   authoritative empty result.
 pub(super) async fn fetch_channels(
@@ -263,7 +263,7 @@ pub(super) async fn fetch_channels(
                 Vec::new()
             };
 
-            Ok::<_, String>(meta_events)
+            Ok::<_, String>((meta_events, collect_members_by_channel(&member_events)))
         },
         // Step 3: non-member channel metadata (kind:39000).
         // - IncludeOpenDirectory: scan ALL open channels so the discovery
@@ -321,7 +321,7 @@ pub(super) async fn fetch_channels(
     #[cfg(debug_assertions)]
     let t_phase1 = _profile_start.elapsed();
 
-    let meta_events = member_chain_result?;
+    let (meta_events, mut membership) = member_chain_result?;
     let open_meta_events = open_meta_result?;
     // hidden_dms is already a resolved HashSet (tolerant path above)
 
@@ -371,8 +371,8 @@ pub(super) async fn fetch_channels(
         }
     }
 
-    // Phase 2 — concurrent: member counts (step 4) and last-message timestamps
-    // (step 5). Member-count failures degrade to zero. Timestamp failures
+    // Phase 2 — concurrent: missing member counts (step 4) and last-message
+    // timestamps (step 5). Missing-count failures degrade to zero. Timestamp failures
     // abort this refresh so the frontend keeps its previous Recent ordering.
     let all_channel_ids: Vec<String> = channels.iter().map(|c| c.id.clone()).collect();
     if !all_channel_ids.is_empty() {
@@ -381,16 +381,27 @@ pub(super) async fn fetch_channels(
             .map(|id| last_message_filter(id))
             .collect();
 
-        // Bind both filter arrays before the join so their lifetimes cover
-        // both branches of the concurrent pair.
+        // Step 1 already returned complete rosters, not just the matching p-tag.
+        // Only directory-only or still-pending channels need another read. Keep
+        // reuse local to this fetch so the next refresh sees membership changes.
+        let missing_member_ids: Vec<&String> = all_channel_ids
+            .iter()
+            .filter(|id| !membership.contains_key(*id))
+            .collect();
         let member_count_filters = [serde_json::json!({
             "kinds": [39002],
-            "#d": &all_channel_ids,
-            "limit": all_channel_ids.len(),
+            "#d": &missing_member_ids,
+            "limit": missing_member_ids.len(),
         })];
         let (members_result, message_result) = tokio::join!(
-            // Step 4: batch-fetch kind:39002 for member counts.
-            query_relay(state, &member_count_filters),
+            // Step 4: do not send an empty #d filter (an unscoped roster query).
+            async {
+                if missing_member_ids.is_empty() {
+                    Ok(Vec::new())
+                } else {
+                    query_relay(state, &member_count_filters).await
+                }
+            },
             // Step 5: preserve one indexed filter per channel while keeping
             // every relay request within its aggregate explicit-channel cap.
             query_last_messages(state, &last_msg_filters),
@@ -400,7 +411,9 @@ pub(super) async fn fetch_channels(
         // empty result and clear every cached timestamp in the frontend.
         let messages = message_result?;
 
-        let membership = collect_members_by_channel(&members_result.unwrap_or_default());
+        membership.extend(collect_members_by_channel(
+            &members_result.unwrap_or_default(),
+        ));
         for channel in &mut channels {
             if let Some(info) = membership.get(&channel.id) {
                 channel.member_count = info.count;
@@ -488,3 +501,7 @@ pub(super) fn collect_members_by_channel(
     }
     map
 }
+
+#[cfg(test)]
+#[path = "fetch_tests.rs"]
+mod tests;
diff --git a/desktop/src-tauri/src/commands/channels/fetch_tests.rs b/desktop/src-tauri/src/commands/channels/fetch_tests.rs
new file mode 100644
index 00000000000..439dfbd6c56
--- /dev/null
+++ b/desktop/src-tauri/src/commands/channels/fetch_tests.rs
@@ -0,0 +1,378 @@
+//! Exercise the production channel-list fetch over the native HTTP bridge.
+use super::*;
+use axum::{extract::State, http::StatusCode, routing::post, Json, Router};
+use nostr::{Event, EventBuilder, Keys, Kind, Tag, Timestamp};
+use serde_json::{json, Value};
+use std::sync::{Arc, Mutex};
+
+#[derive(Default)]
+struct Fixture {
+    events: Vec<Event>,
+    requests: Vec<Vec<Value>>,
+    fail_discovery: bool,
+    fail_fallback: bool,
+    fail_messages: bool,
+}
+
+struct Relay {
+    data: Arc<Mutex<Fixture>>,
+    url: String,
+    task: tokio::task::JoinHandle<()>,
+}
+
+impl Drop for Relay {
+    fn drop(&mut self) {
+        self.task.abort();
+    }
+}
+
+async fn query(
+    State(data): State<Arc<Mutex<Fixture>>>,
+    Json(filters): Json<Vec<Value>>,
+) -> (StatusCode, Json<Value>) {
+    let mut data = data.lock().unwrap();
+    data.requests.push(filters.clone());
+    let mut result = Vec::new();
+    for filter in &filters {
+        let kind = filter["kinds"][0].as_u64().unwrap();
+        if (kind == 39002 && filter.get("#p").is_some() && data.fail_discovery)
+            || (kind == 39002 && filter.get("#d").is_some() && data.fail_fallback)
+            || (kind == 9 && data.fail_messages)
+        {
+            return (
+                StatusCode::SERVICE_UNAVAILABLE,
+                Json(json!({"error": "fixture unavailable"})),
+            );
+        }
+        let mut page: Vec<_> = data
+            .events
+            .iter()
+            .filter(|event| {
+                if !filter["kinds"]
+                    .as_array()
+                    .unwrap()
+                    .contains(&json!(event.kind.as_u16()))
+                {
+                    return false;
+                }
+                for name in ["p", "d", "h"] {
+                    if let Some(values) = filter.get(format!("#{name}")).and_then(Value::as_array) {
+                        if !event.tags.iter().any(|tag| {
+                            let s = tag.as_slice();
+                            s.len() >= 2 && s[0] == name && values.contains(&json!(s[1]))
+                        }) {
+                            return false;
+                        }
+                    }
+                }
+                if let Some(until) = filter["until"].as_u64() {
+                    let ts = event.created_at.as_secs();
+                    if ts > until
+                        || (ts == until
+                            && filter["before_id"]
+                                .as_str()
+                                .is_some_and(|id| event.id.to_hex().as_str() <= id))
+                    {
+                        return false;
+                    }
+                }
+                true
+            })
+            .cloned()
+            .collect();
+        page.sort_by(|a, b| {
+            b.created_at
+                .cmp(&a.created_at)
+                .then_with(|| a.id.cmp(&b.id))
+        });
+        page.truncate(filter["limit"].as_u64().unwrap() as usize);
+        result.extend(page);
+    }
+    (StatusCode::OK, Json(json!(result)))
+}
+
+impl Relay {
+    async fn new(events: Vec<Event>) -> Self {
+        let data = Arc::new(Mutex::new(Fixture {
+            events,
+            ..Default::default()
+        }));
+        let router = Router::new()
+            .route("/query", post(query))
+            .with_state(data.clone());
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let url = format!("http://{}", listener.local_addr().unwrap());
+        let task = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
+        Self { data, url, task }
+    }
+
+    fn state(&self, keys: &Keys) -> AppState {
+        let state = crate::app_state::build_app_state();
+        *state.keys.lock().unwrap() = keys.clone();
+        *state.relay_url_override.lock().unwrap() = Some(self.url.clone());
+        state
+    }
+
+    fn roster_fallbacks(&self) -> Vec<Value> {
+        self.data
+            .lock()
+            .unwrap()
+            .requests
+            .iter()
+            .flatten()
+            .filter(|filter| filter["kinds"] == json!([39002]) && filter.get("#d").is_some())
+            .cloned()
+            .collect()
+    }
+}
+
+fn event(keys: &Keys, kind: u16, tags: Vec<Vec<&str>>) -> Event {
+    EventBuilder::new(Kind::from_u16(kind), "")
+        .allow_self_tagging()
+        .tags(tags.into_iter().map(|tag| Tag::parse(tag).unwrap()))
+        .custom_created_at(Timestamp::from(1_700_000_000))
+        .sign_with_keys(keys)
+        .unwrap()
+}
+
+fn metadata(keys: &Keys, id: &str) -> Event {
+    event(keys, 39000, vec![vec!["d", id], vec!["name", id]])
+}
+
+fn roster(keys: &Keys, id: &str, members: &[&str]) -> Event {
+    let mut tags = vec![vec!["d", id]];
+    tags.extend(members.iter().map(|pk| vec!["p", *pk, "", "member"]));
+    event(keys, 39002, tags)
+}
+
+async fn fetch(state: &AppState, scope: DirectoryScope) -> Result<Vec<ChannelInfo>, String> {
+    tokio::time::timeout(
+        std::time::Duration::from_secs(10),
+        fetch_channels(state, scope),
+    )
+    .await
+    .expect("bounded channel fetch")
+}
+
+#[tokio::test]
+async fn member_rosters_are_reused_including_every_discovery_page() {
+    let _serial = crate::relay_admission::TEST_SERIAL.lock().await;
+    let keys = Keys::generate();
+    let me = keys.public_key().to_hex();
+    let other = Keys::generate().public_key().to_hex();
+    for count in [265, 501] {
+        let mut events = Vec::new();
+        for index in 0..count {
+            let id = format!("channel-{index:04}");
+            events.push(metadata(&keys, &id));
+            // Repeated p-tag must not inflate the count; non-self members must survive.
+            events.push(roster(&keys, &id, &[&me, &other, &other]));
+        }
+        let relay = Relay::new(events).await;
+        let state = relay.state(&keys);
+        let started = std::time::Instant::now();
+        let channels = fetch(&state, DirectoryScope::MemberOnly).await.unwrap();
+        assert_eq!(channels.len(), count);
+        assert!(channels.iter().all(|c| c.is_member
+            && c.member_count == 2
+            && c.member_pubkeys == vec![me.clone(), other.clone()]));
+        assert!(
+            relay.roster_fallbacks().is_empty(),
+            "covered rosters must not be fetched twice"
+        );
+        let data = relay.data.lock().unwrap();
+        let discovery: Vec<_> = data
+            .requests
+            .iter()
+            .flatten()
+            .filter(|f| f["kinds"] == json!([39002]))
+            .collect();
+        assert_eq!(discovery.len(), count / DIRECTORY_PAGE_SIZE + 1);
+        if count > DIRECTORY_PAGE_SIZE {
+            assert_eq!(discovery[1]["until"], json!(1_700_000_000));
+            assert!(discovery[1]["before_id"].is_string());
+        }
+        // Membership pages + member metadata + hidden DMs + bounded activity batches.
+        let expected_reads = count / DIRECTORY_PAGE_SIZE + 1 + 2 + count.div_ceil(128);
+        assert_eq!(data.requests.len(), expected_reads);
+        eprintln!(
+            "roster-reuse fixture channels={count} reads={} elapsed={:?}",
+            data.requests.len(),
+            started.elapsed()
+        );
+    }
+}
+
+#[tokio::test]
+async fn directory_fetches_only_uncovered_rosters_and_keeps_hidden_dm_behavior() {
+    let _serial = crate::relay_admission::TEST_SERIAL.lock().await;
+    let keys = Keys::generate();
+    let me = keys.public_key().to_hex();
+    let other = Keys::generate().public_key().to_hex();
+    let relay = Relay::new(vec![
+        metadata(&keys, "joined"),
+        roster(&keys, "joined", &[&me, &other]),
+        metadata(&keys, "open"),
+        roster(&keys, "open", &[&other]),
+        metadata(&keys, "empty"),
+        roster(&keys, "empty", &[]),
+        event(&keys, 39000, vec![vec!["d", "hidden-dm"], vec!["t", "dm"]]),
+        roster(&keys, "hidden-dm", &[&me, &other]),
+        event(
+            &keys,
+            buzz_core_pkg::kind::KIND_DM_VISIBILITY.try_into().unwrap(),
+            vec![vec!["p", &me], vec!["h", "hidden-dm"]],
+        ),
+        event(&keys, 9, vec![vec!["h", "joined"]]),
+    ])
+    .await;
+    let channels = fetch(&relay.state(&keys), DirectoryScope::IncludeOpenDirectory)
+        .await
+        .unwrap();
+    assert_eq!(channels.len(), 3);
+    let joined = channels.iter().find(|c| c.id == "joined").unwrap();
+    assert!(joined.is_member);
+    assert_eq!(joined.member_pubkeys, vec![me, other.clone()]);
+    assert!(joined.last_message_at.is_some());
+    let open = channels.iter().find(|c| c.id == "open").unwrap();
+    assert!(!open.is_member);
+    assert_eq!(open.member_count, 1);
+    assert_eq!(open.member_pubkeys, vec![other]);
+    let empty = channels.iter().find(|c| c.id == "empty").unwrap();
+    assert!(!empty.is_member);
+    assert_eq!(empty.member_count, 0);
+    assert!(empty.member_pubkeys.is_empty());
+    let fallbacks = relay.roster_fallbacks();
+    assert_eq!(fallbacks.len(), 1);
+    let mut ids = fallbacks[0]["#d"].as_array().unwrap().clone();
+    ids.sort_by_key(Value::to_string);
+    assert_eq!(ids, vec![json!("empty"), json!("open")]);
+    assert_eq!(fallbacks[0]["limit"], json!(2));
+}
+
+#[tokio::test]
+async fn pending_owner_fallback_failure_preserves_covered_rosters() {
+    let _serial = crate::relay_admission::TEST_SERIAL.lock().await;
+    let keys = Keys::generate();
+    let me = keys.public_key().to_hex();
+    let other = Keys::generate().public_key().to_hex();
+    let relay = Relay::new(vec![
+        metadata(&keys, "joined"),
+        roster(&keys, "joined", &[&me, &other]),
+        metadata(&keys, "pending"),
+        roster(&keys, "pending", &[&other]),
+        metadata(&keys, "unpropagated"),
+        metadata(&keys, "someone-elses-pending"),
+    ])
+    .await;
+    let state = relay.state(&keys);
+    state.mark_pending_owned_channel(&me, "joined");
+    state.mark_pending_owned_channel(&me, "pending");
+    state.mark_pending_owned_channel(&me, "unpropagated");
+    state.mark_pending_owned_channel(&other, "someone-elses-pending");
+    for fail in [false, true] {
+        relay.data.lock().unwrap().fail_fallback = fail;
+        let channels = fetch(&state, DirectoryScope::MemberOnly).await.unwrap();
+        assert_eq!(channels.len(), 3);
+        let unpropagated = channels.iter().find(|c| c.id == "unpropagated").unwrap();
+        assert!(unpropagated.is_member);
+        assert_eq!(unpropagated.member_count, 0);
+        assert!(unpropagated.member_pubkeys.is_empty());
+        let pending = channels.iter().find(|c| c.id == "pending").unwrap();
+        assert!(pending.is_member);
+        assert_eq!(pending.member_count, if fail { 0 } else { 1 });
+        assert_eq!(
+            channels
+                .iter()
+                .find(|c| c.id == "joined")
+                .unwrap()
+                .member_count,
+            2
+        );
+        assert!(!state.is_pending_owned_channel(&me, "joined"));
+        assert!(state.is_pending_owned_channel(&me, "pending"));
+    }
+    for fallback in relay.roster_fallbacks() {
+        let mut ids = fallback["#d"].as_array().unwrap().clone();
+        ids.sort_by_key(Value::to_string);
+        assert_eq!(ids, vec![json!("pending"), json!("unpropagated")]);
+        assert_eq!(fallback["limit"], json!(2));
+    }
+}
+
+#[tokio::test]
+async fn each_fetch_observes_roster_changes_and_the_current_identity_and_relay() {
+    let _serial = crate::relay_admission::TEST_SERIAL.lock().await;
+    let keys = Keys::generate();
+    let me = keys.public_key().to_hex();
+    let next_keys = Keys::generate();
+    let next = next_keys.public_key().to_hex();
+    let relay = Relay::new(vec![
+        metadata(&keys, "same-id"),
+        roster(&keys, "same-id", &[&me]),
+    ])
+    .await;
+    let state = relay.state(&keys);
+    assert_eq!(
+        fetch(&state, DirectoryScope::MemberOnly).await.unwrap()[0].member_pubkeys,
+        vec![me.clone()]
+    );
+    relay.data.lock().unwrap().events[1] = roster(&keys, "same-id", &[&me, &next]);
+    assert_eq!(
+        fetch(&state, DirectoryScope::MemberOnly).await.unwrap()[0].member_count,
+        2
+    );
+    relay.data.lock().unwrap().events[1] = roster(&keys, "same-id", &[&next]);
+    assert!(fetch(&state, DirectoryScope::MemberOnly)
+        .await
+        .unwrap()
+        .is_empty());
+    *state.keys.lock().unwrap() = next_keys.clone();
+    assert_eq!(
+        fetch(&state, DirectoryScope::MemberOnly).await.unwrap()[0].member_pubkeys,
+        vec![next.clone()]
+    );
+    let second = Relay::new(vec![
+        metadata(&keys, "same-id"),
+        roster(&keys, "same-id", &[&next, &me]),
+    ])
+    .await;
+    *state.relay_url_override.lock().unwrap() = Some(second.url.clone());
+    assert_eq!(
+        fetch(&state, DirectoryScope::MemberOnly).await.unwrap()[0].member_pubkeys,
+        vec![next, me]
+    );
+    assert!(relay.roster_fallbacks().is_empty());
+    assert!(second.roster_fallbacks().is_empty());
+}
+
+#[tokio::test]
+async fn empty_membership_does_not_issue_metadata_roster_or_activity_queries() {
+    let _serial = crate::relay_admission::TEST_SERIAL.lock().await;
+    let keys = Keys::generate();
+    let relay = Relay::new(vec![]).await;
+    assert!(fetch(&relay.state(&keys), DirectoryScope::MemberOnly)
+        .await
+        .unwrap()
+        .is_empty());
+    assert_eq!(relay.data.lock().unwrap().requests.len(), 2);
+    assert!(relay.roster_fallbacks().is_empty());
+}
+
+#[tokio::test]
+async fn discovery_and_activity_failures_still_abort_the_refresh() {
+    let _serial = crate::relay_admission::TEST_SERIAL.lock().await;
+    let keys = Keys::generate();
+    let me = keys.public_key().to_hex();
+    let relay = Relay::new(vec![
+        metadata(&keys, "joined"),
+        roster(&keys, "joined", &[&me]),
+    ])
+    .await;
+    let state = relay.state(&keys);
+    relay.data.lock().unwrap().fail_discovery = true;
+    assert!(fetch(&state, DirectoryScope::MemberOnly).await.is_err());
+    relay.data.lock().unwrap().fail_discovery = false;
+    relay.data.lock().unwrap().fail_messages = true;
+    assert!(fetch(&state, DirectoryScope::MemberOnly).await.is_err());
+}
diff --git a/desktop/src-tauri/src/egress_guard_tests.rs b/desktop/src-tauri/src/egress_guard_tests.rs
index 29e74cfb506..fe053602f9e 100644
--- a/desktop/src-tauri/src/egress_guard_tests.rs
+++ b/desktop/src-tauri/src/egress_guard_tests.rs
@@ -271,6 +271,7 @@ const EVENTS_INVENTORY: &[(&str, usize, usize)] = &[
     ("src/native_websocket.rs", 0, 2),                  // boundary 8 (WS frames; no events URL)
     // Test-only fixtures — no production egress, no guard:
     ("src/relay_admission.rs", 1, 0),
+    ("src/native_relay_client_transport_tests.rs", 1, 0),
     ("src/archive/mod_tests.rs", 1, 0),
     ("src/managed_agents/persona_events/tests.rs", 1, 0),
     ("src/commands/team_snapshot/tests.rs", 1, 0),
diff --git a/desktop/src-tauri/src/native_relay_client.rs b/desktop/src-tauri/src/native_relay_client.rs
index 2237076a926..19740dd0197 100644
--- a/desktop/src-tauri/src/native_relay_client.rs
+++ b/desktop/src-tauri/src/native_relay_client.rs
@@ -771,11 +771,16 @@ impl ClosedRetry {
                 self.due_at = None;
             }
             ClosedClass::RateLimited => {
-                // Arm the process-wide gate so the HTTP bridge backs off too,
-                // rather than keeping a second private notion of the same
-                // relay's back-pressure.
+                // WS quota/concurrency limits do not consume HTTP's ApiCalls
+                // budget. Only an explicit failure of the shared admission
+                // service warrants damping the other transport too.
                 let hint = parse_retry_in_seconds(message);
-                crate::relay_admission::activate_rate_limit(hint);
+                if message
+                    .trim()
+                    .eq_ignore_ascii_case("rate-limited: shared admission unavailable")
+                {
+                    crate::relay_admission::activate_rate_limit(None);
+                }
                 let hinted = hint
                     .map(Duration::from_secs)
                     .unwrap_or(CLOSED_RATE_LIMIT_DEFAULT);
diff --git a/desktop/src-tauri/src/native_relay_client_tests.rs b/desktop/src-tauri/src/native_relay_client_tests.rs
index 96ec39a4bf0..ca2324327f3 100644
--- a/desktop/src-tauri/src/native_relay_client_tests.rs
+++ b/desktop/src-tauri/src/native_relay_client_tests.rs
@@ -487,7 +487,6 @@ async fn a_reconcile_preserves_the_backoff_of_a_still_desired_subscription() {
          reconcile, got {reopened:?}"
     );
 
-    crate::relay_admission::reset_rate_limit_gate();
     session.shutdown();
 }
 
@@ -726,7 +725,6 @@ fn a_rate_limited_closed_waits_at_least_the_relay_hint() {
         due >= Instant::now() + Duration::from_secs(11),
         "a 12s hint must not be undercut by the base backoff"
     );
-    crate::relay_admission::reset_rate_limit_gate();
 }
 
 #[test]
@@ -739,7 +737,6 @@ fn a_hintless_rate_limited_closed_uses_the_shared_default() {
         due >= Instant::now() + CLOSED_RATE_LIMIT_DEFAULT - Duration::from_secs(1),
         "a hintless rate-limit must fall back to the shared default window"
     );
-    crate::relay_admission::reset_rate_limit_gate();
 }
 
 #[test]
@@ -894,3 +891,6 @@ async fn the_first_lease_installs_a_session_the_archive_then_reuses() {
          replacing an identically scoped one"
     );
 }
+
+#[path = "native_relay_client_transport_tests.rs"]
+mod transport_tests;
diff --git a/desktop/src-tauri/src/native_relay_client_transport_tests.rs b/desktop/src-tauri/src/native_relay_client_transport_tests.rs
new file mode 100644
index 00000000000..d064b521e52
--- /dev/null
+++ b/desktop/src-tauri/src/native_relay_client_transport_tests.rs
@@ -0,0 +1,169 @@
+//! Real persistent-WS receive loop -> real HTTP submit admission regressions.
+use super::*;
+use crate::relay_admission::{reset_rate_limit_gate, TEST_SERIAL};
+use axum::{routing::post, Json, Router};
+
+async fn http_relay() -> (
+    String,
+    mpsc::Receiver<(nostr::Event, std::time::Instant)>,
+    tokio::task::JoinHandle<()>,
+) {
+    let (sent, received) = mpsc::channel(4);
+    let router = Router::new()
+        .route(
+            "/query",
+            post(|| async {
+                (
+                    axum::http::StatusCode::TOO_MANY_REQUESTS,
+                    Json(serde_json::json!({"error": "rate-limited: quota exceeded; retry in 1s"})),
+                )
+            }),
+        )
+        .route(
+            "/events",
+            post(move |Json(event): Json<nostr::Event>| {
+                let sent = sent.clone();
+                async move {
+                    let received_at = std::time::Instant::now();
+                    let id = event.id.to_hex();
+                    assert!(event.verify().is_ok());
+                    sent.send((event, received_at)).await.unwrap();
+                    Json(serde_json::json!({"event_id": id, "accepted": true, "message": ""}))
+                }
+            }),
+        );
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let address = listener.local_addr().unwrap();
+    let server = tokio::spawn(async move {
+        axum::serve(listener, router).await.unwrap();
+    });
+    (format!("http://{address}"), received, server)
+}
+
+fn reply(keys: &Keys) -> nostr::Event {
+    EventBuilder::new(nostr::Kind::Custom(9), "startup reply")
+        .tags([
+            nostr::Tag::parse(["h", "5b130804-d759-40ad-a564-d64cc907fa8e"]).unwrap(),
+            nostr::Tag::parse(["e", &"a".repeat(64), "", "reply"]).unwrap(),
+        ])
+        .sign_with_keys(keys)
+        .unwrap()
+}
+
+async fn closed_then_http_submit(message: &str, shared_unavailable: bool) {
+    let _serial = TEST_SERIAL.lock().await;
+    reset_rate_limit_gate();
+    let (ws_url, mut frames, commands) = stub_relay().await;
+    let keys = Keys::generate();
+    let (session, mut events) = start(ws_url, keys.clone(), None).await;
+    session
+        .set_subscriptions(vec![
+            probe_subscription(),
+            Subscription {
+                id: "barrier".into(),
+                filter: serde_json::json!({"kinds": [1], "limit": 0}),
+            },
+        ])
+        .await;
+    assert_eq!(next_req(&mut frames, "probe REQ").await, PROBE_ID);
+    assert_eq!(next_req(&mut frames, "barrier REQ").await, "barrier");
+    commands
+        .send(StubCommand::Closed(PROBE_ID.into(), message.into()))
+        .await
+        .unwrap();
+    // An ordered frame on an unaffected persistent subscription proves CLOSED
+    // went through the receive loop. No test-side gate activation or sleeps.
+    let barrier = EventBuilder::text_note("barrier")
+        .sign_with_keys(&keys)
+        .unwrap();
+    commands
+        .send(StubCommand::Event(
+            "barrier".into(),
+            serde_json::to_value(barrier).unwrap(),
+        ))
+        .await
+        .unwrap();
+    assert_eq!(
+        tokio::time::timeout(Duration::from_secs(3), events.recv())
+            .await
+            .unwrap()
+            .unwrap()
+            .subscription_id,
+        "barrier"
+    );
+
+    let (http_url, mut submitted, server) = http_relay().await;
+    let state = crate::app_state::build_app_state();
+    let event = reply(&keys);
+    let submit = crate::relay::submit_signed_event_at_with_keys(&event, &state, &http_url, &keys);
+    let outcome = tokio::time::timeout(Duration::from_secs(1), submit).await;
+    session.shutdown();
+    server.abort();
+    reset_rate_limit_gate();
+    if shared_unavailable {
+        assert!(
+            outcome.is_err(),
+            "shared admission outage must still damp HTTP"
+        );
+        assert!(
+            submitted.try_recv().is_err(),
+            "HTTP must not dispatch during the shared outage"
+        );
+    } else {
+        let response = outcome
+            .expect("WS quota must not withhold HTTP submission")
+            .unwrap();
+        assert!(response.accepted);
+        assert_eq!(response.event_id, event.id.to_hex());
+        assert_eq!(submitted.recv().await.unwrap().0, event);
+    }
+    assert!(
+        frames.try_recv().is_err(),
+        "the limited WS subscription must not reopen early"
+    );
+}
+
+#[tokio::test]
+async fn persistent_ws_quota_does_not_withhold_http_reply() {
+    closed_then_http_submit("rate-limited: quota exceeded; retry in 50s", false).await;
+}
+
+#[tokio::test]
+async fn persistent_ws_concurrency_does_not_withhold_http_reply() {
+    closed_then_http_submit("rate-limited: too many concurrent requests", false).await;
+}
+
+#[tokio::test]
+async fn persistent_ws_shared_unavailable_still_withholds_http_reply() {
+    closed_then_http_submit("rate-limited: shared admission unavailable", true).await;
+}
+
+#[tokio::test]
+async fn http_429_still_withholds_http_reply_then_accepts_it() {
+    let _serial = TEST_SERIAL.lock().await;
+    reset_rate_limit_gate();
+    let (http_url, mut submitted, server) = http_relay().await;
+    let state = crate::app_state::build_app_state();
+    let keys = Keys::generate();
+    let event = reply(&keys);
+    let error = crate::relay::query_relay_at(&state, &http_url, &[serde_json::json!({"limit": 1})])
+        .await
+        .unwrap_err();
+    assert_eq!(error, "relay rate-limited: retry in 1s");
+    let before = std::time::Instant::now();
+    let outcome = tokio::time::timeout(
+        Duration::from_secs(3),
+        crate::relay::submit_signed_event_at_with_keys(&event, &state, &http_url, &keys),
+    )
+    .await;
+    server.abort();
+    reset_rate_limit_gate();
+    let response = outcome.unwrap().unwrap();
+    let (received, received_at) = submitted.recv().await.unwrap();
+    assert!(
+        received_at.duration_since(before) >= Duration::from_millis(900),
+        "HTTP submit must honour its own cooldown"
+    );
+    assert!(response.accepted);
+    assert_eq!(received, event);
+}
diff --git a/desktop/src-tauri/src/relay.rs b/desktop/src-tauri/src/relay.rs
index 676b9656ff2..2484fc7d14c 100644
--- a/desktop/src-tauri/src/relay.rs
+++ b/desktop/src-tauri/src/relay.rs
@@ -316,7 +316,7 @@ pub async fn relay_error_message(response: reqwest::Response) -> String {
     };
 
     // 429 Too Many Requests → typed `relay rate-limited:` prefix so the TS
-    // client can activate the rate-limit gate without confusing it with a
+    // client can report back-pressure without confusing it with a
     // connectivity failure (`relay unreachable:`). Also arm the Rust-side
     // admission gate here — the one place every relay HTTP error funnels
     // through — so the next relay-backed command waits out the quota window
@@ -324,10 +324,8 @@ pub async fn relay_error_message(response: reqwest::Response) -> String {
     if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
         let hint = extract_retry_in_hint(&body);
         // Clamp the hint to MAX_HINT_SECONDS before arming the Rust gate AND
-        // before embedding it in the returned string. Every consumer (Rust gate
-        // via `activate_rate_limit` and TS gate via `applyTauriRateLimitIfNeeded`)
-        // must see the same capped value — a single policy point prevents the TS
-        // gate from receiving an uncapped hint from an untrusted relay.
+        // before embedding it in the returned string, so the caller sees the
+        // same bounded hint the native HTTP gate actually honours.
         let capped_hint = hint.map(|s| s.min(crate::relay_admission::MAX_HINT_SECONDS));
         crate::relay_admission::activate_rate_limit(capped_hint);
         if let Some(secs) = capped_hint {
diff --git a/desktop/src-tauri/src/relay/tests.rs b/desktop/src-tauri/src/relay/tests.rs
index 0fcbc891b79..f2928cbf612 100644
--- a/desktop/src-tauri/src/relay/tests.rs
+++ b/desktop/src-tauri/src/relay/tests.rs
@@ -45,7 +45,7 @@ fn overlong_digit_string_returns_none() {
 //
 // Verify that an oversized relay hint is capped in the returned message
 // string, not just inside `activate_rate_limit()`. This guarantees every
-// consumer — including the TS gate via `applyTauriRateLimitIfNeeded` —
+// consumer of the returned error —
 // receives the capped value rather than the raw untrusted relay value.
 
 #[tokio::test]
diff --git a/desktop/src-tauri/src/relay_admission.rs b/desktop/src-tauri/src/relay_admission.rs
index 4b0dd1f3696..29d6cdb309b 100644
--- a/desktop/src-tauri/src/relay_admission.rs
+++ b/desktop/src-tauri/src/relay_admission.rs
@@ -17,6 +17,10 @@
 //! are driven by user-initiated file transfers rather than bridge event flow,
 //! and they have independent retry logic.
 //!
+//! The native WS client also arms this gate for the explicit
+//! `shared admission unavailable` signal. Quota/concurrency CLOSEDs stay on
+//! WebSocket; they do not consume the HTTP bridge's separate ApiCalls budget.
+//!
 //! **Community scope:** the gate is reset on every `apply_workspace` call,
 //! mirroring the TS gate's `resetRateLimitGate()` on community switch in
 //! `useCommunityInit.ts`. A 429 from community A cannot stall community B.
@@ -36,8 +40,7 @@ const DEFAULT_RATE_LIMIT_SECONDS: u64 = 10;
 /// Prevents an untrusted relay from pinning traffic for an unreasonable window
 /// or overflowing `Instant` arithmetic.
 /// Exposed `pub` so `relay.rs` can clamp the hint before embedding it in the
-/// returned error string — ensuring every consumer (Rust gate and TS gate via
-/// `applyTauriRateLimitIfNeeded`) sees the same capped value.
+/// returned error string, matching the window the native HTTP gate honours.
 pub const MAX_HINT_SECONDS: u64 = 300;
 
 static GATE_EXPIRY: Mutex<Option<Instant>> = Mutex::new(None);
diff --git a/desktop/src/features/channels/useLiveChannelUpdates.test.mjs b/desktop/src/features/channels/useLiveChannelUpdates.test.mjs
new file mode 100644
index 00000000000..5b80bd91f6d
--- /dev/null
+++ b/desktop/src/features/channels/useLiveChannelUpdates.test.mjs
@@ -0,0 +1,380 @@
+import assert from "node:assert/strict";
+import { after, before, test } from "node:test";
+import { JSDOM } from "jsdom";
+import { HOME_MENTION_EVENT_KINDS } from "@/shared/constants/kinds";
+
+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,
+    localStorage: dom.window.localStorage,
+  });
+});
+after(() => dom.window.close());
+
+const VIEWER = "a".repeat(64);
+const PEER = "b".repeat(64);
+function channels(count) {
+  return Array.from({ length: count }, (_, i) => ({
+    id: `channel-${i}`,
+    name: `channel-${i}`,
+    channelType: i === 0 ? "dm" : "stream",
+  }));
+}
+function message(id, overrides = {}) {
+  return {
+    id,
+    kind: 9,
+    pubkey: PEER,
+    content: "hello",
+    created_at: Math.floor(Date.now() / 1000),
+    tags: [
+      ["h", "channel-0"],
+      ["p", VIEWER],
+    ],
+    sig: "",
+    ...overrides,
+  };
+}
+
+async function mount(initialChannels, options = {}, subscribeImpl) {
+  const { act, cleanup, renderHook } = await import("@testing-library/react");
+  const React = await import("react");
+  const { QueryClient, QueryClientProvider } = await import(
+    "@tanstack/react-query"
+  );
+  const { relayClient } = await import("@/shared/api/relayClient");
+  const { useLiveChannelUpdates } = await import("./useLiveChannelUpdates.ts");
+  const { channelMessagesKey } = await import(
+    "@/features/messages/lib/messageQueryKeys"
+  );
+  const originalLive = relayClient.subscribeLive;
+  // Keep a tripwire for the removed API so restoring the second family fails.
+  const originalMention = Object.getOwnPropertyDescriptor(
+    relayClient,
+    "subscribeToChannelMentionEvents",
+  );
+  const subscriptions = [];
+  const mentionSubscriptions = [];
+  relayClient.subscribeLive = async (filter, onEvent) => {
+    const sub = { filter, onEvent, disposed: false };
+    subscriptions.push(sub);
+    await subscribeImpl?.(sub);
+    return async () => {
+      sub.disposed = true;
+    };
+  };
+  relayClient.subscribeToChannelMentionEvents = async (...args) => {
+    mentionSubscriptions.push(args);
+    return async () => {};
+  };
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false, gcTime: Infinity } },
+  });
+  const wrapper = ({ children }) =>
+    React.createElement(QueryClientProvider, { client: queryClient }, children);
+  const hook = renderHook(
+    ({ members, opts }) => useLiveChannelUpdates(members, null, opts),
+    {
+      wrapper,
+      initialProps: {
+        members: initialChannels,
+        opts: { currentPubkey: VIEWER, ...options },
+      },
+    },
+  );
+  const settle = () =>
+    act(async () => {
+      // Drain subscription setup and React Query notifications, not relay timing.
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+  await settle();
+  return {
+    act,
+    settle,
+    subscriptions,
+    mentionSubscriptions,
+    queryClient,
+    channelMessagesKey,
+    rerender(members, opts = options) {
+      hook.rerender({ members, opts: { currentPubkey: VIEWER, ...opts } });
+    },
+    async deliver(sub, event) {
+      await act(async () => {
+        sub.onEvent(event);
+      });
+    },
+    unmount: hook.unmount,
+    restore() {
+      hook.unmount();
+      cleanup();
+      queryClient.clear();
+      relayClient.subscribeLive = originalLive;
+      if (originalMention) {
+        Object.defineProperty(
+          relayClient,
+          "subscribeToChannelMentionEvents",
+          originalMention,
+        );
+      } else {
+        delete relayClient.subscribeToChannelMentionEvents;
+      }
+    },
+  };
+}
+
+for (const count of [20, 50, 129]) {
+  test(`${count} member channels use one live stream each, not a second mention family`, async () => {
+    const h = await mount(channels(count), { onLiveMention() {} });
+    try {
+      assert.equal(h.subscriptions.length, count);
+      assert.equal(
+        h.mentionSubscriptions.length,
+        0,
+        "channel streams already include mention kinds",
+      );
+      assert.deepEqual(
+        h.subscriptions.map((s) => s.filter["#h"]),
+        channels(count)
+          .map((c) => [c.id])
+          .sort(),
+      );
+      assert.ok(h.subscriptions.every((s) => s.filter.since > 0));
+      assert.ok(
+        h.subscriptions.every((s) =>
+          HOME_MENTION_EVENT_KINDS.every((kind) =>
+            s.filter.kinds.includes(kind),
+          ),
+        ),
+        "the remaining wire filter must cover every Home mention kind",
+      );
+    } finally {
+      h.restore();
+    }
+  });
+}
+
+test("live channel stream drives mention, unread and DM callbacks once across replay", async () => {
+  const mentions = [];
+  const unreads = [];
+  const dms = [];
+  const h = await mount(channels(1), {
+    onLiveMention: () => mentions.push("mention"),
+    onChannelMessage: (id, event) => unreads.push([id, event.id]),
+    onDmMessage: (event, channel) => dms.push([channel.id, event.id]),
+  });
+  try {
+    const event = message("mention");
+    await h.deliver(h.subscriptions[0], event);
+    await h.deliver(h.subscriptions[0], event);
+    assert.deepEqual(mentions, ["mention"]);
+    assert.deepEqual(unreads, [["channel-0", "mention"]]);
+    assert.deepEqual(dms, [["channel-0", "mention"]]);
+  } finally {
+    h.restore();
+  }
+});
+
+test("mention signal retains kind, recipient, self and member-channel boundaries", async () => {
+  let mentions = 0;
+  const h = await mount(channels(1), { onLiveMention: () => mentions++ });
+  try {
+    const sub = h.subscriptions[0];
+    await h.deliver(
+      sub,
+      message("not-mentioned", { tags: [["h", "channel-0"]] }),
+    );
+    await h.deliver(sub, message("self", { pubkey: VIEWER.toUpperCase() }));
+    for (const kind of [5, 7, 9005, 40001, 40003, 40008, 40099, 48100, 48101]) {
+      await h.deliver(sub, message(`aux-${kind}`, { kind }));
+    }
+    await h.deliver(
+      sub,
+      message("outside", {
+        tags: [
+          ["h", "outside"],
+          ["p", VIEWER],
+        ],
+      }),
+    );
+    assert.equal(mentions, 0);
+    for (const kind of [9, 40002, 45001, 45003]) {
+      await h.deliver(
+        sub,
+        message(`mention-${kind}`, {
+          kind,
+          tags: [
+            ["h", "channel-0"],
+            ["p", VIEWER.toUpperCase()],
+          ],
+        }),
+      );
+    }
+    assert.equal(mentions, 4);
+  } finally {
+    h.restore();
+  }
+});
+
+test("latest mention callback and identity are used without subscription churn", async () => {
+  const notifications = [];
+  const h = await mount(channels(1));
+  try {
+    const sub = h.subscriptions[0];
+    await h.deliver(sub, message("before-callback"));
+    h.rerender(channels(1), {
+      onLiveMention: () => notifications.push("first"),
+    });
+    await h.deliver(sub, message("first"));
+    h.rerender(channels(1), {
+      onLiveMention: () => notifications.push("latest"),
+    });
+    await h.deliver(sub, message("second"));
+    h.rerender(channels(1), {
+      currentPubkey: "c".repeat(64),
+      onLiveMention: () => notifications.push("new-identity"),
+    });
+    await h.deliver(sub, message("old-viewer"));
+    await h.deliver(
+      sub,
+      message("new-viewer", {
+        tags: [
+          ["h", "channel-0"],
+          ["p", "c".repeat(64)],
+        ],
+      }),
+    );
+    h.rerender(channels(1));
+    await h.deliver(sub, message("disabled"));
+    assert.deepEqual(notifications, ["first", "latest", "new-identity"]);
+    assert.equal(h.subscriptions.length, 1);
+    assert.equal(h.mentionSubscriptions.length, 0);
+  } finally {
+    h.restore();
+  }
+});
+
+test("membership diff disposes removed channels and keeps unchanged channel delivery", async () => {
+  let mentions = 0;
+  const opts = { onLiveMention: () => mentions++ };
+  const h = await mount(channels(2), opts);
+  try {
+    const [removed, retained] = h.subscriptions;
+    h.rerender(channels(3).slice(1), opts);
+    await h.settle();
+    assert.equal(
+      h.subscriptions.length,
+      3,
+      "only the newly joined channel subscribes",
+    );
+    assert.equal(removed.disposed, true);
+    assert.equal(retained.disposed, false);
+    await h.deliver(removed, message("removed"));
+    await h.deliver(
+      retained,
+      message("retained", {
+        tags: [
+          ["h", "channel-1"],
+          ["p", VIEWER],
+        ],
+      }),
+    );
+    assert.equal(
+      mentions,
+      1,
+      "late event from a removed channel must not notify",
+    );
+  } finally {
+    h.restore();
+  }
+});
+
+test("untagged auxiliary event keeps its single-channel context in the timeline cache", async () => {
+  let mentions = 0;
+  const h = await mount(channels(2), { onLiveMention: () => mentions++ });
+  try {
+    const key = h.channelMessagesKey("channel-1");
+    h.queryClient.setQueryData(key, [
+      message("parent", { tags: [["h", "channel-1"]] }),
+    ]);
+    await h.deliver(
+      h.subscriptions[1],
+      message("reaction", {
+        kind: 7,
+        content: "👀",
+        tags: [
+          ["e", "parent"],
+          ["p", VIEWER],
+        ],
+      }),
+    );
+    const reaction = h.queryClient
+      .getQueryData(key)
+      .find((event) => event.id === "reaction");
+    assert.ok(reaction);
+    assert.deepEqual(reaction.tags.at(-1), ["h", "channel-1"]);
+    assert.equal(mentions, 0);
+  } finally {
+    h.restore();
+  }
+});
+
+test("one failed setup does not abort other channel streams and retries only that channel", async () => {
+  const originalSetTimeout = window.setTimeout;
+  const originalClearTimeout = window.clearTimeout;
+  const retries = new Map();
+  let timer = 0;
+  window.setTimeout = (fn) => {
+    retries.set(++timer, fn);
+    return timer;
+  };
+  window.clearTimeout = (id) => retries.delete(id);
+  let failOnce = true;
+  const h = await mount(channels(2), {}, async (sub) => {
+    if (sub.filter["#h"][0] === "channel-0" && failOnce) {
+      failOnce = false;
+      throw new Error("fixture subscription setup failure");
+    }
+  });
+  try {
+    assert.equal(h.subscriptions.length, 2);
+    assert.equal(retries.size, 1);
+    await h.act(async () => {
+      retries.values().next().value();
+    });
+    await h.settle();
+    assert.equal(h.subscriptions.length, 3);
+    assert.deepEqual(h.subscriptions[2].filter["#h"], ["channel-0"]);
+  } finally {
+    h.restore();
+    window.setTimeout = originalSetTimeout;
+    window.clearTimeout = originalClearTimeout;
+  }
+});
+
+test("unmount disposes both established and pending channel streams", async () => {
+  let release;
+  const h = await mount(channels(2), { onLiveMention() {} }, async (sub) => {
+    if (sub.filter["#h"][0] === "channel-1") {
+      await new Promise((resolve) => {
+        release = resolve;
+      });
+    }
+  });
+  try {
+    h.unmount();
+    assert.equal(h.subscriptions[0].disposed, true);
+    await h.act(async () => {
+      release();
+    });
+    assert.ok(h.subscriptions.every((sub) => sub.disposed));
+    assert.equal(h.mentionSubscriptions.length, 0);
+  } finally {
+    h.restore();
+  }
+});
diff --git a/desktop/src/features/channels/useLiveChannelUpdates.ts b/desktop/src/features/channels/useLiveChannelUpdates.ts
index 7598e8db3e5..b25df3acf92 100644
--- a/desktop/src/features/channels/useLiveChannelUpdates.ts
+++ b/desktop/src/features/channels/useLiveChannelUpdates.ts
@@ -9,11 +9,15 @@ import {
   getChannelIdFromTags,
   isThreadReply,
 } from "@/features/messages/lib/threading";
-import { shouldNotifyForEvent } from "@/features/notifications/lib/shouldNotify";
+import {
+  hasMentionForEvent,
+  shouldNotifyForEvent,
+} from "@/features/notifications/lib/shouldNotify";
 import { relayClient } from "@/shared/api/relayClient";
 import {
   CHANNEL_EVENT_KINDS,
   CHANNEL_MESSAGE_EVENT_KINDS,
+  HOME_MENTION_EVENT_KINDS,
 } from "@/shared/constants/kinds";
 import type { Channel, RelayEvent } from "@/shared/api/types";
 import {
@@ -142,10 +146,8 @@ export function useLiveChannelUpdates(
   const normalizedCurrentPubkey =
     options.currentPubkey?.trim().toLowerCase() ?? "";
   const seenMentionEventIdsRef = React.useRef(new Set<string>());
-  // Reconnect replay overlaps each live filter by five seconds so no message is
-  // lost at the boundary. Keep one shared guard for every notification side
-  // effect: the same event can be replayed repeatedly while a relay flaps, and
-  // mention events also arrive through both the channel and mention filters.
+  // Reconnect replay overlaps live filters so no message is lost at the
+  // boundary. Guard notification side effects against repeated delivery.
   const seenNotificationEventIdsRef = React.useRef(new Set<string>());
   const channelsInvalidateRef = React.useRef<TrailingDebounce | null>(null);
   if (channelsInvalidateRef.current === null) {
@@ -243,6 +245,17 @@ export function useLiveChannelUpdates(
     }
 
     const isDmChannel = dmChannelMap.has(channelId);
+    // Mention kinds are already in the channel stream. Keep Home's narrower
+    // kind/recipient policy without opening a second REQ for every channel.
+    if (
+      options.onLiveMention &&
+      HOME_MENTION_EVENT_KINDS.some((kind) => kind === event.kind) &&
+      isExternalMentionEvent(event, normalizedCurrentPubkey) &&
+      hasMentionForEvent(event, normalizedCurrentPubkey) &&
+      trackSeenEvent(seenMentionEventIdsRef.current, event.id)
+    ) {
+      options.onLiveMention();
+    }
     const isUnreadTriggerKind = isChannelUnreadTriggerKind(
       event.kind,
       isDmChannel,
@@ -338,19 +351,6 @@ export function useLiveChannelUpdates(
     );
   });
 
-  const handleMentionEvent = React.useEffectEvent((event: RelayEvent) => {
-    if (!isExternalMentionEvent(event, normalizedCurrentPubkey)) {
-      return;
-    }
-
-    if (!trackSeenEvent(seenMentionEventIdsRef.current, event.id)) {
-      return;
-    }
-
-    handleIncomingMessage(event);
-    options.onLiveMention?.();
-  });
-
   React.useEffect(() => {
     return relayClient.subscribeToReconnects(() => {
       void queryClient.invalidateQueries({ queryKey: channelsQueryKey });
@@ -446,105 +446,6 @@ export function useLiveChannelUpdates(
     };
   }, [channelIdsKey]);
 
-  // Subscribe to mention events per channel with a diff-based manager: only
-  // subscribe newly-added channels and unsubscribe removed ones on each sync.
-  // The ref survives re-renders so churn-with-identical-IDs does zero work.
-  const mentionSubsRef = React.useRef(new Map<string, () => Promise<void>>());
-  const mentionSubsPubkeyRef = React.useRef<string | null>(null);
-
-  React.useEffect(() => {
-    if (!options.onLiveMention || normalizedCurrentPubkey.length === 0) {
-      return;
-    }
-
-    let isCancelled = false;
-    let retryTimeout: number | undefined;
-    let retryAttempt = 0;
-
-    const syncSubs = async (): Promise<boolean> => {
-      const activeSubs = mentionSubsRef.current;
-
-      if (
-        mentionSubsPubkeyRef.current !== null &&
-        mentionSubsPubkeyRef.current !== normalizedCurrentPubkey
-      ) {
-        const stale = Array.from(activeSubs.values());
-        activeSubs.clear();
-        await Promise.allSettled(stale.map((dispose) => dispose()));
-        if (isCancelled) return true;
-      }
-      mentionSubsPubkeyRef.current = normalizedCurrentPubkey;
-
-      const targetIds = new Set(channelIdsKey ? channelIdsKey.split(",") : []);
-
-      for (const [channelId, dispose] of activeSubs) {
-        if (!targetIds.has(channelId)) {
-          activeSubs.delete(channelId);
-          void dispose().catch(() => {});
-        }
-      }
-
-      let anyFailed = false;
-      // Pass handleMentionEvent directly — it's a stable useEffectEvent
-      // callback. Do NOT wrap in an isCancelled check here: subs persist
-      // across effect runs (that's the point of the diff manager), so a
-      // stale isCancelled flag from a prior run would silently drop events
-      // on long-lived subs.
-      const additions = Array.from(targetIds)
-        .filter((channelId) => !activeSubs.has(channelId))
-        .map(async (channelId) => {
-          try {
-            const dispose = await relayClient.subscribeToChannelMentionEvents(
-              channelId,
-              normalizedCurrentPubkey,
-              handleMentionEvent,
-            );
-            if (isCancelled) {
-              void dispose().catch(() => {});
-              return;
-            }
-            activeSubs.set(channelId, dispose);
-          } catch (err) {
-            anyFailed = true;
-            console.error(
-              "Failed to subscribe to mention events",
-              channelId,
-              err,
-            );
-          }
-        });
-      await Promise.allSettled(additions);
-      return !anyFailed;
-    };
-
-    const runSync = async () => {
-      const ok = await syncSubs();
-      if (isCancelled) return;
-      if (ok) {
-        retryAttempt = 0;
-        return;
-      }
-      const delayMs = Math.min(
-        LIVE_SUBSCRIPTION_RETRY_BASE_MS * 2 ** retryAttempt,
-        LIVE_SUBSCRIPTION_RETRY_MAX_MS,
-      );
-      retryAttempt += 1;
-      retryTimeout = window.setTimeout(() => {
-        retryTimeout = undefined;
-        void runSync();
-      }, delayMs);
-    };
-
-    void runSync();
-
-    return () => {
-      isCancelled = true;
-      if (retryTimeout !== undefined) {
-        window.clearTimeout(retryTimeout);
-      }
-    };
-  }, [channelIdsKey, normalizedCurrentPubkey, options.onLiveMention]);
-
   React.useEffect(() => {
     return () => {
       channelsInvalidateRef.current?.cancel();
@@ -553,13 +454,6 @@ export function useLiveChannelUpdates(
         void dispose().catch(() => {});
       }
       liveSubsRef.current.clear();
-
-      const subs = mentionSubsRef.current;
-      for (const dispose of subs.values()) {
-        void dispose().catch(() => {});
-      }
-      subs.clear();
-      mentionSubsPubkeyRef.current = null;
     };
   }, []);
 }
diff --git a/desktop/src/shared/api/relayChannelFilters.ts b/desktop/src/shared/api/relayChannelFilters.ts
index b9f623a75f8..b9a6cb11508 100644
--- a/desktop/src/shared/api/relayChannelFilters.ts
+++ b/desktop/src/shared/api/relayChannelFilters.ts
@@ -2,7 +2,6 @@ import {
   CHANNEL_AUX_EVENT_KINDS,
   CHANNEL_EVENT_KINDS,
   CHANNEL_TIMELINE_CONTENT_KINDS,
-  HOME_MENTION_EVENT_KINDS,
   KIND_DELETION,
   KIND_NIP29_DELETE_EVENT,
   KIND_REACTION,
@@ -161,17 +160,3 @@ export function buildGlobalStreamFilter(
     limit,
   };
 }
-
-export function buildChannelMentionFilter(
-  channelId: string,
-  pubkey: string,
-  limit: number,
-): RelaySubscriptionFilter {
-  return {
-    kinds: [...HOME_MENTION_EVENT_KINDS],
-    "#h": [channelId],
-    "#p": [pubkey],
-    limit,
-    since: Math.floor(Date.now() / 1_000),
-  };
-}
diff --git a/desktop/src/shared/api/relayClientPublishRejection.test.mjs b/desktop/src/shared/api/relayClientPublishRejection.test.mjs
index 7875b8679ab..503ac329afa 100644
--- a/desktop/src/shared/api/relayClientPublishRejection.test.mjs
+++ b/desktop/src/shared/api/relayClientPublishRejection.test.mjs
@@ -16,6 +16,7 @@ const pendingTimers = new Map();
 let nextTimerId = 1;
 const sendAttempts = [];
 const deliveredFrames = [];
+let invokeError = null;
 let sendTransport = async (args) => {
   deliveredFrames.push(args);
 };
@@ -29,6 +30,7 @@ globalThis.window = {
   clearTimeout: (id) => pendingTimers.delete(id),
   __TAURI_INTERNALS__: {
     invoke: async (command, args) => {
+      if (command === "get_channels" && invokeError) throw invokeError;
       if (command === "plugin:websocket|send") {
         sendAttempts.push(args);
         return sendTransport(args);
@@ -39,12 +41,14 @@ globalThis.window = {
 Date.now = () => fakeNow;
 
 const { RelayClient } = await import("./relayClientSession.ts");
+const { invokeTauri } = await import("./tauri.ts");
 const { activateRateLimit, isRateLimited, resetRateLimitGate } = await import(
   "./relayRateLimitGate.ts"
 );
 
 function reset() {
   resetRateLimitGate();
+  invokeError = null;
   pendingTimers.clear();
   nextTimerId = 1;
   sendAttempts.length = 0;
@@ -293,3 +297,57 @@ test("a community switch after send failure cannot retry through its replacement
   );
   assert.equal(eventFrames().length, 0);
 });
+
+// Drive the actual invoke rejection and publisher, not a classifier helper.
+// Restoring HTTP -> WS gate propagation must fail before any timer advances.
+for (const message of [
+  "relay rate-limited: retry in 50s",
+  "relay rate-limited: quota exceeded",
+  "relay rate-limited: retry in 1000000s",
+]) {
+  test(`HTTP backoff does not withhold a WS publish: ${message}`, async () => {
+    reset();
+    invokeError = message;
+    await assert.rejects(invokeTauri("get_channels"), { message });
+    const client = connectedClient();
+    const event = { id: "9".repeat(64), kind: 9 };
+    const published = client.publishEvent(event, "timed out", "send failed");
+    try {
+      await flushUntil(() => eventFrames().length === 1);
+      assert.equal(isRateLimited(), false);
+      await deliver(client, ["OK", event.id, true, ""]);
+      assert.equal(await published, event);
+      assert.equal(client.pendingEvents.size, 0);
+    } finally {
+      // Also drain safely when the pre-fix gate coupling is restored.
+      resetRateLimitGate();
+      await flushUntil(() => eventFrames().length === 1);
+      await deliver(client, ["OK", event.id, true, ""]);
+      await published;
+    }
+  });
+}
+
+test("HTTP failure does not clear an existing WS backoff", async () => {
+  reset();
+  const client = connectedClient();
+  await deliver(client, [
+    "NOTICE",
+    "rate-limited: quota exceeded; retry in 4s",
+  ]);
+  invokeError = "relay rate-limited: retry in 50s";
+  await assert.rejects(invokeTauri("get_channels"), { message: invokeError });
+  const event = { id: "8".repeat(64), kind: 9 };
+  const published = client.publishEvent(event, "timed out", "send failed");
+  await Promise.resolve();
+  assert.equal(eventFrames().length, 0);
+  assert.equal(isRateLimited(), true);
+  assert.ok([...pendingTimers.values()].some(({ fireAt }) => fireAt === 4_000));
+  assert.ok(
+    ![...pendingTimers.values()].some(({ fireAt }) => fireAt === 50_000),
+  );
+  resetRateLimitGate();
+  await flushUntil(() => eventFrames().length === 1);
+  await deliver(client, ["OK", event.id, true, ""]);
+  assert.equal(await published, event);
+});
diff --git a/desktop/src/shared/api/relayClientSession.ts b/desktop/src/shared/api/relayClientSession.ts
index 95bcec79700..d9be0e6c9bc 100644
--- a/desktop/src/shared/api/relayClientSession.ts
+++ b/desktop/src/shared/api/relayClientSession.ts
@@ -26,7 +26,6 @@ import {
   buildChannelAuxDeletionFilter,
   buildChannelFilter,
   buildChannelHistoryFilter,
-  buildChannelMentionFilter,
   buildGlobalStreamFilter,
 } from "@/shared/api/relayChannelFilters";
 import {
@@ -413,16 +412,6 @@ export class RelayClient {
   ) {
     return this.subscribe(filter, onEvent, onReady, readinessTimeoutMs);
   }
-  async subscribeToChannelMentionEvents(
-    channelId: string,
-    pubkey: string,
-    onEvent: (event: RelayEvent) => void,
-  ) {
-    return this.subscribe(
-      buildChannelMentionFilter(channelId, pubkey, 50),
-      onEvent,
-    );
-  }
   async preconnect() {
     // Explicit re-engagement (reconnect card / community switch): clears the
     // terminal latch and AUTH rejection streak, and bypasses backoff once.
diff --git a/desktop/src/shared/api/relayRateLimitGate.test.mjs b/desktop/src/shared/api/relayRateLimitGate.test.mjs
index a458e87b487..dd2346911fe 100644
--- a/desktop/src/shared/api/relayRateLimitGate.test.mjs
+++ b/desktop/src/shared/api/relayRateLimitGate.test.mjs
@@ -177,29 +177,6 @@ test("hint exactly at MAX_HINT_SECONDS is honoured without clamping", () => {
   assert.equal(isRateLimited(), false);
 });
 
-test("applyTauriRateLimitIfNeeded with oversized hint clamps to MAX_HINT_SECONDS", async () => {
-  // This test imports applyTauriRateLimitIfNeeded separately and verifies that
-  // the TS cap applies even when the message string contains a large hint value
-  // (the Rust layer clamps in practice, but TS must be independently safe).
-  reset(0);
-  const { applyTauriRateLimitIfNeeded } = await import("./tauri.ts");
-  // Simulate a message that somehow escaped the Rust cap (defence-in-depth).
-  applyTauriRateLimitIfNeeded("relay rate-limited: retry in 1000000s");
-  // Gate should cap at MAX_HINT_SECONDS * 1000 ms.
-  tickTo(MAX_HINT_SECONDS * 1_000 - 1);
-  assert.equal(
-    isRateLimited(),
-    true,
-    "gate must still be active just before cap",
-  );
-  tickTo(MAX_HINT_SECONDS * 1_000 + 1);
-  assert.equal(
-    isRateLimited(),
-    false,
-    "gate must expire at MAX_HINT_SECONDS, not 1 000 000s",
-  );
-});
-
 // ── waitForRateLimit ──────────────────────────────────────────────────────────
 
 test("waitForRateLimit resolves immediately when not rate-limited", async () => {
diff --git a/desktop/src/shared/api/relayRateLimitGate.ts b/desktop/src/shared/api/relayRateLimitGate.ts
index 040bedae780..827713eb069 100644
--- a/desktop/src/shared/api/relayRateLimitGate.ts
+++ b/desktop/src/shared/api/relayRateLimitGate.ts
@@ -1,9 +1,9 @@
 /**
- * Module-level rate-limit gate for the relay WebSocket and HTTP bridge.
+ * Module-level rate-limit gate for relay WebSocket operations.
  *
- * When the relay signals back-pressure via a CLOSED `rate-limited:` message or
- * an HTTP 429 response, callers activate the gate. Operations that must not run
- * while rate-limited call `isRateLimited()` or await `waitForRateLimit()`.
+ * WebSocket back-pressure activates this gate. HTTP 429s are handled by the
+ * native HTTP gate: ApiCalls and WsEvents are separate relay quota budgets.
+ * Callers that must not run while WS-limited await `waitForRateLimit()`.
  *
  * The gate is a singleton: one shared expiry covers all concurrent callers so
  * overlapping hints (multiple CLOSED frames) extend to the latest expiry without
@@ -15,12 +15,10 @@
 const DEFAULT_RATE_LIMIT_SECONDS = 10;
 
 /**
- * Maximum hint the TS gate will honour from a relay 429 response.
+ * Maximum hint the TS gate will honour from a WebSocket rejection.
  *
- * Mirrors `MAX_HINT_SECONDS` in `relay_admission.rs` (Rust). The Rust relay
- * layer clamps the hint before embedding it in the error string, so in practice
- * this TS cap is a defence-in-depth guard against any future Rust path that
- * forgets to clamp, keeping both gates on the same documented bound.
+ * Uses the same cap as the native HTTP gate (`MAX_HINT_SECONDS` in
+ * `relay_admission.rs`), but each transport consumes its own retry hints.
  */
 export const MAX_HINT_SECONDS = 300;
 
diff --git a/desktop/src/shared/api/tauri.test.mjs b/desktop/src/shared/api/tauri.test.mjs
index 2273b55fca3..203c0fca2e9 100644
--- a/desktop/src/shared/api/tauri.test.mjs
+++ b/desktop/src/shared/api/tauri.test.mjs
@@ -1,117 +1,6 @@
-/**
- * Unit tests for tauri.ts — focused on `applyTauriRateLimitIfNeeded`, the
- * extracted `relay rate-limited:` classifier that activates the shared
- * rate-limit gate when Rust emits an HTTP 429 error prefix.
- *
- * Testing the exported production function (not a local copy) ensures any
- * change to the classifier logic is immediately covered here.
- */
 import assert from "node:assert/strict";
 import test from "node:test";
 
-// ── Fake-timer + gate setup ───────────────────────────────────────────────────
-
-let fakeNow = 0;
-const pendingTimers = new Map();
-let nextTimerId = 1;
-
-function fakeSetTimeout(fn, ms) {
-  const id = nextTimerId++;
-  pendingTimers.set(id, { fn, fireAt: fakeNow + ms });
-  return id;
-}
-
-function fakeClearTimeout(id) {
-  pendingTimers.delete(id);
-}
-
-function tickTo(ms) {
-  fakeNow = ms;
-  for (const [id, { fn, fireAt }] of Array.from(pendingTimers.entries())) {
-    if (fireAt <= fakeNow) {
-      pendingTimers.delete(id);
-      fn();
-    }
-  }
-}
-
-const origDateNow = Date.now;
-function setFakeNow(ms) {
-  fakeNow = ms;
-  Date.now = () => fakeNow;
-}
-
-globalThis.window = {
-  setTimeout: fakeSetTimeout,
-  clearTimeout: fakeClearTimeout,
-};
-
-setFakeNow(0);
-
-const { isRateLimited, resetRateLimitGate } = await import(
-  "./relayRateLimitGate.ts"
-);
-
-// Import the production classifier from tauri.ts — tests must exercise the
-// real function, not a local copy, so a logic change is always caught here.
-const { applyTauriRateLimitIfNeeded } = await import("./tauri.ts");
-
-function resetGate(startMs = 0) {
-  pendingTimers.clear();
-  nextTimerId = 1;
-  setFakeNow(startMs);
-  resetRateLimitGate();
-}
-
-// ── applyTauriRateLimitIfNeeded: relay rate-limited: prefix ───────────────────
-
-test("relay rate-limited: prefix activates the rate-limit gate", () => {
-  resetGate(0);
-  applyTauriRateLimitIfNeeded("relay rate-limited: retry in 10s");
-  assert.equal(isRateLimited(), true, "gate must be active after 429 error");
-});
-
-test("relay rate-limited: prefix parses the retry hint and arms the gate duration", () => {
-  resetGate(0);
-  applyTauriRateLimitIfNeeded("relay rate-limited: retry in 7s");
-  // Gate should be active at 6s.
-  setFakeNow(6_000);
-  assert.equal(isRateLimited(), true);
-  // Gate should expire after 7s.
-  tickTo(7_001);
-  assert.equal(isRateLimited(), false);
-});
-
-test("relay rate-limited: with no hint uses the 10s default", () => {
-  resetGate(0);
-  applyTauriRateLimitIfNeeded("relay rate-limited: quota exceeded");
-  tickTo(9_999);
-  assert.equal(isRateLimited(), true);
-  tickTo(10_001);
-  assert.equal(isRateLimited(), false);
-});
-
-test("non-rate-limited error does not activate the gate", () => {
-  resetGate(0);
-  applyTauriRateLimitIfNeeded("relay returned 404 Not Found");
-  assert.equal(
-    isRateLimited(),
-    false,
-    "gate must remain inactive for unrelated errors",
-  );
-});
-
-test("relay rate-limited: prefix check is case-sensitive (Rust always emits lowercase)", () => {
-  resetGate(0);
-  // The prefix from Rust is always lowercase; mixed-case must not trigger it.
-  applyTauriRateLimitIfNeeded("Relay rate-limited: retry in 5s");
-  assert.equal(
-    isRateLimited(),
-    false,
-    "uppercase prefix must not activate gate (relay emits lowercase only)",
-  );
-});
-
 // ── fromRawAcpRuntimeCatalogEntry: custom row API-boundary (B-2) ─────────────
 //
 // These tests feed real raw custom catalog rows through fromRawAcpRuntimeCatalogEntry
@@ -256,10 +145,3 @@ test("fromRawAcpRuntimeCatalogEntry omits maxParallelism when max_parallelism is
     "uncapped harness must have maxParallelism: undefined",
   );
 });
-
-// ── Teardown ──────────────────────────────────────────────────────────────────
-
-test("teardown — restore Date.now", () => {
-  Date.now = origDateNow;
-  assert.ok(true);
-});
diff --git a/desktop/src/shared/api/tauri.ts b/desktop/src/shared/api/tauri.ts
index 984b9d176df..76dadebe8b7 100644
--- a/desktop/src/shared/api/tauri.ts
+++ b/desktop/src/shared/api/tauri.ts
@@ -1,8 +1,4 @@
 import { invoke as tauriInvoke } from "@tauri-apps/api/core";
-import {
-  activateRateLimit,
-  parseRateLimitHint,
-} from "@/shared/api/relayRateLimitGate";
 import {
   fromRawInstallRuntimeResult,
   type RawInstallRuntimeResult,
@@ -280,18 +276,6 @@ function toTauriError(error: unknown): Error {
   }
 }
 
-/**
- * Inspect a Tauri error message and activate the shared rate-limit gate when
- * the Rust relay layer emitted an HTTP 429 response (`relay rate-limited:` prefix).
- *
- * Extracted so it can be unit-tested without mocking the Tauri invoke bridge.
- */
-export function applyTauriRateLimitIfNeeded(message: string): void {
-  if (message.startsWith("relay rate-limited:")) {
-    activateRateLimit(parseRateLimitHint(message));
-  }
-}
-
 export async function invokeTauri<T>(
   command: string,
   args?: Record<string, unknown>,
@@ -299,11 +283,9 @@ export async function invokeTauri<T>(
   try {
     return await tauriInvoke<T>(command, args);
   } catch (error) {
-    const err = toTauriError(error);
-    // Rust emits `relay rate-limited:` for HTTP 429 responses. Activate the
-    // shared gate so the TS relay client backs off for the same window.
-    applyTauriRateLimitIfNeeded(err.message);
-    throw err;
+    // HTTP backoff lives in Rust. Do not apply its separate ApiCalls quota
+    // to the WebSocket gate, but preserve the failure for the caller.
+    throw toTauriError(error);
   }
 }
 

From d074576871a66c72e4a9eb5ad59ec0b22a7f0081 Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Fri, 11 Sep 2026 11:19:17 -0400
Subject: [PATCH 18/19] fix(mobile): bind same-name mentions to exact selected
 identities (#7385)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

<!-- Draft PR body for #7385 · fix(mobile): bind same-name mentions to
exact selected identities · https://github.com/block/buzz/pull/7385 -->

🤖

## Summary

If two people in a channel share a display name, mobile couldn't tell
them apart in mentions: picking the second could overwrite the first's
selection, a rendered mention linked whichever same-name person matched
first, and a later rename or a shorter name could re-bind the text to
the wrong recipient. This PR binds every mention to the exact selected
identity:

- Each same-name selection keeps its own recipient instead of
overwriting by name; conflicting picks get a qualified label like `Name
(key…)`.
- The longest matching label wins, so a shorter or interior name can
never claim part of a longer one and steal its identity.
- Rendering resolves recipients by the signed identity key from the
event's tags — never from message text alone — so qualified labels stay
correct regardless of tag order and survive later renames; an untagged
ambiguous label blocks shorter mentions instead of silently re-binding.

Ports the landed Desktop exact-recipient behavior (see
`docs/mention-editor.md`).

### Related issue

- Fixes: N/A. No mobile issue; Desktop's landed exact-recipient fixes
are the reference this ports.
- Independent base (`main`). #7387 (child) persists these exact
selections in saved drafts.
- Landing note: branches in this series overlap in the composer — when
rebasing, keep exact/durable mention bindings, the explicit
invite/reference-only choice, the account/visit/revision fences, and
authorization before membership preparation and publication; don't
resolve conflicts by taking either side wholesale.
- Draft — not requesting merge yet; the security advisory run for this
range timed out without results (no verdict).

### Testing

- Regressions cover same-name collisions, prefix/overlap, removal, tag
order, and renames.
- At `acd841354a692243f1cb4c04059baad42f1d2abb`: `just mobile-check` and
full `just mobile-test` pass (2,082 tests). The earlier full `just ci`
receipt linked below is reused only for unchanged non-mobile
code/tooling, not claimed as a rerun at this head.
- Previous-head evidence: `just mobile-check`, the full mobile test
suite, and full local `just ci` all pass — receipts in the [exact-head
evidence
comment](https://github.com/block/buzz/pull/7385#issuecomment-5574635836).
- Verification is widget-test level; no native device or simulator run
is claimed.

To see it: mention two teammates with the same display name — both stay
distinct, the second shows a qualified label, and the rendered message
keeps both correct even after either renames.

### Screenshots

Flutter production-widget test renders — not native-device screenshots
or acceptance captures.

| Scenario | Before | After |
|---|---|---|
| Qualified mention chip for same-name recipients, at 200% text scale
(deliberate stress fixture) | ![Before: the short chip is followed by
the distinguishing key spilling out as raw
text](https://github.com/user-attachments/assets/f1e40acc-24f1-47f7-b2f7-e3ba2348c169)
| ![After: the full qualified label wraps inside the bounded chip,
keeping the @ and robot glyph
visible](https://github.com/user-attachments/assets/b949e44f-e3f6-4c72-98ff-68139b2e1ab3)
|

<details>
<summary>Capture provenance</summary>

Rendered by the Flutter widget engine in a `flutter test` run
(production widgets, production theme; no device or simulator). Before:
this PR's declared base `3c7f288c60d67df78577b237e27c3dfc8831aaa1`.
After: its head `39afd73b0adfde14164f4b10dbd089cb498312b6`.

</details>

Signed-off-by: Logan Johnson <loganj@squareup.com>
---
 .../activity/compose_drafts_provider.dart     |  44 ++-
 mobile/lib/features/channels/compose_bar.dart |   1 +
 .../compose_bar/agent_mention_labels.dart     |  54 ++-
 .../compose_bar/compose_bar_widget.dart       |  62 +++-
 .../channels/compose_bar/draft_lifecycle.dart |  55 ++-
 .../markdown_editing_controller.dart          |  10 +
 .../channels/mentions/mention_ranking.dart    |   4 +
 .../features/channels/message_content.dart    |  85 +++--
 .../lib/shared/mentions/mention_bindings.dart |  88 +++++
 .../channels/channel_detail_page_test.dart    |  70 ++++
 .../features/channels/compose_bar_test.dart   |   6 +
 .../compose_bar_test/exact_mention_tests.dart | 312 ++++++++++++++++++
 .../message_content_exact_mentions_test.dart  |  51 +++
 .../mentions/mention_bindings_test.dart       |  56 ++++
 14 files changed, 837 insertions(+), 61 deletions(-)
 create mode 100644 mobile/lib/shared/mentions/mention_bindings.dart
 create mode 100644 mobile/test/features/channels/compose_bar_test/exact_mention_tests.dart
 create mode 100644 mobile/test/features/channels/message_content_exact_mentions_test.dart
 create mode 100644 mobile/test/shared/mentions/mention_bindings_test.dart

diff --git a/mobile/lib/features/activity/compose_drafts_provider.dart b/mobile/lib/features/activity/compose_drafts_provider.dart
index b5755f19c8d..cdeb7030923 100644
--- a/mobile/lib/features/activity/compose_drafts_provider.dart
+++ b/mobile/lib/features/activity/compose_drafts_provider.dart
@@ -22,6 +22,10 @@ class ComposeDraft {
   final String channelId;
   final String? threadHeadId;
   final String text;
+
+  /// Literal picker labels bound to exact keys, never authorization metadata.
+  /// An empty key/value is a malformed-record tombstone; send must refuse it.
+  final Map<String, String> mentionKeys;
   final int updatedAt; // unix seconds
 
   const ComposeDraft({
@@ -30,6 +34,7 @@ class ComposeDraft {
     required this.threadHeadId,
     required this.text,
     required this.updatedAt,
+    this.mentionKeys = const {},
   });
 
   Map<String, dynamic> toJson() => {
@@ -37,6 +42,7 @@ class ComposeDraft {
     'channel_id': channelId,
     if (threadHeadId != null) 'thread_head_id': threadHeadId,
     'text': text,
+    'mention_keys': mentionKeys,
     'updated_at': updatedAt,
   };
 
@@ -48,10 +54,32 @@ class ComposeDraft {
     final updatedAt = raw['updated_at'];
     if (key is! String || channelId is! String || text is! String) return null;
     if (text.trim().isEmpty) return null;
+    final bindings = raw['mention_keys'];
+    final mentionKeys = <String, String>{};
+    if (raw.containsKey('mention_keys')) {
+      if (bindings is! Map<String, dynamic>) {
+        mentionKeys[''] = '';
+      } else {
+        final labels = <String>{};
+        for (final entry in bindings.entries) {
+          if (!labels.add(entry.key.toLowerCase())) mentionKeys[''] = '';
+          final value = entry.value;
+          mentionKeys[entry.key] =
+              entry.key.isNotEmpty &&
+                  value is String &&
+                  RegExp(r'^[0-9a-fA-F]{64}$').hasMatch(value)
+              ? value.toLowerCase()
+              : '';
+        }
+      }
+    }
     return ComposeDraft(
       key: key,
       channelId: channelId,
-      threadHeadId: raw['thread_head_id'] as String?,
+      threadHeadId: raw['thread_head_id'] is String
+          ? raw['thread_head_id'] as String
+          : null,
+      mentionKeys: Map.unmodifiable(mentionKeys),
       text: text,
       updatedAt: updatedAt is int ? updatedAt : 0,
     );
@@ -108,18 +136,23 @@ class ComposeDraftsNotifier extends Notifier<List<ComposeDraft>> {
     required String channelId,
     String? threadHeadId,
     required String text,
+    Map<String, String> mentionKeys = const {},
   }) {
     if (text.trim().isEmpty) {
       remove(key);
       return;
     }
     final existing = state.where((d) => d.key == key).firstOrNull;
-    if (existing?.text == text) return;
+    if (existing?.text == text &&
+        mapEquals(existing?.mentionKeys, mentionKeys)) {
+      return;
+    }
     final draft = ComposeDraft(
       key: key,
       channelId: channelId,
       threadHeadId: threadHeadId,
       text: text,
+      mentionKeys: Map.unmodifiable(mentionKeys),
       updatedAt: DateTime.now().millisecondsSinceEpoch ~/ 1000,
     );
     final next = [draft, ...state.where((d) => d.key != key)];
@@ -131,8 +164,11 @@ class ComposeDraftsNotifier extends Notifier<List<ComposeDraft>> {
     _persist([...state.where((d) => d.key != key)]);
   }
 
-  String? textFor(String key) =>
-      state.where((d) => d.key == key).firstOrNull?.text;
+  /// Read text and selected identities from the same persisted snapshot.
+  ComposeDraft? draftFor(String key) =>
+      state.where((d) => d.key == key).firstOrNull;
+
+  String? textFor(String key) => draftFor(key)?.text;
 
   void _persist(List<ComposeDraft> drafts) {
     state = List.unmodifiable(drafts);
diff --git a/mobile/lib/features/channels/compose_bar.dart b/mobile/lib/features/channels/compose_bar.dart
index 726528a23e6..71ba39d14ec 100644
--- a/mobile/lib/features/channels/compose_bar.dart
+++ b/mobile/lib/features/channels/compose_bar.dart
@@ -18,6 +18,7 @@ import 'package:lucide_icons_flutter/lucide_icons.dart';
 import 'package:nostr/nostr.dart' as nostr;
 
 import '../../shared/mentions/agent_identity_provider.dart';
+import '../../shared/mentions/mention_bindings.dart';
 import '../../shared/huddle/huddle_session.dart';
 import '../../shared/relay/relay.dart';
 import '../../shared/theme/theme.dart';
diff --git a/mobile/lib/features/channels/compose_bar/agent_mention_labels.dart b/mobile/lib/features/channels/compose_bar/agent_mention_labels.dart
index bc29d5bb468..b988c3040ec 100644
--- a/mobile/lib/features/channels/compose_bar/agent_mention_labels.dart
+++ b/mobile/lib/features/channels/compose_bar/agent_mention_labels.dart
@@ -1,10 +1,54 @@
 part of '../compose_bar.dart';
 
 Set<String> _agentMentionLabels({
-  required Iterable<MentionCandidate> candidates,
-}) {
-  return <String>{
-    for (final candidate in candidates)
-      if (candidate.isAgent) candidate.label,
+  required Map<String, MentionCandidate> bindings,
+}) => {
+  for (final entry in bindings.entries)
+    if (entry.value.isAgent) entry.key,
+};
+
+List<MentionCandidate> _resolveComposerMentions(
+  String text,
+  Map<String, MentionCandidate> selected,
+  List<MentionCandidate> members,
+  List<MentionCandidate> restoredCandidates,
+) {
+  // A broken record cannot fall back to a same-name roster entry.
+  if (selected.values.any((c) => c.pubkey.isEmpty)) {
+    throw const FormatException(
+      'Saved mention identity is invalid. Clear the draft and select again.',
+    );
+  }
+  final candidates = <String, List<MentionCandidate>>{
+    for (final e in selected.entries) e.key.toLowerCase(): [e.value],
   };
+  final selectedNames = candidates.keys.toSet();
+  for (final member in members) {
+    final label = member.label.toLowerCase();
+    if (!selectedNames.contains(label)) (candidates[label] ??= []).add(member);
+  }
+  final winners = <String, MentionCandidate>{};
+  for (final range in mentionOccurrences(text, candidates.keys)) {
+    final identities = {
+      for (final c in candidates[range.label]!) c.pubkey.toLowerCase(): c,
+    };
+    if (identities.length > 1) {
+      throw FormatException(
+        'The mention @${range.label} is ambiguous. Choose a recipient from the mention picker.',
+      );
+    }
+    for (final entry in identities.entries) {
+      final selected = entry.value;
+      final current = restoredCandidates
+          .where((c) => c.pubkey == entry.key)
+          .firstOrNull;
+      if (selected.requiresRevalidation && current == null) {
+        throw const FormatException(
+          'Saved mention is no longer available. Select it again from the picker.',
+        );
+      }
+      winners[entry.key] = selected.requiresRevalidation ? current! : selected;
+    }
+  }
+  return winners.values.toList();
 }
diff --git a/mobile/lib/features/channels/compose_bar/compose_bar_widget.dart b/mobile/lib/features/channels/compose_bar/compose_bar_widget.dart
index ca34ffd2a1b..dbf8b8f0fbe 100644
--- a/mobile/lib/features/channels/compose_bar/compose_bar_widget.dart
+++ b/mobile/lib/features/channels/compose_bar/compose_bar_widget.dart
@@ -86,7 +86,9 @@ class ComposeBar extends HookConsumerWidget {
       attachments: attachments,
     );
     final voiceNoteRef = useRef(voiceNote)..value = voiceNote;
+    final mentionMap = useRef(<String, MentionCandidate>{});
     _useComposeDraftLifecycle(
+      mentionMap: mentionMap,
       ref: ref,
       controller: controller,
       draftKey: draftKey,
@@ -219,7 +221,6 @@ class ComposeBar extends HookConsumerWidget {
     // Map of displayName → selected mention candidate built as the user selects
     // mentions. Used to pass resolved pubkeys directly to onSend and to attach
     // selected non-member agents before the message is published.
-    final mentionMap = useRef(<String, MentionCandidate>{});
 
     // Channel autocomplete state ----------------------------------------------
     final channelQuery = useState<String?>(null);
@@ -244,9 +245,7 @@ class ComposeBar extends HookConsumerWidget {
     // owners so @mention suggestions show names ("managed by …" included).
     final relayAgents = ref.watch(agentDirectoryProvider).asData?.value;
     final agentOwners = ref.watch(agentOwnersProvider).asData?.value;
-    final agentMentionLabels = _agentMentionLabels(
-      candidates: mentionMap.value.values,
-    );
+    final agentMentionLabels = _agentMentionLabels(bindings: mentionMap.value);
     final agentMentionLabelsKey = (agentMentionLabels.toList()..sort()).join(
       '\u0000',
     );
@@ -263,6 +262,9 @@ class ComposeBar extends HookConsumerWidget {
         );
         final pubkeys = [
           ...memberList.map((m) => m.pubkey),
+          ...mentionMap.value.values
+              .where((c) => c.requiresRevalidation && c.pubkey.isNotEmpty)
+              .map((c) => c.pubkey),
           ...?relayAgents?.map((a) => a.pubkey),
           ...?agentOwners?.values,
         ];
@@ -272,6 +274,8 @@ class ComposeBar extends HookConsumerWidget {
         return null;
       },
       [
+        draftIdentity,
+        draftKey,
         membersAsync.asData?.value.length,
         cachedMembers.length,
         relayAgents?.length,
@@ -382,7 +386,10 @@ class ComposeBar extends HookConsumerWidget {
 
     // Insert a selected mention into the text field.
     void insertMention(MentionCandidate candidate) {
-      final name = candidate.label;
+      final name = selectedMentionLabel(candidate.label, candidate.pubkey, {
+        for (final entry in mentionMap.value.entries)
+          entry.key: entry.value.pubkey,
+      });
       // Track the resolved candidate so we can pass its pubkey and prepare
       // selected non-member agents at send time.
       mentionMap.value[name] = candidate;
@@ -470,10 +477,45 @@ class ComposeBar extends HookConsumerWidget {
       final messenger = ScaffoldMessenger.maybeOf(context);
 
       // Extract pubkeys for mentions present in the final text.
-      final selectedMentions = <MentionCandidate>[
-        for (final entry in mentionMap.value.entries)
-          if (hasMention(text, entry.key)) entry.value,
-      ];
+      List<MentionCandidate> selectedMentions;
+      try {
+        selectedMentions = _resolveComposerMentions(
+          text,
+          mentionMap.value,
+          buildMentionCandidates(
+            members: channelMembersForAutocomplete(
+              membersAsync: membersAsync,
+              sessionStatus: sessionStatus,
+              cachedMembers: cachedMembers,
+            ),
+            relayAgents: const [],
+            sharedChannelIds: const {},
+            userCache: userCache,
+            ownerByAgentPubkey: agentOwners ?? const {},
+          ),
+          buildMentionCandidates(
+            members: membersAsync.asData?.value ?? const [],
+            relayAgents: relayAgents ?? const [],
+            sharedChannelIds: {
+              for (final c in channels)
+                if (c.isMember && !c.isArchived) c.id,
+            },
+            userCache: userCache,
+            ownerByAgentPubkey: agentOwners ?? const {},
+            currentPubkey: currentPubkey,
+            // Reuse ordinary search-result classification, not membership as
+            // permission. Persisted keys/flags themselves prove no role.
+            searchResults: [
+              for (final c in mentionMap.value.values)
+                if (c.requiresRevalidation && userCache[c.pubkey] != null)
+                  userCache[c.pubkey]!,
+            ],
+          ),
+        );
+      } on FormatException catch (error) {
+        messenger?.showSnackBar(SnackBar(content: Text(error.message)));
+        return;
+      }
       final outgoing = _OutgoingMentions(selectedMentions);
       final scan = await _scanNonMemberMentions(
         ref,
@@ -589,12 +631,12 @@ class ComposeBar extends HookConsumerWidget {
             if (context.mounted &&
                 queueGeneration == uploadGeneration.value &&
                 draftRevision.value == clearedDraftRevision) {
-              controller.value = draftText;
               attachments.value = draftAttachments;
               retainedForRetry = true;
               mentionMap.value
                 ..clear()
                 ..addAll(draftMentions);
+              controller.value = draftText;
               focusNode.requestFocus();
             }
           } finally {
diff --git a/mobile/lib/features/channels/compose_bar/draft_lifecycle.dart b/mobile/lib/features/channels/compose_bar/draft_lifecycle.dart
index b712091b716..5ef69eaa59b 100644
--- a/mobile/lib/features/channels/compose_bar/draft_lifecycle.dart
+++ b/mobile/lib/features/channels/compose_bar/draft_lifecycle.dart
@@ -26,10 +26,10 @@ Future<void> _sendTextOnlyDraft({
         draftRevision.value != clearedDraftRevision) {
       return;
     }
-    controller.value = clearedDraftText;
     mentionMap.value
       ..clear()
       ..addAll(clearedDraftMentions);
+    controller.value = clearedDraftText;
     focusNode.requestFocus();
   }
 
@@ -63,6 +63,7 @@ Future<void> _sendTextOnlyDraft({
 }
 
 void _useComposeDraftLifecycle({
+  required ObjectRef<Map<String, MentionCandidate>> mentionMap,
   required WidgetRef ref,
   required _MarkdownEditingController controller,
   required String draftKey,
@@ -82,11 +83,25 @@ void _useComposeDraftLifecycle({
 }) {
   final lastDraftIdentity = useRef<String?>(null);
   useEffect(() {
+    final identity = '$draftIdentity\u0000$draftKey';
+    final shouldHydrate = lastDraftIdentity.value != identity;
     final identityChanged =
-        lastDraftIdentity.value != null &&
-        lastDraftIdentity.value != draftIdentity;
-    lastDraftIdentity.value = draftIdentity;
-    final saved = ref.read(composeDraftsProvider.notifier).textFor(draftKey);
+        lastDraftIdentity.value != null && lastDraftIdentity.value != identity;
+    lastDraftIdentity.value = identity;
+    final saved = ref.read(composeDraftsProvider.notifier).draftFor(draftKey);
+    if (shouldHydrate) {
+      mentionMap.value
+        ..clear()
+        ..addAll({
+          for (final entry
+              in (saved?.mentionKeys ?? <String, String>{}).entries)
+            entry.key: MentionCandidate(
+              pubkey: entry.value,
+              displayName: entry.key,
+              requiresRevalidation: true,
+            ),
+        });
+    }
     if (identityChanged) {
       draftRevision.value += 1;
       onDraftIdentityChanged();
@@ -101,15 +116,38 @@ void _useComposeDraftLifecycle({
       final staleAttachments = attachments.value;
       attachments.value = const [];
       unawaited(_deleteOwnedAttachments(staleAttachments));
-      controller.text = saved ?? '';
+      controller.text = saved?.text ?? '';
     } else if (saved != null && controller.text.isEmpty) {
-      controller.text = saved;
+      controller.text = saved.text;
     }
 
     var lastPersistedText = controller.text;
+    var lastBindings = <String, String>{
+      for (final e in mentionMap.value.entries) e.key: e.value.pubkey,
+    };
     void persistDraft() {
       final text = controller.text;
-      if (text == lastPersistedText) return;
+      if (text != lastPersistedText) {
+        // Prune before the atomic snapshot, not in a later editor listener.
+        // Code formatting hides a binding without deleting its literal.
+        final retained = mentionOccurrences(
+          text.replaceAll('`', ' '),
+          mentionMap.value.keys,
+        ).map((range) => range.label).toSet();
+        // Whole-record taint has no literal to prune. Removing every @ is a
+        // safe reset; unrelated edits must not turn lost keys into name lookup.
+        mentionMap.value.removeWhere(
+          (label, _) =>
+              label.isEmpty ? !text.contains('@') : !retained.contains(label),
+        );
+      }
+      final bindings = <String, String>{
+        for (final e in mentionMap.value.entries) e.key: e.value.pubkey,
+      };
+      if (text == lastPersistedText && mapEquals(bindings, lastBindings)) {
+        return;
+      }
+      lastBindings = bindings;
       lastPersistedText = text;
       draftRevision.value += 1;
       ref
@@ -119,6 +157,7 @@ void _useComposeDraftLifecycle({
             channelId: channelId,
             threadHeadId: threadHeadId,
             text: text,
+            mentionKeys: bindings,
           );
     }
 
diff --git a/mobile/lib/features/channels/compose_bar/markdown_editing_controller.dart b/mobile/lib/features/channels/compose_bar/markdown_editing_controller.dart
index 2ae71ac110b..2862aad1f37 100644
--- a/mobile/lib/features/channels/compose_bar/markdown_editing_controller.dart
+++ b/mobile/lib/features/channels/compose_bar/markdown_editing_controller.dart
@@ -282,6 +282,16 @@ class _MarkdownEditingController extends TextEditingController {
       if (prefix.isNotEmpty) spans.add(TextSpan(text: prefix, style: style));
 
       final label = match.group(2)!;
+      if (RegExp(r'\([0-9a-f]{64}\)').hasMatch(label)) {
+        spans.add(
+          TextSpan(
+            text: '@$label',
+            style: style.copyWith(color: context.colors.primary),
+          ),
+        );
+        offset = match.end;
+        continue;
+      }
       spans.add(
         WidgetSpan(
           alignment: PlaceholderAlignment.baseline,
diff --git a/mobile/lib/features/channels/mentions/mention_ranking.dart b/mobile/lib/features/channels/mentions/mention_ranking.dart
index 7706df4bdfc..fec710942db 100644
--- a/mobile/lib/features/channels/mentions/mention_ranking.dart
+++ b/mobile/lib/features/channels/mentions/mention_ranking.dart
@@ -7,6 +7,9 @@ import '../../../shared/utils/string_utils.dart';
 @immutable
 class MentionCandidate {
   final String pubkey;
+
+  /// Restored identity only: eligibility must come from current community state.
+  final bool requiresRevalidation;
   final String? displayName;
   final String? secondaryLabel;
   final String? avatarUrl;
@@ -17,6 +20,7 @@ class MentionCandidate {
 
   const MentionCandidate({
     required this.pubkey,
+    this.requiresRevalidation = false,
     this.displayName,
     this.secondaryLabel,
     this.avatarUrl,
diff --git a/mobile/lib/features/channels/message_content.dart b/mobile/lib/features/channels/message_content.dart
index b94954c00cf..f2cccbaa237 100644
--- a/mobile/lib/features/channels/message_content.dart
+++ b/mobile/lib/features/channels/message_content.dart
@@ -14,6 +14,8 @@ import 'package:url_launcher/url_launcher.dart';
 import 'package:video_player/video_player.dart';
 
 import '../../shared/clipboard_utils.dart';
+import '../../shared/mentions/mention_bindings.dart';
+import '../../shared/mentions/mention_tags.dart';
 import '../../shared/deeplink/deep_link.dart';
 import '../../shared/deeplink/pending_deep_link_provider.dart';
 import '../../shared/relay/relay.dart';
@@ -158,6 +160,12 @@ class MessageContent extends HookConsumerWidget {
         baseStyle ??
         context.textTheme.bodyMedium?.copyWith(color: context.colors.onSurface);
     final resolvedMentionNames = mentionNames;
+    final signedMentionPubkeys = mentionedPubkeysFromTags(tags);
+    final mentionBindings = renderedMentionBindings(
+      content,
+      mentionNames,
+      signedMentionPubkeys,
+    );
     final resolvedAgentMentionPubkeys = {
       ...agentMentionPubkeys.map((pubkey) => pubkey.toLowerCase()),
     };
@@ -196,6 +204,7 @@ class MessageContent extends HookConsumerWidget {
             ..sort((a, b) => a.key.compareTo(b.key))))
         '${entry.key}\u0000${entry.value}',
       ...(resolvedAgentMentionPubkeys.toList()..sort()),
+      ...(signedMentionPubkeys.toList()..sort()),
     ].join('\u0001');
 
     // Decided here rather than by the caller: this is where the event's own
@@ -235,14 +244,15 @@ class MessageContent extends HookConsumerWidget {
           mentionBuf.write('`${mentionParts[i]}`');
         } else {
           var segment = mentionParts[i];
-          for (final name in resolvedMentionNames.values) {
-            if (name.contains(' ')) {
-              final normalizedName = _markdownMentionName(name);
-              segment = segment.replaceAllMapped(
-                RegExp('@${RegExp.escape(name)}', caseSensitive: false),
-                (m) => '@$normalizedName',
-              );
-            }
+          for (final range in mentionOccurrences(
+            segment,
+            mentionBindings.keys,
+          ).reversed) {
+            segment = segment.replaceRange(
+              range.start,
+              range.end,
+              '@${_markdownMentionName(range.label)}',
+            );
           }
           mentionBuf.write(segment);
         }
@@ -288,6 +298,14 @@ class MessageContent extends HookConsumerWidget {
         inlineComponents: [
           _MentionMd(
             mentionNames: resolvedMentionNames,
+            bindings: mentionBindings,
+            displayLabels: {
+              for (final range in mentionOccurrences(
+                content,
+                mentionBindings.keys,
+              ))
+                range.label: content.substring(range.start + 1, range.end),
+            },
             agentMentionPubkeys: resolvedAgentMentionPubkeys,
             onMentionTap: onMentionTap,
           ),
@@ -807,16 +825,20 @@ class _MessageCodeBlock extends HookWidget {
 }
 
 class _MentionMd extends InlineMd {
+  final Map<String, Set<String>> bindings;
+  final Map<String, String> displayLabels;
   final Map<String, String> mentionNames;
   final Set<String> agentMentionPubkeys;
   final void Function(String pubkey)? onMentionTap;
   late final RegExp _exp = _buildPrefixPattern(
     prefix: '@',
-    knownNames: _mentionAliases(mentionNames.values),
+    knownNames: bindings.keys.map(_markdownMentionName),
     genericTokenPattern: r'[A-Za-z0-9_][A-Za-z0-9_\u00A0-]*',
   );
 
   _MentionMd({
+    required this.bindings,
+    required this.displayLabels,
     required this.mentionNames,
     required this.agentMentionPubkeys,
     this.onMentionTap,
@@ -837,22 +859,25 @@ class _MentionMd extends InlineMd {
     }
 
     final name = raw.substring(1).replaceAll('\u00A0', ' ').toLowerCase();
-    String? displayName;
-    String? pubkey;
-    for (final entry in mentionNames.entries) {
-      final entryName = entry.value.toLowerCase();
-      final firstName = entryName.split(RegExp(r'\s+')).first;
-      if (entryName == name || firstName == name) {
-        displayName = entry.value;
-        pubkey = entry.key;
-        break;
-      }
+    final matches = bindings[name] ?? const <String>{};
+    final pubkey = matches.length == 1 ? matches.single : null;
+    if (bindings.containsKey(name) && matches.length != 1) {
+      return TextSpan(text: text, style: config.style);
     }
+    final displayName = name.contains(RegExp(r'\([0-9a-f]{64}\)'))
+        ? displayLabels[name]
+        : mentionNames[pubkey];
 
     final isAgent =
         pubkey != null && agentMentionPubkeys.contains(pubkey.toLowerCase());
+    final fullLabel = displayName ?? raw.substring(1);
+    final visibleLabel = fullLabel.replaceAllMapped(
+      RegExp(r'\(([0-9a-f]{64})\)'),
+      (m) => '(${m[1]!.substring(0, 8)}…${m[1]!.substring(60)})',
+    );
     final pill = _MentionPill(
-      label: displayName ?? raw.substring(1),
+      label: visibleLabel,
+      semanticsLabel: fullLabel,
       isAgent: isAgent,
       textStyle: config.style,
     );
@@ -861,7 +886,7 @@ class _MentionMd extends InlineMd {
       alignment: PlaceholderAlignment.baseline,
       baseline: TextBaseline.alphabetic,
       child: pubkey != null && onMentionTap != null
-          ? GestureDetector(onTap: () => onMentionTap!(pubkey!), child: pill)
+          ? GestureDetector(onTap: () => onMentionTap!(pubkey), child: pill)
           : pill,
     );
   }
@@ -869,11 +894,13 @@ class _MentionMd extends InlineMd {
 
 class _MentionPill extends StatelessWidget {
   final String label;
+  final String? semanticsLabel;
   final bool isAgent;
   final TextStyle? textStyle;
 
   const _MentionPill({
     required this.label,
+    this.semanticsLabel,
     required this.isAgent,
     this.textStyle,
   });
@@ -920,7 +947,9 @@ class _MentionPill extends StatelessWidget {
               offset: const Offset(0, -Grid.quarter),
               child: Text('@', style: style),
             ),
-          Text(label, style: style),
+          Flexible(
+            child: Text(label, style: style, semanticsLabel: semanticsLabel),
+          ),
         ],
       ),
     );
@@ -928,15 +957,3 @@ class _MentionPill extends StatelessWidget {
 }
 
 String _markdownMentionName(String name) => name.replaceAll(' ', '\u00A0');
-
-Iterable<String> _mentionAliases(Iterable<String> mentionNames) sync* {
-  for (final name in mentionNames) {
-    final trimmed = name.trim();
-    if (trimmed.isEmpty) continue;
-    yield _markdownMentionName(trimmed);
-    final firstName = trimmed.split(RegExp(r'\s+')).first;
-    if (firstName.isNotEmpty) {
-      yield firstName;
-    }
-  }
-}
diff --git a/mobile/lib/shared/mentions/mention_bindings.dart b/mobile/lib/shared/mentions/mention_bindings.dart
new file mode 100644
index 00000000000..8b2305c1328
--- /dev/null
+++ b/mobile/lib/shared/mentions/mention_bindings.dart
@@ -0,0 +1,88 @@
+/// Reserve an exact label without retargeting an earlier selection.
+String selectedMentionLabel(
+  String name,
+  String pubkey,
+  Map<String, String> bindings,
+) {
+  final normalized = {
+    for (final e in bindings.entries)
+      e.key.toLowerCase(): e.value.toLowerCase(),
+  };
+  bool conflicts(String label) =>
+      normalized.containsKey(label.toLowerCase()) &&
+      normalized[label.toLowerCase()] != pubkey.toLowerCase();
+  if (!conflicts(name)) return name;
+  final qualified = '$name (${pubkey.toLowerCase()})';
+  var label = qualified;
+  for (var suffix = 2; conflicts(label); suffix++) {
+    label = '$qualified $suffix';
+  }
+  return label;
+}
+
+/// Longest literal ranges win, including labels containing another @ sign.
+/// Recognition precedes eligibility: ambiguous labels still block shorter ones.
+List<({int start, int end, String label})> mentionOccurrences(
+  String text,
+  Iterable<String> labels,
+) {
+  final matches = <int, ({int start, int end, String label})>{};
+  for (final label in labels) {
+    if (label.isEmpty) continue;
+    // A qualifier and reservation suffix belong to the literal even when no
+    // candidate binds it. Never fall back to a shorter, different recipient.
+    final suffix =
+        RegExp(r' \([0-9a-f]{64}\)$', caseSensitive: false).hasMatch(label)
+        ? r'(?! (?:[2-9]|[1-9][0-9]+)(?=[\s,;.!?:)\]}*_]|$))'
+        : '';
+    final pattern = RegExp(
+      '(?:^|\\s|[*_]{1,3}|\\|\\|)(@${RegExp.escape(label)})(?! \\([0-9a-f]{64}\\))$suffix(?=\\|\\||[\\s,;.!?:)\\]}*_]|\$)',
+      caseSensitive: false,
+    );
+    for (final match in pattern.allMatches(text)) {
+      final start = match.end - match.group(1)!.length;
+      if (matches[start] == null || matches[start]!.end < match.end) {
+        matches[start] = (start: start, end: match.end, label: label);
+      }
+    }
+  }
+  final result = <({int start, int end, String label})>[];
+  for (final match
+      in matches.values.toList()..sort((a, b) => a.start.compareTo(b.start))) {
+    if (result.isEmpty || match.start >= result.last.end) result.add(match);
+  }
+  return result;
+}
+
+/// Bind tagged qualifiers and ordinary aliases, never historical namesakes.
+Map<String, Set<String>> renderedMentionBindings(
+  String content,
+  Map<String, String> names, [
+  Iterable<String> signedPubkeys = const [],
+]) {
+  final bindings = <String, Set<String>>{};
+  void add(String label, String key) =>
+      (bindings[label.toLowerCase()] ??= {}).add(key.toLowerCase());
+  for (final entry in names.entries) {
+    add(entry.value, entry.key);
+    add(entry.value.split(RegExp(r'\s+')).first, entry.key);
+  }
+  final keys = signedPubkeys.map((key) => key.toLowerCase()).toSet();
+  for (final match in RegExp(
+    r'@([^@\r\n]+) \(([0-9a-f]{64})\)(?: ((?:[1-9][0-9]+|[2-9])))?',
+    caseSensitive: false,
+  ).allMatches(content)) {
+    final key = match.group(2)!.toLowerCase();
+    final label = match.group(0)!.substring(1).toLowerCase();
+    if (!mentionOccurrences(content, [
+      label,
+    ]).any((range) => range.start == match.start)) {
+      continue;
+    }
+    // Text can deny historical aliases without a profile, never authorize keys.
+    bindings[label] = keys.contains(key) ? {key} : <String>{};
+    // Recipient tags/current names cannot establish the historical plain owner.
+    bindings[match.group(1)!.toLowerCase()] = <String>{};
+  }
+  return bindings;
+}
diff --git a/mobile/test/features/channels/channel_detail_page_test.dart b/mobile/test/features/channels/channel_detail_page_test.dart
index 23f547dbad0..7159fb2fd1e 100644
--- a/mobile/test/features/channels/channel_detail_page_test.dart
+++ b/mobile/test/features/channels/channel_detail_page_test.dart
@@ -476,6 +476,76 @@ void main() {
     _testPrefs = await SharedPreferences.getInstance();
   });
 
+  for (final thread in [false, true]) {
+    for (final reverse in [false, true]) {
+      testWidgets('signed qualified caller thread=$thread reverse=$reverse', (
+        tester,
+      ) async {
+        final first = 'a' * 64, second = 'b' * 64, sibling = 'c' * 64;
+        Future<void> tapProfile(String label, String key) async {
+          await tester.tap(find.text(label));
+          await tester.pumpAndSettle();
+          expect(
+            tester
+                .widget<UserProfileSheet>(find.byType(UserProfileSheet))
+                .pubkey,
+            key,
+          );
+          await tester.tap(find.byTooltip('Close sheet'));
+          await tester.pumpAndSettle();
+        }
+
+        for (final firstName in ['Scout', 'Renamed Scout', first, null]) {
+          for (final secondName in [null, 'Scout', 'Renamed Scout', second]) {
+            for (final bystander in [null, 'Bob', 'Scout']) {
+              final names = {
+                first: ?firstName,
+                second: ?secondName,
+                sibling: 'Alice',
+                'd' * 64: ?bystander,
+              };
+              final keys = [
+                first,
+                second.toUpperCase(),
+                sibling,
+                if (bystander != null) 'd' * 64,
+              ];
+              final event = _textMsg(
+                id: 'qualified',
+                pubkey: 'author',
+                content: '@Scout @Scout ($second) @Alice @Other (${'e' * 64})',
+                extraTags: [
+                  for (final key in reverse ? keys.reversed : keys) ['p', key],
+                ],
+              );
+              await tester.pumpWidget(
+                _buildTestable(
+                  messages: [event],
+                  users: {
+                    for (final e in names.entries)
+                      e.key: UserProfile(pubkey: e.key, displayName: e.value),
+                  },
+                  threadReplies: const {'qualified': []},
+                  initialThreadRootId: thread ? 'qualified' : null,
+                ),
+              );
+              await tester.pumpAndSettle();
+              await tapProfile('Scout (bbbbbbbb…bbbb)', second);
+              expect(find.text('Scout'), findsNothing);
+              expect(find.text('Bob'), findsNothing);
+              if (firstName != null) expect(find.text(firstName), findsNothing);
+              expect(find.text('Other (eeeeeeee…eeee)'), findsNothing);
+              await tapProfile('Alice', sibling);
+              expect(tester.takeException(), isNull);
+              await tester.pumpWidget(const SizedBox.shrink());
+              await tester.pumpAndSettle();
+            }
+          }
+        }
+      });
+    }
+  }
+
   group('ChannelDetailPage', () {
     testWidgets(
       'bot-role author avatars stay squircles in channel and thread',
diff --git a/mobile/test/features/channels/compose_bar_test.dart b/mobile/test/features/channels/compose_bar_test.dart
index b8025112a25..34a91e7ea3b 100644
--- a/mobile/test/features/channels/compose_bar_test.dart
+++ b/mobile/test/features/channels/compose_bar_test.dart
@@ -16,6 +16,7 @@ import 'package:nostr/nostr.dart' as nostr;
 import 'package:buzz/features/channels/channel.dart';
 import 'package:buzz/features/channels/channel_management_provider.dart';
 import 'package:buzz/features/channels/compose_bar.dart';
+import 'package:buzz/features/channels/send_message_provider.dart';
 import 'package:buzz/features/channels/channels_provider.dart';
 import 'package:buzz/features/channels/photo_library.dart';
 import 'package:buzz/features/channels/voice_note_play_pause_icon.dart';
@@ -25,6 +26,8 @@ import 'package:buzz/shared/custom_emoji/custom_emoji.dart';
 import 'package:buzz/shared/custom_emoji/custom_emoji_provider.dart';
 import 'package:buzz/shared/mentions/agent_identity_provider.dart';
 import 'package:buzz/shared/relay/relay.dart';
+import 'package:buzz/shared/profile/user_cache_provider.dart';
+import 'package:buzz/shared/profile/user_profile.dart';
 import 'package:buzz/shared/theme/theme.dart';
 import 'package:buzz/shared/utils/string_utils.dart';
 import 'package:buzz/shared/widgets/anchored_popover_menu.dart';
@@ -32,6 +35,8 @@ import 'package:buzz/shared/widgets/avatar_image.dart';
 import 'package:buzz/shared/widgets/mobile_tab_footer_backdrop.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
+part 'compose_bar_test/exact_mention_tests.dart';
+
 final _pngBytes = Uint8List.fromList([
   0x89,
   0x50,
@@ -643,6 +648,7 @@ class _FakeChannelsNotifier extends ChannelsNotifier {
 }
 
 void main() {
+  exactMentionTests();
   TestWidgetsFlutterBinding.ensureInitialized();
 
   setUp(() async {
diff --git a/mobile/test/features/channels/compose_bar_test/exact_mention_tests.dart b/mobile/test/features/channels/compose_bar_test/exact_mention_tests.dart
new file mode 100644
index 00000000000..e7b04ddfdb2
--- /dev/null
+++ b/mobile/test/features/channels/compose_bar_test/exact_mention_tests.dart
@@ -0,0 +1,312 @@
+part of '../compose_bar_test.dart';
+
+void exactMentionTests() {
+  final first = 'a' * 64;
+  final second = 'b' * 64;
+  List<ChannelMember> members() => [
+    for (final key in [first, second])
+      ChannelMember(
+        pubkey: key,
+        displayName: 'Scout',
+        role: 'member',
+        joinedAt: DateTime(2025),
+      ),
+  ];
+  Future<void> mountComposer(
+    WidgetTester tester,
+    List<ChannelMember> roster,
+    ComposeBarOnSend onSend, {
+    nostr.Keys? signer,
+  }) async {
+    await tester.pumpWidget(
+      _buildComposeBar(
+        uploadService: _testUploadService(
+          (signer ?? nostr.Keys.generate()).nsec,
+        ),
+        members: roster,
+        channels: [_makeCurrentChannel()],
+        currentPubkey: signer?.public,
+        relayConfig: signer == null
+            ? null
+            : () => _SwitchableRelayConfigNotifier(
+                RelayConfig(
+                  baseUrl: 'https://relay.example',
+                  nsec: signer.nsec,
+                ),
+              ),
+        onSend: onSend,
+      ),
+    );
+    if (find.byType(TextField).evaluate().isEmpty &&
+        find.textContaining('@Scout').evaluate().isNotEmpty) {
+      // A restored draft displays its text, not the empty composer hint.
+      await tester.tap(find.textContaining('@Scout'));
+      await tester.pumpAndSettle();
+    } else {
+      await _expandComposer(tester);
+    }
+  }
+
+  Future<void> pick(
+    WidgetTester tester,
+    String text, {
+    bool last = false,
+  }) async {
+    await tester.enterText(find.byType(TextField), text);
+    await tester.pumpAndSettle();
+    await tester.tap(last ? find.text('Scout').last : find.text('Scout').first);
+    await tester.pumpAndSettle();
+  }
+
+  for (final scenario in [
+    'rename',
+    'map edited',
+    'map reset',
+    'map plain',
+    'map reselected',
+    'removed',
+    'legacy',
+    'malformed',
+    'tainted',
+    'non-member human',
+    'non-member denied agent',
+  ]) {
+    testWidgets('persisted selection restore to signed send: $scenario', (
+      tester,
+    ) async {
+      final signer = nostr.Keys.generate();
+      final events = <Map<String, dynamic>>[];
+      late SendMessage sendMessage;
+      Future<void> mount(List<ChannelMember> roster) async {
+        await mountComposer(
+          tester,
+          roster,
+          (text, keys, {mediaTags = const []}) => sendMessage(
+            channelId: 'channel-1',
+            content: text,
+            mentionPubkeys: keys,
+            mediaTags: mediaTags,
+          ),
+          signer: signer,
+        );
+        final container = ProviderScope.containerOf(
+          tester.element(find.byType(ComposeBar)),
+        );
+        final session = container.read(relaySessionProvider.notifier);
+        session.debugAttachSocketForTest(
+          _RecordingRelaySocket(
+            events,
+            session.debugHandleSocketMessageForTest,
+          ),
+        );
+        sendMessage = SendMessage(
+          signedEventRelay: SignedEventRelay(
+            session: session,
+            nsec: signer.nsec,
+          ),
+          fetchMembers: (_) async => roster,
+          readUserCache: () => const {},
+          addLocalMessage: (_, _) {},
+          completeLocalMessage: (_, _) {},
+          removeLocalMessage: (_, _) {},
+        );
+      }
+
+      await mount(members());
+      await pick(tester, '@');
+      final prefsKey =
+          'compose_drafts_v1:https://relay.example:${signer.public}';
+      final saved = jsonDecode(_testPrefs.getString(prefsKey)!) as List;
+      expect(saved.single['text'], '@Scout ');
+      expect(saved.single['mention_keys'], {'Scout': first});
+      // Dispose the actual provider state, not just the text controller.
+      await tester.pumpWidget(const SizedBox.shrink());
+      await tester.pumpAndSettle();
+      if (scenario.startsWith('map ')) saved.single['mention_keys'] = null;
+      if (scenario == 'legacy') saved.single.remove('mention_keys');
+      if (scenario == 'malformed') {
+        saved.single['mention_keys'] = {'Scout': 'not-a-key'};
+      }
+      if (scenario == 'tainted') {
+        saved.single['mention_keys'] = {
+          'Scout': {'pubkey': second, 'is_agent': true},
+        };
+      }
+      await _testPrefs.setString(prefsKey, jsonEncode(saved));
+      await mount([
+        if (![
+          'removed',
+          'non-member human',
+          'non-member denied agent',
+        ].contains(scenario))
+          ChannelMember(
+            pubkey: first,
+            displayName: 'Renamed',
+            role: 'member',
+            joinedAt: DateTime(2025),
+          ),
+        members().last,
+      ]);
+      if (scenario.startsWith('non-member')) {
+        ProviderScope.containerOf(tester.element(find.byType(ComposeBar)))
+            .read(userCacheProvider.notifier)
+            .put(
+              UserProfile(
+                pubkey: first,
+                displayName: 'Renamed',
+                ownerPubkey: scenario == 'non-member denied agent'
+                    ? second
+                    : null,
+              ),
+            );
+        await tester.pumpAndSettle();
+      }
+      expect(
+        tester.widget<TextField>(find.byType(TextField)).controller!.text,
+        '@Scout ',
+      );
+      var expectedText = '@Scout ';
+      if (scenario.startsWith('map ')) {
+        expectedText = '@Scout hello';
+        await tester.enterText(find.byType(TextField), expectedText);
+        await tester.pumpAndSettle();
+        expect(
+          jsonDecode(_testPrefs.getString(prefsKey)!).single['mention_keys'],
+          {'': ''},
+        );
+        await tester.pumpWidget(const SizedBox.shrink());
+        await tester.pumpAndSettle();
+        await mount(members());
+        if (scenario != 'map edited') {
+          expectedText = scenario == 'map plain' ? 'hello' : '';
+          await tester.enterText(find.byType(TextField), expectedText);
+          await tester.pumpAndSettle();
+          if (scenario != 'map plain') {
+            await pick(tester, '@', last: scenario == 'map reselected');
+            expectedText = '@Scout ';
+          }
+        }
+      }
+      await tester.tap(find.byIcon(LucideIcons.arrowUp));
+      await tester.pumpAndSettle();
+      if (scenario == 'non-member human') {
+        expect(
+          find.textContaining('Renamed is not in this channel'),
+          findsOneWidget,
+        );
+        await tester.tap(find.text('Do nothing'));
+        await tester.pumpAndSettle();
+      }
+      final messages = events.where(
+        (e) => e['kind'] == EventKind.streamMessage,
+      );
+      if ([
+        'rename',
+        'legacy',
+        'non-member human',
+        'map reset',
+        'map plain',
+        'map reselected',
+      ].contains(scenario)) {
+        final event = messages.single;
+        expect(event['content'], expectedText.trim());
+        expect((event['tags'] as List).where((t) => t[0] == 'p').toList(), [
+          if (scenario != 'non-member human' && scenario != 'map plain')
+            [
+              'p',
+              ['legacy', 'map reselected'].contains(scenario) ? second : first,
+            ],
+        ]);
+        if (scenario == 'non-member human') {
+          expect(
+            (event['tags'] as List).where((t) => t[0] == 'mention').toList(),
+            [
+              ['mention', first],
+            ],
+          );
+          expect(events.where((e) => e['kind'] == 9000), isEmpty);
+        }
+        expect(event['pubkey'], signer.public);
+        expect(event['sig'], matches(RegExp(r'^[0-9a-f]{128}$')));
+        expect(nostr.Event.fromMap(event).id, event['id']);
+      } else {
+        expect(messages, isEmpty);
+        expect(events.where((e) => e['kind'] == 9000), isEmpty);
+        expect(find.textContaining('Saved mention'), findsOneWidget);
+        expect(
+          tester.widget<TextField>(find.byType(TextField)).controller!.text,
+          expectedText,
+        );
+      }
+      // Refusal leaves autocomplete open. Dispose before draining its existing
+      // 250ms search debounce; no send assertion depends on this cleanup pump.
+      await tester.pumpWidget(const SizedBox.shrink());
+      await tester.pump(const Duration(milliseconds: 250));
+    });
+  }
+  testWidgets(
+    'same-name picker selections retain exact recipients through removal',
+    (tester) async {
+      List<String>? sent;
+      await mountComposer(
+        tester,
+        members(),
+        (_, keys, {mediaTags = const []}) async => sent = keys,
+      );
+      await pick(tester, '@');
+      final controller = tester
+          .widget<TextField>(find.byType(TextField))
+          .controller!;
+      expect(controller.text, '@Scout ');
+      await pick(tester, '@Scout @', last: true);
+      expect(controller.text, '@Scout @Scout ($second) ');
+      await tester.tap(find.byIcon(LucideIcons.arrowUp));
+      await tester.pumpAndSettle();
+      expect(sent, [first, second]);
+      await pick(tester, '@');
+      await pick(tester, '@Scout @', last: true);
+      await tester.enterText(find.byType(TextField), '@Scout ($second) ');
+      await tester.pumpAndSettle();
+      await tester.tap(find.byIcon(LucideIcons.arrowUp));
+      await tester.pumpAndSettle();
+      expect(sent, [second]);
+    },
+  );
+
+  testWidgets('unbound qualified text cannot notify a shorter member alias', (
+    tester,
+  ) async {
+    List<String>? sent;
+    await mountComposer(tester, [
+      members().first,
+    ], (_, keys, {mediaTags = const []}) async => sent = keys);
+    await tester.enterText(find.byType(TextField), '@Scout ($second)');
+    await tester.pumpAndSettle();
+    await tester.tap(find.byIcon(LucideIcons.arrowUp));
+    await tester.pumpAndSettle();
+    expect(sent, isEmpty);
+  });
+
+  testWidgets('ambiguous typed names fail visibly without clearing the draft', (
+    tester,
+  ) async {
+    var sent = false;
+    await mountComposer(tester, members(), (
+      _,
+      _, {
+      mediaTags = const [],
+    }) async {
+      sent = true;
+    });
+    await tester.enterText(find.byType(TextField), '@Scout hello');
+    await tester.pumpAndSettle();
+    await tester.tap(find.byIcon(LucideIcons.arrowUp));
+    await tester.pumpAndSettle();
+    expect(sent, isFalse);
+    expect(
+      tester.widget<TextField>(find.byType(TextField)).controller!.text,
+      '@Scout hello',
+    );
+    expect(find.textContaining('is ambiguous'), findsOneWidget);
+  });
+}
diff --git a/mobile/test/features/channels/message_content_exact_mentions_test.dart b/mobile/test/features/channels/message_content_exact_mentions_test.dart
new file mode 100644
index 00000000000..7f18431de67
--- /dev/null
+++ b/mobile/test/features/channels/message_content_exact_mentions_test.dart
@@ -0,0 +1,51 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:buzz/features/channels/message_content.dart';
+import '../../helpers/widget_helpers.dart';
+
+void main() {
+  for (final tagged in [false, true]) {
+    testWidgets(
+      'qualified chips preserve authority and narrow layout: $tagged',
+      (tester) async {
+        tester.view.physicalSize = const Size(320, 640);
+        tester.view.devicePixelRatio = 1;
+        addTearDown(tester.view.reset);
+        final semantics = tester.ensureSemantics();
+        final first = 'a' * 64, second = 'b' * 64;
+        String? tapped;
+        await tester.pumpWidget(
+          WidgetHelpers.testable(
+            child: MediaQuery(
+              data: const MediaQueryData(textScaler: TextScaler.linear(2)),
+              child: MessageContent(
+                content: '@Scout @Scout ($second)',
+                mentionNames: {second: 'Scout', first: 'Scout'},
+                tags: [
+                  for (final key in [first, if (tagged) second]) ['p', key],
+                ],
+                onMentionTap: (key) => tapped = key,
+              ),
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+        expect(find.text('Scout'), findsNothing);
+        final qualified = find.text('Scout (bbbbbbbb…bbbb)');
+        if (tagged) {
+          await tester.tap(qualified);
+          expect(tapped, second);
+          expect(
+            find.bySemanticsLabel(RegExp('Scout.*$second')),
+            findsOneWidget,
+          );
+        } else {
+          expect(qualified, findsNothing);
+          expect(tapped, isNull);
+        }
+        expect(tester.takeException(), isNull);
+        semantics.dispose();
+      },
+    );
+  }
+}
diff --git a/mobile/test/shared/mentions/mention_bindings_test.dart b/mobile/test/shared/mentions/mention_bindings_test.dart
new file mode 100644
index 00000000000..b4091d3b6e6
--- /dev/null
+++ b/mobile/test/shared/mentions/mention_bindings_test.dart
@@ -0,0 +1,56 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:buzz/shared/mentions/mention_bindings.dart';
+
+void main() {
+  final first = 'a' * 64;
+  final second = 'b' * 64;
+  test('qualification is case-insensitive and collision-safe', () {
+    final bindings = {'Scout': first, 'Scout ($second)': first};
+    expect(selectedMentionLabel('scout', first, bindings), 'scout');
+    expect(
+      selectedMentionLabel('Scout', second, bindings),
+      'Scout ($second) 2',
+    );
+  });
+  test('longest occurrences block shorter and interior recipients', () {
+    expect(
+      mentionOccurrences('@Scout ($second) 2', [
+        'Scout',
+        'Scout ($second)',
+        'Scout ($second) 2',
+      ]).single.label,
+      'Scout ($second) 2',
+    );
+    expect(mentionOccurrences('@A @B', ['A @B', 'B']).single.label, 'A @B');
+    expect(mentionOccurrences('mail@Scout', ['Scout']), isEmpty);
+    expect(mentionOccurrences('@Scout ($second)', ['Scout']), isEmpty);
+    expect(
+      mentionOccurrences('@Scout ($second) 2', ['Scout ($second)']),
+      isEmpty,
+    );
+  });
+  // Historical plain denial and both tag orders run through channel/thread UI.
+  test('ordinary ambiguity and qualification require signed authority', () {
+    expect(
+      renderedMentionBindings('@Scout', {
+        first: 'Scout',
+        second: 'Scout',
+      })['scout'],
+      {first, second},
+    );
+    expect(
+      renderedMentionBindings('@Scout ($second)', {
+        first: 'Scout',
+      })['scout ($second)'],
+      isEmpty,
+    );
+    expect(
+      renderedMentionBindings(
+        '@Old ($second)',
+        {second: 'New'},
+        [second],
+      )['old ($second)'],
+      {second},
+    );
+  });
+}

From b1817000ccacce3ee9efabdc10d9a47d9b9e9576 Mon Sep 17 00:00:00 2001
From: Junchao Yan <yjc801@gmail.com>
Date: Fri, 11 Sep 2026 10:07:35 -0700
Subject: [PATCH 19/19] fix(desktop): name Waggle in the Pi adapter restart
 hint

This fork ships the desktop app as Waggle (docs/fork-branding.md), but the
Pi preset's setup hint -- new from upstream in this sync -- tells the user to
"Restart Buzz". On the AdapterMissing and NotInstalled paths a user who also
has an upstream Buzz installed can follow that literally, restart the wrong
process, and leave the running Waggle holding its stale PATH with buzz-pi-acp
still undiscoverable.

Upstream authors these hints, so every future sync can reintroduce one in any
preset. Alongside the two pinned Pi assertions, assert the whole class: no
preset's user-visible setup guidance may contain the upstream app name.
Lowercase command names (buzz-pi-acp, buzz-acp) are binaries, not the brand,
and stay allowed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Junchao Yan <yjc801@gmail.com>
---
 .../src/managed_agents/discovery/presets.rs   | 36 +++++++++++++++++--
 1 file changed, 33 insertions(+), 3 deletions(-)

diff --git a/desktop/src-tauri/src/managed_agents/discovery/presets.rs b/desktop/src-tauri/src/managed_agents/discovery/presets.rs
index 058569f6127..f4d9d53dfb4 100644
--- a/desktop/src-tauri/src/managed_agents/discovery/presets.rs
+++ b/desktop/src-tauri/src/managed_agents/discovery/presets.rs
@@ -110,7 +110,7 @@ pub(super) const PRESET_HARNESSES: &[PresetHarness] = &[
         command: "buzz-pi-acp",
         args: &[],
         install_instructions_url: "https://github.com/salman1993/pi-acp",
-        install_hint: "Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Buzz, then select Pi as the agent harness. Run the same install command again to update the adapter.",
+        install_hint: "Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Waggle, then select Pi as the agent harness. Run the same install command again to update the adapter.",
         underlying_cli: Some("pi"),
         underlying_cli_install_hint: Some(
             "Install Pi with `npm install -g @earendil-works/pi-coding-agent`, then run `pi` to configure its model provider.",
@@ -434,7 +434,7 @@ mod tests {
         assert!(adapter_missing.default_args.is_empty());
         assert_eq!(
             adapter_missing.install_hint,
-            "Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Buzz, then select Pi as the agent harness. Run the same install command again to update the adapter."
+            "Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Waggle, then select Pi as the agent harness. Run the same install command again to update the adapter."
         );
         assert_eq!(
             adapter_missing.install_instructions_url,
@@ -462,7 +462,7 @@ mod tests {
         );
         assert_eq!(
             not_installed.install_hint,
-            "Install Pi with `npm install -g @earendil-works/pi-coding-agent`, then run `pi` to configure its model provider. Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Buzz, then select Pi as the agent harness. Run the same install command again to update the adapter."
+            "Install Pi with `npm install -g @earendil-works/pi-coding-agent`, then run `pi` to configure its model provider. Requires Node.js 22 or newer. Install the Pi ACP adapter with `npm install -g --install-links=true git+https://github.com/salman1993/pi-acp.git#main`. Restart Waggle, then select Pi as the agent harness. Run the same install command again to update the adapter."
         );
     }
 
@@ -601,4 +601,34 @@ mod tests {
             "uncapped preset (devin) must have max_parallelism: None"
         );
     }
+
+    /// Fork branding: no preset's user-visible setup guidance may name the
+    /// upstream app. This fork ships the desktop app as Waggle
+    /// (`docs/fork-branding.md`), so an instruction to "Restart Buzz" points a
+    /// user at a different installation while the running Waggle process keeps
+    /// its stale PATH. Upstream authors these hints, so every fork sync can
+    /// reintroduce one -- assert the whole class, not just the preset that
+    /// happened to carry it. Lowercase command names (`buzz-pi-acp`,
+    /// `buzz-acp`) are binaries, not the brand, and stay allowed.
+    #[test]
+    fn preset_setup_hints_name_the_fork_app() {
+        for preset in PRESET_HARNESSES {
+            for (field, hint) in [
+                ("install_hint", Some(preset.install_hint)),
+                (
+                    "underlying_cli_install_hint",
+                    preset.underlying_cli_install_hint,
+                ),
+            ] {
+                let Some(hint) = hint else {
+                    continue;
+                };
+                assert!(
+                    !hint.contains("Buzz"),
+                    "preset `{}` {field} names the upstream app; this fork ships as Waggle: {hint}",
+                    preset.id
+                );
+            }
+        }
+    }
 }