diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 2b0eb25c688..2114e3d561d 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -775,6 +775,63 @@ jobs:
             ${{ steps.artifacts.outputs.exe }}
             ${{ steps.artifacts.outputs.sig }}
 
+  desktop-release-smoke:
+    name: Desktop release smoke
+    if: github.repository == 'block/buzz'
+    runs-on: ubuntu-latest
+    needs: setup
+    timeout-minutes: 20
+    permissions:
+      contents: read
+    env:
+      PLAYWRIGHT_BROWSERS_PATH: ${{ github.workspace }}/.cache/ms-playwright
+    steps:
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        with:
+          ref: ${{ needs.setup.outputs.source_sha }}
+          persist-credentials: false
+      - uses: cashapp/activate-hermit@cea9af7913204a965fd488637a8d1811bba2e616 # v1
+      - name: Install desktop dependencies
+        run: just desktop-install-ci
+      - name: Get Playwright version
+        id: pw-version
+        run: echo "version=$(cd desktop && node -e \"console.log(require('@playwright/test/package.json').version)\")" >> "$GITHUB_OUTPUT"
+      - name: Restore Playwright browser cache
+        id: playwright-cache
+        uses: actions/cache/restore@caa296126883cff596d87d8935842f9db880ef25 # v5
+        with:
+          path: ${{ env.PLAYWRIGHT_BROWSERS_PATH }}
+          key: playwright-${{ runner.os }}-${{ steps.pw-version.outputs.version }}
+      - name: Install Playwright Chromium
+        if: steps.playwright-cache.outputs.cache-hit != 'true'
+        run: cd desktop && pnpm exec playwright install chromium
+      - name: Install Playwright system dependencies
+        run: cd desktop && pnpm exec playwright install-deps chromium
+      - name: Save Playwright browser cache
+        if: steps.playwright-cache.outputs.cache-hit != 'true'
+        uses: actions/cache/save@caa296126883cff596d87d8935842f9db880ef25 # v5
+        with:
+          path: ${{ env.PLAYWRIGHT_BROWSERS_PATH }}
+          key: playwright-${{ runner.os }}-${{ steps.pw-version.outputs.version }}
+      - name: Build test relay
+        run: cargo build --profile ci -p buzz-relay
+      - name: Run deterministic correctness smoke
+        env:
+          BUZZ_E2E_RELAY_BIN: ${{ github.workspace }}/target/ci/buzz-relay
+          BUZZ_RELEASE_SMOKE_ARTIFACT_DIR: ${{ github.workspace }}/release-smoke-artifacts
+        run: just desktop-release-smoke
+      - name: Upload release-smoke diagnostics
+        if: always()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        with:
+          name: desktop-release-smoke
+          path: |
+            release-smoke-artifacts
+            desktop/test-results
+            desktop/playwright-release-smoke-report
+          if-no-files-found: warn
+          retention-days: 14
+
   assemble-manifest:
     name: Assemble multi-platform latest.json
     # Only the tag-bound setup path can reach this job.
@@ -785,9 +842,10 @@ jobs:
       needs.release-macos-x64.result == 'success' &&
       needs.release-linux.result == 'success' &&
       needs.release-windows.result == 'success' &&
+      needs.desktop-release-smoke.result == 'success' &&
       github.ref == format('refs/tags/desktop-v{0}', needs.setup.outputs.version)
     runs-on: ubuntu-latest
-    needs: [setup, release, release-macos-x64, release-linux, release-windows]
+    needs: [setup, release, release-macos-x64, release-linux, release-windows, desktop-release-smoke]
     timeout-minutes: 10
     permissions:
       contents: write
diff --git a/Cargo.lock b/Cargo.lock
index ddab506c2a0..ab0253dbebf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -881,6 +881,7 @@ dependencies = [
  "tokio",
  "tracing",
  "url",
+ "uuid",
 ]
 
 [[package]]
diff --git a/Justfile b/Justfile
index 6719d3c53f1..b3627f689c8 100644
--- a/Justfile
+++ b/Justfile
@@ -276,6 +276,10 @@ desktop-e2e-smoke:
 desktop-e2e-integration: _ensure-migrations
     cd {{desktop_dir}} && pnpm test:e2e:integration
 
+# Run the deterministic desktop correctness smoke against an isolated local relay
+desktop-release-smoke:
+    ./scripts/run-desktop-release-smoke.sh
+
 # Run only the e2e specs changed vs origin/main (both projects) before pushing
 desktop-e2e-pre-push: _ensure-migrations
     git fetch origin main
diff --git a/TESTING.md b/TESTING.md
index 7c107da5754..29d07a80de0 100644
--- a/TESTING.md
+++ b/TESTING.md
@@ -155,9 +155,49 @@ buzz messages thread --channel "$CHANNEL" --event "$EVENT_ID" | jq .
 
 A successful run prints `{"event_id":"…","accepted":true,"message":""}` for
 the send, and the message body in the `get` output. `thread` returns `[]`
-for a leaf message — populated only after a reply comes in (see §5).
+for a leaf message — populated only after a reply comes in (see §6).
 
-### 5. Going deeper
+### 5. Verify a roster beyond 1,000 members
+
+Use the focused live-relay script when changing channel membership, discovery,
+or reconciliation. It proves the three boundaries that DB-only tests cannot:
+the relay-served kind 39002 includes a member at roster position 1,501, that
+identity can publish a channel message, and targeted reconciliation preserves
+its discoverability.
+
+Run this only against an isolated local database. The script inserts fixture
+members directly, then drives discovery and messaging through the release CLI
+and relay. Keep the release relay from step 3 running and use its configured
+relay key for authoritative replacement:
+
+```bash
+export PATH="$PWD/target/release:$PATH"
+export DATABASE_URL="postgres://buzz:buzz_dev@localhost:5432/buzz_roster_e2e"
+export BUZZ_RELAY_URL="http://localhost:3030"  # match the relay from step 3
+export RELAY_URL="ws://localhost:3030"
+export BUZZ_RELAY_PRIVATE_KEY="<same key used by buzz-relay>"
+
+scripts/e2e-large-channel-roster.sh
+```
+
+Success is directly observable as four `PASS` lines. The first and fourth
+include a member count greater than 1,000 and the same late-member pubkey; the
+second includes the accepted kind 9 event ID, and the third proves targeted
+repair left kind 39000/39001 IDs and tags unchanged:
+
+```text
+PASS discovery-before-republish channel=<uuid> members=1502 late_pubkey=<hex>
+PASS late-member-action event_id=<hex>
+PASS targeted-repair-preserves-metadata-and-admin-events channel=<uuid>
+PASS discovery-after-republish channel=<uuid> members=1502 late_pubkey=<hex>
+```
+
+The script refuses debug binaries and refuses a `buzz` or `buzz-admin` resolved
+outside this checkout's `target/release`. It also requires the targeted admin
+operation to use `BUZZ_RELAY_PRIVATE_KEY`; never substitute an ephemeral signer
+for an authoritative replacement.
+
+### 6. Going deeper
 
 For full coverage of every CLI command (54 subcommands across 12 groups),
 follow [`crates/buzz-cli/TESTING.md`](crates/buzz-cli/TESTING.md).
diff --git a/crates/buzz-admin/Cargo.toml b/crates/buzz-admin/Cargo.toml
index 00c2804cbcf..263ba4eb319 100644
--- a/crates/buzz-admin/Cargo.toml
+++ b/crates/buzz-admin/Cargo.toml
@@ -35,4 +35,5 @@ rustls = { version = "0.23", default-features = false, features = ["ring", "std"
 tracing = { workspace = true }
 sqlx = { workspace = true }
 url = { workspace = true }
+uuid = { workspace = true }
 clap = { version = "4", features = ["derive"] }
diff --git a/crates/buzz-admin/src/main.rs b/crates/buzz-admin/src/main.rs
index 580d5865913..42a7de84f7c 100644
--- a/crates/buzz-admin/src/main.rs
+++ b/crates/buzz-admin/src/main.rs
@@ -88,12 +88,17 @@ enum Command {
         #[command(subcommand)]
         command: deletions::DeletionsCommand,
     },
-    /// Emit kind:39000/39002 events for channels missing them.
+    /// Emit missing kind:39000/39001/39002 channel discovery events, or
+    /// republish only a targeted channel's kind:39002 roster.
     ///
-    /// Channels created via direct SQL (seed scripts, pre-migration data) won't
-    /// have Nostr discovery events. This command creates them so pure-nostr
-    /// clients can see those channels. Idempotent — safe to run multiple times.
+    /// Without `--channel`, only channels missing discovery metadata are
+    /// reconciled. With `--channel`, only that channel's member snapshot is
+    /// replaced; canonical metadata and admin events remain untouched.
     ReconcileChannels {
+        /// Optional channel UUID to force-republish.
+        #[arg(long)]
+        channel: Option<String>,
+
         /// Relay private key (hex) for signing events. Falls back to
         /// BUZZ_RELAY_PRIVATE_KEY env var. If neither is set, generates
         /// an ephemeral key (events will be unverifiable after restart).
@@ -156,8 +161,8 @@ async fn run(cli: Cli) -> Result<i32> {
             command: ProductFeedbackCommand::List { limit },
         } => cmd_list_product_feedback(limit).await,
         Command::Deletions { command } => deletions::run(command).await,
-        Command::ReconcileChannels { relay_key } => {
-            reconcile_channels(relay_key).await?;
+        Command::ReconcileChannels { channel, relay_key } => {
+            reconcile_channels(channel, relay_key).await?;
             Ok(0)
         }
     }
@@ -466,14 +471,26 @@ async fn resolve_admin_tenant(db: &Db) -> Result<TenantContext> {
     Ok(TenantContext::resolved(record.id, record.host))
 }
 
-async fn reconcile_channels(relay_key_arg: Option<String>) -> Result<()> {
+async fn reconcile_channels(
+    channel_arg: Option<String>,
+    relay_key_arg: Option<String>,
+) -> Result<()> {
     use buzz_core::kind::KIND_NIP29_GROUP_ADMINS;
     use buzz_db::event::EventQuery;
 
     let db = connect_db().await?;
 
-    // Resolve relay signing key: arg > env > ephemeral
-    let relay_keys = match relay_key_arg.or_else(|| std::env::var("BUZZ_RELAY_PRIVATE_KEY").ok()) {
+    // Resolve relay signing key: arg > env > ephemeral. Force-republish must
+    // never use an ephemeral key because it replaces an existing authoritative
+    // snapshot.
+    let configured_relay_key =
+        relay_key_arg.or_else(|| std::env::var("BUZZ_RELAY_PRIVATE_KEY").ok());
+    if channel_arg.is_some() && configured_relay_key.is_none() {
+        return Err(anyhow::anyhow!(
+            "--channel requires --relay-key or BUZZ_RELAY_PRIVATE_KEY"
+        ));
+    }
+    let relay_keys = match configured_relay_key {
         Some(key_hex) => {
             Keys::parse(&key_hex).map_err(|e| anyhow::anyhow!("invalid relay key: {e}"))?
         }
@@ -490,7 +507,21 @@ async fn reconcile_channels(relay_key_arg: Option<String>) -> Result<()> {
     };
 
     let tenant = resolve_admin_tenant(&db).await?;
-    let channels = db.list_channels(tenant.community(), None).await?;
+    let target_channel = channel_arg
+        .as_deref()
+        .map(uuid::Uuid::parse_str)
+        .transpose()
+        .map_err(|e| anyhow::anyhow!("invalid --channel UUID: {e}"))?;
+    let channels = if let Some(target) = target_channel {
+        vec![db
+            .get_channel(tenant.community(), target)
+            .await
+            .map_err(|_| {
+                anyhow::anyhow!("channel {target} not found in community {}", tenant.host())
+            })?]
+    } else {
+        db.list_channels(tenant.community(), None).await?
+    };
     if channels.is_empty() {
         println!("No channels in database.");
         return Ok(());
@@ -513,57 +544,64 @@ async fn reconcile_channels(relay_key_arg: Option<String>) -> Result<()> {
             .await
             .unwrap_or_default();
 
-        if !existing.is_empty() {
+        if !existing.is_empty() && target_channel.is_none() {
             skipped += 1;
             continue;
         }
 
         let members = db.get_members(tenant.community(), channel.id).await?;
 
-        // kind:39000 — channel metadata
-        {
-            let mut tags: Vec<Tag> = vec![Tag::parse(["d", &channel_id_str])?];
-            tags.push(Tag::parse(["name", &channel.name])?);
-            if let Some(ref desc) = channel.description {
-                if !desc.is_empty() {
-                    tags.push(Tag::parse(["about", desc])?);
+        // A targeted repair is deliberately roster-only. kind:39000 metadata
+        // is richer than this legacy backfill builder, and kind:39001 is not
+        // part of the stale-roster incident; replacing either can destroy
+        // canonical state. Full backfill still creates all three event kinds
+        // for channels with no discovery metadata.
+        if target_channel.is_none() {
+            // kind:39000 — channel metadata
+            {
+                let mut tags: Vec<Tag> = vec![Tag::parse(["d", &channel_id_str])?];
+                tags.push(Tag::parse(["name", &channel.name])?);
+                if let Some(ref desc) = channel.description {
+                    if !desc.is_empty() {
+                        tags.push(Tag::parse(["about", desc])?);
+                    }
                 }
+                if channel.visibility == "private" {
+                    tags.push(Tag::parse(["private"])?);
+                } else {
+                    tags.push(Tag::parse(["public"])?);
+                }
+                if channel.channel_type == "dm" {
+                    tags.push(Tag::parse(["hidden"])?);
+                }
+                tags.push(Tag::parse(["closed"])?);
+                tags.push(Tag::parse(["t", &channel.channel_type])?);
+
+                let event = EventBuilder::new(Kind::Custom(39000), "")
+                    .tags(tags)
+                    .sign_with_keys(&relay_keys)
+                    .map_err(|e| anyhow::anyhow!("sign kind:39000: {e}"))?;
+                db.replace_addressable_event(tenant.community(), &event, Some(channel.id))
+                    .await?;
             }
-            if channel.visibility == "private" {
-                tags.push(Tag::parse(["private"])?);
-            } else {
-                tags.push(Tag::parse(["public"])?);
-            }
-            if channel.channel_type == "dm" {
-                tags.push(Tag::parse(["hidden"])?);
-            }
-            tags.push(Tag::parse(["closed"])?);
-            tags.push(Tag::parse(["t", &channel.channel_type])?);
 
-            let event = EventBuilder::new(Kind::Custom(39000), "")
-                .tags(tags)
-                .sign_with_keys(&relay_keys)
-                .map_err(|e| anyhow::anyhow!("sign kind:39000: {e}"))?;
-            db.replace_addressable_event(tenant.community(), &event, Some(channel.id))
-                .await?;
-        }
-
-        // kind:39001 — admins
-        {
-            let mut tags: Vec<Tag> = vec![Tag::parse(["d", &channel_id_str])?];
-            for m in members
-                .iter()
-                .filter(|m| m.role == "owner" || m.role == "admin")
+            // kind:39001 — admins
             {
-                let pk = hex::encode(&m.pubkey);
-                tags.push(Tag::parse(["p", &pk, &m.role])?);
+                let mut tags: Vec<Tag> = vec![Tag::parse(["d", &channel_id_str])?];
+                for m in members
+                    .iter()
+                    .filter(|m| m.role == "owner" || m.role == "admin")
+                {
+                    let pk = hex::encode(&m.pubkey);
+                    tags.push(Tag::parse(["p", &pk, &m.role])?);
+                }
+                let event = EventBuilder::new(Kind::Custom(KIND_NIP29_GROUP_ADMINS as u16), "")
+                    .tags(tags)
+                    .sign_with_keys(&relay_keys)
+                    .map_err(|e| anyhow::anyhow!("sign kind:39001: {e}"))?;
+                db.replace_addressable_event(tenant.community(), &event, Some(channel.id))
+                    .await?;
             }
-            let event = EventBuilder::new(Kind::Custom(KIND_NIP29_GROUP_ADMINS as u16), "")
-                .tags(tags)
-                .sign_with_keys(&relay_keys)
-                .map_err(|e| anyhow::anyhow!("sign kind:39001: {e}"))?;
-            db.replace_addressable_event(tenant.community(), &event, Some(channel.id))
-                .await?;
         }
 
         // kind:39002 — members
diff --git a/crates/buzz-db/src/channel.rs b/crates/buzz-db/src/channel.rs
index 3ca9b3d901c..8035ab58adb 100644
--- a/crates/buzz-db/src/channel.rs
+++ b/crates/buzz-db/src/channel.rs
@@ -687,7 +687,12 @@ pub async fn membership_pairs(
         .collect()
 }
 
-/// Returns all active members of the given channel.
+/// Returns all active members of the given channel, ordered by `joined_at`.
+///
+/// The roster is returned in full and is never truncated: callers use it to
+/// build the kind 39002 (NIP-29 group members) snapshot and to resolve actor
+/// roles for admin-event authorization, so a partial list silently hides late
+/// joiners from channel discovery and makes them read as non-members.
 ///
 /// Returns an empty list if the channel has been soft-deleted.
 pub async fn get_members(
@@ -702,7 +707,6 @@ pub async fn get_members(
         JOIN channels c ON cm.community_id = c.community_id AND cm.channel_id = c.id AND c.deleted_at IS NULL
         WHERE cm.community_id = $1 AND cm.channel_id = $2 AND cm.removed_at IS NULL
         ORDER BY cm.joined_at ASC
-        LIMIT 1000
         "#,
     )
     .bind(community_id.as_uuid())
@@ -1532,7 +1536,7 @@ mod tests {
     use crate::user::{ensure_user, set_agent_owner};
     use nostr::Keys;
 
-    const TEST_DB_URL: &str = "postgres://buzz:buzz_dev@localhost:5432/buzz";
+    const TEST_DB_URL: &str = "postgres://buzz:buzz_dev@localhost:5432/buzz"; // sadscan:disable np.postgres.1 -- local test-only credentials
 
     async fn setup_pool() -> PgPool {
         PgPool::connect(TEST_DB_URL)
@@ -1933,6 +1937,85 @@ mod tests {
         assert_eq!(channel_ids.len(), channel_count as usize);
     }
 
+    /// `get_members` must return the complete roster, not a truncated prefix.
+    ///
+    /// The relay builds the kind 39002 (NIP-29 group members) snapshot and every
+    /// admin role lookup from this list, so a cap silently hides late joiners:
+    /// their clients never discover the channel, and an owner past the cutoff
+    /// reads as a non-member.
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn get_members_returns_full_roster_beyond_1000() {
+        let database_url =
+            std::env::var("BUZZ_TEST_DATABASE_URL").unwrap_or_else(|_| TEST_DB_URL.to_string());
+        let pool = PgPool::connect(&database_url)
+            .await
+            .expect("connect to test DB");
+        let community_id = make_test_community(&pool).await;
+        let community = CommunityId::from_uuid(community_id);
+        let creator = random_pubkey();
+
+        // create_test_channel also inserts the creator as the first (owner) member.
+        let channel = create_test_channel(
+            &pool,
+            community_id,
+            "high-volume-roster",
+            ChannelType::Stream,
+            ChannelVisibility::Open,
+            None,
+            &creator,
+            None,
+        )
+        .await
+        .expect("create test channel");
+
+        // Bulk-insert additional members with strictly increasing `joined_at`, so
+        // member N lands at roster position N (the creator holds position 0).
+        // The final member is an owner joining well past the old 1000-row cutoff.
+        let extra_members = 1_500;
+        sqlx::query(
+            r#"
+            INSERT INTO channel_members (community_id, channel_id, pubkey, role, joined_at)
+            SELECT
+                $1,
+                $2,
+                decode(lpad(to_hex(n), 64, '0'), 'hex'),
+                (CASE WHEN n = $3 THEN 'owner' ELSE 'member' END)::member_role,
+                NOW() + (n || ' seconds')::interval
+            FROM generate_series(1, $3) n
+            "#,
+        )
+        .bind(community_id)
+        .bind(channel.id)
+        .bind(extra_members)
+        .execute(&pool)
+        .await
+        .expect("insert high-volume channel members");
+
+        let members = get_members(&pool, community, channel.id)
+            .await
+            .expect("load channel members");
+
+        assert_eq!(
+            members.len(),
+            extra_members as usize + 1,
+            "get_members truncated the roster"
+        );
+
+        // The last joiner sits at the final roster position — past any
+        // 1000-row cap — which also pins the documented `joined_at` ordering.
+        let late_owner = hex::decode(format!("{:064x}", extra_members)).expect("hex pubkey");
+        let late = members.last().expect("roster is non-empty");
+        assert_eq!(
+            late.pubkey, late_owner,
+            "member who joined after the 1000th must be present and ordered last"
+        );
+        assert_eq!(
+            late.role, "owner",
+            "role of a late-joining owner must resolve correctly"
+        );
+    }
+
     /// A random non-admin, non-owner user cannot remove someone else's bot.
     #[tokio::test]
     #[ignore = "requires Postgres"]
diff --git a/crates/buzz-db/src/feed.rs b/crates/buzz-db/src/feed.rs
index 40e58d0d060..6900e2061c5 100644
--- a/crates/buzz-db/src/feed.rs
+++ b/crates/buzz-db/src/feed.rs
@@ -886,4 +886,40 @@ mod tests {
         let unique: std::collections::HashSet<Vec<u8>> = byte_seqs.into_iter().collect();
         assert_eq!(unique.len(), 5, "all channel IDs must be distinct");
     }
+
+    /// `insert_mentions` must index every p-tag even past Postgres's
+    /// bind-parameter statement cap.
+    ///
+    /// Relay-signed kind 39002 member snapshots carry one p-tag per channel
+    /// member, and a multi-row INSERT binds 6 parameters per row — a single
+    /// statement tops out at ~10.9k rows against the 65,535-parameter limit.
+    /// Clients discover their channels via `{kinds:[39002], "#p":[me]}`, so a
+    /// failed insert silently breaks discovery for the whole channel.
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn insert_mentions_indexes_rosters_past_bind_parameter_cap() {
+        let pool = setup_pool().await;
+        let community = CommunityId::from_uuid(make_test_community(&pool).await);
+        let channel = insert_test_channel(&pool, community).await;
+
+        // 11,000 rows x 6 binds = 66,000 > 65,535: overflows a single statement.
+        let mention_count = 11_000usize;
+        let tags: Vec<Tag> = (1..=mention_count)
+            .map(|n| Tag::parse(["p", &format!("{n:064x}")]).expect("p tag"))
+            .collect();
+        let event = store_feed_event(&pool, community, 39002, "", Some(channel), tags).await;
+
+        let indexed: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM event_mentions WHERE community_id = $1 AND event_id = $2",
+        )
+        .bind(community.as_uuid())
+        .bind(event.id.as_bytes().as_slice())
+        .fetch_one(&pool)
+        .await
+        .expect("count indexed mentions");
+        assert_eq!(
+            indexed as usize, mention_count,
+            "every roster p-tag must land in event_mentions"
+        );
+    }
 }
diff --git a/crates/buzz-db/src/lib.rs b/crates/buzz-db/src/lib.rs
index 351eb9d2856..49a646abbe7 100644
--- a/crates/buzz-db/src/lib.rs
+++ b/crates/buzz-db/src/lib.rs
@@ -104,6 +104,21 @@ pub async fn insert_mentions(
     community_id: CommunityId,
     event: &nostr::Event,
     channel_id: Option<Uuid>,
+) -> Result<()> {
+    let mut tx = pool.begin().await?;
+    insert_mentions_in_transaction(&mut tx, community_id, event, channel_id).await?;
+    tx.commit().await?;
+    Ok(())
+}
+
+/// Insert mention rows on the caller's transaction. Replacement writes use
+/// this so the authoritative event and its discovery index commit or roll back
+/// as one unit.
+async fn insert_mentions_in_transaction(
+    tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+    community_id: CommunityId,
+    event: &nostr::Event,
+    channel_id: Option<Uuid>,
 ) -> Result<()> {
     let p_tags: Vec<&str> = event
         .tags
@@ -150,24 +165,31 @@ pub async fn insert_mentions(
         return Ok(());
     }
 
-    // Single multi-row INSERT ... ON CONFLICT DO NOTHING — one round-trip regardless of mention count.
-    let mut qb: QueryBuilder<sqlx::Postgres> = QueryBuilder::new(
-        "INSERT INTO event_mentions \
-         (community_id, pubkey_hex, event_id, event_created_at, channel_id, event_kind) ",
-    );
+    // Multi-row INSERT ... ON CONFLICT DO NOTHING, chunked to stay under
+    // Postgres's 65,535 bind-parameter statement cap (6 binds per row caps a
+    // single statement at ~10.9k rows). Relay-signed kind 39002 rosters carry
+    // one p-tag per channel member and can exceed that. The caller owns the
+    // transaction so all chunks share its commit boundary.
+    const MENTION_INSERT_CHUNK_ROWS: usize = 5_000;
+    for chunk in valid_pubkeys.chunks(MENTION_INSERT_CHUNK_ROWS) {
+        let mut qb: QueryBuilder<sqlx::Postgres> = QueryBuilder::new(
+            "INSERT INTO event_mentions \
+             (community_id, pubkey_hex, event_id, event_created_at, channel_id, event_kind) ",
+        );
 
-    qb.push_values(&valid_pubkeys, |mut b, pubkey| {
-        b.push_bind(community_id.as_uuid())
-            .push_bind(pubkey.as_str())
-            .push_bind(event_id_bytes.as_slice())
-            .push_bind(created_at)
-            .push_bind(channel_id)
-            .push_bind(kind as i32);
-    });
+        qb.push_values(chunk, |mut b, pubkey| {
+            b.push_bind(community_id.as_uuid())
+                .push_bind(pubkey.as_str())
+                .push_bind(event_id_bytes.as_slice())
+                .push_bind(created_at)
+                .push_bind(channel_id)
+                .push_bind(kind as i32);
+        });
 
-    qb.push(" ON CONFLICT DO NOTHING");
+        qb.push(" ON CONFLICT DO NOTHING");
 
-    qb.build().execute(pool).await?;
+        qb.build().execute(&mut **tx).await?;
+    }
     Ok(())
 }
 
@@ -4051,6 +4073,27 @@ impl Db {
         workflow::list_workflow_runs(&self.pool, community_id, workflow_id, limit).await
     }
 
+    /// List one keyset-paginated page of workflow runs.
+    #[datastore_span(name = "list_workflow_runs_page", system = "postgresql")]
+    pub async fn list_workflow_runs_page(
+        &self,
+        community_id: CommunityId,
+        workflow_id: Uuid,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        before_id: Option<Uuid>,
+        limit: i64,
+    ) -> Result<Vec<workflow::WorkflowRunRecord>> {
+        workflow::list_workflow_runs_page(
+            &self.pool,
+            community_id,
+            workflow_id,
+            before,
+            before_id,
+            limit,
+        )
+        .await
+    }
+
     /// Update a workflow run's status.
     #[datastore_span(name = "update_workflow_run", system = "postgresql")]
     pub async fn update_workflow_run(
@@ -4060,7 +4103,7 @@ impl Db {
         status: workflow::RunStatus,
         current_step: i32,
         trace: &serde_json::Value,
-        error: Option<&str>,
+        failure: Option<workflow::WorkflowRunFailure<'_>>,
     ) -> Result<()> {
         workflow::update_workflow_run(
             &self.pool,
@@ -4069,7 +4112,7 @@ impl Db {
             status,
             current_step,
             trace,
-            error,
+            failure,
         )
         .await
     }
@@ -4895,13 +4938,12 @@ impl Db {
             ));
         }
 
-        tx.commit().await?;
+        // The replaceable event and its denormalized mention index are one
+        // authoritative discovery write. An indexing error must roll back the
+        // new event and restore the previously-live event.
+        crate::insert_mentions_in_transaction(&mut tx, community_id, event, channel_id).await?;
 
-        // Mentions are a denormalized index — safe outside the transaction.
-        // insert_event() normally handles this, but we inlined the INSERT above.
-        if let Err(e) = crate::insert_mentions(&self.pool, community_id, event, channel_id).await {
-            tracing::warn!(event_id = %event.id, "Failed to insert mentions: {e}");
-        }
+        tx.commit().await?;
 
         Ok((
             StoredEvent::with_received_at(event.clone(), received_at, channel_id, true),
@@ -5438,6 +5480,87 @@ mod tests {
         id
     }
 
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn addressable_replacement_rolls_back_when_mention_indexing_fails() {
+        use nostr::{EventBuilder, Keys, Kind, Tag, Timestamp};
+
+        let admin = PgPool::connect(&admin_url().await)
+            .await
+            .expect("connect admin");
+        let (pool, scratch_name) = create_scratch_db(&admin, "atomic_addressable").await;
+        let db = Db::from_pool(pool.clone());
+        let community_uuid = Uuid::new_v4();
+        let channel = Uuid::new_v4();
+        let keys = Keys::generate();
+        seed_community_channel(&pool, community_uuid, channel, &keys).await;
+        let community = CommunityId::from_uuid(community_uuid);
+        let member = Keys::generate().public_key().to_hex();
+        let tags = || {
+            vec![
+                Tag::parse(["d", channel.to_string().as_str()]).expect("d tag"),
+                Tag::parse(["p", member.as_str(), "", "member"]).expect("p tag"),
+            ]
+        };
+        let base = Timestamp::now().as_secs();
+        let old = EventBuilder::new(Kind::Custom(39002), "old")
+            .tags(tags())
+            .custom_created_at(Timestamp::from(base))
+            .sign_with_keys(&keys)
+            .expect("sign old");
+        db.replace_addressable_event(community, &old, Some(channel))
+            .await
+            .expect("insert old roster");
+
+        sqlx::query(
+            "CREATE FUNCTION reject_test_mention() RETURNS trigger AS $$ \
+             BEGIN RAISE EXCEPTION 'injected mention failure'; END; \
+             $$ LANGUAGE plpgsql",
+        )
+        .execute(&pool)
+        .await
+        .expect("create failure function");
+        sqlx::query(
+            "CREATE TRIGGER reject_test_mention BEFORE INSERT ON event_mentions \
+             FOR EACH ROW EXECUTE FUNCTION reject_test_mention()",
+        )
+        .execute(&pool)
+        .await
+        .expect("install failure injection");
+
+        let new = EventBuilder::new(Kind::Custom(39002), "new")
+            .tags(tags())
+            .custom_created_at(Timestamp::from(base + 1))
+            .sign_with_keys(&keys)
+            .expect("sign new");
+        let error = db
+            .replace_addressable_event(community, &new, Some(channel))
+            .await
+            .expect_err("mention failure must fail replacement");
+        assert!(error.to_string().contains("injected mention failure"));
+
+        let live_id: Vec<u8> = sqlx::query_scalar(
+            "SELECT id FROM events WHERE community_id=$1 AND channel_id=$2 \
+             AND kind=39002 AND deleted_at IS NULL",
+        )
+        .bind(community.as_uuid())
+        .bind(channel)
+        .fetch_one(&pool)
+        .await
+        .expect("query live roster");
+        assert_eq!(live_id, old.id.as_bytes(), "old roster must remain live");
+        let new_rows: i64 =
+            sqlx::query_scalar("SELECT count(*) FROM events WHERE community_id=$1 AND id=$2")
+                .bind(community.as_uuid())
+                .bind(new.id.as_bytes().as_slice())
+                .fetch_one(&pool)
+                .await
+                .expect("count rolled-back event");
+        assert_eq!(new_rows, 0, "new roster must roll back with its index");
+
+        drop_scratch_db(&admin, pool, &scratch_name).await;
+    }
+
     #[tokio::test]
     #[ignore = "requires Postgres"]
     async fn nip_rs_replacement_hard_deletes_payload_and_watermark_rejects_replay() {
diff --git a/crates/buzz-db/src/migration.rs b/crates/buzz-db/src/migration.rs
index b3bc5f31cf7..be87faa1ac2 100644
--- a/crates/buzz-db/src/migration.rs
+++ b/crates/buzz-db/src/migration.rs
@@ -625,7 +625,7 @@ mod tests {
         let mut migrations: Vec<_> = MIGRATOR.iter().collect();
         migrations.sort_by_key(|migration| migration.version);
 
-        assert_eq!(migrations.len(), 30);
+        assert_eq!(migrations.len(), 31);
         assert_eq!(migrations[0].version, 1);
         assert_eq!(&*migrations[0].description, "initial schema");
         assert!(migrations[0]
@@ -1038,6 +1038,27 @@ mod tests {
         assert!(deletion_recovery.contains("SET LOCAL lock_timeout = '5s'"));
     }
 
+    #[test]
+    fn workflow_run_error_codes_are_additive_and_backfilled_without_parsing_diagnostics() {
+        let mut migrations: Vec<_> = MIGRATOR.iter().collect();
+        migrations.sort_by_key(|migration| migration.version);
+
+        assert_eq!(migrations[30].version, 31);
+        let sql = migrations[30].sql.as_str();
+        assert!(sql.contains("ALTER TABLE workflow_runs ADD COLUMN error_code TEXT"));
+        assert!(sql.contains("SET error_code = 'legacy_unclassified'"));
+        assert!(sql.contains("status IN ('failed', 'cancelled')"));
+        assert!(!sql.contains("error_message LIKE"));
+        assert!(!MIGRATOR
+            .iter()
+            .find(|migration| migration.version == 1)
+            .expect("initial migration")
+            .sql
+            .as_str()
+            .contains("error_code"));
+        assert!(include_str!("../../../schema/schema.sql").contains("error_code          TEXT"));
+    }
+
     #[test]
     fn migration_lint_detects_tables_missing_community_id_by_default() {
         let sql = r#"
diff --git a/crates/buzz-db/src/workflow.rs b/crates/buzz-db/src/workflow.rs
index ad1fd3a9396..e970e978aaf 100644
--- a/crates/buzz-db/src/workflow.rs
+++ b/crates/buzz-db/src/workflow.rs
@@ -216,8 +216,11 @@ pub struct WorkflowRunRecord {
     pub started_at: Option<DateTime<Utc>>,
     /// When execution finished (success or failure).
     pub completed_at: Option<DateTime<Utc>>,
-    /// Error message if the run failed.
+    /// Redacted human-readable diagnostic for failed or cancelled runs.
     pub error_message: Option<String>,
+    /// Stable machine-readable failure or cancellation classification.
+    /// Kept separate from `error_message` so callers never parse diagnostics.
+    pub error_code: Option<String>,
     /// When the run record was created.
     pub created_at: DateTime<Utc>,
 }
@@ -831,7 +834,7 @@ pub async fn get_workflow_run(
     let row = sqlx::query(
         r#"
         SELECT community_id, id, workflow_id, status::text AS status, trigger_event_id, current_step,
-               execution_trace, trigger_context, started_at, completed_at, error_message, created_at
+               execution_trace, trigger_context, started_at, completed_at, error_message, error_code, created_at
         FROM workflow_runs
         WHERE community_id = $1 AND id = $2
         "#,
@@ -845,26 +848,40 @@ pub async fn get_workflow_run(
     row_to_run_record(row)
 }
 
-/// List runs for a workflow, newest first, up to `limit` rows.
-pub async fn list_workflow_runs(
+/// List runs for a workflow using a stable newest-first keyset.
+///
+/// Rows are ordered by `(created_at DESC, id DESC)`. A cursor is valid only
+/// when both `before` and `before_id` are supplied; callers should pass the
+/// final row from the previous page. `limit` is clamped to the shared list
+/// bounds.
+pub async fn list_workflow_runs_page(
     pool: &PgPool,
     community_id: CommunityId,
     workflow_id: Uuid,
+    before: Option<DateTime<Utc>>,
+    before_id: Option<Uuid>,
     limit: i64,
 ) -> Result<Vec<WorkflowRunRecord>> {
-    let limit = limit.min(1000);
+    let limit = limit.clamp(1, LIST_MAX_LIMIT);
     let rows = sqlx::query(
         r#"
         SELECT community_id, id, workflow_id, status::text AS status, trigger_event_id, current_step,
-               execution_trace, trigger_context, started_at, completed_at, error_message, created_at
+               execution_trace, trigger_context, started_at, completed_at, error_message, error_code, created_at
         FROM workflow_runs
         WHERE community_id = $1 AND workflow_id = $2
-        ORDER BY created_at DESC
-        LIMIT $3
+          AND (
+              $3::timestamptz IS NULL
+              OR $4::uuid IS NULL
+              OR (created_at, id) < ($3, $4)
+          )
+        ORDER BY created_at DESC, id DESC
+        LIMIT $5
         "#,
     )
     .bind(community_id.as_uuid())
     .bind(workflow_id)
+    .bind(before)
+    .bind(before_id)
     .bind(limit)
     .fetch_all(pool)
     .await?;
@@ -872,7 +889,26 @@ pub async fn list_workflow_runs(
     rows.into_iter().map(row_to_run_record).collect()
 }
 
-/// Update run status, current step, execution trace, and optional error message.
+/// List runs for a workflow, newest first, up to `limit` rows.
+pub async fn list_workflow_runs(
+    pool: &PgPool,
+    community_id: CommunityId,
+    workflow_id: Uuid,
+    limit: i64,
+) -> Result<Vec<WorkflowRunRecord>> {
+    list_workflow_runs_page(pool, community_id, workflow_id, None, None, limit).await
+}
+
+/// Structured failure persisted for a workflow run.
+#[derive(Debug, Clone, Copy)]
+pub struct WorkflowRunFailure<'a> {
+    /// Stable machine-readable failure code.
+    pub code: &'a str,
+    /// Human-readable failure detail.
+    pub message: &'a str,
+}
+
+/// Update run status, current step, execution trace, and optional failure.
 ///
 /// Fix C3: `started_at` is set when the NEW status is 'running' and `started_at`
 /// has not yet been stamped (IS NULL). The original code read `status` from the
@@ -885,26 +921,31 @@ pub async fn update_workflow_run(
     status: RunStatus,
     current_step: i32,
     trace: &serde_json::Value,
-    error: Option<&str>,
+    failure: Option<WorkflowRunFailure<'_>>,
 ) -> Result<()> {
     let status_str = status.to_string();
+    let (error_code, error) = failure
+        .map(|failure| (Some(failure.code), Some(failure.message)))
+        .unwrap_or((None, None));
     let affected = sqlx::query(
         r#"
         UPDATE workflow_runs
         SET status        = $1::run_status,
             current_step  = $2,
             execution_trace = $3,
-            error_message = $4,
-            started_at    = CASE WHEN $5 = 'running' AND started_at IS NULL
+            error_code    = $4,
+            error_message = $5,
+            started_at    = CASE WHEN $6 = 'running' AND started_at IS NULL
                                  THEN NOW() ELSE started_at END,
-            completed_at  = CASE WHEN $6 IN ('completed','failed','cancelled')
+            completed_at  = CASE WHEN $7 IN ('completed','failed','cancelled')
                                  THEN NOW() ELSE completed_at END
-        WHERE community_id = $7 AND id = $8
+        WHERE community_id = $8 AND id = $9
         "#,
     )
     .bind(&status_str)
     .bind(current_step)
     .bind(trace)
+    .bind(error_code)
     .bind(error)
     .bind(&status_str) // for started_at CASE
     .bind(&status_str) // for completed_at CASE
@@ -1169,6 +1210,7 @@ fn row_to_run_record(row: sqlx::postgres::PgRow) -> Result<WorkflowRunRecord> {
         started_at: row.try_get("started_at")?,
         completed_at: row.try_get("completed_at")?,
         error_message: row.try_get("error_message")?,
+        error_code: row.try_get("error_code")?,
         created_at: row.try_get("created_at")?,
     })
 }
@@ -1473,6 +1515,7 @@ mod tests {
             started_at: Some(now),
             completed_at: None,
             error_message: None,
+            error_code: None,
             created_at: now,
         };
 
@@ -1501,6 +1544,7 @@ mod tests {
             started_at: None,
             completed_at: None,
             error_message: None,
+            error_code: None,
             created_at: now,
         };
 
@@ -1524,6 +1568,7 @@ mod tests {
             started_at: Some(now),
             completed_at: Some(now),
             error_message: Some("step timeout exceeded".to_owned()),
+            error_code: Some("step_timeout".to_owned()),
             created_at: now,
         };
 
@@ -1555,6 +1600,7 @@ mod tests {
             started_at: Some(now),
             completed_at: Some(now),
             error_message: None,
+            error_code: None,
             created_at: now,
         };
 
@@ -1577,6 +1623,7 @@ mod tests {
             started_at: None,
             completed_at: None,
             error_message: None,
+            error_code: None,
             created_at: now,
         };
 
diff --git a/crates/buzz-relay/src/api/bridge.rs b/crates/buzz-relay/src/api/bridge.rs
index 6ada39f5535..4d5bb772dba 100644
--- a/crates/buzz-relay/src/api/bridge.rs
+++ b/crates/buzz-relay/src/api/bridge.rs
@@ -21,7 +21,7 @@ use crate::state::AppState;
 
 use super::{api_error, internal_error, not_found};
 
-async fn enforce_http_admission(
+pub(crate) async fn enforce_http_admission(
     state: &AppState,
     tenant: &TenantContext,
     pubkey: &nostr::PublicKey,
@@ -1938,7 +1938,10 @@ pub async fn workflow_webhook(
                         buzz_db::workflow::RunStatus::Failed,
                         0,
                         &serde_json::json!([]),
-                        Some(&format!("definition parse error: {e}")),
+                        Some(buzz_db::workflow::WorkflowRunFailure {
+                            code: "invalid_definition",
+                            message: &format!("definition parse error: {e}"),
+                        }),
                     )
                     .await
                 {
diff --git a/crates/buzz-relay/src/api/mod.rs b/crates/buzz-relay/src/api/mod.rs
index d9f829433b1..2a942bc8039 100644
--- a/crates/buzz-relay/src/api/mod.rs
+++ b/crates/buzz-relay/src/api/mod.rs
@@ -9,6 +9,7 @@ pub mod media;
 pub mod mesh_demo;
 pub mod nip05;
 pub mod operator;
+pub mod workflows;
 
 // Re-export imeta helpers used by ingest pipeline.
 pub use crate::handlers::imeta::{validate_imeta_tags, verify_imeta_blobs};
diff --git a/crates/buzz-relay/src/api/workflows.rs b/crates/buzz-relay/src/api/workflows.rs
new file mode 100644
index 00000000000..a3d5a6c729e
--- /dev/null
+++ b/crates/buzz-relay/src/api/workflows.rs
@@ -0,0 +1,264 @@
+//! Authorized structured reads for workflow execution state.
+//!
+//! Runs and approvals are relay-owned database rows, not Nostr events. These
+//! endpoints expose those read models without inventing synthetic events.
+
+use std::sync::Arc;
+
+use axum::{
+    extract::{Path, Query, RawQuery, State},
+    http::{HeaderMap, StatusCode},
+    response::Json,
+};
+use chrono::{DateTime, Utc};
+use serde::Deserialize;
+use serde_json::Value;
+use uuid::Uuid;
+
+use buzz_core::TenantContext;
+
+use crate::{
+    api::{api_error, bridge, internal_error},
+    state::AppState,
+};
+
+const DEFAULT_RUN_LIMIT: i64 = 20;
+const MAX_RUN_LIMIT: i64 = 100;
+
+/// Pagination query for workflow run history.
+#[derive(Debug, Deserialize, Default)]
+pub struct RunsQuery {
+    before: Option<DateTime<Utc>>,
+    before_id: Option<Uuid>,
+    limit: Option<i64>,
+}
+
+fn request_path(path: &str, raw_query: Option<&str>) -> String {
+    match raw_query {
+        Some(query) if !query.is_empty() => format!("{path}?{query}"),
+        _ => path.to_string(),
+    }
+}
+
+async fn authorize_workflow_read(
+    state: &Arc<AppState>,
+    headers: &HeaderMap,
+    path: &str,
+    raw_query: Option<&str>,
+    workflow_id: Uuid,
+) -> Result<TenantContext, (StatusCode, Json<Value>)> {
+    let raw_host = headers
+        .get(axum::http::header::HOST)
+        .and_then(|value| value.to_str().ok())
+        .unwrap_or("");
+    let tenant = crate::tenant::bind_community(&state.db, raw_host)
+        .await
+        .map_err(|_| {
+            api_error(
+                StatusCode::NOT_FOUND,
+                "relay: no community is configured for this host",
+            )
+        })?;
+
+    let path_with_query = request_path(path, raw_query);
+    let url = bridge::nip98_expected_url(&state.config.relay_url, &tenant, &path_with_query);
+    let (pubkey, event_id_bytes) =
+        bridge::verify_bridge_auth(headers, "GET", &url, None, state.config.require_auth_token)?;
+    bridge::enforce_http_admission(state, &tenant, &pubkey).await?;
+    bridge::check_nip98_replay(state, &tenant, event_id_bytes).await?;
+
+    let pubkey_bytes = pubkey.to_bytes().to_vec();
+    let auth_tag = headers
+        .get("x-auth-tag")
+        .and_then(|value| value.to_str().ok());
+    super::relay_members::enforce_relay_membership(
+        state,
+        tenant.community(),
+        &pubkey_bytes,
+        auth_tag,
+    )
+    .await?;
+
+    let workflow = state
+        .db
+        .get_workflow(tenant.community(), workflow_id)
+        .await
+        .map_err(|error| match error {
+            buzz_db::error::DbError::NotFound(_) => {
+                api_error(StatusCode::NOT_FOUND, "workflow not found")
+            }
+            other => internal_error(&format!("get workflow for run read: {other}")),
+        })?;
+    let channel_id = workflow
+        .channel_id
+        .ok_or_else(|| api_error(StatusCode::FORBIDDEN, "workflow is not channel-scoped"))?;
+    let accessible = state
+        .get_accessible_channel_ids_cached(tenant.community(), &pubkey_bytes)
+        .await
+        .map_err(|error| internal_error(&format!("workflow channel access lookup: {error}")))?;
+    if !accessible.contains(&channel_id) {
+        return Err(api_error(
+            StatusCode::FORBIDDEN,
+            "workflow is not accessible",
+        ));
+    }
+
+    Ok(tenant)
+}
+
+/// `GET /workflows/{workflow_id}/runs` — one authorized, keyset-paginated page.
+pub async fn workflow_runs(
+    State(state): State<Arc<AppState>>,
+    Path(workflow_id): Path<Uuid>,
+    headers: HeaderMap,
+    RawQuery(raw_query): RawQuery,
+    Query(query): Query<RunsQuery>,
+) -> Result<Json<Value>, (StatusCode, Json<Value>)> {
+    if query.before.is_some() != query.before_id.is_some() {
+        return Err(api_error(
+            StatusCode::BAD_REQUEST,
+            "before and before_id must be supplied together",
+        ));
+    }
+    let limit = query.limit.unwrap_or(DEFAULT_RUN_LIMIT);
+    if !(1..=MAX_RUN_LIMIT).contains(&limit) {
+        return Err(api_error(
+            StatusCode::BAD_REQUEST,
+            "limit must be between 1 and 100",
+        ));
+    }
+
+    let path = format!("/workflows/{workflow_id}/runs");
+    let tenant =
+        authorize_workflow_read(&state, &headers, &path, raw_query.as_deref(), workflow_id).await?;
+    let mut rows = state
+        .db
+        .list_workflow_runs_page(
+            tenant.community(),
+            workflow_id,
+            query.before,
+            query.before_id,
+            limit + 1,
+        )
+        .await
+        .map_err(|error| internal_error(&format!("list workflow runs: {error}")))?;
+
+    let has_more = rows.len() > limit as usize;
+    rows.truncate(limit as usize);
+    let next = if has_more {
+        rows.last().map(|last| {
+            serde_json::json!({
+                "before": last.created_at,
+                "before_id": last.id,
+            })
+        })
+    } else {
+        None
+    };
+
+    Ok(Json(serde_json::json!({
+        "runs": rows.iter().map(run_json).collect::<Vec<_>>(),
+        "next": next,
+    })))
+}
+
+/// `GET /workflows/{workflow_id}/runs/{run_id}/approvals` — approvals for a run.
+pub async fn run_approvals(
+    State(state): State<Arc<AppState>>,
+    Path((workflow_id, run_id)): Path<(Uuid, Uuid)>,
+    headers: HeaderMap,
+) -> Result<Json<Value>, (StatusCode, Json<Value>)> {
+    let path = format!("/workflows/{workflow_id}/runs/{run_id}/approvals");
+    let tenant = authorize_workflow_read(&state, &headers, &path, None, workflow_id).await?;
+
+    let run = state
+        .db
+        .get_workflow_run(tenant.community(), run_id)
+        .await
+        .map_err(|error| match error {
+            buzz_db::error::DbError::NotFound(_) => {
+                api_error(StatusCode::NOT_FOUND, "workflow run not found")
+            }
+            other => internal_error(&format!("get workflow run for approval read: {other}")),
+        })?;
+    if run.workflow_id != workflow_id {
+        return Err(api_error(StatusCode::NOT_FOUND, "workflow run not found"));
+    }
+
+    let approvals = state
+        .db
+        .get_run_approvals(tenant.community(), workflow_id, run_id)
+        .await
+        .map_err(|error| internal_error(&format!("list run approvals: {error}")))?;
+    Ok(Json(serde_json::json!({
+        "approvals": approvals.iter().map(approval_json).collect::<Vec<_>>(),
+    })))
+}
+
+fn run_json(run: &buzz_db::workflow::WorkflowRunRecord) -> Value {
+    serde_json::json!({
+        "id": run.id,
+        "workflow_id": run.workflow_id,
+        "status": run.status,
+        "current_step": run.current_step,
+        "execution_trace": run.execution_trace,
+        "started_at": run.started_at.map(|value| value.timestamp()),
+        "completed_at": run.completed_at.map(|value| value.timestamp()),
+        "error_code": run.error_code,
+        "error_message": run.error_message,
+        "created_at": run.created_at.timestamp(),
+    })
+}
+
+fn approval_json(approval: &buzz_db::workflow::ApprovalRecord) -> Value {
+    serde_json::json!({
+        "approval_ref": hex::encode(&approval.token),
+        "workflow_id": approval.workflow_id,
+        "run_id": approval.run_id,
+        "step_id": approval.step_id,
+        "step_index": approval.step_index,
+        "approver_spec": approval.approver_spec,
+        "status": approval.status,
+        "approver_pubkey": approval.approver_pubkey.as_ref().map(hex::encode),
+        "note": approval.note,
+        "expires_at": approval.expires_at,
+        "created_at": approval.created_at.timestamp(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn request_path_preserves_signed_query_verbatim() {
+        assert_eq!(
+            request_path("/workflows/id/runs", Some("limit=20&before_id=abc")),
+            "/workflows/id/runs?limit=20&before_id=abc"
+        );
+        assert_eq!(
+            request_path("/workflows/id/runs", None),
+            "/workflows/id/runs"
+        );
+    }
+
+    #[test]
+    fn approval_wire_does_not_expose_hash_as_token() {
+        let approval = buzz_db::workflow::ApprovalRecord {
+            token: vec![0xab; 32],
+            workflow_id: Uuid::new_v4(),
+            run_id: Uuid::new_v4(),
+            step_id: "review".to_string(),
+            step_index: 1,
+            approver_spec: "any".to_string(),
+            status: buzz_db::workflow::ApprovalStatus::Pending,
+            approver_pubkey: None,
+            note: None,
+            expires_at: Utc::now(),
+            created_at: Utc::now(),
+        };
+        let wire = approval_json(&approval);
+        assert!(wire.get("token").is_none());
+        assert_eq!(wire["approval_ref"], hex::encode([0xab; 32]));
+    }
+}
diff --git a/crates/buzz-relay/src/handlers/command_executor.rs b/crates/buzz-relay/src/handlers/command_executor.rs
index abb9bb20665..29abe9f27d4 100644
--- a/crates/buzz-relay/src/handlers/command_executor.rs
+++ b/crates/buzz-relay/src/handlers/command_executor.rs
@@ -964,7 +964,10 @@ async fn handle_workflow_trigger(
                         RunStatus::Failed,
                         0,
                         &serde_json::json!([]),
-                        Some(&format!("definition parse error: {e}")),
+                        Some(buzz_db::workflow::WorkflowRunFailure {
+                            code: "invalid_definition",
+                            message: &format!("definition parse error: {e}"),
+                        }),
                     )
                     .await
                 {
@@ -1261,7 +1264,10 @@ async fn handle_approval_deny(
                 RunStatus::Cancelled,
                 run.current_step,
                 &run.execution_trace,
-                Some(&cancel_msg),
+                Some(buzz_db::workflow::WorkflowRunFailure {
+                    code: "approval_denied",
+                    message: &cancel_msg,
+                }),
             )
             .await
         {
@@ -1329,7 +1335,10 @@ async fn resume_workflow_after_approval(
                     RunStatus::Failed,
                     run.current_step,
                     &run.execution_trace,
-                    Some(&format!("definition parse error: {e}")),
+                    Some(buzz_db::workflow::WorkflowRunFailure {
+                        code: "invalid_definition",
+                        message: &format!("definition parse error: {e}"),
+                    }),
                 )
                 .await
             {
diff --git a/crates/buzz-relay/src/handlers/side_effects.rs b/crates/buzz-relay/src/handlers/side_effects.rs
index 88a9f0c731c..0dc6cbd5039 100644
--- a/crates/buzz-relay/src/handlers/side_effects.rs
+++ b/crates/buzz-relay/src/handlers/side_effects.rs
@@ -1033,6 +1033,18 @@ async fn emit_addressable_discovery_event(
     Ok(())
 }
 
+fn group_members_tags(group_id: &str, members: &[MemberRecord]) -> anyhow::Result<Vec<Tag>> {
+    let mut tags: Vec<Tag> = Vec::with_capacity(members.len() + 1);
+    tags.push(Tag::parse(["d", group_id])?);
+    for member in members {
+        let pubkey_hex = hex::encode(&member.pubkey);
+        // NIP-29 convention: ["p", pubkey, relay_url, role]. Empty relay_url
+        // because the canonical relay is implicit (this event is signed by it).
+        tags.push(Tag::parse(["p", &pubkey_hex, "", &member.role])?);
+    }
+    Ok(tags)
+}
+
 /// Emit NIP-29 group discovery events (39000, 39001, 39002) signed by the relay keypair.
 /// Called after group creation, metadata changes, or membership changes.
 /// Events are stored channel-scoped (`channel_id = Some(...)`) so that existing
@@ -1136,13 +1148,7 @@ pub async fn emit_group_discovery_events(
     }
 
     {
-        let mut tags: Vec<Tag> = vec![Tag::parse(["d", &group_id])?];
-        for m in &members {
-            let pubkey_hex = hex::encode(&m.pubkey);
-            // NIP-29 convention: ["p", pubkey, relay_url, role]. Empty relay_url
-            // because the canonical relay is implicit (this event is signed by it).
-            tags.push(Tag::parse(["p", &pubkey_hex, "", &m.role])?);
-        }
+        let tags = group_members_tags(&group_id, &members)?;
         emit_addressable_discovery_event(
             tenant,
             state,
@@ -3372,6 +3378,33 @@ fn topic_for_subscription(channel_id: Option<Uuid>) -> EventTopic {
 mod tests {
     use super::*;
 
+    #[test]
+    fn group_members_snapshot_keeps_members_past_one_thousand() {
+        let channel_id = Uuid::new_v4();
+        let members: Vec<MemberRecord> = (0_u16..1_501)
+            .map(|index| MemberRecord {
+                channel_id,
+                pubkey: vec![(index >> 8) as u8, index as u8],
+                role: if index == 1_500 { "owner" } else { "member" }.to_string(),
+                joined_at: chrono::Utc::now(),
+                invited_by: None,
+                removed_at: None,
+            })
+            .collect();
+
+        let tags = group_members_tags(&channel_id.to_string(), &members).expect("build tags");
+        assert_eq!(tags.len(), 1_502, "d tag plus every member p tag");
+
+        let late_pubkey = hex::encode(&members[1_500].pubkey);
+        assert!(tags.iter().any(|tag| {
+            let fields = tag.as_slice();
+            fields.len() == 4
+                && fields[0] == "p"
+                && fields[1] == late_pubkey
+                && fields[3] == "owner"
+        }));
+    }
+
     #[test]
     fn delete_tombstone_omits_absent_moderation_metadata() {
         let content =
diff --git a/crates/buzz-relay/src/router.rs b/crates/buzz-relay/src/router.rs
index 82ad9938a2f..1dce66e91e4 100644
--- a/crates/buzz-relay/src/router.rs
+++ b/crates/buzz-relay/src/router.rs
@@ -72,6 +72,14 @@ pub fn build_router(state: Arc<AppState>) -> Router {
         .route("/events", post(api::bridge::submit_event))
         .route("/query", post(api::bridge::query_events))
         .route("/count", post(api::bridge::count_events))
+        .route(
+            "/workflows/{workflow_id}/runs",
+            get(api::workflows::workflow_runs),
+        )
+        .route(
+            "/workflows/{workflow_id}/runs/{run_id}/approvals",
+            get(api::workflows::run_approvals),
+        )
         .route(
             "/operator/communities",
             get(api::operator::list_owned_communities).post(api::operator::provision_community),
diff --git a/crates/buzz-workflow/src/error.rs b/crates/buzz-workflow/src/error.rs
index 292f8dd027c..109d4a2cb3d 100644
--- a/crates/buzz-workflow/src/error.rs
+++ b/crates/buzz-workflow/src/error.rs
@@ -65,8 +65,50 @@ pub enum WorkflowError {
     NotImplemented(String),
 }
 
+impl WorkflowError {
+    /// Stable run-level classification. Diagnostics remain in `Display` output.
+    pub const fn code(&self) -> &'static str {
+        match self {
+            Self::InvalidYaml(_) => "invalid_yaml",
+            Self::InvalidDefinition(_) => "invalid_definition",
+            Self::ConditionError(_) => "condition_evaluation_failed",
+            Self::TemplateError(_) => "template_resolution_failed",
+            Self::StepTimeout { .. } => "step_timeout",
+            Self::WebhookError(_) => "webhook_failed",
+            Self::CapacityExceeded => "capacity_exceeded",
+            Self::Database(_) => "database_error",
+            Self::Unauthorized(_) => "owner_unauthorized",
+            Self::NotImplemented(_) => "action_not_implemented",
+        }
+    }
+}
+
 impl From<buzz_db::error::DbError> for WorkflowError {
     fn from(e: buzz_db::error::DbError) -> Self {
         WorkflowError::Database(e.to_string())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::WorkflowError;
+
+    #[test]
+    fn workflow_error_codes_are_stable_and_separate_from_diagnostics() {
+        let timeout = WorkflowError::StepTimeout {
+            step_id: "notify".to_owned(),
+            timeout_secs: 30,
+        };
+        assert_eq!(timeout.code(), "step_timeout");
+        assert!(timeout.to_string().contains("notify"));
+
+        let webhook = WorkflowError::WebhookError("secret-bearing detail".to_owned());
+        assert_eq!(webhook.code(), "webhook_failed");
+        assert!(!webhook.code().contains("secret-bearing detail"));
+
+        assert_eq!(
+            WorkflowError::NotImplemented("SendDm".to_owned()).code(),
+            "action_not_implemented"
+        );
+    }
+}
diff --git a/crates/buzz-workflow/src/lib.rs b/crates/buzz-workflow/src/lib.rs
index e1422211690..fe8b477ba40 100644
--- a/crates/buzz-workflow/src/lib.rs
+++ b/crates/buzz-workflow/src/lib.rs
@@ -242,7 +242,10 @@ impl WorkflowEngine {
                             RunStatus::Failed,
                             step_count,
                             &trace_json,
-                            Some("approval gates not yet implemented — see WF-08"),
+                            Some(buzz_db::workflow::WorkflowRunFailure {
+                                code: "approval_not_supported",
+                                message: "approval gates not yet implemented — see WF-08",
+                            }),
                         )
                         .await
                     {
@@ -285,7 +288,10 @@ impl WorkflowEngine {
                         RunStatus::Failed,
                         progress.step_index as i32,
                         &trace_json,
-                        Some(&e.to_string()),
+                        Some(buzz_db::workflow::WorkflowRunFailure {
+                            code: e.code(),
+                            message: &e.to_string(),
+                        }),
                     )
                     .await
                 {
diff --git a/desktop/.gitignore b/desktop/.gitignore
index 4d3e0c5ac5a..5dda9a099b5 100644
--- a/desktop/.gitignore
+++ b/desktop/.gitignore
@@ -14,6 +14,7 @@ dist-ssr
 playwright-report
 playwright-report.json
 test-results
+playwright-release-smoke-report
 *.local
 playwright-report
 test-results
diff --git a/desktop/package.json b/desktop/package.json
index 3601f25185e..b6581d48057 100644
--- a/desktop/package.json
+++ b/desktop/package.json
@@ -20,6 +20,7 @@
     "test:e2e": "pnpm build:e2e && playwright test",
     "test:e2e:smoke": "pnpm build:e2e && playwright test --project=smoke",
     "test:e2e:integration": "pnpm build:e2e && playwright test --project=integration",
+    "test:e2e:release-smoke": "pnpm build:e2e && playwright test --config=playwright.release-smoke.config.ts",
     "test:e2e:report": "playwright show-report",
     "tauri:build": "tauri build"
   },
diff --git a/desktop/playwright.release-smoke.config.ts b/desktop/playwright.release-smoke.config.ts
new file mode 100644
index 00000000000..19ac3cbf06d
--- /dev/null
+++ b/desktop/playwright.release-smoke.config.ts
@@ -0,0 +1,36 @@
+import { defineConfig, devices } from "@playwright/test";
+
+const webPort = process.env.BUZZ_RELEASE_SMOKE_WEB_PORT ?? "4173";
+const webUrl = `http://127.0.0.1:${webPort}`;
+
+export default defineConfig({
+  testDir: "./tests/e2e",
+  testMatch: [
+    "**/release-smoke.spec.ts",
+    "**/dm-history-live-regression.spec.ts",
+    "**/foreground-responsiveness-regression.spec.ts",
+  ],
+  timeout: 10 * 60_000,
+  retries: 0,
+  workers: 1,
+  reporter: [
+    ["list"],
+    ["json", { outputFile: "test-results/release-smoke/playwright.json" }],
+    [
+      "html",
+      { open: "never", outputFolder: "playwright-release-smoke-report" },
+    ],
+  ],
+  use: {
+    ...devices["Desktop Chrome"],
+    baseURL: webUrl,
+    screenshot: "only-on-failure",
+    trace: "retain-on-failure",
+  },
+  webServer: {
+    command: `python3 -m http.server ${webPort} -d dist`,
+    cwd: ".",
+    reuseExistingServer: false,
+    url: webUrl,
+  },
+});
diff --git a/desktop/src-tauri/src/commands/workflows.rs b/desktop/src-tauri/src/commands/workflows.rs
index 1d5f309fb5c..25e02980fa7 100644
--- a/desktop/src-tauri/src/commands/workflows.rs
+++ b/desktop/src-tauri/src/commands/workflows.rs
@@ -5,7 +5,7 @@ use tauri::State;
 use crate::{
     app_state::AppState,
     events,
-    relay::{parse_command_response, query_relay, submit_event},
+    relay::{get_relay_json, parse_command_response, query_relay, submit_event},
 };
 
 // ── Wire shapes (snake_case, consumed by tauriWorkflows.ts) ──────────────────
@@ -47,6 +47,41 @@ pub struct WorkflowSaveWire {
     pub webhook_secret: Option<String>,
 }
 
+#[derive(Debug, Clone, serde::Deserialize, Serialize, PartialEq)]
+pub struct WorkflowRunCursorWire {
+    pub before: String,
+    pub before_id: String,
+}
+
+#[derive(Debug, Clone, serde::Deserialize, Serialize, PartialEq)]
+pub struct WorkflowRunsWire {
+    pub runs: Vec<Value>,
+    pub next: Option<WorkflowRunCursorWire>,
+}
+
+#[derive(Debug, Clone, serde::Deserialize, Serialize, PartialEq)]
+pub struct WorkflowApprovalsWire {
+    pub approvals: Vec<Value>,
+}
+
+/// Canonical trigger acknowledgement consumed by the Desktop client.
+///
+/// The relay currently returns only `run_id`; the workflow id is the command
+/// input and a newly-created run always begins pending. Keeping that adaptation
+/// here prevents the frontend from guessing fields or confusing the trigger
+/// event id with the persisted run id.
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct WorkflowTriggerWire {
+    pub run_id: String,
+    pub workflow_id: String,
+    pub status: String,
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct WorkflowTriggerAck {
+    run_id: String,
+}
+
 // ── Reads ────────────────────────────────────────────────────────────────────
 
 #[tauri::command]
@@ -121,26 +156,16 @@ pub async fn get_workflow(
 pub async fn get_workflow_runs(
     workflow_id: String,
     limit: Option<u32>,
-    _state: State<'_, AppState>,
-) -> Result<Vec<Value>, String> {
-    // TODO(workflow-runs): Run reconstruction is a clearly-scoped follow-up.
-    // The authoritative run record the frontend's `WorkflowRun` shape needs
-    // (status / current_step / execution_trace / error_message) lives in the
-    // relay DB and is not exposed to the desktop client as a single queryable
-    // record. If the relay starts emitting lifecycle events (46001–46007, …),
-    // folding that stream into `WorkflowRun` would be another viable design.
-    // The important bit for this command is that raw lifecycle events are not
-    // the `RawWorkflowRun` contract.
-    //
-    // Until then we return a bare empty array — NOT a raw-event wrapper. The
-    // frontend wrapper (`getWorkflowRuns`) does `raw.map(fromRawWorkflowRun)`,
-    // so it must receive an array; the wrapped `{ runs: [...] }` shape would
-    // make `.map()` throw and crash the detail panel (the same TypeError class
-    // as the original page bug). Raw lifecycle events also don't carry the
-    // `id`/`workflow_id`/`status`/… fields `RawWorkflowRun` expects, so an
-    // empty list is the honest, safe placeholder.
-    let _ = (workflow_id, limit);
-    Ok(Vec::new())
+    state: State<'_, AppState>,
+) -> Result<WorkflowRunsWire, String> {
+    let workflow_id =
+        uuid::Uuid::parse_str(&workflow_id).map_err(|_| "invalid workflow id".to_string())?;
+    let limit = limit.unwrap_or(20).clamp(1, 100);
+    get_relay_json(
+        &state,
+        &format!("/workflows/{workflow_id}/runs?limit={limit}"),
+    )
+    .await
 }
 
 // ── Writes ───────────────────────────────────────────────────────────────────
@@ -242,10 +267,10 @@ pub async fn delete_workflow(
 pub async fn trigger_workflow(
     workflow_id: String,
     state: State<'_, AppState>,
-) -> Result<Value, String> {
+) -> Result<WorkflowTriggerWire, String> {
     let builder = events::build_workflow_trigger(&workflow_id)?;
     let result = submit_event(builder, &state).await?;
-    Ok(serde_json::json!({ "event_id": result.event_id }))
+    trigger_wire_from_message(workflow_id, &result.message)
 }
 
 // ── Approvals ────────────────────────────────────────────────────────────────
@@ -254,15 +279,17 @@ pub async fn trigger_workflow(
 pub async fn get_run_approvals(
     workflow_id: String,
     run_id: String,
-    _state: State<'_, AppState>,
-) -> Result<Vec<Value>, String> {
-    // TODO(workflow-runs): Like runs (see `get_workflow_runs`), reconstructing
-    // approvals into the frontend's `WorkflowApproval` shape from lifecycle
-    // events (46010/46011/46012) is a clearly-scoped follow-up tracked under
-    // TODO(workflow-runs). Return a bare empty array so the frontend's
-    // `getRunApprovals` (`raw.map(fromRawApproval)`) is safe.
-    let _ = (workflow_id, run_id);
-    Ok(Vec::new())
+    state: State<'_, AppState>,
+) -> Result<WorkflowApprovalsWire, String> {
+    let workflow_id =
+        uuid::Uuid::parse_str(&workflow_id).map_err(|_| "invalid workflow id".to_string())?;
+    let run_id =
+        uuid::Uuid::parse_str(&run_id).map_err(|_| "invalid workflow run id".to_string())?;
+    get_relay_json(
+        &state,
+        &format!("/workflows/{workflow_id}/runs/{run_id}/approvals"),
+    )
+    .await
 }
 
 #[tauri::command]
@@ -289,6 +316,21 @@ pub async fn deny_approval(
 
 // ── Helpers (pure, unit-tested in workflows_tests.rs) ─────────────────────────
 
+fn trigger_wire_from_message(
+    workflow_id: String,
+    message: &str,
+) -> Result<WorkflowTriggerWire, String> {
+    let ack: WorkflowTriggerAck = parse_command_response(message)?;
+    if ack.run_id.trim().is_empty() {
+        return Err("workflow trigger response contained an empty run_id".to_string());
+    }
+    Ok(WorkflowTriggerWire {
+        run_id: ack.run_id,
+        workflow_id,
+        status: "pending".to_string(),
+    })
+}
+
 fn current_pubkey_hex(state: &AppState) -> Result<String, String> {
     let keys = state.keys.lock().map_err(|e| e.to_string())?;
     Ok(keys.public_key().to_hex())
diff --git a/desktop/src-tauri/src/commands/workflows_tests.rs b/desktop/src-tauri/src/commands/workflows_tests.rs
index f07f4b0f421..647cc687064 100644
--- a/desktop/src-tauri/src/commands/workflows_tests.rs
+++ b/desktop/src-tauri/src/commands/workflows_tests.rs
@@ -189,21 +189,41 @@ fn workflow_wire_serializes_with_snake_case_keys() {
 }
 
 #[test]
-fn runs_and_approvals_serialize_to_bare_empty_array() {
-    // Regression guard for the crash class this fix closed. The frontend
-    // wrappers `getWorkflowRuns` / `getRunApprovals` do `raw.map(...)`, so the
-    // Rust side MUST return a bare JSON array. A wrapped `{ runs: [...] }` /
-    // `{ approvals: [...] }` shape would make `.map()` throw and crash the
-    // detail panel — the same TypeError class as the original page bug.
-    //
-    // The commands take `State<AppState>`, so we can't invoke them directly in
-    // a unit test; instead we pin the exact value they return (`Vec::new()` of
-    // their `Vec<Value>` element type) and assert its serialized shape.
-    let runs: Vec<Value> = Vec::new();
-    let approvals: Vec<Value> = Vec::new();
-    assert_eq!(serde_json::to_string(&runs).expect("serialize runs"), "[]");
+fn trigger_response_uses_persisted_run_id_contract() {
+    let wire = trigger_wire_from_message(
+        WF.to_string(),
+        "response:{\"run_id\":\"33333333-3333-3333-3333-333333333333\"}",
+    )
+    .expect("parse trigger response");
+
+    assert_eq!(wire.run_id, "33333333-3333-3333-3333-333333333333");
+    assert_eq!(wire.workflow_id, WF);
+    assert_eq!(wire.status, "pending");
+    let value = serde_json::to_value(wire).expect("serialize trigger response");
+    assert!(value.get("event_id").is_none());
+}
+
+#[test]
+fn trigger_response_rejects_missing_or_empty_run_id() {
+    assert!(trigger_wire_from_message(WF.to_string(), "response:{}").is_err());
+    assert!(trigger_wire_from_message(WF.to_string(), "response:{\"run_id\":\"   \"}",).is_err());
+}
+
+#[test]
+fn run_reads_serialize_to_backend_envelopes() {
+    let runs = WorkflowRunsWire {
+        runs: Vec::new(),
+        next: None,
+    };
+    let approvals = WorkflowApprovalsWire {
+        approvals: Vec::new(),
+    };
+    assert_eq!(
+        serde_json::to_value(runs).expect("serialize runs"),
+        serde_json::json!({ "runs": [], "next": null })
+    );
     assert_eq!(
-        serde_json::to_string(&approvals).expect("serialize approvals"),
-        "[]"
+        serde_json::to_value(approvals).expect("serialize approvals"),
+        serde_json::json!({ "approvals": [] })
     );
 }
diff --git a/desktop/src-tauri/src/relay.rs b/desktop/src-tauri/src/relay.rs
index 7b636a4a822..685f83b7999 100644
--- a/desktop/src-tauri/src/relay.rs
+++ b/desktop/src-tauri/src/relay.rs
@@ -532,6 +532,9 @@ pub struct AgentProfileInfo {
 
 // ── Signed-event submission ─────────────────────────────────────────────────
 
+mod get;
+pub use get::get_relay_json;
+
 mod submit;
 pub use submit::{
     submit_event, submit_event_at_with_keys, submit_signed_event_at_with_keys, SubmitEventResponse,
diff --git a/desktop/src-tauri/src/relay/get.rs b/desktop/src-tauri/src/relay/get.rs
new file mode 100644
index 00000000000..7d0855f463f
--- /dev/null
+++ b/desktop/src-tauri/src/relay/get.rs
@@ -0,0 +1,37 @@
+use reqwest::Method;
+use serde::de::DeserializeOwned;
+
+use crate::app_state::AppState;
+
+use super::{
+    build_nip98_auth_header, classify_request_error, parse_json_response,
+    relay_api_base_url_with_override, relay_error_message,
+};
+
+/// Execute an authenticated GET against the active relay and decode its JSON body.
+pub async fn get_relay_json<T: DeserializeOwned>(
+    state: &AppState,
+    path_with_query: &str,
+) -> Result<T, String> {
+    if !path_with_query.starts_with('/') {
+        return Err("relay GET path must begin with '/'".to_string());
+    }
+    crate::relay_admission::wait_for_rate_limit().await;
+    let url = format!(
+        "{}{}",
+        relay_api_base_url_with_override(state),
+        path_with_query
+    );
+    let auth = build_nip98_auth_header(&Method::GET, &url, &[], state)?;
+    let response = state
+        .http_client
+        .get(&url)
+        .header("Authorization", auth)
+        .send()
+        .await
+        .map_err(|error| classify_request_error(&error))?;
+    if !response.status().is_success() {
+        return Err(relay_error_message(response).await);
+    }
+    parse_json_response(response).await
+}
diff --git a/desktop/src/app/AppHuddleShell.tsx b/desktop/src/app/AppHuddleShell.tsx
index 29dcd26cdfb..68f9eacd6fd 100644
--- a/desktop/src/app/AppHuddleShell.tsx
+++ b/desktop/src/app/AppHuddleShell.tsx
@@ -68,7 +68,7 @@ export function AppHuddleShell({
             {children}
           </div>
           {isRoom || !isCompanionOpen ? (
-            <div className="absolute inset-x-0 bottom-0 z-[2] h-(--buzz-huddle-drawer-height)">
+            <div className="buzz-huddle-drawer-slot absolute inset-x-0 bottom-0 z-[2] h-(--buzz-huddle-drawer-height)">
               <AppHuddleBar
                 mode={isRoom ? "room" : "main"}
                 onOpenHuddleWindow={isRoom ? undefined : onCompanionOpen}
diff --git a/desktop/src/features/agents/lib/agentAutocompleteEligibility.test.mjs b/desktop/src/features/agents/lib/agentAutocompleteEligibility.test.mjs
index b8807ece1ff..4fba7056b27 100644
--- a/desktop/src/features/agents/lib/agentAutocompleteEligibility.test.mjs
+++ b/desktop/src/features/agents/lib/agentAutocompleteEligibility.test.mjs
@@ -3,8 +3,10 @@ import test from "node:test";
 
 import {
   coalesceAgentAutocompleteCandidates,
+  filterAdmittedMentionPubkeys,
   filterCachedAgentSuggestions,
   getAdmittedMemberAgentPubkeys,
+  getAgentMentionAdmission,
   getMentionableAgentPubkeys,
   getSharedChannelIds,
   isAgentIdentityInAllowedList,
@@ -379,6 +381,7 @@ test("isAgentIdentityInAllowedList: keeps people and only explicitly allowed age
 test("shouldHideAgentFromMentions: never hides non-agents", () => {
   assert.equal(
     shouldHideAgentFromMentions({
+      ownerOnly: false,
       isAgent: false,
       isMember: false,
       pubkey: PUB_A,
@@ -392,6 +395,7 @@ test("shouldHideAgentFromMentions: never hides non-agents", () => {
 test("shouldHideAgentFromMentions: shows invocable agents even when non-member", () => {
   assert.equal(
     shouldHideAgentFromMentions({
+      ownerOnly: false,
       isAgent: true,
       isMember: false,
       pubkey: PUB_A,
@@ -405,6 +409,7 @@ test("shouldHideAgentFromMentions: shows invocable agents even when non-member",
 test("shouldHideAgentFromMentions: hides non-member non-invocable agents", () => {
   assert.equal(
     shouldHideAgentFromMentions({
+      ownerOnly: false,
       isAgent: true,
       isMember: false,
       pubkey: PUB_A,
@@ -418,6 +423,7 @@ test("shouldHideAgentFromMentions: hides non-member non-invocable agents", () =>
 test("shouldHideAgentFromMentions: hides member agents with an explicit not-invocable directory entry (Fizz)", () => {
   assert.equal(
     shouldHideAgentFromMentions({
+      ownerOnly: false,
       isAgent: true,
       isMember: true,
       pubkey: PUB_A,
@@ -428,14 +434,46 @@ test("shouldHideAgentFromMentions: hides member agents with an explicit not-invo
   );
 });
 
-test("shouldHideAgentFromMentions: shows member agents with unknown invocability (not in directory)", () => {
+test("shouldHideAgentFromMentions: hides unknown member agents while directories load", () => {
   assert.equal(
     shouldHideAgentFromMentions({
+      ownerOnly: false,
       isAgent: true,
       isMember: true,
       pubkey: PUB_A,
       mentionableAgentPubkeys: new Set(),
       directoryAgentPubkeys: new Set(),
+      directoryReady: false,
+    }),
+    true,
+  );
+});
+
+test("shouldHideAgentFromMentions: hides mentionable member agents while directories load", () => {
+  assert.equal(
+    shouldHideAgentFromMentions({
+      ownerOnly: false,
+      isAgent: true,
+      isMember: true,
+      pubkey: PUB_A,
+      mentionableAgentPubkeys: new Set([PUB_A]),
+      directoryAgentPubkeys: new Set(),
+      directoryReady: false,
+    }),
+    true,
+  );
+});
+
+test("shouldHideAgentFromMentions: shows non-agent members while directories load", () => {
+  assert.equal(
+    shouldHideAgentFromMentions({
+      ownerOnly: false,
+      isAgent: false,
+      isMember: true,
+      pubkey: PUB_A,
+      mentionableAgentPubkeys: new Set(),
+      directoryAgentPubkeys: new Set([PUB_A]),
+      directoryReady: false,
     }),
     false,
   );
@@ -457,6 +495,7 @@ test("member agents: the allowed-list predicate is STRICTER than the hide rule",
     pubkey: PUB_A,
     mentionableAgentPubkeys: new Set(),
     directoryAgentPubkeys: new Set(),
+    ownerOnly: false,
   };
 
   assert.equal(
@@ -534,12 +573,26 @@ test("getAdmittedMemberAgentPubkeys: normalizes before gating and emitting", ()
   );
 });
 
+test("shouldHideAgentFromMentions: hides agents while owner policy loads", () => {
+  assert.equal(
+    shouldHideAgentFromMentions({
+      isAgent: true,
+      pubkey: PUB_A,
+      mentionableAgentPubkeys: new Set([PUB_A]),
+      directoryReady: true,
+      ownerOnly: undefined,
+    }),
+    true,
+  );
+});
+
 test("shouldHideAgentFromMentions: normalizes the pubkey before lookup", () => {
   const mixedCase = "Ab".repeat(32);
   const normalized = mixedCase.toLowerCase();
 
   assert.equal(
     shouldHideAgentFromMentions({
+      ownerOnly: false,
       isAgent: true,
       isMember: true,
       pubkey: mixedCase,
@@ -550,6 +603,58 @@ test("shouldHideAgentFromMentions: normalizes the pubkey before lookup", () => {
   );
 });
 
+test("getAgentMentionAdmission: owner-only requires current verified ownership", () => {
+  const common = {
+    isAgent: true,
+    isManagedAgent: false,
+    pubkey: PUB_A,
+    currentPubkey: CURRENT_PUBKEY,
+    mentionableAgentPubkeys: new Set([PUB_A]),
+    directoryReady: true,
+    ownerOnly: true,
+  };
+
+  assert.equal(
+    getAgentMentionAdmission({ ...common, ownerPubkey: CURRENT_PUBKEY }),
+    "allow",
+  );
+  assert.equal(
+    getAgentMentionAdmission({ ...common, ownerPubkey: OTHER_OWNER_PUBKEY }),
+    "deny",
+  );
+  assert.equal(
+    getAgentMentionAdmission({ ...common, ownerPubkey: null }),
+    "unknown",
+  );
+});
+
+test("getAgentMentionAdmission: unresolved directory state stays unknown", () => {
+  assert.equal(
+    getAgentMentionAdmission({
+      isAgent: true,
+      isManagedAgent: false,
+      pubkey: PUB_A,
+      currentPubkey: CURRENT_PUBKEY,
+      ownerPubkey: CURRENT_PUBKEY,
+      mentionableAgentPubkeys: new Set([PUB_A]),
+      directoryReady: false,
+      ownerOnly: false,
+    }),
+    "unknown",
+  );
+});
+
+test("filterAdmittedMentionPubkeys: rechecks agent admission without dropping people", () => {
+  assert.deepEqual(
+    filterAdmittedMentionPubkeys(
+      [PUB_A, PUB_B, PUB_C],
+      new Set([PUB_A, PUB_B]),
+      new Set([PUB_B]),
+    ),
+    [PUB_B, PUB_C],
+  );
+});
+
 test("coalesceAgentAutocompleteCandidates: keeps agents with the same persona id distinct", () => {
   const first = makeAgent({ pubkey: PUB_A, personaId: "pinky" });
   const second = makeAgent({
diff --git a/desktop/src/features/agents/lib/agentAutocompleteEligibility.ts b/desktop/src/features/agents/lib/agentAutocompleteEligibility.ts
index 2e0584c8944..741ac66ee9d 100644
--- a/desktop/src/features/agents/lib/agentAutocompleteEligibility.ts
+++ b/desktop/src/features/agents/lib/agentAutocompleteEligibility.ts
@@ -168,37 +168,158 @@ export function isAgentIdentityInAllowedList(
   );
 }
 
+export type AgentMentionAdmission = "allow" | "deny" | "unknown";
+
+export function getAgentMentionAdmission({
+  isAgent,
+  isManagedAgent,
+  isMember = false,
+  pubkey,
+  ownerPubkey,
+  currentPubkey,
+  mentionableAgentPubkeys,
+  directoryAgentPubkeys = new Set(),
+  directoryReady,
+  ownerOnly,
+}: {
+  isAgent: boolean;
+  isManagedAgent: boolean;
+  isMember?: boolean;
+  pubkey: string;
+  ownerPubkey?: string | null;
+  currentPubkey?: string | null;
+  mentionableAgentPubkeys: ReadonlySet<string>;
+  directoryAgentPubkeys?: ReadonlySet<string>;
+  directoryReady: boolean;
+  ownerOnly: boolean | undefined;
+}): AgentMentionAdmission {
+  if (!isAgent) return "allow";
+  if (!directoryReady || ownerOnly === undefined) return "unknown";
+
+  const normalized = normalizePubkey(pubkey);
+  // Member (Option B): a channel-member agent with no relay directory
+  // (kind:10100) entry has unknown invocability rather than an explicit
+  // exclusion — treat it as mentionable rather than hiding every
+  // other-owner agent whose profile was never published.
+  const isLenientMember =
+    isMember &&
+    !mentionableAgentPubkeys.has(normalized) &&
+    !directoryAgentPubkeys.has(normalized);
+  if (!mentionableAgentPubkeys.has(normalized) && !isLenientMember) {
+    return "deny";
+  }
+  if (!ownerOnly || isManagedAgent) return "allow";
+  if (!ownerPubkey || !currentPubkey) return "unknown";
+
+  return normalizePubkey(ownerPubkey) === normalizePubkey(currentPubkey)
+    ? "allow"
+    : "deny";
+}
+
 export function shouldHideAgentFromMentions({
   isAgent,
-  isMember,
+  isManagedAgent = false,
+  isMember = false,
   pubkey,
+  ownerPubkey,
+  currentPubkey,
   mentionableAgentPubkeys,
   directoryAgentPubkeys,
+  directoryReady = true,
+  ownerOnly,
 }: {
   isAgent: boolean;
-  isMember: boolean;
+  isManagedAgent?: boolean;
+  isMember?: boolean;
   pubkey: string;
+  ownerPubkey?: string | null;
+  currentPubkey?: string | null;
   mentionableAgentPubkeys: ReadonlySet<string>;
-  directoryAgentPubkeys: ReadonlySet<string>;
+  directoryAgentPubkeys?: ReadonlySet<string>;
+  directoryReady?: boolean;
+  ownerOnly: boolean | undefined;
 }) {
-  if (!isAgent) return false;
-  const normalized = normalizePubkey(pubkey);
-  // Invocable => always show.
-  if (mentionableAgentPubkeys.has(normalized)) return false;
-  // Non-member, non-invocable => hide (preserves prior behavior).
-  if (!isMember) return true;
-  // Member (Option B): hide only when we have an explicit not-invocable
-  // signal — a relay directory (kind:10100) entry that excludes us.
-  // Unknown invocability (not in directory) => show.
-  //
-  // NOTE: this assumes `directoryAgentPubkeys` and `mentionableAgentPubkeys`
-  // share the same source query (`relayAgentsQuery.data`), so directory
-  // presence without membership in `mentionableAgentPubkeys` is a real
-  // explicit-exclusion signal. If a future change sources the directory set
-  // from a different query, an agent that's directory-present but whose
-  // mentionability is still loading could be hidden prematurely — keep the
-  // two sets derived from the same query.
-  return directoryAgentPubkeys.has(normalized);
+  return (
+    getAgentMentionAdmission({
+      isAgent,
+      isManagedAgent,
+      isMember,
+      pubkey,
+      ownerPubkey,
+      currentPubkey,
+      mentionableAgentPubkeys,
+      directoryAgentPubkeys,
+      directoryReady,
+      ownerOnly,
+    }) !== "allow"
+  );
+}
+
+export function getAgentIdentityPubkeys({
+  managedAgentPubkeys,
+  relayAgents,
+  members,
+  profileIsAgent,
+}: {
+  managedAgentPubkeys: ReadonlySet<string>;
+  relayAgents: readonly { pubkey: string }[];
+  members: readonly {
+    pubkey: string;
+    isAgent?: boolean;
+    role?: string | null;
+  }[];
+  profileIsAgent: (pubkey: string) => boolean;
+}) {
+  return new Set([
+    ...managedAgentPubkeys,
+    ...relayAgents.map(({ pubkey }) => normalizePubkey(pubkey)),
+    ...members
+      .filter(
+        (member) =>
+          member.isAgent === true ||
+          member.role === "bot" ||
+          profileIsAgent(normalizePubkey(member.pubkey)),
+      )
+      .map(({ pubkey }) => normalizePubkey(pubkey)),
+  ]);
+}
+
+export function getAdmittedAgentPubkeys(
+  candidates: readonly { pubkey?: string; isAgent?: boolean }[],
+) {
+  return new Set(
+    candidates.flatMap((candidate) =>
+      candidate.isAgent && candidate.pubkey
+        ? [normalizePubkey(candidate.pubkey)]
+        : [],
+    ),
+  );
+}
+
+export function rememberSelectedAgentPubkeys(
+  target: Set<string>,
+  selected: readonly { pubkey?: string; isAgent?: boolean }[],
+  selectionIsAgent: boolean,
+) {
+  for (const candidate of selected) {
+    if (candidate.pubkey && (selectionIsAgent || candidate.isAgent === true)) {
+      target.add(normalizePubkey(candidate.pubkey));
+    }
+  }
+}
+
+export function filterAdmittedMentionPubkeys(
+  pubkeys: readonly string[],
+  agentIdentityPubkeys: ReadonlySet<string>,
+  admittedAgentPubkeys: ReadonlySet<string>,
+) {
+  return pubkeys.filter((pubkey) => {
+    const normalized = normalizePubkey(pubkey);
+    return (
+      !agentIdentityPubkeys.has(normalized) ||
+      admittedAgentPubkeys.has(normalized)
+    );
+  });
 }
 
 /**
@@ -235,6 +356,11 @@ export function getAdmittedMemberAgentPubkeys({
         pubkey: normalized,
         mentionableAgentPubkeys,
         directoryAgentPubkeys,
+        // This helper only answers the invocability/membership question the
+        // picker's member branch depends on — owner-only visibility is
+        // already enforced by the picker itself before a pubkey ever
+        // reaches here.
+        ownerOnly: false,
       })
     ) {
       continue;
diff --git a/desktop/src/features/channels/hooks.ts b/desktop/src/features/channels/hooks.ts
index 2d3dd22f05a..fb2b6864b36 100644
--- a/desktop/src/features/channels/hooks.ts
+++ b/desktop/src/features/channels/hooks.ts
@@ -484,24 +484,31 @@ export function useOpenDmMutation() {
       );
     },
     onSettled: () => {
-      void queryClient.invalidateQueries({ queryKey: channelsQueryKey });
+      // The relay-returned DM is already in the cache. Mark the list stale so
+      // the normal live/poll refresh can reconcile it later without putting a
+      // full get_channels round-trip on the critical path to the conversation.
+      void queryClient.invalidateQueries({
+        queryKey: channelsQueryKey,
+        refetchType: "none",
+      });
     },
   });
 }
 
 /**
- * Waits for any active channel-list refresh to settle, then restores a
- * relay-returned channel to the shared cache before a caller depends on it for
- * navigation.
+ * Reasserts a relay-returned channel in the shared cache before a caller
+ * depends on it for navigation. The open-DM mutation already made the relay
+ * write authoritative, so cancel any older list read and stay local rather
+ * than blocking on a read-after-write channel-list refresh.
  */
 export function useUpsertCachedChannel() {
   const queryClient = useQueryClient();
 
   return React.useCallback(
     async (channel: Channel) => {
-      await queryClient.refetchQueries({
+      await queryClient.cancelQueries({
         queryKey: channelsQueryKey,
-        type: "active",
+        exact: true,
       });
       queryClient.setQueryData<Channel[]>(channelsQueryKey, (current) =>
         reconcileRefreshedCachedChannel(current, channel),
diff --git a/desktop/src/features/forum/ui/ForumComposer.tsx b/desktop/src/features/forum/ui/ForumComposer.tsx
index 6204186abe9..54e7d58c96c 100644
--- a/desktop/src/features/forum/ui/ForumComposer.tsx
+++ b/desktop/src/features/forum/ui/ForumComposer.tsx
@@ -58,6 +58,7 @@ export function ForumComposer({
   const [isCompactExpanded, setIsCompactExpanded] = React.useState(!compact);
   const [isEmojiPickerOpen, setIsEmojiPickerOpen] = React.useState(false);
   const [isFormattingOpen, setIsFormattingOpen] = React.useState(false);
+  const [isSubmissionPending, setIsSubmissionPending] = React.useState(false);
   const [submitMode, setSubmitMode] = React.useState<"primary" | "secondary">(
     "primary",
   );
@@ -83,6 +84,7 @@ export function ForumComposer({
   const disabledRef = React.useRef(disabled);
   const isSendingRef = React.useRef(isSending);
   const isUploadingRef = React.useRef(media.isUploading);
+  const isSubmissionPendingRef = React.useRef(false);
   const onSubmitRef = React.useRef(onSubmit);
   const onSecondarySubmitRef = React.useRef(onSecondarySubmit);
   const submitModeRef = React.useRef(submitMode);
@@ -111,7 +113,7 @@ export function ForumComposer({
 
   const richText = useRichTextEditor({
     placeholder,
-    editable: !disabled,
+    editable: !disabled && !isSubmissionPending,
     mentionNames: mentions.knownNames,
     channelNames: channelLinks.knownChannelNames,
     messageLinkChannels: channelLinks.channels,
@@ -139,6 +141,7 @@ export function ForumComposer({
   // Native ProseMirror transactions — no markdown round-trip.
   const applyMentionInsert = React.useCallback(
     (suggestion: MentionSuggestion) => {
+      if (isSubmissionPendingRef.current) return;
       const { cursor } = richText.getPlainTextAndCursor();
       const { replaceFromOffset, replaceToOffset, insertText } =
         mentions.insertMention(suggestion, cursor);
@@ -157,6 +160,7 @@ export function ForumComposer({
 
   const applyChannelInsert = React.useCallback(
     (suggestion: ChannelSuggestion) => {
+      if (isSubmissionPendingRef.current) return;
       const { cursor } = richText.getPlainTextAndCursor();
       const { replaceFromOffset, replaceToOffset, insertText } =
         channelLinks.insertChannel(suggestion, cursor);
@@ -175,7 +179,7 @@ export function ForumComposer({
 
   const insertEmoji = React.useCallback(
     (emoji: string) => {
-      if (!richText.editor) return;
+      if (isSubmissionPendingRef.current || !richText.editor) return;
       richText.editor.chain().focus().insertContent(emoji).run();
       setIsEmojiPickerOpen(false);
       mentions.clearMentions();
@@ -213,7 +217,7 @@ export function ForumComposer({
 
   // ── Submit ──────────────────────────────────────────────────────────
   const submitMessage = React.useCallback(
-    (submitter = onSubmitRef.current) => {
+    async (submitter = onSubmitRef.current) => {
       const trimmed = contentRef.current.trim();
       const currentPendingImeta = media.pendingImetaRef.current;
       const hasMedia = currentPendingImeta.length > 0;
@@ -222,58 +226,68 @@ export function ForumComposer({
         (!trimmed && !hasMedia) ||
         disabledRef.current ||
         isSendingRef.current ||
-        isUploadingRef.current
+        isUploadingRef.current ||
+        isSubmissionPendingRef.current
       ) {
         return;
       }
 
-      const pubkeys = mentions.extractMentionPubkeys(trimmed);
-
-      // Reuse the shared send-path builder so forum/notes posts emit the same
-      // body + imeta as chat: generic files become `[filename](url)` links with a
-      // `filename` imeta tag (FileCard renderer), images/video stay inline. Send
-      // semantics use `undefined` for "no attachments" (no imeta tags emitted).
-      const { content: finalContent, mediaTags } = buildOutgoingMessage(
-        trimmed,
-        currentPendingImeta,
-      );
-
-      // Save draft state so we can restore on failure.
-      const savedContent = contentRef.current;
-      const savedImeta = [...currentPendingImeta];
-
-      setContent("");
-      contentRef.current = "";
-      richText.clearContent();
-      media.setPendingImeta([]);
-      mentions.clearMentions();
+      isSubmissionPendingRef.current = true;
+      setIsSubmissionPending(true);
+      mentions.cancelMentionAutocomplete();
       channelLinks.clearChannels();
       setIsEmojiPickerOpen(false);
-
-      const result = submitter(finalContent, pubkeys, mediaTags);
-      const completeSubmission = () => {
-        setSubmitMode("primary");
-        if (compact) setIsCompactExpanded(false);
-      };
-
-      // If onSubmit returns a promise, restore draft on failure.
-      if (result && typeof result.then === "function") {
-        result.then(completeSubmission).catch(() => {
+      try {
+        const pubkeys = await mentions.revalidateMentionPubkeys(
+          mentions.extractMentionPubkeys(trimmed),
+        );
+
+        // Reuse the shared send-path builder so forum/notes posts emit the same
+        // body + imeta as chat: generic files become `[filename](url)` links with a
+        // `filename` imeta tag (FileCard renderer), images/video stay inline. Send
+        // semantics use `undefined` for "no attachments" (no imeta tags emitted).
+        const { content: finalContent, mediaTags } = buildOutgoingMessage(
+          trimmed,
+          currentPendingImeta,
+        );
+
+        // Save draft state so we can restore on failure.
+        const savedContent = contentRef.current;
+        const savedImeta = [...currentPendingImeta];
+
+        setContent("");
+        contentRef.current = "";
+        richText.clearContent();
+        media.setPendingImeta([]);
+        mentions.clearMentions();
+        channelLinks.clearChannels();
+        setIsEmojiPickerOpen(false);
+
+        try {
+          await submitter(finalContent, pubkeys, mediaTags);
+          setSubmitMode("primary");
+          if (compact) setIsCompactExpanded(false);
+        } catch {
           setContent(savedContent);
           contentRef.current = savedContent;
           richText.setContent(savedContent);
           media.setPendingImeta(savedImeta);
           if (compact) setIsCompactExpanded(true);
-        });
-      } else {
-        completeSubmission();
+        }
+      } catch {
+        // Keep the draft intact when authorization refresh fails.
+      } finally {
+        isSubmissionPendingRef.current = false;
+        setIsSubmissionPending(false);
       }
     },
     [
       compact,
       media.pendingImetaRef,
       media.setPendingImeta,
+      mentions.cancelMentionAutocomplete,
       mentions.extractMentionPubkeys,
+      mentions.revalidateMentionPubkeys,
       mentions.clearMentions,
       channelLinks.clearChannels,
       richText.clearContent,
@@ -375,9 +389,16 @@ export function ForumComposer({
   const sendDisabled = React.useMemo(
     () =>
       disabled ||
+      isSubmissionPending ||
       media.isUploading ||
       (content.trim().length === 0 && media.pendingImeta.length === 0),
-    [disabled, media.isUploading, content, media.pendingImeta.length],
+    [
+      disabled,
+      isSubmissionPending,
+      media.isUploading,
+      content,
+      media.pendingImeta.length,
+    ],
   );
   const hasComposerContent =
     content.trim().length > 0 ||
@@ -448,15 +469,30 @@ export function ForumComposer({
           "relative rounded-2xl border border-input bg-card px-3 py-2 sm:px-4",
           className,
         )}
+        inert={isSubmissionPending ? true : undefined}
         onBlurCapture={handleFormBlur}
         onDragEnter={(event) => {
+          if (isSubmissionPending) {
+            event.preventDefault();
+            return;
+          }
           expandCompactComposer();
           media.handleDragEnter(event);
         }}
         onDragLeave={media.handleDragLeave}
-        onDragOver={media.handleDragOver}
-        onDrop={(e) => {
-          void media.handleDrop(e);
+        onDragOver={(event) => {
+          if (isSubmissionPending) {
+            event.preventDefault();
+            return;
+          }
+          media.handleDragOver(event);
+        }}
+        onDrop={(event) => {
+          if (isSubmissionPending) {
+            event.preventDefault();
+            return;
+          }
+          void media.handleDrop(event);
         }}
         onFocusCapture={expandCompactComposer}
         onSubmit={handleSubmit}
@@ -466,7 +502,7 @@ export function ForumComposer({
           <ForumComposerCompactLayout
             editor={richText.editor}
             header={header}
-            isSending={isSending}
+            isSending={Boolean(isSending || isSubmissionPending)}
             onEditorKeyDown={handleEditorKeyDown}
             sendDisabled={sendDisabled}
           />
@@ -496,7 +532,15 @@ export function ForumComposer({
               position={autocompletePosition}
             />
 
-            <ForumComposerMediaStatus media={media} />
+            <fieldset
+              className="min-w-0 border-0 p-0"
+              disabled={isSubmissionPending}
+            >
+              <ForumComposerMediaStatus
+                disabled={isSubmissionPending}
+                media={media}
+              />
+            </fieldset>
 
             {/* biome-ignore lint/a11y/noStaticElementInteractions: keydown handler bridges Tiptap editor to autocomplete and submit */}
             <div
@@ -507,14 +551,14 @@ export function ForumComposer({
             </div>
 
             <MessageComposerToolbar
-              composerDisabled={disabled ?? false}
+              composerDisabled={Boolean(disabled || isSubmissionPending)}
               editor={richText.editor}
               extraActions={
                 onCancel || (onSecondarySubmit && secondarySubmitLabel) ? (
                   <>
                     {onCancel ? (
                       <Button
-                        disabled={isSending}
+                        disabled={isSending || isSubmissionPending}
                         onClick={onCancel}
                         size="sm"
                         type="button"
@@ -531,7 +575,9 @@ export function ForumComposer({
                               submitMode === "secondary" &&
                                 "border-amber-500/40 text-amber-700 hover:bg-amber-500/10 hover:text-amber-800 dark:text-amber-400 dark:hover:text-amber-300",
                             )}
-                            disabled={disabled || isSending}
+                            disabled={
+                              disabled || isSending || isSubmissionPending
+                            }
                             size="sm"
                             type="button"
                             variant="outline"
@@ -562,10 +608,10 @@ export function ForumComposer({
                   </>
                 ) : undefined
               }
-              formattingDisabled={disabled ?? false}
+              formattingDisabled={Boolean(disabled || isSubmissionPending)}
               isEmojiPickerOpen={isEmojiPickerOpen}
               isFormattingOpen={isFormattingOpen}
-              isSending={isSending ?? false}
+              isSending={Boolean(isSending || isSubmissionPending)}
               isUploading={media.isUploading}
               onCaptureSelection={handleToolbarMouseDown}
               onEmojiPickerOpenChange={setIsEmojiPickerOpen}
@@ -579,8 +625,8 @@ export function ForumComposer({
           </>
         )}
       </form>
-      {linkEditor.card}
-      {linkEditor.dialog}
+      {!isSubmissionPending && linkEditor.card}
+      {!isSubmissionPending && linkEditor.dialog}
     </>
   );
 }
diff --git a/desktop/src/features/forum/ui/ForumComposerMediaStatus.tsx b/desktop/src/features/forum/ui/ForumComposerMediaStatus.tsx
index 3a245bdfce9..b7dccf709f2 100644
--- a/desktop/src/features/forum/ui/ForumComposerMediaStatus.tsx
+++ b/desktop/src/features/forum/ui/ForumComposerMediaStatus.tsx
@@ -19,17 +19,27 @@ type ComposerMedia = Pick<
 >;
 
 type ForumComposerMediaStatusProps = {
+  disabled?: boolean;
   media: ComposerMedia;
 };
 
 export function ForumComposerMediaStatus({
+  disabled = false,
   media,
 }: ForumComposerMediaStatusProps) {
   const handleEditSave = React.useCallback(
     async (url: string, bytes: Uint8Array) => {
+      if (disabled) return;
       await media.uploadEditedAttachment(url, bytes);
     },
-    [media.uploadEditedAttachment],
+    [disabled, media.uploadEditedAttachment],
+  );
+  const guard = React.useCallback(
+    <T,>(callback: (value: T) => void) =>
+      (value: T) => {
+        if (!disabled) callback(value);
+      },
+    [disabled],
   );
 
   return (
@@ -39,6 +49,7 @@ export function ForumComposerMediaStatus({
           Upload failed: {media.uploadState.message}
           <button
             className="ml-2 underline"
+            disabled={disabled}
             onClick={() => media.setUploadState({ status: "idle" })}
             type="button"
           >
@@ -52,10 +63,10 @@ export function ForumComposerMediaStatus({
           <ComposerAttachments
             attachments={media.pendingImeta}
             isUploading={media.isUploading}
-            onCancelUpload={media.cancelUpload}
+            onCancelUpload={guard(media.cancelUpload)}
             onEditSave={handleEditSave}
-            onRemove={media.removeAttachment}
-            onRevert={media.revertAttachment}
+            onRemove={guard(media.removeAttachment)}
+            onRevert={guard(media.revertAttachment)}
             originalUrlByUrl={media.originalUrlByUrl}
             uploadingCount={media.uploadingCount}
             uploadingPreviews={media.uploadingPreviews}
diff --git a/desktop/src/features/home/ui/HomeView.tsx b/desktop/src/features/home/ui/HomeView.tsx
index 3b7bff44ea0..893b3c309c6 100644
--- a/desktop/src/features/home/ui/HomeView.tsx
+++ b/desktop/src/features/home/ui/HomeView.tsx
@@ -822,6 +822,7 @@ export function HomeView({
                 if (!selectedItem || !canDelete) return;
                 void deleteInboxMessage(selectedItem.id);
               }}
+              onDeleteMessage={deleteInboxMessage}
               onManageChannel={(channelId) => {
                 handleCloseProfilePanel();
                 setManagedChannelId(channelId);
diff --git a/desktop/src/features/home/ui/InboxDetailPane.tsx b/desktop/src/features/home/ui/InboxDetailPane.tsx
index c1ad2607528..8ad02376750 100644
--- a/desktop/src/features/home/ui/InboxDetailPane.tsx
+++ b/desktop/src/features/home/ui/InboxDetailPane.tsx
@@ -102,6 +102,7 @@ type InboxDetailPaneProps = {
   latchedDefaultParentId?: string | null;
   onBack?: () => void;
   onDelete: () => void;
+  onDeleteMessage: (eventId: string) => void;
   onEditTargetChange: React.Dispatch<React.SetStateAction<string | null>>;
   onEditSave: (input: {
     content: string;
@@ -170,6 +171,7 @@ function InboxMessageDetailPane({
   latchedDefaultParentId = null,
   onBack,
   onDelete,
+  onDeleteMessage,
   onEditTargetChange,
   onEditSave,
   onRequestEmptyEditDelete,
@@ -663,6 +665,11 @@ function InboxMessageDetailPane({
                   isFocusHighlightVisible={isFocusHighlightVisible}
                   key={message.id}
                   message={message}
+                  onDelete={
+                    canEditMessage
+                      ? () => onDeleteMessage(message.id)
+                      : undefined
+                  }
                   onEdit={canEditMessage ? handleSelectEditTarget : undefined}
                   onSelectReplyTarget={handleSelectReplyTarget}
                   onToggleReaction={onToggleReaction}
diff --git a/desktop/src/features/home/ui/InboxMessageRow.tsx b/desktop/src/features/home/ui/InboxMessageRow.tsx
index 039d418a148..0c49b2423b0 100644
--- a/desktop/src/features/home/ui/InboxMessageRow.tsx
+++ b/desktop/src/features/home/ui/InboxMessageRow.tsx
@@ -32,6 +32,7 @@ type InboxMessageRowProps = {
   isFirst?: boolean;
   isFocusHighlightVisible: boolean;
   message: InboxDisplayMessage;
+  onDelete?: (message: InboxDisplayMessage) => void;
   onEdit?: (message: InboxDisplayMessage) => void;
   onSelectReplyTarget: (message: InboxDisplayMessage) => void;
   onToggleReaction?: (
@@ -50,6 +51,7 @@ export function InboxMessageRow({
   isFirst = false,
   isFocusHighlightVisible,
   message,
+  onDelete,
   onEdit,
   onSelectReplyTarget,
   onToggleReaction,
@@ -119,7 +121,7 @@ export function InboxMessageRow({
             : "home-inbox-context-message"
         }
       >
-        {canReply || canToggleReactions || onEdit ? (
+        {canReply || canToggleReactions || onDelete || onEdit ? (
           <div
             className={cn(
               "absolute right-2 top-1 z-10",
@@ -129,6 +131,7 @@ export function InboxMessageRow({
             <MessageActionBar
               channelId={channelId}
               message={timelineMessage}
+              onDelete={onDelete ? () => onDelete(message) : undefined}
               onEdit={onEdit ? () => onEdit(message) : undefined}
               onReactionSelect={
                 canToggleReactions ? handleReactionSelect : undefined
diff --git a/desktop/src/features/messages/hooks.ts b/desktop/src/features/messages/hooks.ts
index e59cd72a919..e595c30323d 100644
--- a/desktop/src/features/messages/hooks.ts
+++ b/desktop/src/features/messages/hooks.ts
@@ -452,6 +452,7 @@ export function useSendMessageMutation(
       mediaTags?: string[][];
       sentFromThreadRootId?: string | null;
       sentFromThreadRootExcerpt?: string | null;
+      transport?: "auto" | "http";
     },
     MessageQueryContext | undefined
   >({
@@ -464,6 +465,7 @@ export function useSendMessageMutation(
       mediaTags,
       sentFromThreadRootId,
       sentFromThreadRootExcerpt,
+      transport = "auto",
     }) => {
       // Prefer a channel captured by the caller at compose time. Otherwise,
       // resolve a captured id from the shared channel cache so navigation
@@ -523,6 +525,7 @@ export function useSendMessageMutation(
       // the relay's tag validation runs. The WebSocket path emits no extra
       // tags, so emoji-only messages would otherwise lose their emoji tag.
       if (
+        transport === "http" ||
         parentEventId ||
         imetaTags.length > 0 ||
         emojiTags.length > 0 ||
diff --git a/desktop/src/features/messages/lib/agentMentionRevalidation.test.mjs b/desktop/src/features/messages/lib/agentMentionRevalidation.test.mjs
new file mode 100644
index 00000000000..077c5c8fad5
--- /dev/null
+++ b/desktop/src/features/messages/lib/agentMentionRevalidation.test.mjs
@@ -0,0 +1,177 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { revalidateAgentMentionPubkeys } from "./agentMentionRevalidation.ts";
+
+const CURRENT = "a".repeat(64);
+const AGENT = "b".repeat(64);
+const HUMAN = "c".repeat(64);
+const OTHER_OWNER = "d".repeat(64);
+
+function options(refetchOwnerProfiles) {
+  return {
+    pubkeys: [HUMAN, AGENT],
+    agentPubkeys: new Set([AGENT]),
+    refetchMembers: async () => ({ data: [], error: null }),
+    activeCommunityRelayUrl: null,
+    currentPubkey: CURRENT,
+    eligibilityScope: { type: "channel", channelId: "general" },
+    sharedChannelIds: new Set(["general"]),
+    ownerOnly: true,
+    ownerPolicyError: null,
+    refetchManagedAgents: async () => ({ data: [], error: null }),
+    refetchRelayAgents: async () => ({
+      data: [
+        {
+          pubkey: AGENT,
+          respondTo: "anyone",
+          respondToAllowlist: [],
+          channelIds: ["general"],
+        },
+      ],
+      error: null,
+    }),
+    refetchOwnerProfiles,
+  };
+}
+
+test("revalidation preserves member admission for a member agent with no directory record", async () => {
+  const result = await revalidateAgentMentionPubkeys({
+    pubkeys: [HUMAN, AGENT],
+    agentPubkeys: new Set([AGENT]),
+    refetchMembers: async () => ({ data: [{ pubkey: AGENT }], error: null }),
+    activeCommunityRelayUrl: null,
+    currentPubkey: CURRENT,
+    eligibilityScope: { type: "channel", channelId: "general" },
+    sharedChannelIds: new Set(["general"]),
+    ownerOnly: false,
+    ownerPolicyError: null,
+    refetchManagedAgents: async () => ({ data: [], error: null }),
+    // No relay directory entry for AGENT — mirrors the picker's admitted
+    // member-agent case (getAdmittedMemberAgentPubkeys), which revalidation
+    // must not silently strip.
+    refetchRelayAgents: async () => ({ data: [], error: null }),
+    refetchOwnerProfiles: async () => ({ profiles: {}, missing: [] }),
+  });
+
+  assert.deepEqual(result, [HUMAN, AGENT]);
+});
+
+test("revalidation denies a member agent removed from the channel since the picker loaded", async () => {
+  const result = await revalidateAgentMentionPubkeys({
+    pubkeys: [HUMAN, AGENT],
+    agentPubkeys: new Set([AGENT]),
+    // Stale picker state may still think AGENT is a member; the fresh
+    // roster fetched at send time no longer contains it.
+    refetchMembers: async () => ({ data: [], error: null }),
+    activeCommunityRelayUrl: null,
+    currentPubkey: CURRENT,
+    eligibilityScope: { type: "channel", channelId: "general" },
+    sharedChannelIds: new Set(["general"]),
+    ownerOnly: false,
+    ownerPolicyError: null,
+    refetchManagedAgents: async () => ({ data: [], error: null }),
+    refetchRelayAgents: async () => ({ data: [], error: null }),
+    refetchOwnerProfiles: async () => ({ profiles: {}, missing: [] }),
+  });
+
+  assert.deepEqual(result, [HUMAN]);
+});
+
+test("revalidation fails closed when the channel roster cannot be refreshed", async () => {
+  const result = await revalidateAgentMentionPubkeys({
+    pubkeys: [HUMAN, AGENT],
+    agentPubkeys: new Set([AGENT]),
+    refetchMembers: async () => ({
+      data: undefined,
+      error: new Error("relay unavailable"),
+    }),
+    activeCommunityRelayUrl: null,
+    currentPubkey: CURRENT,
+    eligibilityScope: { type: "channel", channelId: "general" },
+    sharedChannelIds: new Set(["general"]),
+    ownerOnly: false,
+    ownerPolicyError: null,
+    refetchManagedAgents: async () => ({ data: [], error: null }),
+    refetchRelayAgents: async () => ({
+      data: [
+        {
+          pubkey: AGENT,
+          respondTo: "anyone",
+          respondToAllowlist: [],
+          channelIds: ["general"],
+        },
+      ],
+      error: null,
+    }),
+    refetchOwnerProfiles: async () => ({ profiles: {}, missing: [] }),
+  });
+
+  assert.deepEqual(result, [HUMAN]);
+});
+
+test("revalidation admits a managed agent when no channel exists yet (managed-only scope)", async () => {
+  // Mirrors NewMessageScreen: MessageComposer runs with channelId=null before
+  // onPrepareSendChannel creates the DM, so there is no roster to fetch.
+  const result = await revalidateAgentMentionPubkeys({
+    pubkeys: [HUMAN, AGENT],
+    agentPubkeys: new Set([AGENT]),
+    refetchMembers: async () => {
+      throw new Error("must not be called for a managed-only scope");
+    },
+    activeCommunityRelayUrl: null,
+    currentPubkey: CURRENT,
+    eligibilityScope: { type: "managed-only" },
+    sharedChannelIds: new Set(),
+    ownerOnly: false,
+    ownerPolicyError: null,
+    refetchManagedAgents: async () => ({
+      data: [{ pubkey: AGENT, communityRelayUrl: null }],
+      error: null,
+    }),
+    refetchRelayAgents: async () => ({ data: [], error: null }),
+    refetchOwnerProfiles: async () => ({ profiles: {}, missing: [] }),
+  });
+
+  assert.deepEqual(result, [HUMAN, AGENT]);
+});
+
+test("owner-only revalidation admits an agent only from a fresh same-owner proof", async () => {
+  const requested = [];
+  const result = await revalidateAgentMentionPubkeys(
+    options(async (pubkeys) => {
+      requested.push(...pubkeys);
+      return {
+        profiles: { [AGENT]: { ownerPubkey: CURRENT } },
+        missing: [],
+      };
+    }),
+  );
+
+  assert.deepEqual(requested, [AGENT]);
+  assert.deepEqual(result, [HUMAN, AGENT]);
+});
+
+for (const [name, refetchOwnerProfiles] of [
+  ["revoked owner proof", async () => ({ profiles: {}, missing: [AGENT] })],
+  [
+    "changed owner proof",
+    async () => ({
+      profiles: { [AGENT]: { ownerPubkey: OTHER_OWNER } },
+      missing: [],
+    }),
+  ],
+  [
+    "owner profile query error",
+    async () => {
+      throw new Error("relay unavailable");
+    },
+  ],
+]) {
+  test(`owner-only revalidation fails closed on ${name}`, async () => {
+    assert.deepEqual(
+      await revalidateAgentMentionPubkeys(options(refetchOwnerProfiles)),
+      [HUMAN],
+    );
+  });
+}
diff --git a/desktop/src/features/messages/lib/agentMentionRevalidation.ts b/desktop/src/features/messages/lib/agentMentionRevalidation.ts
new file mode 100644
index 00000000000..ad1d8b8a07f
--- /dev/null
+++ b/desktop/src/features/messages/lib/agentMentionRevalidation.ts
@@ -0,0 +1,191 @@
+import {
+  filterAdmittedMentionPubkeys,
+  getAgentMentionAdmission,
+  getMentionableAgentPubkeys,
+  type AgentEligibilityScope,
+} from "@/features/agents/lib/agentAutocompleteEligibility";
+import { evictUsersBatchEntries } from "@/features/profile/hooks";
+import { getUsersBatch } from "@/shared/api/tauriProfiles";
+import type {
+  ChannelMember,
+  ManagedAgent,
+  RelayAgent,
+  UsersBatchResponse,
+} from "@/shared/api/types";
+import { normalizePubkey } from "@/shared/lib/pubkey";
+import { useQueryClient } from "@tanstack/react-query";
+import * as React from "react";
+
+type DirectoryResult<T> = {
+  data: T | undefined;
+  error: Error | null;
+};
+
+export async function revalidateAgentMentionPubkeys({
+  pubkeys,
+  agentPubkeys,
+  refetchMembers,
+  activeCommunityRelayUrl,
+  currentPubkey,
+  eligibilityScope,
+  sharedChannelIds,
+  ownerOnly,
+  ownerPolicyError,
+  refetchManagedAgents,
+  refetchRelayAgents,
+  refetchOwnerProfiles,
+}: {
+  pubkeys: readonly string[];
+  agentPubkeys: ReadonlySet<string>;
+  refetchMembers: () => Promise<DirectoryResult<ChannelMember[]>>;
+  activeCommunityRelayUrl: string | null;
+  currentPubkey: string | null;
+  eligibilityScope: AgentEligibilityScope;
+  sharedChannelIds: ReadonlySet<string>;
+  ownerOnly: boolean | undefined;
+  ownerPolicyError: Error | null;
+  refetchManagedAgents: () => Promise<DirectoryResult<ManagedAgent[]>>;
+  refetchRelayAgents: () => Promise<DirectoryResult<RelayAgent[]>>;
+  refetchOwnerProfiles: (pubkeys: string[]) => Promise<UsersBatchResponse>;
+}) {
+  const requestedAgentPubkeys = new Set(
+    pubkeys.map(normalizePubkey).filter((pubkey) => agentPubkeys.has(pubkey)),
+  );
+  if (requestedAgentPubkeys.size === 0) {
+    return [...pubkeys];
+  }
+
+  // Roster proof only matters to the lenient channel-member admission
+  // branch. A "managed-only"/"community" scope (e.g. a new-DM composer with
+  // no channel yet) has no roster to fetch — requiring one would fail-close
+  // a valid managed-agent mention before the channel even exists.
+  const [managedResult, relayResult, membersResult, ownerProfiles] =
+    await Promise.all([
+      refetchManagedAgents(),
+      refetchRelayAgents(),
+      eligibilityScope.type === "channel"
+        ? refetchMembers()
+        : Promise.resolve<DirectoryResult<ChannelMember[]>>({
+            data: [],
+            error: null,
+          }),
+      ownerOnly
+        ? refetchOwnerProfiles([...requestedAgentPubkeys]).catch(() => null)
+        : Promise.resolve(null),
+    ]);
+  if (
+    managedResult.error !== null ||
+    relayResult.error !== null ||
+    membersResult.error !== null ||
+    managedResult.data === undefined ||
+    relayResult.data === undefined ||
+    membersResult.data === undefined ||
+    ownerOnly === undefined ||
+    ownerPolicyError !== null ||
+    (ownerOnly && ownerProfiles === null)
+  ) {
+    return filterAdmittedMentionPubkeys(pubkeys, agentPubkeys, new Set());
+  }
+
+  const managedPubkeys = new Set(
+    managedResult.data.map((agent) => normalizePubkey(agent.pubkey)),
+  );
+  const directoryAgentPubkeys = new Set(
+    relayResult.data.map((agent) => normalizePubkey(agent.pubkey)),
+  );
+  const memberPubkeys = new Set(
+    membersResult.data.map((member) => normalizePubkey(member.pubkey)),
+  );
+  const mentionablePubkeys = getMentionableAgentPubkeys({
+    activeCommunityRelayUrl,
+    currentPubkey,
+    eligibilityScope,
+    managedAgents: managedResult.data,
+    relayAgents: relayResult.data,
+    sharedChannelIds,
+  });
+  const admittedPubkeys = new Set(
+    [...agentPubkeys].filter(
+      (pubkey) =>
+        getAgentMentionAdmission({
+          isAgent: true,
+          isManagedAgent: managedPubkeys.has(pubkey),
+          isMember: memberPubkeys.has(pubkey),
+          pubkey,
+          ownerPubkey: ownerProfiles?.profiles[pubkey]?.ownerPubkey,
+          currentPubkey,
+          mentionableAgentPubkeys: mentionablePubkeys,
+          directoryAgentPubkeys,
+          directoryReady: true,
+          ownerOnly,
+        }) === "allow",
+    ),
+  );
+  return filterAdmittedMentionPubkeys(pubkeys, agentPubkeys, admittedPubkeys);
+}
+
+export function useAgentMentionRevalidation({
+  agentPubkeys,
+  refetchMembers,
+  getSelectedAgentPubkeys,
+  activeCommunityRelayUrl,
+  currentPubkey,
+  eligibilityScope,
+  sharedChannelIds,
+  ownerOnly,
+  ownerPolicyError,
+  refetchManagedAgents,
+  refetchRelayAgents,
+}: {
+  agentPubkeys: ReadonlySet<string>;
+  refetchMembers: () => Promise<DirectoryResult<ChannelMember[]>>;
+  getSelectedAgentPubkeys: () => ReadonlySet<string>;
+  activeCommunityRelayUrl: string | null;
+  currentPubkey: string | null;
+  eligibilityScope: AgentEligibilityScope;
+  sharedChannelIds: ReadonlySet<string>;
+  ownerOnly: boolean | undefined;
+  ownerPolicyError: Error | null;
+  refetchManagedAgents: () => Promise<DirectoryResult<ManagedAgent[]>>;
+  refetchRelayAgents: () => Promise<DirectoryResult<RelayAgent[]>>;
+}) {
+  const queryClient = useQueryClient();
+  const refetchOwnerProfiles = React.useCallback(
+    async (pubkeys: string[]) => {
+      evictUsersBatchEntries(queryClient, pubkeys);
+      return getUsersBatch(pubkeys);
+    },
+    [queryClient],
+  );
+  return React.useCallback(
+    (pubkeys: readonly string[]) =>
+      revalidateAgentMentionPubkeys({
+        pubkeys,
+        agentPubkeys: new Set([...agentPubkeys, ...getSelectedAgentPubkeys()]),
+        refetchMembers,
+        activeCommunityRelayUrl,
+        currentPubkey,
+        eligibilityScope,
+        sharedChannelIds,
+        ownerOnly,
+        ownerPolicyError,
+        refetchManagedAgents,
+        refetchRelayAgents,
+        refetchOwnerProfiles,
+      }),
+    [
+      activeCommunityRelayUrl,
+      agentPubkeys,
+      currentPubkey,
+      eligibilityScope,
+      getSelectedAgentPubkeys,
+      refetchMembers,
+      ownerOnly,
+      ownerPolicyError,
+      refetchManagedAgents,
+      refetchOwnerProfiles,
+      refetchRelayAgents,
+      sharedChannelIds,
+    ],
+  );
+}
diff --git a/desktop/src/features/messages/lib/mentionCandidates.ts b/desktop/src/features/messages/lib/mentionCandidates.ts
index 0498bef9ae4..3ad358a0d66 100644
--- a/desktop/src/features/messages/lib/mentionCandidates.ts
+++ b/desktop/src/features/messages/lib/mentionCandidates.ts
@@ -1,7 +1,30 @@
 import { resolveTeamPersonas } from "@/features/agents/lib/teamPersonas";
-import type { AgentPersona, AgentTeam, ChannelRole } from "@/shared/api/types";
+import type {
+  AgentPersona,
+  AgentTeam,
+  ChannelRole,
+  UserSearchResult,
+} from "@/shared/api/types";
 import { truncatePubkey } from "@/shared/lib/pubkey";
 
+export function formatSearchUserDisplayName(user: UserSearchResult) {
+  return user.displayName?.trim() || user.nip05Handle?.trim() || null;
+}
+
+export function formatSearchUserSecondaryLabel(user: UserSearchResult) {
+  const displayName = user.displayName?.trim();
+  const nip05Handle = user.nip05Handle?.trim();
+  return displayName && nip05Handle ? nip05Handle : null;
+}
+
+export function appendUniqueName(current: string[], name: string): string[] {
+  return current.some(
+    (candidate) => candidate.toLowerCase() === name.toLowerCase(),
+  )
+    ? current
+    : [...current, name];
+}
+
 export type TeamMentionMember = {
   displayName: string;
   kind: "identity" | "persona";
diff --git a/desktop/src/features/messages/lib/useMentionAgentPubkeys.ts b/desktop/src/features/messages/lib/useMentionAgentPubkeys.ts
index 614e65fa5bf..24ebaa6a0eb 100644
--- a/desktop/src/features/messages/lib/useMentionAgentPubkeys.ts
+++ b/desktop/src/features/messages/lib/useMentionAgentPubkeys.ts
@@ -25,7 +25,6 @@ import { normalizePubkey } from "@/shared/lib/pubkey";
 export function useMentionAgentPubkeys({
   activeCommunityRelayUrl,
   currentPubkey,
-  directoryAgentPubkeys,
   isArchived,
   managedAgentNamesByPubkey,
   managedAgents,
@@ -38,7 +37,6 @@ export function useMentionAgentPubkeys({
 }: {
   activeCommunityRelayUrl: string | null;
   currentPubkey: string | null;
-  directoryAgentPubkeys: ReadonlySet<string>;
   isArchived: (pubkey: string) => boolean;
   managedAgentNamesByPubkey: ReadonlyMap<string, string>;
   managedAgents: readonly ManagedAgentScopeInput[] | undefined;
@@ -51,6 +49,7 @@ export function useMentionAgentPubkeys({
 }): {
   mentionableAgentPubkeys: ReadonlySet<string>;
   memberAgentPubkeys: ReadonlySet<string>;
+  directoryAgentPubkeys: ReadonlySet<string>;
   knownAgentPubkeys: ReadonlySet<string>;
 } {
   const mentionableAgentPubkeys = React.useMemo(
@@ -75,6 +74,14 @@ export function useMentionAgentPubkeys({
     ],
   );
 
+  const directoryAgentPubkeys = React.useMemo(
+    () =>
+      new Set(
+        (relayAgents ?? []).map((agent) => normalizePubkey(agent.pubkey)),
+      ),
+    [relayAgents],
+  );
+
   const memberAgentPubkeys = React.useMemo(() => {
     const pubkeys = new Set<string>();
     for (const member of members ?? []) {
@@ -113,5 +120,10 @@ export function useMentionAgentPubkeys({
     mentionableAgentPubkeys,
   ]);
 
-  return { mentionableAgentPubkeys, memberAgentPubkeys, knownAgentPubkeys };
+  return {
+    mentionableAgentPubkeys,
+    memberAgentPubkeys,
+    directoryAgentPubkeys,
+    knownAgentPubkeys,
+  };
 }
diff --git a/desktop/src/features/messages/lib/useMentions.ts b/desktop/src/features/messages/lib/useMentions.ts
index b398be96baa..0b2d28cbd3a 100644
--- a/desktop/src/features/messages/lib/useMentions.ts
+++ b/desktop/src/features/messages/lib/useMentions.ts
@@ -5,6 +5,7 @@ import {
   useRelayAgentsQuery,
   useTeamsQuery,
 } from "@/features/agents/hooks";
+import { useAgentAccessOwnerOnlyQuery } from "@/features/agents/useAgentAccessOwnerOnly";
 import {
   useChannelMembersQuery,
   useChannelsQuery,
@@ -14,9 +15,13 @@ import type { MentionSuggestion } from "@/features/messages/ui/MentionAutocomple
 import {
   coalesceAgentAutocompleteCandidates,
   coalesceAutocompleteCandidatesByKey,
+  filterAdmittedMentionPubkeys,
   filterCachedAgentSuggestions,
+  getAdmittedAgentPubkeys,
+  getAgentIdentityPubkeys,
   getSharedChannelIds,
   isAgentMentionChannelType,
+  rememberSelectedAgentPubkeys,
   shouldHideAgentFromMentions,
   uniqueAutocompleteLabels,
 } from "@/features/agents/lib/agentAutocompleteEligibility";
@@ -31,7 +36,6 @@ import type {
   AgentPersona,
   ChannelMember,
   ChannelType,
-  UserSearchResult,
 } from "@/shared/api/types";
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { detectPrefixQuery } from "@/shared/lib/detectPrefixQuery";
@@ -39,6 +43,7 @@ import { normalizePubkey } from "@/shared/lib/pubkey";
 import { trimMapToSize } from "@/shared/lib/trimMapToSize";
 import { flushMentionDebounce } from "./flushMentionDebounce";
 import { useManagedAgentMentionMaps } from "./managedAgentMentionMaps";
+import { useAgentMentionRevalidation } from "./agentMentionRevalidation";
 import { hasMention } from "./hasMention";
 import { extractMentionPubkeys } from "./extractMentionPubkeys";
 import { useDraftMentionRouting } from "./useDraftMentionRouting";
@@ -46,7 +51,10 @@ import { useMentionAgentPubkeys } from "./useMentionAgentPubkeys";
 import { rankMentionCandidates } from "./mentionRanking";
 import { mapMentionCandidateToSuggestion } from "./mentionSuggestionMapping";
 import {
+  appendUniqueName,
   buildTeamMentionCandidates,
+  formatSearchUserDisplayName,
+  formatSearchUserSecondaryLabel,
   formatTeamMention,
   globalSearchIdentityKey,
   type MentionCandidate,
@@ -61,25 +69,6 @@ export type PersonaMentionTarget = {
 type UseMentionsOptions = {
   channelType?: ChannelType | null;
 };
-function formatSearchUserDisplayName(user: UserSearchResult) {
-  return user.displayName?.trim() || user.nip05Handle?.trim() || null;
-}
-function formatSearchUserSecondaryLabel(user: UserSearchResult) {
-  const displayName = user.displayName?.trim();
-  const nip05Handle = user.nip05Handle?.trim();
-  if (displayName && nip05Handle) {
-    return nip05Handle;
-  }
-  return null;
-}
-function appendUniqueName(current: string[], name: string): string[] {
-  return current.some(
-    (candidate) => candidate.toLowerCase() === name.toLowerCase(),
-  )
-    ? current
-    : [...current, name];
-}
-
 export function useMentions(
   channelId: string | null,
   externalMembers?: ChannelMember[],
@@ -95,6 +84,7 @@ export function useMentions(
   const [selectedAgentMentionNames, setSelectedAgentMentionNames] =
     React.useState<string[]>([]);
   const selectedAgentMentionNamesRef = React.useRef<string[]>([]);
+  const selectedAgentMentionPubkeysRef = React.useRef<Set<string>>(new Set());
   selectedAgentMentionNamesRef.current = selectedAgentMentionNames;
   const mentionMapRef = React.useRef<Map<string, string>>(new Map());
   const personaMentionMapRef = React.useRef<Map<string, string>>(new Map());
@@ -114,18 +104,22 @@ export function useMentions(
   const personasQuery = usePersonasQuery();
   const teamsQuery = useTeamsQuery();
   const activeCommunityRelayUrl = useActiveCommunityRelayUrl();
+  const agentAccessOwnerOnlyQuery = useAgentAccessOwnerOnlyQuery();
   const managedAgentDirectoryReady =
-    managedAgentsQuery.data !== undefined ||
-    !managedAgentsQuery.isLoading ||
-    managedAgentsQuery.error !== null;
+    managedAgentsQuery.data !== undefined &&
+    managedAgentsQuery.error === null &&
+    !managedAgentsQuery.isFetching;
   const relayAgentDirectoryReady =
-    relayAgentsQuery.data !== undefined ||
-    !relayAgentsQuery.isLoading ||
-    relayAgentsQuery.error !== null;
-  const canSearchGlobalUsers =
-    canSearchGlobalPeople &&
-    managedAgentDirectoryReady &&
-    relayAgentDirectoryReady;
+    relayAgentsQuery.data !== undefined &&
+    relayAgentsQuery.error === null &&
+    !relayAgentsQuery.isFetching;
+  const ownerPolicyReady =
+    agentAccessOwnerOnlyQuery.data !== undefined &&
+    agentAccessOwnerOnlyQuery.error === null &&
+    !agentAccessOwnerOnlyQuery.isFetching;
+  const agentDirectoriesReady =
+    managedAgentDirectoryReady && relayAgentDirectoryReady && ownerPolicyReady;
+  const canSearchGlobalUsers = canSearchGlobalPeople && agentDirectoriesReady;
   const userSearchQuery = useInfiniteUserSearchQuery(mentionQuery ?? "", {
     allowEmpty: true,
     enabled: canSearchGlobalUsers && mentionQuery !== null,
@@ -152,15 +146,6 @@ export function useMentions(
       ),
     [relayAgentsQuery.data],
   );
-  const directoryAgentPubkeys = React.useMemo(
-    () =>
-      new Set(
-        (relayAgentsQuery.data ?? []).map((agent) =>
-          normalizePubkey(agent.pubkey),
-        ),
-      ),
-    [relayAgentsQuery.data],
-  );
   const sharedChannelIds = React.useMemo(
     () => getSharedChannelIds(channelsQuery.data),
     [channelsQuery.data],
@@ -181,21 +166,31 @@ export function useMentions(
     }
     return lookup;
   }, [managedAgentsQuery.data, personasQuery.data]);
-  const { mentionableAgentPubkeys, memberAgentPubkeys, knownAgentPubkeys } =
-    useMentionAgentPubkeys({
-      activeCommunityRelayUrl,
-      currentPubkey,
-      directoryAgentPubkeys,
-      isArchived: isArchivedDiscovery,
-      managedAgentNamesByPubkey,
-      managedAgents: managedAgentsQuery.data,
-      members,
-      mentionChannelId,
-      profiles,
-      relayAgents: relayAgentsQuery.data,
-      relayAgentNamesByPubkey,
-      sharedChannelIds,
-    });
+  const {
+    mentionableAgentPubkeys,
+    memberAgentPubkeys,
+    directoryAgentPubkeys,
+    knownAgentPubkeys: admittedKnownAgentPubkeys,
+  } = useMentionAgentPubkeys({
+    activeCommunityRelayUrl,
+    currentPubkey,
+    isArchived: isArchivedDiscovery,
+    managedAgentNamesByPubkey,
+    managedAgents: managedAgentsQuery.data,
+    members,
+    mentionChannelId,
+    profiles,
+    relayAgents: relayAgentsQuery.data,
+    relayAgentNamesByPubkey,
+    sharedChannelIds,
+  });
+  // Every managed agent counts as "known" for send-path classification even
+  // when it falls outside the current community scope (still the user's own
+  // agent) — mentionableAgentPubkeys alone would drop it.
+  const knownAgentPubkeys = React.useMemo(
+    () => new Set([...admittedKnownAgentPubkeys, ...managedAgentPubkeys]),
+    [admittedKnownAgentPubkeys, managedAgentPubkeys],
+  );
   const activePersonas = React.useMemo(
     () => (personasQuery.data ?? []).filter((persona) => persona.isActive),
     [personasQuery.data],
@@ -213,9 +208,18 @@ export function useMentions(
       new Set((members ?? []).map((member) => normalizePubkey(member.pubkey))),
     [members],
   );
+  const agentIdentityPubkeys = React.useMemo(
+    () =>
+      getAgentIdentityPubkeys({
+        managedAgentPubkeys,
+        relayAgents: relayAgentsQuery.data ?? [],
+        members: members ?? [],
+        profileIsAgent: (pubkey) => profiles?.[pubkey]?.isAgent === true,
+      }),
+    [managedAgentPubkeys, members, profiles, relayAgentsQuery.data],
+  );
   const mentionCandidates = React.useMemo<MentionCandidate[]>(() => {
     const candidatesByPubkey = new Map<string, MentionCandidate>();
-
     const addCandidate = (candidate: MentionCandidate & { pubkey: string }) => {
       const pubkey = normalizePubkey(candidate.pubkey);
       if (isArchivedDiscovery(pubkey)) {
@@ -228,10 +232,18 @@ export function useMentions(
       if (
         shouldHideAgentFromMentions({
           isAgent: candidate.isAgent === true,
+          isManagedAgent: candidate.isManagedAgent === true,
           isMember: candidate.isMember === true,
           pubkey,
+          ownerPubkey: candidate.ownerPubkey,
+          currentPubkey,
           mentionableAgentPubkeys,
           directoryAgentPubkeys,
+          directoryReady:
+            candidate.isManagedAgent === true
+              ? managedAgentDirectoryReady
+              : relayAgentDirectoryReady,
+          ownerOnly: agentAccessOwnerOnlyQuery.data,
         })
       ) {
         return;
@@ -241,7 +253,6 @@ export function useMentions(
         candidatesByPubkey.set(pubkey, { ...candidate, pubkey });
         return;
       }
-
       candidatesByPubkey.set(pubkey, {
         ...current,
         avatarUrl: current.avatarUrl ?? candidate.avatarUrl ?? null,
@@ -301,7 +312,6 @@ export function useMentions(
             : null,
       });
     }
-
     for (const agent of relayAgentsQuery.data ?? []) {
       const pubkey = normalizePubkey(agent.pubkey);
       addCandidate({
@@ -316,7 +326,6 @@ export function useMentions(
         isAgent: true,
       });
     }
-
     for (const agent of managedAgentsQuery.data ?? []) {
       addCandidate({
         kind: "identity",
@@ -331,7 +340,6 @@ export function useMentions(
         ownerPubkey: currentPubkey,
       });
     }
-
     if (canSearchGlobalUsers) {
       for (const user of userSearchResults) {
         const pubkey = normalizePubkey(user.pubkey);
@@ -356,7 +364,6 @@ export function useMentions(
         });
       }
     }
-
     const personaCandidates: MentionCandidate[] = activePersonas
       .filter((persona) => !managedAgentPersonaIds.has(persona.id))
       .map((persona) => ({
@@ -368,7 +375,6 @@ export function useMentions(
         isAgent: true,
       }))
       .filter((candidate) => candidate.displayName.trim().length > 0);
-
     return coalesceAgentAutocompleteCandidates(
       coalesceAutocompleteCandidatesByKey(
         [...candidatesByPubkey.values(), ...personaCandidates],
@@ -383,11 +389,13 @@ export function useMentions(
   }, [
     activePersonaById,
     activePersonas,
+    agentAccessOwnerOnlyQuery.data,
     userSearchResults,
     canSearchGlobalUsers,
     currentPubkey,
     directoryAgentPubkeys,
     isArchivedDiscovery,
+    managedAgentDirectoryReady,
     managedAgentNamesByPubkey,
     managedAgentPersonaIds,
     managedAgentPersonaIdsByPubkey,
@@ -398,10 +406,14 @@ export function useMentions(
     mentionableAgentPubkeys,
     personaNameByPubkey,
     profiles,
+    relayAgentDirectoryReady,
     relayAgentNamesByPubkey,
     relayAgentsQuery.data,
   ]);
-
+  const admittedAgentPubkeys = React.useMemo(
+    () => getAdmittedAgentPubkeys(mentionCandidates),
+    [mentionCandidates],
+  );
   const mentionCandidatesWithTeams = React.useMemo(
     () => [
       ...mentionCandidates,
@@ -413,7 +425,6 @@ export function useMentions(
     ],
     [mentionCandidates, personasQuery.data, teamsQuery.data],
   );
-
   const ownerPubkeys = React.useMemo(
     () => [
       ...new Set(
@@ -427,7 +438,6 @@ export function useMentions(
   const ownerProfilesQuery = useUsersBatchQuery(ownerPubkeys, {
     enabled: ownerPubkeys.length > 0,
   });
-
   const searchableNames = React.useMemo(
     () => uniqueAutocompleteLabels(mentionCandidatesWithTeams),
     [mentionCandidatesWithTeams],
@@ -612,6 +622,11 @@ export function useMentions(
         (suggestion.pubkey
           ? knownAgentPubkeys.has(normalizePubkey(suggestion.pubkey))
           : false);
+      rememberSelectedAgentPubkeys(
+        selectedAgentMentionPubkeysRef.current,
+        selectedMentions,
+        isAgentMention,
+      );
       if (isAgentMention) {
         setSelectedAgentMentionNames((current) => {
           const known = new Set(current.map((name) => name.toLowerCase()));
@@ -755,15 +770,42 @@ export function useMentions(
   );
 
   const extractMentionPubkeysForCurrentMentions = React.useCallback(
-    (text: string): string[] =>
-      extractMentionPubkeys({
+    (text: string): string[] => {
+      const extracted = extractMentionPubkeys({
         text,
         selectedMentions: mentionMapRef.current,
         selectedDisplayNames: personaMentionMapRef.current.keys(),
         memberCandidates: mentionCandidates,
-      }),
-    [mentionCandidates],
+      });
+      return filterAdmittedMentionPubkeys(
+        extracted,
+        new Set([
+          ...agentIdentityPubkeys,
+          ...selectedAgentMentionPubkeysRef.current,
+        ]),
+        admittedAgentPubkeys,
+      );
+    },
+    [admittedAgentPubkeys, agentIdentityPubkeys, mentionCandidates],
   );
+  const getSelectedAgentPubkeys = React.useRef(
+    () => selectedAgentMentionPubkeysRef.current,
+  ).current;
+  const revalidateMentionPubkeys = useAgentMentionRevalidation({
+    agentPubkeys: agentIdentityPubkeys,
+    refetchMembers: membersQuery.refetch,
+    getSelectedAgentPubkeys,
+    activeCommunityRelayUrl,
+    currentPubkey,
+    eligibilityScope: mentionChannelId
+      ? { type: "channel", channelId: mentionChannelId }
+      : { type: "managed-only" },
+    sharedChannelIds,
+    ownerOnly: agentAccessOwnerOnlyQuery.data,
+    ownerPolicyError: agentAccessOwnerOnlyQuery.error,
+    refetchManagedAgents: managedAgentsQuery.refetch,
+    refetchRelayAgents: relayAgentsQuery.refetch,
+  });
 
   const extractMentionPersonas = React.useCallback(
     (text: string): PersonaMentionTarget[] => {
@@ -799,12 +841,12 @@ export function useMentions(
     setMentionQuery(null);
     setMentionSelectedIndex(0);
   }, []);
-
   const clearMentions = React.useCallback(() => {
     cancelMentionAutocomplete();
     mentionMapRef.current.clear();
     personaMentionMapRef.current.clear();
     selectedAgentMentionNamesRef.current = [];
+    selectedAgentMentionPubkeysRef.current.clear();
     setSelectedMentionNames([]);
     setSelectedAgentMentionNames([]);
   }, [cancelMentionAutocomplete]);
@@ -907,6 +949,7 @@ export function useMentions(
     clearMentions,
     extractMentionPersonas,
     extractMentionPubkeys: extractMentionPubkeysForCurrentMentions,
+    revalidateMentionPubkeys,
     getDraftMentionRefs,
     getMentionDisplayName,
     handleMentionKeyDown,
diff --git a/desktop/src/features/messages/ui/MessageComposer.tsx b/desktop/src/features/messages/ui/MessageComposer.tsx
index 9d61e9c3657..d13cec95eba 100644
--- a/desktop/src/features/messages/ui/MessageComposer.tsx
+++ b/desktop/src/features/messages/ui/MessageComposer.tsx
@@ -516,9 +516,7 @@ function MessageComposerImpl({
     // Edit mode
     if (editTargetRef.current && onEditSaveRef.current) {
       if (isEditSubmissionLocked) return;
-      // No empty-edit guard here: clearing an edit to empty (no text, no
-      // attachments) flows through to onEditSave as empty content, which
-      // deletes the message instead of publishing it (see handleEditSave).
+      // Empty edits delete the message through handleEditSave.
       await submitMessageEdit({
         content: trimmed,
         editTargetId: editTargetRef.current.id,
@@ -551,6 +549,7 @@ function MessageComposerImpl({
           setSpoileredAttachmentUrls(draft.spoileredAttachmentUrls);
         },
         restoreMentionRefs: mentions.restoreDraftMentionRefs,
+        revalidateMentionPubkeys: mentions.revalidateMentionPubkeys,
         shouldRestoreComposer: () => canRestoreEditDraftRef.current,
         setDeferredUploadPending: setDeferredEditPending,
         setUploadError: (message) =>
@@ -638,6 +637,7 @@ function MessageComposerImpl({
     effectiveDraftKey,
     mentions.getDraftMentionRefs,
     mentions.restoreDraftMentionRefs,
+    mentions.revalidateMentionPubkeys,
   ]);
   submitMessageRef.current = submitMessage;
   // ── Auto-submit on draft send ────────────────────────────────────────────
diff --git a/desktop/src/features/messages/ui/NewMessageScreen.tsx b/desktop/src/features/messages/ui/NewMessageScreen.tsx
index f94dd5d1e1f..f7192f6e45c 100644
--- a/desktop/src/features/messages/ui/NewMessageScreen.tsx
+++ b/desktop/src/features/messages/ui/NewMessageScreen.tsx
@@ -263,6 +263,11 @@ export function NewMessageScreen() {
           content,
           mentionPubkeys,
           mediaTags,
+          // A newly opened DM is not subscribed yet, so publish its first
+          // message through the acknowledged HTTP path. This avoids holding
+          // the entire navigation on a WebSocket OK frame that staging may
+          // never deliver.
+          transport: "http",
         });
       } catch (error) {
         preparedDirectMessageRef.current = null;
diff --git a/desktop/src/features/messages/ui/submitMessageEdit.test.mjs b/desktop/src/features/messages/ui/submitMessageEdit.test.mjs
index 126dfd13fcd..9e6cb957fda 100644
--- a/desktop/src/features/messages/ui/submitMessageEdit.test.mjs
+++ b/desktop/src/features/messages/ui/submitMessageEdit.test.mjs
@@ -29,6 +29,7 @@ function baseOptions(
     queuedAttachments: [],
     restoreComposer: () => {},
     restoreMentionRefs: () => {},
+    revalidateMentionPubkeys: async (pubkeys) => [...pubkeys],
     setDeferredUploadPending: () => {},
     setUploadError: () => {},
     shouldRestoreComposer: () => true,
@@ -81,3 +82,63 @@ test("edit save uses edit-target refs that resolve after edit-open", async () =>
     eventId: "event-id",
   });
 });
+
+test("edit save revalidates added mentions immediately before save", async () => {
+  const agent = "c".repeat(64);
+  const calls = [];
+  await submitMessageEdit({
+    ...baseOptions(async (_content, _tags, mentionPubkeys) => {
+      calls.push(["save", mentionPubkeys]);
+    }),
+    content: "hello @Agent",
+    originalContent: "hello",
+    extractMentionPubkeys: (content) =>
+      content.includes("@Agent") ? [agent] : [],
+    revalidateMentionPubkeys: async (pubkeys) => {
+      calls.push(["revalidate", pubkeys]);
+      return [];
+    },
+  });
+
+  assert.deepEqual(calls, [
+    ["revalidate", [agent]],
+    ["save", []],
+  ]);
+});
+
+test("edit upload pause revalidates revoked mentions only after upload completes", async () => {
+  const agent = "d".repeat(64);
+  const calls = [];
+  let completeUpload;
+  await submitMessageEdit({
+    ...baseOptions(async (_content, _tags, mentionPubkeys) => {
+      calls.push(["save", mentionPubkeys]);
+    }),
+    content: "hello @Agent",
+    originalContent: "hello",
+    extractMentionPubkeys: (content) =>
+      content.includes("@Agent") ? [agent] : [],
+    queuedAttachments: [
+      {
+        file: new File(["image"], "image.png", { type: "image/png" }),
+        id: 1,
+        spoilered: false,
+      },
+    ],
+    enqueueUpload: ({ onComplete }) => {
+      completeUpload = () => onComplete([], new AbortController().signal);
+      return {};
+    },
+    revalidateMentionPubkeys: async (pubkeys) => {
+      calls.push(["revalidate", pubkeys]);
+      return [];
+    },
+  });
+
+  assert.deepEqual(calls, []);
+  await completeUpload();
+  assert.deepEqual(calls, [
+    ["revalidate", [agent]],
+    ["save", []],
+  ]);
+});
diff --git a/desktop/src/features/messages/ui/submitMessageEdit.ts b/desktop/src/features/messages/ui/submitMessageEdit.ts
index 06c0de19287..4eb1e274fe5 100644
--- a/desktop/src/features/messages/ui/submitMessageEdit.ts
+++ b/desktop/src/features/messages/ui/submitMessageEdit.ts
@@ -31,6 +31,7 @@ type SubmitMessageEditOptions = Omit<
   extractMentionPubkeys: (content: string) => string[];
   getMentionRefs: (content: string) => DraftMentionRef[];
   editTargetId: string;
+  enqueueUpload?: typeof enqueueBackgroundMediaUpload;
   editTarget: Pick<
     MessageComposerEditTarget,
     "mentionRefs" | "unresolvedMentionPubkeys"
@@ -39,6 +40,7 @@ type SubmitMessageEditOptions = Omit<
   ownerPubkey: string | null;
   restoreComposer: (draft: EditDraft) => void;
   restoreMentionRefs: (refs: DraftMentionRef[]) => void;
+  revalidateMentionPubkeys: (pubkeys: readonly string[]) => Promise<string[]>;
   shouldRestoreComposer: () => boolean;
   setDeferredUploadPending: (isPending: boolean) => void;
   save: (
@@ -55,6 +57,7 @@ export async function submitMessageEdit({
   content,
   customEmoji,
   editTargetId,
+  enqueueUpload = enqueueBackgroundMediaUpload,
   editTarget,
   extractMentionPubkeys,
   getMentionRefs,
@@ -64,6 +67,7 @@ export async function submitMessageEdit({
   queuedAttachments,
   restoreComposer,
   restoreMentionRefs,
+  revalidateMentionPubkeys,
   setDeferredUploadPending,
   shouldRestoreComposer,
   save,
@@ -122,11 +126,19 @@ export async function submitMessageEdit({
       ],
     );
     if (signal?.aborted) return;
-    await save(finalContent, outgoingTags, addedMentionPubkeys, editTargetId);
+    const revalidatedMentionPubkeys =
+      await revalidateMentionPubkeys(addedMentionPubkeys);
+    if (signal?.aborted) return;
+    await save(
+      finalContent,
+      outgoingTags,
+      revalidatedMentionPubkeys,
+      editTargetId,
+    );
   };
 
   if (hasQueuedAttachments) {
-    enqueueBackgroundMediaUpload({
+    enqueueUpload({
       attachments: draft.queuedAttachments,
       onComplete: async (uploaded, signal) => {
         try {
diff --git a/desktop/src/features/messages/ui/useMentionSendFlow.helpers.ts b/desktop/src/features/messages/ui/useMentionSendFlow.helpers.ts
index b2eb3893b7f..39eb75aca12 100644
--- a/desktop/src/features/messages/ui/useMentionSendFlow.helpers.ts
+++ b/desktop/src/features/messages/ui/useMentionSendFlow.helpers.ts
@@ -1,4 +1,4 @@
-import type { ManagedAgent } from "@/shared/api/types";
+import type { ChannelType, ManagedAgent } from "@/shared/api/types";
 import type { ImetaMedia } from "@/features/messages/lib/imetaMediaMarkdown";
 import type { QueuedMediaAttachment } from "@/features/messages/lib/backgroundMediaUploadStore";
 import type { DraftMentionRef } from "@/features/messages/lib/useDrafts";
@@ -75,3 +75,23 @@ export function isManagedAgentRunning(agent: ManagedAgent) {
 export function isProviderBackedAgent(agent: ManagedAgent) {
   return agent.backend.type === "provider";
 }
+
+export function getNonMemberMentionPubkeys({
+  pubkeys,
+  channelType,
+  hasResolvedMembers,
+  memberPubkeys,
+}: {
+  pubkeys: string[];
+  channelType: ChannelType | null;
+  hasResolvedMembers: boolean;
+  memberPubkeys: ReadonlySet<string>;
+}) {
+  if (channelType === null || channelType === "dm" || !hasResolvedMembers) {
+    return [];
+  }
+
+  return uniqueNormalizedPubkeys(pubkeys).filter(
+    (pubkey) => !memberPubkeys.has(pubkey),
+  );
+}
diff --git a/desktop/src/features/messages/ui/useMentionSendFlow.ts b/desktop/src/features/messages/ui/useMentionSendFlow.ts
index 7c34b15db45..9f34529d2f4 100644
--- a/desktop/src/features/messages/ui/useMentionSendFlow.ts
+++ b/desktop/src/features/messages/ui/useMentionSendFlow.ts
@@ -41,6 +41,7 @@ import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
 import { buildCustomEmojiTags } from "@/shared/lib/customEmojiTags";
 import {
   getErrorMessage,
+  getNonMemberMentionPubkeys as computeNonMemberMentionPubkeys,
   isManagedAgentRunning,
   isProviderBackedAgent,
   MENTION_REFERENCE_TAG,
@@ -242,7 +243,6 @@ export function useMentionSendFlow({
       startAgentMutation,
     ],
   );
-
   const createMentionedPersonaAgents = React.useCallback(
     async (trimmed: string, capturedChannelId: string) => {
       const personaMentions = mentions.extractMentionPersonas(trimmed);
@@ -253,7 +253,6 @@ export function useMentionSendFlow({
           pubkeys: [] as string[],
         };
       }
-
       const runtimes = await getAvailableRuntimes();
       const defaultRuntime = runtimes[0] ?? null;
       const errors: string[] = [];
@@ -262,13 +261,11 @@ export function useMentionSendFlow({
       const seenPersonaIds = new Set<string>();
       const shouldProvisionForDm =
         channelType === "dm" && Boolean(onPrepareSendChannel);
-
       for (const { displayName, persona } of personaMentions) {
         if (seenPersonaIds.has(persona.id)) {
           continue;
         }
         seenPersonaIds.add(persona.id);
-
         const { runtime } = resolvePersonaRuntime(
           persona.runtime,
           runtimes,
@@ -278,7 +275,6 @@ export function useMentionSendFlow({
           errors.push(`${displayName}: No agent runtime available.`);
           continue;
         }
-
         try {
           const input: CreateChannelManagedAgentInput & {
             channelId: string;
@@ -311,7 +307,6 @@ export function useMentionSendFlow({
           );
         }
       }
-
       return {
         agents,
         errors,
@@ -406,8 +401,15 @@ export function useMentionSendFlow({
       };
       let uploadStarted = false;
       try {
+        const admittedMentionPubkeys = uniqueNormalizedPubkeys(
+          await mentions.revalidateMentionPubkeys(mentionPubkeys),
+        );
+        if (!isMountedRef.current) return persistPreflightDraft();
+        const admittedMentionPubkeySet = new Set(admittedMentionPubkeys);
         const readyAgentPubkeys = new Set(
-          (draft.readyAgentPubkeys ?? []).map(normalizePubkey),
+          uniqueNormalizedPubkeys(draft.readyAgentPubkeys ?? []).filter(
+            (pubkey) => admittedMentionPubkeySet.has(pubkey),
+          ),
         );
         const managedAgentsByPubkey = await getManagedAgentsByPubkey();
         if (!isMountedRef.current) {
@@ -417,8 +419,7 @@ export function useMentionSendFlow({
         for (const agent of draft.preparedManagedAgents ?? []) {
           managedAgentsByPubkey.set(normalizePubkey(agent.pubkey), agent);
         }
-        const normalizedMentionPubkeys =
-          uniqueNormalizedPubkeys(mentionPubkeys);
+        const normalizedMentionPubkeys = admittedMentionPubkeys;
         const managedMentionPubkeys = normalizedMentionPubkeys.filter(
           (pubkey) => managedAgentsByPubkey.has(pubkey),
         );
@@ -465,7 +466,6 @@ export function useMentionSendFlow({
           toast.error(message);
           return;
         }
-
         if (preparedAgentPubkeys.length > 0 && sendChannelId) {
           try {
             await invokeTauri("sync_agents_to_active_huddle", {
@@ -482,13 +482,11 @@ export function useMentionSendFlow({
             return;
           }
         }
-
         const effectiveExplicitAgentPubkeys =
           filterEffectiveExplicitAgentPubkeys(
             draft.explicitAgentPubkeys,
             mentionPubkeys,
           );
-
         const send = onSendRef.current;
         const persistCanceledDraft = () => {
           if (!draft.recoveryDraftKey) return;
@@ -562,23 +560,28 @@ export function useMentionSendFlow({
             outgoingTags ?? [],
           );
           if (signal?.aborted) return;
+          const revalidatedMentionPubkeys =
+            await mentions.revalidateMentionPubkeys(mentionPubkeys);
+          if (signal?.aborted) return;
+          const revalidatedExplicitAgentPubkeys =
+            filterEffectiveExplicitAgentPubkeys(
+              draft.explicitAgentPubkeys,
+              revalidatedMentionPubkeys,
+            );
           await send(
             finalContent,
-            mentionPubkeys,
+            revalidatedMentionPubkeys,
             finalOutgoingTags,
             sendChannelId,
             draft.capturedThreadContext,
           );
           if (signal?.aborted) return;
-          if (effectiveExplicitAgentPubkeys.length > 0) {
-            // Promote only explicitly authored agents that remained effective
-            // for this successful send. "Send without inviting" removes its
-            // excluded recipients here as well as from event routing.
+          if (revalidatedExplicitAgentPubkeys.length > 0) {
             onSuccessfulExplicitAgentAudience?.({
               channelId: sendChannelId ?? draft.capturedChannelId ?? "",
               expectedGeneration: draft.audienceGeneration,
               expectedRevision: draft.audienceRevision,
-              explicitAgentPubkeys: effectiveExplicitAgentPubkeys,
+              explicitAgentPubkeys: revalidatedExplicitAgentPubkeys,
             });
           }
           if (draft.sentDraftKey) {
@@ -614,7 +617,6 @@ export function useMentionSendFlow({
             return;
           }
         }
-
         // Replace the sent body directly with its final post-send state before
         // the async network send starts. This avoids an intermediate blank frame
         // for persistent audiences while preserving the ordinary empty state.
@@ -649,6 +651,7 @@ export function useMentionSendFlow({
       ensureManagedAgentMentionsReady,
       getManagedAgentsByPubkey,
       mentions.isAgentPubkey,
+      mentions.revalidateMentionPubkeys,
       onPrepareSendChannel,
       onSendRef,
       onSuccessfulExplicitAgentAudience,
@@ -664,19 +667,13 @@ export function useMentionSendFlow({
   );
 
   const getNonMemberMentionPubkeys = React.useCallback(
-    (pubkeys: string[]) => {
-      if (
-        channelType === null ||
-        channelType === "dm" ||
-        !mentions.hasResolvedMembers
-      ) {
-        return [];
-      }
-
-      return uniqueNormalizedPubkeys(pubkeys).filter(
-        (pubkey) => !mentions.memberPubkeys.has(pubkey),
-      );
-    },
+    (pubkeys: string[]) =>
+      computeNonMemberMentionPubkeys({
+        pubkeys,
+        channelType,
+        hasResolvedMembers: mentions.hasResolvedMembers,
+        memberPubkeys: mentions.memberPubkeys,
+      }),
     [channelType, mentions.hasResolvedMembers, mentions.memberPubkeys],
   );
 
@@ -875,38 +872,37 @@ export function useMentionSendFlow({
     );
     void completeSend(pendingNonMemberSend, mentionPubkeys, outgoingTags);
   }, [completeSend, pendingNonMemberSend]);
-
   const handleInviteNonMembers = React.useCallback(() => {
     if (!pendingNonMemberSend) return;
-    // The dialog hides Invite in this case; this guards the keyboard/programmatic
-    // path so we surface the reason instead of a raw relay rejection.
     if (!canInviteNonMembers) {
       setNonMemberPromptError(PRIVATE_CHANNEL_ADD_DENIED_MESSAGE);
       return;
     }
-
-    const invitedPubkeys = new Set(
-      pendingNonMemberSend.nonMemberPubkeys.map(normalizePubkey),
-    );
-    const mentionPubkeys = uniqueNormalizedPubkeys([
-      ...pendingNonMemberSend.mentionPubkeys,
-      ...pendingNonMemberSend.nonMemberPubkeys,
-    ]);
-    const outgoingTags = (pendingNonMemberSend.outgoingTags ?? []).filter(
-      (tag) =>
-        tag[0] !== MENTION_REFERENCE_TAG ||
-        !invitedPubkeys.has(normalizePubkey(tag[1] ?? "")),
-    );
-
     setNonMemberPromptError(null);
     void (async () => {
+      const mentionPubkeys = uniqueNormalizedPubkeys(
+        await mentions.revalidateMentionPubkeys([
+          ...pendingNonMemberSend.mentionPubkeys,
+          ...pendingNonMemberSend.nonMemberPubkeys,
+        ]),
+      );
+      const admittedMentionPubkeys = new Set(mentionPubkeys);
+      const originalNonMemberPubkeys = new Set(
+        pendingNonMemberSend.nonMemberPubkeys.map(normalizePubkey),
+      );
+      const nonMemberPubkeys = [...originalNonMemberPubkeys].filter(
+        admittedMentionPubkeys.has.bind(admittedMentionPubkeys),
+      );
+      const outgoingTags = (pendingNonMemberSend.outgoingTags ?? []).filter(
+        (tag) =>
+          tag[0] !== MENTION_REFERENCE_TAG ||
+          !originalNonMemberPubkeys.has(normalizePubkey(tag[1] ?? "")),
+      );
       const managedAgentsByPubkey = await getManagedAgentsByPubkey();
+      if (!isMountedRef.current) return;
       const peoplePubkeys: string[] = [];
       const relayAgentPubkeys: string[] = [];
-
-      for (const pubkey of uniqueNormalizedPubkeys(
-        pendingNonMemberSend.nonMemberPubkeys,
-      )) {
+      for (const pubkey of nonMemberPubkeys) {
         if (managedAgentsByPubkey.has(pubkey)) {
           continue;
         }
@@ -962,6 +958,7 @@ export function useMentionSendFlow({
     completeSend,
     getManagedAgentsByPubkey,
     mentions.isAgentPubkey,
+    mentions.revalidateMentionPubkeys,
     pendingNonMemberSend,
   ]);
 
diff --git a/desktop/src/features/settings/ui/AppearanceSettingsControls.tsx b/desktop/src/features/settings/ui/AppearanceSettingsControls.tsx
index cc5cd31f144..6e3d1604531 100644
--- a/desktop/src/features/settings/ui/AppearanceSettingsControls.tsx
+++ b/desktop/src/features/settings/ui/AppearanceSettingsControls.tsx
@@ -13,6 +13,7 @@ import {
   useLinkPreviewStyle,
   type LinkPreviewStyle,
 } from "@/shared/lib/linkPreviewStylePreference";
+import { isLinuxPlatform } from "@/shared/lib/platform";
 import {
   ACCENT_COLORS,
   DEFAULT_GLASS_OPACITY,
@@ -168,6 +169,9 @@ export function GlassBackgroundSetting() {
     setGlassOpacity,
   } = useTheme();
   const shouldReduceMotion = useReducedMotion();
+
+  if (isLinuxPlatform()) return null;
+
   const shouldShowOpacity = glassBackgroundSupported && glassBackground;
   const opacityRow = (
     <SettingsOptionRow data-testid="glass-opacity-row">
diff --git a/desktop/src/features/workflows/ui/WorkflowApprovalCard.tsx b/desktop/src/features/workflows/ui/WorkflowApprovalCard.tsx
index 8c39b01f59f..65f58c17a51 100644
--- a/desktop/src/features/workflows/ui/WorkflowApprovalCard.tsx
+++ b/desktop/src/features/workflows/ui/WorkflowApprovalCard.tsx
@@ -1,19 +1,10 @@
-import { Check, X } from "lucide-react";
-import * as React from "react";
-
-import { useApprovalMutation } from "@/features/workflows/hooks";
 import type { WorkflowApproval } from "@/shared/api/types";
-import { Button } from "@/shared/ui/button";
-import { Textarea } from "@/shared/ui/textarea";
 
 type WorkflowApprovalCardProps = {
   approval: WorkflowApproval;
 };
 
 export function WorkflowApprovalCard({ approval }: WorkflowApprovalCardProps) {
-  const [note, setNote] = React.useState("");
-  const approvalMutation = useApprovalMutation();
-
   const isExpired = new Date(approval.expiresAt) < new Date();
 
   if (approval.status !== "pending" || isExpired) {
@@ -32,48 +23,9 @@ export function WorkflowApprovalCard({ approval }: WorkflowApprovalCardProps) {
       <p className="mb-2 text-xs text-muted-foreground">
         Expires: {new Date(approval.expiresAt).toLocaleString()}
       </p>
-
-      <Textarea
-        aria-label="Approval note"
-        className="mb-2 h-16 resize-none text-xs"
-        onChange={(event) => setNote(event.target.value)}
-        placeholder="Optional note..."
-        value={note}
-      />
-
-      <div className="flex gap-2">
-        <Button
-          className="flex-1 bg-green-600 text-white hover:bg-green-700"
-          disabled={approvalMutation.isPending}
-          onClick={() =>
-            approvalMutation.mutate({
-              token: approval.token,
-              action: "grant",
-              note: note || undefined,
-            })
-          }
-          size="sm"
-        >
-          <Check className="mr-1 h-4 w-4" />
-          Approve
-        </Button>
-        <Button
-          className="flex-1"
-          disabled={approvalMutation.isPending}
-          onClick={() =>
-            approvalMutation.mutate({
-              token: approval.token,
-              action: "deny",
-              note: note || undefined,
-            })
-          }
-          size="sm"
-          variant="destructive"
-        >
-          <X className="mr-1 h-4 w-4" />
-          Deny
-        </Button>
-      </div>
+      <p className="text-xs text-muted-foreground" role="status">
+        Approval actions are not yet available in Desktop.
+      </p>
     </div>
   );
 }
diff --git a/desktop/src/features/workflows/ui/WorkflowDetailPanel.tsx b/desktop/src/features/workflows/ui/WorkflowDetailPanel.tsx
index 152bf99203a..3bc94a89868 100644
--- a/desktop/src/features/workflows/ui/WorkflowDetailPanel.tsx
+++ b/desktop/src/features/workflows/ui/WorkflowDetailPanel.tsx
@@ -44,6 +44,16 @@ export function WorkflowDetailPanel({
     ? getWorkflowTriggerSummary(workflow.definition)
     : null;
   const workflowStatus = workflow ? getWorkflowDisplayStatus(workflow) : null;
+  const triggerError = errorMessage(
+    triggerMutation.error,
+    "The relay did not create a workflow run.",
+  );
+  const runsError = errorMessage(
+    runsQuery.error,
+    "Run history could not be loaded.",
+  );
+  const selectedRunIsPendingHistory =
+    selectedRunId !== null && !runs.some((run) => run.id === selectedRunId);
 
   async function handleTrigger() {
     try {
@@ -118,8 +128,14 @@ export function WorkflowDetailPanel({
       </div>
 
       {triggerMutation.isError ? (
-        <div className="border-b px-4 py-2 text-xs text-red-400">
-          Failed to trigger workflow
+        <div
+          className="border-b px-4 py-2 text-xs text-destructive"
+          role="alert"
+        >
+          <p className="font-medium">Failed to trigger workflow</p>
+          <p className="mt-1 break-words text-muted-foreground">
+            {triggerError}
+          </p>
         </div>
       ) : null}
 
@@ -142,7 +158,37 @@ export function WorkflowDetailPanel({
               <h4 className="mb-2 text-xs font-semibold uppercase tracking-wider text-muted-foreground">
                 Run History
               </h4>
-              {runs.length === 0 ? (
+              {runsQuery.isError ? (
+                <div
+                  className="rounded-lg border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive"
+                  role="alert"
+                >
+                  <p className="font-medium">Failed to load run history</p>
+                  <p className="mt-1 break-words">{runsError}</p>
+                </div>
+              ) : runsQuery.isLoading ? (
+                <div
+                  className="space-y-2"
+                  aria-label="Loading run history"
+                  role="status"
+                >
+                  <Skeleton className="h-16 w-full rounded-xl" />
+                </div>
+              ) : selectedRunIsPendingHistory ? (
+                <div
+                  className="rounded-lg border border-primary/30 bg-primary/10 px-3 py-2 text-xs"
+                  data-testid="workflow-run-created"
+                  role="status"
+                >
+                  <p className="font-medium">Run created</p>
+                  <p className="mt-1 break-all font-mono text-muted-foreground">
+                    {selectedRunId}
+                  </p>
+                  <p className="mt-1 text-muted-foreground">
+                    Waiting for its persisted trace…
+                  </p>
+                </div>
+              ) : runs.length === 0 ? (
                 <p className="text-sm text-muted-foreground">No runs yet.</p>
               ) : (
                 <div className="space-y-2">
@@ -152,6 +198,10 @@ export function WorkflowDetailPanel({
                       run.startedAt,
                       run.completedAt,
                     );
+                    const failureReason = workflowRunFailureReason(
+                      run.errorCode,
+                      run.errorMessage,
+                    );
 
                     return (
                       <div
@@ -205,9 +255,9 @@ export function WorkflowDetailPanel({
                                   </span>
                                 ) : null}
                               </div>
-                              {run.errorMessage ? (
+                              {failureReason ? (
                                 <p className="mt-2 break-words pl-6 text-xs text-destructive">
-                                  {run.errorMessage}
+                                  {failureReason}
                                 </p>
                               ) : null}
                             </div>
@@ -266,6 +316,30 @@ export function WorkflowDetailPanel({
   );
 }
 
+function workflowRunFailureReason(
+  errorCode: string | null,
+  diagnostic: string | null,
+) {
+  if (diagnostic?.trim()) return diagnostic;
+  if (!errorCode) return null;
+  const knownReasons: Record<string, string> = {
+    approval_denied: "Approval was denied.",
+    approval_expired: "Approval expired before the workflow could continue.",
+    external_outcome_unknown:
+      "The external action may have completed, but its outcome could not be confirmed.",
+    run_interrupted: "The run was interrupted before it could finish.",
+  };
+  return (
+    knownReasons[errorCode] ?? `Run failed (${errorCode.replace(/_/g, " ")}).`
+  );
+}
+
+function errorMessage(error: unknown, fallback: string) {
+  return error instanceof Error && error.message.trim().length > 0
+    ? error.message
+    : fallback;
+}
+
 function formatRunDuration(
   startedAt: number | null,
   completedAt: number | null,
diff --git a/desktop/src/shared/api/tauriWorkflows.ts b/desktop/src/shared/api/tauriWorkflows.ts
index 2fbf4be0443..0247e1f2111 100644
--- a/desktop/src/shared/api/tauriWorkflows.ts
+++ b/desktop/src/shared/api/tauriWorkflows.ts
@@ -43,12 +43,23 @@ type RawWorkflowRun = {
   execution_trace: RawTraceEntry[];
   started_at: number | null;
   completed_at: number | null;
+  error_code?: string | null;
   error_message: string | null;
   created_at: number;
 };
 
+type RawWorkflowRunCursor = {
+  before: string;
+  before_id: string;
+};
+
+type RawWorkflowRunsResponse = {
+  runs: RawWorkflowRun[];
+  next: RawWorkflowRunCursor | null;
+};
+
 type RawWorkflowApproval = {
-  token: string;
+  approval_ref: string;
   workflow_id: string;
   run_id: string;
   step_id: string;
@@ -61,6 +72,10 @@ type RawWorkflowApproval = {
   created_at: number;
 };
 
+type RawWorkflowApprovalsResponse = {
+  approvals: RawWorkflowApproval[];
+};
+
 type RawTriggerWorkflowResponse = {
   run_id: string;
   workflow_id: string;
@@ -116,6 +131,7 @@ function fromRawWorkflowRun(raw: RawWorkflowRun): WorkflowRun {
     executionTrace: raw.execution_trace.map(fromRawTraceEntry),
     startedAt: raw.started_at,
     completedAt: raw.completed_at,
+    errorCode: raw.error_code ?? null,
     errorMessage: raw.error_message,
     createdAt: raw.created_at,
   };
@@ -123,7 +139,7 @@ function fromRawWorkflowRun(raw: RawWorkflowRun): WorkflowRun {
 
 export function fromRawApproval(raw: RawWorkflowApproval): WorkflowApproval {
   return {
-    token: raw.token,
+    approvalRef: raw.approval_ref,
     workflowId: raw.workflow_id,
     runId: raw.run_id,
     stepId: raw.step_id,
@@ -220,22 +236,25 @@ export async function getWorkflowRuns(
   workflowId: string,
   limit?: number,
 ): Promise<WorkflowRun[]> {
-  const raw = await invokeTauri<RawWorkflowRun[]>("get_workflow_runs", {
+  const raw = await invokeTauri<RawWorkflowRunsResponse>("get_workflow_runs", {
     workflowId,
     limit: limit ?? null,
   });
-  return raw.map(fromRawWorkflowRun);
+  return raw.runs.map(fromRawWorkflowRun);
 }
 
 export async function getRunApprovals(
   workflowId: string,
   runId: string,
 ): Promise<WorkflowApproval[]> {
-  const raw = await invokeTauri<RawWorkflowApproval[]>("get_run_approvals", {
-    workflowId,
-    runId,
-  });
-  return raw.map(fromRawApproval);
+  const raw = await invokeTauri<RawWorkflowApprovalsResponse>(
+    "get_run_approvals",
+    {
+      workflowId,
+      runId,
+    },
+  );
+  return raw.approvals.map(fromRawApproval);
 }
 
 export async function triggerWorkflow(
diff --git a/desktop/src/shared/api/workflowTypes.ts b/desktop/src/shared/api/workflowTypes.ts
index 7f4a312acc7..3eb7f393f0b 100644
--- a/desktop/src/shared/api/workflowTypes.ts
+++ b/desktop/src/shared/api/workflowTypes.ts
@@ -41,6 +41,7 @@ export type WorkflowRun = {
   executionTrace: TraceEntry[];
   startedAt: number | null;
   completedAt: number | null;
+  errorCode: string | null;
   errorMessage: string | null;
   createdAt: number;
 };
@@ -52,7 +53,8 @@ export type WorkflowApprovalStatus =
   | "expired";
 
 export type WorkflowApproval = {
-  token: string;
+  /** Opaque, non-actionable identifier for display/correlation only. */
+  approvalRef: string;
   workflowId: string;
   runId: string;
   stepId: string;
diff --git a/desktop/src/shared/styles/globals/components.css b/desktop/src/shared/styles/globals/components.css
index 5ab551bed08..172c1b180c2 100644
--- a/desktop/src/shared/styles/globals/components.css
+++ b/desktop/src/shared/styles/globals/components.css
@@ -7,6 +7,7 @@
 
   .buzz-huddle-shell {
     --buzz-huddle-drawer-height: 5rem;
+    --buzz-huddle-drawer-inset: 8px;
     --buzz-huddle-drawer-radius: 24px;
     --buzz-huddle-drawer-ease: cubic-bezier(0.32, 0.72, 0, 1);
     --buzz-huddle-drawer-surface: var(--huddle-drawer-surface, 0 0% 0%);
diff --git a/desktop/src/shared/styles/globals/theme.css b/desktop/src/shared/styles/globals/theme.css
index 171f8c0b2e1..5fd2593c79c 100644
--- a/desktop/src/shared/styles/globals/theme.css
+++ b/desktop/src/shared/styles/globals/theme.css
@@ -901,7 +901,9 @@
   background: transparent;
 }
 
-:root[data-glass-background] .buzz-huddle-app-surface-open::after {
+:root[data-glass-background]
+  .buzz-huddle-shell[data-huddle-window="true"]
+  .buzz-huddle-app-surface-open::after {
   background: hsl(var(--buzz-huddle-drawer-surface));
 }
 
@@ -914,8 +916,8 @@
 }
 
 :root[data-buzz-sidebar][data-glass-background]
-  .buzz-huddle-shell[data-huddle-open="true"] {
-  background-color: hsl(var(--buzz-huddle-drawer-surface));
+  .buzz-huddle-shell[data-huddle-window="false"][data-huddle-open="true"] {
+  background-color: transparent;
   background-image: none;
 }
 
@@ -930,3 +932,36 @@
   position: absolute;
   z-index: 0;
 }
+
+/* In the main glass window, let vibrancy continue around the Huddle controls
+ * and present the tray as an inset four-corner surface. The dedicated Huddle
+ * window keeps the full-width dark control dock above. */
+:root[data-glass-background]
+  .buzz-huddle-shell[data-huddle-window="false"]
+  .buzz-huddle-drawer-backdrop {
+  background: transparent;
+}
+
+:root[data-buzz-sidebar][data-glass-background]
+  .buzz-huddle-shell[data-huddle-window="false"][data-huddle-open="true"]::before {
+  content: none;
+}
+
+:root[data-glass-background]
+  .buzz-huddle-shell[data-huddle-window="false"]
+  .buzz-huddle-drawer-slot {
+  padding: var(--buzz-huddle-drawer-inset);
+}
+
+:root[data-glass-background]
+  .buzz-huddle-shell[data-huddle-window="false"]
+  .buzz-huddle-drawer-slot
+  > .buzz-huddle-drawer {
+  border-radius: calc(
+    var(--buzz-huddle-drawer-radius) -
+    var(--buzz-huddle-drawer-inset)
+  );
+  height: 100%;
+  padding-block: var(--buzz-huddle-drawer-inset);
+  padding-inline: var(--buzz-huddle-drawer-inset);
+}
diff --git a/desktop/src/shared/theme/ThemeProvider.tsx b/desktop/src/shared/theme/ThemeProvider.tsx
index 8f4092b87f9..63fd3adb4de 100644
--- a/desktop/src/shared/theme/ThemeProvider.tsx
+++ b/desktop/src/shared/theme/ThemeProvider.tsx
@@ -361,6 +361,14 @@ async function applyWindowGlass(enabled: boolean) {
   glassBackgroundPreferenceEnabled = enabled;
   const requestToken = ++glassVibrancyRequest;
 
+  if (!isTauri() || !isMacPlatform()) {
+    glassBackgroundPreferenceEnabled = false;
+    glassVibrancyEnabled = false;
+    glassVibrancyReady = false;
+    setGlassBackgroundActive(false);
+    return;
+  }
+
   if (enabled && glassVibrancyEnabled && glassVibrancyReady) {
     maybeEnableGlassBackground(requestToken);
     return;
@@ -368,11 +376,6 @@ async function applyWindowGlass(enabled: boolean) {
 
   glassVibrancyReady = false;
 
-  if (!isTauri()) {
-    setGlassBackgroundActive(false);
-    return;
-  }
-
   try {
     await invokeTauri<void>("set_window_vibrancy", {
       enabled,
@@ -478,6 +481,8 @@ export function ThemeProvider({
   children,
   defaultTheme = "buzz",
 }: ThemeProviderProps) {
+  const glassBackgroundSupported = isTauri() && isMacPlatform();
+
   // Apply cached vars synchronously before first render
   const [selectedTheme, setSelectedTheme] = useState<string>(() => {
     applyCachedVars();
@@ -499,8 +504,9 @@ export function ThemeProvider({
   const [glassBackground, setGlassBackgroundState] = useState<boolean>(() => {
     const stored = getStorageItem(GLASS_BACKGROUND_STORAGE_KEY);
     // Glass is opt-in. Explicitly saved preferences remain intact, while a
-    // fresh profile starts with the normal opaque window treatment.
-    const enabled = stored === "true";
+    // fresh profile starts with the normal opaque window treatment. Keep an
+    // unsupported platform opaque without erasing a preference saved on Mac.
+    const enabled = glassBackgroundSupported && stored === "true";
     glassBackgroundPreferenceEnabled = enabled;
     return enabled;
   });
@@ -668,17 +674,27 @@ export function ThemeProvider({
     [],
   );
 
-  const setGlassBackground = useCallback((enabled: boolean) => {
-    window.localStorage.setItem(
-      GLASS_BACKGROUND_STORAGE_KEY,
-      enabled ? "true" : "false",
-    );
-    glassBackgroundPreferenceEnabled = enabled;
-    if (!enabled) {
-      setGlassBackgroundActive(false);
-    }
-    setGlassBackgroundState(enabled);
-  }, []);
+  const setGlassBackground = useCallback(
+    (enabled: boolean) => {
+      if (!glassBackgroundSupported) {
+        glassBackgroundPreferenceEnabled = false;
+        setGlassBackgroundActive(false);
+        setGlassBackgroundState(false);
+        return;
+      }
+
+      window.localStorage.setItem(
+        GLASS_BACKGROUND_STORAGE_KEY,
+        enabled ? "true" : "false",
+      );
+      glassBackgroundPreferenceEnabled = enabled;
+      if (!enabled) {
+        setGlassBackgroundActive(false);
+      }
+      setGlassBackgroundState(enabled);
+    },
+    [glassBackgroundSupported],
+  );
 
   const setGlassOpacity = useCallback((opacity: number) => {
     const nextOpacity = clampGlassOpacity(opacity);
@@ -704,7 +720,7 @@ export function ThemeProvider({
     followSystem,
     glassBackground,
     glassOpacity,
-    glassBackgroundSupported: isTauri() && isMacPlatform(),
+    glassBackgroundSupported,
     prominentActiveTab,
     hasPair,
     terminalPalette,
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index 2cb6d0f75dc..4d66dd1b077 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -299,6 +299,8 @@ type E2eConfig = {
     personaSharePublicationStatuses?: Array<"published" | "queued">;
     teams?: MockTeamSeed[];
     relayAgents?: MockRelayAgentSeed[];
+    /** Reject successive relay-agent directory reads, then resume. */
+    relayAgentListErrors?: (string | null)[];
     /** Native-like huddle state seeded from authoritative role-bearing membership. */
     huddle?: MockHuddleSeed;
     agentListDelayMs?: number;
@@ -3381,6 +3383,7 @@ type RawWorkflowRun = {
   execution_trace: RawWorkflowTraceEntry[];
   started_at: number | null;
   completed_at: number | null;
+  error_code: string | null;
   error_message: string | null;
   created_at: number;
 };
@@ -3540,6 +3543,7 @@ function buildMockWorkflowRun(workflow: MockWorkflow): RawWorkflowRun {
     execution_trace: executionTrace,
     started_at: startedAt,
     completed_at: completedAt,
+    error_code: null,
     error_message: null,
     created_at: createdAt,
   };
@@ -3564,11 +3568,14 @@ function handleGetWorkflowRuns(args: {
   const runs = mockWorkflowRuns.filter(
     (run) => run.workflow_id === args.workflowId,
   );
-  return args.limit ? runs.slice(0, args.limit) : runs;
+  return {
+    runs: args.limit ? runs.slice(0, args.limit) : runs,
+    next: null,
+  };
 }
 
 function handleGetRunApprovals(_args: { workflowId: string; runId: string }) {
-  return [];
+  return { approvals: [] };
 }
 
 const mockProfiles = new Map<string, RawProfile>([
@@ -7481,6 +7488,8 @@ async function handleListRelayAgents(
   config: E2eConfig | undefined,
 ): Promise<RawRelayAgent[]> {
   await delayAgentList(config);
+  const error = config?.mock?.relayAgentListErrors?.shift();
+  if (error) throw new Error(error);
   syncMockRelayAgentsFromManagedAgents();
   return mockRelayAgents.map(cloneRelayAgent);
 }
@@ -9199,6 +9208,16 @@ async function handleSendChannelMessage(
     );
   }
 
+  // Mirror the WebSocket send path's failure injection so specs that route
+  // the first message through the acknowledged HTTP transport still exercise
+  // `sendMessageErrors`. The real command rejects on a relay `OK false`, which
+  // surfaces to callers as a thrown error carrying the relay reason.
+  const sendMessageError =
+    kind === 9 ? config?.mock?.sendMessageErrors?.shift() : null;
+  if (sendMessageError) {
+    throw new Error(sendMessageError);
+  }
+
   // NIP-92 imeta attachments. The real relay echoes these back on the stored
   // event; mirror that here so attachment renderers (FileCard, images, video)
   // have the imeta tags they key on. `null`/empty → no extra tags.
diff --git a/desktop/tests/e2e/buzz-theme-screenshots.spec.ts b/desktop/tests/e2e/buzz-theme-screenshots.spec.ts
index a5218142905..2bcd36908eb 100644
--- a/desktop/tests/e2e/buzz-theme-screenshots.spec.ts
+++ b/desktop/tests/e2e/buzz-theme-screenshots.spec.ts
@@ -478,6 +478,13 @@ test("appearance groups theme and preferences into labeled rows", async ({
   page,
 }) => {
   await seedTheme(page, "github-light");
+  await page.addInitScript((prominentActiveTabStorageKey) => {
+    window.localStorage.setItem(prominentActiveTabStorageKey, "true");
+    Object.defineProperty(navigator, "platform", {
+      configurable: true,
+      get: () => "MacIntel",
+    });
+  }, PROMINENT_ACTIVE_TAB_STORAGE_KEY);
   await installMockBridge(page);
   await openAppearance(page, "light");
   const themeCard = page.getByTestId("appearance-theme-card");
@@ -539,6 +546,22 @@ test("appearance groups theme and preferences into labeled rows", async ({
   await themeCard.getByTestId("theme-option-buzz").click();
   await expect(themeStyleTrigger).toHaveAttribute("aria-expanded", "true");
   await expect(themeStyleOptions).toBeVisible();
+  await expect(
+    themeCard.getByTestId("prominent-active-tab-toggle"),
+  ).toBeChecked();
+  const glassBeforeProminent = await themeCard.evaluate((card) => {
+    const glass = card.querySelector('[data-testid="glass-background-toggle"]');
+    const prominent = card.querySelector(
+      '[data-testid="prominent-active-tab-row"]',
+    );
+    return Boolean(
+      glass &&
+        prominent &&
+        glass.compareDocumentPosition(prominent) &
+          Node.DOCUMENT_POSITION_FOLLOWING,
+    );
+  });
+  expect(glassBeforeProminent).toBe(true);
 
   const colorModeLabelBox = await themeCard
     .getByTestId("appearance-color-mode-row")
@@ -1127,6 +1150,49 @@ test("glass background keeps the content panel solid", async ({ page }) => {
     .toBe("false");
 });
 
+test("glass background is unavailable on Linux", async ({ page }) => {
+  await seedTheme(page, "buzz");
+  await page.addInitScript((storageKey) => {
+    window.localStorage.setItem(storageKey, "true");
+    (window as typeof window & { isTauri?: boolean }).isTauri = true;
+    Object.defineProperty(navigator, "platform", {
+      configurable: true,
+      get: () => "Linux x86_64",
+    });
+    Object.defineProperty(navigator, "userAgent", {
+      configurable: true,
+      get: () => "Buzz Desktop Linux",
+    });
+  }, GLASS_BACKGROUND_STORAGE_KEY);
+  await installMockBridge(page);
+  await openAppearance(page, "light");
+
+  await expect(page.getByTestId("glass-background-row")).toHaveCount(0);
+  await expect(page.getByTestId("glass-background-toggle")).toHaveCount(0);
+  await expect(page.getByTestId("glass-opacity-slider")).toHaveCount(0);
+  await expect(page.locator("html")).not.toHaveAttribute(
+    "data-glass-background",
+    "",
+  );
+  await expect
+    .poll(() =>
+      page.evaluate(() =>
+        (window.__BUZZ_E2E_COMMAND_LOG__ ?? []).some(
+          (entry) => entry.command === "set_window_vibrancy",
+        ),
+      ),
+    )
+    .toBe(false);
+  await expect
+    .poll(() =>
+      page.evaluate(
+        (storageKey) => window.localStorage.getItem(storageKey),
+        GLASS_BACKGROUND_STORAGE_KEY,
+      ),
+    )
+    .toBe("true");
+});
+
 test("non-Buzz glass preserves the selected theme sidebar tint", async ({
   page,
 }) => {
@@ -1178,6 +1244,12 @@ test("accent picker reveals/hides when toggling Buzz", async ({ page }) => {
   // non-Buzz tile brings it back. Asserts the presence toggle (the motion
   // wrapper) works end to end.
   await seedTheme(page, "github-light");
+  await page.addInitScript(() => {
+    Object.defineProperty(navigator, "platform", {
+      configurable: true,
+      get: () => "MacIntel",
+    });
+  });
   await installMockBridge(page);
   await openAppearance(page, "light");
   await expect(page.getByTestId("accent-color-neutral")).toBeVisible();
diff --git a/desktop/tests/e2e/channels.spec.ts b/desktop/tests/e2e/channels.spec.ts
index 4a55849920d..f80f3588eff 100644
--- a/desktop/tests/e2e/channels.spec.ts
+++ b/desktop/tests/e2e/channels.spec.ts
@@ -781,33 +781,18 @@ test("creates the DM before preparing a persona mention", async ({ page }) => {
   expect(expandedOpenIndex).toBeLessThan(startIndex);
   expect(sendCommands).not.toContain("add_channel_members");
 
-  const sentMessageCommand = sendCommandPayloads.find((entry) => {
-    if (entry.command !== "plugin:websocket|send") {
-      return false;
-    }
-    const data = (entry.payload as { message?: { data?: string } } | undefined)
-      ?.message?.data;
-    if (!data) {
-      return false;
-    }
-    const frame = JSON.parse(data) as unknown[];
-    return (
-      frame[0] === "EVENT" &&
-      (frame[1] as { content?: string } | undefined)?.content.includes(
-        "for a hand",
-      )
-    );
-  });
-  const sentMessageData = (
-    sentMessageCommand?.payload as { message?: { data?: string } } | undefined
-  )?.message?.data;
-  expect(sentMessageData).toBeTruthy();
-  const sentMessageEvent = (
-    JSON.parse(sentMessageData ?? "[]") as [string, { tags?: string[][] }]
-  )[1];
-  const sentChannelId = sentMessageEvent.tags?.find(
-    (tag) => tag[0] === "h",
-  )?.[1];
+  const sentMessageCommand = sendCommandPayloads.find(
+    (entry) =>
+      entry.command === "send_channel_message" &&
+      (
+        entry.payload as { content?: string; channelId?: string } | undefined
+      )?.content?.includes("for a hand"),
+  );
+  const sentChannelId = (
+    sentMessageCommand?.payload as
+      | { content?: string; channelId?: string }
+      | undefined
+  )?.channelId;
   expect(sentChannelId).toBeTruthy();
   await expect(
     page.locator("[data-active='true'][data-channel-id]"),
@@ -1048,7 +1033,15 @@ test("drops an expanded DM after the first message fails", async ({ page }) => {
   await expect(input).toContainText("Fizz");
 
   const commandsAfterFailure = await readCommandPayloadLog(page);
-  const failedSendChannelId = await readOutgoingChannelId(page, "for a hand");
+  const failedSendChannelId = (
+    commandsAfterFailure.find(
+      (entry) =>
+        entry.command === "send_channel_message" &&
+        (
+          entry.payload as { content?: string; channelId?: string } | undefined
+        )?.content?.includes("for a hand"),
+    )?.payload as { content?: string; channelId?: string } | undefined
+  )?.channelId;
   expect(failedSendChannelId).toBeTruthy();
   expect(commandsAfterFailure.map((entry) => entry.command)).not.toContain(
     "add_channel_members",
@@ -1075,29 +1068,15 @@ test("drops an expanded DM after the first message fails", async ({ page }) => {
     ),
   ).toBe(baselineOpenDmCount + 1);
   const retryCommands = allCommands.slice(retryBaseline);
-  const retrySend = retryCommands.find((entry) => {
-    if (entry.command !== "plugin:websocket|send") {
-      return false;
-    }
-    const data = (entry.payload as { message?: { data?: string } } | undefined)
-      ?.message?.data;
-    if (!data) {
-      return false;
-    }
-    const frame = JSON.parse(data) as unknown[];
-    return (
-      frame[0] === "EVENT" &&
-      (frame[1] as { content?: string } | undefined)?.content === retryMessage
-    );
-  });
-  const retrySendData = (
-    retrySend?.payload as { message?: { data?: string } } | undefined
-  )?.message?.data;
-  expect(retrySendData).toBeTruthy();
-  const retryEvent = (
-    JSON.parse(retrySendData ?? "[]") as [string, { tags?: string[][] }]
-  )[1];
-  const retryChannelId = retryEvent.tags?.find((tag) => tag[0] === "h")?.[1];
+  const retrySend = retryCommands.find(
+    (entry) =>
+      entry.command === "send_channel_message" &&
+      (entry.payload as { content?: string; channelId?: string } | undefined)
+        ?.content === retryMessage,
+  );
+  const retryChannelId = (
+    retrySend?.payload as { content?: string; channelId?: string } | undefined
+  )?.channelId;
   expect(retryChannelId).toBeTruthy();
   expect(retryChannelId).not.toBe(failedSendChannelId);
   await expect(
@@ -1231,7 +1210,7 @@ test("does not reopen a direct message after leaving the composer", async ({
   await expect(page.getByTestId("chat-title")).toHaveText("general");
 });
 
-test("does not reopen a sent direct message after leaving during cache reseed", async ({
+test("opens a sent direct message without waiting for a channel-list refresh", async ({
   page,
 }) => {
   await page.goto("/");
@@ -1241,29 +1220,37 @@ test("does not reopen a sent direct message after leaving during cache reseed",
   await page
     .getByTestId(`new-dm-result-${TEST_IDENTITIES.charlie.pubkey}`)
     .click();
-  const staleMessage = "Stay on the channel after cache reseed";
-  await page.getByTestId("message-input").fill(staleMessage);
+  const message = "Open without a channel-list refresh";
+  await page.getByTestId("message-input").fill(message);
+  const baselineChannelsReads = commandCount(
+    await readCommandLog(page),
+    "get_channels",
+  );
+  const baselineHttpSends = commandCount(
+    await readCommandLog(page),
+    "send_channel_message",
+  );
   await page.evaluate(() => {
     const testWindow = window as Window & {
       __BUZZ_E2E__?: { mock?: { channelsReadDelayMs?: number } };
     };
     testWindow.__BUZZ_E2E__ ??= {};
     testWindow.__BUZZ_E2E__.mock ??= {};
-    testWindow.__BUZZ_E2E__.mock.channelsReadDelayMs = 1_000;
+    testWindow.__BUZZ_E2E__.mock.channelsReadDelayMs = 3_000;
   });
 
   await page.getByTestId("send-message").click();
-  await expect
-    .poll(async () => hasOutgoingEventWithContent(page, staleMessage))
-    .toBe(true);
-
-  await page.getByTestId("channel-general").click();
-  await expect(page.getByTestId("chat-title")).toHaveText("general");
-  await page.waitForTimeout(1_250);
-  await expect(page).toHaveURL(
-    new RegExp(`/channels/${GENERAL_CHANNEL_ID}(?:\\?|$)`),
+  await expect(page.getByTestId("chat-title")).toHaveText("charlie", {
+    timeout: 1_000,
+  });
+  await expect(page.getByTestId("message-timeline")).toContainText(message);
+  expect(commandCount(await readCommandLog(page), "get_channels")).toBe(
+    baselineChannelsReads,
   );
-  await expect(page.getByTestId("chat-title")).toHaveText("general");
+  expect(commandCount(await readCommandLog(page), "send_channel_message")).toBe(
+    baselineHttpSends + 1,
+  );
+  await expect(page).toHaveURL(/\/channels\/[0-9a-f-]+(?:\?|$)/);
 });
 
 test("shows capped participant stack in group direct message header", async ({
diff --git a/desktop/tests/e2e/dm-history-live-regression.spec.ts b/desktop/tests/e2e/dm-history-live-regression.spec.ts
new file mode 100644
index 00000000000..c8891d354da
--- /dev/null
+++ b/desktop/tests/e2e/dm-history-live-regression.spec.ts
@@ -0,0 +1,203 @@
+import { expect, test, type Page, type Route } from "@playwright/test";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import { finalizeEvent, type VerifiedEvent } from "nostr-tools/pure";
+
+import { installRelayBridge, TEST_IDENTITIES } from "../helpers/bridge";
+import { assertRelaySeeded } from "../helpers/seed";
+
+const RELAY_HTTP = process.env.BUZZ_E2E_RELAY_URL ?? "http://localhost:3000";
+const DM_ID = "5a9c064e-0411-5242-ae6b-0363ba99b8e6";
+
+async function publishAliceDm(
+  content: string,
+  createdAt: number,
+): Promise<VerifiedEvent> {
+  const event = finalizeEvent(
+    {
+      kind: 9,
+      content,
+      created_at: createdAt,
+      tags: [
+        ["h", DM_ID],
+        ["p", TEST_IDENTITIES.tyler.pubkey],
+      ],
+    },
+    hexToBytes(TEST_IDENTITIES.alice.privateKey),
+  );
+  const response = await fetch(`${RELAY_HTTP}/events`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "X-Pubkey": event.pubkey },
+    body: JSON.stringify(event),
+  });
+  if (!response.ok) {
+    throw new Error(
+      `POST /events failed (${response.status}): ${await response.text()}`,
+    );
+  }
+  return event;
+}
+
+async function timelineIds(page: Page) {
+  return page.getByTestId("message-timeline").evaluate((element) =>
+    Array.from(element.querySelectorAll<HTMLElement>("[data-message-id]"))
+      .map((row) => row.dataset.messageId)
+      .filter((id): id is string => Boolean(id)),
+  );
+}
+
+async function cachedMessageIds(page: Page) {
+  return page.evaluate((channelId) => {
+    const client = window.__BUZZ_E2E_QUERY_CLIENT__ as unknown as {
+      getQueryData: (
+        key: readonly unknown[],
+      ) => Array<{ id: string }> | undefined;
+    };
+    if (!client) throw new Error("E2E query client is unavailable.");
+    return (client.getQueryData(["channel-messages", channelId]) ?? []).map(
+      (event) => event.id,
+    );
+  }, DM_ID);
+}
+
+function isDmWindowQuery(route: Route) {
+  const request = route.request();
+  if (request.method() !== "POST" || !request.url().endsWith("/query")) {
+    return false;
+  }
+  try {
+    const body = request.postDataJSON() as Array<Record<string, unknown>>;
+    return body.some(
+      (filter) =>
+        Array.isArray(filter["#h"]) &&
+        filter["#h"].includes(DM_ID) &&
+        filter.top_level === true &&
+        filter.include_summaries === true &&
+        filter.include_aux === true,
+    );
+  } catch {
+    return false;
+  }
+}
+
+async function dmLiveRequestCount(page: Page) {
+  return page.evaluate((channelId) => {
+    let count = 0;
+    for (const entry of window.__BUZZ_E2E_COMMAND_LOG__ ?? []) {
+      if (entry.command !== "plugin:websocket|send") continue;
+      const data = (
+        entry.payload as { message?: { data?: string } } | undefined
+      )?.message?.data;
+      if (!data) continue;
+      try {
+        const frame = JSON.parse(data) as [
+          string,
+          string,
+          ...Record<string, unknown>[],
+        ];
+        if (
+          frame[0] === "REQ" &&
+          frame
+            .slice(2)
+            .some(
+              (filter) =>
+                Array.isArray(filter["#h"]) &&
+                filter["#h"].includes(channelId) &&
+                typeof filter.since === "number",
+            )
+        ) {
+          count += 1;
+        }
+      } catch {
+        // Ignore non-JSON websocket payloads.
+      }
+    }
+    return count;
+  }, DM_ID);
+}
+
+test.beforeAll(async () => {
+  test.setTimeout(90_000);
+  await assertRelaySeeded();
+});
+
+test("existing DM history remains when the first live DM reaches a pageless window", async ({
+  page,
+}) => {
+  const baseSecond = Math.floor(Date.now() / 1000) - 10;
+  const history = await Promise.all(
+    [0, 1, 2].map((index) =>
+      publishAliceDm(`dm history ${index}`, baseSecond + index),
+    ),
+  );
+  const historyIds = history.map((event) => event.id);
+
+  await installRelayBridge(page, "tyler");
+  await page.goto("/");
+  await page.getByTestId("channel-alice-tyler").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("alice-tyler");
+  await expect.poll(() => timelineIds(page)).toEqual(historyIds);
+
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+  await expect.poll(() => cachedMessageIds(page)).toEqual(historyIds);
+  await page.evaluate((channelId) => {
+    const client = window.__BUZZ_E2E_QUERY_CLIENT__ as unknown as {
+      removeQueries: (filters: {
+        queryKey: readonly unknown[];
+        exact: boolean;
+      }) => void;
+    };
+    if (!client) throw new Error("E2E query client is unavailable.");
+    client.removeQueries({
+      queryKey: ["channel-window", channelId],
+      exact: true,
+    });
+  }, DM_ID);
+
+  let heldDmWindowQuery = false;
+  let releaseHeldQuery: (() => void) | undefined;
+  let finishHeldQuery: (() => void) | undefined;
+  const heldQueryReleased = new Promise<void>((resolve) => {
+    releaseHeldQuery = resolve;
+  });
+  const heldQueryFinished = new Promise<void>((resolve) => {
+    finishHeldQuery = resolve;
+  });
+  const holdDmWindowQuery = async (route: Route) => {
+    if (!isDmWindowQuery(route)) {
+      await route.continue();
+      return;
+    }
+    heldDmWindowQuery = true;
+    await heldQueryReleased;
+    await route.continue();
+    finishHeldQuery?.();
+  };
+  await page.route("**/query", holdDmWindowQuery);
+
+  try {
+    const priorLiveRequests = await dmLiveRequestCount(page);
+    await page.getByTestId("channel-alice-tyler").click();
+    await expect(page.getByTestId("chat-title")).toHaveText("alice-tyler");
+    await expect
+      .poll(() => dmLiveRequestCount(page))
+      .toBeGreaterThan(priorLiveRequests);
+
+    const live = await publishAliceDm(
+      "dm live arrival",
+      Math.floor(Date.now() / 1000),
+    );
+    const expectedIds = [...historyIds, live.id];
+
+    await expect.poll(() => timelineIds(page)).toEqual(expectedIds);
+    await expect.poll(() => cachedMessageIds(page)).toEqual(expectedIds);
+    expect(new Set(expectedIds).size).toBe(expectedIds.length);
+    await expect(page.getByTestId("channel-alice-tyler")).toBeVisible();
+    await expect(page.getByTestId("message-input")).toBeVisible();
+    await expect(page.getByTestId("message-input")).toBeEnabled();
+  } finally {
+    releaseHeldQuery?.();
+    if (heldDmWindowQuery) await heldQueryFinished;
+    await page.unroute("**/query", holdDmWindowQuery);
+  }
+});
diff --git a/desktop/tests/e2e/foreground-responsiveness-regression.spec.ts b/desktop/tests/e2e/foreground-responsiveness-regression.spec.ts
new file mode 100644
index 00000000000..db2ea01d6a4
--- /dev/null
+++ b/desktop/tests/e2e/foreground-responsiveness-regression.spec.ts
@@ -0,0 +1,242 @@
+import { expect, test } from "@playwright/test";
+
+import { installRelayBridge } from "../helpers/bridge";
+import { assertRelaySeeded } from "../helpers/seed";
+
+const REPRESENTATIVE_FAMILIES = new Set([
+  "channels",
+  "home-feed",
+  "relay-agents",
+  "channel-templates",
+  "custom-emoji",
+  "user-status",
+]);
+
+type ForegroundProbe = {
+  marker: string;
+  at: number;
+  detail?: unknown;
+};
+
+test.beforeAll(async () => {
+  test.setTimeout(90_000);
+  await assertRelaySeeded();
+});
+
+test("foreground paints and handles a sidebar action before resume fetches", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    type Probe = { marker: string; at: number; detail?: unknown };
+    const probes: Probe[] = [];
+    const record = (marker: string, detail?: unknown) =>
+      probes.push({ marker, at: performance.now(), detail });
+    (
+      window as typeof window & { __FOREGROUND_PROBES__?: Probe[] }
+    ).__FOREGROUND_PROBES__ = probes;
+
+    let captured = false;
+    window.addEventListener(
+      "focus",
+      () => {
+        const armed = (
+          window as typeof window & { __FOREGROUND_PROBE_ARMED__?: boolean }
+        ).__FOREGROUND_PROBE_ARMED__;
+        if (!armed || captured) return;
+        captured = true;
+        record("focus", {
+          hasFocus: document.hasFocus(),
+          visibilityState: document.visibilityState,
+        });
+        window.requestAnimationFrame(() => {
+          record("first-frame");
+          const target = document.querySelector<HTMLElement>(
+            '[data-testid="channel-alice-tyler"]',
+          );
+          if (!target)
+            throw new Error("Sidebar sentinel channel is unavailable.");
+          target.click();
+          record("interaction-dispatched");
+
+          const recordCommitWhenSelected = () => {
+            const selectedTitle = document
+              .querySelector<HTMLElement>('[data-testid="chat-title"]')
+              ?.textContent?.trim();
+            if (selectedTitle === "alice-tyler") {
+              record("interaction-committed");
+              return;
+            }
+            window.requestAnimationFrame(recordCommitWhenSelected);
+          };
+          recordCommitWhenSelected();
+        });
+      },
+      { capture: true },
+    );
+  });
+  await installRelayBridge(page, "tyler");
+  await page.goto("/");
+  await expect(page.getByTestId("app-sidebar")).toBeVisible();
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+
+  const seasonedKeys = await page.evaluate(
+    (representativeFamilies) => {
+      type QueryLike = {
+        queryKey: readonly unknown[];
+        options: { refetchOnWindowFocus?: unknown };
+        state: Record<string, unknown>;
+        getObserversCount: () => number;
+        setState: (state: Record<string, unknown>) => void;
+      };
+      type QueryCacheLike = {
+        findAll: () => QueryLike[];
+        subscribe: (
+          listener: (event: { query?: QueryLike }) => void,
+        ) => () => void;
+      };
+      type QueryClientLike = { getQueryCache: () => QueryCacheLike };
+      const client =
+        window.__BUZZ_E2E_QUERY_CLIENT__ as unknown as QueryClientLike;
+      if (!client) throw new Error("E2E query client is unavailable.");
+
+      const families = new Set(representativeFamilies);
+      const active = client
+        .getQueryCache()
+        .findAll()
+        .filter(
+          (query) =>
+            query.getObserversCount() > 0 &&
+            families.has(String(query.queryKey[0] ?? "")),
+        );
+      for (const query of active) {
+        query.setState({
+          ...query.state,
+          dataUpdatedAt: 1,
+          isInvalidated: true,
+        });
+      }
+
+      const probes = (
+        window as typeof window & { __FOREGROUND_PROBES__?: ForegroundProbe[] }
+      ).__FOREGROUND_PROBES__;
+      if (!probes) throw new Error("Foreground probe was not installed.");
+      const record = (marker: string, detail?: unknown) =>
+        probes.push({ marker, at: performance.now(), detail });
+
+      const activeHashes = new Set(
+        active.map((query) => JSON.stringify(query.queryKey)),
+      );
+      const fetchingHashes = new Set<string>();
+      client.getQueryCache().subscribe((event) => {
+        const query = event.query;
+        if (!query) return;
+        const hash = JSON.stringify(query.queryKey);
+        if (
+          activeHashes.has(hash) &&
+          query.state.fetchStatus === "fetching" &&
+          !fetchingHashes.has(hash)
+        ) {
+          fetchingHashes.add(hash);
+          record("resume-fetch-start", query.queryKey);
+        }
+      });
+
+      return active.map((query) => ({
+        key: query.queryKey,
+        refetchOnWindowFocus: query.options.refetchOnWindowFocus ?? null,
+      }));
+    },
+    [...REPRESENTATIVE_FAMILIES],
+  );
+
+  expect(seasonedKeys.length).toBeGreaterThanOrEqual(3);
+
+  const originalHasFocus = await page.evaluateHandle(() => document.hasFocus);
+  await page.evaluate(() => {
+    (
+      window as typeof window & { __FOREGROUND_PROBE_ARMED__?: boolean }
+    ).__FOREGROUND_PROBE_ARMED__ = true;
+    Object.defineProperty(document, "hasFocus", {
+      configurable: true,
+      value: () => false,
+    });
+    window.dispatchEvent(new Event("blur"));
+  });
+  await expect.poll(() => page.evaluate(() => document.hasFocus())).toBe(false);
+
+  // Headless Chromium reports every page as focused, even after bringToFront on
+  // another target. Drive the production listener and isAppFocused predicate
+  // together rather than shipping a false-green no-op focus transition.
+  await page.evaluate(() => {
+    Object.defineProperty(document, "hasFocus", {
+      configurable: true,
+      value: () => true,
+    });
+    window.dispatchEvent(new Event("focus"));
+  });
+  await expect.poll(() => page.evaluate(() => document.hasFocus())).toBe(true);
+  await expect(page.getByTestId("chat-title")).toHaveText("alice-tyler", {
+    timeout: 5_000,
+  });
+
+  const probes = await expect
+    .poll(
+      () =>
+        page.evaluate(
+          () =>
+            (
+              window as typeof window & {
+                __FOREGROUND_PROBES__?: ForegroundProbe[];
+              }
+            ).__FOREGROUND_PROBES__ ?? [],
+        ),
+      { timeout: 5_000 },
+    )
+    .toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ marker: "focus" }),
+        expect.objectContaining({ marker: "first-frame" }),
+        expect.objectContaining({ marker: "interaction-dispatched" }),
+        expect.objectContaining({ marker: "interaction-committed" }),
+      ]),
+    );
+
+  // expect.poll returns void; read the settled marker stream for ordering.
+  void probes;
+  const settled = await page.evaluate(
+    () =>
+      (window as typeof window & { __FOREGROUND_PROBES__?: ForegroundProbe[] })
+        .__FOREGROUND_PROBES__ ?? [],
+  );
+  await test.info().attach("foreground-ordering", {
+    body: Buffer.from(
+      `${JSON.stringify({ seasonedKeys, probes: settled }, null, 2)}\n`,
+    ),
+    contentType: "application/json",
+  });
+
+  const index = (marker: string) =>
+    settled.findIndex((probe) => probe.marker === marker);
+  const focus = settled.find((probe) => probe.marker === "focus");
+  expect(focus?.detail).toEqual({
+    hasFocus: true,
+    visibilityState: "visible",
+  });
+  expect(index("first-frame")).toBeGreaterThan(index("focus"));
+  expect(index("interaction-dispatched")).toBeGreaterThan(index("first-frame"));
+  expect(index("interaction-committed")).toBeGreaterThan(
+    index("interaction-dispatched"),
+  );
+
+  // The production scheduler promises a painted interaction boundary before
+  // resume work, not completion of an asynchronous route transition. Dispatch
+  // proves the sidebar target was actionable after the first frame; the commit
+  // marker remains a responsiveness witness and must still settle promptly.
+  const firstResumeFetch = index("resume-fetch-start");
+  if (firstResumeFetch !== -1) {
+    expect(firstResumeFetch).toBeGreaterThan(index("interaction-dispatched"));
+  }
+
+  await originalHasFocus.dispose();
+});
diff --git a/desktop/tests/e2e/huddle-transcription.spec.ts b/desktop/tests/e2e/huddle-transcription.spec.ts
index 404f145fa28..734e4ba17ea 100644
--- a/desktop/tests/e2e/huddle-transcription.spec.ts
+++ b/desktop/tests/e2e/huddle-transcription.spec.ts
@@ -264,6 +264,117 @@ test("keeps the drawer open until the huddle is expanded", async ({ page }) => {
   expect(closedGradient).toBe(openGradient);
 });
 
+test("floats the in-app huddle tray over the glass background", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    window.localStorage.setItem("buzz-theme", "buzz-dark");
+    window.localStorage.setItem("buzz-glass-background", "true");
+    (window as typeof window & { isTauri?: boolean }).isTauri = true;
+    Object.defineProperty(navigator, "platform", {
+      configurable: true,
+      get: () => "MacIntel",
+    });
+  });
+  await installMockBridge(page, {
+    huddle: {
+      parentChannelId: HUDDLE_PARENT_ID,
+      ephemeralChannelId: HUDDLE_CHANNEL_ID,
+      members: [
+        { pubkey: TEST_IDENTITIES.tyler.pubkey, role: "member" },
+        { pubkey: TEST_IDENTITIES.alice.pubkey, role: "bot" },
+      ],
+      transcriptionEnabled: true,
+    },
+  });
+
+  await page.goto("/");
+
+  const root = page.locator("html");
+  const shell = page.locator('.buzz-huddle-shell[data-huddle-window="false"]');
+  const slot = shell.locator(".buzz-huddle-drawer-slot");
+  const drawer = slot.locator(":scope > .buzz-huddle-drawer");
+  const backdrop = shell.locator(".buzz-huddle-drawer-backdrop");
+  const transcriptButton = drawer.getByRole("button", {
+    name: "Stop transcript",
+  });
+
+  await expect(root).toHaveAttribute("data-glass-background", "");
+  await expect(shell).toHaveAttribute("data-huddle-open", "true");
+  await expect(shell).toHaveCSS("background-color", "rgba(0, 0, 0, 0)");
+  await expect(backdrop).toHaveCSS("background-color", "rgba(0, 0, 0, 0)");
+  await expect(drawer).toHaveCSS("border-top-left-radius", "16px");
+  await expect(drawer).toHaveCSS("border-top-right-radius", "16px");
+  await expect(drawer).toHaveCSS("border-bottom-right-radius", "16px");
+  await expect(drawer).toHaveCSS("border-bottom-left-radius", "16px");
+  await expect(drawer).toHaveCSS("padding-top", "8px");
+  await expect(drawer).toHaveCSS("padding-right", "8px");
+  await expect(drawer).toHaveCSS("padding-bottom", "8px");
+  await expect(drawer).toHaveCSS("padding-left", "8px");
+
+  const geometry = await Promise.all([
+    slot.boundingBox(),
+    drawer.boundingBox(),
+    transcriptButton.boundingBox(),
+  ]);
+  const [slotBox, drawerBox, transcriptButtonBox] = geometry;
+  expect(slotBox).not.toBeNull();
+  expect(drawerBox).not.toBeNull();
+  expect(transcriptButtonBox).not.toBeNull();
+  if (!slotBox || !drawerBox || !transcriptButtonBox) return;
+  expect(drawerBox.x - slotBox.x).toBe(8);
+  expect(drawerBox.y - slotBox.y).toBe(8);
+  expect(slotBox.x + slotBox.width - (drawerBox.x + drawerBox.width)).toBe(8);
+  expect(slotBox.y + slotBox.height - (drawerBox.y + drawerBox.height)).toBe(8);
+  expect(
+    Math.abs(
+      transcriptButtonBox.y +
+        transcriptButtonBox.height / 2 -
+        (drawerBox.y + drawerBox.height / 2),
+    ),
+  ).toBeLessThanOrEqual(1);
+});
+
+test("keeps the popped-out huddle dock full-width over glass", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    window.localStorage.setItem("buzz-theme", "buzz-dark");
+    window.localStorage.setItem("buzz-glass-background", "true");
+    (window as typeof window & { isTauri?: boolean }).isTauri = true;
+    Object.defineProperty(navigator, "platform", {
+      configurable: true,
+      get: () => "MacIntel",
+    });
+  });
+  await installMockBridge(page, {
+    windowLabel: `huddle-${HUDDLE_CHANNEL_ID}`,
+    huddle: {
+      parentChannelId: HUDDLE_PARENT_ID,
+      ephemeralChannelId: HUDDLE_CHANNEL_ID,
+      members: [
+        { pubkey: TEST_IDENTITIES.tyler.pubkey, role: "member" },
+        { pubkey: TEST_IDENTITIES.alice.pubkey, role: "bot" },
+      ],
+      transcriptionEnabled: true,
+    },
+  });
+
+  await page.goto("/");
+
+  const root = page.locator("html");
+  const shell = page.locator('.buzz-huddle-shell[data-huddle-window="true"]');
+  const slot = shell.locator(".buzz-huddle-drawer-slot");
+  const drawer = slot.locator(":scope > .buzz-huddle-drawer");
+
+  await expect(root).toHaveAttribute("data-glass-background", "");
+  await expect(shell).toHaveAttribute("data-huddle-open", "true");
+  await expect(shell).not.toHaveCSS("background-color", "rgba(0, 0, 0, 0)");
+  await expect(slot).toHaveCSS("padding-top", "0px");
+  await expect(drawer).toHaveCSS("border-top-left-radius", "0px");
+  await expect(drawer).toHaveCSS("border-top-right-radius", "0px");
+});
+
 test("shows speaker identity on every huddle chat message", async ({
   page,
 }) => {
diff --git a/desktop/tests/e2e/inbox-edit.spec.ts b/desktop/tests/e2e/inbox-edit.spec.ts
index 63cc3c570da..79707fb4f53 100644
--- a/desktop/tests/e2e/inbox-edit.spec.ts
+++ b/desktop/tests/e2e/inbox-edit.spec.ts
@@ -322,7 +322,7 @@ test("editing an immediate attachment reply preserves its media tags", async ({
   ).toHaveAttribute("href", ATTACHMENT_URL);
 });
 
-test("Inbox offers a working Edit action only for manageable messages", async ({
+test("Inbox offers Edit and Delete actions only for manageable messages", async ({
   page,
 }) => {
   await installMockBridge(page);
@@ -398,6 +398,9 @@ test("Inbox offers a working Edit action only for manageable messages", async ({
   await expect(
     page.getByTestId(`edit-message-${OWN_MESSAGE_ID}`),
   ).toBeVisible();
+  await expect(
+    page.getByTestId(`delete-message-${OWN_MESSAGE_ID}`),
+  ).toBeVisible();
   await waitForAnimations(page);
   await page.screenshot({ path: `${SHOTS}/01-edit-action.png` });
   await page.getByTestId(`edit-message-${OWN_MESSAGE_ID}`).click();
@@ -423,6 +426,9 @@ test("Inbox offers a working Edit action only for manageable messages", async ({
   await expect(
     page.getByTestId(`edit-message-${FOREIGN_MESSAGE_ID}`),
   ).toHaveCount(0);
+  await expect(
+    page.getByTestId(`delete-message-${FOREIGN_MESSAGE_ID}`),
+  ).toHaveCount(0);
   await page.keyboard.press("Escape");
 
   await page.evaluate(async (channelId) => {
@@ -443,6 +449,77 @@ test("Inbox offers a working Edit action only for manageable messages", async ({
   await expect(page.getByTestId(`edit-message-${OWN_MESSAGE_ID}`)).toHaveCount(
     0,
   );
+  await expect(
+    page.getByTestId(`delete-message-${OWN_MESSAGE_ID}`),
+  ).toHaveCount(0);
+});
+
+test("cancelling explicit Inbox deletion preserves the message and selection", async ({
+  page,
+}) => {
+  await installMockBridge(page);
+  await page.goto("/");
+  await expect(page.getByTestId("home-inbox-list")).toBeVisible();
+  const { detail, rootRow } = await seedEmptyDeleteThread(page);
+  const selectedReplyRow = detail.locator(
+    `[data-message-id="${EMPTY_DELETE_REPLY_ID}"]`,
+  );
+
+  await openMoreActions(page, EMPTY_DELETE_ROOT_ID);
+  await page.getByTestId(`delete-message-${EMPTY_DELETE_ROOT_ID}`).click();
+  const dialog = page.getByRole("alertdialog");
+  await expect(dialog).toContainText("Delete message?");
+  await dialog.getByRole("button", { name: "Cancel" }).click();
+
+  await expect(dialog).toBeHidden();
+  await expect(rootRow).toContainText(EMPTY_DELETE_ROOT_CONTENT);
+  await expect(selectedReplyRow).toContainText(EMPTY_DELETE_REPLY_CONTENT);
+  await expect(selectedReplyRow).toHaveAttribute(
+    "data-testid",
+    "home-inbox-selected-message",
+  );
+  expect(
+    await page.evaluate(
+      () =>
+        ((window as MockWindow).__BUZZ_E2E_COMMAND_PAYLOADS__ ?? []).filter(
+          (entry) => entry.command === "delete_message",
+        ).length,
+    ),
+  ).toBe(0);
+});
+
+test("explicit Inbox deletion targets the chosen non-selected message", async ({
+  page,
+}) => {
+  await installMockBridge(page);
+  await page.goto("/");
+  await expect(page.getByTestId("home-inbox-list")).toBeVisible();
+  const { detail, rootRow } = await seedEmptyDeleteThread(page);
+  const selectedReplyRow = detail.locator(
+    `[data-message-id="${EMPTY_DELETE_REPLY_ID}"]`,
+  );
+
+  await openMoreActions(page, EMPTY_DELETE_ROOT_ID);
+  await page.getByTestId(`delete-message-${EMPTY_DELETE_ROOT_ID}`).click();
+  const dialog = page.getByRole("alertdialog");
+  await expect(dialog).toContainText("Delete message?");
+  await dialog.getByRole("button", { name: "Delete" }).click();
+
+  await expect(dialog).toBeHidden();
+  await expect(rootRow).toBeHidden();
+  await expect(selectedReplyRow).toContainText(EMPTY_DELETE_REPLY_CONTENT);
+  await expect(selectedReplyRow).toHaveAttribute(
+    "data-testid",
+    "home-inbox-selected-message",
+  );
+  const deletePayload = await page.evaluate(() => {
+    const payloads = (window as MockWindow).__BUZZ_E2E_COMMAND_PAYLOADS__ ?? [];
+    return payloads.findLast((entry) => entry.command === "delete_message")
+      ?.payload;
+  });
+  expect(deletePayload).toEqual(
+    expect.objectContaining({ eventId: EMPTY_DELETE_ROOT_ID }),
+  );
 });
 
 test("empty edit confirms deletion of the edited non-selected Inbox row", async ({
diff --git a/desktop/tests/e2e/mentions.spec.ts b/desktop/tests/e2e/mentions.spec.ts
index d366240244e..b198a23557f 100644
--- a/desktop/tests/e2e/mentions.spec.ts
+++ b/desktop/tests/e2e/mentions.spec.ts
@@ -74,6 +74,22 @@ async function readOutgoingMentionPubkeys(
   content: string,
 ) {
   return page.evaluate((expectedContent) => {
+    const signedEvent = (
+      window as Window & {
+        __BUZZ_E2E_SIGNED_EVENTS__?: Array<{
+          content?: string;
+          tags?: string[][];
+        }>;
+      }
+    ).__BUZZ_E2E_SIGNED_EVENTS__?.find(
+      (event) => event.content === expectedContent,
+    );
+    if (signedEvent) {
+      return (signedEvent.tags ?? [])
+        .filter((tag) => tag[0] === "p" && tag[1])
+        .map((tag) => tag[1]);
+    }
+
     const entries =
       (
         window as Window & {
@@ -85,6 +101,25 @@ async function readOutgoingMentionPubkeys(
       ).__BUZZ_E2E_COMMAND_LOG__ ?? [];
 
     for (const entry of entries) {
+      if (entry.command === "send_channel_message") {
+        const payload = entry.payload as
+          | { content?: string; mentionPubkeys?: string[] }
+          | undefined;
+        if (payload?.content === expectedContent) {
+          return payload.mentionPubkeys ?? [];
+        }
+      }
+
+      if (entry.command === "sign_event") {
+        const unsignedEvent = entry.payload as
+          | { content?: string; tags?: string[][] }
+          | undefined;
+        if (unsignedEvent?.content !== expectedContent) continue;
+        return (unsignedEvent.tags ?? [])
+          .filter((tag) => tag[0] === "p" && tag[1])
+          .map((tag) => tag[1]);
+      }
+
       if (entry.command !== "plugin:websocket|send") continue;
       const data = (
         entry.payload as { message?: { data?: string } } | undefined
@@ -1022,6 +1057,74 @@ test("relay-only shared agents appear in forum mentions", async ({ page }) => {
   ).toBeVisible();
 });
 
+test("forum sends revalidate relay-agent authorization before signing", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    deferredComposerUploads: true,
+    uploadDescriptors: [
+      {
+        url: `https://mock.relay/media/${"f".repeat(64)}.pdf`,
+        sha256: "f".repeat(64),
+        size: 12345,
+        type: "application/pdf",
+        uploaded: Math.floor(Date.now() / 1000),
+        filename: "forum-race.pdf",
+      },
+    ],
+    relayAgents: [
+      {
+        pubkey: ALLOWLIST_RELAY_AGENT_PUBKEY,
+        name: "quinn",
+        respondTo: "allowlist",
+        respondToAllowlist: [MOCK_VIEWER_PUBKEY],
+        channelNames: ["watercooler"],
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-watercooler").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("watercooler");
+  await page.getByRole("button", { name: "Start a new post..." }).click();
+
+  const input = page.getByTestId("message-input");
+  await input.fill("@quinn");
+  await page.getByTestId("mention-autocomplete").getByText("quinn").click();
+  await page.keyboard.type("hello");
+  await page.getByRole("button", { name: "Attach file" }).click();
+  const removeAttachment = page.getByRole("button", {
+    name: "Remove attachment",
+  });
+  await expect(removeAttachment).toBeVisible();
+  await page.evaluate(() => {
+    window.__BUZZ_E2E__.mock ??= {};
+    window.__BUZZ_E2E__.mock.agentListDelayMs = 1_000;
+    window.__BUZZ_E2E__.mock.relayAgentListErrors = Array(100).fill(
+      "mock forum directory revoked before send",
+    );
+  });
+
+  await page.getByTestId("send-message").click();
+  await expect(input).toHaveAttribute("contenteditable", "false");
+  await expect(removeAttachment).toBeDisabled();
+  await removeAttachment.evaluate((button: HTMLButtonElement) =>
+    button.click(),
+  );
+  await expect(removeAttachment).toBeVisible();
+  await input.focus();
+  await page.keyboard.type(" later edit");
+  await expect(input).toContainText("@quinn hello");
+  await expect(input).not.toContainText("later edit");
+
+  const outgoingContent = `@quinn hello\n[forum-race.pdf](https://mock.relay/media/${"f".repeat(64)}.pdf)`;
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, outgoingContent))
+    .not.toBeNull();
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, outgoingContent))
+    .not.toContain(ALLOWLIST_RELAY_AGENT_PUBKEY);
+});
+
 test("relay-only allowlisted agents are visible in channel mentions", async ({
   page,
 }) => {
@@ -1048,6 +1151,271 @@ test("relay-only allowlisted agents are visible in channel mentions", async ({
   await expect(dropdown.getByText("agent")).toBeVisible();
 });
 
+test("relay-agent directory errors fail closed and recover after a fresh fetch", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    relayAgentListErrors: ["mock directory unavailable", null],
+    relayAgents: [
+      {
+        pubkey: ALLOWLIST_RELAY_AGENT_PUBKEY,
+        name: "quinn",
+        respondTo: "allowlist",
+        respondToAllowlist: [MOCK_VIEWER_PUBKEY],
+        channelNames: ["general"],
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  const input = page.getByTestId("message-input");
+  await input.fill("@quinn");
+  await expect(autocomplete(page)).toHaveCount(0);
+
+  await page.evaluate(async () => {
+    await window.__BUZZ_E2E_QUERY_CLIENT__?.invalidateQueries({
+      queryKey: ["relay-agents"],
+    });
+  });
+  await expect(autocomplete(page).getByText("quinn")).toBeVisible();
+
+  await page.evaluate(() => {
+    window.__BUZZ_E2E__.mock ??= {};
+    window.__BUZZ_E2E__.mock.agentListDelayMs = 1_000;
+    void window.__BUZZ_E2E_QUERY_CLIENT__?.invalidateQueries({
+      queryKey: ["relay-agents"],
+    });
+  });
+  await expect(autocomplete(page).getByText("quinn")).toHaveCount(0);
+  await expect(autocomplete(page).getByText("quinn")).toBeVisible();
+});
+
+test("relay-only allowlisted agents emit a p tag when sent", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    relayAgents: [
+      {
+        pubkey: ALLOWLIST_RELAY_AGENT_PUBKEY,
+        name: "quinn",
+        respondTo: "allowlist",
+        respondToAllowlist: [MOCK_VIEWER_PUBKEY],
+        channelNames: ["general"],
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+
+  const input = page.getByTestId("message-input");
+  await input.fill("@quinn");
+  const quinnRow = autocomplete(page).locator("button", { hasText: "quinn" });
+  await expect(quinnRow).toBeVisible();
+  await quinnRow.click();
+  await page.keyboard.type("hello");
+  await expect(input).toHaveText("@quinn hello");
+  await page.getByTestId("send-message").click();
+  await page.getByRole("button", { name: "Invite", exact: true }).click();
+
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, "@quinn hello"))
+    .toContain(ALLOWLIST_RELAY_AGENT_PUBKEY);
+});
+
+test("selected relay agents revoked before send emit no p tag", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    relayAgents: [
+      {
+        pubkey: ALLOWLIST_RELAY_AGENT_PUBKEY,
+        name: "quinn",
+        respondTo: "allowlist",
+        respondToAllowlist: [MOCK_VIEWER_PUBKEY],
+        channelNames: ["general"],
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  const input = page.getByTestId("message-input");
+  await input.fill("@quinn");
+  const quinnRow = autocomplete(page).locator("button", { hasText: "quinn" });
+  await expect(quinnRow).toBeVisible();
+  await quinnRow.click();
+  await page.keyboard.type("hello");
+
+  await page.evaluate(async () => {
+    window.__BUZZ_E2E__.mock ??= {};
+    window.__BUZZ_E2E__.mock.relayAgentListErrors = Array(5).fill(
+      "mock directory revoked",
+    );
+    const queryClient = window.__BUZZ_E2E_QUERY_CLIENT__ as unknown as {
+      invalidateQueries: (filters: {
+        queryKey: readonly unknown[];
+      }) => Promise<void>;
+      getQueryState: (
+        queryKey: readonly unknown[],
+      ) => { status?: string } | undefined;
+    };
+    await queryClient.invalidateQueries({ queryKey: ["relay-agents"] });
+    if (queryClient.getQueryState(["relay-agents"])?.status !== "error") {
+      throw new Error(
+        "relay-agent directory refetch did not enter error state",
+      );
+    }
+  });
+  const baselineCommands = await readCommandLog(page);
+  await page.getByTestId("send-message").click();
+
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, "@quinn hello"))
+    .not.toBeNull();
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, "@quinn hello"))
+    .not.toContain(ALLOWLIST_RELAY_AGENT_PUBKEY);
+  const commands = await readCommandLog(page);
+  for (const command of [
+    "add_channel_members",
+    "start_managed_agent",
+    "attach_managed_agent",
+    "sync_agents_to_active_huddle",
+  ]) {
+    expect(commandCount(commands, command)).toBe(
+      commandCount(baselineCommands, command),
+    );
+  }
+});
+
+test("selected relay agents revoked after the invite prompt cause no side effects", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    relayAgents: [
+      {
+        pubkey: ALLOWLIST_RELAY_AGENT_PUBKEY,
+        name: "quinn",
+        respondTo: "allowlist",
+        respondToAllowlist: [MOCK_VIEWER_PUBKEY],
+        channelNames: ["general"],
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  const input = page.getByTestId("message-input");
+  await input.fill("@quinn");
+  const quinnRow = autocomplete(page).locator("button", { hasText: "quinn" });
+  await expect(quinnRow).toBeVisible();
+  await quinnRow.click();
+  await page.keyboard.type("hello");
+  await page.getByTestId("send-message").click();
+  const inviteButton = page.getByRole("button", {
+    name: "Invite",
+    exact: true,
+  });
+  await expect(inviteButton).toBeVisible();
+
+  await page.evaluate(() => {
+    window.__BUZZ_E2E__.mock ??= {};
+    window.__BUZZ_E2E__.mock.relayAgentListErrors = Array(5).fill(
+      "mock directory revoked after invite prompt",
+    );
+  });
+  const baselineCommands = await readCommandLog(page);
+  await inviteButton.click();
+
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, "@quinn hello"))
+    .not.toBeNull();
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, "@quinn hello"))
+    .not.toContain(ALLOWLIST_RELAY_AGENT_PUBKEY);
+  const commands = await readCommandLog(page);
+  for (const command of [
+    "add_channel_members",
+    "start_managed_agent",
+    "attach_managed_agent",
+    "sync_agents_to_active_huddle",
+  ]) {
+    expect(commandCount(commands, command)).toBe(
+      commandCount(baselineCommands, command),
+    );
+  }
+});
+
+test("selected relay agents revoked during send emit no p tag", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    relayAgents: [
+      {
+        pubkey: ALLOWLIST_RELAY_AGENT_PUBKEY,
+        name: "quinn",
+        respondTo: "allowlist",
+        respondToAllowlist: [MOCK_VIEWER_PUBKEY],
+        channelNames: ["general"],
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  const input = page.getByTestId("message-input");
+  await input.fill("@quinn");
+  const quinnRow = autocomplete(page).locator("button", { hasText: "quinn" });
+  await expect(quinnRow).toBeVisible();
+  await quinnRow.click();
+  await page.keyboard.type("hello");
+
+  await page.evaluate(() => {
+    window.__BUZZ_E2E__.mock ??= {};
+    window.__BUZZ_E2E__.mock.agentListDelayMs = 300;
+  });
+  await page.getByTestId("send-message").click();
+  await page.getByRole("button", { name: "Invite", exact: true }).click();
+  await page.evaluate(() => {
+    window.__BUZZ_E2E__.mock ??= {};
+    window.__BUZZ_E2E__.mock.relayAgentListErrors = Array(100).fill(
+      "mock directory revoked mid-send",
+    );
+  });
+
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, "@quinn hello"))
+    .not.toBeNull();
+  await expect
+    .poll(() => readOutgoingMentionPubkeys(page, "@quinn hello"))
+    .not.toContain(ALLOWLIST_RELAY_AGENT_PUBKEY);
+});
+
+test("owner-only builds hide other-owned relay agents", async ({ page }) => {
+  await installMockBridge(page, {
+    ownerOnlyAccessBuild: true,
+    searchProfiles: [
+      {
+        pubkey: ALLOWLIST_RELAY_AGENT_PUBKEY,
+        displayName: "quinn",
+        ownerPubkey: TEST_IDENTITIES.outsider.pubkey,
+        isAgent: true,
+      },
+    ],
+    relayAgents: [
+      {
+        pubkey: ALLOWLIST_RELAY_AGENT_PUBKEY,
+        name: "quinn",
+        respondTo: "allowlist",
+        respondToAllowlist: [MOCK_VIEWER_PUBKEY],
+        channelNames: ["general"],
+      },
+    ],
+  });
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await page.getByTestId("message-input").fill("@quinn");
+
+  await expect(autocomplete(page)).toHaveCount(0);
+});
+
 test("relay-only allowlisted agents stay hidden outside their channel", async ({
   page,
 }) => {
diff --git a/desktop/tests/e2e/messaging.spec.ts b/desktop/tests/e2e/messaging.spec.ts
index cbe19133c9d..68a5fad7fc6 100644
--- a/desktop/tests/e2e/messaging.spec.ts
+++ b/desktop/tests/e2e/messaging.spec.ts
@@ -1312,7 +1312,10 @@ test("compact link preview image geometry truncates long titles to one line", as
   page,
 }) => {
   const previewUrl = "https://github.com/block/buzz/pull/3246?geometry=1";
-  await page.route("http://localhost:3000/media/*.png", (route) =>
+  // Sent snapshot media is relay-hosted and rewritten through the
+  // authenticated media proxy (#5627), so serve the fixture from the mock
+  // proxy origin rather than the raw relay origin.
+  await page.route("http://127.0.0.1:54321/media/**", (route) =>
     route.fulfill({
       body: LINK_PREVIEW_IMAGE,
       contentType: "image/png",
diff --git a/desktop/tests/e2e/perf/metrics.ts b/desktop/tests/e2e/perf/metrics.ts
new file mode 100644
index 00000000000..3c65fcde955
--- /dev/null
+++ b/desktop/tests/e2e/perf/metrics.ts
@@ -0,0 +1,68 @@
+import type { CDPSession, Page } from "@playwright/test";
+
+export type BrowserMetrics = {
+  layoutMs: number;
+  recalcMs: number;
+  layoutCount: number;
+  scriptMs: number;
+  taskMs: number;
+};
+
+export type ActionMeasurement<T> = {
+  metrics: BrowserMetrics;
+  result: T;
+  wallMs: number;
+};
+
+async function readBrowserMetrics(client: CDPSession): Promise<BrowserMetrics> {
+  const { metrics } = (await client.send("Performance.getMetrics")) as {
+    metrics: Array<{ name: string; value: number }>;
+  };
+  const metric = (name: string) =>
+    metrics.find((candidate) => candidate.name === name)?.value ?? 0;
+  return {
+    layoutMs: metric("LayoutDuration") * 1000,
+    recalcMs: metric("RecalcStyleDuration") * 1000,
+    layoutCount: metric("LayoutCount"),
+    scriptMs: metric("ScriptDuration") * 1000,
+    taskMs: metric("TaskDuration") * 1000,
+  };
+}
+
+function delta(after: BrowserMetrics, before: BrowserMetrics): BrowserMetrics {
+  return {
+    layoutMs: after.layoutMs - before.layoutMs,
+    recalcMs: after.recalcMs - before.recalcMs,
+    layoutCount: after.layoutCount - before.layoutCount,
+    scriptMs: after.scriptMs - before.scriptMs,
+    taskMs: after.taskMs - before.taskMs,
+  };
+}
+
+export async function measureAction<T>(
+  page: Page,
+  action: () => Promise<T>,
+): Promise<ActionMeasurement<T>> {
+  const client = await page.context().newCDPSession(page);
+  await client.send("Performance.enable");
+  try {
+    const before = await readBrowserMetrics(client);
+    const startedAt = performance.now();
+    const result = await action();
+    await page.evaluate(
+      () =>
+        new Promise<void>((resolve) =>
+          requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
+        ),
+    );
+    const wallMs = performance.now() - startedAt;
+    return {
+      metrics: delta(await readBrowserMetrics(client), before),
+      result,
+      wallMs,
+    };
+  } finally {
+    await client.send("Performance.disable");
+    await client.detach();
+  }
+}
diff --git a/desktop/tests/e2e/release-smoke.spec.ts b/desktop/tests/e2e/release-smoke.spec.ts
new file mode 100644
index 00000000000..19beb276171
--- /dev/null
+++ b/desktop/tests/e2e/release-smoke.spec.ts
@@ -0,0 +1,246 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+import { expect, test, type Page, type TestInfo } from "@playwright/test";
+
+import { installRelayBridge } from "../helpers/bridge";
+import { assertRelaySeeded } from "../helpers/seed";
+import { denseSecondWall, seedScenario } from "../helpers/seedRelay";
+import { measureAction, type ActionMeasurement } from "./perf/metrics";
+
+const RELAY_HTTP = process.env.BUZZ_E2E_RELAY_URL ?? "http://localhost:3000";
+const GENERAL_CHANNEL_ID = "9f28288a-d724-587a-9709-92dc7f967110";
+const DEEP_ROW_COUNT = Number.parseInt(
+  process.env.BUZZ_RELEASE_SMOKE_ROWS ?? "10000",
+  10,
+);
+const FIXTURE_VERSION = 1;
+
+type ScenarioArtifact = {
+  schemaVersion: 1;
+  fixtureVersion: number;
+  fixtureSecond: number;
+  scenario: string;
+  relayUrl: string;
+  rowCount: number;
+  expectedIdHash: string;
+  observed: Record<string, unknown>;
+  measurement: Omit<ActionMeasurement<unknown>, "result">;
+};
+
+async function sha256(values: readonly string[]) {
+  const bytes = new TextEncoder().encode([...values].sort().join("\n"));
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest), (byte) =>
+    byte.toString(16).padStart(2, "0"),
+  ).join("");
+}
+
+async function writeArtifact(testInfo: TestInfo, artifact: ScenarioArtifact) {
+  const body = `${JSON.stringify(artifact, null, 2)}\n`;
+  const outputPath = testInfo.outputPath("metrics.json");
+  await writeFile(outputPath, body);
+  await testInfo.attach("release-smoke-metrics", {
+    body: Buffer.from(body),
+    contentType: "application/json",
+  });
+
+  const requestedDirectory = process.env.BUZZ_RELEASE_SMOKE_ARTIFACT_DIR;
+  if (requestedDirectory) {
+    const directory = resolve(requestedDirectory);
+    await mkdir(directory, { recursive: true });
+    await writeFile(resolve(directory, `${artifact.scenario}.json`), body);
+  }
+}
+
+async function openGeneral(page: Page) {
+  await installRelayBridge(page, "tyler");
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+  await expect(page.locator('[data-render-pending="true"]')).toHaveCount(0);
+  const timeline = page.getByTestId("message-timeline");
+  await expect(timeline.locator("[data-message-id]").first()).toBeVisible();
+  return timeline;
+}
+
+async function mountedRowCount(page: Page) {
+  return page.getByTestId("message-row").count();
+}
+
+test.beforeAll(async () => {
+  test.setTimeout(90_000);
+  await assertRelaySeeded();
+});
+
+test("deep local-relay timeline remains bounded and every row is reachable", async ({
+  page,
+}, testInfo) => {
+  testInfo.setTimeout(10 * 60_000);
+
+  const fixtureSecond = Math.floor(Date.now() / 1000) - 1;
+  const fixture = denseSecondWall({
+    channelId: GENERAL_CHANNEL_ID,
+    count: DEEP_ROW_COUNT,
+    second: fixtureSecond,
+  });
+  const expected = await seedScenario(fixture, {
+    relayHttpUrl: RELAY_HTTP,
+    concurrency: 64,
+  });
+  expect(expected).toHaveLength(DEEP_ROW_COUNT);
+  const expectedIdHash = await sha256(expected.map(({ id }) => id));
+  const expectedOrder = expected.map(({ id }) => id).sort();
+  const expectedRank = new Map(expectedOrder.map((id, index) => [id, index]));
+
+  const measurement = await measureAction(page, async () => {
+    const timeline = await openGeneral(page);
+    const initialMountedRows = await mountedRowCount(page);
+    let duplicateSnapshots = 0;
+    let orderingViolations = 0;
+    let orderDirection: "ascending" | "descending" | null = null;
+    let maxMountedRows = initialMountedRows;
+    let renderPendingTimeouts = 0;
+    const seen = new Set<string>();
+    const collect = async () => {
+      const ids = await timeline.evaluate((element) =>
+        Array.from(element.querySelectorAll<HTMLElement>("[data-message-id]"))
+          .map((row) => row.dataset.messageId)
+          .filter((id): id is string => Boolean(id)),
+      );
+      if (new Set(ids).size !== ids.length) duplicateSnapshots += 1;
+      const ranks = ids.map((id) => expectedRank.get(id) ?? -1);
+      if (ranks.includes(-1)) orderingViolations += 1;
+      for (let index = 1; index < ranks.length; index += 1) {
+        if (ranks[index] === ranks[index - 1]) {
+          orderingViolations += 1;
+          continue;
+        }
+        const direction =
+          ranks[index] > ranks[index - 1] ? "ascending" : "descending";
+        orderDirection ??= direction;
+        if (direction !== orderDirection) orderingViolations += 1;
+      }
+      for (const id of ids) seen.add(id);
+    };
+
+    await collect();
+    await timeline.hover();
+    const passes: Array<{
+      pass: number;
+      before: number;
+      after: number;
+      continuationRequests: number;
+      scrollTop: number;
+      scrollHeight: number;
+    }> = [];
+    let stalled = 0;
+    let stallReason = "row-target-reached";
+    const maxPasses = Math.ceil(DEEP_ROW_COUNT / 25) + 32;
+    for (
+      let pass = 0;
+      pass < maxPasses && seen.size < DEEP_ROW_COUNT;
+      pass += 1
+    ) {
+      const before = seen.size;
+      // Keep wheel increments below a typical virtualized page height. Large
+      // jumps can legitimately skip transiently mounted rows and turn a DOM
+      // reachability assertion into a collector bug.
+      for (let step = 0; step < 128; step += 1) {
+        await page.mouse.wheel(0, -400);
+        await page.waitForTimeout(20);
+        await collect();
+        const atTop = await timeline.evaluate(
+          (element) => (element as HTMLDivElement).scrollTop <= 1,
+        );
+        if (atTop) break;
+      }
+      await expect
+        .poll(
+          async () => {
+            await collect();
+            return seen.size;
+          },
+          { timeout: 4_000 },
+        )
+        .toBeGreaterThan(before)
+        .catch(() => {});
+      try {
+        await expect(page.locator('[data-render-pending="true"]')).toHaveCount(
+          0,
+          { timeout: 5_000 },
+        );
+      } catch {
+        renderPendingTimeouts += 1;
+      }
+      await collect();
+      const mounted = await mountedRowCount(page);
+      maxMountedRows = Math.max(maxMountedRows, mounted);
+      const state = await timeline.evaluate((element) => ({
+        continuationRequests:
+          (
+            window as typeof window & {
+              __CHANNEL_WINDOW_FETCH_COUNT__?: number;
+            }
+          ).__CHANNEL_WINDOW_FETCH_COUNT__ ?? 0,
+        scrollTop: (element as HTMLDivElement).scrollTop,
+        scrollHeight: (element as HTMLDivElement).scrollHeight,
+      }));
+      passes.push({ pass, before, after: seen.size, ...state });
+      stalled = seen.size === before ? stalled + 1 : 0;
+      if (stalled >= 8) {
+        stallReason = "eight-passes-without-new-rows";
+        break;
+      }
+      stallReason = "pass-limit-reached";
+    }
+
+    if (seen.size >= DEEP_ROW_COUNT) stallReason = "row-target-reached";
+
+    return {
+      initialMountedRows,
+      finalMountedRows: await mountedRowCount(page),
+      maxMountedRows,
+      duplicateSnapshots,
+      orderingViolations,
+      orderDirection,
+      renderPendingTimeouts,
+      reachableRows: seen.size,
+      reachableIdHash: await sha256([...seen]),
+      continuationRequests: await page.evaluate(
+        () =>
+          (
+            window as typeof window & {
+              __CHANNEL_WINDOW_FETCH_COUNT__?: number;
+            }
+          ).__CHANNEL_WINDOW_FETCH_COUNT__ ?? 0,
+      ),
+      passCount: passes.length,
+      stallReason,
+      passes,
+    };
+  });
+
+  await writeArtifact(testInfo, {
+    schemaVersion: 1,
+    fixtureVersion: FIXTURE_VERSION,
+    fixtureSecond,
+    scenario: "deep-local-relay-timeline",
+    relayUrl: RELAY_HTTP,
+    rowCount: DEEP_ROW_COUNT,
+    expectedIdHash,
+    observed: measurement.result,
+    measurement: {
+      wallMs: measurement.wallMs,
+      metrics: measurement.metrics,
+    },
+  });
+
+  expect(measurement.result.initialMountedRows).toBeGreaterThan(0);
+  expect(measurement.result.maxMountedRows).toBeLessThanOrEqual(300);
+  expect(measurement.result.duplicateSnapshots).toBe(0);
+  expect(measurement.result.orderingViolations).toBe(0);
+  expect(measurement.result.renderPendingTimeouts).toBe(0);
+  expect(measurement.result.reachableRows).toBe(DEEP_ROW_COUNT);
+  expect(measurement.result.reachableIdHash).toBe(expectedIdHash);
+});
diff --git a/desktop/tests/helpers/bridge.ts b/desktop/tests/helpers/bridge.ts
index 24db8fdf7bd..f9d26625698 100644
--- a/desktop/tests/helpers/bridge.ts
+++ b/desktop/tests/helpers/bridge.ts
@@ -250,6 +250,8 @@ type MockBridgeOptions = {
   personaSharePublicationStatuses?: Array<"published" | "queued">;
   teams?: MockTeamSeed[];
   relayAgents?: MockRelayAgentSeed[];
+  /** Reject successive relay-agent directory reads, then resume. */
+  relayAgentListErrors?: (string | null)[];
   /** Delay both managed and relay agent directory reads. */
   agentListDelayMs?: number;
   createManagedAgentDelayMs?: number;
diff --git a/migrations/0031_workflow_run_error_codes.sql b/migrations/0031_workflow_run_error_codes.sql
new file mode 100644
index 00000000000..85421f1fa38
--- /dev/null
+++ b/migrations/0031_workflow_run_error_codes.sql
@@ -0,0 +1,10 @@
+-- Stable workflow failure classification, kept separate from redacted human diagnostics.
+-- TEXT is intentional: new codes remain additive across rolling upgrades.
+SET LOCAL lock_timeout = '5s';
+
+ALTER TABLE workflow_runs ADD COLUMN error_code TEXT;
+
+UPDATE workflow_runs
+SET error_code = 'legacy_unclassified'
+WHERE status IN ('failed', 'cancelled')
+  AND error_code IS NULL;
diff --git a/schema/schema.sql b/schema/schema.sql
index d08dbd9019a..9ef7bc0a4b8 100644
--- a/schema/schema.sql
+++ b/schema/schema.sql
@@ -396,6 +396,7 @@ CREATE TABLE workflow_runs (
     started_at          TIMESTAMPTZ,
     completed_at        TIMESTAMPTZ,
     error_message       TEXT,
+    error_code          TEXT,
     created_at          TIMESTAMPTZ NOT NULL DEFAULT NOW(),
     PRIMARY KEY (community_id, id),
     FOREIGN KEY (community_id, workflow_id)
diff --git a/scripts/e2e-large-channel-roster.sh b/scripts/e2e-large-channel-roster.sh
new file mode 100755
index 00000000000..9f82f9bd35c
--- /dev/null
+++ b/scripts/e2e-large-channel-roster.sh
@@ -0,0 +1,127 @@
+#!/usr/bin/env bash
+# Prove a channel member past the historical 1,000-row boundary is present in
+# relay-served discovery, can write, and survives an authoritative republish.
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$REPO_ROOT"
+
+: "${DATABASE_URL:?set DATABASE_URL to the isolated relay database}"
+: "${BUZZ_RELAY_URL:=http://localhost:3030}"
+: "${RELAY_URL:=ws://localhost:3030}"
+: "${BUZZ_RELAY_PRIVATE_KEY:=0000000000000000000000000000000000000000000000000000000000000001}"
+export BUZZ_RELAY_URL RELAY_URL BUZZ_RELAY_PRIVATE_KEY
+unset BUZZ_AUTH_TAG
+
+for binary in buzz buzz-admin; do
+  resolved="$(command -v "$binary" || true)"
+  [[ "$resolved" == "$REPO_ROOT/target/release/$binary" ]] || {
+    echo "error: $binary must resolve to $REPO_ROOT/target/release/$binary (got ${resolved:-not found})" >&2
+    exit 1
+  }
+done
+command -v jq >/dev/null || { echo "error: jq is required" >&2; exit 1; }
+command -v psql >/dev/null || { echo "error: psql is required" >&2; exit 1; }
+
+key_field() {
+  awk -v label="$1" '$1 == label && $2 == "key:" { print $3 }'
+}
+
+OWNER_GEN="$(buzz-admin generate-key)"
+OWNER_SK="$(printf '%s\n' "$OWNER_GEN" | key_field Secret)"
+export BUZZ_PRIVATE_KEY="$OWNER_SK"
+
+CHANNEL="$(buzz channels create \
+  --name "roster-boundary-$$" --type stream --visibility open | jq -er '.channel_id')"
+
+LATE_GEN="$(buzz-admin generate-key)"
+LATE_SK="$(printf '%s\n' "$LATE_GEN" | key_field Secret)"
+LATE_PUBKEY="$(printf '%s\n' "$LATE_GEN" | key_field Public)"
+
+# The creator is roster position 1. Add 1,499 fixtures followed by the real
+# late identity at position 1,501. A final API-added member forces the relay to
+# emit a fresh discovery snapshot through the normal membership-change path.
+psql "$DATABASE_URL" -v ON_ERROR_STOP=1 \
+  --set=channel="$CHANNEL" --set=late_pubkey="$LATE_PUBKEY" <<'SQL'
+WITH target AS (
+  SELECT community_id, id
+  FROM channels
+  WHERE id = :'channel'::uuid
+), fixtures AS (
+  SELECT n, decode(lpad(to_hex(n + 65536), 64, '0'), 'hex') AS pubkey
+  FROM generate_series(1, 1499) AS n
+)
+INSERT INTO channel_members (community_id, channel_id, pubkey, role, joined_at)
+SELECT target.community_id, target.id, fixtures.pubkey, 'member',
+       NOW() + fixtures.n * interval '1 millisecond'
+FROM target CROSS JOIN fixtures;
+
+INSERT INTO channel_members (community_id, channel_id, pubkey, role, joined_at)
+SELECT community_id, id, decode(:'late_pubkey', 'hex'), 'member',
+       NOW() + interval '2 seconds'
+FROM channels
+WHERE id = :'channel'::uuid;
+SQL
+
+TRIGGER_GEN="$(buzz-admin generate-key)"
+TRIGGER_PUBKEY="$(printf '%s\n' "$TRIGGER_GEN" | key_field Public)"
+buzz channels add-member --channel "$CHANNEL" --pubkey "$TRIGGER_PUBKEY" --role member >/dev/null
+
+BEFORE="$(buzz channels members --channel "$CHANNEL")"
+BEFORE_COUNT="$(jq 'length' <<<"$BEFORE")"
+jq -e --arg pk "$LATE_PUBKEY" 'any(.[]; .pubkey == $pk and .role == "member")' \
+  <<<"$BEFORE" >/dev/null
+(( BEFORE_COUNT > 1000 ))
+printf 'PASS discovery-before-republish channel=%s members=%s late_pubkey=%s\n' \
+  "$CHANNEL" "$BEFORE_COUNT" "$LATE_PUBKEY"
+
+export BUZZ_PRIVATE_KEY="$LATE_SK"
+ACTION="$(buzz messages send --channel "$CHANNEL" --content "member-1501-action")"
+jq -e '.accepted == true' <<<"$ACTION" >/dev/null
+ACTION_ID="$(jq -er '.event_id' <<<"$ACTION")"
+buzz messages get --channel "$CHANNEL" --limit 10 \
+  | jq -e --arg id "$ACTION_ID" 'any(.[]; .id == $id and .content == "member-1501-action")' >/dev/null
+printf 'PASS late-member-action event_id=%s\n' "$ACTION_ID"
+
+# Targeted roster repair must not replace canonical metadata or admin events.
+# Preserve both the event ID and complete tags, including fields this backfill
+# command does not know how to rebuild (DM participants, topic, TTL, etc.).
+DISCOVERY_BEFORE="$(psql "$DATABASE_URL" -AtX -v ON_ERROR_STOP=1 \
+  --set=channel="$CHANNEL" <<'SQL'
+SELECT jsonb_object_agg(kind::text, jsonb_build_object(
+  'id', encode(id, 'hex'),
+  'tags', tags
+) ORDER BY kind)::text
+FROM events
+WHERE channel_id = :'channel'::uuid
+  AND kind IN (39000, 39001)
+  AND deleted_at IS NULL;
+SQL
+)"
+jq -e 'has("39000") and has("39001")' <<<"$DISCOVERY_BEFORE" >/dev/null
+
+DATABASE_URL="$DATABASE_URL" RELAY_URL="$RELAY_URL" \
+  buzz-admin reconcile-channels --channel "$CHANNEL" >/dev/null
+
+DISCOVERY_AFTER="$(psql "$DATABASE_URL" -AtX -v ON_ERROR_STOP=1 \
+  --set=channel="$CHANNEL" <<'SQL'
+SELECT jsonb_object_agg(kind::text, jsonb_build_object(
+  'id', encode(id, 'hex'),
+  'tags', tags
+) ORDER BY kind)::text
+FROM events
+WHERE channel_id = :'channel'::uuid
+  AND kind IN (39000, 39001)
+  AND deleted_at IS NULL;
+SQL
+)"
+[[ "$DISCOVERY_AFTER" == "$DISCOVERY_BEFORE" ]]
+printf 'PASS targeted-repair-preserves-metadata-and-admin-events channel=%s\n' "$CHANNEL"
+
+AFTER="$(buzz channels members --channel "$CHANNEL")"
+AFTER_COUNT="$(jq 'length' <<<"$AFTER")"
+jq -e --arg pk "$LATE_PUBKEY" 'any(.[]; .pubkey == $pk and .role == "member")' \
+  <<<"$AFTER" >/dev/null
+(( AFTER_COUNT == BEFORE_COUNT ))
+printf 'PASS discovery-after-republish channel=%s members=%s late_pubkey=%s\n' \
+  "$CHANNEL" "$AFTER_COUNT" "$LATE_PUBKEY"
diff --git a/scripts/run-desktop-release-smoke.sh b/scripts/run-desktop-release-smoke.sh
new file mode 100755
index 00000000000..33f7013ab3e
--- /dev/null
+++ b/scripts/run-desktop-release-smoke.sh
@@ -0,0 +1,148 @@
+#!/usr/bin/env bash
+# Run deterministic desktop correctness smoke; timing metrics are informational.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+ARTIFACT_DIR="${BUZZ_RELEASE_SMOKE_ARTIFACT_DIR:-${ROOT}/desktop/test-results/release-smoke}"
+DB_NAME="${BUZZ_RELEASE_SMOKE_DB:-buzz_release_smoke_${$}}"
+REDIS_DB="${BUZZ_RELEASE_SMOKE_REDIS_DB:-}"
+LOCK_DIR="${TMPDIR:-/tmp}/buzz-desktop-release-smoke.lock"
+RELAY_PID=""
+LOCK_HELD=false
+
+free_port() {
+  python3 - <<'PY'
+import socket
+with socket.socket() as sock:
+    sock.bind(("127.0.0.1", 0))
+    print(sock.getsockname()[1])
+PY
+}
+
+RELAY_PORT="${BUZZ_RELEASE_SMOKE_RELAY_PORT:-$(free_port)}"
+HEALTH_PORT="${BUZZ_RELEASE_SMOKE_HEALTH_PORT:-$(free_port)}"
+METRICS_PORT="${BUZZ_RELEASE_SMOKE_METRICS_PORT:-$(free_port)}"
+COMMUNITY_HOST="localhost:${RELAY_PORT}"
+RELAY_HTTP_URL="http://${COMMUNITY_HOST}"
+STARTED_AT="$(date +%s)"
+
+log() { printf '[desktop-release-smoke] %s\n' "$*"; }
+phase() {
+  local name="$1" start="$2"
+  printf '{"phase":"%s","duration_ms":%d}\n' "$name" "$(( ($(date +%s) - start) * 1000 ))" >> "${ARTIFACT_DIR}/phases.jsonl"
+}
+
+cleanup() {
+  local status=$?
+  trap - EXIT INT TERM
+  if [[ -n "${RELAY_PID}" ]]; then
+    kill "${RELAY_PID}" 2>/dev/null || true
+    for _ in $(seq 1 50); do
+      kill -0 "${RELAY_PID}" 2>/dev/null || break
+      sleep 0.1
+    done
+    kill -9 "${RELAY_PID}" 2>/dev/null || true
+  fi
+  docker exec buzz-redis redis-cli -n "${REDIS_DB}" FLUSHDB >/dev/null 2>&1 || true
+  docker exec buzz-postgres dropdb -U buzz --if-exists "${DB_NAME}" >/dev/null 2>&1 || true
+  if [[ "${LOCK_HELD}" == true ]]; then rmdir "${LOCK_DIR}" 2>/dev/null || true; fi
+  exit "${status}"
+}
+trap cleanup EXIT INT TERM
+
+# Shared Docker services expose one Redis instance and a finite database index
+# space. Serialize automatic allocation; callers that deliberately own an
+# isolated Redis DB may opt out by setting BUZZ_RELEASE_SMOKE_REDIS_DB.
+if [[ -z "${REDIS_DB}" ]]; then
+  mkdir "${LOCK_DIR}" 2>/dev/null || {
+    log "another release-smoke run owns ${LOCK_DIR}; set BUZZ_RELEASE_SMOKE_REDIS_DB only for an isolated runner"
+    exit 1
+  }
+  LOCK_HELD=true
+  REDIS_DB=15
+fi
+
+mkdir -p "${ARTIFACT_DIR}"
+: > "${ARTIFACT_DIR}/phases.jsonl"
+cd "${ROOT}"
+
+phase_start="$(date +%s)"
+log "starting backing services"
+docker compose up -d postgres redis minio minio-init
+for container in buzz-postgres buzz-redis buzz-minio; do
+  for _ in $(seq 1 60); do
+    [[ "$(docker inspect --format='{{.State.Health.Status}}' "${container}" 2>/dev/null || true)" == "healthy" ]] && break
+    sleep 1
+  done
+  [[ "$(docker inspect --format='{{.State.Health.Status}}' "${container}" 2>/dev/null || true)" == "healthy" ]] || {
+    docker logs "${container}" || true
+    exit 1
+  }
+done
+phase services "${phase_start}"
+
+phase_start="$(date +%s)"
+log "creating isolated database ${DB_NAME}"
+docker exec buzz-postgres createdb -U buzz "${DB_NAME}"
+export PGHOST=localhost PGPORT=5432 PGUSER=buzz PGPASSWORD=buzz_dev PGDATABASE="${DB_NAME}"
+export PGSCHEMA_PLAN_HOST=localhost PGSCHEMA_PLAN_PORT=5432 PGSCHEMA_PLAN_DB="${DB_NAME}"
+export PGSCHEMA_PLAN_USER=buzz PGSCHEMA_PLAN_PASSWORD=buzz_dev
+./bin/pgschema apply --file schema/schema.sql --auto-approve
+docker exec -i -e PGPASSWORD=buzz_dev buzz-postgres \
+  psql -U buzz -d "${DB_NAME}" -v ON_ERROR_STOP=1 < scripts/attach-schema-partitions.sql
+BUZZ_DB_NAME="${DB_NAME}" BUZZ_COMMUNITY_HOST="${COMMUNITY_HOST}" ./scripts/setup-desktop-test-data.sh
+docker exec buzz-redis redis-cli -n "${REDIS_DB}" FLUSHDB >/dev/null
+phase database "${phase_start}"
+
+phase_start="$(date +%s)"
+if [[ -n "${BUZZ_E2E_RELAY_BIN:-}" ]]; then
+  RELAY_BIN="${BUZZ_E2E_RELAY_BIN}"
+else
+  log "building relay"
+  cargo build --profile ci -p buzz-relay
+  RELAY_BIN="${ROOT}/target/ci/buzz-relay"
+fi
+log "starting relay at ${RELAY_HTTP_URL}"
+env \
+  DATABASE_URL="postgres://buzz:buzz_dev@localhost:5432/${DB_NAME}" \
+  REDIS_URL="redis://localhost:6379/${REDIS_DB}" \
+  RELAY_URL="ws://${COMMUNITY_HOST}" \
+  BUZZ_BIND_ADDR="127.0.0.1:${RELAY_PORT}" \
+  BUZZ_HEALTH_PORT="${HEALTH_PORT}" \
+  BUZZ_METRICS_PORT="${METRICS_PORT}" \
+  BUZZ_REQUIRE_AUTH_TOKEN=false \
+  BUZZ_RECONCILE_CHANNELS=true \
+  BUZZ_RATE_LIMIT_HUMAN_MESSAGES_PER_MIN=1000000 \
+  BUZZ_RATE_LIMIT_HUMAN_API_CALLS_PER_MIN=1000000 \
+  BUZZ_RATE_LIMIT_HUMAN_WS_EVENTS_PER_SEC=100000 \
+  "${RELAY_BIN}" > "${ARTIFACT_DIR}/relay.log" 2>&1 &
+RELAY_PID=$!
+ready=false
+for _ in $(seq 1 300); do
+  kill -0 "${RELAY_PID}" 2>/dev/null || { cat "${ARTIFACT_DIR}/relay.log"; exit 1; }
+  if curl --silent --fail --max-time 1 "http://127.0.0.1:${HEALTH_PORT}/_readiness" >/dev/null; then
+    ready=true
+    break
+  fi
+  sleep 0.1
+done
+[[ "${ready}" == true ]] || { cat "${ARTIFACT_DIR}/relay.log"; exit 1; }
+phase relay "${phase_start}"
+
+phase_start="$(date +%s)"
+if [[ "${BUZZ_RELEASE_SMOKE_NO_BUILD:-0}" == "1" ]]; then
+  log "reusing existing desktop E2E bundle"
+else
+  log "building desktop E2E bundle"
+  pnpm -C desktop build:e2e
+fi
+phase build "${phase_start}"
+
+phase_start="$(date +%s)"
+log "running release smoke"
+BUZZ_E2E_RELAY_URL="${RELAY_HTTP_URL}" \
+BUZZ_RELEASE_SMOKE_ARTIFACT_DIR="${ARTIFACT_DIR}" \
+pnpm -C desktop exec playwright test --config=playwright.release-smoke.config.ts
+phase smoke "${phase_start}"
+phase total "${STARTED_AT}"
+log "artifacts: ${ARTIFACT_DIR}"