diff --git a/desktop/.env.e2e b/desktop/.env.e2e
new file mode 100644
index 00000000000..a323e18f6c7
--- /dev/null
+++ b/desktop/.env.e2e
@@ -0,0 +1 @@
+VITE_BUZZ_BESTIE=1
diff --git a/desktop/playwright.config.ts b/desktop/playwright.config.ts
index 701c767b329..674300ff73e 100644
--- a/desktop/playwright.config.ts
+++ b/desktop/playwright.config.ts
@@ -39,6 +39,7 @@ export default defineConfig({
         "**/hosted-communities-settings-screenshots.spec.ts",
         "**/invites-settings-screenshots.spec.ts",
         "**/messaging.spec.ts",
+        "**/bestie.spec.ts",
         "**/message-feedback-snapshots.spec.ts",
         "**/message-copy-link.spec.ts",
         "**/custom-emoji.spec.ts",
diff --git a/desktop/src-tauri/src/commands/agents.rs b/desktop/src-tauri/src/commands/agents.rs
index eacef621fb3..296123f470d 100644
--- a/desktop/src-tauri/src/commands/agents.rs
+++ b/desktop/src-tauri/src/commands/agents.rs
@@ -6,14 +6,16 @@ use super::managed_agent_definition::validate_create_definition;
 use crate::{
     app_state::AppState,
     managed_agents::{
+        bestie_assignment::{recover_pending_assignment_cleanup, with_agent_assignments_cleared},
         build_managed_agent_summary, current_instance_id, ensure_persona_is_active,
         find_managed_agent_mut, load_managed_agents, load_personas, load_teams,
-        managed_agent_avatar_url, normalize_agent_args, resolve_provider_binary,
-        save_managed_agents, start_managed_agent_process, stop_managed_agent_process,
-        stop_managed_agent_workspace_pair, sync_managed_agent_processes, try_regenerate_nest,
-        validate_provider_config, BackendKind, CreateManagedAgentRequest,
-        CreateManagedAgentResponse, ManagedAgentRecord, ManagedAgentSummary, RelayMeshConfig,
-        DEFAULT_ACP_COMMAND, DEFAULT_AGENT_PARALLELISM, DEFAULT_AGENT_TURN_TIMEOUT_SECONDS,
+        managed_agent_avatar_url, managed_agents_base_dir, normalize_agent_args,
+        resolve_provider_binary, save_managed_agents, start_managed_agent_process,
+        stop_managed_agent_process, stop_managed_agent_workspace_pair,
+        sync_managed_agent_processes, try_regenerate_nest, validate_provider_config, BackendKind,
+        CreateManagedAgentRequest, CreateManagedAgentResponse, ManagedAgentRecord,
+        ManagedAgentSummary, RelayMeshConfig, DEFAULT_ACP_COMMAND, DEFAULT_AGENT_PARALLELISM,
+        DEFAULT_AGENT_TURN_TIMEOUT_SECONDS,
     },
     relay::relay_ws_url_with_override,
     util::now_iso,
@@ -1087,6 +1089,20 @@ pub async fn stop_managed_agent(
 
 // Async so the blocking body (disk reads/writes, process termination, keyring
 // delete, nest regeneration) runs off the main UI thread via spawn_blocking.
+fn run_managed_agent_deletion<T>(
+    base_dir: &std::path::Path,
+    pubkey: &str,
+    records: &mut Vec<ManagedAgentRecord>,
+    delete: impl FnOnce(&mut Vec<ManagedAgentRecord>) -> Result<T, String>,
+) -> Result<T, String> {
+    recover_pending_assignment_cleanup(base_dir, |pending_pubkey| {
+        records
+            .iter()
+            .any(|record| record.pubkey.eq_ignore_ascii_case(pending_pubkey))
+    })?;
+    with_agent_assignments_cleared(base_dir, pubkey, || delete(records))
+}
+
 #[tauri::command]
 pub async fn delete_managed_agent(
     pubkey: String,
@@ -1102,6 +1118,12 @@ pub async fn delete_managed_agent(
                 .lock()
                 .map_err(|error| error.to_string())?;
             let mut records = load_managed_agents(&app)?;
+            let base_dir = managed_agents_base_dir(&app)?;
+            recover_pending_assignment_cleanup(&base_dir, |pending_pubkey| {
+                records
+                    .iter()
+                    .any(|record| record.pubkey.eq_ignore_ascii_case(pending_pubkey))
+            })?;
             let mut runtimes = state
                 .managed_agent_processes
                 .lock()
@@ -1135,16 +1157,17 @@ pub async fn delete_managed_agent(
                 }
             }
 
-            if let Some(record) = records.iter_mut().find(|record| record.pubkey == pubkey) {
-                stop_managed_agent_process(&app, record, &mut runtimes)?;
-            }
-            state.clear_agent_session_caches(&pubkey);
-            let initial_len = records.len();
-            records.retain(|record| record.pubkey != pubkey);
-            if records.len() == initial_len {
+            if !records.iter().any(|record| record.pubkey == pubkey) {
                 return Err(format!("agent {pubkey} not found"));
             }
-            save_managed_agents(&app, &records)?;
+            run_managed_agent_deletion(&base_dir, &pubkey, &mut records, |records| {
+                if let Some(record) = records.iter_mut().find(|record| record.pubkey == pubkey) {
+                    stop_managed_agent_process(&app, record, &mut runtimes)?;
+                }
+                state.clear_agent_session_caches(&pubkey);
+                records.retain(|record| record.pubkey != pubkey);
+                save_managed_agents(&app, records)
+            })?;
             crate::managed_agents::delete_agent_key(&pubkey);
             // Tombstone after confirmed removal (inside lock; every published
             // agent tombstones). The NIP-IA kind:9035 archive request — which
diff --git a/desktop/src-tauri/src/commands/agents_tests.rs b/desktop/src-tauri/src/commands/agents_tests.rs
index ef71321bedf..59e04b09ff0 100644
--- a/desktop/src-tauri/src/commands/agents_tests.rs
+++ b/desktop/src-tauri/src/commands/agents_tests.rs
@@ -188,6 +188,45 @@ fn deploy_resolver_inherits_global_when_definition_blank() {
     );
 }
 
+#[test]
+fn production_delete_orchestration_restores_bestie_when_agent_save_fails() {
+    use crate::managed_agents::{
+        bestie_assignment::{assignment_matches, replace_assignment},
+        retention::open_retention_db,
+    };
+
+    let dir = tempfile::tempdir().unwrap_or_else(|error| panic!("temp dir: {error}"));
+    let retention_dir = dir.path().join("retention");
+    std::fs::create_dir_all(&retention_dir)
+        .unwrap_or_else(|error| panic!("create retention dir: {error}"));
+    let db_path = retention_dir.join("owner.db");
+    let pubkey = "a".repeat(64);
+    replace_assignment(
+        &mut open_retention_db(&db_path)
+            .unwrap_or_else(|error| panic!("open assignment DB: {error}")),
+        &pubkey,
+    )
+    .unwrap_or_else(|error| panic!("seed assignment: {error}"));
+    let mut record = bare_agent_record(None, None, None);
+    record.pubkey.clone_from(&pubkey);
+    let mut records = vec![record];
+
+    let result = run_managed_agent_deletion(dir.path(), &pubkey, &mut records, |_records| {
+        Err::<(), _>("injected managed-agent save failure".to_string())
+    });
+
+    assert_eq!(
+        result,
+        Err("injected managed-agent save failure".to_string())
+    );
+    assert!(assignment_matches(
+        &open_retention_db(&db_path)
+            .unwrap_or_else(|error| panic!("reopen assignment DB: {error}")),
+        &pubkey,
+    )
+    .unwrap_or_else(|error| panic!("read restored assignment: {error}")));
+}
+
 /// Deploy resolver falls back to global when both definition and record have none.
 #[test]
 fn deploy_resolver_falls_back_to_global_when_definition_and_record_have_none() {
diff --git a/desktop/src-tauri/src/commands/bestie.rs b/desktop/src-tauri/src/commands/bestie.rs
new file mode 100644
index 00000000000..19f21186258
--- /dev/null
+++ b/desktop/src-tauri/src/commands/bestie.rs
@@ -0,0 +1,218 @@
+use std::sync::atomic::Ordering;
+
+use tauri::{AppHandle, State};
+
+use crate::{
+    app_state::AppState,
+    managed_agents::{
+        bestie_assignment::{
+            assignment_matches, clear_assignment, get_assignment,
+            recover_pending_assignment_cleanup, replace_assignment, BestieAssignment,
+        },
+        load_managed_agents, managed_agents_base_dir,
+        retention::{active_retention_scope, open_retention_db, RetentionScope},
+        BackendKind, ManagedAgentRecord,
+    },
+    models::ChannelInfo,
+};
+
+fn canonical_relay(relay_url: &str) -> Result<String, String> {
+    buzz_core_pkg::relay::normalize_relay_url(relay_url).map_err(|error| error.to_string())
+}
+
+fn assert_expected_scope(
+    scope: &RetentionScope,
+    expected_relay_url: Option<&str>,
+    expected_signer_pubkey: Option<&str>,
+) -> Result<(), String> {
+    if let Some(expected) = expected_relay_url {
+        if canonical_relay(expected)? != canonical_relay(&scope.relay_url)? {
+            return Err("active community changed while resolving Bestie".to_string());
+        }
+    }
+    if let Some(expected) = expected_signer_pubkey {
+        if expected.trim().to_ascii_lowercase() != scope.owner_keys.public_key().to_hex() {
+            return Err("active identity changed while resolving Bestie".to_string());
+        }
+    }
+    Ok(())
+}
+
+fn validate_agent_pubkey(pubkey: &str) -> Result<String, String> {
+    let normalized = pubkey.trim().to_ascii_lowercase();
+    if normalized.len() != 64
+        || !normalized
+            .chars()
+            .all(|character| character.is_ascii_hexdigit())
+    {
+        return Err("Bestie agent pubkey must be 64 hexadecimal characters".to_string());
+    }
+    Ok(normalized)
+}
+
+fn require_eligible_local_agent(
+    records: &[ManagedAgentRecord],
+    pubkey: &str,
+) -> Result<(), String> {
+    let record = records
+        .iter()
+        .find(|record| record.pubkey.eq_ignore_ascii_case(pubkey))
+        .ok_or_else(|| "assigned Bestie agent no longer exists on this device".to_string())?;
+    if record.backend != BackendKind::Local {
+        return Err("only a local managed agent can be your Bestie".to_string());
+    }
+    Ok(())
+}
+
+fn recover_pending_cleanup(app: &AppHandle, records: &[ManagedAgentRecord]) -> Result<(), String> {
+    recover_pending_assignment_cleanup(&managed_agents_base_dir(app)?, |pending_pubkey| {
+        records
+            .iter()
+            .any(|record| record.pubkey.eq_ignore_ascii_case(pending_pubkey))
+    })
+}
+
+#[tauri::command]
+pub fn get_bestie_assignment(
+    expected_relay_url: Option<String>,
+    expected_signer_pubkey: Option<String>,
+    app: AppHandle,
+    state: State<'_, AppState>,
+) -> Result<Option<BestieAssignment>, String> {
+    let scope = active_retention_scope(&app, &state)?;
+    assert_expected_scope(
+        &scope,
+        expected_relay_url.as_deref(),
+        expected_signer_pubkey.as_deref(),
+    )?;
+    let _store_guard = state
+        .managed_agents_store_lock
+        .lock()
+        .map_err(|error| error.to_string())?;
+    let records = load_managed_agents(&app)?;
+    recover_pending_cleanup(&app, &records)?;
+    let conn = open_retention_db(&scope.db_path)?;
+    get_assignment(&conn)
+}
+
+#[tauri::command]
+pub fn assign_bestie(
+    agent_pubkey: String,
+    expected_relay_url: Option<String>,
+    expected_signer_pubkey: Option<String>,
+    app: AppHandle,
+    state: State<'_, AppState>,
+) -> Result<BestieAssignment, String> {
+    let pubkey = validate_agent_pubkey(&agent_pubkey)?;
+    let scope = active_retention_scope(&app, &state)?;
+    assert_expected_scope(
+        &scope,
+        expected_relay_url.as_deref(),
+        expected_signer_pubkey.as_deref(),
+    )?;
+    let _store_guard = state
+        .managed_agents_store_lock
+        .lock()
+        .map_err(|error| error.to_string())?;
+    let records = load_managed_agents(&app)?;
+    recover_pending_cleanup(&app, &records)?;
+    require_eligible_local_agent(&records, &pubkey)?;
+    let mut conn = open_retention_db(&scope.db_path)?;
+    replace_assignment(&mut conn, &pubkey)
+}
+
+#[tauri::command]
+pub fn clear_bestie_assignment(
+    expected_relay_url: Option<String>,
+    expected_signer_pubkey: Option<String>,
+    app: AppHandle,
+    state: State<'_, AppState>,
+) -> Result<(), String> {
+    let scope = active_retention_scope(&app, &state)?;
+    assert_expected_scope(
+        &scope,
+        expected_relay_url.as_deref(),
+        expected_signer_pubkey.as_deref(),
+    )?;
+    let _store_guard = state
+        .managed_agents_store_lock
+        .lock()
+        .map_err(|error| error.to_string())?;
+    let records = load_managed_agents(&app)?;
+    recover_pending_cleanup(&app, &records)?;
+    let mut conn = open_retention_db(&scope.db_path)?;
+    clear_assignment(&mut conn)
+}
+
+#[tauri::command]
+pub async fn resolve_bestie_conversation(
+    expected_relay_url: Option<String>,
+    expected_signer_pubkey: Option<String>,
+    app: AppHandle,
+    state: State<'_, AppState>,
+) -> Result<ChannelInfo, String> {
+    let generation = state.workspace_apply_generation.load(Ordering::Acquire);
+    let scope = active_retention_scope(&app, &state)?;
+    assert_expected_scope(
+        &scope,
+        expected_relay_url.as_deref(),
+        expected_signer_pubkey.as_deref(),
+    )?;
+    let assignment = {
+        let _store_guard = state
+            .managed_agents_store_lock
+            .lock()
+            .map_err(|error| error.to_string())?;
+        let records = load_managed_agents(&app)?;
+        recover_pending_cleanup(&app, &records)?;
+        let conn = open_retention_db(&scope.db_path)?;
+        let assignment = get_assignment(&conn)?
+            .ok_or_else(|| "choose an agent before opening Bestie".to_string())?;
+        require_eligible_local_agent(&records, &assignment.agent_pubkey)?;
+        assignment
+    };
+
+    let owner_pubkey = scope.owner_keys.public_key().to_hex();
+    let channel = super::dms::open_dm_with_scope(
+        vec![assignment.agent_pubkey.clone()],
+        Some(&scope.relay_url),
+        Some(&owner_pubkey),
+        &state,
+    )
+    .await?;
+
+    if state.workspace_apply_generation.load(Ordering::Acquire) != generation {
+        return Err("active workspace changed while resolving Bestie".to_string());
+    }
+    let current_scope = active_retention_scope(&app, &state)?;
+    assert_expected_scope(&current_scope, Some(&scope.relay_url), Some(&owner_pubkey))?;
+    let conn = open_retention_db(&scope.db_path)?;
+    if !assignment_matches(&conn, &assignment.agent_pubkey)? {
+        return Err("Bestie assignment changed while opening the conversation".to_string());
+    }
+    Ok(channel)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn relay_scope_accepts_runtime_equivalences() {
+        assert_eq!(
+            canonical_relay(" WSS://LOCALHOST:443/ ")
+                .unwrap_or_else(|error| panic!("canonical relay: {error}")),
+            "wss://127.0.0.1"
+        );
+    }
+
+    #[test]
+    fn pubkeys_are_normalized_and_validated() {
+        assert_eq!(
+            validate_agent_pubkey(&"A".repeat(64))
+                .unwrap_or_else(|error| panic!("valid pubkey: {error}")),
+            "a".repeat(64)
+        );
+        assert!(validate_agent_pubkey("short").is_err());
+    }
+}
diff --git a/desktop/src-tauri/src/commands/dms.rs b/desktop/src-tauri/src/commands/dms.rs
index 5f6ca279802..252068c94d7 100644
--- a/desktop/src-tauri/src/commands/dms.rs
+++ b/desktop/src-tauri/src/commands/dms.rs
@@ -23,6 +23,21 @@ pub async fn open_dm(
     expected_relay_url: Option<String>,
     expected_signer_pubkey: Option<String>,
     state: State<'_, AppState>,
+) -> Result<ChannelInfo, String> {
+    open_dm_with_scope(
+        pubkeys,
+        expected_relay_url.as_deref(),
+        expected_signer_pubkey.as_deref(),
+        &state,
+    )
+    .await
+}
+
+pub(crate) async fn open_dm_with_scope(
+    pubkeys: Vec<String>,
+    expected_relay_url: Option<&str>,
+    expected_signer_pubkey: Option<&str>,
+    state: &AppState,
 ) -> Result<ChannelInfo, String> {
     // Resolve the relay AND the signing identity once for the open + metadata
     // read pair. Callers with a captured tenant scope (Projects agent sends)
@@ -34,25 +49,22 @@ pub async fn open_dm(
     // tenant-A DM signed as tenant B's identity — fail closed instead, and
     // use this exact key snapshot for both the event signature and the
     // NIP-98 auth of every request in this command.
-    let api_base_url = crate::relay::relay_api_base_url_with_override(&state);
-    assert_expected_relay_scope(expected_relay_url.as_deref(), &api_base_url)?;
+    let api_base_url = crate::relay::relay_api_base_url_with_override(state);
+    assert_expected_relay_scope(expected_relay_url, &api_base_url)?;
     let keys = state.signing_keys()?;
-    assert_expected_signer(
-        expected_signer_pubkey.as_deref(),
-        &keys.public_key().to_hex(),
-    )?;
+    assert_expected_signer(expected_signer_pubkey, &keys.public_key().to_hex())?;
 
     // Submit a kind:41010 dm-open event; the relay replies with the channel id
     // in its OK message payload.
     let builder = events::build_dm_open(&pubkeys)?;
-    let result = submit_event_at_with_keys(builder, &state, &api_base_url, &keys).await?;
+    let result = submit_event_at_with_keys(builder, state, &api_base_url, &keys).await?;
     let ack: OpenDmAck = parse_command_response(&result.message)?;
 
     // Re-fetch the channel metadata so the frontend gets the same `ChannelInfo`
     // shape as `get_channel_details` — through the same scope-checked base and
     // the same pinned identity.
     let metadata = query_relay_at_with_keys(
-        &state,
+        state,
         &api_base_url,
         &[serde_json::json!({
             "kinds": [39000],
diff --git a/desktop/src-tauri/src/commands/mod.rs b/desktop/src-tauri/src/commands/mod.rs
index 324e13e68a5..c8184a01031 100644
--- a/desktop/src-tauri/src/commands/mod.rs
+++ b/desktop/src-tauri/src/commands/mod.rs
@@ -11,6 +11,7 @@ mod agent_providers;
 mod agent_settings;
 mod agent_update_rollback;
 mod agents;
+mod bestie;
 mod canvas;
 mod channel_reconnect_repair;
 mod channel_templates;
@@ -84,6 +85,7 @@ pub use agent_models::*;
 pub use agent_providers::*;
 pub use agent_settings::*;
 pub use agents::*;
+pub use bestie::*;
 pub use canvas::*;
 pub use channel_reconnect_repair::*;
 pub use channel_templates::*;
diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs
index 0e4832a702a..12082a2a82e 100644
--- a/desktop/src-tauri/src/lib.rs
+++ b/desktop/src-tauri/src/lib.rs
@@ -621,6 +621,10 @@ pub fn run() {
             create_channel,
             ensure_starter_channels,
             open_dm,
+            get_bestie_assignment,
+            assign_bestie,
+            clear_bestie_assignment,
+            resolve_bestie_conversation,
             hide_dm,
             get_channel_details,
             get_channel_members,
diff --git a/desktop/src-tauri/src/managed_agents/bestie_assignment.rs b/desktop/src-tauri/src/managed_agents/bestie_assignment.rs
new file mode 100644
index 00000000000..e823db124b8
--- /dev/null
+++ b/desktop/src-tauri/src/managed_agents/bestie_assignment.rs
@@ -0,0 +1,595 @@
+//! Durable, owner-and-relay-scoped Bestie designation storage.
+
+use std::{
+    fs,
+    io::ErrorKind,
+    path::{Path, PathBuf},
+};
+
+use rusqlite::{params, Connection, OptionalExtension};
+use serde::{Deserialize, Serialize};
+
+use super::{retention::open_retention_db, storage::atomic_write_json_restricted};
+
+const RECOVERY_JOURNAL_FILE: &str = "bestie-assignment-recovery.json";
+
+/// The one durable Bestie designation in a retention scope.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct BestieAssignment {
+    pub agent_pubkey: String,
+}
+
+fn ensure_table(conn: &Connection) -> Result<(), String> {
+    conn.execute_batch(
+        "CREATE TABLE IF NOT EXISTS bestie_assignments (
+            singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+            agent_pubkey TEXT NOT NULL
+        );",
+    )
+    .map_err(|error| format!("failed to create bestie assignment table: {error}"))
+}
+
+/// Read the designation for the already-scoped retention database.
+pub fn get_assignment(conn: &Connection) -> Result<Option<BestieAssignment>, String> {
+    ensure_table(conn)?;
+    conn.query_row(
+        "SELECT agent_pubkey FROM bestie_assignments WHERE singleton = 1",
+        [],
+        |row| {
+            Ok(BestieAssignment {
+                agent_pubkey: row.get(0)?,
+            })
+        },
+    )
+    .optional()
+    .map_err(|error| format!("failed to read bestie assignment: {error}"))
+}
+
+/// Atomically create or replace the one designation in this scope.
+pub fn replace_assignment(
+    conn: &mut Connection,
+    agent_pubkey: &str,
+) -> Result<BestieAssignment, String> {
+    ensure_table(conn)?;
+    let normalized = agent_pubkey.trim().to_ascii_lowercase();
+    let transaction = conn
+        .transaction()
+        .map_err(|error| format!("failed to begin bestie assignment transaction: {error}"))?;
+    transaction
+        .execute(
+            "INSERT INTO bestie_assignments (singleton, agent_pubkey)
+             VALUES (1, ?1)
+             ON CONFLICT(singleton) DO UPDATE SET agent_pubkey = excluded.agent_pubkey",
+            params![normalized],
+        )
+        .map_err(|error| format!("failed to replace bestie assignment: {error}"))?;
+    transaction
+        .commit()
+        .map_err(|error| format!("failed to commit bestie assignment: {error}"))?;
+    get_assignment(conn)?.ok_or_else(|| "bestie assignment was not persisted".to_string())
+}
+
+/// Clear the designation without changing or stopping the agent.
+pub fn clear_assignment(conn: &mut Connection) -> Result<(), String> {
+    ensure_table(conn)?;
+    let transaction = conn
+        .transaction()
+        .map_err(|error| format!("failed to begin bestie clear transaction: {error}"))?;
+    transaction
+        .execute("DELETE FROM bestie_assignments WHERE singleton = 1", [])
+        .map_err(|error| format!("failed to clear bestie assignment: {error}"))?;
+    transaction
+        .commit()
+        .map_err(|error| format!("failed to commit bestie clear: {error}"))
+}
+
+/// Whether the same agent is still designated after an asynchronous operation.
+pub fn assignment_matches(conn: &Connection, agent_pubkey: &str) -> Result<bool, String> {
+    ensure_table(conn)?;
+    let normalized = agent_pubkey.trim().to_ascii_lowercase();
+    Ok(get_assignment(conn)?.is_some_and(|assignment| assignment.agent_pubkey == normalized))
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+struct ScopedAssignment {
+    agent_pubkey: String,
+    path: PathBuf,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct AssignmentRecoveryJournal {
+    assignments: Vec<ScopedAssignment>,
+    version: u8,
+}
+
+fn recovery_journal_path(base_dir: &Path) -> PathBuf {
+    base_dir.join(RECOVERY_JOURNAL_FILE)
+}
+
+fn persist_recovery_journal(
+    base_dir: &Path,
+    assignments: &[ScopedAssignment],
+) -> Result<(), String> {
+    fs::create_dir_all(base_dir)
+        .map_err(|error| format!("failed to create agents directory: {error}"))?;
+    let payload = serde_json::to_vec_pretty(&AssignmentRecoveryJournal {
+        assignments: assignments.to_vec(),
+        version: 1,
+    })
+    .map_err(|error| format!("failed to serialize Bestie recovery journal: {error}"))?;
+    atomic_write_json_restricted(&recovery_journal_path(base_dir), &payload)
+        .map_err(|error| format!("failed to persist Bestie recovery journal: {error}"))
+}
+
+fn load_recovery_journal(base_dir: &Path) -> Result<Option<AssignmentRecoveryJournal>, String> {
+    let path = recovery_journal_path(base_dir);
+    let payload = match fs::read(&path) {
+        Ok(payload) => payload,
+        Err(error) if error.kind() == ErrorKind::NotFound => return Ok(None),
+        Err(error) => {
+            return Err(format!(
+                "failed to read Bestie recovery journal {}: {error}",
+                path.display()
+            ))
+        }
+    };
+    let journal: AssignmentRecoveryJournal = serde_json::from_slice(&payload)
+        .map_err(|error| format!("failed to parse Bestie recovery journal: {error}"))?;
+    if journal.version != 1 {
+        return Err(format!(
+            "unsupported Bestie recovery journal version {}",
+            journal.version
+        ));
+    }
+    let retention_dir = base_dir.join("retention");
+    for assignment in &journal.assignments {
+        if assignment.path.parent() != Some(retention_dir.as_path())
+            || assignment.path.extension().and_then(|value| value.to_str()) != Some("db")
+        {
+            return Err(format!(
+                "Bestie recovery journal contains an invalid retention path: {}",
+                assignment.path.display()
+            ));
+        }
+    }
+    Ok(Some(journal))
+}
+
+fn remove_recovery_journal(base_dir: &Path) -> Result<(), String> {
+    let path = recovery_journal_path(base_dir);
+    match fs::remove_file(&path) {
+        Ok(()) => Ok(()),
+        Err(error) if error.kind() == ErrorKind::NotFound => Ok(()),
+        Err(error) => Err(format!(
+            "failed to remove Bestie recovery journal {}: {error}",
+            path.display()
+        )),
+    }
+}
+
+fn retention_db_paths(base_dir: &Path) -> Result<Vec<PathBuf>, String> {
+    let retention_dir = base_dir.join("retention");
+    let entries = match fs::read_dir(&retention_dir) {
+        Ok(entries) => entries,
+        Err(error) if error.kind() == ErrorKind::NotFound => return Ok(Vec::new()),
+        Err(error) => {
+            return Err(format!(
+                "failed to read retention directory {}: {error}",
+                retention_dir.display()
+            ))
+        }
+    };
+
+    let mut paths = Vec::new();
+    for entry in entries {
+        let entry = entry.map_err(|error| {
+            format!(
+                "failed to inspect retention directory {}: {error}",
+                retention_dir.display()
+            )
+        })?;
+        let path = entry.path();
+        if path.extension().and_then(|extension| extension.to_str()) != Some("db") {
+            continue;
+        }
+        paths.push(path);
+    }
+    paths.sort();
+    Ok(paths)
+}
+
+fn matching_assignments(
+    base_dir: &Path,
+    agent_pubkey: &str,
+) -> Result<Vec<ScopedAssignment>, String> {
+    let normalized = agent_pubkey.trim().to_ascii_lowercase();
+    let mut assignments = Vec::new();
+    // Read and validate every scope before mutating any of them. A broken later
+    // database therefore cannot leave an already-cleared prefix behind.
+    for path in retention_db_paths(base_dir)? {
+        let conn = open_retention_db(&path)?;
+        ensure_table(&conn)?;
+        if assignment_matches(&conn, &normalized)? {
+            assignments.push(ScopedAssignment {
+                agent_pubkey: normalized.clone(),
+                path,
+            });
+        }
+    }
+    Ok(assignments)
+}
+
+fn clear_scope(assignment: &ScopedAssignment) -> Result<(), String> {
+    let conn = open_retention_db(&assignment.path)?;
+    conn.execute(
+        "DELETE FROM bestie_assignments WHERE singleton = 1 AND agent_pubkey = ?1",
+        params![assignment.agent_pubkey],
+    )
+    .map_err(|error| {
+        format!(
+            "failed to clear bestie assignment in {}: {error}",
+            assignment.path.display()
+        )
+    })?;
+    Ok(())
+}
+
+fn apply_to_assignments(
+    assignments: &[ScopedAssignment],
+    mut apply: impl FnMut(&ScopedAssignment) -> Result<(), String>,
+    action: &str,
+) -> Result<(), String> {
+    let mut failures = Vec::new();
+    for assignment in assignments {
+        if let Err(error) = apply(assignment) {
+            failures.push(format!("{}: {error}", assignment.path.display()));
+        }
+    }
+    if failures.is_empty() {
+        Ok(())
+    } else {
+        Err(format!(
+            "failed to {action} Bestie assignments: {}",
+            failures.join("; ")
+        ))
+    }
+}
+
+fn restore_scope(assignment: &ScopedAssignment) -> Result<(), String> {
+    let mut conn = open_retention_db(&assignment.path)?;
+    replace_assignment(&mut conn, &assignment.agent_pubkey).map(|_| ())
+}
+
+fn restore_assignments(assignments: &[ScopedAssignment]) -> Result<(), String> {
+    apply_to_assignments(assignments, restore_scope, "restore")
+}
+
+/// Replay a durable interrupted-deletion journal.
+///
+/// The managed-agent store is authoritative for which side of the operation
+/// committed: a retained agent gets its exact pre-delete assignments restored;
+/// an absent agent gets those exact assignments cleared. The journal is only
+/// removed after every scope reaches that deterministic state.
+pub fn recover_pending_assignment_cleanup(
+    base_dir: &Path,
+    agent_exists: impl FnOnce(&str) -> bool,
+) -> Result<(), String> {
+    let Some(journal) = load_recovery_journal(base_dir)? else {
+        return Ok(());
+    };
+    let agent_pubkey = journal
+        .assignments
+        .first()
+        .map(|assignment| assignment.agent_pubkey.as_str())
+        .ok_or_else(|| "Bestie recovery journal contains no assignments".to_string())?;
+    if journal
+        .assignments
+        .iter()
+        .any(|assignment| assignment.agent_pubkey != agent_pubkey)
+    {
+        return Err("Bestie recovery journal contains multiple agents".to_string());
+    }
+    if agent_exists(agent_pubkey) {
+        restore_assignments(&journal.assignments)?;
+    } else {
+        apply_to_assignments(&journal.assignments, clear_scope, "clear")?;
+    }
+    remove_recovery_journal(base_dir)
+}
+
+fn clear_scoped_assignments(
+    assignments: &[ScopedAssignment],
+    mut clear: impl FnMut(&ScopedAssignment) -> Result<(), String>,
+) -> Result<(), String> {
+    for assignment in assignments {
+        clear(assignment)?;
+    }
+    Ok(())
+}
+
+fn rollback_with_journal<T>(
+    base_dir: &Path,
+    assignments: &[ScopedAssignment],
+    error: String,
+    restore: impl FnMut(&ScopedAssignment) -> Result<(), String>,
+) -> Result<T, String> {
+    match apply_to_assignments(assignments, restore, "restore") {
+        Ok(()) => match remove_recovery_journal(base_dir) {
+            Ok(()) => Err(error),
+            Err(journal_error) => Err(format!("{error}; {journal_error}")),
+        },
+        Err(restore_error) => Err(format!("{error}; {restore_error}")),
+    }
+}
+
+fn with_agent_assignments_cleared_using<T>(
+    base_dir: &Path,
+    agent_pubkey: &str,
+    delete: impl FnOnce() -> Result<T, String>,
+    clear: impl FnMut(&ScopedAssignment) -> Result<(), String>,
+    mut restore: impl FnMut(&ScopedAssignment) -> Result<(), String>,
+) -> Result<T, String> {
+    if load_recovery_journal(base_dir)?.is_some() {
+        return Err("pending Bestie assignment recovery must complete before deletion".to_string());
+    }
+    let assignments = matching_assignments(base_dir, agent_pubkey)?;
+    if assignments.is_empty() {
+        return delete();
+    }
+    persist_recovery_journal(base_dir, &assignments)?;
+    if let Err(error) = clear_scoped_assignments(&assignments, clear) {
+        return rollback_with_journal(base_dir, &assignments, error, &mut restore);
+    }
+    match delete() {
+        Ok(value) => {
+            if let Err(error) = remove_recovery_journal(base_dir) {
+                // The authoritative managed-agent write already committed.
+                // Keep the journal as a durable cleanup record; launch/command
+                // recovery will observe the absent agent, re-clear these exact
+                // scopes idempotently, and retry journal removal.
+                eprintln!("buzz-desktop: {error}; cleanup will retry");
+            }
+            Ok(value)
+        }
+        Err(error) => rollback_with_journal(base_dir, &assignments, error, &mut restore),
+    }
+}
+
+/// Run agent deletion work with this agent's community-scoped Bestie
+/// assignments temporarily cleared.
+///
+/// Call this while holding `managed_agents_store_lock`. Every matching scope is
+/// snapshotted before the first write. A partial clear, or any later stop/save
+/// failure returned by `delete`, restores the snapshot before the error is
+/// propagated. Assignments remain cleared only when `delete` succeeds.
+pub fn with_agent_assignments_cleared<T>(
+    base_dir: &Path,
+    agent_pubkey: &str,
+    delete: impl FnOnce() -> Result<T, String>,
+) -> Result<T, String> {
+    with_agent_assignments_cleared_using(base_dir, agent_pubkey, delete, clear_scope, restore_scope)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn connection() -> Connection {
+        Connection::open_in_memory().unwrap_or_else(|error| panic!("open test db: {error}"))
+    }
+
+    #[test]
+    fn assignment_is_singleton_and_idempotent() {
+        let mut conn = connection();
+        let first = replace_assignment(&mut conn, &"A".repeat(64))
+            .unwrap_or_else(|error| panic!("assign first: {error}"));
+        assert_eq!(first.agent_pubkey, "a".repeat(64));
+
+        let same = replace_assignment(&mut conn, &"a".repeat(64))
+            .unwrap_or_else(|error| panic!("reassign same: {error}"));
+        assert_eq!(same.agent_pubkey, "a".repeat(64));
+
+        let replaced = replace_assignment(&mut conn, &"b".repeat(64))
+            .unwrap_or_else(|error| panic!("replace: {error}"));
+        assert_eq!(replaced.agent_pubkey, "b".repeat(64));
+    }
+
+    #[test]
+    fn stale_resolver_is_fenced_after_replace_and_clear_is_idempotent() {
+        let mut conn = connection();
+        replace_assignment(&mut conn, &"a".repeat(64))
+            .unwrap_or_else(|error| panic!("assign: {error}"));
+        replace_assignment(&mut conn, &"b".repeat(64))
+            .unwrap_or_else(|error| panic!("replace: {error}"));
+        assert!(!assignment_matches(&conn, &"a".repeat(64))
+            .unwrap_or_else(|error| panic!("check stale assignment: {error}")));
+        clear_assignment(&mut conn).unwrap_or_else(|error| panic!("clear: {error}"));
+        clear_assignment(&mut conn).unwrap_or_else(|error| panic!("clear again: {error}"));
+        assert_eq!(
+            get_assignment(&conn).unwrap_or_else(|error| panic!("read: {error}")),
+            None
+        );
+    }
+
+    #[test]
+    fn deleting_agent_clears_every_matching_scope_and_preserves_other_assignments() {
+        let dir = tempfile::tempdir().unwrap_or_else(|error| panic!("temp dir: {error}"));
+        let retention_dir = dir.path().join("retention");
+        fs::create_dir_all(&retention_dir)
+            .unwrap_or_else(|error| panic!("create retention dir: {error}"));
+        let agent = "a".repeat(64);
+        let other = "b".repeat(64);
+        let first_path = retention_dir.join("first.db");
+        let second_path = retention_dir.join("second.db");
+        let third_path = retention_dir.join("third.db");
+        replace_assignment(
+            &mut open_retention_db(&first_path)
+                .unwrap_or_else(|error| panic!("open first db: {error}")),
+            &agent,
+        )
+        .unwrap_or_else(|error| panic!("assign first scope: {error}"));
+        replace_assignment(
+            &mut open_retention_db(&second_path)
+                .unwrap_or_else(|error| panic!("open second db: {error}")),
+            &agent,
+        )
+        .unwrap_or_else(|error| panic!("assign second scope: {error}"));
+        replace_assignment(
+            &mut open_retention_db(&third_path)
+                .unwrap_or_else(|error| panic!("open third db: {error}")),
+            &other,
+        )
+        .unwrap_or_else(|error| panic!("assign third scope: {error}"));
+
+        with_agent_assignments_cleared(dir.path(), &agent, || Ok(()))
+            .unwrap_or_else(|error| panic!("clear agent assignments: {error}"));
+        assert_eq!(
+            get_assignment(
+                &open_retention_db(&first_path)
+                    .unwrap_or_else(|error| panic!("reopen first db: {error}"))
+            )
+            .unwrap_or_else(|error| panic!("read first scope: {error}")),
+            None
+        );
+        assert_eq!(
+            get_assignment(
+                &open_retention_db(&third_path)
+                    .unwrap_or_else(|error| panic!("reopen third db: {error}"))
+            )
+            .unwrap_or_else(|error| panic!("read third scope: {error}"))
+            .map(|assignment| assignment.agent_pubkey),
+            Some(other)
+        );
+    }
+
+    #[test]
+    fn later_scope_clear_failure_restores_the_already_cleared_prefix() {
+        let dir = tempfile::tempdir().unwrap_or_else(|error| panic!("temp dir: {error}"));
+        let retention_dir = dir.path().join("retention");
+        fs::create_dir_all(&retention_dir)
+            .unwrap_or_else(|error| panic!("create retention dir: {error}"));
+        let agent = "a".repeat(64);
+        for name in ["first.db", "second.db"] {
+            replace_assignment(
+                &mut open_retention_db(&retention_dir.join(name))
+                    .unwrap_or_else(|error| panic!("open {name}: {error}")),
+                &agent,
+            )
+            .unwrap_or_else(|error| panic!("assign {name}: {error}"));
+        }
+
+        let result = with_agent_assignments_cleared_using(
+            dir.path(),
+            &agent,
+            || Ok(()),
+            |assignment| {
+                if assignment.path.ends_with("second.db") {
+                    Err("injected later retention DB failure".to_string())
+                } else {
+                    clear_scope(assignment)
+                }
+            },
+            restore_scope,
+        );
+
+        assert!(result.is_err());
+        for name in ["first.db", "second.db"] {
+            let conn = open_retention_db(&retention_dir.join(name))
+                .unwrap_or_else(|error| panic!("reopen {name}: {error}"));
+            assert!(assignment_matches(&conn, &agent)
+                .unwrap_or_else(|error| panic!("read {name}: {error}")));
+        }
+    }
+
+    fn assert_later_deletion_failure_restores_assignment(failure: &str) {
+        let dir = tempfile::tempdir().unwrap_or_else(|error| panic!("temp dir: {error}"));
+        let retention_dir = dir.path().join("retention");
+        fs::create_dir_all(&retention_dir)
+            .unwrap_or_else(|error| panic!("create retention dir: {error}"));
+        let path = retention_dir.join("owner.db");
+        let agent = "a".repeat(64);
+        replace_assignment(
+            &mut open_retention_db(&path)
+                .unwrap_or_else(|error| panic!("open assignment db: {error}")),
+            &agent,
+        )
+        .unwrap_or_else(|error| panic!("assign agent: {error}"));
+
+        let result = with_agent_assignments_cleared(dir.path(), &agent, || {
+            Err::<(), _>(failure.to_string())
+        });
+
+        assert_eq!(result, Err(failure.to_string()));
+        let conn = open_retention_db(&path)
+            .unwrap_or_else(|error| panic!("reopen assignment db: {error}"));
+        assert!(assignment_matches(&conn, &agent)
+            .unwrap_or_else(|error| panic!("read restored assignment: {error}")));
+    }
+
+    #[test]
+    fn stop_failure_after_cleanup_restores_assignment() {
+        assert_later_deletion_failure_restores_assignment("injected stop failure");
+    }
+
+    #[test]
+    fn save_failure_after_cleanup_restores_assignment() {
+        assert_later_deletion_failure_restores_assignment("injected save failure");
+    }
+
+    #[test]
+    fn failed_rollback_leaves_a_durable_journal_that_repairs_on_restart() {
+        let dir = tempfile::tempdir().unwrap_or_else(|error| panic!("temp dir: {error}"));
+        let retention_dir = dir.path().join("retention");
+        fs::create_dir_all(&retention_dir)
+            .unwrap_or_else(|error| panic!("create retention dir: {error}"));
+        let agent = "a".repeat(64);
+        let first_path = retention_dir.join("first.db");
+        let second_path = retention_dir.join("second.db");
+        for path in [&first_path, &second_path] {
+            replace_assignment(
+                &mut open_retention_db(path)
+                    .unwrap_or_else(|error| panic!("open {}: {error}", path.display())),
+                &agent,
+            )
+            .unwrap_or_else(|error| panic!("assign {}: {error}", path.display()));
+        }
+
+        let result = with_agent_assignments_cleared_using(
+            dir.path(),
+            &agent,
+            || Err::<(), _>("injected managed-agent save failure".to_string()),
+            clear_scope,
+            |assignment| {
+                if assignment.path == second_path {
+                    Err("injected restore failure".to_string())
+                } else {
+                    restore_scope(assignment)
+                }
+            },
+        );
+
+        assert!(result
+            .as_ref()
+            .is_err_and(|error| error.contains("injected restore failure")));
+        assert!(recovery_journal_path(dir.path()).exists());
+        assert!(!assignment_matches(
+            &open_retention_db(&second_path)
+                .unwrap_or_else(|error| panic!("reopen second scope: {error}")),
+            &agent,
+        )
+        .unwrap_or_else(|error| panic!("read torn scope: {error}")));
+
+        recover_pending_assignment_cleanup(dir.path(), |pubkey| pubkey == agent)
+            .unwrap_or_else(|error| panic!("replay durable recovery: {error}"));
+
+        for path in [&first_path, &second_path] {
+            assert!(assignment_matches(
+                &open_retention_db(path)
+                    .unwrap_or_else(|error| panic!("reopen {}: {error}", path.display())),
+                &agent,
+            )
+            .unwrap_or_else(|error| panic!("read repaired {}: {error}", path.display())));
+        }
+        assert!(!recovery_journal_path(dir.path()).exists());
+    }
+}
diff --git a/desktop/src-tauri/src/managed_agents/mod.rs b/desktop/src-tauri/src/managed_agents/mod.rs
index 392059dfb6c..a66f9c75ba2 100644
--- a/desktop/src-tauri/src/managed_agents/mod.rs
+++ b/desktop/src-tauri/src/managed_agents/mod.rs
@@ -11,6 +11,7 @@ pub(crate) use agent_env::{
 mod agent_description;
 pub(crate) use agent_description::{effective_agent_description, record_effective_description};
 mod backend;
+pub(crate) mod bestie_assignment;
 pub(crate) mod claude_config;
 pub(crate) mod config_bridge;
 pub(crate) mod custom_harnesses;
diff --git a/desktop/src-tauri/src/managed_agents/restore.rs b/desktop/src-tauri/src/managed_agents/restore.rs
index bbda1e7c860..1d7fb34120e 100644
--- a/desktop/src-tauri/src/managed_agents/restore.rs
+++ b/desktop/src-tauri/src/managed_agents/restore.rs
@@ -1,5 +1,6 @@
 use super::{
-    find_managed_agent_mut, kill_stale_tracked_processes, load_managed_agents, load_personas,
+    bestie_assignment::recover_pending_assignment_cleanup, find_managed_agent_mut,
+    kill_stale_tracked_processes, load_managed_agents, load_personas, managed_agents_base_dir,
     save_managed_agents, spawn_agent_child, sync_managed_agent_processes, BackendKind,
     ManagedAgentProcess,
 };
@@ -114,6 +115,11 @@ pub async fn restore_managed_agents_on_launch(
         }
 
         let mut records = load_managed_agents(app)?;
+        recover_pending_assignment_cleanup(&managed_agents_base_dir(app)?, |pending_pubkey| {
+            records
+                .iter()
+                .any(|record| record.pubkey.eq_ignore_ascii_case(pending_pubkey))
+        })?;
         let mut runtimes = state
             .managed_agent_processes
             .lock()
diff --git a/desktop/src/app/AppShell.tsx b/desktop/src/app/AppShell.tsx
index eb5ab5a95d8..57cd1554b4e 100644
--- a/desktop/src/app/AppShell.tsx
+++ b/desktop/src/app/AppShell.tsx
@@ -1,4 +1,5 @@
 import * as React from "react";
+import { ProtectedGlobalOverlay } from "@protected-feature-components";
 import { useQueryClient } from "@tanstack/react-query";
 import { Outlet, useLocation } from "@tanstack/react-router";
 import { deriveShellRoute, markAllReadSources } from "@/app/AppShell.helpers";
@@ -986,6 +987,7 @@ export function AppShell() {
                     onOpenChange={setIsSendFeedbackOpen}
                     open={isSendFeedbackOpen}
                   />
+                  {!isHuddleRoom ? <ProtectedGlobalOverlay /> : null}
                 </AppWorkflowEditorOverlayProvider>
               </AppProfilePanelProvider>
             </SidebarProvider>
diff --git a/desktop/src/features/agents/ui/AgentIdentityCard.tsx b/desktop/src/features/agents/ui/AgentIdentityCard.tsx
index bd67def785f..60d16c833eb 100644
--- a/desktop/src/features/agents/ui/AgentIdentityCard.tsx
+++ b/desktop/src/features/agents/ui/AgentIdentityCard.tsx
@@ -9,6 +9,7 @@ type AgentIdentityCardProps = {
   ariaLabel: string;
   avatar?: ReactNode;
   avatarUrl?: string | null;
+  footerAccessory?: ReactNode;
   dataTestId: string;
   label: string;
   /**
@@ -28,6 +29,7 @@ export function AgentIdentityCard({
   avatar,
   avatarUrl,
   dataTestId,
+  footerAccessory,
   label,
   subtitle,
   onClick,
@@ -74,20 +76,25 @@ export function AgentIdentityCard({
         <div className="absolute top-3 right-3 z-40">{actions}</div>
       ) : null}
 
-      <div className="pointer-events-none absolute right-3 bottom-3 left-3 z-30 flex min-w-0 flex-col gap-0.5 text-left text-sm leading-5">
-        <span className="min-w-0 truncate font-semibold text-foreground tracking-normal">
-          {label}
-        </span>
-        {subtitle ? (
-          <span className="line-clamp-2 min-w-0 text-xs font-normal text-muted-foreground">
-            {subtitle}
+      <div className="pointer-events-none absolute right-3 bottom-3 left-3 z-30 flex min-w-0 items-end gap-2 text-left text-sm leading-5">
+        <div className="flex min-w-0 flex-1 flex-col gap-0.5">
+          <span className="min-w-0 truncate font-semibold text-foreground tracking-normal">
+            {label}
           </span>
-        ) : null}
-        {/* pointer-events-auto: the overlay button above has pointer-events-none
-            on this container, but the status badge itself (a sibling of the button
-            in z-order) needs hover so the restart diff tooltip can fire. */}
-        {statusBadge ? (
-          <div className="pointer-events-auto">{statusBadge}</div>
+          {subtitle ? (
+            <span className="line-clamp-2 min-w-0 text-xs font-normal text-muted-foreground">
+              {subtitle}
+            </span>
+          ) : null}
+          {/* pointer-events-auto: the overlay button above has pointer-events-none
+              on this container, but the status badge itself (a sibling of the button
+              in z-order) needs hover so the restart diff tooltip can fire. */}
+          {statusBadge ? (
+            <div className="pointer-events-auto">{statusBadge}</div>
+          ) : null}
+        </div>
+        {footerAccessory ? (
+          <div className="shrink-0">{footerAccessory}</div>
         ) : null}
       </div>
     </div>
diff --git a/desktop/src/features/agents/ui/UnifiedAgentsSection.tsx b/desktop/src/features/agents/ui/UnifiedAgentsSection.tsx
index 36f950d4c59..8b914e76343 100644
--- a/desktop/src/features/agents/ui/UnifiedAgentsSection.tsx
+++ b/desktop/src/features/agents/ui/UnifiedAgentsSection.tsx
@@ -16,6 +16,10 @@ import type { AgentPersona, ManagedAgent } from "@/shared/api/types";
 import type { ProfilePanelOpenOptions } from "@/shared/context/ProfilePanelContext";
 import { useFeedbackToasts } from "@/shared/hooks/useToastEffect";
 import { Badge } from "@/shared/ui/badge";
+import {
+  ProtectedBestieCardBadge,
+  useProtectedBestiePubkey,
+} from "@protected-feature-components";
 import { IdentityCardSkeleton } from "@/shared/ui/identity-card-skeleton";
 import { AgentIdentityCard } from "./AgentIdentityCard";
 import { AgentRuntimeAvatarControl } from "./AgentRuntimeAvatarControl";
@@ -97,6 +101,7 @@ export function UnifiedAgentsSection(props: UnifiedAgentsSectionProps) {
   } = props;
 
   const isArchived = useIsArchivedPredicate();
+  const bestiePubkey = useProtectedBestiePubkey(agents)?.toLowerCase() ?? null;
   const { groups, ungrouped, unknown } = React.useMemo(
     () => buildUnifiedGroups(personas, agents, isArchived),
     [personas, agents, isArchived],
@@ -154,6 +159,7 @@ export function UnifiedAgentsSection(props: UnifiedAgentsSectionProps) {
                   )}
                   agent={profileAgent}
                   defaultModel={defaultModel}
+                  isBestie={profileAgent?.pubkey.toLowerCase() === bestiePubkey}
                   key={group.persona.id}
                   persona={group.persona}
                   restartingAgentPubkey={restartingAgentPubkey}
@@ -175,6 +181,7 @@ export function UnifiedAgentsSection(props: UnifiedAgentsSectionProps) {
               collapsed={collapsed}
               defaultModel={defaultModel}
               groupKey="__unknown__"
+              bestiePubkey={bestiePubkey}
               label="Unknown agents"
               restartingAgentPubkey={restartingAgentPubkey}
               startingAgentPubkey={startingAgentPubkey}
@@ -190,6 +197,7 @@ export function UnifiedAgentsSection(props: UnifiedAgentsSectionProps) {
               collapsed={collapsed}
               defaultModel={defaultModel}
               groupKey="__ungrouped__"
+              bestiePubkey={bestiePubkey}
               label="Custom agents"
               restartingAgentPubkey={restartingAgentPubkey}
               startingAgentPubkey={startingAgentPubkey}
@@ -224,6 +232,7 @@ function AgentPersonaCard({
   actions,
   agent,
   defaultModel,
+  isBestie,
   persona,
   restartingAgentPubkey,
   startingAgentPubkey,
@@ -240,6 +249,7 @@ function AgentPersonaCard({
   ) => React.ReactNode;
   agent: ManagedAgent | undefined;
   defaultModel: string;
+  isBestie: boolean;
   persona: AgentPersona;
   restartingAgentPubkey: string | null;
   startingAgentPubkey: string | null;
@@ -316,6 +326,11 @@ function AgentPersonaCard({
       }
       avatarUrl={avatarUrl}
       dataTestId={`persona-agent-row-${persona.id}`}
+      footerAccessory={
+        agent ? (
+          <ProtectedBestieCardBadge agent={agent} isBestie={isBestie} />
+        ) : null
+      }
       label={title}
       subtitle={subtitle}
       onClick={() => {
@@ -344,6 +359,7 @@ function AgentPersonaCard({
 
 function StandaloneAgentCard({
   agent,
+  isBestie,
   defaultModel,
   restartingAgentPubkey,
   startingAgentPubkey,
@@ -352,6 +368,7 @@ function StandaloneAgentCard({
   onStartAgent,
 }: {
   agent: ManagedAgent;
+  isBestie: boolean;
   defaultModel: string;
   restartingAgentPubkey: string | null;
   startingAgentPubkey: string | null;
@@ -398,6 +415,9 @@ function StandaloneAgentCard({
       }
       avatarUrl={profileQuery.data?.avatarUrl}
       dataTestId={`managed-agent-${agent.pubkey}`}
+      footerAccessory={
+        <ProtectedBestieCardBadge agent={agent} isBestie={isBestie} />
+      }
       label={title}
       subtitle={
         // Definition-less instance: no authored description exists, so fall
@@ -450,6 +470,7 @@ function CollapsibleAgentGroup({
   groupKey,
   label,
   agents,
+  bestiePubkey,
   collapsed,
   defaultModel,
   restartingAgentPubkey,
@@ -462,6 +483,7 @@ function CollapsibleAgentGroup({
   groupKey: string;
   label: string;
   agents: ManagedAgent[];
+  bestiePubkey: string | null;
   collapsed: ReadonlySet<string>;
   defaultModel: string;
   restartingAgentPubkey: string | null;
@@ -496,6 +518,7 @@ function CollapsibleAgentGroup({
             <StandaloneAgentCard
               agent={agent}
               defaultModel={defaultModel}
+              isBestie={agent.pubkey.toLowerCase() === bestiePubkey}
               key={agent.pubkey}
               restartingAgentPubkey={restartingAgentPubkey}
               startingAgentPubkey={startingAgentPubkey}
diff --git a/desktop/src/features/messages/ui/MessageActionBar.tsx b/desktop/src/features/messages/ui/MessageActionBar.tsx
index 02dcdcaf6d1..b6fb3d11abf 100644
--- a/desktop/src/features/messages/ui/MessageActionBar.tsx
+++ b/desktop/src/features/messages/ui/MessageActionBar.tsx
@@ -49,6 +49,7 @@ import {
 import { isPositiveEmojiParticle } from "@/shared/ui/EmojiBurstProvider";
 import { Popover, PopoverContent, PopoverTrigger } from "@/shared/ui/popover";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
+import { ProtectedMessageAction } from "@protected-feature-components";
 
 const ACTION_BUTTON_CLASS = "h-8 w-8 rounded-full p-0";
 const ACTION_ICON_CLASS = "!h-4 !w-4";
@@ -562,6 +563,8 @@ export const MessageActionBar = React.memo(function MessageActionBar({
             </Popover>
           ) : null}
 
+          <ProtectedMessageAction channelId={channelId} message={message} />
+
           {hasReactionAction && quickReactionItems.length > 0 ? (
             <div
               aria-hidden="true"
diff --git a/desktop/src/features/messages/ui/TimelineMessageList.tsx b/desktop/src/features/messages/ui/TimelineMessageList.tsx
index d7ef78ea04b..600df0d8c89 100644
--- a/desktop/src/features/messages/ui/TimelineMessageList.tsx
+++ b/desktop/src/features/messages/ui/TimelineMessageList.tsx
@@ -98,6 +98,8 @@ type TimelineMessageListProps = {
   searchMatchingMessageIds?: Set<string>;
   /** The current find-in-channel query string. */
   searchQuery?: string;
+  /** Keep date chips pinned while the timeline scrolls. */
+  stickyDayDividers?: boolean;
   /** Per-thread unread counts keyed by thread root id. */
   threadUnreadCounts?: ReadonlyMap<string, number>;
   /** Content rendered as the first virtual row before channel history. */
@@ -154,6 +156,7 @@ export const TimelineMessageList = React.memo(function TimelineMessageList({
   searchActiveMessageId = null,
   searchMatchingMessageIds,
   searchQuery,
+  stickyDayDividers = true,
   threadUnreadCounts,
   unfollowThreadById,
   leadingContent,
@@ -352,7 +355,10 @@ export const TimelineMessageList = React.memo(function TimelineMessageList({
           key={group.key}
         >
           {hideDayDividers || group.headingTimestamp === null ? null : (
-            <DayDivider label={formatDayGroupLabel(group.headingTimestamp)} />
+            <DayDivider
+              label={formatDayGroupLabel(group.headingTimestamp)}
+              sticky={stickyDayDividers}
+            />
           )}
           {group.items.map((item) => (
             <TimelineRowShell item={item} key={getTimelineItemKey(item)}>
diff --git a/desktop/src/features/profile/ui/UserProfileAgentManagementRows.tsx b/desktop/src/features/profile/ui/UserProfileAgentManagementRows.tsx
index 7b8a586224e..b43bb3aa804 100644
--- a/desktop/src/features/profile/ui/UserProfileAgentManagementRows.tsx
+++ b/desktop/src/features/profile/ui/UserProfileAgentManagementRows.tsx
@@ -31,6 +31,7 @@ export function UserProfileAgentManagementRows({
   canDeleteAgent,
   isDeletePending,
   managedAgent,
+  supplementalAction,
   onCreateCard,
   onDeleteAgent,
   onDuplicateAgent,
@@ -41,6 +42,7 @@ export function UserProfileAgentManagementRows({
   canDeleteAgent: boolean;
   isDeletePending: boolean;
   managedAgent?: ManagedAgent;
+  supplementalAction?: React.ReactNode;
   /** Mint an agent trading card. Present only for owner-managed personas. */
   onCreateCard?: () => void;
   onDeleteAgent: () => void;
@@ -51,6 +53,7 @@ export function UserProfileAgentManagementRows({
     !onCreateCard &&
     !onDuplicateAgent &&
     !onExportAgent &&
+    !supplementalAction &&
     !canArchiveAgent &&
     !canDeleteAgent
   ) {
@@ -86,6 +89,7 @@ export function UserProfileAgentManagementRows({
           testId="user-profile-create-card-row"
         />
       ) : null}
+      {supplementalAction}
       {canArchiveAgent ? (
         <ProfileArchiveAgentRow archiveActions={archiveActions} />
       ) : null}
@@ -100,10 +104,11 @@ export function UserProfileAgentManagementRows({
   );
 }
 
-function ProfileAgentActionRow({
+export function ProfileAgentActionRow({
   destructive = false,
   disabled = false,
   icon: Icon,
+  iconClassName,
   label,
   onClick,
   testId,
@@ -111,6 +116,7 @@ function ProfileAgentActionRow({
   destructive?: boolean;
   disabled?: boolean;
   icon: LucideIcon;
+  iconClassName?: string;
   label: string;
   onClick: () => void;
   testId: string;
@@ -125,9 +131,10 @@ function ProfileAgentActionRow({
     >
       <Icon
         className={
-          destructive
+          iconClassName ??
+          (destructive
             ? "h-4 w-4 shrink-0 text-destructive"
-            : "h-4 w-4 shrink-0 text-muted-foreground"
+            : "h-4 w-4 shrink-0 text-muted-foreground")
         }
         data-slot="profile-action-icon"
       />
diff --git a/desktop/src/features/profile/ui/UserProfilePanelTabs.tsx b/desktop/src/features/profile/ui/UserProfilePanelTabs.tsx
index 842ffd58ffb..29bb0980e46 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelTabs.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanelTabs.tsx
@@ -26,6 +26,7 @@ import {
   useProfileActivityFeedScope,
 } from "@/features/profile/lib/profileActivityFeedScope";
 import { UserProfileAgentManagementRows } from "@/features/profile/ui/UserProfileAgentManagementRows";
+import { ProtectedAgentBestieAction } from "@protected-feature-components";
 import { ProfileInstancesSection } from "@/features/profile/ui/ProfileInstancesSection";
 import {
   type ProfileField,
@@ -315,6 +316,11 @@ export function ProfileInfoTabContent({
         onDeleteAgent={onDeleteAgent}
         onDuplicateAgent={onDuplicateAgent}
         onExportAgent={onExportAgent}
+        supplementalAction={
+          managedAgent ? (
+            <ProtectedAgentBestieAction agent={managedAgent} />
+          ) : null
+        }
       />
     </div>
   );
diff --git a/desktop/src/features/sidebar/ui/AppSidebar.tsx b/desktop/src/features/sidebar/ui/AppSidebar.tsx
index 9c7f3cf1661..647ed632644 100644
--- a/desktop/src/features/sidebar/ui/AppSidebar.tsx
+++ b/desktop/src/features/sidebar/ui/AppSidebar.tsx
@@ -73,6 +73,7 @@ import {
   SidebarRail,
   useSidebar,
 } from "@/shared/ui/sidebar";
+import { useProtectedVisibleDirectMessages } from "@protected-feature-components";
 
 export function AppSidebar({
   addCommunityPrefill,
@@ -367,10 +368,14 @@ export function AppSidebar({
       ),
     [channels, sortModeFor],
   );
-  const directMessages = React.useMemo(
+  const allDirectMessages = React.useMemo(
     () => channels.filter((channel) => channel.channelType === "dm"),
     [channels],
   );
+  const directMessages = useProtectedVisibleDirectMessages(
+    allDirectMessages,
+    currentPubkey,
+  );
   const isSelectedDirectMessage =
     selectedView === "channel" &&
     directMessages.some((channel) => channel.id === selectedChannelId);
diff --git a/desktop/src/features/sidebar/ui/AppSidebarPinnedHeader.tsx b/desktop/src/features/sidebar/ui/AppSidebarPinnedHeader.tsx
index a9bf7058eb6..660f7d9a8aa 100644
--- a/desktop/src/features/sidebar/ui/AppSidebarPinnedHeader.tsx
+++ b/desktop/src/features/sidebar/ui/AppSidebarPinnedHeader.tsx
@@ -12,6 +12,7 @@ import {
   SidebarMenuItem,
 } from "@/shared/ui/sidebar";
 import { SidebarMenuLabel } from "@/shared/ui/sidebar-menu-label";
+import { ProtectedBestieSidebarEntry } from "@protected-feature-components";
 
 type SidebarSelectedView =
   | "home"
@@ -167,6 +168,7 @@ export function AppSidebarPrimaryMenu({
               <SidebarMenuLabel>Agents</SidebarMenuLabel>
             </SidebarMenuButton>
           </SidebarMenuItem>
+          <ProtectedBestieSidebarEntry />
           <FeatureGate feature="workflows">
             <SidebarMenuItem>
               <SidebarMenuButton
diff --git a/desktop/src/protectedFeatures/bestie/BestieCardBadge.tsx b/desktop/src/protectedFeatures/bestie/BestieCardBadge.tsx
new file mode 100644
index 00000000000..6a519f2ddf9
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/BestieCardBadge.tsx
@@ -0,0 +1,25 @@
+import { Star } from "lucide-react";
+
+import type { ManagedAgent } from "@/shared/api/types";
+
+export function BestieCardBadge({
+  agent,
+  isBestie,
+}: {
+  agent: ManagedAgent;
+  isBestie: boolean;
+}) {
+  if (!isBestie) return null;
+
+  return (
+    <span
+      aria-label={`${agent.name} is your Bestie`}
+      className="inline-flex shrink-0 items-center justify-center text-foreground opacity-50"
+      data-testid={`bestie-card-badge-${agent.pubkey}`}
+      role="img"
+      title="Bestie"
+    >
+      <Star className="h-4 w-4 fill-current" />
+    </span>
+  );
+}
diff --git a/desktop/src/protectedFeatures/bestie/BestieGlobalOverlay.tsx b/desktop/src/protectedFeatures/bestie/BestieGlobalOverlay.tsx
new file mode 100644
index 00000000000..ccecdc280c6
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/BestieGlobalOverlay.tsx
@@ -0,0 +1,212 @@
+import * as React from "react";
+import { LayoutGroup, motion } from "motion/react";
+import { createPortal } from "react-dom";
+
+import { Bloom } from "./BloomMenu";
+import { BestiePopover, BestieTriggerVisual } from "./BestiePopover";
+import { useBestie } from "./useBestie";
+
+type Point = { x: number; y: number };
+type Placement = {
+  anchor: "start" | "end";
+  direction: "top" | "bottom";
+};
+type DragBounds = {
+  maxX: number;
+  maxY: number;
+  minX: number;
+  minY: number;
+};
+const AVATAR_SIZE = 48;
+const EDGE_INSET = 16;
+const BESTIE_AVATAR_LAYOUT_ID = "bestie-floating-bloom-avatar";
+
+function clampPoint(point: Point): Point {
+  return {
+    x: Math.min(
+      Math.max(EDGE_INSET, point.x),
+      Math.max(EDGE_INSET, window.innerWidth - AVATAR_SIZE - EDGE_INSET),
+    ),
+    y: Math.min(
+      Math.max(EDGE_INSET, point.y),
+      Math.max(EDGE_INSET, window.innerHeight - AVATAR_SIZE - EDGE_INSET),
+    ),
+  };
+}
+
+function initialPoint(): Point {
+  return clampPoint({ x: window.innerWidth - AVATAR_SIZE - 20, y: 52 });
+}
+
+export function BestieGlobalOverlay() {
+  const bestie = useBestie();
+  const [open, setOpen] = React.useState(false);
+  const [placement, setPlacement] = React.useState<Placement | null>(null);
+  const [shareAvatarLayout, setShareAvatarLayout] = React.useState(true);
+  const [dragging, setDragging] = React.useState(false);
+  const [position, setPosition] = React.useState<Point>(initialPoint);
+  const dragRef = React.useRef<
+    | {
+        bounds: DragBounds;
+        moved: boolean;
+        open: boolean;
+        origin: Point;
+        pointerId: number;
+        start: Point;
+      }
+    | undefined
+  >(undefined);
+  const suppressClickRef = React.useRef(false);
+
+  React.useEffect(() => {
+    const handleResize = () => setPosition((current) => clampPoint(current));
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+
+  const currentPlacement: Placement = {
+    direction:
+      position.y > (window.innerHeight - AVATAR_SIZE) / 2 ? "top" : "bottom",
+    anchor:
+      position.x > (window.innerWidth - AVATAR_SIZE) / 2 ? "end" : "start",
+  };
+  const activePlacement = open && placement ? placement : currentPlacement;
+
+  const updateOpen = (nextOpen: boolean) => {
+    setShareAvatarLayout(nextOpen);
+    if (nextOpen) setPlacement(currentPlacement);
+    setOpen(nextOpen);
+  };
+
+  return createPortal(
+    <div
+      className="pointer-events-auto fixed z-[200]"
+      data-testid="bestie-floating-avatar"
+      onPointerCancel={(event) => {
+        const drag = dragRef.current;
+        if (!drag || drag.pointerId !== event.pointerId) return;
+        dragRef.current = undefined;
+        setDragging(false);
+        if (event.currentTarget.hasPointerCapture(event.pointerId)) {
+          event.currentTarget.releasePointerCapture(event.pointerId);
+        }
+      }}
+      onPointerDown={(event) => {
+        if (event.button !== 0) return;
+        const target = event.target as HTMLElement;
+        if (
+          open &&
+          (!target.closest("[data-bestie-drag-handle]") ||
+            target.closest("button, input, textarea, a"))
+        ) {
+          return;
+        }
+        const surface = open
+          ? event.currentTarget
+              .querySelector('[data-testid="bestie-bloom-content"]')
+              ?.getBoundingClientRect()
+          : event.currentTarget.getBoundingClientRect();
+        if (!surface) return;
+        event.preventDefault();
+        event.currentTarget.setPointerCapture(event.pointerId);
+        setDragging(true);
+        setShareAvatarLayout(false);
+        dragRef.current = {
+          bounds: {
+            maxX: window.innerWidth - EDGE_INSET - surface.right,
+            maxY: window.innerHeight - EDGE_INSET - surface.bottom,
+            minX: EDGE_INSET - surface.left,
+            minY: EDGE_INSET - surface.top,
+          },
+          open,
+          pointerId: event.pointerId,
+          origin: position,
+          start: { x: event.clientX, y: event.clientY },
+          moved: false,
+        };
+      }}
+      onPointerMove={(event) => {
+        const drag = dragRef.current;
+        if (!drag || drag.pointerId !== event.pointerId) return;
+        const rawX = event.clientX - drag.start.x;
+        const rawY = event.clientY - drag.start.y;
+        const dx = Math.min(drag.bounds.maxX, Math.max(drag.bounds.minX, rawX));
+        const dy = Math.min(drag.bounds.maxY, Math.max(drag.bounds.minY, rawY));
+        if (Math.hypot(dx, dy) > 4) drag.moved = true;
+        setPosition(
+          clampPoint({ x: drag.origin.x + dx, y: drag.origin.y + dy }),
+        );
+      }}
+      onPointerUp={(event) => {
+        const drag = dragRef.current;
+        if (!drag || drag.pointerId !== event.pointerId) return;
+        if (!drag.open) suppressClickRef.current = drag.moved;
+        dragRef.current = undefined;
+        setDragging(false);
+        if (event.currentTarget.hasPointerCapture(event.pointerId)) {
+          event.currentTarget.releasePointerCapture(event.pointerId);
+        }
+        if (!drag.open && !drag.moved) updateOpen(true);
+      }}
+      style={{
+        left: 0,
+        top: 0,
+        transform: `translate3d(${position.x}px, ${position.y}px, 0)`,
+        willChange: "transform",
+      }}
+    >
+      <LayoutGroup id="bestie-floating-bloom">
+        <Bloom.Root
+          anchor={activePlacement.anchor}
+          direction={activePlacement.direction}
+          onOpenChange={(nextOpen) => {
+            if (nextOpen && suppressClickRef.current) {
+              suppressClickRef.current = false;
+              return;
+            }
+            updateOpen(nextOpen);
+          }}
+          open={open}
+        >
+          <Bloom.Container
+            buttonSize={AVATAR_SIZE}
+            className="border border-border/70 bg-popover text-popover-foreground ring-1 ring-foreground/5"
+            edgeDraggable
+            menuRadius={20}
+            menuWidth={320}
+            motionDisabled={dragging}
+            onMorphAnimationComplete={(isOpen) => {
+              if (isOpen) setShareAvatarLayout(false);
+            }}
+          >
+            <Bloom.Trigger
+              ariaLabel="Open Bestie"
+              className="flex h-12 w-12 touch-none select-none items-center justify-center rounded-full border-0 bg-transparent p-0 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring [&_img]:pointer-events-none"
+            >
+              <motion.div
+                key={shareAvatarLayout ? "shared-avatar" : "static-avatar"}
+                layoutId={
+                  shareAvatarLayout ? BESTIE_AVATAR_LAYOUT_ID : undefined
+                }
+              >
+                <BestieTriggerVisual
+                  agent={bestie.assignedAgent}
+                  imageDraggable={false}
+                />
+              </motion.div>
+            </Bloom.Trigger>
+            <Bloom.Content ariaLabel="Bestie" className="p-4">
+              <BestiePopover
+                avatarLayoutId={
+                  shareAvatarLayout ? BESTIE_AVATAR_LAYOUT_ID : undefined
+                }
+                onRequestClose={() => updateOpen(false)}
+              />
+            </Bloom.Content>
+          </Bloom.Container>
+        </Bloom.Root>
+      </LayoutGroup>
+    </div>,
+    document.body,
+  );
+}
diff --git a/desktop/src/protectedFeatures/bestie/BestieMessageAction.tsx b/desktop/src/protectedFeatures/bestie/BestieMessageAction.tsx
new file mode 100644
index 00000000000..f69e093ad1e
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/BestieMessageAction.tsx
@@ -0,0 +1,46 @@
+import type { TimelineMessage } from "@/features/messages/types";
+import { Button } from "@/shared/ui/button";
+import { Popover, PopoverContent, PopoverTrigger } from "@/shared/ui/popover";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
+import { BestiePopover, BestieTriggerVisual } from "./BestiePopover";
+import { useBestie } from "./useBestie";
+
+export function BestieMessageAction({
+  channelId,
+  message,
+}: {
+  channelId?: string | null;
+  message: TimelineMessage;
+}) {
+  const bestie = useBestie();
+  const [open, setOpen] = React.useState(false);
+  return (
+    <Popover onOpenChange={setOpen} open={open}>
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <PopoverTrigger asChild>
+            <Button
+              aria-label="Ask Bestie about this message"
+              className="h-8 w-8 rounded-full p-0"
+              data-testid={`bestie-message-${message.id}`}
+              size="sm"
+              type="button"
+              variant="ghost"
+            >
+              <BestieTriggerVisual agent={bestie.assignedAgent} compact />
+            </Button>
+          </PopoverTrigger>
+        </TooltipTrigger>
+        <TooltipContent>Ask Bestie</TooltipContent>
+      </Tooltip>
+      <PopoverContent align="end" className="w-80" side="top" sideOffset={10}>
+        <BestiePopover
+          contextChannelId={channelId}
+          contextMessage={message}
+          onRequestClose={() => setOpen(false)}
+        />
+      </PopoverContent>
+    </Popover>
+  );
+}
+import * as React from "react";
diff --git a/desktop/src/protectedFeatures/bestie/BestiePopover.tsx b/desktop/src/protectedFeatures/bestie/BestiePopover.tsx
new file mode 100644
index 00000000000..7a542501acc
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/BestiePopover.tsx
@@ -0,0 +1,496 @@
+import { ArrowUp, Plus, X } from "lucide-react";
+import { motion } from "motion/react";
+import * as React from "react";
+import { toast } from "sonner";
+
+import {
+  useChannelMessagesQuery,
+  useChannelSubscription,
+  useSendMessageMutation,
+  useToggleReactionMutation,
+} from "@/features/messages/hooks";
+import { formatTimelineMessages } from "@/features/messages/lib/formatTimelineMessages";
+import { buildMainTimelineEntries } from "@/features/messages/lib/threadPanel";
+import { useRenderScopedReactionHydration } from "@/features/messages/lib/useRenderScopedReactionHydration";
+import type { TimelineMessage } from "@/features/messages/types";
+import { TimelineMessageList } from "@/features/messages/ui/TimelineMessageList";
+import { ProtectedMessageActionsBoundary } from "@protected-feature-components";
+import { PresenceDot } from "@/features/presence/ui/PresenceBadge";
+import { useProfileQuery } from "@/features/profile/hooks";
+import type { UserProfileLookup } from "@/features/profile/lib/identity";
+import { useIdentityQuery } from "@/shared/api/hooks";
+import type { Channel, ManagedAgent, PresenceStatus } from "@/shared/api/types";
+import {
+  KIND_STREAM_MESSAGE,
+  KIND_STREAM_MESSAGE_V2,
+} from "@/shared/constants/kinds";
+import { cn } from "@/shared/lib/cn";
+import { normalizePubkey } from "@/shared/lib/pubkey";
+import { Button } from "@/shared/ui/button";
+import { Textarea } from "@/shared/ui/textarea";
+import { UserAvatar } from "@/shared/ui/UserAvatar";
+import { buildBestieMessageContext } from "./bestieMessageContext";
+import { useBestie } from "./useBestie";
+
+export function BestieTriggerVisual({
+  agent,
+  className,
+  compact = false,
+  imageDraggable,
+}: {
+  agent: ManagedAgent | null;
+  className?: string;
+  compact?: boolean;
+  imageDraggable?: boolean;
+}) {
+  if (agent) {
+    return (
+      <UserAvatar
+        avatarUrl={agent.avatarUrl}
+        className={cn(compact ? "h-6 w-6" : "h-10 w-10", className)}
+        displayName={agent.name}
+        fallbackDelayMs={0}
+        imageDraggable={imageDraggable}
+        size={compact ? "sm" : "md"}
+        testId="bestie-trigger-avatar"
+      />
+    );
+  }
+
+  return (
+    <Plus
+      aria-hidden="true"
+      className={cn(compact ? "h-4 w-4" : "h-5 w-5", className)}
+      data-testid="bestie-empty-mark"
+    />
+  );
+}
+
+export function BestieAgentLockup({
+  agent,
+  avatarLayoutId,
+  presenceStatus,
+  compact = false,
+}: {
+  agent: ManagedAgent;
+  avatarLayoutId?: string;
+  presenceStatus: PresenceStatus;
+  compact?: boolean;
+}) {
+  return (
+    <div className="flex min-w-0 items-center gap-2.5">
+      <motion.div
+        aria-hidden="true"
+        className="relative shrink-0"
+        data-testid="bestie-agent-avatar"
+        layoutId={avatarLayoutId}
+      >
+        <UserAvatar
+          avatarUrl={agent.avatarUrl}
+          className={compact ? "h-5 w-5" : "h-8 w-8"}
+          displayName={agent.name}
+          fallbackDelayMs={0}
+          size={compact ? "xs" : "sm"}
+        />
+        <span
+          className={cn(
+            "absolute flex items-center justify-center rounded-full",
+            compact
+              ? "-bottom-0.5 -right-0.5 h-2.5 w-2.5 bg-sidebar"
+              : "-bottom-0.5 -right-0.5 h-3.5 w-3.5 bg-popover",
+          )}
+        >
+          <PresenceDot
+            className={compact ? "h-1.5 w-1.5" : "h-2 w-2"}
+            data-testid="bestie-activity-dot"
+            status={presenceStatus}
+          />
+        </span>
+      </motion.div>
+      <span className="min-w-0 truncate text-sm font-medium">{agent.name}</span>
+      <span className="sr-only">{presenceStatus}</span>
+    </div>
+  );
+}
+
+function EmptyBestie() {
+  return (
+    <div className="flex min-h-32 flex-col items-center justify-center gap-3 px-4 text-center">
+      <div className="flex h-10 w-10 items-center justify-center rounded-full bg-muted text-muted-foreground">
+        <Plus aria-hidden="true" className="h-5 w-5" />
+      </div>
+      <div>
+        <h2 className="text-sm font-semibold">Choose a Bestie</h2>
+        <p className="mt-1 text-xs text-muted-foreground">
+          Open one of your local agents and turn on Bestie.
+        </p>
+      </div>
+    </div>
+  );
+}
+
+function BestieConversationTranscript({
+  channel,
+  currentPubkey,
+  messages,
+  onToggleReaction,
+  profiles,
+}: {
+  channel: Channel;
+  currentPubkey: string | undefined;
+  messages: TimelineMessage[];
+  onToggleReaction: (
+    message: TimelineMessage,
+    emoji: string,
+    remove: boolean,
+  ) => Promise<void>;
+  profiles: UserProfileLookup;
+}) {
+  const transcriptRef = React.useRef<HTMLDivElement>(null);
+  const latestMessageKey = messages.at(-1)?.renderKey ?? messages.at(-1)?.id;
+  const mainTimelineEntries = React.useMemo(
+    () => buildMainTimelineEntries(messages, undefined, undefined, profiles),
+    [messages, profiles],
+  );
+  useRenderScopedReactionHydration({
+    activeChannel: channel,
+    mainTimelineEntries,
+    threadHeadMessage: null,
+    threadMessages: [],
+  });
+
+  React.useLayoutEffect(() => {
+    if (!latestMessageKey) return;
+    const transcript = transcriptRef.current;
+    if (!transcript) return;
+    transcript.scrollTop = transcript.scrollHeight;
+  }, [latestMessageKey]);
+
+  return (
+    <div
+      aria-live="polite"
+      className="h-full min-h-0 max-h-48 overflow-y-auto"
+      data-bestie-channel-id={channel.id}
+      data-bestie-channel-name={channel.name}
+      data-testid="bestie-mini-transcript"
+      ref={transcriptRef}
+    >
+      <ProtectedMessageActionsBoundary>
+        <TimelineMessageList
+          channelId={channel.id}
+          channelName={channel.name}
+          channelType={channel.channelType}
+          currentPubkey={currentPubkey}
+          mainEntries={mainTimelineEntries}
+          messages={messages}
+          onToggleReaction={onToggleReaction}
+          profiles={profiles}
+          stickyDayDividers={false}
+        />
+      </ProtectedMessageActionsBoundary>
+    </div>
+  );
+}
+
+export function BestiePopover({
+  avatarLayoutId,
+  contextChannelId,
+  contextMessage,
+  onRequestClose,
+}: {
+  avatarLayoutId?: string;
+  contextChannelId?: string | null;
+  contextMessage?: TimelineMessage;
+  onRequestClose?: () => void;
+}) {
+  const bestie = useBestie();
+  const [draft, setDraft] = React.useState("");
+  const [contextSent, setContextSent] = React.useState(false);
+  const [conversationChannel, setConversationChannel] =
+    React.useState<Channel | null>(null);
+  const [sessionBoundary, setSessionBoundary] = React.useState<{
+    baselineMessageIds: ReadonlySet<string>;
+    firstMessageCreatedAt: number;
+  } | null>(null);
+  const identityQuery = useIdentityQuery();
+  const profileQuery = useProfileQuery();
+  const conversationQuery = useChannelMessagesQuery(conversationChannel);
+  useChannelSubscription(conversationChannel);
+  const sendMutation = useSendMessageMutation(
+    conversationChannel,
+    identityQuery.data,
+  );
+  const toggleReactionMutation = useToggleReactionMutation();
+  const toggleReactionMutateRef = React.useRef(
+    toggleReactionMutation.mutateAsync,
+  );
+  toggleReactionMutateRef.current = toggleReactionMutation.mutateAsync;
+  const agent = bestie.assignedAgent;
+  const assignedAgentPubkey = agent?.pubkey;
+  const conversationPromiseRef = React.useRef<Promise<Channel> | null>(null);
+  const resolveConversationForOpen = React.useEffectEvent(() =>
+    bestie.resolveConversation(),
+  );
+
+  React.useEffect(() => {
+    setConversationChannel(null);
+    conversationPromiseRef.current = null;
+    if (!assignedAgentPubkey) return;
+
+    let cancelled = false;
+    const pending = resolveConversationForOpen();
+    conversationPromiseRef.current = pending;
+    void pending
+      .then((channel) => {
+        if (!cancelled) setConversationChannel(channel);
+      })
+      .catch((error) => {
+        console.warn("Couldn’t load the Bestie conversation", error);
+      })
+      .finally(() => {
+        if (conversationPromiseRef.current === pending) {
+          conversationPromiseRef.current = null;
+        }
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [assignedAgentPubkey]);
+
+  const currentPubkey = identityQuery.data?.pubkey;
+  const currentProfile = profileQuery.data;
+  const conversationProfiles = React.useMemo<UserProfileLookup>(() => {
+    if (!agent) return {};
+    const profiles: UserProfileLookup = {
+      [normalizePubkey(agent.pubkey)]: {
+        avatarUrl: agent.avatarUrl,
+        displayName: agent.name,
+        isAgent: true,
+        name: agent.name,
+        nip05Handle: null,
+        ownerPubkey: null,
+      },
+    };
+    if (currentPubkey) {
+      profiles[normalizePubkey(currentPubkey)] = {
+        avatarUrl: currentProfile?.avatarUrl ?? null,
+        displayName: "You",
+        isAgent: false,
+        name: null,
+        nip05Handle: currentProfile?.nip05Handle ?? null,
+        ownerPubkey: null,
+      };
+    }
+    return profiles;
+  }, [
+    agent,
+    currentProfile?.avatarUrl,
+    currentProfile?.nip05Handle,
+    currentPubkey,
+  ]);
+  const contextEnvelope = React.useMemo(
+    () => buildBestieMessageContext(contextChannelId, contextMessage),
+    [contextChannelId, contextMessage],
+  );
+  const allConversationMessages = React.useMemo(() => {
+    if (!conversationChannel) return [];
+    return formatTimelineMessages(
+      conversationQuery.data ?? [],
+      conversationChannel,
+      currentPubkey,
+      currentProfile?.avatarUrl ?? null,
+      conversationProfiles,
+    )
+      .filter(
+        (message) =>
+          (message.kind === KIND_STREAM_MESSAGE ||
+            message.kind === KIND_STREAM_MESSAGE_V2) &&
+          !message.parentId,
+      )
+      .map((message) => {
+        if (!contextEnvelope || !message.body.startsWith(contextEnvelope)) {
+          return message;
+        }
+        return {
+          ...message,
+          body: message.body.slice(contextEnvelope.length).trim(),
+        };
+      })
+      .filter((message) => message.body.length > 0);
+  }, [
+    contextEnvelope,
+    conversationChannel,
+    conversationProfiles,
+    conversationQuery.data,
+    currentProfile?.avatarUrl,
+    currentPubkey,
+  ]);
+  const conversationMessages = React.useMemo(() => {
+    if (!sessionBoundary) return [];
+    return allConversationMessages
+      .filter(
+        (message) =>
+          message.createdAt >= sessionBoundary.firstMessageCreatedAt &&
+          !sessionBoundary.baselineMessageIds.has(message.id),
+      )
+      .slice(-12);
+  }, [allConversationMessages, sessionBoundary]);
+  const handleToggleReaction = React.useCallback(
+    async (message: TimelineMessage, emoji: string, remove: boolean) => {
+      await toggleReactionMutateRef.current({
+        emoji,
+        eventId: message.id,
+        remove,
+      });
+    },
+    [],
+  );
+  if (bestie.isLoading) {
+    return <p className="text-sm text-muted-foreground">Loading Bestie…</p>;
+  }
+  if (!agent) return <EmptyBestie />;
+
+  const presenceStatus = bestie.presenceStatus ?? "offline";
+  const sendMessage = () => {
+    const trimmedDraft = draft.trim();
+    if (!trimmedDraft || bestie.isOpening || sendMutation.isPending) return;
+    void (async () => {
+      const baselineMessageIds = new Set(
+        allConversationMessages.map((message) => message.id),
+      );
+      const startResult = bestie.ensureAgentRunning().then(
+        () => ({ error: null }),
+        (error: unknown) => ({ error }),
+      );
+      const channel =
+        conversationChannel ??
+        (await (conversationPromiseRef.current ??
+          bestie.resolveConversation()));
+      setConversationChannel(channel);
+      const sentMessage = await sendMutation.mutateAsync({
+        content:
+          contextEnvelope && !contextSent
+            ? `${contextEnvelope}\n\n${trimmedDraft}`
+            : trimmedDraft,
+        targetChannel: channel,
+      });
+      setSessionBoundary(
+        (current) =>
+          current ?? {
+            baselineMessageIds,
+            firstMessageCreatedAt: sentMessage.created_at,
+          },
+      );
+      setContextSent(true);
+      setDraft("");
+      const { error: startError } = await startResult;
+      if (startError) throw startError;
+    })().catch((error) => {
+      toast.error(
+        error instanceof Error ? error.message : "Couldn’t message Bestie",
+      );
+    });
+  };
+
+  return (
+    <div className="flex max-h-[min(32rem,var(--radix-popover-content-available-height,calc(100vh-2rem)))] flex-col gap-4">
+      <div
+        className="flex shrink-0 touch-none select-none items-center gap-3 cursor-grab active:cursor-grabbing"
+        data-bestie-drag-handle
+      >
+        <BestieAgentLockup
+          agent={agent}
+          avatarLayoutId={avatarLayoutId}
+          presenceStatus={presenceStatus}
+        />
+        <div className="flex-1" />
+        <Button
+          aria-label="Close Bestie"
+          onClick={onRequestClose}
+          size="icon-xs"
+          variant="ghost"
+        >
+          <X />
+        </Button>
+      </div>
+
+      {conversationMessages.length > 0 && conversationChannel ? (
+        <div className="min-h-0 max-h-48 overflow-hidden">
+          <BestieConversationTranscript
+            channel={conversationChannel}
+            currentPubkey={currentPubkey}
+            messages={conversationMessages}
+            onToggleReaction={handleToggleReaction}
+            profiles={conversationProfiles}
+          />
+        </div>
+      ) : null}
+
+      {contextMessage && !contextSent ? (
+        <div
+          className="shrink-0 space-y-2"
+          data-testid="bestie-message-context"
+        >
+          <div
+            className="max-h-24 max-w-[75%] overflow-hidden rounded-xl border border-border/70 bg-muted/45 p-2.5 shadow-xs"
+            data-testid="bestie-message-snapshot"
+          >
+            <div className="flex min-w-0 items-center gap-2">
+              <UserAvatar
+                avatarUrl={contextMessage.avatarUrl ?? null}
+                className="h-5 w-5"
+                displayName={contextMessage.author}
+                fallbackDelayMs={0}
+                size="xs"
+              />
+              <span className="truncate text-xs font-semibold">
+                {contextMessage.author}
+              </span>
+            </div>
+            <p className="mt-1.5 whitespace-pre-wrap break-words text-xs leading-4 text-foreground/80">
+              {contextMessage.body}
+            </p>
+          </div>
+          <div className="w-fit rounded-2xl bg-muted px-3 py-2 text-sm">
+            How can I help?
+          </div>
+        </div>
+      ) : null}
+
+      <div className="relative shrink-0">
+        <Textarea
+          aria-label={`Message ${agent.name}`}
+          className="min-h-24 resize-none rounded-2xl pb-11"
+          data-bloom-autofocus
+          data-testid="bestie-composer"
+          onChange={(event) => setDraft(event.target.value)}
+          onKeyDown={(event) => {
+            if (
+              event.key !== "Enter" ||
+              event.shiftKey ||
+              event.altKey ||
+              event.ctrlKey ||
+              event.metaKey ||
+              event.nativeEvent.isComposing
+            ) {
+              return;
+            }
+            event.preventDefault();
+            sendMessage();
+          }}
+          placeholder={`Message ${agent.name}`}
+          value={draft}
+        />
+        <Button
+          aria-label="Send in Bestie conversation"
+          className="absolute bottom-2 right-2 rounded-full"
+          disabled={!draft.trim() || bestie.isOpening || sendMutation.isPending}
+          onClick={sendMessage}
+          size="icon"
+        >
+          <ArrowUp />
+        </Button>
+      </div>
+    </div>
+  );
+}
diff --git a/desktop/src/protectedFeatures/bestie/BestieProfileSection.tsx b/desktop/src/protectedFeatures/bestie/BestieProfileSection.tsx
new file mode 100644
index 00000000000..6e15a88942c
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/BestieProfileSection.tsx
@@ -0,0 +1,86 @@
+import * as React from "react";
+import { Star } from "lucide-react";
+import { toast } from "sonner";
+
+import { ProfileAgentActionRow } from "@/features/profile/ui/UserProfileAgentManagementRows";
+import type { ManagedAgent } from "@/shared/api/types";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/shared/ui/alert-dialog";
+import { useBestie } from "./useBestie";
+
+export function BestieProfileAction({ agent }: { agent: ManagedAgent }) {
+  const bestie = useBestie();
+  const [confirmOpen, setConfirmOpen] = React.useState(false);
+  if (agent.backend.type !== "local") return null;
+
+  const isBestie =
+    bestie.assignment?.agentPubkey.toLowerCase() === agent.pubkey.toLowerCase();
+  const isPending = bestie.isAssigning;
+  const handleClick = () => {
+    if (!isBestie) {
+      setConfirmOpen(true);
+      return;
+    }
+    void bestie.clearAssignment().catch((error) => {
+      toast.error(
+        error instanceof Error ? error.message : "Couldn’t update Bestie",
+      );
+    });
+  };
+
+  return (
+    <>
+      <ProfileAgentActionRow
+        disabled={bestie.isLoading || isPending}
+        icon={Star}
+        iconClassName={
+          isBestie ? "h-4 w-4 shrink-0 fill-current text-foreground" : undefined
+        }
+        label={isBestie ? "Remove Bestie" : "Make Bestie"}
+        onClick={handleClick}
+        testId="user-profile-bestie-action"
+      />
+      <AlertDialog onOpenChange={setConfirmOpen} open={confirmOpen}>
+        <AlertDialogContent data-testid="bestie-confirm-dialog">
+          <AlertDialogHeader>
+            <AlertDialogTitle>Make {agent.name} your Bestie?</AlertDialogTitle>
+            <AlertDialogDescription>
+              {bestie.assignedAgent && !isBestie
+                ? `${agent.name} will replace ${bestie.assignedAgent.name} in the floating shortcut and message actions.`
+                : `${agent.name} will appear in the floating shortcut and message actions.`}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel disabled={isPending}>Cancel</AlertDialogCancel>
+            <AlertDialogAction
+              disabled={isPending}
+              onClick={(event) => {
+                event.preventDefault();
+                void bestie
+                  .assignAgent(agent)
+                  .then(() => setConfirmOpen(false))
+                  .catch((error) => {
+                    toast.error(
+                      error instanceof Error
+                        ? error.message
+                        : "Couldn’t update Bestie",
+                    );
+                  });
+              }}
+            >
+              {isPending ? "Saving…" : "Make Bestie"}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}
diff --git a/desktop/src/protectedFeatures/bestie/BestieSidebarEntry.tsx b/desktop/src/protectedFeatures/bestie/BestieSidebarEntry.tsx
new file mode 100644
index 00000000000..56e4cfd155d
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/BestieSidebarEntry.tsx
@@ -0,0 +1,50 @@
+import { Plus } from "lucide-react";
+import { toast } from "sonner";
+
+import { useAppNavigation } from "@/app/navigation/useAppNavigation";
+import { SidebarMenuButton, SidebarMenuItem } from "@/shared/ui/sidebar";
+import { BestieAgentLockup } from "./BestiePopover";
+import { useBestie } from "./useBestie";
+
+export function BestieSidebarEntry() {
+  const bestie = useBestie();
+  const { goAgents } = useAppNavigation();
+
+  const handleClick = () => {
+    if (!bestie.assignedAgent) {
+      void goAgents();
+      return;
+    }
+    void bestie.openConversation().catch((error) => {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : "Couldn’t open Bestie conversation",
+      );
+    });
+  };
+
+  return (
+    <SidebarMenuItem data-testid="bestie-sidebar-entry">
+      <SidebarMenuButton
+        disabled={bestie.isOpening}
+        onClick={handleClick}
+        tooltip="Bestie"
+        type="button"
+      >
+        {bestie.assignedAgent ? (
+          <BestieAgentLockup
+            agent={bestie.assignedAgent}
+            compact
+            presenceStatus={bestie.presenceStatus ?? "offline"}
+          />
+        ) : (
+          <>
+            <Plus className="h-4 w-4" />
+            <span>Bestie</span>
+          </>
+        )}
+      </SidebarMenuButton>
+    </SidebarMenuItem>
+  );
+}
diff --git a/desktop/src/protectedFeatures/bestie/BloomMenu.tsx b/desktop/src/protectedFeatures/bestie/BloomMenu.tsx
new file mode 100644
index 00000000000..97159b69d82
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/BloomMenu.tsx
@@ -0,0 +1,362 @@
+/**
+ * Bestie-scoped adaptation of Josh Puckett's MIT-licensed Bloom menu.
+ * Source: https://github.com/joshpuckett/bloom/tree/8fa80a0f136b3f687c1641a09ff8c97aa8e514ba/packages/bloom
+ *
+ * The public package could not be pulled through the workspace's approved npm
+ * proxy, so this keeps the small Root/Container/Trigger/Content surface we use
+ * and points it at the repo's existing Motion runtime.
+ */
+import { AnimatePresence, motion, useReducedMotion } from "motion/react";
+import * as React from "react";
+
+type Direction = "top" | "bottom";
+type Anchor = "start" | "center" | "end";
+type OpenChangeOptions = { restoreFocus?: boolean };
+
+type BloomContextValue = {
+  anchor: Anchor;
+  contentId: string;
+  contentRef: React.RefObject<HTMLDivElement | null>;
+  direction: Direction;
+  open: boolean;
+  setOpen: (open: boolean, options?: OpenChangeOptions) => void;
+  triggerRef: React.RefObject<HTMLButtonElement | null>;
+};
+
+const BloomContext = React.createContext<BloomContextValue | null>(null);
+
+function useBloomContext() {
+  const context = React.useContext(BloomContext);
+  if (!context) throw new Error("Bloom components require Bloom.Root");
+  return context;
+}
+
+function Root({
+  anchor = "start",
+  children,
+  direction = "top",
+  onOpenChange,
+  open,
+}: {
+  anchor?: Anchor;
+  children: React.ReactNode;
+  direction?: Direction;
+  onOpenChange: (open: boolean) => void;
+  open: boolean;
+}) {
+  const triggerRef = React.useRef<HTMLButtonElement>(null);
+  const contentRef = React.useRef<HTMLDivElement>(null);
+  const contentId = React.useId();
+  const previousOpenRef = React.useRef(open);
+  const restoreFocusOnCloseRef = React.useRef(true);
+
+  const setOpen = React.useCallback(
+    (nextOpen: boolean, options?: OpenChangeOptions) => {
+      if (nextOpen) {
+        restoreFocusOnCloseRef.current = true;
+      } else {
+        restoreFocusOnCloseRef.current = options?.restoreFocus ?? true;
+      }
+      onOpenChange(nextOpen);
+    },
+    [onOpenChange],
+  );
+
+  React.useEffect(() => {
+    const wasOpen = previousOpenRef.current;
+    previousOpenRef.current = open;
+    if (wasOpen === open) return;
+
+    const frame = requestAnimationFrame(() => {
+      if (open) {
+        const preferredTarget = contentRef.current?.querySelector<HTMLElement>(
+          "[data-bloom-autofocus]",
+        );
+        const fallbackTarget = contentRef.current?.querySelector<HTMLElement>(
+          "button:not([disabled]), input:not([disabled]), textarea:not([disabled]), select:not([disabled]), a[href]",
+        );
+        (preferredTarget ?? fallbackTarget ?? contentRef.current)?.focus();
+      } else if (restoreFocusOnCloseRef.current) {
+        triggerRef.current?.focus();
+      }
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [open]);
+
+  React.useEffect(() => {
+    if (!open) return;
+    const closeOnOutsidePress = (event: MouseEvent | TouchEvent) => {
+      const target = event.target as Node;
+      if (
+        !triggerRef.current?.contains(target) &&
+        !contentRef.current?.contains(target)
+      ) {
+        setOpen(false, { restoreFocus: false });
+      }
+    };
+    const closeOnEscape = (event: KeyboardEvent) => {
+      if (event.key !== "Escape") return;
+      event.preventDefault();
+      setOpen(false);
+    };
+    document.addEventListener("mousedown", closeOnOutsidePress);
+    document.addEventListener("touchstart", closeOnOutsidePress);
+    document.addEventListener("keydown", closeOnEscape);
+    return () => {
+      document.removeEventListener("mousedown", closeOnOutsidePress);
+      document.removeEventListener("touchstart", closeOnOutsidePress);
+      document.removeEventListener("keydown", closeOnEscape);
+    };
+  }, [open, setOpen]);
+
+  const value = React.useMemo(
+    () => ({
+      anchor,
+      contentId,
+      contentRef,
+      direction,
+      open,
+      setOpen,
+      triggerRef,
+    }),
+    [anchor, contentId, direction, open, setOpen],
+  );
+
+  return (
+    <BloomContext.Provider value={value}>{children}</BloomContext.Provider>
+  );
+}
+
+function Container({
+  buttonSize = 48,
+  children,
+  className,
+  edgeDraggable = false,
+  menuRadius = 20,
+  menuWidth = 320,
+  motionDisabled = false,
+  onMorphAnimationComplete,
+}: {
+  buttonSize?: number;
+  children: React.ReactNode;
+  className?: string;
+  edgeDraggable?: boolean;
+  menuRadius?: number;
+  menuWidth?: number;
+  motionDisabled?: boolean;
+  onMorphAnimationComplete?: (open: boolean) => void;
+}) {
+  const { anchor, direction, open, setOpen } = useBloomContext();
+  const reduceMotion = useReducedMotion();
+  const measureRef = React.useRef<HTMLDivElement>(null);
+  const [measuredHeight, setMeasuredHeight] = React.useState(buttonSize);
+
+  React.useLayoutEffect(() => {
+    if (!open || !measureRef.current) return;
+    const measure = () => {
+      if (measureRef.current) {
+        setMeasuredHeight(measureRef.current.offsetHeight);
+      }
+    };
+    measure();
+    const observer = new ResizeObserver(measure);
+    observer.observe(measureRef.current);
+    return () => observer.disconnect();
+  }, [open]);
+
+  const horizontalOffset =
+    anchor === "start"
+      ? 0
+      : -(menuWidth - buttonSize) * (anchor === "center" ? 0.5 : 1);
+  const verticalOffset =
+    direction === "top" ? -buttonSize * 0.75 : buttonSize * 0.75;
+  const openTransform = `translate3d(${horizontalOffset}px, ${verticalOffset}px, 0) scale(1)`;
+
+  return (
+    <div className="relative h-12 w-12">
+      <motion.div
+        animate={{
+          borderRadius: open ? menuRadius : buttonSize / 2,
+          boxShadow: open
+            ? "0 20px 25px -5px rgb(0 0 0 / 0.12), 0 8px 10px -6px rgb(0 0 0 / 0.1)"
+            : "0 10px 15px -3px rgb(0 0 0 / 0.12), 0 4px 6px -4px rgb(0 0 0 / 0.1)",
+          height: open ? measuredHeight : buttonSize,
+          transform: open ? openTransform : "translate3d(0, 0, 0) scale(1)",
+          width: open ? menuWidth : buttonSize,
+        }}
+        className={className}
+        data-testid="bestie-bloom-container"
+        initial={false}
+        onAnimationComplete={() => onMorphAnimationComplete?.(open)}
+        onClick={(event) => {
+          if (open) return;
+          event.preventDefault();
+          setOpen(true);
+        }}
+        style={{
+          ...(direction === "top"
+            ? { bottom: 0, left: 0 }
+            : { left: 0, top: 0 }),
+          cursor: open ? "default" : "pointer",
+          overflow: "hidden",
+          position: "absolute",
+          transformOrigin: `${
+            anchor === "start" ? "left" : anchor === "end" ? "right" : "center"
+          } ${direction === "top" ? "bottom" : "top"}`,
+          willChange: "transform",
+          zIndex: open ? 50 : "auto",
+        }}
+        transition={
+          reduceMotion || motionDisabled
+            ? { duration: 0 }
+            : { bounce: 0.15, type: "spring", visualDuration: 0.25 }
+        }
+      >
+        <div ref={measureRef}>{children}</div>
+        {open && edgeDraggable ? (
+          <div
+            aria-hidden="true"
+            className="pointer-events-none absolute inset-0 z-10"
+          >
+            <div
+              className="pointer-events-auto absolute inset-x-0 top-0 h-2 touch-none cursor-grab active:cursor-grabbing"
+              data-bestie-drag-edge="top"
+              data-bestie-drag-handle
+            />
+            <div
+              className="pointer-events-auto absolute inset-x-0 bottom-0 h-2 touch-none cursor-grab active:cursor-grabbing"
+              data-bestie-drag-edge="bottom"
+              data-bestie-drag-handle
+            />
+            <div
+              className="pointer-events-auto absolute inset-y-2 left-0 w-2 touch-none cursor-grab active:cursor-grabbing"
+              data-bestie-drag-edge="left"
+              data-bestie-drag-handle
+            />
+            <div
+              className="pointer-events-auto absolute inset-y-2 right-0 w-2 touch-none cursor-grab active:cursor-grabbing"
+              data-bestie-drag-edge="right"
+              data-bestie-drag-handle
+            />
+          </div>
+        ) : null}
+      </motion.div>
+    </div>
+  );
+}
+
+function Trigger({
+  ariaLabel,
+  children,
+  className,
+}: {
+  ariaLabel: string;
+  children: React.ReactNode;
+  className?: string;
+}) {
+  const { anchor, contentId, direction, open, setOpen, triggerRef } =
+    useBloomContext();
+
+  return (
+    <motion.button
+      aria-controls={contentId}
+      aria-expanded={open}
+      aria-haspopup="dialog"
+      aria-label={ariaLabel}
+      className={className}
+      disabled={open}
+      key="bloom-trigger"
+      onClick={(event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        setOpen(true);
+      }}
+      ref={triggerRef}
+      style={{
+        ...(anchor === "end" ? { right: 0 } : { left: 0 }),
+        ...(direction === "top" ? { bottom: 0 } : { top: 0 }),
+        pointerEvents: open ? "none" : "auto",
+        position: "absolute",
+        visibility: open ? "hidden" : "visible",
+      }}
+      tabIndex={open ? -1 : 0}
+      type="button"
+    >
+      {children}
+    </motion.button>
+  );
+}
+
+function Content({
+  ariaLabel,
+  children,
+  className,
+}: {
+  ariaLabel: string;
+  children: React.ReactNode;
+  className?: string;
+}) {
+  const { anchor, contentId, contentRef, direction, open } = useBloomContext();
+  const reduceMotion = useReducedMotion();
+  const hiddenY = direction === "top" ? 8 : -8;
+
+  return (
+    <AnimatePresence>
+      {open ? (
+        <motion.div
+          aria-label={ariaLabel}
+          aria-modal="false"
+          animate={{
+            filter: "blur(0px)",
+            opacity: 1,
+            transform: "translate3d(0, 0, 0) scale(1)",
+          }}
+          className={className}
+          data-testid="bestie-bloom-content"
+          exit={{
+            filter: reduceMotion ? "blur(0px)" : "blur(8px)",
+            opacity: 0,
+            transform: reduceMotion
+              ? "translate3d(0, 0, 0) scale(1)"
+              : `translate3d(0, ${direction === "top" ? 24 : -24}px, 0) scale(0.95)`,
+          }}
+          initial={{
+            filter: reduceMotion ? "blur(0px)" : "blur(10px)",
+            opacity: 0,
+            transform: reduceMotion
+              ? "translate3d(0, 0, 0) scale(1)"
+              : `translate3d(0, ${hiddenY}px, 0) scale(0.95)`,
+          }}
+          key="bloom-content"
+          id={contentId}
+          ref={contentRef}
+          role="dialog"
+          style={{
+            transformOrigin: `${
+              anchor === "start"
+                ? "left"
+                : anchor === "end"
+                  ? "right"
+                  : "center"
+            } ${direction === "top" ? "bottom" : "top"}`,
+          }}
+          transition={
+            reduceMotion
+              ? { duration: 0.12 }
+              : {
+                  bounce: 0.15,
+                  delay: 0.03,
+                  type: "spring",
+                  visualDuration: 0.2,
+                }
+          }
+          tabIndex={-1}
+        >
+          {children}
+        </motion.div>
+      ) : null}
+    </AnimatePresence>
+  );
+}
+
+export const Bloom = { Container, Content, Root, Trigger };
diff --git a/desktop/src/protectedFeatures/bestie/api.ts b/desktop/src/protectedFeatures/bestie/api.ts
new file mode 100644
index 00000000000..b29b046fdf6
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/api.ts
@@ -0,0 +1,56 @@
+import type { Channel } from "@/shared/api/types";
+import { fromRawChannel, type RawChannel } from "@/shared/api/tauriChannels";
+import { invokeTauri } from "@/shared/api/tauri";
+
+type RawBestieAssignment = {
+  agent_pubkey: string;
+};
+
+export type BestieAssignment = {
+  agentPubkey: string;
+};
+
+export type BestieScope = {
+  expectedRelayUrl: string;
+  expectedSignerPubkey: string;
+};
+
+function fromRawAssignment(assignment: RawBestieAssignment): BestieAssignment {
+  return {
+    agentPubkey: assignment.agent_pubkey,
+  };
+}
+
+export async function getBestieAssignment(
+  scope: BestieScope,
+): Promise<BestieAssignment | null> {
+  const assignment = await invokeTauri<RawBestieAssignment | null>(
+    "get_bestie_assignment",
+    scope,
+  );
+  return assignment ? fromRawAssignment(assignment) : null;
+}
+
+export async function assignBestie(
+  agentPubkey: string,
+  scope: BestieScope,
+): Promise<BestieAssignment> {
+  return fromRawAssignment(
+    await invokeTauri<RawBestieAssignment>("assign_bestie", {
+      agentPubkey,
+      ...scope,
+    }),
+  );
+}
+
+export async function clearBestieAssignment(scope: BestieScope): Promise<void> {
+  await invokeTauri("clear_bestie_assignment", scope);
+}
+
+export async function resolveBestieConversation(
+  scope: BestieScope,
+): Promise<Channel> {
+  return fromRawChannel(
+    await invokeTauri<RawChannel>("resolve_bestie_conversation", scope),
+  );
+}
diff --git a/desktop/src/protectedFeatures/bestie/bestieMessageContext.test.mjs b/desktop/src/protectedFeatures/bestie/bestieMessageContext.test.mjs
new file mode 100644
index 00000000000..4e16dca91cc
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/bestieMessageContext.test.mjs
@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildBestieMessageContext } from "./bestieMessageContext.ts";
+
+const CHANNEL_ID = "channel-1";
+
+function message(overrides = {}) {
+  return {
+    id: "message-1",
+    author: "Baxen",
+    body: "This visible body must not be copied into the agent prompt.",
+    createdAt: 1,
+    depth: 0,
+    time: "8:52 AM",
+    ...overrides,
+  };
+}
+
+test("sends a canonical link to a top-level message instead of its body", () => {
+  const context = buildBestieMessageContext(CHANNEL_ID, message());
+
+  assert.equal(
+    context,
+    "Help me with this thread from Baxen:\n\nbuzz://message?channel=channel-1&id=message-1",
+  );
+  assert.doesNotMatch(context, /visible body/);
+});
+
+test("links a reply to its thread root", () => {
+  const context = buildBestieMessageContext(
+    CHANNEL_ID,
+    message({ id: "reply-1", rootId: "root-1", parentId: "root-1" }),
+  );
+
+  assert.equal(
+    context,
+    "Help me with this thread from Baxen:\n\nbuzz://message?channel=channel-1&id=root-1&thread=root-1",
+  );
+});
+
+test("does not construct a lossy fallback when channel context is missing", () => {
+  assert.equal(buildBestieMessageContext(null, message()), null);
+  assert.equal(buildBestieMessageContext(CHANNEL_ID, undefined), null);
+});
diff --git a/desktop/src/protectedFeatures/bestie/bestieMessageContext.ts b/desktop/src/protectedFeatures/bestie/bestieMessageContext.ts
new file mode 100644
index 00000000000..cf0857c879c
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/bestieMessageContext.ts
@@ -0,0 +1,18 @@
+import { buildMessageLink } from "@/features/messages/lib/messageLink";
+import type { TimelineMessage } from "@/features/messages/types";
+
+export function buildBestieMessageContext(
+  channelId: string | null | undefined,
+  message: TimelineMessage | undefined,
+): string | null {
+  if (!channelId || !message) return null;
+
+  const threadRootId = message.rootId ?? message.id;
+  const threadLink = buildMessageLink({
+    channelId,
+    messageId: threadRootId,
+    threadRootId: message.rootId ? threadRootId : null,
+  });
+
+  return `Help me with this thread from ${message.author}:\n\n${threadLink}`;
+}
diff --git a/desktop/src/protectedFeatures/bestie/filterBestieDmChannels.test.mjs b/desktop/src/protectedFeatures/bestie/filterBestieDmChannels.test.mjs
new file mode 100644
index 00000000000..bbc40406a02
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/filterBestieDmChannels.test.mjs
@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { filterBestieDmChannels } from "./filterBestieDmChannels.ts";
+
+const SELF = "AA";
+const BESTIE = "BB";
+const OTHER = "CC";
+
+function makeDm(id, participantPubkeys) {
+  return {
+    archivedAt: null,
+    channelType: "dm",
+    description: "",
+    id,
+    isMember: true,
+    lastMessageAt: null,
+    memberCount: participantPubkeys.length,
+    memberPubkeys: participantPubkeys,
+    name: id,
+    participantPubkeys,
+    participants: participantPubkeys,
+    purpose: null,
+    topic: null,
+    ttlDeadline: null,
+    ttlSeconds: null,
+    visibility: "private",
+  };
+}
+
+test("filters only the one-to-one DM with the designated Bestie", () => {
+  const bestieDm = makeDm("bestie", [BESTIE, SELF]);
+  const otherDm = makeDm("other", [SELF, OTHER]);
+  const groupWithBestie = makeDm("group", [SELF, BESTIE, OTHER]);
+
+  assert.deepEqual(
+    filterBestieDmChannels(
+      [bestieDm, otherDm, groupWithBestie],
+      SELF.toLowerCase(),
+      BESTIE.toLowerCase(),
+    ).map(({ id }) => id),
+    ["other", "group"],
+  );
+});
+
+test("preserves the DM list until identity and assignment are available", () => {
+  const channels = [makeDm("bestie", [SELF, BESTIE])];
+
+  assert.equal(filterBestieDmChannels(channels, undefined, BESTIE), channels);
+  assert.equal(filterBestieDmChannels(channels, SELF, null), channels);
+});
diff --git a/desktop/src/protectedFeatures/bestie/filterBestieDmChannels.ts b/desktop/src/protectedFeatures/bestie/filterBestieDmChannels.ts
new file mode 100644
index 00000000000..9684bf3579b
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/filterBestieDmChannels.ts
@@ -0,0 +1,25 @@
+import type { Channel } from "@/shared/api/types";
+import { normalizePubkey } from "@/shared/lib/pubkey";
+
+export function filterBestieDmChannels(
+  channels: Channel[],
+  currentPubkey: string | undefined,
+  bestiePubkey: string | null,
+) {
+  if (!currentPubkey || !bestiePubkey) return channels;
+
+  const expectedParticipants = new Set([
+    normalizePubkey(currentPubkey),
+    normalizePubkey(bestiePubkey),
+  ]);
+
+  return channels.filter((channel) => {
+    const participants = new Set(
+      channel.participantPubkeys.map(normalizePubkey),
+    );
+    const isBestiePair =
+      participants.size === expectedParticipants.size &&
+      [...expectedParticipants].every((pubkey) => participants.has(pubkey));
+    return !isBestiePair;
+  });
+}
diff --git a/desktop/src/protectedFeatures/bestie/findAssignedLocalAgent.test.mjs b/desktop/src/protectedFeatures/bestie/findAssignedLocalAgent.test.mjs
new file mode 100644
index 00000000000..ca06c3be65a
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/findAssignedLocalAgent.test.mjs
@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { findAssignedLocalAgent } from "./findAssignedLocalAgent.ts";
+
+const LOCAL = {
+  backend: { type: "local" },
+  pubkey: "a".repeat(64),
+};
+const REMOTE = {
+  backend: { type: "provider" },
+  pubkey: "b".repeat(64),
+};
+
+test("resolves only an existing local Bestie assignment", () => {
+  assert.equal(
+    findAssignedLocalAgent([LOCAL, REMOTE], { agentPubkey: "A".repeat(64) }),
+    LOCAL,
+  );
+  assert.equal(
+    findAssignedLocalAgent([LOCAL, REMOTE], { agentPubkey: REMOTE.pubkey }),
+    null,
+  );
+  assert.equal(
+    findAssignedLocalAgent([LOCAL], { agentPubkey: "c".repeat(64) }),
+    null,
+  );
+  assert.equal(findAssignedLocalAgent([LOCAL], null), null);
+});
diff --git a/desktop/src/protectedFeatures/bestie/findAssignedLocalAgent.ts b/desktop/src/protectedFeatures/bestie/findAssignedLocalAgent.ts
new file mode 100644
index 00000000000..a6376ad47af
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/findAssignedLocalAgent.ts
@@ -0,0 +1,17 @@
+import type { ManagedAgent } from "@/shared/api/types";
+import type { BestieAssignment } from "./api";
+
+/** Resolve a durable assignment only when its local managed agent still exists. */
+export function findAssignedLocalAgent(
+  agents: ManagedAgent[],
+  assignment: BestieAssignment | null | undefined,
+) {
+  if (!assignment) return null;
+  return (
+    agents.find(
+      (agent) =>
+        agent.backend.type === "local" &&
+        agent.pubkey.toLowerCase() === assignment.agentPubkey.toLowerCase(),
+    ) ?? null
+  );
+}
diff --git a/desktop/src/protectedFeatures/bestie/useBestie.ts b/desktop/src/protectedFeatures/bestie/useBestie.ts
new file mode 100644
index 00000000000..d724023a793
--- /dev/null
+++ b/desktop/src/protectedFeatures/bestie/useBestie.ts
@@ -0,0 +1,180 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+import { useAppNavigation } from "@/app/navigation/useAppNavigation";
+import { useManagedAgentsQuery } from "@/features/agents/hooks";
+import {
+  managedAgentRuntimesQueryKey,
+  useManagedAgentRuntimeAction,
+  useManagedAgentRuntimesQuery,
+} from "@/features/agents/managedAgentRuntimeHooks";
+import {
+  canonicalRelayUrl,
+  findManagedAgentRuntime,
+  managedAgentPairAction,
+} from "@/features/agents/managedAgentRuntimeStatus";
+import {
+  channelsQueryKey,
+  upsertCachedChannel,
+} from "@/features/channels/hooks";
+import { dmVisibilityQueryKeyFor } from "@/features/channels/useHiddenDmIds";
+import { useCommunities } from "@/features/communities/useCommunities";
+import { usePresenceQuery } from "@/features/presence/hooks";
+import { useIdentityQuery } from "@/shared/api/hooks";
+import type { Channel, ManagedAgent } from "@/shared/api/types";
+import {
+  assignBestie,
+  clearBestieAssignment,
+  getBestieAssignment,
+  resolveBestieConversation,
+  type BestieScope,
+} from "./api";
+import { findAssignedLocalAgent } from "./findAssignedLocalAgent";
+
+export function bestieAssignmentQueryKey(
+  relayUrl: string,
+  ownerPubkey: string,
+) {
+  return [
+    "bestie-assignment",
+    canonicalRelayUrl(relayUrl) ?? relayUrl,
+    ownerPubkey.toLowerCase(),
+  ] as const;
+}
+
+export function useBestieAssignmentQuery(enabled = true) {
+  const { activeCommunity } = useCommunities();
+  const identityQuery = useIdentityQuery();
+  const relayUrl = activeCommunity?.relayUrl ?? "";
+  const ownerPubkey = identityQuery.data?.pubkey ?? "";
+  const scope: BestieScope | null =
+    relayUrl && ownerPubkey
+      ? {
+          expectedRelayUrl: relayUrl,
+          expectedSignerPubkey: ownerPubkey,
+        }
+      : null;
+  const queryKey = bestieAssignmentQueryKey(relayUrl, ownerPubkey);
+  const assignmentQuery = useQuery({
+    enabled: enabled && scope !== null,
+    queryKey,
+    queryFn: () => {
+      if (!scope) return null;
+      return getBestieAssignment(scope);
+    },
+  });
+
+  return { assignmentQuery, ownerPubkey, queryKey, relayUrl, scope };
+}
+
+export function useBestie() {
+  const queryClient = useQueryClient();
+  const { goChannel } = useAppNavigation();
+  const { assignmentQuery, ownerPubkey, queryKey, relayUrl, scope } =
+    useBestieAssignmentQuery();
+  const managedAgentsQuery = useManagedAgentsQuery({ enabled: scope !== null });
+  const runtimesQuery = useManagedAgentRuntimesQuery({
+    enabled: scope !== null,
+  });
+  const runtimeAction = useManagedAgentRuntimeAction();
+  const assignedAgent = findAssignedLocalAgent(
+    managedAgentsQuery.data ?? [],
+    assignmentQuery.data,
+  );
+  const presenceQuery = usePresenceQuery(
+    assignedAgent ? [assignedAgent.pubkey] : [],
+    { enabled: assignedAgent !== null },
+  );
+  const presenceStatus = assignedAgent
+    ? (presenceQuery.data?.[assignedAgent.pubkey.toLowerCase()] ?? "offline")
+    : undefined;
+  const runtime = assignedAgent
+    ? findManagedAgentRuntime(
+        runtimesQuery.data ?? [],
+        assignedAgent.pubkey,
+        relayUrl,
+      )
+    : undefined;
+
+  const assignMutation = useMutation({
+    mutationFn: (agent: ManagedAgent) => {
+      if (!scope) throw new Error("Bestie is unavailable outside a community");
+      return assignBestie(agent.pubkey, scope);
+    },
+    onSuccess: (assignment) => {
+      queryClient.setQueryData(queryKey, assignment);
+    },
+  });
+  const clearMutation = useMutation({
+    mutationFn: () => {
+      if (!scope) throw new Error("Bestie is unavailable outside a community");
+      return clearBestieAssignment(scope);
+    },
+    onSuccess: () => {
+      queryClient.setQueryData(queryKey, null);
+    },
+  });
+  const resolveMutation = useMutation({
+    mutationFn: () => {
+      if (!scope) throw new Error("Bestie is unavailable outside a community");
+      return resolveBestieConversation(scope);
+    },
+    onSuccess: (channel) => {
+      queryClient.setQueryData<Channel[]>(channelsQueryKey, (current) =>
+        upsertCachedChannel(current, channel),
+      );
+      queryClient.setQueryData<Set<string>>(
+        dmVisibilityQueryKeyFor(relayUrl, ownerPubkey),
+        (current) => {
+          const next = new Set(current);
+          next.delete(channel.id);
+          return next;
+        },
+      );
+    },
+  });
+
+  const ensureAgentRunning = async () => {
+    if (assignedAgent) {
+      const action = managedAgentPairAction(runtime);
+      if (action !== "stop") {
+        await runtimeAction.mutateAsync({
+          action,
+          pubkey: assignedAgent.pubkey,
+          relayUrl,
+        });
+        await queryClient.invalidateQueries({
+          queryKey: managedAgentRuntimesQueryKey,
+        });
+      }
+    }
+  };
+
+  const resolveConversation = async () => {
+    return resolveMutation.mutateAsync();
+  };
+
+  const openConversation = async (draft?: string) => {
+    await ensureAgentRunning();
+    const channel = await resolveConversation();
+    await goChannel(channel.id, draft ? { autoSend: draft } : undefined);
+  };
+
+  return {
+    assignedAgent,
+    assignment: assignmentQuery.data ?? null,
+    assignmentError: assignmentQuery.error,
+    assignAgent: assignMutation.mutateAsync,
+    clearAssignment: clearMutation.mutateAsync,
+    ensureAgentRunning,
+    isAssigning: assignMutation.isPending,
+    isLoading:
+      assignmentQuery.isLoading ||
+      managedAgentsQuery.isLoading ||
+      runtimesQuery.isLoading,
+    isOpening: resolveMutation.isPending || runtimeAction.isPending,
+    openConversation,
+    presenceStatus,
+    resolveConversation,
+    runtime,
+  };
+}
diff --git a/desktop/src/protectedFeatures/internalUi.ts b/desktop/src/protectedFeatures/internalUi.ts
new file mode 100644
index 00000000000..6cccae6f1a9
--- /dev/null
+++ b/desktop/src/protectedFeatures/internalUi.ts
@@ -0,0 +1,89 @@
+import {
+  createContext,
+  createElement,
+  type ReactNode,
+  useContext,
+  useMemo,
+} from "react";
+
+import { useManagedAgentsQuery } from "@/features/agents/hooks";
+import type { TimelineMessage } from "@/features/messages/types";
+import type { Channel, ManagedAgent } from "@/shared/api/types";
+import { useFeatureEnabled } from "@/shared/features";
+import { BestieGlobalOverlay } from "./bestie/BestieGlobalOverlay";
+import { BestieCardBadge } from "./bestie/BestieCardBadge";
+import { BestieMessageAction } from "./bestie/BestieMessageAction";
+import { BestieProfileAction } from "./bestie/BestieProfileSection";
+import { BestieSidebarEntry } from "./bestie/BestieSidebarEntry";
+import { filterBestieDmChannels } from "./bestie/filterBestieDmChannels";
+import { findAssignedLocalAgent } from "./bestie/findAssignedLocalAgent";
+import { useBestieAssignmentQuery } from "./bestie/useBestie";
+
+const ProtectedMessageActionsContext = createContext(true);
+
+export function ProtectedGlobalOverlay() {
+  const enabled = useFeatureEnabled("bestie");
+  return enabled ? createElement(BestieGlobalOverlay) : null;
+}
+
+export function ProtectedMessageAction(props: {
+  channelId?: string | null;
+  message: TimelineMessage;
+}) {
+  const enabled = useFeatureEnabled("bestie");
+  const actionsAllowed = useContext(ProtectedMessageActionsContext);
+  return enabled && actionsAllowed
+    ? createElement(BestieMessageAction, props)
+    : null;
+}
+
+export function ProtectedMessageActionsBoundary({
+  children,
+}: {
+  children: ReactNode;
+}) {
+  return createElement(
+    ProtectedMessageActionsContext.Provider,
+    { value: false },
+    children,
+  );
+}
+
+export function ProtectedAgentBestieAction(props: { agent: ManagedAgent }) {
+  const enabled = useFeatureEnabled("bestie");
+  return enabled ? createElement(BestieProfileAction, props) : null;
+}
+
+export function ProtectedBestieCardBadge(props: {
+  agent: ManagedAgent;
+  isBestie: boolean;
+}) {
+  const enabled = useFeatureEnabled("bestie");
+  return enabled ? createElement(BestieCardBadge, props) : null;
+}
+
+export function ProtectedBestieSidebarEntry() {
+  const enabled = useFeatureEnabled("bestie");
+  return enabled ? createElement(BestieSidebarEntry) : null;
+}
+
+export function useProtectedBestiePubkey(agents: ManagedAgent[]) {
+  const enabled = useFeatureEnabled("bestie");
+  const { assignmentQuery } = useBestieAssignmentQuery(enabled);
+  if (!enabled) return null;
+  return findAssignedLocalAgent(agents, assignmentQuery.data)?.pubkey ?? null;
+}
+
+export function useProtectedVisibleDirectMessages(
+  channels: Channel[],
+  currentPubkey: string | undefined,
+) {
+  const enabled = useFeatureEnabled("bestie");
+  const managedAgentsQuery = useManagedAgentsQuery({ enabled });
+  const bestiePubkey = useProtectedBestiePubkey(managedAgentsQuery.data ?? []);
+
+  return useMemo(
+    () => filterBestieDmChannels(channels, currentPubkey, bestiePubkey),
+    [bestiePubkey, channels, currentPubkey],
+  );
+}
diff --git a/desktop/src/protectedFeatures/publicUi.ts b/desktop/src/protectedFeatures/publicUi.ts
new file mode 100644
index 00000000000..776a9aee48d
--- /dev/null
+++ b/desktop/src/protectedFeatures/publicUi.ts
@@ -0,0 +1,51 @@
+import type { ReactNode } from "react";
+
+import type { TimelineMessage } from "@/features/messages/types";
+import type { Channel, ManagedAgent } from "@/shared/api/types";
+
+export function ProtectedGlobalOverlay() {
+  return null;
+}
+
+export function ProtectedMessageAction(_props: {
+  channelId?: string | null;
+  message: TimelineMessage;
+}) {
+  return null;
+}
+
+export function ProtectedMessageActionsBoundary({
+  children,
+}: {
+  children: ReactNode;
+}) {
+  return children;
+}
+
+export function ProtectedAgentBestieAction(_props: { agent: ManagedAgent }) {
+  return null;
+}
+
+export function ProtectedBestieCardBadge(_props: {
+  agent: ManagedAgent;
+  isBestie: boolean;
+}) {
+  return null;
+}
+
+export function ProtectedBestieSidebarEntry() {
+  return null;
+}
+
+export function useProtectedBestiePubkey(
+  _agents: ManagedAgent[],
+): string | null {
+  return null;
+}
+
+export function useProtectedVisibleDirectMessages(
+  channels: Channel[],
+  _currentPubkey: string | undefined,
+) {
+  return channels;
+}
diff --git a/desktop/src/shared/ui/UserAvatar.tsx b/desktop/src/shared/ui/UserAvatar.tsx
index 8618d83c5a1..1b47bc4c92c 100644
--- a/desktop/src/shared/ui/UserAvatar.tsx
+++ b/desktop/src/shared/ui/UserAvatar.tsx
@@ -40,6 +40,7 @@ type UserAvatarProps = {
   shape?: "circle" | "squircle";
   className?: string;
   fallbackDelayMs?: number;
+  imageDraggable?: boolean;
   testId?: string;
 };
 
@@ -51,6 +52,7 @@ export function UserAvatar({
   shape,
   className,
   fallbackDelayMs = 200,
+  imageDraggable,
   testId,
 }: UserAvatarProps) {
   const initials = getInitials(displayName);
@@ -86,6 +88,7 @@ export function UserAvatar({
           alt={`${displayName} avatar`}
           className={cn("object-cover", !animated && "bg-secondary")}
           data-testid={testId ? `${testId}-image` : undefined}
+          draggable={imageDraggable}
           referrerPolicy="no-referrer"
           src={src}
         />
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index b31504fe0a0..1884a2cf9e1 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -2475,6 +2475,7 @@ function resetMockRelayAgents(config?: E2eConfig) {
 
 function resetMockManagedAgents(config?: E2eConfig) {
   mockManagedAgents = [];
+  mockBestieAssignment = null;
   mockManagedAgentRuntimes = (config?.mock?.managedAgentRuntimes ?? []).map(
     (seed) => ({
       pubkey: seed.pubkey,
@@ -3225,6 +3226,9 @@ let mockClosedChannelLiveSubscription = false;
 const realSockets = new Map<number, WebSocket>();
 let mockManagedAgents: MockManagedAgent[] = [];
 let mockManagedAgentRuntimes: MockManagedAgentRuntimeRow[] = [];
+let mockBestieAssignment: {
+  agent_pubkey: string;
+} | null = null;
 
 // Mutable `save_subscriptions` table mirror — TEST-ONLY.
 //
@@ -9694,6 +9698,9 @@ async function handleDeleteManagedAgent(args: {
   mockManagedAgents = mockManagedAgents.filter(
     (candidate) => candidate.pubkey !== args.pubkey,
   );
+  if (mockBestieAssignment?.agent_pubkey === args.pubkey) {
+    mockBestieAssignment = null;
+  }
   syncMockRelayAgentsFromManagedAgents();
 }
 
@@ -13734,6 +13741,32 @@ export function maybeInstallE2eTauriMocks() {
         );
       case "list_managed_agent_runtimes":
         return mockManagedAgentRuntimes.map((row) => ({ ...row }));
+      case "get_bestie_assignment":
+        return mockBestieAssignment ? { ...mockBestieAssignment } : null;
+      case "assign_bestie": {
+        const agentPubkey = (payload as { agentPubkey: string }).agentPubkey;
+        const agent = getMockManagedAgent(agentPubkey);
+        if (agent.backend.type !== "local") {
+          throw new Error("only a local managed agent can be your Bestie");
+        }
+        mockBestieAssignment = {
+          agent_pubkey: agent.pubkey,
+        };
+        return { ...mockBestieAssignment };
+      }
+      case "clear_bestie_assignment":
+        mockBestieAssignment = null;
+        return undefined;
+      case "resolve_bestie_conversation": {
+        if (!mockBestieAssignment) {
+          throw new Error("choose an agent before opening Bestie");
+        }
+        const channel = await handleOpenDm(
+          { pubkeys: [mockBestieAssignment.agent_pubkey] },
+          activeConfig,
+        );
+        return channel;
+      }
       case "start_managed_agent_runtime":
         return handleManagedAgentRuntimeAction(
           "start",
diff --git a/desktop/test-loader-hooks.mjs b/desktop/test-loader-hooks.mjs
index d473587adf3..bdd15c3ae12 100644
--- a/desktop/test-loader-hooks.mjs
+++ b/desktop/test-loader-hooks.mjs
@@ -95,6 +95,12 @@ export function resolve(specifier, context, nextResolve) {
     const resolved = path.join(srcRoot, "protectedFeatures", variant);
     return nextResolve(toFileSpecifier(resolved), context);
   }
+  if (specifier === "@protected-feature-components") {
+    const variant =
+      process.env.VITE_BUZZ_BESTIE === "1" ? "internalUi.ts" : "publicUi.ts";
+    const resolved = path.join(srcRoot, "protectedFeatures", variant);
+    return nextResolve(toFileSpecifier(resolved), context);
+  }
   if (specifier === "@model-capabilities-manifest") {
     const resolved = path.join(repoRoot, "scripts", "model-capabilities.json");
     return nextResolve(toFileSpecifier(resolved), context);
diff --git a/desktop/tests/e2e/bestie.spec.ts b/desktop/tests/e2e/bestie.spec.ts
new file mode 100644
index 00000000000..e5281e2cd82
--- /dev/null
+++ b/desktop/tests/e2e/bestie.spec.ts
@@ -0,0 +1,388 @@
+import { expect, test } from "@playwright/test";
+
+import { waitForAnimations } from "../helpers/animations";
+import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
+
+const BESTIE_PUBKEY = TEST_IDENTITIES.alice.pubkey;
+const RELAY_URL = "ws://localhost:3000";
+
+async function enableBestie(page: import("@playwright/test").Page) {
+  await page.addInitScript(() => {
+    window.localStorage.setItem(
+      "buzz-feature-overrides-v1",
+      JSON.stringify({ bestie: true }),
+    );
+  });
+}
+
+async function waitForMockLiveSubscription(
+  page: import("@playwright/test").Page,
+  channelName: string,
+) {
+  await expect
+    .poll(() =>
+      page.evaluate(
+        (name) =>
+          window.__BUZZ_E2E_HAS_MOCK_LIVE_SUBSCRIPTION__?.({
+            channelName: name,
+          }) ?? false,
+        channelName,
+      ),
+    )
+    .toBe(true);
+}
+
+test("assigns from an agent profile, reopens, drags, and offers the message action", async ({
+  page,
+}) => {
+  await enableBestie(page);
+  await installMockBridge(
+    page,
+    {
+      managedAgents: [
+        {
+          pubkey: BESTIE_PUBKEY,
+          name: "Mochi",
+          avatarUrl:
+            "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==",
+          status: "stopped",
+        },
+      ],
+      managedAgentRuntimes: [
+        {
+          pubkey: BESTIE_PUBKEY,
+          relayUrl: RELAY_URL,
+          lifecycle: "stopped",
+        },
+      ],
+    },
+    { seedPreviewFeatures: false },
+  );
+  await page.goto("/", { waitUntil: "domcontentloaded" });
+
+  const floatingAvatar = page.getByTestId("bestie-floating-avatar");
+  await expect(floatingAvatar).toBeVisible();
+  expect(
+    await floatingAvatar.evaluate(
+      (element) => element.parentElement === document.body,
+    ),
+  ).toBe(true);
+  await expect(floatingAvatar.getByTestId("bestie-empty-mark")).toBeVisible();
+  await floatingAvatar.click();
+  await expect(
+    page.getByText("Choose a Bestie", { exact: true }),
+  ).toBeVisible();
+  await expect(page.getByText(/Open one of your local agents/)).toBeVisible();
+  await waitForAnimations(page);
+  await page.getByTestId("bestie-bloom-content").screenshot({
+    path: "test-results/bestie/00-empty-state.png",
+  });
+  await page.keyboard.press("Escape");
+
+  await page.getByTestId("open-agents-view").click();
+  await page.getByRole("button", { name: "Mochi agent profile" }).click();
+  const bestieAction = page.getByTestId("user-profile-bestie-action");
+  await expect(bestieAction).toContainText("Make Bestie");
+  await bestieAction.click();
+  const confirmation = page.getByTestId("bestie-confirm-dialog");
+  await expect(confirmation).toContainText("Make Mochi your Bestie?");
+  await waitForAnimations(page);
+  await confirmation.screenshot({
+    path: "test-results/bestie/01-confirm-bestie.png",
+  });
+  await confirmation.getByRole("button", { name: "Make Bestie" }).click();
+  await expect(bestieAction).toContainText("Remove Bestie");
+  await expect(
+    floatingAvatar.getByTestId("bestie-trigger-avatar"),
+  ).toBeVisible();
+  await expect(
+    floatingAvatar.getByTestId("bestie-trigger-avatar-image"),
+  ).toHaveAttribute("draggable", "false");
+  const sidebarBestie = page.getByTestId("bestie-sidebar-entry");
+  await expect(sidebarBestie).toContainText("Mochi");
+  await expect(
+    page.getByTestId("dm-list").getByTestId("channel-alice-tyler"),
+  ).toHaveCount(0);
+  expect(
+    await sidebarBestie.evaluate(
+      (element) =>
+        element.previousElementSibling?.querySelector(
+          '[data-testid="open-agents-view"]',
+        ) !== null,
+    ),
+  ).toBe(true);
+  await waitForAnimations(page);
+  await page.getByTestId("sidebar-primary-menu").screenshot({
+    path: "test-results/bestie/02-sidebar-entry.png",
+  });
+  await page.getByTestId("user-profile-agent-management-section").screenshot({
+    path: "test-results/bestie/03-profile-actions.png",
+  });
+
+  await page.keyboard.press("Escape");
+  const bestieCard = page.getByTestId(`managed-agent-${BESTIE_PUBKEY}`);
+  await expect(
+    bestieCard.getByTestId(`bestie-card-badge-${BESTIE_PUBKEY}`),
+  ).toBeVisible();
+  await waitForAnimations(page);
+  await bestieCard.screenshot({
+    path: "test-results/bestie/04-bestie-card.png",
+  });
+
+  await floatingAvatar.click();
+  await expect(page.getByTestId("bestie-activity-dot").last()).toBeVisible();
+  await expect(page.getByText("Waking", { exact: true })).toHaveCount(0);
+  await expect(page.getByText("Choose a different agent")).toHaveCount(0);
+  await waitForAnimations(page);
+  await page.getByTestId("bestie-bloom-content").screenshot({
+    path: "test-results/bestie/05-floating-popover.png",
+  });
+
+  const bloomContent = page.getByTestId("bestie-bloom-content");
+  const bloomAvatar = bloomContent.getByTestId("bestie-agent-avatar");
+  const openPanelBeforeDrag = await bloomContent.boundingBox();
+  const openAvatarBeforeDrag = await bloomAvatar.boundingBox();
+  for (const edge of ["top", "right", "bottom", "left"]) {
+    await expect(
+      floatingAvatar.locator(`[data-bestie-drag-edge="${edge}"]`),
+    ).toBeVisible();
+  }
+  const dragHandle = floatingAvatar.locator('[data-bestie-drag-edge="bottom"]');
+  const dragHandleBox = await dragHandle.boundingBox();
+  expect(dragHandleBox).not.toBeNull();
+  await page.mouse.move(
+    (dragHandleBox?.x ?? 0) + (dragHandleBox?.width ?? 0) / 2,
+    (dragHandleBox?.y ?? 0) + (dragHandleBox?.height ?? 0) / 2,
+  );
+  await page.mouse.down();
+  await page.mouse.move(
+    (dragHandleBox?.x ?? 0) + (dragHandleBox?.width ?? 0) / 2 - 80,
+    (dragHandleBox?.y ?? 0) + (dragHandleBox?.height ?? 0) / 2 + 80,
+    { steps: 8 },
+  );
+  await page.mouse.up();
+  const openPanelAfterDrag = await bloomContent.boundingBox();
+  const openAvatarAfterDrag = await bloomAvatar.boundingBox();
+  const openContainerAfterDrag = await page
+    .getByTestId("bestie-bloom-container")
+    .boundingBox();
+  const panelDelta = {
+    x: (openPanelAfterDrag?.x ?? 0) - (openPanelBeforeDrag?.x ?? 0),
+    y: (openPanelAfterDrag?.y ?? 0) - (openPanelBeforeDrag?.y ?? 0),
+  };
+  const avatarDelta = {
+    x: (openAvatarAfterDrag?.x ?? 0) - (openAvatarBeforeDrag?.x ?? 0),
+    y: (openAvatarAfterDrag?.y ?? 0) - (openAvatarBeforeDrag?.y ?? 0),
+  };
+  expect(Math.abs(panelDelta.x - avatarDelta.x)).toBeLessThan(1);
+  expect(Math.abs(panelDelta.y - avatarDelta.y)).toBeLessThan(1);
+
+  await bloomContent.getByRole("button", { name: "Close Bestie" }).click();
+  await expect(bloomContent).toHaveCount(0);
+  await waitForAnimations(page);
+  const closeAnchor = await floatingAvatar.boundingBox();
+  expect(
+    Math.abs(
+      (closeAnchor?.x ?? 0) +
+        (closeAnchor?.width ?? 0) -
+        ((openContainerAfterDrag?.x ?? 0) +
+          (openContainerAfterDrag?.width ?? 0)),
+    ),
+  ).toBeLessThan(1);
+
+  const floatingTrigger = floatingAvatar.getByRole("button", {
+    name: "Open Bestie",
+  });
+  await expect(floatingTrigger).toHaveAttribute("aria-haspopup", "dialog");
+  await floatingTrigger.focus();
+  await page.keyboard.press("Enter");
+  const keyboardOpenedPopover = page.getByTestId("bestie-bloom-content");
+  await expect(keyboardOpenedPopover).toHaveAttribute("role", "dialog");
+  await expect(page.getByTestId("bestie-composer")).toBeFocused();
+  await page.keyboard.press("Escape");
+  await expect(keyboardOpenedPopover).toHaveCount(0);
+  await expect(floatingTrigger).toBeFocused();
+
+  await floatingTrigger.click();
+  await expect(page.getByTestId("bestie-composer")).toBeFocused();
+  const outsideDestination = page.getByTestId("open-agents-view");
+  await outsideDestination.click();
+  await expect(page.getByTestId("bestie-bloom-content")).toHaveCount(0);
+  await expect(outsideDestination).toBeFocused();
+
+  await sidebarBestie.click();
+  await expect(page).toHaveURL(/\/channels\//);
+  await expect(
+    page.getByRole("heading", { name: "alice-tyler" }),
+  ).toBeVisible();
+  const firstConversationUrl = page.url();
+  await expect(page).toHaveURL(firstConversationUrl);
+  await expect(page.getByTestId("bestie-bloom-content")).toHaveCount(0);
+
+  await floatingAvatar.click();
+  await expect(page.getByTestId("bestie-activity-dot").last()).toBeVisible();
+  await page.getByRole("button", { name: "Close Bestie" }).click();
+  await waitForAnimations(page);
+  const beforeDrag = await floatingAvatar.boundingBox();
+  const collapsedAvatar = floatingAvatar.getByTestId("bestie-trigger-avatar");
+  const collapsedAvatarBeforeDrag = await collapsedAvatar.boundingBox();
+  expect(beforeDrag).not.toBeNull();
+  await page.mouse.move(
+    (beforeDrag?.x ?? 0) + (beforeDrag?.width ?? 0) / 2,
+    (beforeDrag?.y ?? 0) + (beforeDrag?.height ?? 0) / 2,
+  );
+  await page.mouse.down();
+  await page.mouse.move(
+    (beforeDrag?.x ?? 0) - 120,
+    (beforeDrag?.y ?? 0) + 120,
+    { steps: 8 },
+  );
+  await page.mouse.up();
+  const afterDrag = await floatingAvatar.boundingBox();
+  const collapsedAvatarAfterDrag = await collapsedAvatar.boundingBox();
+  expect(afterDrag?.x).toBeLessThan(beforeDrag?.x ?? 0);
+  expect(afterDrag?.y).toBeGreaterThan(beforeDrag?.y ?? 0);
+  expect(
+    Math.abs(
+      (afterDrag?.x ?? 0) -
+        (beforeDrag?.x ?? 0) -
+        ((collapsedAvatarAfterDrag?.x ?? 0) -
+          (collapsedAvatarBeforeDrag?.x ?? 0)),
+    ),
+  ).toBeLessThan(1);
+  expect(
+    Math.abs(
+      (afterDrag?.y ?? 0) -
+        (beforeDrag?.y ?? 0) -
+        ((collapsedAvatarAfterDrag?.y ?? 0) -
+          (collapsedAvatarBeforeDrag?.y ?? 0)),
+    ),
+  ).toBeLessThan(1);
+
+  await page.getByTestId("channel-general").click();
+  const messageRow = page.getByTestId("message-row").first();
+  await messageRow.hover();
+  const messageAction = messageRow.locator('[data-testid^="bestie-message-"]');
+  await expect(messageAction).toBeVisible();
+  await messageAction.click();
+  const messagePopover = page
+    .locator("[data-radix-popper-content-wrapper]")
+    .last();
+  await expect(messagePopover.getByLabel("Message Mochi")).toHaveValue("");
+  await expect(
+    messagePopover.getByText("How can I help?", { exact: true }),
+  ).toBeVisible();
+  const snapshot = messagePopover.getByTestId("bestie-message-snapshot");
+  await expect(snapshot).toBeVisible();
+  const snapshotBox = await snapshot.boundingBox();
+  const popoverBox = await messagePopover.boundingBox();
+  expect(snapshotBox?.height).toBeLessThanOrEqual(96);
+  expect(snapshotBox?.width).toBeLessThanOrEqual(
+    (popoverBox?.width ?? 0) * 0.75 + 1,
+  );
+  await waitForAnimations(page);
+  await messagePopover.screenshot({
+    path: "test-results/bestie/06-message-handoff.png",
+  });
+  const channelUrl = page.url();
+  const miniComposer = messagePopover.getByLabel("Message Mochi");
+  await miniComposer.fill("Give me a concise reply");
+  await miniComposer.press("Shift+Enter");
+  await miniComposer.pressSequentially("with one example");
+  await expect(miniComposer).toHaveValue(
+    "Give me a concise reply\nwith one example",
+  );
+  await expect(
+    messagePopover.getByTestId("bestie-mini-transcript"),
+  ).toHaveCount(0);
+  await miniComposer.press("Enter");
+  await expect(page).toHaveURL(channelUrl);
+  await expect(messagePopover).toBeVisible();
+  await expect(miniComposer).toHaveValue("");
+  await expect(snapshot).toHaveCount(0);
+  await expect(
+    messagePopover.getByTestId("bestie-mini-transcript"),
+  ).toContainText("Give me a concise reply\nwith one example");
+  const miniTranscript = messagePopover.getByTestId("bestie-mini-transcript");
+  const sentMessageRow = miniTranscript
+    .getByTestId("message-row")
+    .filter({ hasText: "Give me a concise reply" });
+  await expect(sentMessageRow).toBeVisible();
+  const sentMessageId = await sentMessageRow.getAttribute("data-message-id");
+  expect(sentMessageId).toBeTruthy();
+  const bestieChannelName = await miniTranscript.getAttribute(
+    "data-bestie-channel-name",
+  );
+  expect(bestieChannelName).toBeTruthy();
+  await waitForMockLiveSubscription(page, bestieChannelName as string);
+  await page.evaluate(
+    ({ channelName, pubkey, targetId }) => {
+      window.__BUZZ_E2E_EMIT_MOCK_MESSAGE__?.({
+        channelName,
+        content: "Here’s the concise reply.",
+        pubkey,
+      });
+      window.__BUZZ_E2E_EMIT_MOCK_MESSAGE__?.({
+        channelName,
+        content: "👀",
+        extraTags: [["e", targetId]],
+        kind: 7,
+        pubkey,
+      });
+    },
+    {
+      channelName: bestieChannelName as string,
+      pubkey: BESTIE_PUBKEY,
+      targetId: sentMessageId as string,
+    },
+  );
+  await expect(miniTranscript).toContainText("Here’s the concise reply.");
+  await expect(sentMessageRow.getByLabel("Toggle 👀 reaction")).toBeVisible();
+  const miniDayDivider = miniTranscript
+    .getByTestId("message-timeline-day-divider")
+    .first();
+  if ((await miniDayDivider.count()) > 0) {
+    await expect(miniDayDivider).toHaveCSS("position", "static");
+  }
+  await sentMessageRow.hover();
+  await expect(
+    sentMessageRow.locator('[data-testid^="bestie-message-"]'),
+  ).toHaveCount(0);
+
+  await miniComposer.fill("One more thought");
+  await miniComposer.press("Enter");
+  await expect(page).toHaveURL(channelUrl);
+  await expect(miniTranscript).toContainText("One more thought");
+  await waitForAnimations(page);
+  await messagePopover.screenshot({
+    path: "test-results/bestie/07-message-conversation.png",
+  });
+  await messagePopover.getByRole("button", { name: "Close Bestie" }).click();
+  await expect(page.getByLabel("Message Mochi")).toHaveCount(0);
+
+  await floatingAvatar.click();
+  const freshFloatingPopover = page.getByTestId("bestie-bloom-content");
+  await expect(freshFloatingPopover.getByLabel("Message Mochi")).toBeVisible();
+  await expect(
+    freshFloatingPopover.getByTestId("bestie-mini-transcript"),
+  ).toHaveCount(0);
+  await expect(freshFloatingPopover).not.toContainText("One more thought");
+  await freshFloatingPopover
+    .getByRole("button", { name: "Close Bestie" })
+    .click();
+
+  await messageRow.hover();
+  await messageAction.focus();
+  await messageAction.press("Enter");
+  const freshMessagePopover = page
+    .locator("[data-radix-popper-content-wrapper]")
+    .last();
+  await expect(freshMessagePopover.getByLabel("Message Mochi")).toBeVisible();
+  await expect(
+    freshMessagePopover.getByTestId("bestie-mini-transcript"),
+  ).toHaveCount(0);
+  await expect(freshMessagePopover).not.toContainText("One more thought");
+  await expect(
+    freshMessagePopover.getByTestId("bestie-message-snapshot"),
+  ).toBeVisible();
+});
diff --git a/desktop/tsconfig.json b/desktop/tsconfig.json
index feb7e7590f2..02e86e194d3 100644
--- a/desktop/tsconfig.json
+++ b/desktop/tsconfig.json
@@ -9,6 +9,7 @@
       "@/*": ["./src/*"],
       "@features-manifest": ["../preview-features.json"],
       "@protected-features": ["./src/protectedFeatures/public.ts"],
+      "@protected-feature-components": ["./src/protectedFeatures/publicUi.ts"],
       "@model-capabilities-manifest": ["../scripts/model-capabilities.json"]
     },
 
diff --git a/desktop/vite.config.ts b/desktop/vite.config.ts
index 257c8382bbb..ca51271dfa1 100644
--- a/desktop/vite.config.ts
+++ b/desktop/vite.config.ts
@@ -39,6 +39,12 @@ export default defineConfig(async ({ mode }) => {
             ? "./src/protectedFeatures/internal.ts"
             : "./src/protectedFeatures/public.ts",
         ),
+        "@protected-feature-components": path.resolve(
+          __dirname,
+          protectedFeaturesEnabled
+            ? "./src/protectedFeatures/internalUi.ts"
+            : "./src/protectedFeatures/publicUi.ts",
+        ),
         "@model-capabilities-manifest": path.resolve(
           __dirname,
           "../scripts/model-capabilities.json",