vector_core/community/v2/

service.rs

//! Concord v2 service — the stateful orchestration binding the pure v2 modules
//! to storage + transport. Free functions, `SessionGuard`-gated at every write
//! (a `swap_session` can land at any await — see CLAUDE.md), mirroring the v1
//! service's discipline.
//!
//! Signing + NIP-44 flow through the active [`VectorSigner`] (`active_signer()`):
//! the live client's signer for a NIP-46 bunker / NIP-55 offline account, else the
//! local vault. Every identity op in v2 is `sign_event` / `nip44_encrypt` /
//! `nip44_decrypt` — a remote signer's whole surface — so create, send, join,
//! invite, moderate, rotate, and refound all work keylessly (CORD-06 D1/D5 made the
//! rekey locator public + its blobs pairwise NIP-44, so unlike v1 there is no
//! raw-ECDH exception).

use nostr_sdk::prelude::{Event, Keys, PublicKey, Timestamp};

use super::super::transport::{Query, Transport};
use super::super::{version, ChannelId, Epoch};
use super::chat::{self, ChatEvent};
use super::community::{ChannelV2, CommunityV2};
use super::control;
use super::derive::{base_rekey_group_key, channel_group_key, channel_rekey_group_key, control_group_key, GroupKey};
use super::invite::{self, CommunityInvite};
use super::rekey::{self, Continuity, RekeyScope};
use super::{guestbook, stream, vsk};
use crate::community::edition::ParsedEdition;
use crate::state::SessionGuard;

/// The active signer for v2 authority actions: the live client's signer — which
/// covers a NIP-46 bunker / NIP-55 offline signer — falling back to the local
/// vault keys when there is no client or no signer attached (local accounts,
/// headless/CLI paths, and tests). Every v2 seal, rekey blob, and control edition
/// signs / NIP-44-wraps through this, so a keyless account can create AND
/// administer a community. v2's rekey locator is public + its blobs are pairwise
/// NIP-44 (CORD-06 D1/D5), so unlike v1 there is no raw-ECDH exception.
/// The active identity's public key for addressing/tags — authoritative (set at
/// login), no signer round-trip. Used everywhere v2 needs "who am I" so a keyless
/// account (empty vault) still resolves its own identity.
fn me_pk() -> Result<PublicKey, String> {
    crate::state::my_public_key().ok_or_else(|| "no active identity".to_string())
}

fn now_ms() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_millis() as u64)
        .unwrap_or(0)
}

/// Create a fresh v2 community owned by the local identity: mint the genesis
/// (self-certifying id + the two owner editions), persist, publish the genesis
/// control editions, and announce the owner's Guestbook Join. Returns the saved
/// community.
pub async fn create_community<T: Transport + ?Sized>(
    transport: &T,
    name: &str,
    relays: Vec<String>,
    description: Option<String>,
) -> Result<CommunityV2, String> {
    let session = SessionGuard::capture();
    let signer = crate::signer::active_signer()?;
    let owner_pk = me_pk()?;
    let at_ms = now_ms();

    let meta = control::CommunityMetadata {
        name: name.to_string(),
        description: description.clone(),
        relays: relays.clone(),
        ..Default::default()
    };
    let genesis = control::genesis_signed(owner_pk, &signer, meta, at_ms / 1000).await.map_err(|e| e.to_string())?;
    let community = CommunityV2::from_genesis(&genesis, name, description, relays.clone(), at_ms);

    // Save-before-publish (like v1 create): no peers exist yet so there's no
    // shared view to diverge from, and the fresh-random keys are irrecoverable
    // if a publish hiccup rolled them back. Re-check the session after the genesis
    // signing await (a bunker signs over the network) before the DB write.
    if !session.is_valid() {
        return Err("account changed during community creation".to_string());
    }
    // Seed the genesis edition heads (v1) as the owner's refuse-downgrade floor, so a
    // later edit can't be rolled back by a relay serving only the genesis prefix. The
    // live control sub is replay-free (limit 0), so the owner won't re-fold its own
    // genesis to seed the floor otherwise. Floors land BEFORE the community row
    // (floors-then-state ordering).
    let control = control_group_key(&community.community_root, community.id(), community.root_epoch);
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    for wrap in &genesis.wraps {
        if let Ok((ed, _)) = control::open_control_edition(wrap, &control) {
            let entity_hex = crate::simd::hex::bytes_to_hex_32(&ed.entity_id);
            crate::db::community::set_edition_head_at_epoch(&cid_hex, &entity_hex, ed.version, &ed.self_hash, &ed.inner_id, community.root_epoch.0)?;
        }
    }
    crate::db::community::save_community_v2(&community)?;
    // Archive the genesis root at epoch 0, so a later Refounding leaves this epoch's
    // Public-channel history readable (CORD-03 §3 multi-epoch read).
    let _ = crate::db::community::store_epoch_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, community.root_epoch.0, &community.community_root);

    // Publish the two genesis control editions at the epoch-0 control plane.
    // Durable, not single-shot: over a slow transport (Tor) one attempt is a coin
    // flip, and a lost genesis leaves a community that exists only locally. Durable
    // races every relay, returns on the first ACK, then heals stragglers in the bg.
    for wrap in &genesis.wraps {
        transport.publish_durable(wrap, &community.relays).await?;
    }

    // Announce the owner's Guestbook Join so they appear in the memberlist. Relays are
    // proven-alive by the genesis ACK above, so durable here just guarantees the owner's
    // own join lands (member count) without a real block risk.
    let gb_group = super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch);
    let join_rumor = guestbook::build_join_rumor(owner_pk, None, at_ms);
    if let Ok((join_wrap, _)) = guestbook::seal_guestbook_rumor_signed(&signer, owner_pk, &join_rumor, &gb_group, Timestamp::from_secs(at_ms / 1000)).await {
        let _ = transport.publish_durable(&join_wrap, &community.relays).await;
    }

    // Sync the new membership across devices (CORD-02 §8), durably — see the join path.
    match republish_community_list(transport, Some(community.id())).await {
        Ok(true) => {}
        Ok(false) => republish_community_list_durable(Some(*community.id())),
        Err(e) => {
            crate::log_warn!("[CommunityList] failed to record this community across devices ({}) — retrying", e);
            republish_community_list_durable(Some(*community.id()));
        }
    }
    Ok(community)
}

/// Mint a v2 migration TWIN whose primary channel REUSES the v1 primary channel id (§migration)
/// so chat history stitches through the flip. Same owner identity, fresh salt/root. Additional
/// v1 channels are added by the wizard via `create_*_channel_with_id`. Mirrors
/// [`create_community`]'s persist-before-publish + floor seeding.
pub async fn create_migration_twin<T: Transport + ?Sized>(
    transport: &T,
    name: &str,
    relays: Vec<String>,
    description: Option<String>,
    primary: (ChannelId, String),
) -> Result<CommunityV2, String> {
    let session = SessionGuard::capture();
    let signer = crate::signer::active_signer()?;
    let owner_pk = me_pk()?;
    let at_ms = now_ms();

    let meta = control::CommunityMetadata {
        name: name.to_string(),
        description: description.clone(),
        relays: relays.clone(),
        ..Default::default()
    };
    let primary_name = primary.1.clone();
    let genesis = control::genesis_signed_with_primary(owner_pk, &signer, meta, at_ms / 1000, Some(primary))
        .await
        .map_err(|e| e.to_string())?;
    let mut community = CommunityV2::from_genesis(&genesis, name, description, relays.clone(), at_ms);
    // from_genesis hard-names the primary "general"; carry the v1 name (the wire edition
    // already carries it, so this only keeps the owner's immediate local view correct).
    if let Some(ch) = community.channels.first_mut() {
        ch.name = primary_name;
    }
    if !session.is_valid() {
        return Err("account changed during twin creation".to_string());
    }
    let control = control_group_key(&community.community_root, community.id(), community.root_epoch);
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    for wrap in &genesis.wraps {
        if let Ok((ed, _)) = control::open_control_edition(wrap, &control) {
            let entity_hex = crate::simd::hex::bytes_to_hex_32(&ed.entity_id);
            crate::db::community::set_edition_head_at_epoch(&cid_hex, &entity_hex, ed.version, &ed.self_hash, &ed.inner_id, community.root_epoch.0)?;
        }
    }
    crate::db::community::save_community_v2(&community)?;
    let _ = crate::db::community::store_epoch_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, community.root_epoch.0, &community.community_root);
    for wrap in &genesis.wraps {
        transport.publish_durable(wrap, &community.relays).await?;
    }
    // Owner Guestbook Join so they appear in the twin's memberlist.
    let gb_group = super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch);
    let join_rumor = guestbook::build_join_rumor(owner_pk, None, at_ms);
    if let Ok((join_wrap, _)) = guestbook::seal_guestbook_rumor_signed(&signer, owner_pk, &join_rumor, &gb_group, Timestamp::from_secs(at_ms / 1000)).await {
        let _ = transport.publish_durable(&join_wrap, &community.relays).await;
    }
    Ok(community)
}

/// Clone a v1 banlist onto the v2 twin (§migration Phase 1.3): the join-time ban gate needs
/// the v2 banlist to name every v1-banned npub, else a banned-but-never-cut member who can
/// open `m` would walk in. Owner-signed on the twin's control plane.
pub async fn clone_banlist_to_twin<T: Transport + ?Sized>(
    transport: &T,
    twin: &CommunityV2,
    banned: &[String],
) -> Result<(), String> {
    if banned.is_empty() {
        return Ok(());
    }
    set_banlist(transport, twin, banned).await
}

/// Clone v1 governance onto the twin (§migration Phase 1.3): every v1 member who was a FULL
/// admin (effective permissions ⊇ ADMIN_ALL) is re-granted @admin on the twin (mapping v1's
/// Admin onto v2's deterministic admin role id, CORD-04 §2). The owner is supreme by
/// identity (never a grant) and banned members are skipped (a banned author's editions fold
/// out anyway, and re-granting would spring them back to admin on a future unban).
///
/// NON-ESCALATION: only a full admin maps to v2 @admin (which holds ADMIN_ALL). A
/// partial-management v1 role holder (e.g. CREATE_INVITE only — never minted by the v1 UI,
/// but reachable via the SDK) degrades to a plain member rather than being ESCALATED to full
/// admin. Bespoke non-admin custom roles are not carried — a documented, non-security gap.
pub async fn clone_governance_to_twin<T: Transport + ?Sized>(
    transport: &T,
    twin: &CommunityV2,
    v1_roles: &crate::community::roles::CommunityRoles,
    banned: &[String],
) -> Result<(), String> {
    use crate::community::roles::Permissions;
    let owner = twin.owner()?;
    for grant in &v1_roles.grants {
        if !v1_roles.effective_permissions(&grant.member).contains(Permissions::ADMIN_ALL) {
            continue; // not a full admin → plain member on v2 (never escalated)
        }
        if banned.contains(&grant.member) {
            continue; // banned → no authority on v2, don't re-arm a future unban
        }
        let Ok(member) = PublicKey::parse(&grant.member) else { continue };
        if member == owner {
            continue; // supreme by identity — never needs a grant
        }
        grant_admin(transport, twin, &member).await?;
    }
    Ok(())
}

/// The twin's JoinMaterial — the membership subset sealed into the migration `m`.
pub fn twin_join_material(twin: &CommunityV2) -> super::list::JoinMaterial {
    join_material(twin)
}

/// Send a text message to a channel. Derives the channel's Chat-Plane group key
/// (community_root for a Public channel, the channel key for a Private one),
/// seals it encrypted, and publishes. Returns the message's rumor id (hex).
pub async fn send_message<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    content: &str,
) -> Result<String, String> {
    send_chat_message(transport, community, channel_id, content, None, &[], vec![]).await
}

/// Full chat send: threaded reply (NIP-C7 `q`, the parent's `(rumor_id, author)`
/// hex pair), NIP-30 custom-emoji pairs, and verbatim extra tags (NIP-92 `imeta`
/// attachments). Returns the message's rumor id (hex).
pub async fn send_chat_message<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    content: &str,
    reply_to: Option<(&str, &str)>,
    emoji: &[(&str, &str)],
    extra_tags: Vec<nostr_sdk::prelude::Tag>,
) -> Result<String, String> {
    send_chat_message_at(transport, community, channel_id, content, reply_to, emoji, extra_tags, now_ms()).await
}

/// [`send_chat_message`] with an explicit event time. The rumor id is a pure
/// function of its inputs, so a GUI that picks `at_ms` can precompute the id for
/// its optimistic pending row — the in-process echo and the finalize then key
/// the SAME id (the exact v1 pending → sent contract).
#[allow(clippy::too_many_arguments)]
pub async fn send_chat_message_at<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    content: &str,
    reply_to: Option<(&str, &str)>,
    emoji: &[(&str, &str)],
    extra_tags: Vec<nostr_sdk::prelude::Tag>,
    at_ms: u64,
) -> Result<String, String> {
    let (author_pk, group, epoch, session) = chat_send_context(community, channel_id)?;
    let rumor = chat::build_message_rumor(author_pk, channel_id, epoch, content, reply_to, emoji, extra_tags, at_ms);
    publish_chat(transport, community, &session, &group, author_pk, channel_id, epoch, rumor, at_ms, false).await
}

/// React to a channel message (kind 7, NIP-25 shape). `target_id_hex` /
/// `target_author_hex` name the reacted-to message; `target_kind` is its rumor
/// kind (`kind::MESSAGE`, or `kind::COMMENT` for a threaded reply); `emoji`
/// carries the NIP-30 pair when `emoji_content` is a custom `:shortcode:`.
#[allow(clippy::too_many_arguments)]
pub async fn send_reaction<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    target_id_hex: &str,
    target_author_hex: &str,
    target_kind: u16,
    emoji_content: &str,
    emoji: Option<(&str, &str)>,
) -> Result<String, String> {
    let (author_pk, group, epoch, session) = chat_send_context(community, channel_id)?;
    let at_ms = now_ms();
    let rumor =
        chat::build_reaction_rumor(author_pk, channel_id, epoch, target_id_hex, target_author_hex, target_kind, emoji_content, emoji, at_ms);
    publish_chat(transport, community, &session, &group, author_pk, channel_id, epoch, rumor, at_ms, false).await
}

/// Edit one of your own messages (kind 3302): peers re-render `target_id_hex`
/// with the replacement text. Author-enforced on the read side — only the
/// original author's edit folds.
pub async fn send_edit<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    target_id_hex: &str,
    new_content: &str,
) -> Result<String, String> {
    let (author_pk, group, epoch, session) = chat_send_context(community, channel_id)?;
    let at_ms = now_ms();
    let rumor = chat::build_edit_rumor(author_pk, channel_id, epoch, target_id_hex, new_content, at_ms);
    publish_chat(transport, community, &session, &group, author_pk, channel_id, epoch, rumor, at_ms, false).await
}

/// Cooperative in-plane delete (kind 5, NIP-09 semantics): peers stop rendering
/// `target_id_hex`. The wrap ciphertext on relays is scrubbed separately via the
/// retained per-message stream key (see `publish_chat`).
pub async fn send_delete<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    target_id_hex: &str,
    target_kind: u16,
) -> Result<String, String> {
    let (author_pk, group, epoch, session) = chat_send_context(community, channel_id)?;
    let at_ms = now_ms();
    let rumor = chat::build_delete_rumor(author_pk, channel_id, epoch, target_id_hex, target_kind, at_ms, None);
    publish_chat(transport, community, &session, &group, author_pk, channel_id, epoch, rumor, at_ms, false).await
}

/// Moderation-hide: remove SOMEONE ELSE's message under `MANAGE_MESSAGES`
/// (CORD-04 §3/§5). Same kind-5 the author's own delete uses — CORD defines no
/// separate hide, the authority is what differs, and every reader re-derives it
/// from the seal's real npub against the folded Roster.
///
/// Gated locally against the same predicate peers enforce, so the button can't
/// promise what the plane will refuse; a non-owner cites the Grant it acts under.
/// `target_author` comes from the caller's resident copy — you can only moderate
/// a message you can see.
pub async fn moderation_delete<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    target_id_hex: &str,
    target_kind: u16,
    target_author: &PublicKey,
) -> Result<String, String> {
    let (author_pk, group, epoch, session) = chat_send_context(community, channel_id)?;
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    if crate::db::community::get_community_dissolved(&cid_hex).unwrap_or(false) {
        return Err("this community is dissolved — it accepts no new moderation actions".to_string());
    }
    let owner_hex = community.owner()?.to_hex();
    let roster = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    if !crate::community::moderation::can_hide(
        Some(&owner_hex),
        &roster,
        &author_pk.to_hex(),
        &target_author.to_hex(),
    ) {
        return Err("you can't hide a message from a member who outranks you (or the owner)".to_string());
    }
    let at_ms = now_ms();
    let citation = required_authority_citation(community, &author_pk)?;
    let rumor = chat::build_delete_rumor(author_pk, channel_id, epoch, target_id_hex, target_kind, at_ms, citation.as_ref());
    publish_chat(transport, community, &session, &group, author_pk, channel_id, epoch, rumor, at_ms, false).await
}

/// WebXDC realtime peer signal (kind 3310) — the v2 twin of v1's
/// `publish_webxdc_signal`: the same shared content shape, sealed on the
/// channel's chat plane, DURABLE (a reopening peer backfills a recent ad).
/// Signed by the member's real identity — a member can't forge another
/// player's presence. Failure is non-fatal to callers (the next re-advertise
/// covers a missed ad).
pub async fn send_webxdc_signal<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    topic_id: &str,
    node_addr: Option<&str>,
) -> Result<(), String> {
    let (author_pk, group, epoch, session) = chat_send_context(community, channel_id)?;
    let at_ms = now_ms();
    let content = crate::webxdc::peer_signal_content(topic_id, node_addr);
    let rumor = chat::build_webxdc_rumor(author_pk, channel_id, epoch, &content, vec![], at_ms);
    publish_chat(transport, community, &session, &group, author_pk, channel_id, epoch, rumor, at_ms, false).await.map(|_| ())
}

/// Ephemeral typing indicator (kind 23311 in a 21059 wrap — relays never store it).
pub async fn send_typing<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
) -> Result<(), String> {
    let (author_pk, group, epoch, session) = chat_send_context(community, channel_id)?;
    let at_ms = now_ms();
    let rumor = chat::build_typing_rumor(author_pk, channel_id, epoch, at_ms);
    publish_chat(transport, community, &session, &group, author_pk, channel_id, epoch, rumor, at_ms, true).await.map(|_| ())
}

/// Everything a chat-plane send needs: local keys, the channel's group key +
/// epoch, and the session snapshot taken BEFORE any await. Refuses a dissolved
/// community (every honest member sealed it read-only) and a keyless Private
/// channel — deriving from the root would post to the public plane; its key
/// arrives over the rekey plane.
fn chat_send_context(community: &CommunityV2, channel_id: &ChannelId) -> Result<(PublicKey, GroupKey, Epoch, SessionGuard), String> {
    let session = SessionGuard::capture();
    let author_pk = me_pk()?;
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    if crate::db::community::get_community_dissolved(&cid_hex).unwrap_or(false) {
        return Err("this community has been dissolved".to_string());
    }
    // A self-ban: every honest peer drops our events (CORD-04 §4) and the send
    // echo would silently no-op, so fail loudly instead of a message that seems
    // to send but shows up nowhere.
    if crate::db::community::get_community_banlist(&cid_hex).unwrap_or_default().contains(&author_pk.to_hex()) {
        return Err("you are banned from this community".to_string());
    }
    let ch = community.channel(channel_id).ok_or("no such channel in this community")?;
    if ch.private && ch.key.is_none() {
        return Err("this private channel has no key yet (awaiting rekey delivery)".to_string());
    }
    let (secret, epoch) = community.channel_secret(ch);
    Ok((author_pk, channel_group_key(&secret, channel_id, epoch), epoch, session))
}

/// Seal one chat rumor, re-check the session, publish, and echo the send into the
/// shared store. Returns the rumor id (hex).
#[allow(clippy::too_many_arguments)]
async fn publish_chat<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    session: &SessionGuard,
    group: &GroupKey,
    author_pk: PublicKey,
    channel_id: &ChannelId,
    epoch: Epoch,
    rumor: nostr_sdk::prelude::UnsignedEvent,
    at_ms: u64,
    ephemeral: bool,
) -> Result<String, String> {
    let rumor_id = rumor.id.ok_or("rumor has no id")?.to_hex();
    let signer = crate::signer::active_signer()?;
    let (wrap, _p_tag_keys) = chat::seal_chat_rumor_signed(&signer, author_pk, &rumor, group, Timestamp::from_secs(at_ms / 1000), ephemeral).await
        .map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed before send".to_string());
    }
    transport.publish(&wrap, &community.relays).await?;
    // Retain the wrap's signing key (the group stream key) keyed by rumor id so a
    // full delete can NIP-09 this exact wrap off relays (same-author rule, honored
    // everywhere — the discarded p-tag pair only works on recipient-delete relays).
    // Frozen per-message so later rekeys can't strand it. Session-gated: the publish
    // straddled network I/O.
    if !ephemeral {
        if !session.is_valid() {
            return Ok(rumor_id);
        }
        crate::db::community::store_message_key(&rumor_id, &wrap.id.to_hex(), group.keys(), &community.relays)?;
    }
    // Local echo (v1 parity): open our OWN wrap through the exact inbound path so
    // send-then-read works with no listen loop, and the relay's re-delivery dedups
    // against this row instead of re-firing callbacks. Best-effort — the publish
    // already succeeded. Ephemeral kinds (typing) apply to nothing and skip out.
    if !ephemeral {
        if let Ok(event) = chat::open_chat_event(&wrap, group, channel_id, epoch) {
            let channel_hex = crate::simd::hex::bytes_to_hex_32(&channel_id.0);
            let outcome = {
                let mut st = crate::state::STATE.lock().await;
                if !session.is_valid() {
                    return Ok(rumor_id); // swapped on the lock await — never echo into another account.
                }
                super::inbound::apply_chat_to_state(&mut st, &event, &channel_hex, &author_pk)
            };
            if let Some(outcome) = outcome {
                if !session.is_valid() {
                    return Ok(rumor_id);
                }
                super::inbound::persist_chat(&channel_hex, &outcome).await;
            }
        }
    }
    Ok(rumor_id)
}

/// A chat event opened from a channel fetch, tagged with the epoch its key
/// decrypted under.
pub struct FetchedEvent {
    pub event: ChatEvent,
    pub epoch: Epoch,
}

/// Self-heal scrub-key retention for an OWN rumor seen during a history open:
/// pre-retention and other-device sends stay fully deletable, because the wrap's
/// signing key is the derivable group stream key — only this rumor→wrap mapping
/// was ever missing locally. No-op for foreign authors, kinds the UI can't
/// delete, and already-retained rows. Best-effort: a store failure never breaks
/// the fetch.
fn heal_own_wrap_key(event: &ChatEvent, group: &GroupKey, relays: &[String]) {
    if !matches!(event, ChatEvent::Message { .. } | ChatEvent::Reaction { .. }) {
        return;
    }
    let opened = event.opened();
    if crate::state::my_public_key() != Some(opened.author) {
        return;
    }
    let rumor_hex = opened.rumor_id.to_hex();
    // Only fill a confirmed gap — never clobber a send-time row, never write
    // when the store can't be read.
    if !matches!(crate::db::community::get_message_key(&rumor_hex), Ok(None)) {
        return;
    }
    if crate::db::community::store_message_key(&rumor_hex, &opened.wrapper_id.to_hex(), group.keys(), relays).is_ok() {
        // The UI caches full-vs-limited delete verdicts per message; tell it this
        // one just flipped so it re-resolves without an app restart.
        crate::traits::emit_event("message_delete_meta_changed", &serde_json::json!({ "id": rumor_hex }));
    }
}

/// Fetch a channel's newest messages — one page of [`fetch_channel_history`].
/// `limit` is one relay-side bound across the whole epoch-author OR-set, not
/// per epoch; deeper history pages backwards via the walk.
pub async fn fetch_channel<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    limit: usize,
) -> Result<Vec<FetchedEvent>, String> {
    fetch_channel_history(transport, community, channel_id, limit, 1, None, None, crate::community::transport::Evidence::Quorum, |_| true).await
}

/// Walk a channel's history newest-first (CORD-03 §3 "clients load a Channel
/// newest-first and paginate backwards"), querying every held epoch's Chat-Plane
/// address one `page`-sized query at a time until `max_pages`, a drained relay,
/// or `keep_paging` returns false for a page (the caller's "I already hold
/// these" early stop — consulted only on pages that opened something, so junk
/// at the address can't fake exhaustion). Pages step by INCLUSIVE `until` with
/// wrap-id dedup, so a page boundary landing mid-second can't skip siblings; a
/// full page of only-already-seen wraps is a same-second WALL (relay filters
/// are second-granular) and steps past it accepting that unseen same-second
/// siblings beyond the relay cap are unreachable — logged, and a protocol-level
/// limitation (the `ms` tag can't be filtered server-side).
///
/// Returns everything opened, deduped by rumor id, oldest→newest.
pub async fn fetch_channel_history<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    page: usize,
    max_pages: usize,
    since: Option<u64>,
    // Unix-seconds upper bound for the FIRST page (inclusive) — the back-paging
    // cursor. `None` starts at the newest.
    start_until: Option<u64>,
    evidence: crate::community::transport::Evidence,
    mut keep_paging: impl FnMut(&[FetchedEvent]) -> bool,
) -> Result<Vec<FetchedEvent>, String> {
    // Guards the opportunistic scrub-key heals below — the fetch loop straddles
    // network I/O, and an account swap must not write into the new account's DB.
    let session = SessionGuard::capture();
    let ch = community.channel(channel_id).ok_or("no such channel in this community")?;
    // A Public channel reads across EVERY held base-root epoch, and a Private one
    // across its OWN held epochs (CORD-03 §3), so history spanning a rotation stays
    // continuous either way. A keyless Private channel is unreadable — never derived
    // from the root (that would address the public plane).
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let coords: Vec<([u8; 32], Epoch)> = if ch.private {
        let Some(current) = ch.key else {
            return Ok(Vec::new());
        };
        let ch_hex = crate::simd::hex::bytes_to_hex_32(&ch.id.0);
        let mut held = crate::db::community::held_epoch_keys(&cid_hex, &ch_hex).unwrap_or_default();
        if !held.iter().any(|(ep, _)| *ep == ch.epoch) {
            held.push((ch.epoch, current));
        }
        // Only real grants are archived, but keep the invariant local: a private
        // plane is never read with the root value.
        held.into_iter().filter(|(_, k)| *k != community.community_root).map(|(ep, k)| (k, ep)).collect()
    } else {
        let mut roots = crate::db::community::held_epoch_keys(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX).unwrap_or_default();
        if !roots.iter().any(|(ep, _)| *ep == community.root_epoch) {
            roots.push((community.root_epoch, community.community_root));
        }
        roots.into_iter().map(|(ep, root)| (root, ep)).collect()
    };
    if coords.is_empty() {
        return Ok(Vec::new());
    }

    let mut seen_wraps: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
    let mut seen_rumors = std::collections::HashSet::new();
    let mut out: Vec<(u64, FetchedEvent)> = Vec::new();
    let mut until: Option<u64> = start_until;
    let mut oldest: Option<u64> = None;
    for _ in 0..max_pages {
        // Fetch each held epoch's Chat-Plane AUTHED AS that plane key. AUTH-gating
        // relays (Ditto) require the connection authed as the author queried and
        // reject a multi-author REQ ("all authors must be authenticated"), so a
        // single merged fetch returns nothing there — the latest messages under a
        // freshly-adopted epoch never load. Per-plane authed fetches + union.
        let mut wraps: Vec<Event> = Vec::new();
        let mut wrap_ids: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
        for (secret, epoch) in &coords {
            let plane = channel_group_key(secret, channel_id, *epoch);
            let q = Query {
                kinds: vec![stream::KIND_WRAP],
                authors: vec![plane.pk_hex()],
                since,
                until,
                limit: Some(page),
                evidence,
                ..Default::default()
            };
            if let Ok(evs) = transport.fetch_plane(plane.keys(), &q, &community.relays).await {
                for e in evs {
                    if wrap_ids.insert(e.id) {
                        wraps.push(e);
                    }
                }
            }
        }
        if wraps.is_empty() {
            break;
        }
        let mut fresh = 0usize;
        let mut page_events: Vec<FetchedEvent> = Vec::new();
        for wrap in &wraps {
            if !seen_wraps.insert(wrap.id) {
                continue;
            }
            fresh += 1;
            let at = wrap.created_at.as_secs();
            if oldest.is_none_or(|o| at < o) {
                oldest = Some(at);
            }
            // Select the epoch whose group key authored this wrap (no trial decrypt).
            for (secret, epoch) in &coords {
                let group = channel_group_key(secret, channel_id, *epoch);
                if wrap.pubkey != group.pk() {
                    continue;
                }
                if let Ok(event) = chat::open_chat_event(wrap, &group, channel_id, *epoch) {
                    let id = event.opened().rumor_id;
                    if seen_rumors.insert(id) {
                        if session.is_valid() {
                            heal_own_wrap_key(&event, &group, &community.relays);
                        }
                        page_events.push(FetchedEvent { event, epoch: *epoch });
                    }
                }
                break;
            }
        }
        if fresh == 0 {
            if wraps.len() < page {
                break; // drained — the relay has nothing older.
            }
            // A full page of already-seen wraps: a same-second WALL. Step past it;
            // same-second siblings beyond the relay's cap are unreachable by a
            // second-granular filter.
            let Some(o) = oldest else { break };
            if o == 0 {
                break;
            }
            crate::log_warn!("v2: same-second history wall at {o} — stepping past it (messages beyond the relay page cap in that second are unreachable)");
            until = Some(o - 1);
            continue;
        }
        let stop = !page_events.is_empty() && !keep_paging(&page_events);
        out.extend(page_events.into_iter().map(|e| (e.event.opened().at_ms, e)));
        if stop {
            break; // the caller holds everything from here back.
        }
        until = oldest; // inclusive — wrap-id dedup absorbs the boundary overlap.
    }
    out.sort_by_key(|(ms, _)| *ms);
    Ok(out.into_iter().map(|(_, e)| e).collect())
}

// ── Invites (CORD-05) ────────────────────────────────────────────────────────

/// Who an invite bundle is FOR — which decides the Private-Channel keys it may
/// carry (CORD-05 §1 vs §2).
///
/// A **Link** has no recipient: "anyone the link reaches can join", so its
/// audience holds no Role by construction and is entitled to no Private Channel
/// at all. A **Member** is a specific npub whose entitlement is computable.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BundleAudience {
    /// A public link (33301 bundle event): public channels only.
    Link,
    /// A direct invite (3313) to this npub: may carry Private-Channel keys.
    Member(PublicKey),
}

/// Build the §1 invite bundle for this community, scoped to `audience`. A
/// Public channel carries the `community_root` as its "key" (the joiner derives
/// the real secret from the root); a Private one its own key — and only for a
/// Member the folded roster shows entitled. The bundle self-certifies the owner,
/// so the inviter's identity is irrelevant to trust.
pub fn bundle_of(
    community: &CommunityV2,
    audience: BundleAudience,
    creator: Option<PublicKey>,
    expires_at_ms: Option<u64>,
    label: Option<String>,
) -> CommunityInvite {
    bundle_of_with_overlay(community, audience, creator, expires_at_ms, label, &[], &[])
}

/// [`bundle_of`] settling entitlement against a Grant this client JUST published
/// (`with`/`without` role ids), since the fold lags its own publish. This is the
/// grant-vend path (CORD-03 "delivered on grant").
pub fn bundle_of_with_overlay(
    community: &CommunityV2,
    audience: BundleAudience,
    creator: Option<PublicKey>,
    expires_at_ms: Option<u64>,
    label: Option<String>,
    with: &[String],
    without: &[String],
) -> CommunityInvite {
    let hex = crate::simd::hex::bytes_to_hex_32;
    let cid_hex = hex(&community.identity.community_id.0);
    let roster = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    let owner_hex = community.owner().ok().map(|o| o.to_hex());
    let recipient_hex = match audience {
        BundleAudience::Link => None,
        BundleAudience::Member(pk) => Some(pk.to_hex()),
    };
    let channels = community
        .vendable_channels(&roster, owner_hex.as_deref(), recipient_hex.as_deref(), with, without)
        .into_iter()
        .map(|c| invite::ChannelGrant {
            id: hex(&c.id.0),
            key: hex(&c.key.unwrap_or(community.community_root)),
            epoch: c.epoch.0,
            name: c.name.clone(),
        })
        .collect();
    CommunityInvite {
        community_id: hex(&community.identity.community_id.0),
        owner: hex(&community.identity.owner_xonly),
        owner_salt: hex(&community.identity.owner_salt),
        community_root: hex(&community.community_root),
        root_epoch: community.root_epoch.0,
        channels,
        relays: community.relays.clone(),
        name: community.name.clone(),
        // Mint-time snapshot so a parked invite renders the real logo before any
        // fold; the Control Plane stays the authority after joining.
        icon: community.icon.clone(),
        expires_at: expires_at_ms,
        creator_npub: creator.map(|p| p.to_hex()),
        label,
        extra: Default::default(),
    }
}

/// Gift-wrap a Direct Invite (kind 3313) of this community straight to `recipient`
/// and publish it to the community relays. `expires_at_ms` (unix ms) optionally
/// bounds its shelf life; `label` is echoed in the joiner's Guestbook Join. The
/// bundle hands over the keys; the recipient consents by accepting (nothing joins
/// on receipt). Returns the wrap.
pub async fn send_direct_invite<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    recipient: &PublicKey,
    expires_at_ms: Option<u64>,
    label: Option<String>,
) -> Result<Event, String> {
    let session = SessionGuard::capture();
    // A stale bundle is worse than a stale edit: it hands the joiner keys to a
    // buried epoch, and their client later self-evicts on the rekey exclusion.
    assert_current_root(community)?;
    let signer = crate::signer::active_signer()?;
    let inviter_pk = me_pk()?;
    let bundle = bundle_of(community, BundleAudience::Member(*recipient), Some(inviter_pk), expires_at_ms, label);
    let wrap = invite::build_direct_invite_signed(&signer, inviter_pk, recipient, &bundle).await.map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed before sending invite".to_string());
    }
    transport.publish(&wrap, &community.relays).await?;
    Ok(wrap)
}

/// A minted public link: the shareable URL plus the addressable bundle event to
/// publish and the link keypair to retain (in the Invite List) for later refresh
/// or revocation.
pub struct MintedLink {
    pub url: String,
    pub bundle_event: Event,
    pub link_signer: Keys,
    pub token: [u8; super::derive::TOKEN_LEN],
    /// Unix ms, mirrored from the bundle. The Invite List is the creator's only
    /// record of it, and the Registry prunes on it — the coordinate a member
    /// folds carries no expiry, so a lapsed link the creator never pruned reads
    /// as a live door forever (CORD-05 §4/§5).
    pub expires_at_ms: Option<u64>,
    pub label: Option<String>,
}

/// Mint a public invite link for this community: a fresh token + link keypair, the
/// bundle encrypted under the token key and published at `(33301, link_signer,
/// "")`, and the `base/invite/<naddr>#<fragment>` URL. `base` is the deep-link
/// domain (e.g. `https://vectorapp.io`); the fragment carries the token + bootstrap
/// relays and never reaches a server.
pub async fn mint_public_link<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    base: &str,
    expires_at_ms: Option<u64>,
    label: Option<String>,
) -> Result<MintedLink, String> {
    let session = SessionGuard::capture();
    let mut token = [0u8; super::derive::TOKEN_LEN];
    token.copy_from_slice(&super::super::random_32()[..super::derive::TOKEN_LEN]);
    let link_signer = Keys::generate();
    let bundle = bundle_of(community, BundleAudience::Link, Some(me_pk()?), expires_at_ms, label.clone());
    let bundle_key = super::derive::invite_bundle_key(&token);
    let bundle_event = invite::build_bundle_event(&link_signer, &bundle, &bundle_key).map_err(|e| e.to_string())?;
    let url = invite::build_invite_url(base, &link_signer.public_key(), &token, &community.relays).map_err(|e| e.to_string())?;

    if !session.is_valid() {
        return Err("account changed before minting link".to_string());
    }
    transport.publish_durable(&bundle_event, &community.relays).await?;
    let minted = MintedLink { url, bundle_event, link_signer, token, expires_at_ms, label: label.clone() };
    // Sync the link across the creator's devices (13303) + publish the Registry
    // (vsk-8) so members see the community is Public. Best-effort — the link works
    // without the sync.
    let _ = record_minted_link(transport, community, &minted).await;
    // Local mirror so `list_public_invites` stays a sync local read (v1 parity);
    // the 13303 list remains the cross-device record. Re-check the session: the
    // publishes above straddled awaits, and this write must not land account A's
    // link (secret token included) in a swapped-in account's DB.
    if session.is_valid() {
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let token_hex = crate::simd::hex::bytes_to_hex_16(&minted.token);
        let _ = crate::db::community::save_public_invite(&token_hex, &cid_hex, &minted.url, expires_at_ms.map(|e| e as i64), label.as_deref());
    }
    Ok(minted)
}

// ── The Invite Registry (vsk 8) + Invite List (13303), CORD-05 §4/§5 ──────────

/// Fetch the creator's own 13303 Invite List from `relays` (newest wins; a
/// decrypt/parse failure is "no news", never a clobber of the local mirror).
/// Transport failure is Err, NOT None: the 13303 is REPLACEABLE, so a caller
/// that mistakes "couldn't reach the relays" for "no list yet" and publishes a
/// fresh one wipes every link minted on other devices. Full evidence for the
/// same reason — this read feeds replaceable-event writes.
async fn fetch_invite_list<T: Transport + ?Sized>(
    transport: &T,
    relays: &[String],
) -> Result<Option<invite::InviteList>, String> {
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let query = Query {
        kinds: vec![super::kind::INVITE_LIST],
        authors: vec![my_pk.to_hex()],
        limit: Some(4),
        evidence: crate::community::transport::Evidence::Full,
        ..Default::default()
    };
    let events = transport.fetch(&query, relays).await?;
    let mut best: Option<(u64, invite::InviteList)> = None;
    for e in events {
        if let Ok(l) = invite::parse_invite_list_event_signed(&signer, my_pk, &e).await {
            let at = e.created_at.as_secs();
            if best.as_ref().map(|(b, _)| at > *b).unwrap_or(true) {
                best = Some((at, l));
            }
        }
    }
    Ok(best.map(|(_, l)| l))
}

/// The creator's LIVE link-signer pubkeys for one community — the Registry's
/// content (CORD-05 §5), derived from the stored link secrets.
///
/// Live means neither tombstoned nor EXPIRED. An expired link cannot be joined
/// (`InviteBundle::expired`, CORD-05 §1), so leaving it in the Registry states
/// a door that isn't there: the aggregate never empties, the community reads
/// Public forever, and every gate hanging off that reading silently inverts.
fn live_signers_for(list: &invite::InviteList, community_id_hex: &str, now_ms: u64) -> Vec<PublicKey> {
    let dead: std::collections::HashSet<&str> = list.tombstones.iter().map(|t| t.token.as_str()).collect();
    list.entries
        .iter()
        .filter(|e| e.community_id == community_id_hex && !dead.contains(e.token.as_str()))
        .filter(|e| !e.expires_at.is_some_and(|exp| now_ms > exp))
        .filter_map(|e| Keys::parse(&e.signer_sk).ok().map(|k| k.public_key()))
        .collect()
}

/// Publish the creator's Registry (vsk-8) edition — their live link signers for this
/// community — so members fold it into the Public/Private source of truth (a
/// non-empty aggregate = Public).
async fn publish_invite_registry<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, session: &SessionGuard, live_signers: &[PublicKey]) -> Result<(), String> {
    let my_pk = me_pk()?;
    let eid = super::derive::invite_links_locator(community.id(), &my_pk.to_bytes());
    let content = invite::build_registry_content(live_signers);
    publish_control_edition(transport, community, session, vsk::INVITE_LINKS, &eid, &content).await?;
    // Refresh the cache from the PLANE, not from `live_signers`: the column aggregates
    // every creator, so writing only mine would clobber theirs, and a union could never
    // shrink — retiring the last link would leave the community reading Public forever.
    refresh_invite_registry_cache(transport, community, session).await;
    Ok(())
}

/// Re-fold the whole invite Registry and cache it, so Public/Private stays a sync
/// LOCAL read. Silent no-op when the plane can't be read whole — a partial fold
/// would under-state Public, leaving a live link open behind a ban.
async fn refresh_invite_registry_cache<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, session: &SessionGuard) {
    let Ok(owner) = community.owner() else { return };
    let Some(editions) = fetch_control_plane_whole(transport, community).await else { return };
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let floors: Floors = crate::db::community::get_all_edition_heads_full(&cid_hex)
        .unwrap_or_default()
        .into_iter()
        .filter(|(_, f)| f.0 == community.root_epoch.0)
        .map(|(entity, f)| (entity, (f.1, f.2, f.3)))
        .collect();
    let authority = fold_authority(community, &editions, &floors);
    let sets = live_invite_link_sets(community.id(), &owner.to_hex(), &editions, &authority, &floors);
    if session.is_valid() {
        let _ = crate::db::community::set_community_invite_registry(&cid_hex, &flatten_link_sets(&sets));
        let _ = crate::db::community::replace_invite_link_sets(&cid_hex, &sets);
    }
}

/// Record a freshly-minted public link across the creator's devices: append it to the
/// 13303 Invite List and refresh the Registry (CORD-05 §4/§5).
async fn record_minted_link<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, minted: &MintedLink) -> Result<(), String> {
    let session = SessionGuard::capture();
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let token_hex = crate::simd::hex::bytes_to_hex_16(&minted.token);
    // Err aborts the sync half (the link's bundle already published durably;
    // a retry re-records it) — an unreachable relay set must never be mistaken
    // for "no list yet" and clobber the replaceable 13303. Ok(None) IS a fresh
    // creator's honest first list.
    let mut list = fetch_invite_list(transport, &community.relays).await?.unwrap_or_default();
    if !list.entries.iter().any(|e| e.token == token_hex) {
        list.entries.push(invite::InviteEntry {
            token: token_hex,
            signer_sk: minted.link_signer.secret_key().to_secret_hex(),
            community_id: cid_hex.clone(),
            url: minted.url.clone(),
            label: minted.label.clone(),
            created_at: now_ms() / 1000,
            expires_at: minted.expires_at_ms,
            extra: Default::default(),
        });
    }
    if !session.is_valid() {
        return Err("account changed during link record".to_string());
    }
    let event = invite::build_invite_list_event_signed(&signer, my_pk, &list).await.map_err(|e| e.to_string())?;
    transport.publish(&event, &community.relays).await?;
    let signers = live_signers_for(&list, &cid_hex, now_ms());
    publish_invite_registry(transport, community, &session, &signers).await
}

/// Revoke a public link by its token hex (CORD-05 §2/§5): re-post its coordinate as a
/// revocation tombstone (retiring the bundle behind the URL, so a fetcher finds the
/// grave), tombstone the Invite List entry, and refresh the Registry. Retiring the
/// LAST live link empties the Registry → the community reads Private (a Refounding is
/// the owner's separate read-cut).
pub async fn revoke_public_link<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, token_hex: &str) -> Result<(), String> {
    let session = SessionGuard::capture();
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let mut list = fetch_invite_list(transport, &community.relays).await?.ok_or("no invite list found to revoke from")?;
    let entry = list
        .entries
        .iter()
        .find(|e| e.token == token_hex && e.community_id == cid_hex)
        .cloned()
        .ok_or("no such link in the invite list")?;
    // Re-post the bundle coordinate as a revocation tombstone (creator-signed).
    let link_signer = Keys::parse(&entry.signer_sk).map_err(|_| "malformed link signer")?;
    let revocation = invite::build_revocation(&link_signer).map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed during revoke".to_string());
    }
    transport.publish_durable(&revocation, &community.relays).await?;
    // Tombstone the Invite List entry (permanent — a stale device can't resurrect it).
    list.tombstones.push(invite::InviteTombstone { token: token_hex.to_string(), community_id: cid_hex.clone(), extra: Default::default() });
    list.entries.retain(|e| e.token != token_hex);
    let event = invite::build_invite_list_event_signed(&signer, my_pk, &list).await.map_err(|e| e.to_string())?;
    transport.publish(&event, &community.relays).await?;
    let signers = live_signers_for(&list, &cid_hex, now_ms());
    publish_invite_registry(transport, community, &session, &signers).await?;
    // Drop the local mirror row (sibling of the mint-time save) — only if still our session.
    if session.is_valid() {
        let _ = crate::db::community::delete_public_invite(token_hex);
    }
    Ok(())
}

/// Refresh every live public link's bundle behind its stable URL (CORD-05 §2) — e.g.
/// after a Rekey/Refounding rolled the keys — by re-posting the bundle at the same
/// coordinate with the CURRENT community state, so a link shared once keeps working
/// across rotations. Best-effort.
pub async fn refresh_public_links<T: Transport + ?Sized>(transport: &T, community: &CommunityV2) -> Result<(), String> {
    let session = SessionGuard::capture();
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    // Fetch inline (not via fetch_invite_list) so a TRANSPORT FAILURE propagates as
    // Err — the caller (a post-refounding refresh) must be able to retry, or live
    // links keep serving the PRE-refound root and new joiners land on the dead
    // epoch. A genuinely-empty list is Ok (nothing to refresh).
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let query = Query {
        kinds: vec![super::kind::INVITE_LIST],
        authors: vec![my_pk.to_hex()],
        limit: Some(4),
        ..Default::default()
    };
    let events = transport.fetch(&query, &community.relays).await?;
    let mut best: Option<(u64, invite::InviteList)> = None;
    for e in events {
        if let Ok(l) = invite::parse_invite_list_event_signed(&signer, my_pk, &e).await {
            let at = e.created_at.as_secs();
            if best.as_ref().map(|(b, _)| at > *b).unwrap_or(true) {
                best = Some((at, l));
            }
        }
    }
    let Some((_, list)) = best else {
        return Ok(());
    };
    let creator = my_pk;
    let now = now_ms();
    let dead: std::collections::HashSet<&str> = list.tombstones.iter().map(|t| t.token.as_str()).collect();
    for entry in &list.entries {
        if entry.community_id != cid_hex || dead.contains(entry.token.as_str()) || entry.token.len() != 2 * super::derive::TOKEN_LEN {
            continue;
        }
        // An expired link can't be joined, so refreshing it just re-states a
        // door that isn't there (CORD-05 §1/§5).
        if entry.expires_at.is_some_and(|exp| now > exp) {
            continue;
        }
        let Ok(link_signer) = Keys::parse(&entry.signer_sk) else { continue };
        let token = crate::simd::hex::hex_to_bytes_16(&entry.token);
        let bundle = bundle_of(community, BundleAudience::Link, Some(creator), entry.expires_at, entry.label.clone());
        let bundle_key = super::derive::invite_bundle_key(&token);
        if let Ok(event) = invite::build_bundle_event(&link_signer, &bundle, &bundle_key) {
            if !session.is_valid() {
                return Err("account changed during link refresh".to_string());
            }
            let _ = transport.publish_durable(&event, &community.relays).await;
        }
    }
    // Republish the Registry from the same pruned view. Expiry is the one way a
    // link dies with no user action, so without a heal point here the aggregate
    // never empties and the community reads Public long after its last door
    // shut (CORD-05 §5). Idempotent when nothing lapsed.
    //
    // Only for a creator who actually minted here: one Invite List spans every
    // community, so a member holding links ELSEWHERE would otherwise publish an
    // empty Registry edition into this one on every rotation they adopt — a
    // control-plane write, and a version bump, for a coordinate they never owned.
    let mine_here = list.entries.iter().any(|e| e.community_id == cid_hex);
    if !mine_here {
        return Ok(());
    }
    let signers = live_signers_for(&list, &cid_hex, now);
    if !session.is_valid() {
        return Err("account changed during link refresh".to_string());
    }
    let _ = publish_invite_registry(transport, community, &session, &signers).await;
    Ok(())
}

/// Whether this community is PUBLIC (CORD-05 §5): fold every creator's Registry
/// (vsk-8) that its author is authorized for (`CREATE_INVITE`, bound to their
/// coordinate) into an aggregate live-link set — non-empty ⇒ a live link exists ⇒
/// Public; empty ⇒ Private. Retiring the last link is what flips it back.
pub async fn community_is_public<T: Transport + ?Sized>(transport: &T, community: &CommunityV2) -> bool {
    let Ok(owner) = community.owner() else { return false };
    // Truncation fails toward Public: over-stating it only makes a caller take the
    // stronger remedy (privatise + re-found + reissue), while under-stating it
    // leaves a live link open behind a ban.
    let Some(editions) = fetch_control_plane_whole(transport, community).await else { return true };
    let cid = community.id();
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&cid.0);
    let floors: Floors = crate::db::community::get_all_edition_heads_full(&cid_hex)
        .unwrap_or_default()
        .into_iter()
        .filter(|(_, f)| f.0 == community.root_epoch.0)
        .map(|(entity, f)| (entity, (f.1, f.2, f.3)))
        .collect();
    let authority = fold_authority(community, &editions, &floors);
    !live_invite_link_sets(cid, &owner.to_hex(), &editions, &authority, &floors).is_empty()
}

/// Page the WHOLE control plane, not the newest window: a registry pushed out of a
/// single page reads as retired, and any member can push it out since the plane key
/// comes from the community root they hold. `None` = it could NOT be read whole
/// (transport failure, same-second wall, pager depth), so a caller must not mistake
/// an empty fold for absence.
async fn fetch_control_plane_whole<T: Transport + ?Sized>(transport: &T, community: &CommunityV2) -> Option<Vec<ParsedEdition>> {
    let control = control_group_key(&community.community_root, community.id(), community.root_epoch);
    let mut editions: Vec<ParsedEdition> = Vec::new();
    let mut seen_wraps: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
    let mut oldest: Option<u64> = None;
    let mut until: Option<u64> = None;
    for page in 0..COMPACT_MAX_PAGES {
        // Quorum, DECLARED (the until→Full transport floor is gone): these
        // control reads tolerate a partial union — their fold semantics are
        // fail-safe on gaps (seeded banlists, withheld roster cache).
        let query = Query {
            kinds: vec![stream::KIND_WRAP],
            authors: vec![control.pk_hex()],
            until,
            limit: Some(FOLLOW_PAGE),
            evidence: crate::community::transport::Evidence::Quorum,
            ..Default::default()
        };
        let Ok(wraps) = transport.fetch(&query, &community.relays).await else { return None };
        let mut fresh = 0usize;
        for w in &wraps {
            if !seen_wraps.insert(w.id) {
                continue;
            }
            fresh += 1;
            let at = w.created_at.as_secs();
            if oldest.is_none_or(|o| at < o) {
                oldest = Some(at);
            }
            if let Ok((ed, _)) = control::open_control_edition(w, &control) {
                editions.push(ed);
            }
        }
        if fresh == 0 {
            if wraps.len() >= FOLLOW_PAGE {
                return None; // same-second wall: the plane can't be read whole
            }
            return Some(editions);
        }
        until = oldest;
        if page + 1 == COMPACT_MAX_PAGES {
            return None;
        }
    }
    Some(editions)
}

/// The live link coordinates PER AUTHORISED CREATOR across every Registry (vsk-8);
/// non-empty ⇒ the Community is Public, and the per-creator split is what drives
/// "X has N active invite links". Pure over an already-fetched edition set so the
/// on-demand probe and the control follow fold it identically.
fn live_invite_link_sets(
    cid: &crate::community::CommunityId,
    owner_hex: &str,
    editions: &[ParsedEdition],
    authority: &AuthoritySet,
    floors: &Floors,
) -> Vec<crate::db::community::InviteLinkSetRow> {
    use crate::community::roles::Permissions;
    use std::collections::BTreeMap;
    let mut by_eid: BTreeMap<[u8; 32], Vec<&ParsedEdition>> = BTreeMap::new();
    for e in editions {
        if e.vsk == vsk::INVITE_LINKS {
            by_eid.entry(e.entity_id).or_default().push(e);
        }
    }
    let mut sets: Vec<crate::db::community::InviteLinkSetRow> = Vec::new();
    for (eid, group) in &by_eid {
        // Authority BEFORE the fold, matching `apply_control_fold`. `fold_head`
        // picks an equal-version winner author-blind (lowest inner id, which an
        // author can grind), so folding first would let any member occupy the head
        // slot and have the whole registry dropped by the check below — silently
        // retiring a live invite link, i.e. flipping the community to Private.
        let authed: Vec<&ParsedEdition> = group
            .iter()
            .copied()
            .filter(|p| {
                let author = p.author.to_hex();
                // The creator must hold CREATE_INVITE, not be banned, AND own this coordinate.
                !authority.banned.contains(&author)
                    && authority.roles.is_authorized(&author, Some(owner_hex), Permissions::CREATE_INVITE)
                    && super::derive::invite_links_locator(cid, &p.author.to_bytes()) == *eid
            })
            .collect();
        if authed.is_empty() {
            continue;
        }
        let fold_eds: Vec<version::Edition> = authed.iter().map(|p| p.to_fold_edition()).collect();
        let (Some(hi), _) = fold_head(&fold_eds, floors.get(&crate::simd::hex::bytes_to_hex_32(eid))) else { continue };
        if let Ok(signers) = invite::parse_registry_content(&authed[hi].content) {
            if signers.is_empty() {
                continue; // a creator who retired every link is absent, not a zero row
            }
            sets.push(crate::db::community::InviteLinkSetRow {
                creator_hex: authed[hi].author.to_hex(),
                locators: signers.iter().map(|p| p.to_hex()).collect(),
            });
        }
    }
    sets
}

/// Flatten per-creator sets into the aggregate the `invite_registry` column holds.
fn flatten_link_sets(sets: &[crate::db::community::InviteLinkSetRow]) -> Vec<String> {
    let mut flat: Vec<String> = sets.iter().flat_map(|s| s.locators.iter().cloned()).collect();
    flat.sort();
    flat.dedup();
    flat
}

/// Accept an already-unwrapped bundle: verify the owner commitment AND that the
/// delivered community_root is genuinely the owner's, persist the community, and
/// announce a Guestbook Join (with invite attribution). Shared tail of both accept
/// paths. Takes the caller's `SessionGuard` (captured BEFORE any network fetch the
/// caller did) so the `is_valid()` gate straddles that I/O.
async fn accept_bundle<T: Transport + ?Sized>(
    transport: &T,
    session: &SessionGuard,
    bundle: &CommunityInvite,
    invited_by: Option<PublicKey>,
    announce_join: bool,
) -> Result<CommunityV2, String> {
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let at_ms = now_ms();
    // Expiry gate: a past invite still previews but must not join (CORD-05 §1).
    if bundle.expired(at_ms) {
        return Err("this invite has expired".to_string());
    }
    // `from_bundle` re-validates bounds + the owner commitment fail-closed.
    let community = CommunityV2::from_bundle(bundle, at_ms)?;
    // Captured before the save below: a re-accept of a held community must not
    // re-announce a membership this account already declared.
    let already_held = crate::db::community::load_community_v2(community.id()).ok().flatten().is_some();

    // Authenticate the delivered community_root before trusting it. The owner
    // commitment proves WHO the owner is, but community_root (and channel keys) are
    // NOT in that commitment, so a forged invite can pair a real (id, owner, salt)
    // with an attacker-chosen root and silently partition the joiner onto planes
    // only the attacker controls. Requiring the owner's genesis to open under the
    // delivered root closes that eclipse; also reconciles channel classification.
    // A preview verified the SAME (id, root) moments ago → reuse its fold instead
    // of re-walking the plane (the bundle re-fetch above kept the revocation gate).
    let handoff = VERIFIED_PREVIEW.lock().unwrap().take().filter(|v| {
        v.session.is_valid()
            && v.at.elapsed() < VERIFIED_PREVIEW_TTL
            && v.community_id == community.id().0
            && v.community_root == community.community_root
    });
    let (community, join_heads, join_banlist) = match handoff {
        Some(v) => {
            let mut c = v.folded;
            // The preview holds no acquisition time — stamp the JOIN's.
            c.created_at_ms = at_ms;
            (c, v.heads, v.banned)
        }
        None => verify_owner_root_and_reconcile(transport, community).await?,
    };

    // A dissolved community is a grave (CORD-02 §9): refuse to join it.
    if is_dissolved(transport, &community).await {
        return Err("this community has been dissolved".to_string());
    }

    // Join-time ban gate (CORD-04 §4, Armada parity): an honest client refuses to join a
    // community whose authorized banlist names it — before the Guestbook Join publishes
    // and before any local write. Every door funnels through here (direct invite, parked,
    // public link, migration), so none of them needs its own exclusion.
    if join_banlist.contains(&my_pk.to_hex()) {
        return Err("you are banned from this community".to_string());
    }

    // The account must not have swapped since the guard was captured (which was
    // before any fetch the caller / the verify above performed) — else we'd write
    // A's join into B.
    if !session.is_valid() {
        return Err("account changed during join".to_string());
    }
    // Seed the verified heads as the initial refuse-downgrade floor BEFORE the
    // community row lands (floors-then-state, so a mid-seed error can't leave saved
    // state outrunning its floor); the first post-join follow then can't persist a
    // state below what this join already showed.
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    for h in &join_heads {
        crate::db::community::set_edition_head_at_epoch(&cid_hex, &h.entity_hex, h.version, &h.self_hash, &h.inner_id, community.root_epoch.0)?;
    }
    crate::db::community::save_community_v2(&community)?;
    // Archive the joined root at its epoch, so this member reads Public-channel
    // history from their join epoch onward across later Refoundings (CORD-03 §3).
    let _ = crate::db::community::store_epoch_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, community.root_epoch.0, &community.community_root);
    // Same for each granted Private-channel key: the archive is what lets its
    // history stay readable after the channel rotates away from this key.
    for ch in &community.channels {
        if let (true, Some(key)) = (ch.private, ch.key) {
            let _ = crate::db::community::store_epoch_key(&cid_hex, &crate::simd::hex::bytes_to_hex_32(&ch.id.0), ch.epoch.0, &key);
        }
    }

    // Announce our Guestbook Join, echoing the invite attribution when present.
    // Only an ACTUAL join speaks: a re-accept of a held community, or a
    // cross-device key sync (announce_join=false), is not a membership event —
    // the account's original Join already stands in the guestbook, and every
    // re-publish renders as "<user> has joined" spam for the whole community.
    if announce_join && !already_held {
        let attribution = invited_by
            .map(|p| p.to_hex())
            .or_else(|| bundle.creator_npub.clone())
            .zip(Some(bundle.label.clone().unwrap_or_default()));
        let attr_ref = attribution.as_ref().map(|(c, l)| (c.as_str(), l.as_str()));
        let gb_group = super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch);
        let join_rumor = guestbook::build_join_rumor(my_pk, attr_ref, at_ms);
        if let Ok((join_wrap, _)) = guestbook::seal_guestbook_rumor_signed(&signer, my_pk, &join_rumor, &gb_group, Timestamp::from_secs(at_ms / 1000)).await {
            let _ = transport.publish(&join_wrap, &community.relays).await;
        }
    }

    // Record the membership across devices (CORD-02 §8). The inline attempt covers the
    // happy path; anything else hands off to the durable retry, because an unrecorded
    // join is what strands a community behind a stale tombstone.
    match republish_community_list(transport, Some(community.id())).await {
        Ok(true) => {}
        Ok(false) => republish_community_list_durable(Some(*community.id())),
        Err(e) => {
            crate::log_warn!("[CommunityList] failed to record this join across devices ({}) — retrying", e);
            republish_community_list_durable(Some(*community.id()));
        }
    }
    Ok(community)
}

/// Prove the delivered `community_root` is genuinely the owner's, and reconcile
/// channel classification from the owner's editions. `community_id` commits only
/// to `(owner_xonly, owner_salt)` — both semi-public (they ride every bundle and
/// every synced Community List) — so a forged invite can present a real community's
/// id/owner/salt with an attacker-chosen root; every plane then derives from that
/// root, silently eclipsing the joiner onto attacker-controlled addresses while the
/// owner commitment still "verifies". The defense: the owner's genesis metadata
/// edition (vsk-0, `eid == community_id`) only opens under the AUTHENTIC root — an
/// attacker can't forge the owner's seal — so its presence on the control plane
/// derived from the delivered root proves that root. On a ROTATED plane (epoch > 0)
/// the compaction may have carried an admin-signed metadata head instead (CORD-06
/// re-wraps heads with their original signatures), so the anchor there is the
/// community-bound metadata head plus any owner-signed edition under the same root.
/// Fail-closed: no anchor (forged invite, or relays unreachable) → refuse to join.
/// On success, folds the owner's authoritative editions to heal a bundle that
/// misclassified a channel.
async fn verify_owner_root_and_reconcile<T: Transport + ?Sized>(
    transport: &T,
    community: CommunityV2,
) -> Result<(CommunityV2, Vec<FoldedHead>, std::collections::BTreeSet<String>), String> {
    let owner = community.owner()?;
    let control = control_group_key(&community.community_root, community.id(), community.root_epoch);
    let control_pk = control.pk_hex();

    // AUTH-gating relays (ditto-relay's default gates kind-1059) serve a plane's
    // wraps ONLY to a connection authenticated AS the stream key — Concord's
    // group-addressed wraps aren't p-tagged to the joiner, so the login alone can't
    // satisfy the gate and the control plane reads back empty. Register this
    // community's stream keys + start the challenge responder so the fetch below
    // (whose REQ triggers the relay's AUTH challenge) reads the plane after auth.
    super::streamauth::prime(&community);

    // Authenticity = the owner's GENESIS metadata edition (vsk-0, `eid ==
    // community_id`) at the root-derived control plane. The genesis eid pins it to
    // THIS community, and it lives ONLY under the real root — so a forged root can't
    // produce one: an edition's seal carries no community binding, but another
    // community's genesis has a different eid, and this community's own genesis is
    // unreadable without its real root (which the forger lacks). ("Any owner edition"
    // is NOT sound: an owner sig from any co-owned community, rewrapped onto the fake
    // plane, would pass — reopening the eclipse.) The residual — a T-member replaying
    // T's genesis onto a fake root to MITM another T-joiner — is closed only by
    // binding the root into community_id (protocol, deferred).
    //
    // Seed `until` with a FAR-FUTURE constant (NOT now-based), and request
    // Evidence::Full EXPLICITLY below: this walk draws an ABSENCE verdict (no
    // owner-signed genesis ⇒ reject), which trusts only the completest union —
    // an open partial window misses a genesis on a lagging relay (routine over
    // Tor). A constant beyond any real created_at clips NOTHING — so neither
    // a clock-skewed future-dated genesis nor a >1h-slow-clock joiner is excluded (a
    // now-based bound could clip either). Break on an EMPTY page (a short page is a
    // relay cap). A forged root walks to exhaustion and rejects; a flood/deep plane
    // that buries the genesis past the walk is the deferred protocol residual.
    const PAGE: usize = 500;
    const MAX_PAGES: usize = 4;
    const FAR_FUTURE_SECS: u64 = 4_102_444_800; // ~year 2100 — above any real edition, safe as a relay `until`.
    let mut editions: Vec<ParsedEdition> = Vec::new();
    let mut all_editions: Vec<ParsedEdition> = Vec::new();
    let mut found_genesis = false;
    // Rotated planes (CORD-06): compaction re-wraps each entity's CURRENT head with
    // its ORIGINAL signature, so if an admin last edited the metadata the plane holds
    // no owner-signed vsk-0 at all — the strict genesis anchor is unsatisfiable there.
    // Fallback pair for epoch > 0: the community-bound metadata head (any signer) PLUS
    // at least one owner-signed edition opened under this root. A non-member forger
    // can produce neither; the sibling-community rewrap residual this reopens is the
    // same class the spec defers to root-in-id binding.
    let mut compacted_metadata = false;
    crate::log_debug!(
        "[JoinVerify] control_pk={} root_epoch={:?} relays={:?}",
        &control_pk[..12], community.root_epoch, community.relays
    );
    let anchored = |found_genesis: bool, compacted_metadata: bool, owner_editions: usize, epoch: Epoch| {
        found_genesis || (epoch.0 > 0 && compacted_metadata && owner_editions > 0)
    };
    for attempt in 0..2 {
        editions.clear();
        all_editions.clear();
        compacted_metadata = false;
        let mut until: Option<u64> = Some(FAR_FUTURE_SECS);
        let mut seen_wraps: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
        for page_no in 0..MAX_PAGES {
            let query = Query {
                kinds: vec![stream::KIND_WRAP],
                authors: vec![control_pk.clone()],
                until,
                limit: Some(PAGE),
                evidence: crate::community::transport::Evidence::Full,
                ..Default::default()
            };
            let wraps = transport.fetch(&query, &community.relays).await?;
            crate::log_trace!(
                "[JoinVerify] attempt {} page {}: fetched {} wraps",
                attempt, page_no, wraps.len()
            );
            // INCLUSIVE `until` + wrap-id dedup: a `-1` step can skip same-second
            // siblings at a page boundary (and the genesis with them); re-served
            // boundary events are free, and no-new-events means exhausted.
            let mut oldest = u64::MAX;
            let mut fresh = 0usize;
            for w in &wraps {
                if !seen_wraps.insert(w.id) {
                    continue;
                }
                fresh += 1;
                oldest = oldest.min(w.created_at.as_secs());
                if let Ok((ed, _)) = control::open_control_edition(w, &control) {
                    crate::log_trace!(
                        "[JoinVerify] edition vsk={} eid={} owner={} at={}",
                        ed.vsk, crate::simd::hex::bytes_to_hex_32(&ed.entity_id)[..12].to_string(),
                        ed.author == owner, w.created_at.as_secs()
                    );
                    if ed.vsk == vsk::COMMUNITY_METADATA && ed.entity_id == community.id().0 {
                        if ed.author == owner {
                            found_genesis = true;
                        } else {
                            compacted_metadata = true;
                        }
                    }
                    if ed.author == owner {
                        editions.push(ed.clone());
                    }
                    // Any-author set for the join-time authority fold below: the banlist head
                    // may be admin-signed, and its authority chains to the owner regardless.
                    all_editions.push(ed);
                }
            }
            crate::log_debug!(
                "[JoinVerify] attempt {} page {}: fresh={} opened_owner={} opened_any={} genesis={} compacted={}",
                attempt, page_no, fresh, editions.len(), all_editions.len(), found_genesis, compacted_metadata
            );
            if anchored(found_genesis, compacted_metadata, editions.len(), community.root_epoch) || fresh == 0 {
                break; // authenticated, or the relay is exhausted.
            }
            until = Some(oldest);
        }
        if anchored(found_genesis, compacted_metadata, editions.len(), community.root_epoch) {
            break;
        }
        if attempt == 0 {
            // AUTH-gating relays: the first walk's REQ triggers the NIP-42 challenge,
            // but nostr-sdk's own retry re-auths as the USER key — which doesn't
            // satisfy a stream-authors gate — and can land before the responder's
            // stream-key auth settles, reading the plane back EMPTY. Replay the
            // remembered challenges for every registered stream key, then walk once
            // more on the settled connection.
            if let Some(client) = crate::state::nostr_client() {
                super::streamauth::prime_auth(&client, &community.relays).await;
            }
        }
    }
    if !anchored(found_genesis, compacted_metadata, editions.len(), community.root_epoch) {
        return Err(
            "could not verify this community from its relays (the invite may be forged, the relays are unreachable, or the control plane is being flooded); not joining"
                .to_string(),
        );
    }
    // Join-time reconcile: the joiner holds no floors yet (empty map → bootstrap per
    // entity). The heads this fold verified are returned for the caller to SEED as
    // the initial floor once the community row is saved — without that, the first
    // post-join follow would bootstrap floor-less and could persist a state BELOW
    // what this join already verified and showed.
    // Join-time reconcile folds only the owner's editions (genesis-authenticated
    // above), and the owner is supreme — so owner-only authority suffices. The full
    // roster (admins) folds on the first post-join follow_control.
    let empty_floors = Floors::new();
    let authority = AuthoritySet::owner_only();
    let fold = apply_control_fold(&community, &editions, &empty_floors, &authority);
    // Join-time banlist: fold authority over the ANY-author edition set (roles/grants
    // chain to the genesis-verified owner; the banlist head is honored only if its signer
    // held BAN). Returned so the accept path can refuse a banned self BEFORE it publishes
    // a Guestbook Join — the gate every join door shares (Armada parity, CORD-04 §4).
    let join_banlist = fold_authority(&community, &all_editions, &empty_floors).banned;
    Ok((fold.updated.unwrap_or(community), fold.heads, join_banlist))
}

/// Accept a Direct Invite: unwrap the 3313 giftwrap (Schnorr-verifying the seal),
/// then run the shared accept path. The recipient's consent IS this call. No
/// network await precedes the accept, so the guard captured here suffices.
pub async fn accept_direct_invite<T: Transport + ?Sized>(transport: &T, wrap: &Event) -> Result<CommunityV2, String> {
    let session = SessionGuard::capture();
    let signer = crate::signer::active_signer()?;
    let (inviter, bundle) = invite::unwrap_direct_invite_signed(&signer, wrap).await.map_err(|e| e.to_string())?;
    accept_bundle(transport, &session, &bundle, Some(inviter), true).await
}

/// Accept a PARKED Direct Invite from its stored bundle JSON (the wrap was already
/// unwrapped + owner-verified at park time). Re-parses through the same fail-closed
/// bundle validation, then runs the shared accept path (which re-verifies the owner
/// root over the network). `inviter_hex` is the parked seal signer, for Guestbook
/// Join attribution.
pub async fn accept_parked_invite<T: Transport + ?Sized>(
    transport: &T,
    bundle_json: &str,
    inviter_hex: Option<&str>,
) -> Result<CommunityV2, String> {
    let session = SessionGuard::capture();
    let bundle = CommunityInvite::from_bundle_json(bundle_json).map_err(|e| e.to_string())?;
    let invited_by = inviter_hex.and_then(|h| PublicKey::parse(h).ok());
    accept_bundle(transport, &session, &bundle, invited_by, true).await
}

/// Accept v2 JoinMaterial recovered from a v1→v2 migration dissolution payload (`m`). The
/// material IS a bundle's membership subset — rebuild the invite and run the SHARED accept
/// path, which re-verifies the owner root over the network and enforces the join-time ban
/// gate (a banned-never-cut v1 member who can open `m` is refused here, fail-closed). No
/// giftwrap to unwrap: the dissolution already authenticated the owner via its signature.
pub async fn accept_migration_material<T: Transport + ?Sized>(
    transport: &T,
    jm: &super::list::JoinMaterial,
) -> Result<CommunityV2, String> {
    let session = SessionGuard::capture();
    let bundle = material_to_invite(jm);
    accept_bundle(transport, &session, &bundle, None, true).await
}

/// Fetch + decrypt the newest Live bundle at a public link's coordinate
/// (`(33301, link_signer, "")`). **Revocation is authoritative-if-present**: if
/// ANY signer-valid tombstone is among the fetched events, refuse — never trust
/// fetch ordering (a cross-relay union has no global newest-first sort, so a
/// stale Live could otherwise win a partial-propagation race). Otherwise pick
/// the newest valid Live by `created_at`. Read-only.
pub async fn fetch_public_bundle<T: Transport + ?Sized>(transport: &T, url: &str) -> Result<CommunityInvite, String> {
    let parsed = invite::parse_invite_link(url).map_err(|e| e.to_string())?;
    // NO `#d` filter, even though the coordinate's `d` is empty (CORD-05 §2). Relays disagree on
    // indexing an empty tag value: some answer the REQ and then never EOSE, so the fetch burns its
    // whole union grace on every invite. The per-link signer pins the coordinate on its own (it
    // signs nothing else), and `parse_bundle_event` re-checks the empty `d` locally.
    let query = Query {
        kinds: vec![super::kind::INVITE_BUNDLE],
        authors: vec![parsed.link_signer.to_hex()],
        ..Default::default()
    };
    let relays = if parsed.bootstrap_relays.is_empty() {
        invite::stock_relays()
    } else {
        parsed.bootstrap_relays.clone()
    };
    // One bounded retry: a join fired while the pool is still warming (bootstrap
    // relays mid-handshake, routine during boot contention) reads back a transport
    // error, not an absent bundle. The pool add already happened on the first try,
    // so wait for a socket rather than guessing with a fixed sleep.
    let events = match transport.fetch(&query, &relays).await {
        Ok(evs) => evs,
        Err(_) => {
            wait_for_bootstrap_relay(&relays).await;
            transport.fetch(&query, &relays).await?
        }
    };
    let bundle_key = super::derive::invite_bundle_key(&parsed.token);

    // Scan EVERY event: a tombstone beats a Live unconditionally (order-independent).
    let mut newest_live: Option<(u64, CommunityInvite)> = None;
    for event in &events {
        match invite::parse_bundle_event(event, &parsed.link_signer, &bundle_key) {
            Ok(invite::BundleState::Revoked) => return Err("this invite link has been revoked".to_string()),
            Ok(invite::BundleState::Live(bundle)) => {
                let at = event.created_at.as_secs();
                if newest_live.as_ref().is_none_or(|(t, _)| at > *t) {
                    newest_live = Some((at, *bundle));
                }
            }
            Err(_) => {} // a foreign/garbage event at the coordinate — ignore.
        }
    }
    newest_live.map(|(_, b)| b).ok_or_else(|| "invite bundle not found on relays".to_string())
}

/// Wait — bounded — for ANY of the targets to report Connected before a retry:
/// the fetch's own warm path bounds its connect wait tighter than a cold TLS
/// handshake takes under boot contention.
async fn wait_for_bootstrap_relay(relays: &[String]) {
    let Some(client) = crate::state::nostr_client() else { return };
    let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(8);
    loop {
        for url in relays {
            if let Ok(Some(relay)) = client.relay(url).await {
                if relay.status() == nostr_sdk::prelude::RelayStatus::Connected {
                    return;
                }
            }
        }
        if tokio::time::Instant::now() >= deadline {
            return;
        }
        tokio::time::sleep(std::time::Duration::from_millis(400)).await;
    }
}

/// The most recent owner-root verification a PREVIEW completed, handed to a join
/// so accepting seconds later doesn't re-walk the control plane. Single-slot,
/// short-lived, session-guarded, and keyed on `(community_id, community_root)` —
/// a different delivered root never matches. The join's own bundle re-fetch is
/// untouched, so the revocation gate always runs live.
struct VerifiedPreview {
    session: SessionGuard,
    at: std::time::Instant,
    community_id: [u8; 32],
    community_root: [u8; 32],
    folded: CommunityV2,
    heads: Vec<FoldedHead>,
    /// The join-time authorized banlist from the SAME verified walk — carried so the
    /// handoff path keeps the ban gate (a preview-then-join must not skip it).
    banned: std::collections::BTreeSet<String>,
}
static VERIFIED_PREVIEW: std::sync::Mutex<Option<VerifiedPreview>> = std::sync::Mutex::new(None);
const VERIFIED_PREVIEW_TTL: std::time::Duration = std::time::Duration::from_secs(120);

/// Read-only rich preview of a public link: the decrypted bundle plus the LATEST
/// display metadata folded live from the Control Plane (a v2 bundle deliberately
/// carries no icon — the fold is the authority). Owner-root verification rides
/// the fold, so a forged-root link can't render a convincing preview; on a
/// fold/transport failure the bundle snapshot is the fallback. Nothing persists
/// — the caller hasn't joined.
pub async fn preview_public_link<T: Transport + ?Sized>(transport: &T, url: &str) -> Result<CommunityV2, String> {
    let bundle = fetch_public_bundle(transport, url).await?;
    preview_bundle(transport, &bundle).await
}

/// The fold half of [`preview_public_link`], over an already-fetched bundle. Split out so a caller
/// that only needs the community's IDENTITY can read it off the bundle (it is self-certifying) and
/// skip the Control-Plane walk entirely — the walk is the join gate, and `accept_public_link` runs
/// it again regardless.
pub async fn preview_bundle<T: Transport + ?Sized>(transport: &T, bundle: &CommunityInvite) -> Result<CommunityV2, String> {
    let community = CommunityV2::from_bundle(bundle, 0)?;
    match verify_owner_root_and_reconcile(transport, community.clone()).await {
        Ok((folded, heads, banned)) => {
            *VERIFIED_PREVIEW.lock().unwrap() = Some(VerifiedPreview {
                session: SessionGuard::capture(),
                at: std::time::Instant::now(),
                community_id: folded.id().0,
                community_root: folded.community_root,
                folded: folded.clone(),
                heads,
                banned,
            });
            Ok(folded)
        }
        Err(_) => Ok(community),
    }
}

/// Accept a public invite link: fetch its bundle (revocation-aware) and join.
pub async fn accept_public_link<T: Transport + ?Sized>(transport: &T, url: &str) -> Result<CommunityV2, String> {
    // Capture BEFORE the network fetch so the join's is_valid() gate straddles it.
    let session = SessionGuard::capture();
    let bundle = fetch_public_bundle(transport, url).await?;
    if !session.is_valid() {
        return Err("account changed during join".to_string());
    }
    accept_bundle(transport, &session, &bundle, None, true).await
}

/// Leave a community: publish a Guestbook Leave and tear down the local hold.
pub async fn leave_community<T: Transport + ?Sized>(transport: &T, community: &CommunityV2) -> Result<(), String> {
    let session = SessionGuard::capture();
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let at_ms = now_ms();
    let gb_group = super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch);
    let leave_rumor = guestbook::build_leave_rumor(my_pk, at_ms);
    if let Ok((wrap, _)) = guestbook::seal_guestbook_rumor_signed(&signer, my_pk, &leave_rumor, &gb_group, Timestamp::from_secs(at_ms / 1000)).await {
        let _ = transport.publish(&wrap, &community.relays).await;
    }
    if !session.is_valid() {
        return Err("account changed during leave".to_string());
    }
    // Tombstone the membership across devices (CORD-02 §8) BEFORE the local delete,
    // to the leaving community's own relays (it's about to be gone locally) —
    // best-effort.
    let _ = tombstone_community_list(transport, community.id(), &community.relays).await;
    // The tombstone publish straddled an await — never delete from a swapped-in DB.
    if !session.is_valid() {
        return Err("account changed during leave".to_string());
    }
    crate::db::community::delete_community(&crate::simd::hex::bytes_to_hex_32(&community.id().0))?;
    Ok(())
}

/// Cooperative Kick (CORD-04 §6, Guestbook plane): name the target; every reader
/// honors it iff the signer holds KICK and strictly outranks them (the coalesce's
/// `can_kick`), so publishing without authority is inert. A kicked member may
/// rejoin with a fresh invite — cryptographic severance is the ban/refound path.
pub async fn kick_member<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, target: &PublicKey) -> Result<(), String> {
    let session = SessionGuard::capture();
    assert_current_root(community)?;
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    // Fast local pre-check; readers re-verify independently.
    let authority = fetch_authority(transport, community).await;
    let owner_hex = community.owner()?.to_hex();
    if !authority.roles.can_act_on_member(
        &my_pk.to_hex(),
        Some(&owner_hex),
        &target.to_hex(),
        crate::community::roles::Permissions::KICK,
    ) {
        return Err("not authorized to kick this member".to_string());
    }
    // CORD-04 §6 composition: a Kick is Role Removal THEN the directive — strip
    // first, so the target's rank is gone before the departure lands. Without it a
    // kicked admin leaves the memberlist still holding every management bit, and
    // every client keeps honoring their control editions.
    //
    // SKIPPED (not refused) when the strip isn't ours to make: a revoke needs
    // MANAGE_ROLES + strict outrank, and a KICK-only moderator still kicks — the
    // target just keeps their rank until an authorized strip lands. Each layer
    // validates on its own rule, so a missing one is a weaker removal, never a
    // broken one. A strip we DO attempt and lose is a hard error: proceeding would
    // publish a directive we know leaves rank behind.
    let target_hex = target.to_hex();
    let holds_roles = authority.roles.grants.iter().any(|g| g.member == target_hex && !g.role_ids.is_empty());
    let may_strip = authority.roles.can_act_on_member(
        &my_pk.to_hex(),
        Some(&owner_hex),
        &target_hex,
        crate::community::roles::Permissions::MANAGE_ROLES,
    );
    if holds_roles && may_strip {
        grant_roles(transport, community, target, Vec::new())
            .await
            .map_err(|e| format!("could not strip this member's roles before kicking: {e}"))?;
        if !session.is_valid() {
            return Err("account changed during kick".to_string());
        }
    }
    let at_ms = now_ms();
    let gb_group = super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch);
    // A Kick is an authority action, so it cites its Grant like any other
    // (CORD-02 §5 / CORD-04 §5).
    let citation = required_authority_citation(community, &my_pk)?;
    let rumor = guestbook::build_kick_rumor(my_pk, *target, citation.as_ref(), at_ms);
    let (wrap, _) = guestbook::seal_guestbook_rumor_signed(&signer, my_pk, &rumor, &gb_group, Timestamp::from_secs(at_ms / 1000)).await
        .map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed before send".to_string());
    }
    transport.publish(&wrap, &community.relays).await?;
    Ok(())
}

/// A community's folded, delegation-authorized authority — the on-demand read
/// view (a paged control-plane fetch + fold, nothing persisted). `roles` is the
/// owner-seeded authorized roster (shared algebra with v1); `banned` the
/// enforced banlist. `floored`/`head_entities` let a writer detect a WITHHELD
/// entity (floored locally but no head folded) before replacing it blind.
pub struct AuthorityView {
    pub roles: crate::community::roles::CommunityRoles,
    pub banned: std::collections::BTreeSet<String>,
    /// Any authority entity's fold hit a floor gap (withheld / evicted link).
    pub gapped: bool,
    /// Entity hexes holding a persisted floor at this epoch (all vsk kinds).
    pub floored: std::collections::BTreeSet<String>,
    /// Authority entities (role/grant/banlist) that folded a head this fetch.
    pub head_entities: std::collections::BTreeSet<String>,
    /// Ban history (npub hex → secs), outliving the ban so an un-ban raises no phantom.
    pub banned_at: std::collections::BTreeMap<String, u64>,
}

/// Fetch + fold the community's current authority (CORD-04), paging older like
/// `follow_control` while the fold is gapped so a busy control plane can't push
/// the roster off the newest window. A fetch failure degrades fail-safe:
/// owner-only authority plus the PERSISTED banlist — nobody gains standing from
/// an outage, and a ban never lifts on withheld data.
pub async fn fetch_authority<T: Transport + ?Sized>(transport: &T, community: &CommunityV2) -> AuthorityView {
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let floors: Floors = crate::db::community::get_all_edition_heads_full(&cid_hex)
        .unwrap_or_default()
        .into_iter()
        .filter(|(_, f)| f.0 == community.root_epoch.0)
        .map(|(entity, f)| (entity, (f.1, f.2, f.3)))
        .collect();
    let control = control_group_key(&community.community_root, community.id(), community.root_epoch);

    let mut editions: Vec<ParsedEdition> = Vec::new();
    let mut seen: std::collections::HashSet<[u8; 32]> = std::collections::HashSet::new();
    let mut seen_wraps: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
    let mut oldest: Option<u64> = None;
    let mut until: Option<u64> = None;
    // Seed from an EMPTY fold, not owner_only(): a fold over zero editions yields
    // owner-only roles AND retains the PERSISTED banlist. So a first-page transport
    // error returns the stored bans (fail-safe), never an empty banlist that would
    // silently un-ban on withheld data.
    let mut a = fold_authority(community, &[], &floors);
    for _ in 0..FOLLOW_MAX_PAGES {
        // Quorum, DECLARED (the until→Full transport floor is gone): these
        // control reads tolerate a partial union — their fold semantics are
        // fail-safe on gaps (seeded banlists, withheld roster cache).
        let query = Query {
            kinds: vec![stream::KIND_WRAP],
            authors: vec![control.pk_hex()],
            until,
            limit: Some(FOLLOW_PAGE),
            evidence: crate::community::transport::Evidence::Quorum,
            ..Default::default()
        };
        let Ok(wraps) = transport.fetch(&query, &community.relays).await else { break };
        let mut fresh = 0usize;
        for w in &wraps {
            if !seen_wraps.insert(w.id) {
                continue;
            }
            fresh += 1;
            let at = w.created_at.as_secs();
            if oldest.is_none_or(|o| at < o) {
                oldest = Some(at);
            }
            if let Ok((ed, _)) = control::open_control_edition(w, &control) {
                if seen.insert(ed.inner_id) {
                    editions.push(ed);
                }
            }
        }
        a = fold_authority(community, &editions, &floors);
        if !a.gapped || fresh == 0 {
            break;
        }
        until = oldest;
    }
    AuthorityView {
        roles: a.roles,
        banned: a.banned,
        gapped: a.gapped,
        floored: floors.keys().cloned().collect(),
        head_entities: a.heads.iter().map(|h| h.entity_hex.clone()).collect(),
        banned_at: a.banned_at,
    }
}

/// Page the Guestbook plane newest-to-oldest, stopping once a page's oldest wrap
/// falls below `since_secs` (everything older is already held) or the plane is
/// exhausted. Returns the parsed events at/after the window plus the newest wrap
/// time seen (the caller's next cursor; `since_secs` when nothing newer arrived).
///
/// PAGE bound rationale: a single 500-window silently drops a member whose Join
/// aged out (organic growth, or an insider flooding throwaway Joins), and
/// `refound_community` consumes the fold as its rekey recipient set — a dropped
/// member is SEVERED. Beyond this depth a community needs sharding (documented);
/// the granted-member union in [`fold_members`] is the consensus-complete
/// backstop regardless of Guestbook depth.
async fn fetch_guestbook_events<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    since_secs: u64,
) -> Result<(Vec<guestbook::GuestbookEvent>, u64), String> {
    let gb_group = super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch);
    const GB_PAGE: usize = 500;
    const GB_MAX_PAGES: usize = 12;
    let mut events = Vec::new();
    let mut newest: u64 = since_secs;
    let mut seen: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
    let mut until: Option<u64> = None;
    let mut oldest: Option<u64> = None;
    for _ in 0..GB_MAX_PAGES {
        // Full: this set becomes the refound's recipient list — a member's
        // Join visible only on a minority relay must not be severed.
        let query = Query { kinds: vec![stream::KIND_WRAP], authors: vec![gb_group.pk_hex()], until, limit: Some(GB_PAGE), evidence: crate::community::transport::Evidence::Full, ..Default::default() };
        let wraps = transport.fetch(&query, &community.relays).await?;
        let mut fresh = 0usize;
        for wrap in &wraps {
            if !seen.insert(wrap.id) {
                continue;
            }
            fresh += 1;
            let at = wrap.created_at.as_secs();
            if oldest.is_none_or(|o| at < o) {
                oldest = Some(at);
            }
            if at > newest {
                newest = at;
            }
            // Older than the cursor window — already held; skip the decrypt.
            if at < since_secs {
                continue;
            }
            if let Ok(opened) = stream::open_wrap(wrap, &gb_group) {
                if let Ok(ev) = guestbook::parse_guestbook_event(&opened) {
                    events.push(ev);
                }
            }
        }
        if fresh == 0 || wraps.len() < GB_PAGE || oldest.is_some_and(|o| o < since_secs) {
            break;
        }
        match oldest {
            Some(o) if o > 0 => until = Some(o),
            _ => break,
        }
    }
    Ok((events, newest))
}

/// The shared membership fold: coalesce Guestbook events under the community's
/// authority (owner-supreme kicks, refounder snapshots), union observed authors
/// plus every roster grantee, subtract the banlist, and pin the proven owner.
/// One implementation, so the live and stored reads can't drift.
fn fold_members(
    community: &CommunityV2,
    events: &[guestbook::GuestbookEvent],
    mut observed: std::collections::BTreeMap<PublicKey, u64>,
    roles: &crate::community::roles::CommunityRoles,
    banlist: &std::collections::BTreeSet<PublicKey>,
    banned_at: &std::collections::BTreeMap<PublicKey, u64>,
) -> Result<Vec<PublicKey>, String> {
    let owner = community.owner()?;
    let owner_hex = owner.to_hex();
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);

    // CONSENSUS-COMPLETE backstop: every member the folded roster GRANTS a role to
    // is provably a member (a Grant binds member_xonly, CORD-02 A.6) — count them
    // even if their Join aged out of the Guestbook entirely and they never posted.
    // This is what keeps a Refounding from severing a lurking admin. `observed`
    // carries them at ts 0 (presence, not recency); the banlist subtraction below
    // still removes a banned grantee whose grant wasn't yet stripped.
    for g in &roles.grants {
        if let Some(pk) = PublicKey::from_hex(&g.member).ok().filter(|_| !g.role_ids.is_empty()) {
            observed.entry(pk).or_insert(0);
        }
    }

    // Snapshot authority (CORD-02 §5): a refounding rolls `root_epoch` and re-seeds the
    // new epoch's Guestbook with a 3312 snapshot of the survivors. Only the OWNER's snapshot is
    // honored here, so a silent survivor stays in the memberlist across an owner refound
    // without re-posting. A genesis community (root_epoch 0) has no refounder, hence no
    // snapshot power. KNOWN GAP (do not "fix" unilaterally — CORD-04/06 + Armada): the refound
    // send/receive gates authorize any BAN-holder to refound, but their snapshot is NOT honored
    // here, so a non-owner admin's refound drops silent survivors (incl. migration roster seeds)
    // until they re-post. Binding the minting rotator into snapshot authority is a spec change.
    let snapshot_authority = (community.root_epoch.0 > 0).then_some(&owner);
    // Kick authority (CORD-04 §5/§6): the signer must cite a Grant we've synced AND
    // hold KICK AND strictly outrank the target (the owner is supreme; equal cannot
    // kick equal).
    let can_kick = |actor: &PublicKey, target: &PublicKey, citation: Option<&crate::community::edition::AuthorityCitation>| {
        let actor_hex = actor.to_hex();
        citation_is_synced(&cid_hex, &owner_hex, &actor_hex, citation)
            && roles.can_act_on_member(&actor_hex, Some(&owner_hex), &target.to_hex(), crate::community::roles::Permissions::KICK)
    };
    let coalesced = guestbook::coalesce(events, now_ms(), snapshot_authority, &can_kick);
    let mut members = guestbook::complete_memberlist(&coalesced, &observed, banlist, banned_at);
    // The owner is a member by definition, independent of any fetched Join.
    if !banlist.contains(&owner) {
        members.insert(owner);
    }
    Ok(members.into_iter().collect())
}

/// Did the AUTHORIZED Guestbook coalesce rule `member` KICKED, per the stored plane?
///
/// This is the only sound basis for acting on a kick against ourselves. The
/// memberlist is the wrong question: it also folds the banlist, the ban marks and
/// observed authors, so a member whose Guestbook hasn't caught up yet — a REJOIN,
/// where the store starts empty while the control fold has already re-derived their
/// old ban mark — is absent from it while being perfectly joined. Coalescing asks
/// only "what is the latest authorized entry for this npub", so a fresh Join
/// supersedes an old Kick and an empty store yields no verdict at all.
pub fn stored_kick_verdict(community: &CommunityV2, member: &PublicKey) -> bool {
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let Ok((events, _cursor)) = crate::db::community::get_guestbook(&cid_hex) else {
        return false;
    };
    let Ok(owner) = community.owner() else { return false };
    let owner_hex = owner.to_hex();
    let roles = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    let snapshot_authority = (community.root_epoch.0 > 0).then_some(&owner);
    let can_kick = |actor: &PublicKey, target: &PublicKey, citation: Option<&crate::community::edition::AuthorityCitation>| {
        let actor_hex = actor.to_hex();
        citation_is_synced(&cid_hex, &owner_hex, &actor_hex, citation)
            && roles.can_act_on_member(&actor_hex, Some(&owner_hex), &target.to_hex(), crate::community::roles::Permissions::KICK)
    };
    matches!(
        guestbook::coalesce(&events, now_ms(), snapshot_authority, &can_kick).get(member),
        Some(st) if st.verdict == guestbook::Verdict::Kicked
    )
}

/// Catch the persisted Guestbook up from its stored cursor (a fresh hold seeds
/// from zero). The fetch straddles the network, so the session re-checks before
/// the store writes. Returns the events that were NEW to the store — the caller
/// surfaces them (presence lines) and refreshes on non-empty.
pub async fn sync_guestbook<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    session: &SessionGuard,
) -> Result<Vec<guestbook::GuestbookEvent>, String> {
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let (mut events, cursor) = crate::db::community::get_guestbook(&cid_hex)?;
    // Overlap one second so a same-second boundary event can't slip the cursor;
    // the rumor-id merge below dedups the re-fetched edge.
    let since = cursor.saturating_sub(1);
    let (fresh, newest) = fetch_guestbook_events(transport, community, since).await?;
    if !session.is_valid() {
        return Err("account changed during guestbook sync".to_string());
    }
    let known: std::collections::HashSet<[u8; 32]> = events.iter().map(|e| e.rumor_id).collect();
    let mut added = Vec::new();
    for ev in fresh {
        if !known.contains(&ev.rumor_id) {
            events.push(ev.clone());
            added.push(ev);
        }
    }
    if !added.is_empty() || newest > cursor {
        crate::db::community::set_guestbook(&cid_hex, &events, newest.max(cursor))?;
    }
    Ok(added)
}

/// Fold ONE live guestbook event into the store (the realtime path — no fetch).
/// Returns whether it was new.
pub fn ingest_guestbook_event(community: &CommunityV2, ev: guestbook::GuestbookEvent, wrap_secs: u64) -> Result<bool, String> {
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let (mut events, cursor) = crate::db::community::get_guestbook(&cid_hex)?;
    if events.iter().any(|e| e.rumor_id == ev.rumor_id) {
        return Ok(false);
    }
    events.push(ev);
    crate::db::community::set_guestbook(&cid_hex, &events, cursor.max(wrap_secs))?;
    Ok(true)
}

/// The memberlist from LOCAL state only: the persisted Guestbook, plus locally
/// observed authors (the synced events DB), plus roster grantees, minus the
/// banlist. Instant and offline-correct; [`sync_guestbook`] (post-join, boot,
/// reconnect, live ingest) keeps the store current. The live [`memberlist`]
/// remains the authoritative walk — a refounding's rekey recipient set must
/// never trust a possibly-stale store.
pub fn stored_memberlist(community: &CommunityV2) -> Result<Vec<PublicKey>, String> {
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let (events, _cursor) = crate::db::community::get_guestbook(&cid_hex)?;
    let mut observed: std::collections::BTreeMap<PublicKey, u64> = std::collections::BTreeMap::new();
    for (npub, last_active_secs) in crate::db::community::community_member_activity(&cid_hex).unwrap_or_default() {
        if let Ok(pk) = PublicKey::parse(&npub) {
            observed.insert(pk, last_active_secs.saturating_mul(1000));
        }
    }
    let roles = crate::db::community::get_community_roles(&cid_hex)?;
    let banlist: std::collections::BTreeSet<PublicKey> = crate::db::community::get_community_banlist(&cid_hex)
        .unwrap_or_default()
        .iter()
        .filter_map(|h| PublicKey::from_hex(h).ok())
        .collect();
    // Ban history outlives the banlist itself — see [`fold_members`]. Read from the store,
    // since this path never folds editions.
    let banned_at: std::collections::BTreeMap<PublicKey, u64> = crate::db::community::get_community_ban_marks(&cid_hex)
        .unwrap_or_default()
        .into_iter()
        .filter_map(|(h, at)| PublicKey::from_hex(&h).ok().map(|pk| (pk, at)))
        .collect();
    fold_members(community, &events, observed, &roles, &banlist, &banned_at)
}

/// Fold the Complete Memberlist from the Guestbook plane. The proven owner is
/// ALWAYS a member (derived from the self-certifying community_id — no network,
/// so a lost/evicted genesis Join can't drop them). Observed authors — anyone
/// seen publishing on a channel — are folded in FORWARD-only per CORD-02 §5, so a
/// member whose Join was lost still counts.
pub async fn memberlist<T: Transport + ?Sized>(transport: &T, community: &CommunityV2) -> Result<Vec<PublicKey>, String> {
    let (events, _newest) = fetch_guestbook_events(transport, community, 0).await?;
    // Observed authors: fold each held channel's recent authorship (real author +
    // newest ms), so a member who posted but whose Join was lost is still counted.
    let mut observed: std::collections::BTreeMap<PublicKey, u64> = std::collections::BTreeMap::new();
    for ch in &community.channels {
        if let Ok(page) = fetch_channel(transport, community, &ch.id, 200).await {
            for f in &page {
                let e = observed.entry(f.event.opened().author).or_insert(0);
                *e = (*e).max(f.event.opened().at_ms);
            }
        }
    }

    // Fold the Control Plane roster + banlist (CORD-04) for Kick authority and the
    // ban subtraction. A control fetch failure degrades to owner-only authority + no
    // bans (fail-open on availability is safe here: a Kick still needs a real signer,
    // and a missed ban only fails to HIDE, never to wrongly admit authority).
    let authority = fetch_authority(transport, community).await;
    // The authorized banlist, as pubkeys (a malformed hex entry is simply dropped).
    let banlist: std::collections::BTreeSet<PublicKey> =
        authority.banned.iter().filter_map(|h| PublicKey::from_hex(h).ok()).collect();
    // Union the live fold's ban history with the stored marks: the fetch only reaches the
    // editions still in its window, and a ban that aged out is exactly the one whose
    // pre-ban Join would phantom.
    let mut banned_at: std::collections::BTreeMap<PublicKey, u64> = crate::db::community::get_community_ban_marks(
        &crate::simd::hex::bytes_to_hex_32(&community.id().0),
    )
    .unwrap_or_default()
    .into_iter()
    .filter_map(|(h, at)| PublicKey::from_hex(&h).ok().map(|pk| (pk, at)))
    .collect();
    for (h, at) in &authority.banned_at {
        if let Ok(pk) = PublicKey::from_hex(h) {
            let slot = banned_at.entry(pk).or_insert(0);
            *slot = (*slot).max(*at);
        }
    }
    fold_members(community, &events, observed, &authority.roles, &banlist, &banned_at)
}

// ── Dissolution (CORD-02 §9) ─────────────────────────────────────────────────

/// Owner dissolution / "Delete Community" (CORD-02 §9): publish the terminal
/// tombstone at the dissolved plane (`community_id`-derived, epoch-free, so every
/// past or present member resolves the same grave and a Refounding can never strand
/// it). The tombstone's presence IS the state; only the owner's seal counts.
/// Irreversible — on success the local hold is sealed read-only.
pub async fn dissolve_community<T: Transport + ?Sized>(transport: &T, community: &CommunityV2) -> Result<(), String> {
    let session = SessionGuard::capture();
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    if community.owner()? != my_pk {
        return Err("only the owner can dissolve a community".to_string());
    }
    let at = now_ms() / 1000;
    let rumor = super::dissolution::dissolved_tombstone_rumor(my_pk, community.id(), at);
    let wrap = super::dissolution::seal_dissolved_signed(&signer, my_pk, &rumor, community.id(), Timestamp::from_secs(at)).await.map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed during dissolve".to_string());
    }
    // Durable broadcast: death must propagate (a rekey racing a dissolution loses).
    transport.publish_durable(&wrap, &community.relays).await?;
    crate::db::community::set_community_dissolved(&crate::simd::hex::bytes_to_hex_32(&community.id().0))?;
    Ok(())
}

/// Whether a valid owner-signed dissolution tombstone exists for this community on
/// its relays (CORD-02 §9). A join refuses a dead community, and a live follow seals
/// on sight. Fail-OPEN on a fetch error (absence of proof is not death), but any
/// owner-verified tombstone found is authoritative.
pub async fn is_dissolved<T: Transport + ?Sized>(transport: &T, community: &CommunityV2) -> bool {
    let group = super::derive::dissolved_group_key(community.id());
    let query = Query {
        kinds: vec![stream::KIND_WRAP],
        authors: vec![group.pk_hex()],
        limit: Some(20),
        ..Default::default()
    };
    let Ok(wraps) = transport.fetch(&query, &community.relays).await else {
        return false;
    };
    wraps.iter().any(|w| super::dissolution::verify_dissolved(w, &community.identity))
}

// ── Refounding (CORD-06 §3) ──────────────────────────────────────────────────

/// Owner/admin Refounding (CORD-06 §3): roll the `community_root` to
/// cryptographically remove `removed` from a Private community (a Ban's read-cut).
/// Compacts the Control Plane under the new root (re-wraps each head VERBATIM — the
/// inner owner/actor signatures survive, so no re-authoring), rekeys the base plus
/// every Private channel (each sealed under the PRIOR root, D2, so a base-fork loser
/// can still open them), and seeds the new epoch's Guestbook snapshot. Requires BAN.
///
/// **Acquire-before-commit:** the compaction is fetched + re-sealed BEFORE any
/// publish, and a head we can't fetch ABORTS with ZERO published state — so a
/// transient miss never strands a published rekey with a half-anchored plane.
pub async fn refound_community<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, removed: &[PublicKey]) -> Result<CommunityV2, String> {
    let session = SessionGuard::capture();
    let cid = community.id();
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&cid.0);
    // Death wins every race: a dissolved community never re-founds (CORD-02 §9).
    if crate::db::community::get_community_dissolved(&cid_hex).unwrap_or(false) {
        return Err("this community has been dissolved; it cannot be re-founded".to_string());
    }
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    // Serialize with the follow worker for the whole rotation: the commit tail
    // whole-row-saves, and an unserialized concurrent follow could otherwise be
    // rolled back (or adopt a half-published sibling of this very rotation).
    let lock = super::realtime::follow_lock(cid);
    let _guard = lock.lock().await;
    // Reload the FRESHEST base state: a stale caller struct would address the rotation
    // under a superseded root (a base fork with no heal). The community_id is
    // self-certifying + stable, so re-loading by it is safe.
    let fresh = crate::db::community::load_community_v2(cid)?.ok_or("community gone before re-founding")?;
    let community = &fresh;
    let owner = community.owner()?;

    // CORD-06 §Authority: a Refounding requires the BAN permission and the rotator
    // must strictly OUTRANK every removed target — the owner is supreme (BAN ⊂
    // owner). Mirrors the receive counterpart (`advance_scope::base_rotator_ok`)
    // and the banlist authority fold: any admin holding BAN may re-found, checked
    // against the folded Roster. Fail-closed — an empty/unauthorized roster leaves
    // only the owner able to re-found.
    {
        let owner_hex = owner.to_hex();
        let me_hex = my_pk.to_hex();
        // Persisted (last-folded) roster — the receive side is authoritative, so
        // this is a belt-and-suspenders gate. Fail-closed: a stale/empty roster
        // collapses to owner-only, which can only OVER-restrict a fresh admin whose
        // grant hasn't folded into their own DB (the caller's ban flow folds control
        // first). It can never grant authority no one has.
        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
        let banned = crate::db::community::get_community_banlist(&cid_hex).unwrap_or_default();
        let authorized = my_pk == owner
            || (!banned.contains(&me_hex)
                && roster.is_authorized(&me_hex, Some(&owner_hex), crate::community::roles::Permissions::BAN)
                && removed.iter().all(|t| {
                    roster.can_act_on_member(&me_hex, Some(&owner_hex), &t.to_hex(), crate::community::roles::Permissions::BAN)
                }));
        if !authorized {
            return Err("re-founding requires the BAN permission and outranking every removed member".to_string());
        }
    }

    // Fold the current roster: the opened editions are reused for the compaction (their
    // seals re-wrap under the new epoch), and the roster gates which admin-authored
    // heads carry forward.
    let floors: Floors = crate::db::community::get_all_edition_heads_full(&cid_hex)?
        .into_iter()
        .filter(|(_, f)| f.0 == community.root_epoch.0)
        .map(|(entity, f)| (entity, (f.1, f.2, f.3)))
        .collect();
    let current_control = control_group_key(&community.community_root, cid, community.root_epoch);
    // Page the ENTIRE control plane, not just the newest window: the compaction MUST
    // carry EVERY committed (floored) entity to the new epoch, so a head buried under a
    // flood of newer editions (100 roles + 400 grants already exceeds one page) or a
    // head a relay withholds can't silently drop. CORD-06 §3 mandates aborting if the
    // Refounder cannot fold all Control Events — a dropped Banlist would unban a member
    // at the new epoch a fresh joiner bootstraps.
    let mut opened: Vec<(ParsedEdition, super::stream::OpenedStream)> = Vec::new();
    let mut seen_wraps: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
    let mut oldest: Option<u64> = None;
    let mut until: Option<u64> = None;
    // Read to EXHAUSTION, not to coverage: an entity with no floor yet (a
    // first-ever Banlist published while we were away) is invisible to a
    // coverage test, so stopping there could compact it away.
    let mut truncated = false;
    for page in 0..COMPACT_MAX_PAGES {
        // Full: compaction re-wraps the head set it can SEE — a control
        // edition (a ban head) reachable only on a minority relay must not be
        // compacted away by a partial union.
        let query = Query {
            kinds: vec![stream::KIND_WRAP],
            authors: vec![current_control.pk_hex()],
            until,
            limit: Some(FOLLOW_PAGE),
            evidence: crate::community::transport::Evidence::Full,
            ..Default::default()
        };
        let wraps = transport.fetch(&query, &community.relays).await?;
        let mut fresh = 0usize;
        for w in &wraps {
            if !seen_wraps.insert(w.id) {
                continue;
            }
            fresh += 1;
            let at = w.created_at.as_secs();
            if oldest.is_none_or(|o| at < o) {
                oldest = Some(at);
            }
            if let Ok(parsed) = control::open_control_edition(w, &current_control) {
                opened.push(parsed);
            }
        }
        if fresh == 0 {
            // `until` is inclusive: a FULL page with nothing new is a same-second
            // wall no cursor steps past, so older editions stay unreachable. A
            // short page is simply the end of the plane.
            truncated = wraps.len() >= FOLLOW_PAGE;
            break;
        }
        until = oldest;
        if page + 1 == COMPACT_MAX_PAGES {
            truncated = true;
        }
    }
    if truncated {
        return Err(
            "The community's control plane is too deep to read in full right now; re-founding stopped so no member is left behind.".to_string(),
        );
    }

    let prev_epoch = community.root_epoch;
    let new_epoch = Epoch(prev_epoch.0.checked_add(1).ok_or("root epoch overflow")?);
    let prev_commit = super::derive::epoch_key_commitment(prev_epoch, &community.community_root);
    // Mint-or-REUSE the new root, keyed by (scope, new_epoch) and archived BEFORE any
    // publish: a retried Refounding re-delivers the SAME root at this epoch/address, so
    // it can't double-mint two roots a receiver's correlation dedup would collapse into
    // a permanent fork (CORD-06 §3 idempotency). The compaction fetch above straddled
    // this DB write — re-check so a mid-fetch swap can't archive into another account.
    if !session.is_valid() {
        return Err("account changed during re-founding compaction".to_string());
    }
    let new_root = mint_or_reuse_rotation_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, new_epoch.0)?;
    let new_control = control_group_key(&new_root, cid, new_epoch);
    let at = now_ms();
    let at_secs = at / 1000;

    // ACQUIRE + COVERAGE GATE (CORD-06 §3 MUST): re-wrap the head of EVERY committed
    // (floored) entity under the new epoch — FLOOR-driven, so nothing silently drops,
    // including entities the metadata/roster folds don't touch (the invite Registry
    // vsk-8, whose coordinate survives the rekey per CORD-05 §5). A floor whose head
    // can't be folded (buried past the pager / withheld) ABORTS before any publish.
    use std::collections::BTreeMap;
    let mut by_eid: BTreeMap<String, Vec<usize>> = BTreeMap::new();
    for (i, (e, _)) in opened.iter().enumerate() {
        by_eid.entry(crate::simd::hex::bytes_to_hex_32(&e.entity_id)).or_default().push(i);
    }
    let mut carried: Vec<(FoldedHead, Event)> = Vec::new();
    for (floor_key, floor) in &floors {
        // Re-wrap the AUTHORIZED head — the exact edition the persisted floor commits to
        // (its self_hash). The floor advances ONLY to authorized heads (author-aware fold),
        // so matching it is authority-correct across EVERY entity type. `fold_head`'s
        // version-chain TIP is author-BLIND: a member can seal a forged higher-version
        // edition chaining onto the floor, which the tip would carry and honest folders
        // then DROP as unauthorized — silently suppressing that role/grant/banlist across
        // the refounding. Abort if the committed head isn't served (fail-closed).
        let head_idx = by_eid
            .get(floor_key)
            .and_then(|v| v.iter().copied().find(|&i| opened[i].0.self_hash == floor.1));
        let Some(head_idx) = head_idx else {
            return Err(format!("re-founding aborted: the committed head of control entity {floor_key} (v{}) was not served; no state published", floor.0));
        };
        let (head_ed, head_os) = &opened[head_idx];
        let h = FoldedHead { entity_hex: floor_key.clone(), version: head_ed.version, self_hash: head_ed.self_hash, inner_id: head_ed.inner_id };
        let (rewrapped, _) = super::stream::rewrap_seal(&head_os.seal, &new_control, Timestamp::from_secs(at_secs)).map_err(|e| e.to_string())?;
        carried.push((h, rewrapped));
    }
    if !session.is_valid() {
        return Err("account changed during re-founding acquire".to_string());
    }

    // Recipients: the current members minus `removed`, plus me (multi-device).
    let members = memberlist(transport, community).await?;
    let removed_set: std::collections::HashSet<[u8; 32]> = removed.iter().map(|p| p.to_bytes()).collect();
    let mut recipients: Vec<PublicKey> = members.into_iter().filter(|m| !removed_set.contains(&m.to_bytes())).collect();
    if !recipients.iter().any(|p| *p == my_pk) {
        recipients.push(my_pk);
    }

    // Base rekey blobs (the new root to each recipient), sealed under the PRIOR root.
    let mut base_blobs = Vec::new();
    for r in &recipients {
        base_blobs.push(
            super::rekey::build_blob(&signer, &my_pk.to_bytes(), r, super::rekey::RekeyScope::Root, new_epoch, &new_root)
                .await
                .map_err(|e| e.to_string())?,
        );
    }
    let base_group = super::derive::base_rekey_group_key(&community.community_root, cid, new_epoch);
    let base_chunks =
        super::rekey::build_rekey_chunks(&signer, my_pk, &base_group, super::rekey::RekeyScope::Root, new_epoch, prev_epoch, &prev_commit, &base_blobs, at_secs, my_authority_citation(community, &my_pk).as_ref())
            .await
            .map_err(|e| e.to_string())?;

    // Private-channel rekeys: each mints a fresh key at its next channel-epoch, sealed
    // under the PRIOR root (D2). Public channels ride the base — no per-channel rekey.
    //
    // Each private channel goes only to ITS entitled set, never the base recipient
    // list: a Refounding that re-broadcast every private key to every member would
    // undo the access lists on every rotation (CORD-03).
    // Entitlement must come from a CURRENT roster, not the last-folded cache: the
    // base recipients above are a fresh network fold, and mixing the two strands
    // anyone granted since this client last folded — they keep a dead key and the
    // new epoch's rekey plane carries no blob for them. Fetched, then merged over
    // the cache so a role we published ourselves survives too.
    let mut roster_for_channels = fetch_authority(transport, community).await.roles;
    {
        let cached = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
        for r in cached.roles {
            if !roster_for_channels.roles.iter().any(|x| x.role_id == r.role_id) {
                roster_for_channels.roles.push(r);
            }
        }
        for g in cached.grants {
            if !roster_for_channels.grants.iter().any(|x| x.member == g.member) {
                roster_for_channels.grants.push(g);
            }
        }
    }
    if !session.is_valid() {
        return Err("account changed during re-founding entitlement fetch".to_string());
    }
    let owner_hex_for_channels = community.owner().ok().map(|o| o.to_hex());
    let mut channel_updates: Vec<(ChannelId, [u8; 32], Epoch)> = Vec::new();
    let mut channel_chunk_sets: Vec<Vec<Event>> = Vec::new();
    for ch in &community.channels {
        let (Some(old_key), true) = (ch.key, ch.private) else { continue };
        let ch_hex = crate::simd::hex::bytes_to_hex_32(&ch.id.0);
        let entitled: Vec<PublicKey> = recipients
            .iter()
            .copied()
            .filter(|r| {
                *r == my_pk
                    || roster_for_channels.is_entitled(owner_hex_for_channels.as_deref(), &r.to_hex(), &ch_hex, &[], &[])
            })
            .collect();
        let ch_new_epoch = Epoch(ch.epoch.0.checked_add(1).ok_or("channel epoch overflow")?);
        // Mint-or-reuse per channel too, keyed by (channel_id, next epoch) — same
        // retry-idempotency as the base root. The base-rekey signing above is a bunker
        // round-trip; re-check before this per-channel DB write straddles it.
        if !session.is_valid() {
            return Err("account changed during re-founding channel prepare".to_string());
        }
        let ch_new_key = mint_or_reuse_rotation_key(&cid_hex, &crate::simd::hex::bytes_to_hex_32(&ch.id.0), ch_new_epoch.0)?;
        let ch_prev_commit = super::derive::epoch_key_commitment(ch.epoch, &old_key);
        let mut ch_blobs = Vec::new();
        for r in &entitled {
            ch_blobs.push(
                super::rekey::build_blob(&signer, &my_pk.to_bytes(), r, super::rekey::RekeyScope::Channel(ch.id), ch_new_epoch, &ch_new_key)
                    .await
                    .map_err(|e| e.to_string())?,
            );
        }
        let ch_group = super::derive::channel_rekey_group_key(&community.community_root, &ch.id, ch_new_epoch);
        let ch_chunks = super::rekey::build_rekey_chunks(&signer, my_pk, &ch_group, super::rekey::RekeyScope::Channel(ch.id), ch_new_epoch, ch.epoch, &ch_prev_commit, &ch_blobs, at_secs, my_authority_citation(community, &my_pk).as_ref())
            .await
            .map_err(|e| e.to_string())?;
        channel_updates.push((ch.id, ch_new_key, ch_new_epoch));
        channel_chunk_sets.push(ch_chunks);
    }
    if !session.is_valid() {
        return Err("account changed during re-founding prepare".to_string());
    }

    // COMMIT (durable publishes only — all fetching is done). Base rekey first
    // (delivers the new root), then channel rekeys, then the compacted control.
    for c in &base_chunks {
        transport.publish_durable(c, &community.relays).await?;
    }
    for set in &channel_chunk_sets {
        for c in set {
            transport.publish_durable(c, &community.relays).await?;
        }
    }
    for (_, wrap) in &carried {
        transport.publish_durable(wrap, &community.relays).await?;
    }
    // Guestbook snapshot at the new epoch — best-effort (a Refounding succeeds without
    // it; an omitted member heals by publishing their own Join).
    let gb_group = super::derive::guestbook_group_key(&new_root, cid, new_epoch);
    let snap_id = crate::community::random_32();
    for rumor in guestbook::build_snapshot_rumors(my_pk, &recipients, snap_id, at) {
        if let Ok((wrap, _)) = guestbook::seal_guestbook_rumor_signed(&signer, my_pk, &rumor, &gb_group, Timestamp::from_secs(at_secs)).await {
            let _ = transport.publish(&wrap, &community.relays).await;
        }
    }

    // COMMIT locally, only now that the new root + compacted plane are on relays.
    if !session.is_valid() {
        return Err("account changed during re-founding commit".to_string());
    }
    if crate::db::community::community_protocol(cid)?.is_none() {
        return Ok(community.clone()); // left/deleted mid-rotation — don't resurrect.
    }
    // Save the new root/epoch + rekeyed channel keys in ONE tx FIRST, so a crash can
    // never leave the base root advanced while the channel keys lag (which would
    // re-derive the channel rekey address under the wrong root and orphan them).
    let mut updated = community.clone();
    updated.community_root = new_root;
    updated.root_epoch = new_epoch;
    for (id, key, ep) in &channel_updates {
        if let Some(c) = updated.channels.iter_mut().find(|c| c.id.0 == id.0) {
            c.key = Some(*key);
            c.epoch = *ep;
        }
    }
    crate::db::community::save_community_v2(&updated)?;
    // Archive the new epoch key + confirm the monotonic base head (the root was already
    // archived by mint_or_reuse, so this is idempotent). Record the carried heads at
    // the NEW epoch; if a crash skips this, the epoch-filtered floors bootstrap the
    // compacted control on the next follow, so they self-heal.
    crate::db::community::advance_server_root_epoch(&cid_hex, new_epoch.0, &new_root)?;
    for (h, _) in &carried {
        crate::db::community::set_edition_head_at_epoch(&cid_hex, &h.entity_hex, h.version, &h.self_hash, &h.inner_id, new_epoch.0)?;
    }
    // Re-subscribe NOW: the rotation changed every plane author, and the live sub
    // still carries the OLD epoch's set. Members adopt via the follow worker
    // (which refreshes); the REFOUNDER has no such path — without this, the very
    // client that performed the ban goes deaf to the new epoch (a rejoin lands on
    // the relays and never arrives live).
    if let Some(client) = crate::state::nostr_client() {
        super::realtime::refresh_subscription(&client).await;
    }
    // Refresh any live public links so their bundles carry the NEW root behind the
    // same URL (a link shared once survives the rotation, CORD-05 §2). Idempotent,
    // so retry a transient failure — a stranded link lands a new joiner on the dead
    // pre-refound epoch, and there's no other trigger to heal it before the next
    // refounding. A persistent failure is logged (refound already succeeded).
    for attempt in 0..3u8 {
        match refresh_public_links(transport, &updated).await {
            Ok(()) => break,
            Err(_) if !session.is_valid() => break, // swapped — stop touching this account
            Err(e) if attempt == 2 => {
                crate::log_warn!("v2: post-refounding public-link refresh failed after retries ({e}); live links may serve the prior root until the next refresh");
            }
            Err(_) => continue,
        }
    }
    Ok(updated)
}

/// BIRTH refound (§migration Phase 1.4): roll a freshly-minted migration twin from epoch 0
/// to epoch 1 so it can carry an owner-signed Guestbook SNAPSHOT of the full v1 memberlist —
/// genesis (epoch 0) has no snapshot authority (`fold_members` gates on `root_epoch > 0`), so
/// this is the ONLY way to seed a roster every honest client folds. UNLIKE [`refound_community`]
/// the two sets are DECOUPLED:
///
/// - **Rekey recipients = {owner} ONLY.** Members do NOT get the epoch-1 root via birth blobs
///   — they get it from the migration carrier's `m` (sealed AFTER this returns). Keeping the
///   set at {owner} also dodges the 120-blob rotation cap for large communities.
/// - **Snapshot members = the EXPLICIT full v1 list** (`snapshot_members`, display/roster only,
///   no keys). Chunked at SNAPSHOT_CHUNK (400)/rumor, no cap — a 10k-member community seeds fine.
///
/// The SAFEST refound possible: the owner authored 100% of the control plane seconds ago and
/// holds every edition locally, so the fold-all-or-abort discipline is trivially met (a flaky
/// relay just fires the abort → the wizard retries). Returns the epoch-1 community.
pub async fn refound_at_birth<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    snapshot_members: &[PublicKey],
) -> Result<CommunityV2, String> {
    let session = SessionGuard::capture();
    let cid = community.id();
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&cid.0);
    // Death wins every race: a dissolved community never re-founds (CORD-02 §9, parity with
    // refound_community). A migration twin should never be dissolved mid-build, but fail-closed.
    if crate::db::community::get_community_dissolved(&cid_hex).unwrap_or(false) {
        return Err("this community has been dissolved; it cannot be birth-refounded".to_string());
    }
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    if my_pk != community.owner()? {
        return Err("only the owner can birth-refound the migration twin".to_string());
    }
    let lock = super::realtime::follow_lock(cid);
    let _guard = lock.lock().await;
    let community = crate::db::community::load_community_v2(cid)?.ok_or("twin gone before birth refound")?;
    // RESUME IDEMPOTENCE: if the refound already committed locally (epoch 1) but crashed
    // before its ledger write, the wizard re-calls this. The epoch advance + compaction only
    // commit AFTER the snapshot published durably + verified back (below), so an epoch-1 twin
    // means the snapshot already landed and is readable — return it. A twin past epoch 1 is
    // unexpected (nothing else rotates a mid-migration twin).
    if community.root_epoch.0 == 1 {
        return Ok(community);
    }
    if community.root_epoch.0 != 0 {
        return Err("birth refound only rolls a genesis (epoch 0) twin".to_string());
    }
    let community = &community;

    // Compact the epoch-0 control plane onto epoch 1: re-wrap the committed head of every
    // floored entity VERBATIM (inner owner/admin signatures survive). The owner holds every
    // edition locally (authored seconds ago), so this fold-all-or-abort is trivially met.
    let floors: Floors = crate::db::community::get_all_edition_heads_full(&cid_hex)?
        .into_iter()
        .filter(|(_, f)| f.0 == community.root_epoch.0)
        .map(|(entity, f)| (entity, (f.1, f.2, f.3)))
        .collect();
    let current_control = control_group_key(&community.community_root, cid, community.root_epoch);
    let mut opened: Vec<(ParsedEdition, super::stream::OpenedStream)> = Vec::new();
    let mut seen_wraps: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
    let mut oldest: Option<u64> = None;
    let mut until: Option<u64> = None;
    // Exhaustion, not coverage — see the sibling read in `refound_community`.
    let mut truncated = false;
    for page in 0..COMPACT_MAX_PAGES {
        let query = Query { kinds: vec![stream::KIND_WRAP], authors: vec![current_control.pk_hex()], until, limit: Some(FOLLOW_PAGE), evidence: crate::community::transport::Evidence::Full, ..Default::default() };
        let wraps = transport.fetch(&query, &community.relays).await?;
        let mut fresh = 0usize;
        for w in &wraps {
            if !seen_wraps.insert(w.id) { continue; }
            fresh += 1;
            let at = w.created_at.as_secs();
            if oldest.is_none_or(|o| at < o) { oldest = Some(at); }
            if let Ok(parsed) = control::open_control_edition(w, &current_control) {
                opened.push(parsed);
            }
        }
        if fresh == 0 {
            truncated = wraps.len() >= FOLLOW_PAGE;
            break;
        }
        until = oldest;
        if page + 1 == COMPACT_MAX_PAGES { truncated = true; }
    }
    if truncated {
        return Err(
            "The community's control plane is too deep to read in full right now; re-founding stopped so no member is left behind.".to_string(),
        );
    }

    let prev_epoch = community.root_epoch; // 0
    let new_epoch = Epoch(1);
    let prev_commit = super::derive::epoch_key_commitment(prev_epoch, &community.community_root);
    if !session.is_valid() {
        return Err("account changed during birth-refound compaction".to_string());
    }
    let new_root = mint_or_reuse_rotation_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, new_epoch.0)?;
    let new_control = control_group_key(&new_root, cid, new_epoch);
    let at = now_ms();
    let at_secs = at / 1000;

    use std::collections::BTreeMap;
    let mut by_eid: BTreeMap<String, Vec<usize>> = BTreeMap::new();
    for (i, (e, _)) in opened.iter().enumerate() {
        by_eid.entry(crate::simd::hex::bytes_to_hex_32(&e.entity_id)).or_default().push(i);
    }
    let mut carried: Vec<(FoldedHead, Event)> = Vec::new();
    for (floor_key, floor) in &floors {
        let head_idx = by_eid.get(floor_key).and_then(|v| v.iter().copied().find(|&i| opened[i].0.self_hash == floor.1));
        let Some(head_idx) = head_idx else {
            return Err(format!("birth refound aborted: committed head of entity {floor_key} (v{}) not served; no state published", floor.0));
        };
        let (head_ed, head_os) = &opened[head_idx];
        let h = FoldedHead { entity_hex: floor_key.clone(), version: head_ed.version, self_hash: head_ed.self_hash, inner_id: head_ed.inner_id };
        let (rewrapped, _) = super::stream::rewrap_seal(&head_os.seal, &new_control, Timestamp::from_secs(at_secs)).map_err(|e| e.to_string())?;
        carried.push((h, rewrapped));
    }
    if !session.is_valid() {
        return Err("account changed during birth-refound acquire".to_string());
    }

    // Base rekey: the epoch-1 root to the OWNER ONLY (members key up via the carrier's `m`).
    let base_blobs = vec![
        super::rekey::build_blob(&signer, &my_pk.to_bytes(), &my_pk, super::rekey::RekeyScope::Root, new_epoch, &new_root)
            .await
            .map_err(|e| e.to_string())?,
    ];
    let base_group = super::derive::base_rekey_group_key(&community.community_root, cid, new_epoch);
    let base_chunks =
        super::rekey::build_rekey_chunks(&signer, my_pk, &base_group, super::rekey::RekeyScope::Root, new_epoch, prev_epoch, &prev_commit, &base_blobs, at_secs, my_authority_citation(community, &my_pk).as_ref())
            .await
            .map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed during birth-refound prepare".to_string());
    }

    // COMMIT to the wire: base rekey (owner's new root), then the compacted control.
    for c in &base_chunks {
        transport.publish_durable(c, &community.relays).await?;
    }
    for (_, wrap) in &carried {
        transport.publish_durable(wrap, &community.relays).await?;
    }
    // The Guestbook SNAPSHOT — the WHOLE POINT of the birth refound, so publish it DURABLY
    // and FAIL the refound if any chunk doesn't land. Unlike `refound_community` (where
    // live members heal via their own Join if a chunk drops), a seeded-never-landed member
    // CANNOT heal — omitted → absent from `memberlist()` → excluded from every future rotation
    // → permanently stranded. So the snapshot is load-bearing, not best-effort. The publishes
    // precede the local commit, so a `?`-abort leaves epoch 0 and a retry re-runs idempotently
    // (mint_or_reuse gives the same epoch-1 root; snapshot chunks coalesce commutatively).
    let gb_group = super::derive::guestbook_group_key(&new_root, cid, new_epoch);
    let snap_id = crate::community::random_32();
    let snapshot_wraps: Vec<Event> = {
        let mut out = Vec::new();
        for rumor in guestbook::build_snapshot_rumors(my_pk, snapshot_members, snap_id, at) {
            let (wrap, _) = guestbook::seal_guestbook_rumor_signed(&signer, my_pk, &rumor, &gb_group, Timestamp::from_secs(at_secs))
                .await
                .map_err(|e| format!("seal birth snapshot: {e}"))?;
            out.push(wrap);
        }
        out
    };
    for wrap in &snapshot_wraps {
        transport.publish_durable(wrap, &community.relays).await?;
    }
    // Verify-back (design §4 Phase 1.5): fetch the snapshot at the new epoch and confirm every
    // seeded member folds, before we commit locally. A relay that ACKed a durable publish but
    // won't serve it back (or a partial landing) aborts here with ZERO local state — the retry
    // re-publishes. A seed that is (legitimately) in the folded banlist is EXPECTED to be
    // absent from the memberlist (`memberlist` subtracts the banlist, so requiring a
    // banned seed to "fold" would wedge the retry forever) — so subtract the wire-folded
    // banlist from the expected set. The real caller never seeds a banned member, but the
    // arbitrary-`snapshot_members` API must not be able to wedge on one.
    let verify_view = {
        let mut v = community.clone();
        v.community_root = new_root;
        v.root_epoch = new_epoch;
        v
    };
    let expected: Vec<PublicKey> = {
        let banlist = fetch_authority(transport, &verify_view).await.banned;
        snapshot_members.iter().copied()
            .filter(|m| *m != my_pk && !banlist.contains(&m.to_hex()))
            .collect()
    };
    if !expected.is_empty() {
        let folded = memberlist(transport, &verify_view).await.unwrap_or_default();
        let missing = expected.iter().filter(|m| !folded.contains(m)).count();
        if missing > 0 {
            return Err(format!("birth snapshot verify-back: {missing} seeded member(s) not readable from relays; not committing"));
        }
    }

    // COMMIT locally, only now that the new root + compacted plane + snapshot are on relays.
    if !session.is_valid() {
        return Err("account changed during birth-refound commit".to_string());
    }
    if crate::db::community::community_protocol(cid)?.is_none() {
        return Ok(community.clone());
    }
    let mut updated = community.clone();
    updated.community_root = new_root;
    updated.root_epoch = new_epoch;
    crate::db::community::save_community_v2(&updated)?;
    crate::db::community::advance_server_root_epoch(&cid_hex, new_epoch.0, &new_root)?;
    for (h, _) in &carried {
        crate::db::community::set_edition_head_at_epoch(&cid_hex, &h.entity_hex, h.version, &h.self_hash, &h.inner_id, new_epoch.0)?;
    }
    Ok(updated)
}

/// Mint a fresh 32-byte rotation key for `(scope, new_epoch)`, or REUSE the one
/// already archived from a prior (aborted) attempt — so a retried Refounding re-
/// delivers the SAME key at the same epoch/address instead of double-minting two roots
/// a receiver's correlation dedup would collapse into a permanent fork (CORD-06 §3
/// idempotency). Archived BEFORE the first publish; `scope` is the all-zero server-root
/// sentinel for a base rotation, else the channel_id hex.
fn mint_or_reuse_rotation_key(community_id_hex: &str, scope_hex: &str, new_epoch: u64) -> Result<[u8; 32], String> {
    if let Some(existing) = crate::db::community::held_epoch_key(community_id_hex, scope_hex, new_epoch)? {
        return Ok(existing);
    }
    let fresh = crate::community::random_32();
    crate::db::community::store_epoch_key(community_id_hex, scope_hex, new_epoch, &fresh)?;
    Ok(fresh)
}

// ── The Community List (kind 13302, CORD-02 §8) ──────────────────────────────

/// This community's MEMBERSHIP subset for the 13302 list (CORD-02 §8): never the
/// icon (a rehydrating device folds it from the Control Plane), never the link
/// fields. Only PRIVATE channel keys ride — public channels derive from the root.
fn join_material(community: &CommunityV2) -> super::list::JoinMaterial {
    let hex = crate::simd::hex::bytes_to_hex_32;
    let channels = community
        .channels
        .iter()
        .filter(|c| c.private)
        // Keyed channels ONLY. A keyless entry is readable by this build but is
        // rejected outright by shipped ones (their `key` is a required String),
        // so emitting one would strand every older client on a stale list.
        .filter_map(|c| {
            c.key.map(|k| super::list::ChannelKeyRef { id: hex(&c.id.0), key: Some(hex(&k)), epoch: c.epoch.0, name: c.name.clone() })
        })
        .collect();
    super::list::JoinMaterial {
        community_id: hex(&community.identity.community_id.0),
        owner: hex(&community.identity.owner_xonly),
        owner_salt: hex(&community.identity.owner_salt),
        community_root: hex(&community.community_root),
        root_epoch: community.root_epoch.0,
        channels,
        relays: community.relays.clone(),
        name: community.name.clone(),
        extra: Default::default(),
    }
}

/// Rebuild an invite bundle from list join material, for a cross-device rehydrate
/// (the material IS the membership subset of a bundle). The owner root is still
/// verified over the network before the community is trusted (accept_bundle).
fn material_to_invite(jm: &super::list::JoinMaterial) -> CommunityInvite {
    // A keyless listing records that the channel EXISTS, not a grant — there is
    // nothing to seat, and it keys up when access is granted.
    let channels = jm
        .channels
        .iter()
        .filter_map(|c| {
            c.key.as_ref().map(|k| invite::ChannelGrant { id: c.id.clone(), key: k.clone(), epoch: c.epoch, name: c.name.clone() })
        })
        .collect();
    CommunityInvite {
        community_id: jm.community_id.clone(),
        owner: jm.owner.clone(),
        owner_salt: jm.owner_salt.clone(),
        community_root: jm.community_root.clone(),
        root_epoch: jm.root_epoch,
        channels,
        relays: jm.relays.clone(),
        name: jm.name.clone(),
        icon: None,
        expires_at: None,
        creator_npub: None,
        label: None,
        extra: Default::default(),
    }
}

/// The union of every held v2 community's relays — where this account's 13302 list
/// lives (a fresh device that opens any held community reaches the same set).
fn held_v2_relays() -> Vec<String> {
    let mut set: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
    if let Ok(ids) = crate::db::community::list_community_ids() {
        for id in ids {
            if matches!(crate::db::community::community_protocol(&id), Ok(Some(crate::community::ConcordProtocol::V2))) {
                if let Ok(Some(c)) = crate::db::community::load_community_v2(&id) {
                    set.extend(c.relays);
                }
            }
        }
    }
    set.into_iter().collect()
}

/// Fetch this account's own 13302 Community List from `relays` (the newest wins;
/// a decrypt/parse failure is "no news", never a clobber of the local mirror).
/// Fetch this account's newest 13302 list. `Err` = the transport FAILED (a caller
/// must NOT drive a replaceable-event write from a failed read — it would clobber
/// the live list); `Ok(None)` = genuinely no list yet; `Ok(Some)` = the list.
async fn fetch_community_list<T: Transport + ?Sized>(transport: &T, relays: &[String]) -> Result<Option<super::list::CommunityList>, String> {
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let query = Query {
        kinds: vec![super::kind::COMMUNITY_LIST],
        authors: vec![my_pk.to_hex()],
        limit: Some(4),
        ..Default::default()
    };
    let events = transport.fetch(&query, relays).await?;
    let seen = events.len();
    // Which copy won matters: relays disagree (one may hold a stale replaceable),
    // and a list near the NIP-44 ceiling stops accepting joins — both are invisible
    // without saying so.
    let mut undecryptable = 0usize;
    let mut unreadable: Option<(u64, String, usize, String)> = None;
    let mut best: Option<(u64, String, super::list::CommunityList)> = None;
    for e in events {
        let at = e.created_at.as_secs();
        let id_hex = e.id.to_hex();
        let content_len = e.content.len();
        match super::list::parse_list_event_signed(&signer, my_pk, &e).await {
            Ok(l) => {
                if best.as_ref().map(|(b, _, _)| at > *b).unwrap_or(true) {
                    best = Some((at, id_hex, l));
                }
            }
            Err(err) => {
                undecryptable += 1;
                if unreadable.as_ref().map(|(a, _, _, _)| at > *a).unwrap_or(true) {
                    unreadable = Some((at, id_hex, content_len, err.to_string()));
                }
            }
        }
    }
    // Only the case that costs data is worth a warning: a copy we could not read
    // that was NEWER than the one we settled for. That silently pins the account
    // to stale membership, and the parse error is the only clue to why.
    if let Some((at, id, len, err)) = &unreadable {
        if best.as_ref().map(|(b, _, _)| at > b).unwrap_or(true) {
            crate::log_net_fail!(
                "[CommunityList] IGNORED a newer copy {} created_at={at} ({len} content bytes) — falling back to stale membership: {err}",
                &id[..8]
            );
        }
    }
    if let Some((at, id, l)) = &best {
        let bytes = serde_json::to_string(l).map(|s| s.len()).unwrap_or(0);
        crate::log_debug!(
            "[CommunityList] using {} created_at={at} ({bytes}/{} bytes) of {seen} copies, {undecryptable} unreadable",
            &id[..8],
            super::stream::NIP44_MAX_PLAINTEXT
        );
    }
    Ok(best.map(|(_, _, l)| l))
}

/// Rebuild this account's 13302 from its held v2 communities, MERGE with the remote
/// copy (preserving tombstones, other-device entries, unknown fields), and publish.
/// `just_joined` is the community THIS call is recording a create/join for — the
/// ONLY community whose entry is (re)stamped `now`, so it beats any prior tombstone
/// (a deliberate re-join resurrects). Every OTHER held community that the remote
/// has tombstoned is left tombstoned (a sibling device's leave is NOT undone just
/// because we joined something else — the W1 resurrection hole). Idempotent;
/// best-effort — a list-publish failure never fails the membership change itself.
/// Returns `Ok(true)` when the list was PUBLISHED, `Ok(false)` when the attempt was
/// skipped without failing the caller (a failed remote fetch — see below). Callers that
/// need the membership to actually land use [`republish_community_list_durable`].
pub async fn republish_community_list<T: Transport + ?Sized>(transport: &T, just_joined: Option<&crate::community::CommunityId>) -> Result<bool, String> {
    let session = SessionGuard::capture();
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let relays = held_v2_relays();
    if relays.is_empty() {
        return Ok(false); // nothing held → nothing to sync
    }
    // A FAILED remote fetch must not drive this replaceable-event write: publishing
    // a list built without the remote seeds would drop older-epoch backfill anchors
    // and re-stamp add-times (the W2 seed-regression + a resurrection window).
    let remote = match fetch_community_list(transport, &relays).await {
        Ok(r) => r.unwrap_or_default(),
        Err(e) => {
            // SILENT-SKIP HAZARD: bailing is correct (publishing a list built without the
            // remote seeds drops backfill anchors), but the membership this call was meant
            // to record is now simply unrecorded. A join that lands here leaves a community
            // held locally with no list entry — and if it also carries an older tombstone,
            // nothing ever out-ranks it again. Say so loudly; `Ok(())` keeps it non-fatal.
            crate::log_warn!(
                "[CommunityList] republish SKIPPED (remote fetch failed: {}){}",
                e,
                just_joined
                    .map(|c| format!(" — the join of {} is NOT recorded across devices", &crate::simd::hex::bytes_to_hex_32(&c.0)[..8]))
                    .unwrap_or_default()
            );
            return Ok(false);
        }
    };
    let just_joined_hex = just_joined.map(|c| crate::simd::hex::bytes_to_hex_32(&c.0));
    let now = now_ms();
    let mut local = super::list::CommunityList::default();
    for id in crate::db::community::list_community_ids()? {
        if !matches!(crate::db::community::community_protocol(&id), Ok(Some(crate::community::ConcordProtocol::V2))) {
            continue;
        }
        let Some(c) = crate::db::community::load_community_v2(&id)? else { continue };
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&c.id().0);
        let is_join = just_joined_hex.as_deref() == Some(cid_hex.as_str());
        // A held community the remote has tombstoned (a sibling device left it) that
        // we are NOT currently (re)joining stays LEFT — don't re-add it, or joining a
        // different community would silently undo the leave everywhere.
        //
        // UNLESS our hold POST-DATES the removal. A rejoin whose membership never
        // reached the list (this publish is best-effort — a failed remote fetch
        // silently skips it) leaves a tombstone with no entry, and nothing can ever
        // out-rank it again: every boot the list sync reads "removed", tears the
        // community down, the rejoin re-adds it, and it loops forever. Our own hold
        // is first-hand evidence of membership, so let it settle the tie by the same
        // add-vs-remove rule the list already uses everywhere else.
        let tombstoned_at = remote
            .tombstones
            .iter()
            .find(|t| t.community_id == cid_hex)
            .map(|t| t.removed_at)
            .unwrap_or(0);
        let held_since = c.created_at_ms;
        if !is_join && !remote.is_live(&cid_hex) && tombstoned_at > 0 && held_since <= tombstoned_at {
            crate::log_warn!(
                "[CommunityList] holding {} but NOT recording it: a tombstone at {} post-dates our hold ({}) — treated as a leave from another device",
                &cid_hex[..8], tombstoned_at, held_since
            );
            continue;
        }
        // Keep an already-live entry's add time (no churn); the joined community (or a
        // genuinely-new one) stamps `now` so a re-join beats a stale tombstone. A hold
        // that outlived a tombstone re-asserts itself at its own join time, which is
        // already newer than the removal.
        let added_at = if remote.is_live(&cid_hex) && !is_join {
            remote.entries.iter().find(|e| e.community_id == cid_hex).map(|e| e.added_at).unwrap_or(now)
        } else if !is_join && tombstoned_at > 0 {
            held_since
        } else {
            now
        };
        let jm = join_material(&c);
        local.entries.push(super::list::CommunityListEntry { community_id: cid_hex, seed: jm.clone(), current: jm, added_at, extra: Default::default() });
    }
    let merged = remote.merge(&local);
    merged.assert_fits().map_err(|e| e.to_string())?;
    let event = super::list::build_list_event_signed(&signer, my_pk, &merged).await.map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed during community-list publish".to_string());
    }
    if let Err(e) = transport.publish(&event, &relays).await {
        crate::log_warn!("[CommunityList] publish FAILED ({}) — memberships stay local-only until the next edit", e);
        return Err(e);
    }
    Ok(true)
}

/// Retry budget for [`republish_community_list_durable`]. An unrecorded membership is
/// invisible to the user and self-heals only on their NEXT join, so ride out a relay
/// blip rather than a single shot. Bounded: a permanently dead relay set gives up
/// instead of spinning.
const LIST_REPUBLISH_BACKOFF_SECS: [u64; 6] = [2, 5, 15, 45, 120, 300];

/// Record a membership across devices DURABLY: retry in the background until the list
/// actually lands.
///
/// [`republish_community_list`] must never fail a join, and it deliberately publishes
/// NOTHING when the remote fetch fails (a list built without the remote seeds would drop
/// other devices' entries). One shot at that means a relay blip during a join leaves the
/// membership unrecorded until the user happens to join something else — and if a stale
/// tombstone out-ranks it, the community is stranded until a manual leave+rejoin.
///
/// Non-blocking. Skipped entirely without a live client (headless/unit tests drive the
/// generic fn directly). The `SessionGuard` is captured BEFORE the spawn and re-checked
/// before every attempt, so an account swap mid-backoff can't publish A's list from B.
pub fn republish_community_list_durable(just_joined: Option<crate::community::CommunityId>) {
    if crate::state::nostr_client().is_none() {
        return;
    }
    let session = SessionGuard::capture();
    tokio::spawn(async move {
        for (attempt, wait) in LIST_REPUBLISH_BACKOFF_SECS.iter().enumerate() {
            if !session.is_valid() {
                return;
            }
            let transport = crate::community::transport::LiveTransport::with_timeout(std::time::Duration::from_secs(12));
            match republish_community_list(&transport, just_joined.as_ref()).await {
                Ok(true) => {
                    if attempt > 0 {
                        crate::log_info!("[CommunityList] membership recorded on retry #{}", attempt);
                    }
                    return;
                }
                Ok(false) => {} // skipped (remote fetch failed) — already logged; retry
                Err(e) => crate::log_warn!("[CommunityList] republish attempt #{} failed: {}", attempt, e),
            }
            tokio::time::sleep(std::time::Duration::from_secs(*wait)).await;
        }
        crate::log_warn!(
            "[CommunityList] gave up recording membership after {} attempts — it will re-record on the next join/leave",
            LIST_REPUBLISH_BACKOFF_SECS.len()
        );
    });
}

/// Record a permanent leave tombstone for `community_id` in the 13302, published to
/// `relays` (the leaving community's own, since it's about to be deleted locally).
async fn tombstone_community_list<T: Transport + ?Sized>(transport: &T, community_id: &crate::community::CommunityId, relays: &[String]) -> Result<(), String> {
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community_id.0);
    // A failed fetch here would drop other communities' entries (only the
    // tombstone would survive); preserve them by bailing — the leave re-records
    // on the next attempt, and the local teardown already happened.
    let mut doc = match fetch_community_list(transport, relays).await {
        Ok(d) => d.unwrap_or_default(),
        Err(e) => return Err(e),
    };
    let now = now_ms();
    doc.tombstones.retain(|t| t.community_id != cid_hex);
    doc.tombstones.push(super::list::Tombstone { community_id: cid_hex, removed_at: now, extra: Default::default() });
    doc.assert_fits().map_err(|e| e.to_string())?;
    let event = super::list::build_list_event_signed(&signer, my_pk, &doc).await.map_err(|e| e.to_string())?;
    transport.publish(&event, relays).await
}

/// Sync memberships from the 13302 across devices: fetch this account's list from
/// `bootstrap_relays` (its held communities' relays plus any caller-supplied set for
/// a fresh device), and JOIN every live entry not already held — reconstructing the
/// community from its join material and re-verifying the owner root. Returns the
/// newly-rehydrated communities (so the caller can subscribe + notify).
/// What one Community-List sync changed locally.
pub struct ListSyncOutcome {
    /// Communities newly adopted from the list (already persisted + chat-registered).
    pub joined: Vec<CommunityV2>,
    /// Communities a sibling device LEFT, as `(community_id_hex, channel_id_hexes)`.
    ///
    /// The rows are already gone here, so the ids are captured BEFORE deletion: the caller
    /// still has to finish the local teardown (chat rows, STATE, the live subscription),
    /// and it can't look them up afterwards. Deleting the community while leaving its chat
    /// row behind is what produces a ghost "0 Members" room pointing at nothing.
    pub removed: Vec<(String, Vec<String>)>,
}

pub async fn sync_community_list<T: Transport + ?Sized>(transport: &T, bootstrap_relays: &[String]) -> Result<ListSyncOutcome, String> {
    let session = SessionGuard::capture();
    let mut relays = held_v2_relays();
    relays.extend(bootstrap_relays.iter().cloned());
    relays.sort();
    relays.dedup();
    if relays.is_empty() {
        return Ok(ListSyncOutcome { joined: vec![], removed: vec![] });
    }
    // A cross-device sync that finds nothing is indistinguishable from one that
    // never ran, so every exit says why — this path is only ever debugged after
    // the fact, from a user's log.
    let list = match fetch_community_list(transport, &relays).await {
        Ok(Some(l)) => {
            crate::log_debug!(
                "[CommunityList] fetched: {} entries, {} tombstones, across {} relays",
                l.entries.len(),
                l.tombstones.len(),
                relays.len()
            );
            l
        }
        Ok(None) => {
            // Transient by nature: boot runs many concurrent passes and a relay that
            // times out under that load returns nothing. Only persistent absence
            // matters, and that shows up as "adopted nothing" anyway.
            crate::log_debug!("[CommunityList] no kind-13302 across {} relays", relays.len());
            return Ok(ListSyncOutcome { joined: vec![], removed: vec![] });
        }
        Err(e) => {
            crate::log_net_fail!("[CommunityList] fetch failed across {} relays: {e}", relays.len());
            return Ok(ListSyncOutcome { joined: vec![], removed: vec![] });
        }
    };
    // Receive-side teardown (the counterpart to the republish tombstone guard):
    // a community this device still holds but the synced list shows TOMBSTONED (a
    // sibling device left it) and NOT live gets torn down here, so a leave on one
    // device propagates to the others. A re-join would have re-added it live
    // (beating the tombstone), so is_live short-circuits the honest case.
    let mut removed: Vec<(String, Vec<String>)> = Vec::new();
    for t in &list.tombstones {
        if list.is_live(&t.community_id) {
            continue;
        }
        let Some(cid) = crate::simd::hex::hex_to_bytes_32_checked(&t.community_id) else { continue };
        let id = crate::community::CommunityId(cid);
        let Some(held) = crate::db::community::load_community_v2(&id).ok().flatten() else {
            continue; // not held — nothing to tear down
        };
        // `is_live` above assumes a rejoin re-added an entry, but recording that entry is
        // best-effort: a relay blip at join time leaves the tombstone unopposed forever, and
        // this would then delete the community on every sync. So let the LOCAL hold break the
        // tie too — a hold created after the removal IS the rejoin, whether or not its entry
        // ever reached the list. Same rule the v1 sweep uses.
        if held.created_at_ms > t.removed_at {
            crate::log_warn!(
                "[CommunityList] {} is tombstoned at {} but our hold ({}) post-dates it — treating as a rejoin, not tearing down",
                &t.community_id[..8], t.removed_at, held.created_at_ms
            );
            continue;
        }
        if !session.is_valid() {
            return Err("account changed during community-list sync".to_string());
        }
        let channel_ids: Vec<String> = held.channels.iter().map(|c| crate::simd::hex::bytes_to_hex_32(&c.id.0)).collect();
        let _ = crate::db::community::delete_community(&t.community_id);
        removed.push((t.community_id.clone(), channel_ids));
    }
    let mut joined = Vec::new();
    for entry in list.live_entries() {
        let Some(cid) = crate::simd::hex::hex_to_bytes_32_checked(&entry.community_id) else { continue };
        if crate::db::community::load_community_v2(&crate::community::CommunityId(cid)).ok().flatten().is_some() {
            continue; // already held
        }
        if !session.is_valid() {
            return Err("account changed during community-list sync".to_string());
        }
        // The material IS a bundle; accept_bundle re-verifies the owner root, saves,
        // and seeds floors. NO Guestbook Join: this device is receiving keys the
        // account already holds elsewhere — the membership was announced when it
        // actually joined, and a key sync is not a membership event.
        let bundle = material_to_invite(&entry.current);
        match accept_bundle(transport, &session, &bundle, None, false).await {
            Ok(community) => joined.push(community),
            // A listed-but-unadoptable entry is the failure mode that reads as
            // "cross-device sync is broken": the community never appears and any
            // parked invite for it is never retired.
            Err(e) => crate::log_net_fail!(
                "[CommunityList] {} is listed but adoption failed: {e}",
                &entry.community_id[..entry.community_id.len().min(8)]
            ),
        }
    }
    Ok(ListSyncOutcome { joined, removed })
}

// ── Control edition authoring (CORD-04 roles / CORD-02 §6 / CORD-03 §2) ──────

/// Publish one control edition (a role, grant, banlist, community-metadata, or
/// channel-metadata edit) at the next version for its entity, chaining `prev` from
/// our held head, and advance our local floor. Authority is enforced by every
/// reader's roster fold (CORD-04 §5: authority is rejection, not prevention), so this
/// requires only a valid local signer; a well-behaved client checks its own rank
/// first, but a reader drops an unauthorized edition regardless.
/// This actor's authority citation for a control edition (CORD-04 §5): the head
/// of their OWN Grant entity, pinned by coordinate + version + edition hash.
///
/// A SYNC FLOOR, not a verdict — a verifier refuses to act until it has synced
/// at least this Grant, then resolves rank against its CURRENT roster, so a
/// demoted admin is never grandfathered by an old-but-once-valid citation.
///
/// `None` for the owner (supreme, rank comes from the community id) and `None`
/// when no Grant head is held — an actor who cannot cite has no rank to claim,
/// and the edition is dropped by a conforming reader either way.
/// The verify half of [`my_authority_citation`] (CORD-04 §5): does the actor's
/// cited Grant prove authority we have actually SYNCED? The owner is supreme and
/// cites nothing. A non-owner MUST cite, and we must hold that Grant at ≥ the
/// cited version with the cited hash at the tip — else fail closed, because
/// honoring an action whose authority we can't confirm is exactly how a demoted
/// moderator keeps moderating.
///
/// Completeness only: the permission + outrank is the separate roster check, so a
/// since-demoted actor is refused there (refuse-superseded). An action citing a
/// version we haven't synced parks and is re-judged on the next roster sync — the
/// sync path can't escalate to a blocking fetch.
pub(super) fn citation_is_synced(
    cid_hex: &str,
    owner_hex: &str,
    actor_hex: &str,
    citation: Option<&crate::community::edition::AuthorityCitation>,
) -> bool {
    if owner_hex == actor_hex {
        return true;
    }
    if citation.is_none() {
        return false;
    }
    let cid_bytes = crate::simd::hex::hex_to_bytes_32(cid_hex);
    let actor_bytes = crate::simd::hex::hex_to_bytes_32(actor_hex);
    let grant_hex = crate::simd::hex::bytes_to_hex_32(&super::derive::grant_locator(
        &crate::community::CommunityId(cid_bytes),
        &actor_bytes,
    ));
    let head: Vec<crate::community::roster::EntityHead> =
        crate::db::community::get_edition_head(cid_hex, &grant_hex)
            .ok()
            .flatten()
            .map(|(version, self_hash)| crate::community::roster::EntityHead {
                entity_hex: grant_hex.clone(),
                version,
                self_hash,
                inner_id: [0u8; 32],
                citation: None,
            })
            .into_iter()
            .collect();
    crate::community::roster::authority_citation_satisfied(&head, Some(owner_hex), actor_hex, &grant_hex, citation)
}

/// [`my_authority_citation`], but refusing to emit an action every reader will
/// drop (CORD-04 §5: an uncited non-owner action is not honored).
///
/// The citation is built from PERSISTED heads, which only `follow_control` writes
/// — so an admin who hasn't folded yet (just promoted, or freshly restored) would
/// otherwise publish uncited and have the action silently vanish on every client,
/// with nothing shown locally. Failing here turns that into one retryable error.
fn required_authority_citation(
    community: &CommunityV2,
    actor: &PublicKey,
) -> Result<Option<crate::community::edition::AuthorityCitation>, String> {
    if community.owner().ok().as_ref() == Some(actor) {
        return Ok(None); // supreme, cites nothing
    }
    my_authority_citation(community, actor).map(Some).ok_or_else(|| {
        "your admin rights aren't synced on this device yet — reopen the community and retry".to_string()
    })
}

fn my_authority_citation(
    community: &CommunityV2,
    actor: &PublicKey,
) -> Option<crate::community::edition::AuthorityCitation> {
    if community.owner().ok().as_ref() == Some(actor) {
        return None;
    }
    let entity_id = super::derive::grant_locator(community.id(), &actor.to_bytes());
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let entity_hex = crate::simd::hex::bytes_to_hex_32(&entity_id);
    crate::db::community::get_edition_head(&cid_hex, &entity_hex)
        .ok()
        .flatten()
        .map(|(version, edition_hash)| crate::community::edition::AuthorityCitation { entity_id, version, edition_hash })
}

/// Refuse a root-derived write whose in-hand struct predates a rotation.
///
/// A Ban's refound buries the old root while the caller's `CommunityV2` still
/// points at it; publishing there lands on a plane nobody folds — the action
/// "succeeds" and silently never happened (an unban that doesn't unban, an
/// invite that strands its joiner on a dead epoch). Failing loudly instead lets
/// the caller reload and retry against the living root.
fn assert_current_root(community: &CommunityV2) -> Result<(), String> {
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    match crate::db::community::get_server_root_epoch(&cid_hex)? {
        Some(held) if held != community.root_epoch.0 => Err(format!(
            "the community re-founded mid-action (epoch {} -> {held}); retry",
            community.root_epoch.0
        )),
        _ => Ok(()), // no row = a not-yet-persisted create; nothing newer to defer to
    }
}

async fn publish_control_edition<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    session: &SessionGuard,
    vsk: &str,
    entity_id: &[u8; 32],
    content: &str,
) -> Result<(), String> {
    assert_current_root(community)?;
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let control = control_group_key(&community.community_root, community.id(), community.root_epoch);
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let entity_hex = crate::simd::hex::bytes_to_hex_32(entity_id);
    let (version, prev) = match crate::db::community::get_edition_head(&cid_hex, &entity_hex)? {
        Some((v, h)) => (v + 1, Some(h)),
        None => (1, None),
    };
    // CORD-04 §5: a non-owner names the exact Grant edition it claims its rank
    // under. Computed here rather than passed in — the citation is a property of
    // WHO IS ACTING, identical for every entity kind, so deciding it per call
    // site is nine chances to forget (and nine were, silently: every site passed
    // None). The owner cites nothing; their rank is the community id itself.
    let citation = required_authority_citation(community, &my_pk)?;
    let at = now_ms() / 1000;
    let rumor = control::build_edition_rumor(my_pk, vsk, entity_id, version, prev.as_ref(), content, at, citation.as_ref());
    let (wrap, _) = control::seal_control_edition_signed(&signer, my_pk, &rumor, &control, Timestamp::from_secs(at)).await.map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed before control publish".to_string());
    }
    transport.publish(&wrap, &community.relays).await?;
    // Advance our own floor so a follow-up edit chains from this head and refuse-
    // downgrade holds; open our own wrap to recover the self_hash + inner_id.
    // Re-check the session AFTER the publish await: a swap mid-publish means the
    // pool now points at another account's DB — skipping is safe (the next own
    // edit rebuilds the same head from the relay's copy).
    if !session.is_valid() {
        return Ok(());
    }
    if let Ok((ed, _)) = control::open_control_edition(&wrap, &control) {
        crate::db::community::set_edition_head_at_epoch(&cid_hex, &entity_hex, ed.version, &ed.self_hash, &ed.inner_id, community.root_epoch.0)?;
    }
    Ok(())
}

/// Merge our OWN just-published Role/Grant into the locally stored roster.
///
/// v2 persists the roster only inside `follow_control`, so a role or grant we
/// just published is invisible to every sync local read (entitlement, capability
/// gates, the next grant) until the next fold. This writes what we are already
/// authorized to have written; the next fold recomputes from the plane and
/// converges. Mirrors the fold's own write, so the stored `roles_at` is left
/// alone — a real edition always outranks this optimistic merge.
fn merge_local_roster(cid_hex: &str, role: Option<&crate::community::roles::Role>, grant: Option<&crate::community::roles::MemberGrant>) {
    let mut roster = crate::db::community::get_community_roles(cid_hex).unwrap_or_default();
    if let Some(r) = role {
        match roster.roles.iter_mut().find(|x| x.role_id == r.role_id) {
            Some(slot) => *slot = r.clone(),
            None => roster.roles.push(r.clone()),
        }
    }
    if let Some(g) = grant {
        match roster.grants.iter_mut().find(|x| x.member == g.member) {
            Some(slot) => *slot = g.clone(),
            None => roster.grants.push(g.clone()),
        }
    }
    let at = crate::db::community::get_community_roles_at(cid_hex).unwrap_or(0);
    if let Err(e) = crate::db::community::set_community_roles(cid_hex, &roster, at) {
        crate::log_warn!("v2: local roster merge failed (heals on the next control fold): {e}");
    }
}

/// Create or edit a Role (vsk 1, CORD-04 §2). `role.role_id` is the coordinate; a
/// rename or permission change is a versioned edit of the same id. Gated on the
/// reader side by `MANAGE_ROLES` + outrank.
pub async fn set_role<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, role: &crate::community::roles::Role) -> Result<(), String> {
    let session = SessionGuard::capture();
    super::roles::validate_role(role)?;
    let content = super::roles::role_content_json(role)?;
    let role_id = crate::simd::hex::hex_to_bytes_32_checked(&role.role_id).ok_or("role_id must be 32-byte hex")?;
    publish_control_edition(transport, community, &session, vsk::ROLE, &role_id, &content).await
}

/// Grant or revoke a member's Roles (vsk 3, CORD-04 §2). Empty `role_ids` is a
/// revoke. Gated on the reader side by `MANAGE_ROLES` + outrank of every role + the
/// member.
pub async fn grant_roles<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, member: &PublicKey, role_ids: Vec<String>) -> Result<(), String> {
    let session = SessionGuard::capture();
    let grant = crate::community::roles::MemberGrant { member: member.to_hex(), role_ids };
    let content = super::roles::grant_content_json(&grant)?;
    let eid = super::derive::grant_locator(community.id(), &member.to_bytes());
    publish_control_edition(transport, community, &session, vsk::GRANT, &eid, &content).await
}

/// The community's @admin role id: the folded Server-scope ADMIN_ALL role when one
/// exists, else (with `create_if_missing`) a DETERMINISTIC mint — the same id on
/// every device, so concurrent grants converge as editions of ONE entity instead
/// of forking two Admin roles.
pub async fn ensure_admin_role<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    view: &AuthorityView,
    create_if_missing: bool,
) -> Result<Option<String>, String> {
    use crate::community::roles::{Permissions, Role, RoleScope};
    if let Some(r) = view
        .roles
        .roles
        .iter()
        .find(|r| matches!(r.scope, RoleScope::Server) && r.permissions.contains(Permissions::ADMIN_ALL))
    {
        return Ok(Some(r.role_id.clone()));
    }
    if !create_if_missing {
        return Ok(None);
    }
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let role_id = crate::crypto::sha256_hex(format!("vector/v2/role/admin/{cid_hex}").as_bytes());
    set_role(transport, community, &Role::admin(role_id.clone())).await?;
    Ok(Some(role_id))
}

/// Grant the @admin role (minting it deterministically when absent), MERGED into
/// the member's existing grant — a grant entity replaces whole (CORD-04 §2), so a
/// blind push would erase their other roles. Owner-only: the position-1 Admin is
/// manageable only by position 0 (an equal never outranks it), and refusing
/// before any publish keeps an unauthorized edition of the DETERMINISTIC admin
/// entity from advancing this device's own floor onto a head readers reject.
pub async fn grant_admin<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, member: &PublicKey) -> Result<(), String> {
    // Guard spans the multi-page fetch below: a swap mid-fetch must not let the
    // downstream publish's own (post-swap) guard write account A's floor into B.
    let session = SessionGuard::capture();
    let my_pk = me_pk()?;
    if my_pk != community.owner()? {
        return Err("only the community owner can grant @admin".to_string());
    }
    let view = fetch_authority(transport, community).await;
    if !session.is_valid() {
        return Err("account changed during grant".to_string());
    }
    let member_hex = member.to_hex();
    require_grant_head(community, &view, &member_hex)?;
    let role_id = ensure_admin_role(transport, community, &view, true)
        .await?
        .expect("create_if_missing yields an id");
    let mut role_ids = view
        .roles
        .grants
        .iter()
        .find(|g| g.member == member_hex)
        .map(|g| g.role_ids.clone())
        .unwrap_or_default();
    if role_ids.contains(&role_id) {
        return Ok(()); // already admin — don't bump the grant edition for nothing.
    }
    role_ids.push(role_id);
    grant_roles(transport, community, member, role_ids).await
}

/// Strip the @admin role from the member's grant, preserving their other roles.
/// A no-op when they don't hold it. Owner-only, like [`grant_admin`].
pub async fn revoke_admin<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, member: &PublicKey) -> Result<(), String> {
    let session = SessionGuard::capture();
    let my_pk = me_pk()?;
    if my_pk != community.owner()? {
        return Err("only the community owner can revoke @admin".to_string());
    }
    let view = fetch_authority(transport, community).await;
    if !session.is_valid() {
        return Err("account changed during revoke".to_string());
    }
    let member_hex = member.to_hex();
    require_grant_head(community, &view, &member_hex)?;
    let Some(role_id) = ensure_admin_role(transport, community, &view, false).await? else {
        return Ok(()); // no admin role exists — nothing to revoke.
    };
    let mut role_ids = view
        .roles
        .grants
        .iter()
        .find(|g| g.member == member_hex)
        .map(|g| g.role_ids.clone())
        .unwrap_or_default();
    let before = role_ids.len();
    role_ids.retain(|r| r != &role_id);
    if role_ids.len() == before {
        return Ok(());
    }
    grant_roles(transport, community, member, role_ids).await
}

/// A grant replaces whole — refuse the merge when this member's grant is FLOORED
/// locally but no head folded (withheld / evicted): a blind push at that point
/// would erase their other roles at a higher version.
fn require_grant_head(community: &CommunityV2, view: &AuthorityView, member_hex: &str) -> Result<(), String> {
    let Some(member) = crate::simd::hex::hex_to_bytes_32_checked(member_hex) else {
        return Err("malformed member key".to_string());
    };
    let eid_hex = crate::simd::hex::bytes_to_hex_32(&super::derive::grant_locator(community.id(), &member));
    if view.floored.contains(&eid_hex) && !view.head_entities.contains(&eid_hex) {
        return Err("this member's current grant could not be fetched; try again once relays serve the control plane".to_string());
    }
    Ok(())
}

/// Replace the Banlist (vsk 4, CORD-04 §4) with `banned` (lowercase-hex npubs), the
/// whole list on every edit. Gated on the reader side by `BAN`.
pub async fn set_banlist<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, banned: &[String]) -> Result<(), String> {
    let session = SessionGuard::capture();
    super::roles::validate_banlist(banned)?;
    let content = super::roles::banlist_content_json(banned)?;
    let eid = super::derive::banlist_locator(community.id());
    publish_control_edition(transport, community, &session, vsk::BANLIST, &eid, &content).await
}

/// Edit the community metadata (vsk 0, CORD-02 §6). Gated on the reader side by
/// `MANAGE_METADATA`.
pub async fn edit_community_metadata<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, meta: &control::CommunityMetadata) -> Result<(), String> {
    let session = SessionGuard::capture();
    control::validate_community_metadata(meta).map_err(|e| e.to_string())?;
    let content = serde_json::to_string(meta).map_err(|e| e.to_string())?;
    publish_control_edition(transport, community, &session, vsk::COMMUNITY_METADATA, &community.id().0, &content).await
}

/// Persist a freshly-published icon/banner onto the held row and return the fresh
/// row. Reloads under the community's follow lock: `save_community_v2` is a
/// whole-row save that prunes channels absent from the passed struct, so writing
/// a stale pre-upload copy would drop rows a concurrent fold just landed.
pub async fn persist_community_image(
    id: &crate::community::CommunityId,
    img: control::ImageRef,
    is_banner: bool,
    session: &SessionGuard,
) -> Option<CommunityV2> {
    let lock = super::realtime::follow_lock(id);
    let _guard = lock.lock().await;
    if !session.is_valid() {
        return None;
    }
    let mut fresh = crate::db::community::load_community_v2(id).ok()??;
    if is_banner {
        fresh.banner = Some(img);
    } else {
        fresh.icon = Some(img);
    }
    crate::db::community::save_community_v2(&fresh).ok()?;
    Some(fresh)
}

/// Add or edit a channel's metadata (vsk 2, CORD-03 §2). `channel_id` is the
/// coordinate. Gated on the reader side by `MANAGE_CHANNELS`.
pub async fn edit_channel_metadata<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, channel_id: &ChannelId, meta: &control::ChannelMetadata) -> Result<(), String> {
    let session = SessionGuard::capture();
    let my_pk = me_pk()?;
    ensure_channel_manager(community, &my_pk)?;
    let old_name = community.channel(channel_id).map(|c| c.name.clone());
    // Public → private CONVERSION is a key rotation (CORD-03 §2) this build doesn't
    // mint yet — refuse the flag flip rather than publish an edition no reader can
    // key (members would keep posting on the root-derived plane, splitting the
    // channel). Private → public works (readers heal to the root derivation).
    if meta.private {
        if let Some(held) = community.channel(channel_id) {
            if !held.private {
                return Err("converting a public channel to private is not supported yet".to_string());
            }
        }
    }
    control::validate_channel_metadata(meta).map_err(|e| e.to_string())?;
    let content = serde_json::to_string(meta).map_err(|e| e.to_string())?;
    publish_control_edition(transport, community, &session, vsk::CHANNEL_METADATA, &channel_id.0, &content).await?;
    // Apply locally too. The fold is the authority but runs later, so without this
    // an edit we just made reads back stale until some future control pass — the
    // rename appears to have silently failed.
    if !session.is_valid() {
        return Ok(());
    }
    if let Ok(Some(mut held)) = crate::db::community::load_community_v2(community.id()) {
        if let Some(ch) = held.channels.iter_mut().find(|c| c.id.0 == channel_id.0) {
            ch.name = meta.name.clone();
            ch.private = meta.private;
            ch.voice = meta.voice;
            ch.meta_custom = meta.custom.clone();
            ch.meta_extra = meta.extra.clone();
            crate::db::community::save_community_v2(&held)?;
        }
    }
    // Keep the companion access role's label in step with the channel it gates.
    if meta.private {
        if let Some(old) = old_name.filter(|o| *o != meta.name) {
            rename_channel_access_role(transport, community, channel_id, &old, &meta.name, &session).await;
        }
    }
    Ok(())
}

/// Rename a private channel's companion access role to follow the channel (CORD-04 §2).
/// Best-effort and never fatal: the channel rename has already published, and a role's
/// name is cosmetic — entitlement is carried by the scope, not the label.
///
/// Only renames a label still equal to the channel's OLD name, so a deliberately
/// customised role name survives a channel rename untouched.
async fn rename_channel_access_role<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    old_name: &str,
    new_name: &str,
    session: &SessionGuard,
) {
    let (Ok(my_pk), Ok(owner)) = (me_pk(), community.owner()) else {
        return;
    };
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let chan_hex = crate::simd::hex::bytes_to_hex_32(&channel_id.0);
    // Fetched, not cached: `set_role` republishes the WHOLE role body, so a stale
    // cache would clobber a permission edit this client has not folded yet.
    let mut roster = fetch_authority(transport, community).await.roles;
    let cached = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    for r in cached.roles {
        if !roster.roles.iter().any(|x| x.role_id == r.role_id) {
            roster.roles.push(r);
        }
    }
    if !session.is_valid() {
        return;
    }
    // MANAGE_CHANNELS got us the rename; the role edition needs MANAGE_ROLES + outrank
    // of its own. Publishing one readers reject would wedge our later, legitimate role
    // edits behind a rejected chain, so verify before publishing rather than after.
    let (me_hex, owner_hex) = (my_pk.to_hex(), owner.to_hex());
    if !roster.is_authorized_in(&me_hex, Some(&owner_hex), &chan_hex, crate::community::roles::Permissions::MANAGE_ROLES) {
        return;
    }
    // Same selector `grant_channel_access` vends: the permission-less scoped role. A
    // per-channel moderator role sharing the scope is NOT the access list.
    let Some(mut role) = roster
        .channel_roles(&chan_hex)
        .into_iter()
        .find(|r| r.permissions == crate::community::roles::Permissions::empty() && r.name == old_name)
        .cloned()
    else {
        return;
    };
    if !roster.can_act_on_position(&me_hex, Some(&owner_hex), role.position, crate::community::roles::Permissions::MANAGE_ROLES) {
        return;
    }
    role.name = new_name.to_string();
    if let Err(e) = set_role(transport, community, &role).await {
        crate::log_warn!("v2: channel renamed but its access role did not follow: {e}");
        return;
    }
    if session.is_valid() {
        merge_local_roster(&cid_hex, Some(&role), None);
    }
}

/// The local mirror of the reader's `MANAGE_CHANNELS` fold gate (CORD-03 §2): the
/// owner, or a roster-authorized manager who isn't banned. Refusing BEFORE any
/// publish keeps an unauthorized device from advancing its own edition floor onto
/// a head every reader rejects (wedging its later, legitimately-authorized edits
/// behind a rejected chain).
fn ensure_channel_manager(community: &CommunityV2, me: &PublicKey) -> Result<(), String> {
    let owner = community.owner()?;
    if *me == owner {
        return Ok(());
    }
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let me_hex = me.to_hex();
    if crate::db::community::get_community_banlist(&cid_hex).unwrap_or_default().contains(&me_hex) {
        return Err("you are banned from this community".to_string());
    }
    let roster = crate::db::community::get_community_roles(&cid_hex)?;
    if roster.is_authorized(&me_hex, Some(&owner.to_hex()), crate::community::roles::Permissions::MANAGE_CHANNELS) {
        Ok(())
    } else {
        Err("managing channels here needs the MANAGE_CHANNELS permission".to_string())
    }
}

/// Create a new PUBLIC channel (CORD-03 §2): mint a fresh id, publish its metadata
/// edition (vsk 2), and add it to the held community. A Public channel derives its Chat
/// Plane from the `community_root` (no per-channel key), so other members fold it in on
/// their next control follow with nothing to distribute. Returns the new channel id.
/// Reader-gated by `MANAGE_CHANNELS`.
pub async fn create_public_channel<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, name: &str) -> Result<ChannelId, String> {
    let channel_id = ChannelId(super::super::random_32());
    create_public_channel_with_id(transport, community, name, channel_id).await?;
    Ok(channel_id)
}

/// [`create_public_channel`] with a CALLER-CHOSEN id — the migration-only entry point
/// (§migration) that reuses a v1 channel's id so chat history stitches through the flip.
/// Asserts the id isn't already live in a DIFFERENT held v2 community before minting.
pub async fn create_public_channel_with_id<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, name: &str, channel_id: ChannelId) -> Result<(), String> {
    let session = SessionGuard::capture();
    // Serialize with the follow worker: the save below writes the WHOLE community
    // row from this caller's struct, so an unserialized concurrent follow adopting
    // a rotation would be rolled back to a stale root (a deaf community).
    let lock = super::realtime::follow_lock(community.id());
    let _guard = lock.lock().await;
    let my_pk = me_pk()?;
    ensure_channel_manager(community, &my_pk)?;
    assert_channel_id_free(&channel_id, community.id())?;
    let meta = control::ChannelMetadata { name: name.to_string(), private: false, voice: None, deleted: None, custom: None, extra: Default::default() };
    control::validate_channel_metadata(&meta).map_err(|e| e.to_string())?;
    let content = serde_json::to_string(&meta).map_err(|e| e.to_string())?;
    publish_control_edition(transport, community, &session, vsk::CHANNEL_METADATA, &channel_id.0, &content).await?;
    if !session.is_valid() {
        return Err("account changed during channel create".to_string());
    }
    // Add locally + persist so the creator can post immediately (peers fold it in).
    let mut updated = community.clone();
    updated.channels.push(ChannelV2 { id: channel_id, name: name.to_string(), private: false, key: None, epoch: updated.root_epoch, voice: None, meta_custom: None, meta_extra: Default::default() });
    crate::db::community::save_community_v2(&updated)?;
    Ok(())
}

/// Refuse a channel id already live in a DIFFERENT held v2 community — the same
/// cross-community hijack the `save_community_v2` guard forecloses, checked up front so a
/// migration twin never adopts an id it doesn't own. A collision with a v1-owned row is
/// fine (that's the whole point — the flip re-parents it); only a foreign v2 owner blocks.
fn assert_channel_id_free(channel_id: &ChannelId, community_id: &crate::community::CommunityId) -> Result<(), String> {
    let ch_hex = crate::simd::hex::bytes_to_hex_32(&channel_id.0);
    if let Ok(Some(existing)) = crate::db::community::community_id_for_channel(&ch_hex) {
        let mine = crate::simd::hex::bytes_to_hex_32(&community_id.0);
        let existing_id = crate::community::CommunityId(crate::simd::hex::hex_to_bytes_32(&existing));
        if existing != mine
            && matches!(crate::db::community::community_protocol(&existing_id), Ok(Some(crate::community::ConcordProtocol::V2)))
        {
            return Err("channel id is already live in another v2 community".to_string());
        }
    }
    Ok(())
}

/// Create a new PRIVATE channel (CORD-03 §2): mint a fresh id + an independent
/// random key at channel-epoch 1, mint a companion channel-scoped Role that is
/// the channel's access list (CORD-04 §2), deliver the key to the entitled over
/// the rekey plane (CORD-06 §1), then announce the channel (vsk 2, `private`).
/// Epoch 0 is the root generation ("the first privatisation is epoch 1"), so the
/// delivery commits its continuity to `(0, community_root)` — verifiable by every
/// member and bound to THIS community's root. The key ships BEFORE the
/// announcement: an aborted attempt leaves only an unannounced crate (invisible),
/// and a retry mints a fresh id, so there is no same-coordinate double-mint to
/// fork on. Live public links are refreshed; they carry no private key, so this
/// only re-states the public set.
pub async fn create_private_channel<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, name: &str) -> Result<ChannelId, String> {
    let channel_id = ChannelId(super::super::random_32());
    create_private_channel_with_id(transport, community, name, channel_id).await?;
    Ok(channel_id)
}

/// The companion Role minted alongside a Private channel — the channel's access
/// list (CORD-04 §2 `scope: {"kind":"channel"}`). Same name as the channel, and
/// **no permission bits**: it confers read access, which is key possession, never
/// authority. Position sits below every management role for the same reason.
pub fn channel_access_role(channel_id: &ChannelId, name: &str) -> crate::community::roles::Role {
    use crate::community::roles::{Permissions, Role, RoleScope};
    Role {
        role_id: crate::simd::hex::bytes_to_hex_32(&super::super::random_32()),
        name: name.to_string(),
        position: u32::MAX - 1,
        permissions: Permissions::empty(),
        scope: RoleScope::Channel(crate::simd::hex::bytes_to_hex_32(&channel_id.0)),
        color: 0,
    }
}

/// [`create_private_channel`] with a CALLER-CHOSEN id — the migration-only entry point
/// (§migration) reusing a v1 private channel's id so history stitches through the flip.
pub async fn create_private_channel_with_id<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, name: &str, channel_id: ChannelId) -> Result<(), String> {
    let session = SessionGuard::capture();
    // Serialize with the follow worker across the whole fetch→publish→save span
    // (the memberlist fetch is seconds long; an unserialized follow adopting a
    // rotation meanwhile would be rolled back by the whole-row save below).
    let lock = super::realtime::follow_lock(community.id());
    let _guard = lock.lock().await;
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    ensure_channel_manager(community, &my_pk)?;
    assert_channel_id_free(&channel_id, community.id())?;
    let meta = control::ChannelMetadata { name: name.to_string(), private: true, voice: None, deleted: None, custom: None, extra: Default::default() };
    control::validate_channel_metadata(&meta).map_err(|e| e.to_string())?;
    let content = serde_json::to_string(&meta).map_err(|e| e.to_string())?;

    let channel_key = super::super::random_32();
    let epoch = Epoch(1);

    // The channel's access list: a companion channel-scoped Role (CORD-04 §2),
    // granted to me so the creator is entitled from the first edition.
    let access_role = channel_access_role(&channel_id, name);
    let access_role_ids = vec![access_role.role_id.clone()];

    // Recipients are the ENTITLED, not the memberlist: CORD-03's private channel
    // is "readable only by granted role-holders". At create that is me (plus the
    // owner, who is always entitled) — everyone else keys up when granted.
    let owner = community.owner()?;
    let mut recipients = vec![my_pk];
    if owner != my_pk {
        recipients.push(owner);
    }
    let prev_commit = super::derive::epoch_key_commitment(Epoch(0), &community.community_root);
    let mut blobs = Vec::with_capacity(recipients.len());
    for r in &recipients {
        blobs.push(
            rekey::build_blob(&signer, &my_pk.to_bytes(), r, RekeyScope::Channel(channel_id), epoch, &channel_key)
                .await
                .map_err(|e| e.to_string())?,
        );
    }
    let group = channel_rekey_group_key(&community.community_root, &channel_id, epoch);
    let at_secs = now_ms() / 1000;
    let chunks = rekey::build_rekey_chunks(&signer, my_pk, &group, RekeyScope::Channel(channel_id), epoch, Epoch(0), &prev_commit, &blobs, at_secs, my_authority_citation(community, &my_pk).as_ref())
        .await
        .map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed during channel create".to_string());
    }
    for c in &chunks {
        transport.publish_durable(c, &community.relays).await?;
    }
    publish_control_edition(transport, community, &session, vsk::CHANNEL_METADATA, &channel_id.0, &content).await?;
    if !session.is_valid() {
        return Err("account changed during channel create".to_string());
    }
    // Publish the access list AFTER the channel exists, so a peer folding the
    // Role always resolves the channel it scopes to. A failure here leaves a
    // channel only its creator can read — recoverable by re-granting, never a
    // leak.
    set_role(transport, community, &access_role).await?;
    grant_roles(transport, community, &my_pk, access_role_ids.clone()).await?;
    if !session.is_valid() {
        return Err("account changed during channel create".to_string());
    }
    // The fold is the authority but runs later; without this the creator is not
    // yet entitled to their own channel and the next grant finds no access role.
    merge_local_roster(
        &crate::simd::hex::bytes_to_hex_32(&community.id().0),
        Some(&access_role),
        Some(&crate::community::roles::MemberGrant { member: my_pk.to_hex(), role_ids: access_role_ids }),
    );
    // A leave/delete raced the create: saving would resurrect the community row.
    if crate::db::community::community_protocol(community.id())?.is_none() {
        return Err("community removed during channel create".to_string());
    }
    let mut updated = community.clone();
    updated.channels.push(ChannelV2 { id: channel_id, name: name.to_string(), private: true, key: Some(channel_key), epoch, voice: None, meta_custom: None, meta_extra: Default::default() });
    crate::db::community::save_community_v2(&updated)?;
    // Archive the epoch-1 key so this channel's history stays readable across its
    // future rotations (CORD-03 §3).
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    crate::db::community::store_epoch_key(&cid_hex, &crate::simd::hex::bytes_to_hex_32(&channel_id.0), epoch.0, &channel_key)?;
    // Re-state live links. They carry no private key (CORD-05 §2 — a link's
    // audience holds no Role), so this only refreshes the public set.
    let _ = refresh_public_links(transport, &updated).await;
    Ok(())
}

/// Tombstone a channel (CORD-03 §2, `deleted: true`) + drop it locally. Reader-gated by
// ── Receiving a key vend (CORD-03 "delivered on grant") ──────────────────────

/// What a client should do with a vended Private-Channel key right now.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VendVerdict {
    /// Every rule passed — adopt the key.
    Accept,
    /// Cannot judge YET: our fold lags the grant it delivers. Park quietly and
    /// re-judge after the next control follow. NOT an anomaly — a lagging fold
    /// is the normal case for a vend that races its own Grant.
    Park(&'static str),
    /// Judged invalid against evidence that cannot become true later. Alarm-worthy.
    Refuse(&'static str),
}

/// Judge a vended Private-Channel key against our OWN folded state.
///
/// The Grant is the authority half and rides the owner-rooted control plane, so
/// it cannot be forged; the vend is only delivery. Acceptance therefore rests
/// entirely on what our own fold proves — a bundle can never introduce a channel
/// our control plane doesn't define, which is what closes the hidden-channel
/// injection class.
///
/// `community` must already be the held (self-certified) community: the caller
/// resolves it by `community_id`, so a bundle naming a community we're not in is
/// never judged here at all.
pub fn judge_channel_key_vend(
    community: &CommunityV2,
    roster: &crate::community::roles::CommunityRoles,
    channel_id: &ChannelId,
    epoch: Epoch,
    sender_hex: &str,
) -> VendVerdict {
    let me = match me_pk() {
        Ok(pk) => pk.to_hex(),
        Err(_) => return VendVerdict::Park("no active identity"),
    };
    let owner_hex = match community.owner() {
        Ok(o) => o.to_hex(),
        Err(_) => return VendVerdict::Refuse("community has no resolvable owner"),
    };
    let chan_hex = crate::simd::hex::bytes_to_hex_32(&channel_id.0);

    // (2) The channel must exist in OUR fold, and be private there. The bundle's
    // own claims are ignored: a vend may deliver a key, never define a channel.
    let Some(ch) = community.channel(channel_id) else {
        return VendVerdict::Park("channel not in our fold yet");
    };
    if !ch.private {
        // Never heals: our owner-rooted fold says this channel is public, so a
        // "private key" for it is a spoof, not a lagging view.
        return VendVerdict::Refuse("vend names a channel our fold says is public");
    }

    // (5) Epoch sanity, BOTH directions. Below is superseded by the rotation that
    // produced our copy. Above matters more: the channel head is monotonic, so a
    // wildly-ahead epoch is not merely wrong, it is PERMANENT — every genuine
    // rotation afterwards lands at `head + 1`, is refused as stale, and the
    // channel dies for us with no heal path at all (not a rekey, not a re-grant,
    // not a refound). Rotations advance one epoch at a time, so a lead this large
    // is never a delivery we could place.
    if ch.key.is_some() && epoch.0 <= ch.epoch.0 {
        return VendVerdict::Refuse("superseded: we already hold this epoch or newer");
    }
    if epoch.0 > ch.epoch.0.saturating_add(MAX_VEND_EPOCH_LEAD) {
        return VendVerdict::Refuse("vend epoch is implausibly far ahead of the channel head");
    }

    // (3) OUR fold must show US granted a role scoped to this channel. This is
    // the rule that kills the spoof class: an attacker cannot forge the Grant,
    // so they cannot make us accept a key for a channel we were never granted.
    if !roster.is_entitled(Some(&owner_hex), &me, &chan_hex, &[], &[]) {
        return VendVerdict::Park("our grant for this channel has not folded yet");
    }

    // (4) The vendor must be entitled too — they hold the real key, so a wrong
    // key from them costs isolation, never confidentiality.
    if sender_hex != owner_hex && !roster.is_entitled(Some(&owner_hex), sender_hex, &chan_hex, &[], &[]) {
        return VendVerdict::Park("vendor's entitlement has not folded yet");
    }

    VendVerdict::Accept
}

/// How long an unprovable parked vend is kept. Deliberately long: the fallback
/// heal is the channel's next rotation, which may never come.
const PARKED_VEND_TTL_SECS: u64 = 30 * 24 * 3600;

/// How far above our channel head a vend may claim to be. Generous — a keyless
/// cursor can lag a busy channel by many rotations — but bounded, because the
/// head is monotonic and an over-advance can never be walked back.
const MAX_VEND_EPOCH_LEAD: u64 = 1024;

/// Re-judge every parked key vend for this community and adopt the ones that now
/// pass. Runs after a control follow (the fold moved, so verdicts can change) and
/// on the boot sweep.
///
/// Returns the channels newly keyed up.
pub fn absorb_parked_channel_keys(community: &CommunityV2, session: &SessionGuard) -> Vec<ChannelId> {
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let parked = match crate::db::community::get_pending_channel_keys(&cid_hex) {
        Ok(p) if !p.is_empty() => p,
        _ => return Vec::new(),
    };
    let roster = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    let mut adopted = Vec::new();
    let now = now_ms() / 1000;
    for p in parked {
        // Several candidates may name one channel (parking is open to any sender,
        // so a stranger can never suppress the entitled vendor's key by holding a
        // slot). Once one is seated the rest are moot.
        if adopted.iter().any(|c: &ChannelId| crate::simd::hex::bytes_to_hex_32(&c.0) == p.channel_id) {
            let _ = crate::db::community::drop_pending_channel_key(p.id);
            continue;
        }
        // A vend we were never able to prove is not kept forever: an admin who
        // adds then immediately removes someone leaves a row nothing will ever
        // discharge. Generous by design — the alternative heal (the channel's
        // next rotation) can be arbitrarily far away, so this is hygiene, not a
        // deadline.
        if now.saturating_sub(p.received_at.max(0) as u64) > PARKED_VEND_TTL_SECS {
            let _ = crate::db::community::drop_pending_channel_key(p.id);
            continue;
        }
        let Some(id_bytes) = crate::simd::hex::hex_to_bytes_32_checked(&p.channel_id) else {
            let _ = crate::db::community::drop_pending_channel_key(p.id);
            continue;
        };
        let channel_id = ChannelId(id_bytes);
        match judge_channel_key_vend(community, &roster, &channel_id, Epoch(p.epoch), &p.sender) {
            VendVerdict::Accept => {
                if !session.is_valid() {
                    return adopted;
                }
                // First delivery vs rotation. A keyless channel must bypass the
                // monotonic guard: it sits at the epoch-0 cursor, and a peer that
                // mints born-private channels at epoch 0 vends that same epoch, so
                // `new > current` would refuse the only key on offer.
                let keyless = community.channel(&channel_id).is_some_and(|c| c.key.is_none());
                let seated = if keyless {
                    crate::db::community::seat_channel_key(&cid_hex, &p.channel_id, p.epoch, &p.key)
                } else {
                    crate::db::community::advance_channel_epoch(&cid_hex, &p.channel_id, p.epoch, &p.key).map(|_| ())
                };
                if let Err(e) = seated {
                    crate::log_warn!("v2: adopting a vended channel key failed: {e}");
                    continue;
                }
                // The key landed — every other candidate for this channel is moot.
                let _ = crate::db::community::drop_pending_channel_keys_for(&cid_hex, &p.channel_id);
                adopted.push(channel_id);
            }
            VendVerdict::Refuse(why) => {
                crate::log_warn!("v2: refused a vended channel key for {}: {why}", p.channel_id);
                // Only THIS candidate — a sibling may still be the genuine vend.
                let _ = crate::db::community::drop_pending_channel_key(p.id);
            }
            // Quiet by design: the fold simply hasn't caught up.
            VendVerdict::Park(_) => {}
        }
    }
    adopted
}

/// Grant `member` read access to a Private channel (CORD-03 "delivered on
/// grant"): publish a Grant adding the channel's access role, then vend the key
/// as a CORD-05 §6 Direct Invite whose bundle carries exactly the channels they
/// are now entitled to.
///
/// The Grant is the authority half and rides the owner-rooted control plane, so
/// it cannot be forged; the vend is only delivery. A recipient accepts the key
/// solely on the strength of their OWN fold showing this grant — the bundle can
/// never introduce a channel their control plane doesn't define.
pub async fn grant_channel_access<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    member: &PublicKey,
) -> Result<(), String> {
    let session = SessionGuard::capture();
    let my_pk = me_pk()?;
    let ch = community.channel(channel_id).ok_or("unknown channel")?;
    if !ch.private {
        return Err("channel is public — every member already reads it".to_string());
    }
    if ch.key.is_none() {
        return Err("we hold no key for this channel, so we cannot vend it".to_string());
    }
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let chan_hex = crate::simd::hex::bytes_to_hex_32(&channel_id.0);
    let owner_hex = community.owner()?.to_hex();
    // A Grant REPLACES the member's role set, so the union it is built from must
    // be CURRENT: a stale local roster would silently strip every role this
    // client hasn't folded yet. Fetch the authority fresh rather than trusting
    // the cache, and merge the local view on top so a role we just published
    // ourselves (which the plane has but no fold has read back) survives too.
    let mut roster = fetch_authority(transport, community).await.roles;
    let cached = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    for r in cached.roles {
        if !roster.roles.iter().any(|x| x.role_id == r.role_id) {
            roster.roles.push(r);
        }
    }
    for g in cached.grants {
        if !roster.grants.iter().any(|x| x.member == g.member) {
            roster.grants.push(g);
        }
    }
    if !session.is_valid() {
        return Err("account changed during grant".to_string());
    }
    // Reader-gated by MANAGE_ROLES, like any Grant; narrowed to this channel so
    // a channel-scoped manager can run its own access list.
    if !roster.is_authorized_in(&my_pk.to_hex(), Some(&owner_hex), &chan_hex, crate::community::roles::Permissions::MANAGE_ROLES) {
        return Err("not authorized to manage this channel's access".to_string());
    }
    // The channel's roles are ordered by AUTHORITY, so `.first()` is the most
    // privileged — granting read access must never hand out a per-channel
    // moderator role that happens to share the scope. Pick the permission-less
    // one: conferring read access is exactly what carries no authority.
    let role_id = roster
        .channel_roles(&chan_hex)
        .into_iter()
        .find(|r| r.permissions == crate::community::roles::Permissions::empty())
        .map(|r| r.role_id.clone())
        .ok_or("channel has no permission-less access role to grant")?;

    let mut role_ids: Vec<String> = roster.roles_of(&member.to_hex()).map(|r| r.role_id.clone()).collect();
    if !role_ids.contains(&role_id) {
        role_ids.push(role_id.clone());
    }
    grant_roles(transport, community, member, role_ids.clone()).await?;
    if !session.is_valid() {
        return Err("account changed during grant".to_string());
    }
    merge_local_roster(&cid_hex, None, Some(&crate::community::roles::MemberGrant { member: member.to_hex(), role_ids }));
    // Settle the vend against the Grant we JUST published — the fold lags it.
    let bundle = bundle_of_with_overlay(
        community,
        BundleAudience::Member(*member),
        Some(my_pk),
        None,
        None,
        std::slice::from_ref(&role_id),
        &[],
    );
    let signer = crate::signer::active_signer()?;
    let wrap = invite::build_direct_invite_signed(&signer, my_pk, member, &bundle).await.map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed before vending the key".to_string());
    }
    transport.publish(&wrap, &community.relays).await?;
    Ok(())
}

/// Revoke `member`'s read access to a Private channel (CORD-03 "rekeyed on
/// removal"): drop the channel's access role from their Grant, then rotate the
/// channel to its next epoch delivering the fresh key to everyone still
/// entitled (CORD-06). The revoked member keeps whatever history they already
/// read — a rekey protects the future, never the past.
pub async fn revoke_channel_access<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    member: &PublicKey,
) -> Result<(), String> {
    let session = SessionGuard::capture();
    let my_pk = me_pk()?;
    let ch = community.channel(channel_id).ok_or("unknown channel")?;
    if !ch.private {
        return Err("channel is public — there is no access to revoke".to_string());
    }
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let chan_hex = crate::simd::hex::bytes_to_hex_32(&channel_id.0);
    let owner_hex = community.owner()?.to_hex();
    // Same replace-not-merge hazard as the grant: the retained set must be built
    // from a CURRENT roster or this revoke strips roles we simply hadn't folded.
    let mut roster = fetch_authority(transport, community).await.roles;
    let cached = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    for r in cached.roles {
        if !roster.roles.iter().any(|x| x.role_id == r.role_id) {
            roster.roles.push(r);
        }
    }
    for g in cached.grants {
        if !roster.grants.iter().any(|x| x.member == g.member) {
            roster.grants.push(g);
        }
    }
    if !session.is_valid() {
        return Err("account changed during revoke".to_string());
    }
    if !roster.is_authorized_in(&my_pk.to_hex(), Some(&owner_hex), &chan_hex, crate::community::roles::Permissions::MANAGE_ROLES) {
        return Err("not authorized to manage this channel's access".to_string());
    }
    if *member == community.owner()? {
        return Err("the owner is supreme and cannot be removed".to_string());
    }
    let access_ids = roster.channel_role_ids(&chan_hex);
    // Without the access list this revoke is a no-op that still ROTATES, and the
    // rotation's recipient filter would match nobody — cutting off every
    // legitimately entitled member. Refuse rather than mass-evict.
    if access_ids.is_empty() {
        return Err("this channel's access role has not folded yet — retry once the control plane serves it".to_string());
    }
    let remaining: Vec<String> = roster
        .roles_of(&member.to_hex())
        .map(|r| r.role_id.clone())
        .filter(|id| !access_ids.contains(id))
        .collect();
    grant_roles(transport, community, member, remaining.clone()).await?;
    if !session.is_valid() {
        return Err("account changed during revoke".to_string());
    }
    merge_local_roster(&cid_hex, None, Some(&crate::community::roles::MemberGrant { member: member.to_hex(), role_ids: remaining }));
    // Rotate so the removal actually severs them (CORD-06 §1). The revoked
    // member is excluded from the recipient set by the overlay, since the fold
    // has not yet caught the Grant we just published.
    rekey_channel_excluding(transport, community, channel_id, &roster, &access_ids, member).await
}

/// Rotate one Private channel to its next epoch, delivering the fresh key to
/// everyone entitled EXCEPT `removed` (CORD-06 §1 single-channel rekey).
///
/// `roster` must be the caller's CURRENT view (fetched, not the local cache):
/// the recipient set is built from it, so a cached roster silently drops every
/// member granted since this client last folded — they keep a dead key with no
/// heal path. `access_ids` is that roster's access-role set for this channel;
/// `removed` is excluded explicitly, since the revoking Grant was published
/// moments ago and no fold has caught it.
async fn rekey_channel_excluding<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    channel_id: &ChannelId,
    roster: &crate::community::roles::CommunityRoles,
    access_ids: &[String],
    removed: &PublicKey,
) -> Result<(), String> {
    let session = SessionGuard::capture();
    // Whole-row save below — serialize with the follow worker (see create_*_channel).
    let lock = super::realtime::follow_lock(community.id());
    let _guard = lock.lock().await;
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let chan_hex = crate::simd::hex::bytes_to_hex_32(&channel_id.0);
    let ch = community.channel(channel_id).ok_or("unknown channel")?.clone();
    let old_key = ch.key.ok_or("we hold no key for this channel, so we cannot rotate it")?;
    let new_epoch = Epoch(ch.epoch.0.checked_add(1).ok_or("channel epoch overflow")?);
    let owner = community.owner()?;
    let owner_hex = owner.to_hex();

    // Everyone still entitled: the owner (always), me (the rotator must be able
    // to read what it rekeys), and every member the roster shows holding an
    // access role — minus the removal.
    let removed_hex = removed.to_hex();
    let mut recipients: Vec<PublicKey> = vec![my_pk];
    if owner != my_pk {
        recipients.push(owner);
    }
    for g in &roster.grants {
        if g.member == removed_hex || g.member == owner_hex {
            continue;
        }
        if !g.role_ids.iter().any(|id| access_ids.contains(id)) {
            continue;
        }
        if let Ok(pk) = PublicKey::parse(&g.member) {
            if !recipients.contains(&pk) {
                recipients.push(pk);
            }
        }
    }
    // Mint-or-reuse keyed by (channel, next epoch) so a retry after a partial
    // publish re-uses the same key instead of forking the epoch.
    let new_key = mint_or_reuse_rotation_key(&cid_hex, &chan_hex, new_epoch.0)?;
    let prev_commit = super::derive::epoch_key_commitment(ch.epoch, &old_key);
    let mut blobs = Vec::with_capacity(recipients.len());
    for r in &recipients {
        blobs.push(
            rekey::build_blob(&signer, &my_pk.to_bytes(), r, RekeyScope::Channel(*channel_id), new_epoch, &new_key)
                .await
                .map_err(|e| e.to_string())?,
        );
    }
    let group = channel_rekey_group_key(&community.community_root, channel_id, new_epoch);
    let at_secs = now_ms() / 1000;
    let chunks = rekey::build_rekey_chunks(&signer, my_pk, &group, RekeyScope::Channel(*channel_id), new_epoch, ch.epoch, &prev_commit, &blobs, at_secs, my_authority_citation(community, &my_pk).as_ref())
        .await
        .map_err(|e| e.to_string())?;
    if !session.is_valid() {
        return Err("account changed during channel rekey".to_string());
    }
    for c in &chunks {
        transport.publish_durable(c, &community.relays).await?;
    }
    if !session.is_valid() {
        return Err("account changed during channel rekey".to_string());
    }
    if crate::db::community::community_protocol(community.id())?.is_none() {
        return Err("community removed during channel rekey".to_string());
    }
    // Adopt locally + archive, so our own history reads across the rotation.
    crate::db::community::advance_channel_epoch(&cid_hex, &chan_hex, new_epoch.0, &new_key)?;
    crate::db::community::store_epoch_key(&cid_hex, &chan_hex, new_epoch.0, &new_key)?;
    Ok(())
}

/// Tombstone a channel (CORD-03 §2, `deleted: true`) + drop it locally. Reader-gated by
/// `MANAGE_CHANNELS`; the coordinate stays folded as a grave so peers hide it.
pub async fn delete_channel<T: Transport + ?Sized>(transport: &T, community: &CommunityV2, channel_id: &ChannelId, name: &str) -> Result<(), String> {
    let session = SessionGuard::capture();
    // Whole-row save below — serialize with the follow worker (see create_*_channel).
    let lock = super::realtime::follow_lock(community.id());
    let _guard = lock.lock().await;
    let my_pk = me_pk()?;
    ensure_channel_manager(community, &my_pk)?;
    // The tombstone carries the FULL held document (deleted flag set): a strict
    // reader treats an edition as the entity, so even a deletion must not strip
    // fields it didn't touch (CORD-02 §6).
    let mut meta = community.channel(channel_id).map(|c| c.metadata()).unwrap_or_else(|| control::ChannelMetadata {
        name: name.to_string(), private: false, voice: None, deleted: None, custom: None, extra: Default::default(),
    });
    meta.deleted = Some(true);
    let content = serde_json::to_string(&meta).map_err(|e| e.to_string())?;
    publish_control_edition(transport, community, &session, vsk::CHANNEL_METADATA, &channel_id.0, &content).await?;
    if !session.is_valid() {
        return Err("account changed during channel delete".to_string());
    }
    let mut updated = community.clone();
    updated.channels.retain(|c| c.id.0 != channel_id.0);
    crate::db::community::save_community_v2(&updated)?;
    Ok(())
}

// ── Live control-follow (CORD-02 §6 / CORD-03 §2) ────────────────────────────

/// Re-fold this community's Control Plane and apply the current metadata +
/// **public** channel set to the held community, persisting any change. Called
/// when a control-plane wrap arrives in realtime (a rename, a new channel, an
/// edited description) so a long-running bot tracks the community mid-session
/// instead of freezing at its join-time view.
///
/// **Authority (CORD-04 §5):** the roster (roles/grants/banlist) folds first into
/// the owner-seeded authorized set ([`fold_authority`]), then each metadata/channel
/// edition is eligible only if its signer CURRENTLY holds the entity's management
/// bit (`MANAGE_METADATA`/`MANAGE_CHANNELS`) — so an authorized admin's edits fold,
/// a demoted one's drop. The owner is supreme, proven by the self-certifying
/// community_id (no network trust).
///
/// **Private channels are skipped here:** a Private channel's Chat-Plane key is
/// delivered over the rekey plane (or an invite bundle), never derivable from a
/// control edition alone. A new Private channel therefore surfaces only once
/// [`follow_rekeys`] delivers its key. Public channels derive from the
/// community_root, so they fold in directly.
///
/// Returns the updated community iff something changed (so the caller can skip a
/// redundant re-subscribe + refresh notification).
pub async fn follow_control<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    session: &SessionGuard,
) -> Result<Option<CommunityV2>, String> {
    community.owner()?; // fail fast if the community is somehow unproven.
    let control = control_group_key(&community.community_root, community.id(), community.root_epoch);
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);

    // Per-entity refuse-downgrade floors for the CURRENT epoch only. A head recorded
    // under a prior epoch is excluded, so that entity auto-bootstraps after a
    // Refounding (Armada accepts a compacted head across a dangling prev — matched).
    // A read error FAILS CLOSED: an empty map would silently re-open the rollback
    // window the floor exists to shut.
    let floors: Floors = crate::db::community::get_all_edition_heads_full(&cid_hex)?
        .into_iter()
        .filter(|(_, f)| f.0 == community.root_epoch.0)
        .map(|(entity, f)| (entity, (f.1, f.2, f.3)))
        .collect();

    // Newest window first; page OLDER only while a tracking entity is gapped (its
    // floor link evicted from the window — H1/M8 refetch), bounded like the join
    // verifier. A withholding relay still converges to fail-closed after the cap.
    let mut editions: Vec<ParsedEdition> = Vec::new();
    let mut seen: std::collections::HashSet<[u8; 32]> = std::collections::HashSet::new();
    let mut seen_wraps: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
    let mut oldest: Option<u64> = None;
    let mut until: Option<u64> = None;
    let mut fold = ControlFold { updated: None, heads: Vec::new(), gapped: false };
    let mut authority = AuthoritySet::owner_only();
    // Whether this round gave up with editions still unread. The follow is
    // procedural by design — process what arrives, converge with everyone else —
    // so a short read never blocks reading, writing or epoch adoption. It only
    // withholds the ROSTER cache below: caching a partial authority as this
    // device's baseline is the one step that outlives the round.
    let mut truncated = true;
    for _ in 0..FOLLOW_MAX_PAGES {
        // Quorum, DECLARED (the until→Full transport floor is gone): these
        // control reads tolerate a partial union — their fold semantics are
        // fail-safe on gaps (seeded banlists, withheld roster cache).
        let query = Query {
            kinds: vec![stream::KIND_WRAP],
            authors: vec![control.pk_hex()],
            until,
            limit: Some(FOLLOW_PAGE),
            evidence: crate::community::transport::Evidence::Quorum,
            ..Default::default()
        };
        let wraps = transport.fetch(&query, &community.relays).await?;
        // The `until` cursor is INCLUSIVE (a `-1` step can skip same-second siblings
        // at a page boundary); the wrap-id dedup makes re-served boundary events
        // free, and a page with nothing new means the relay is exhausted.
        let mut fresh = 0usize;
        for w in &wraps {
            if !seen_wraps.insert(w.id) {
                continue;
            }
            fresh += 1;
            let at = w.created_at.as_secs();
            if oldest.is_none_or(|o| at < o) {
                oldest = Some(at);
            }
            // Open + seal-verify every edition; authority is resolved by the roster
            // fold (CORD-04 §5), not by a signer filter here — an admin's edits fold.
            if let Ok((ed, _)) = control::open_control_edition(w, &control) {
                if seen.insert(ed.inner_id) {
                    editions.push(ed);
                }
            }
        }
        // Roster first (roles/grants/banlist → authorized set), then the authority-
        // gated metadata/channel fold over the same edition set.
        authority = fold_authority(community, &editions, &floors);
        fold = apply_control_fold(community, &editions, &floors, &authority);
        if !(fold.gapped || authority.gapped) {
            truncated = false; // nothing is gapped: this view is coherent
            break;
        }
        if fresh == 0 {
            // A FULL page with nothing new is a same-second wall no `until` steps
            // past, so older editions stay unreachable; a short page is the end
            // of the plane, and a gap in THAT is the relay withholding, not us
            // giving up early.
            truncated = wraps.len() >= FOLLOW_PAGE;
            break;
        }
        until = oldest;
    }

    // The fetches straddled awaits; a swap since the guard was captured must not
    // write account A's control state into B.
    if !session.is_valid() {
        return Err("account changed during control follow".to_string());
    }
    // A leave/delete raced this follow: writing now would resurrect the community
    // row and orphan floor rows past delete_community's wipe.
    if crate::db::community::community_protocol(community.id())?.is_none() {
        return Ok(None);
    }
    // Persist advanced floors BEFORE the state save (a failed floor write must not
    // let saved state outrun its floor), stamping the epoch this fold ran under —
    // not the row's write-time value, which a concurrent re-founding can bump. Both
    // the metadata/channel heads and the roster/banlist heads advance their floors;
    // run the advance (v+1) and same-version convergence (fork tiebreak) paths.
    for h in fold.heads.iter().chain(authority.heads.iter()) {
        crate::db::community::set_edition_head_at_epoch(&cid_hex, &h.entity_hex, h.version, &h.self_hash, &h.inner_id, community.root_epoch.0)?;
        crate::db::community::converge_edition_head_at_epoch(&cid_hex, &h.entity_hex, h.version, &h.self_hash, &h.inner_id, community.root_epoch.0)?;
    }
    // Persist the authorized banlist content (retained/withholding folds carry None,
    // so the stored banlist is left intact — an anti-roster never silently un-bans).
    let mut authority_changed = false;
    // Ban marks MERGE (never replace): they must outlive both the ban and this window,
    // so a later un-ban can't resurrect a pre-ban Join. Persisted even when the banlist
    // itself was retained — the history is what the suppression reads.
    let _ = crate::db::community::merge_community_ban_marks(&cid_hex, &authority.banned_at);
    if let Some((banned, version)) = &authority.banlist_persist {
        let mut before = crate::db::community::get_community_banlist(&cid_hex).unwrap_or_default();
        crate::db::community::set_community_banlist(&cid_hex, banned, *version as i64)?;
        let mut after = banned.clone();
        before.sort();
        after.sort();
        authority_changed |= before != after;
    }
    // Persist the authorized roster so capabilities/roles stay sync LOCAL reads
    // (v1 parity: the passive follow folds, reads never fetch). Guarded like v1's
    // fetch path: only an aggregate built from roster editions at least as new as
    // the stored one may replace it — a withholding relay serving NO roster
    // editions folds an empty-but-ungapped aggregate (absence raises no gap flag),
    // and that must RETAIN the stored roster, never wipe standing.
    let newest_roster_at: i64 = editions
        .iter()
        .filter(|e| e.vsk == vsk::ROLE || e.vsk == vsk::GRANT || e.vsk == vsk::BANLIST)
        .map(|e| e.created_at as i64)
        .max()
        .unwrap_or(0);
    // Completeness gate: the `gapped` flag only covers entities present in the window.
    // A role/grant floored on this device but with ZERO editions fetched (aged out of
    // the paging reach) folds absent yet raises no gap — persisting would silently drop
    // it. So if any CURRENTLY-STORED entity is floored but folded no head this round,
    // RETAIN. A real revoke still folds a head (see select_authorized), so it persists.
    let stored = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    let head_ents: std::collections::HashSet<&str> = authority.heads.iter().map(|h| h.entity_hex.as_str()).collect();
    let stored_complete = stored.roles.iter().all(|r| !floors.contains_key(&r.role_id) || head_ents.contains(r.role_id.as_str()))
        && stored.grants.iter().all(|g| {
            crate::simd::hex::hex_to_bytes_32_checked(&g.member).is_none_or(|m| {
                let eid = crate::simd::hex::bytes_to_hex_32(&super::derive::grant_locator(community.id(), &m));
                !floors.contains_key(&eid) || head_ents.contains(eid.as_str())
            })
        });
    // `truncated` covers the case the other three can't: a COLD device (no floors,
    // no stored roster) folding under a plane a member has inflated past the pager.
    // `stored_complete` is trivially true with nothing stored, so without this the
    // first sync would cache a partial authority as its own baseline.
    if !truncated && !authority.gapped && stored_complete && newest_roster_at >= crate::db::community::get_community_roles_at(&cid_hex)? {
        authority_changed |= stored != authority.roles;
        crate::db::community::set_community_roles(&cid_hex, &authority.roles, newest_roster_at)?;
    }
    // Cache the folded invite Registry so Public/Private stays a sync LOCAL read
    // (v1 parity — `invite_registry` is the column every caller reads). Gated like
    // the roster: a truncated or gapped window folds an empty registry out of mere
    // absence, and persisting that under-states Public — the unsafe direction, since
    // it leaves a live link open behind a ban.
    if !truncated && !authority.gapped && !fold.gapped {
        if let Ok(owner) = community.owner() {
            let sets = live_invite_link_sets(community.id(), &owner.to_hex(), &editions, &authority, &floors);
            let live = flatten_link_sets(&sets);
            let mut before = crate::db::community::get_community_invite_registry(&cid_hex).unwrap_or_default();
            before.sort();
            if before != live {
                crate::db::community::set_community_invite_registry(&cid_hex, &live)?;
                authority_changed = true;
            }
            // The per-creator split drives "X has N active invite links" and the
            // first-link-flips-Public confirm; it lives in its own table.
            crate::db::community::replace_invite_link_sets(&cid_hex, &sets)?;
        }
    }
    // Roster/banlist moves are invisible in the returned community (they live in
    // their own columns), so callers that key a refresh off `updated` would never
    // repaint a promote/demote/ban. Announce from the single fold point — it covers
    // realtime, boot catch-up and manual sync alike.
    if authority_changed {
        crate::emit_event("community_refreshed", &serde_json::json!({ "community_id": cid_hex }));
    }
    match fold.updated {
        Some(u) => {
            crate::db::community::save_community_v2(&u)?;
            Ok(Some(u))
        }
        None => Ok(None),
    }
}

/// Control-follow paging bounds: enough depth to re-anchor a long-offline floor
/// (H1/M8 refetch) without letting a flooding relay stall the follow queue.
///
/// Nearly free to raise: both follow loops exit the moment the fold stops being
/// gapped, so the cap only binds when something is genuinely missing — exactly
/// when paging further is what's wanted. The old ceiling of 4 (~2k editions) sat
/// under a plane that 100 roles + 400 grants already outgrows before counting
/// superseded versions, which accumulate until a compaction retires them.
const FOLLOW_MAX_PAGES: usize = 32;
const FOLLOW_PAGE: usize = 500;
/// Page ceiling for a COMPACTION read (CORD-06 §3: a Refounder that cannot fold
/// every Control Event must abort). Far above any real plane, but plane depth is
/// attacker-controlled — any member holds the key that mints wraps — so the read
/// is bounded and reports coming up short rather than compacting a partial view.
const COMPACT_MAX_PAGES: usize = 512;

/// A folded control head to persist as the per-entity refuse-downgrade floor.
#[derive(Clone)]
struct FoldedHead {
    entity_hex: String,
    version: u64,
    self_hash: [u8; 32],
    inner_id: [u8; 32],
}

/// The outcome of a floor-aware control fold: the updated community (if content
/// changed), the heads to persist as the new floor (returned even when content is
/// unchanged, so the floor still seeds/advances), and whether any TRACKING entity
/// hit an unresolvable gap — the caller's signal to page older history and re-fold
/// (CORD-04 H1/M8's refetch).
struct ControlFold {
    updated: Option<CommunityV2>,
    heads: Vec<FoldedHead>,
    gapped: bool,
}

/// Per-entity floor: `(version, self_hash, inner_id)` of the committed head.
type Floors = std::collections::HashMap<String, (u64, [u8; 32], Option<[u8; 32]>)>;

/// Fold owner-authored control editions into an updated community using the
/// PERSISTED per-entity version floor (refuse-downgrade). Per entity, fold with
/// [`version::fold`]`(floor, floor_hash)`:
///   - ANCHORED: adopt the chain-verified head. A `gap` ABOVE it (withheld middles)
///     doesn't block the verified prefix — refuse-downgrade holds for everything
///     applied — but flags `gapped` so the caller pages for the rest.
///   - UNANCHORED under a held floor: one legitimate cause is a same-version owner
///     fork AT the floor whose deterministic winner (lower inner id; a NULL held id
///     is always replaceable, mirroring v1's `decide()`) isn't our held edition —
///     the floor CONVERGES to the winner and the chain re-anchors on it, so every
///     client lands on the same head where a hash-strict floor would wedge forever.
///     Anything else is withholding → fail closed + `gapped`.
///   - BOOTSTRAPPING (`floor == 0` — a fresh joiner, or a fresh epoch after a
///     Refounding, since the caller epoch-filters the floor) takes the highest
///     signed head (author already owner-filtered).
/// This matches CORD-04 §1 and mirrors v1's `fold_roster`. Epoch-filtering makes a
/// compaction at a new epoch auto-bootstrap, converging with Armada's acceptance of
/// a compacted head across a dangling `prev` (Armada doesn't persist a floor, so a
/// Vector floor only makes Vector STRICTER locally — no wire change, honest-case
/// convergence preserved).
fn apply_control_fold(community: &CommunityV2, editions: &[ParsedEdition], floors: &Floors, authority: &AuthoritySet) -> ControlFold {
    use crate::community::roles::Permissions;
    use std::collections::BTreeMap;

    let owner_hex = community.owner().ok().map(|o| o.to_hex());

    let mut groups: BTreeMap<(String, [u8; 32]), Vec<&ParsedEdition>> = BTreeMap::new();
    for e in editions {
        groups.entry((e.vsk.clone(), e.entity_id)).or_default().push(e);
    }

    let mut out = community.clone();
    let mut changed = false;
    let mut heads = Vec::new();
    let mut gapped = false;
    for ((vsk_code, eid), group) in &groups {
        // This fold applies exactly two entities: community metadata (eid ==
        // community_id) and channel metadata. A vsk-2 whose eid equals the community
        // id is excluded — the floor row keys on the entity alone, so it would share
        // (and corrupt) the metadata chain's floor.
        let is_meta = vsk_code == vsk::COMMUNITY_METADATA && *eid == community.id().0;
        let is_channel = vsk_code == vsk::CHANNEL_METADATA && *eid != community.id().0;
        if !is_meta && !is_channel {
            continue;
        }
        // Authority gate (CORD-04 §5): only editions whose author CURRENTLY holds the
        // entity's management bit are eligible. Pre-filtering before the fold means a
        // demoted admin's (possibly higher-version) edition can't be the head; the
        // highest AUTHORIZED head wins. The owner is supreme.
        let required = if is_meta { Permissions::MANAGE_METADATA } else { Permissions::MANAGE_CHANNELS };
        let authed: Vec<&ParsedEdition> = group
            .iter()
            .copied()
            .filter(|e| {
                let author = e.author.to_hex();
                // A banned npub's edits are dropped (CORD-04 §4), even if they still
                // held a bit via a not-yet-stripped grant.
                !authority.banned.contains(&author)
                    && authority.roles.is_authorized(&author, owner_hex.as_deref(), required)
                    // …and the CORD-04 §5 sync floor. Resolved against the Grant heads
                    // this same fold settled, so it works on a bootstrap where no
                    // persisted head exists yet.
                    && citation_ok_in_fold(community.id(), &authority.heads, owner_hex.as_deref(), &e.author, e.authority.as_ref())
            })
            .collect();
        if authed.is_empty() {
            continue;
        }
        let entity_hex = crate::simd::hex::bytes_to_hex_32(eid);
        let fold_eds: Vec<version::Edition> = authed.iter().map(|p| p.to_fold_edition()).collect();
        let (hi, entity_gapped) = fold_head(&fold_eds, floors.get(&entity_hex));
        gapped |= entity_gapped;
        let Some(hi) = hi else { continue };

        let head = authed[hi];
        heads.push(FoldedHead { entity_hex, version: head.version, self_hash: head.self_hash, inner_id: head.inner_id });
        if is_meta {
            if let Ok(meta) = serde_json::from_str::<control::CommunityMetadata>(&head.content) {
                changed |= apply_community_metadata(&mut out, meta);
            }
        } else if let Ok(meta) = serde_json::from_str::<control::ChannelMetadata>(&head.content) {
            // vsk-2 carries no community binding (shared v1 grammar); a same-owner
            // cross-community replay can inject a phantom PUBLIC channel (bounded:
            // root-scoped key, eids don't collide). Binding is a deferred wire change.
            changed |= apply_channel_metadata(&mut out, ChannelId(*eid), meta);
        }
    }
    ControlFold { updated: changed.then_some(out), heads, gapped }
}

/// Fold one entity's editions against its persisted floor into a head index (into the
/// input slice) plus whether a TRACKING gap was hit (the caller pages older history).
/// Encapsulates the W2 refuse-downgrade policy: bootstrap at floor 0 (highest signed
/// head, what Armada shows across a compaction's dangling prev); adopt the chain-
/// anchored head, paging on an upper gap; converge a same-version fork at the floor to
/// the lower-inner-id winner; and fail closed otherwise.
fn fold_head(fold_eds: &[version::Edition], floor: Option<&(u64, [u8; 32], Option<[u8; 32]>)>) -> (Option<usize>, bool) {
    let floor_v = floor.map(|f| f.0).unwrap_or(0);
    if floor_v == 0 {
        return (version::bootstrap_head(fold_eds, 0), false);
    }
    let floor_hash = floor.map(|f| &f.1);
    let held_inner = floor.and_then(|f| f.2);
    let result = version::fold(fold_eds, floor_v, floor_hash);
    if result.anchored {
        return (result.head, result.gap); // verified prefix; page any upper gap.
    }
    if result.head.is_none() && !result.gap {
        return (None, false); // everything below floor — a stale relay, no paging.
    }
    // Unanchored under a held floor: converge a same-version fork at the floor to its
    // deterministic winner (lower inner id; a NULL held id is always replaceable),
    // else fail closed.
    let fork = fold_eds.iter().enumerate().filter(|(_, e)| e.version == floor_v).min_by_key(|(_, e)| e.tiebreak_id);
    let win_hash = match fork {
        Some((_, w)) if floor_hash != Some(&w.self_hash) && held_inner.is_none_or(|h| w.tiebreak_id < h) => w.self_hash,
        _ => return (None, true), // detached from our committed head → withholding.
    };
    let re = version::fold(fold_eds, floor_v, Some(&win_hash));
    if !re.anchored {
        return (None, true);
    }
    (re.head, re.gap)
}

/// The folded, delegation-AUTHORIZED control-plane authority (CORD-04): the roster
/// (roles + grants, owner-seeded fixpoint), the enforced banlist, and the
/// role/grant/banlist heads to persist as refuse-downgrade floors. The owner is
/// recomputed from the self-certifying community_id at each use.
struct AuthoritySet {
    roles: crate::community::roles::CommunityRoles,
    banned: std::collections::BTreeSet<String>,
    heads: Vec<FoldedHead>,
    gapped: bool,
    /// The authorized banlist `(content, version)` to persist when an authorized head
    /// advanced the floor. `None` when the banlist was retained (no new authorized
    /// head) or is empty — the caller then leaves the stored banlist untouched.
    banlist_persist: Option<(Vec<String>, u64)>,
    /// Ban HISTORY: npub hex → `created_at` (secs) of the newest authorized edition that
    /// named them, across every edition in the window rather than just the head. Outlives
    /// the ban itself so an un-ban can't resurrect a phantom (see [`fold_members`]).
    banned_at: std::collections::BTreeMap<String, u64>,
}

impl AuthoritySet {
    /// Bootstrap authority for a community with no roster editions folded yet: only
    /// the owner is authorized (supreme), nobody banned.
    fn owner_only() -> Self {
        AuthoritySet {
            roles: Default::default(),
            banned: Default::default(),
            heads: vec![],
            gapped: false,
            banlist_persist: None,
            banned_at: Default::default(),
        }
    }
}

/// Fold the roster/banlist entities (vsk 1/3/4) from the control editions into the
/// delegation-AUTHORIZED roster + enforced banlist (CORD-04 §2-§5). Each entity binds
/// to its coordinate (role at role_id, grant at grant_locator(cid, member), banlist at
/// banlist_locator(cid)); a content whose coordinate doesn't match is dropped. Roles
/// cap at the 100 lowest role_ids, a member at 64 roles, the banlist at 500. The
/// banlist is enforced only if its head's signer held BAN in the authorized roster.
fn fold_authority(community: &CommunityV2, editions: &[ParsedEdition], floors: &Floors) -> AuthoritySet {
    use crate::community::roles::Permissions;
    use std::collections::BTreeMap;

    let cid = community.id();
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&cid.0);
    let owner = community.owner().ok();
    let owner_hex = owner.map(|o| o.to_hex());
    let banlist_eid = super::derive::banlist_locator(cid);
    let banlist_hex = crate::simd::hex::bytes_to_hex_32(&banlist_eid);

    let mut groups: BTreeMap<[u8; 32], Vec<&ParsedEdition>> = BTreeMap::new();
    for e in editions {
        if e.vsk == vsk::ROLE || e.vsk == vsk::GRANT || e.vsk == vsk::BANLIST {
            groups.entry(e.entity_id).or_default().push(e);
        }
    }

    // Per-entity CANDIDATE lists — every ≥floor edition of a role/grant, highest
    // version first (lowest inner-id as the deterministic tiebreak). CORD-04 §1: an
    // edition whose signer isn't authorized is SIMPLY DROPPED and the fold continues
    // to the next candidate, so a forged higher-version edition can't suppress the
    // authorized head beneath it (the author-blind collapse-to-one-head it replaces
    // let any member vanish a role or a member's grant). `gapped` (drives older-
    // paging) stays fold_head's per-entity flag.
    let mut role_cands: BTreeMap<String, Vec<AuthorityCand>> = BTreeMap::new();
    let mut grant_cands: BTreeMap<String, Vec<AuthorityCand>> = BTreeMap::new();
    let mut gapped = false;

    for (eid, group) in &groups {
        // The banlist is folded author-aware AFTER the roster is known (below).
        if *eid == banlist_eid {
            continue;
        }
        let entity_hex = crate::simd::hex::bytes_to_hex_32(eid);
        let fold_eds: Vec<version::Edition> = group.iter().map(|p| p.to_fold_edition()).collect();
        let (_hi, entity_gapped) = fold_head(&fold_eds, floors.get(&entity_hex));
        gapped |= entity_gapped;
        let floor_v = floors.get(&entity_hex).map(|f| f.0).unwrap_or(0);

        for p in group {
            // Refuse-downgrade: never consider an edition below the persisted floor.
            if p.version < floor_v {
                continue;
            }
            let head = FoldedHead { entity_hex: entity_hex.clone(), version: p.version, self_hash: p.self_hash, inner_id: p.inner_id };
            match p.vsk.as_str() {
                vsk::ROLE => {
                    // Bind: the content's role_id IS the coordinate; position 0 is the owner's.
                    if let Some(role) = super::roles::parse_role_content(&p.content) {
                        if role.role_id == entity_hex && role.position != 0 {
                            role_cands.entry(entity_hex.clone()).or_default().push(AuthorityCand { role: Some(role), grant: None, author: p.author, head, citation: p.authority.clone() });
                        }
                    }
                }
                vsk::GRANT => {
                    if let Some(mut grant) = super::roles::parse_grant_content(&p.content) {
                        if let Some(member) = crate::simd::hex::hex_to_bytes_32_checked(&grant.member) {
                            if super::derive::grant_locator(cid, &member) == *eid {
                                grant.role_ids.truncate(super::roles::MAX_ROLES_PER_MEMBER);
                                grant_cands.entry(entity_hex.clone()).or_default().push(AuthorityCand { role: None, grant: Some(grant), author: p.author, head, citation: p.authority.clone() });
                            }
                        }
                    }
                }
                _ => {}
            }
        }
    }
    for cands in role_cands.values_mut().chain(grant_cands.values_mut()) {
        cands.sort_by(|a, b| b.head.version.cmp(&a.head.version).then(a.head.inner_id.cmp(&b.head.inner_id)));
    }

    let empty: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
    // Preliminary roster (bans not yet applied) — the authority view the banlist head
    // is judged against.
    let (prelim, prelim_heads) = select_authorized(cid, &role_cands, &grant_cands, owner_hex.as_deref(), &empty);

    // Banlist (CORD-04 §4), folded AUTHORITY-aware so its two anti-roster hazards are
    // both closed:
    //   - head selection: the head is the highest version whose author CURRENTLY holds
    //     BAN — an unauthorized higher-version edition can't erase existing bans
    //     (fail-open), and the floor never advances to one;
    //   - per-target: each entry is kept only if the author STRICTLY OUTRANKS that
    //     target (`can_act_on_member` — an admin can't ban a peer/superior, and the
    //     owner is unbannable);
    //   - withholding: when no authorized head is served, the persisted banlist is
    //     RETAINED (an anti-roster must not un-ban on a relay withholding the ban).
    let persisted_banned: Vec<String> = crate::db::community::get_community_banlist(&cid_hex).unwrap_or_default();
    // An ALREADY-banned npub can't author the banlist (a banned member vanishes, §4), or
    // a BAN-holder whose grant-strip hasn't yet folded could publish a list omitting their
    // OWN ban to un-ban themselves (removals aren't outrank-checked). Exclude them from
    // head eligibility, not just from the roster.
    let banned_authors: std::collections::HashSet<&str> = persisted_banned.iter().map(String::as_str).collect();
    let banlist_authored: Vec<&ParsedEdition> = groups
        .get(&banlist_eid)
        .map(|g| {
            g.iter()
                .copied()
                .filter(|e| {
                    let ah = e.author.to_hex();
                    !banned_authors.contains(ah.as_str())
                        && prelim.is_authorized(&ah, owner_hex.as_deref(), Permissions::BAN)
                        && citation_ok_in_fold(cid, &prelim_heads, owner_hex.as_deref(), &e.author, e.authority.as_ref())
                })
                .collect()
        })
        .unwrap_or_default();
    // Ban history for phantom suppression: the newest AUTHORIZED edition naming each npub,
    // over EVERY candidate rather than only the head — an un-ban replaces the head, so the
    // head alone forgets the ban that the suppression exists to remember. The owner is
    // skipped: they are never bannable, and a moderator listing them must not durably
    // suppress them past the un-ban.
    let mut banned_at: std::collections::BTreeMap<String, u64> = std::collections::BTreeMap::new();
    for p in &banlist_authored {
        for t in super::roles::parse_banlist_content(&p.content).unwrap_or_default() {
            if owner_hex.as_deref() == Some(t.as_str()) {
                continue;
            }
            let slot = banned_at.entry(t).or_insert(0);
            *slot = (*slot).max(p.created_at);
        }
    }
    let mut banlist_persist: Option<(Vec<String>, u64)> = None;
    let mut banlist_head: Option<FoldedHead> = None;
    let banned: std::collections::BTreeSet<String> = if banlist_authored.is_empty() {
        persisted_banned.into_iter().collect()
    } else {
        let fold_eds: Vec<version::Edition> = banlist_authored.iter().map(|p| p.to_fold_edition()).collect();
        let (hi, g) = fold_head(&fold_eds, floors.get(&banlist_hex));
        gapped |= g;
        match hi {
            Some(hi) => {
                let head = banlist_authored[hi];
                let ah = head.author.to_hex();
                let list: Vec<String> = super::roles::parse_banlist_content(&head.content)
                    .unwrap_or_default()
                    .into_iter()
                    .filter(|t| prelim.can_act_on_member(&ah, owner_hex.as_deref(), t, Permissions::BAN))
                    .take(super::roles::MAX_BANLIST)
                    .collect();
                banlist_head = Some(FoldedHead { entity_hex: banlist_hex.clone(), version: head.version, self_hash: head.self_hash, inner_id: head.inner_id });
                banlist_persist = Some((list.clone(), head.version));
                list.into_iter().collect()
            }
            None => persisted_banned.into_iter().collect(),
        }
    };

    // Final roster (CORD-04 §4: a banned npub vanishes — every edition it authored is
    // dropped, and a grant TO a banned member carries no rank). Re-run selection with
    // the banned set excluded so a banned admin loses authority.
    let (mut authorized, mut heads) = select_authorized(cid, &role_cands, &grant_cands, owner_hex.as_deref(), &banned);
    if let Some(bh) = banlist_head {
        heads.push(bh);
    }

    // Cap the AUTHORIZED community at the 100 lowest role_ids — applied AFTER
    // authorization, so an attacker's unauthorized roles can't consume cap slots and
    // evict a legitimate one (the pre-authorize cap they replace let 100 forged low-id
    // roles empty the roster).
    if authorized.roles.len() > super::roles::MAX_ROLES_PER_COMMUNITY {
        authorized.roles.sort_by(|a, b| a.role_id.cmp(&b.role_id));
        authorized.roles.truncate(super::roles::MAX_ROLES_PER_COMMUNITY);
        let kept: std::collections::HashSet<&str> = authorized.roles.iter().map(|r| r.role_id.as_str()).collect();
        authorized.grants.iter_mut().for_each(|g| g.role_ids.retain(|rid| kept.contains(rid.as_str())));
        authorized.grants.retain(|g| !g.role_ids.is_empty());
    }

    AuthoritySet { roles: authorized, banned, heads, gapped, banlist_persist, banned_at }
}

/// One candidate edition of a role/grant entity — the pool [`select_authorized`]
/// draws the highest AUTHORIZED head from (exactly one of `role`/`grant` is set).
struct AuthorityCand {
    role: Option<crate::community::roles::Role>,
    grant: Option<crate::community::roles::MemberGrant>,
    author: PublicKey,
    head: FoldedHead,
    /// The `vac` this edition carried (CORD-04 §5). `None` for an owner edition
    /// (supreme, cites nothing) or an uncited one — the latter is refused.
    citation: Option<crate::community::edition::AuthorityCitation>,
}

/// CORD-04 §5 sync floor, resolved against the heads THIS fold pass has accepted.
///
/// Deliberately not the persisted-head helper the kick/hide paths use: this IS the
/// pass that establishes those heads, so an external floor would refuse every
/// non-owner edition on a bootstrap and the roster could never fold. Same rule the
/// spec gives for a dangling `prev` across a Refounding — a fresh joiner takes the
/// authority-verified head as its baseline, a tracking client fails closed per
/// entity — applied to the citation instead of the chain link.
fn citation_ok_in_fold(
    cid: &crate::community::CommunityId,
    heads: &[FoldedHead],
    owner_hex: Option<&str>,
    author: &PublicKey,
    citation: Option<&crate::community::edition::AuthorityCitation>,
) -> bool {
    let actor_hex = author.to_hex();
    if owner_hex == Some(actor_hex.as_str()) {
        return true;
    }
    let grant_hex = crate::simd::hex::bytes_to_hex_32(&super::derive::grant_locator(cid, &author.to_bytes()));
    let as_entity: Vec<crate::community::roster::EntityHead> = heads
        .iter()
        .map(|h| crate::community::roster::EntityHead {
            entity_hex: h.entity_hex.clone(),
            version: h.version,
            self_hash: h.self_hash,
            inner_id: h.inner_id,
            citation: None,
        })
        .collect();
    crate::community::roster::authority_citation_satisfied(&as_entity, owner_hex, &actor_hex, &grant_hex, citation)
}

/// The owner-seeded delegation fixpoint (CORD-04 §1/§2), author-AWARE: per entity it
/// takes the highest-version candidate whose author is authorized to author it under
/// the roster resolved SO FAR, dropping unauthorized higher versions rather than
/// vanishing the entity. Authority resolves outward from the owner (proven by
/// `community_id`, never a Role), and the strict-outrank rule (no edition at/above its
/// signer's own position) keeps the fixpoint monotone, so it converges. Returns the
/// authorized roster plus the per-entity heads of the SELECTED editions (the floor
/// advances only to authorized heads — an unauthorized forgery never poisons it).
fn select_authorized(
    cid: &crate::community::CommunityId,
    role_cands: &std::collections::BTreeMap<String, Vec<AuthorityCand>>,
    grant_cands: &std::collections::BTreeMap<String, Vec<AuthorityCand>>,
    owner_hex: Option<&str>,
    excluded: &std::collections::BTreeSet<String>,
) -> (crate::community::roles::CommunityRoles, Vec<FoldedHead>) {
    use crate::community::roles::{CommunityRoles, Permissions};
    let mut accepted = CommunityRoles::default();
    let mut heads: Vec<FoldedHead> = Vec::new();
    // Jacobi iteration: authority propagates one delegation level per round, so a
    // generous multiple of the entity count is an ample bound. Non-convergence (never
    // seen for an owner-rooted chain) falls through fail-safe: only authorized editions
    // are ever selected.
    let bound = 2 * (role_cands.len() + grant_cands.len()) + 8;
    for _ in 0..bound {
        let mut next = CommunityRoles::default();
        let mut next_heads: Vec<FoldedHead> = Vec::new();

        for cands in role_cands.values() {
            // Two gates, not one (CORD-04 §2). Minting at a position you outrank
            // is necessary but not sufficient: an edition REPLACES the entity, so
            // the author must also outrank the position standing before it.
            // Without that, an admin at position 5 rewrites the position-1 role
            // to position 9 — every check passes, since 9 is beneath them — and
            // a role that outranked them is now beneath them, along with everyone
            // holding it. Rank inversion by republish.
            //
            // The chain is replayed ASCENDING so each version is judged against
            // the position its own predecessor established, then the highest
            // admissible version wins (candidates arrive version-DESC, forks
            // broken by lowest inner_id — preserved by walking version groups).
            let mut admissible: std::collections::HashSet<[u8; 32]> = std::collections::HashSet::new();
            let mut standing: Option<u32> = None;
            let mut i = cands.len();
            while i > 0 {
                let hi = i;
                let ver = cands[i - 1].head.version;
                while i > 0 && cands[i - 1].head.version == ver {
                    i -= 1;
                }
                // One winner per version: fork siblings can't sidestep the gate.
                for c in cands[i..hi].iter().rev() {
                    let Some(role) = &c.role else { continue };
                    let ah = c.author.to_hex();
                    if excluded.contains(&ah) || role.position == 0 {
                        continue;
                    }
                    if !accepted.can_act_on_position(&ah, owner_hex, role.position, Permissions::MANAGE_ROLES) {
                        continue;
                    }
                    if let Some(prev) = standing {
                        if !accepted.can_act_on_position(&ah, owner_hex, prev, Permissions::MANAGE_ROLES) {
                            continue;
                        }
                    }
                    if !citation_ok_in_fold(cid, &heads, owner_hex, &c.author, c.citation.as_ref()) {
                        continue;
                    }
                    admissible.insert(c.head.self_hash);
                    standing = Some(role.position);
                    break;
                }
            }
            for c in cands {
                let Some(role) = &c.role else { continue };
                if !admissible.contains(&c.head.self_hash) {
                    continue;
                }
                next.roles.push(role.clone());
                next_heads.push(c.head.clone());
                break; // highest admissible candidate for this entity
            }
        }
        for cands in grant_cands.values() {
            for c in cands {
                let Some(grant) = &c.grant else { continue };
                let ah = c.author.to_hex();
                if excluded.contains(&ah) || excluded.contains(&grant.member) {
                    continue;
                }
                // The granter must outrank every granted role (resolved against the
                // accepted roster) AND the member — the escalation defense (CORD-04 §2).
                let positions: Option<Vec<u32>> = grant.role_ids.iter().map(|rid| accepted.role(rid).map(|r| r.position)).collect();
                let Some(positions) = positions else { continue };
                if !citation_ok_in_fold(cid, &heads, owner_hex, &c.author, c.citation.as_ref()) {
                    continue;
                }
                if positions.iter().all(|p| accepted.can_act_on_position(&ah, owner_hex, *p, Permissions::MANAGE_ROLES))
                    && accepted.can_act_on_member(&ah, owner_hex, &grant.member, Permissions::MANAGE_ROLES)
                {
                    // Record the head even for an EMPTY grant (a revoke is a real chain
                    // advance a completeness check must see), but don't carry the husk
                    // into the roster.
                    next_heads.push(c.head.clone());
                    if !grant.role_ids.is_empty() {
                        next.grants.push(grant.clone());
                    }
                    break;
                }
            }
        }

        let converged = next.roles == accepted.roles && next.grants == accepted.grants;
        accepted = next;
        heads = next_heads;
        if converged {
            break;
        }
    }
    (accepted, heads)
}

/// Apply a folded community-metadata head. Relays only overwrite when the edition
/// carries a non-empty list (a metadata edition that omits relays must not blank
/// the working set). Returns whether anything changed.
fn apply_community_metadata(out: &mut CommunityV2, meta: control::CommunityMetadata) -> bool {
    let mut changed = false;
    if out.name != meta.name {
        out.name = meta.name;
        changed = true;
    }
    if out.description != meta.description {
        out.description = meta.description;
        changed = true;
    }
    // Icon/banner apply verbatim, None included — an edition is the full
    // document, so an absent image IS a removal (editors preserve via
    // `CommunityV2::metadata()`).
    if out.icon != meta.icon {
        out.icon = meta.icon;
        changed = true;
    }
    if out.banner != meta.banner {
        out.banner = meta.banner;
        changed = true;
    }
    // Client-extensible + unknown fields ride the fold verbatim so our own
    // editions can carry them forward (CORD-02 §6).
    if out.meta_custom != meta.custom {
        out.meta_custom = meta.custom;
        changed = true;
    }
    if out.meta_extra != meta.extra {
        out.meta_extra = meta.extra;
        changed = true;
    }
    // CAP on the way in. `cap_relays` is the truncate-on-read invariant for every
    // other construction boundary, and the fold is a boundary like any other: an
    // authorized editor is not a trusted one, and an oversize list costs every
    // member a fan-out on each publish and the slowest of N on each fetch
    // (CORD-02 §6 makes trimming explicitly a client's call). Compare against the
    // CAPPED list too — against the raw one, an oversize edition never compares
    // equal, so every fold would report a change and re-save forever.
    let relays = crate::community::cap_relays(meta.relays);
    if !relays.is_empty() && out.relays != relays {
        out.relays = relays;
        changed = true;
    }
    changed
}

/// Apply a folded channel-metadata head: delete removes the channel, a rename
/// updates an existing one, a brand-new PUBLIC channel is added, and a brand-new
/// PRIVATE one is recorded KEYLESS (unreadable until its key arrives over the
/// rekey plane or a fresh bundle). Returns whether anything changed.
fn apply_channel_metadata(out: &mut CommunityV2, id: ChannelId, meta: control::ChannelMetadata) -> bool {
    let deleted = meta.deleted.unwrap_or(false);
    if deleted {
        let before = out.channels.len();
        out.channels.retain(|c| c.id.0 != id.0);
        return out.channels.len() != before;
    }
    match out.channels.iter_mut().find(|c| c.id.0 == id.0) {
        Some(existing) => {
            let mut changed = false;
            if existing.name != meta.name {
                existing.name = meta.name;
                changed = true;
            }
            // vsk-2 fields Vector doesn't drive still fold + persist, so a later
            // local edit republishes them instead of wiping (CORD-02 §6).
            if existing.voice != meta.voice {
                existing.voice = meta.voice;
                changed = true;
            }
            if existing.meta_custom != meta.custom {
                existing.meta_custom = meta.custom;
                changed = true;
            }
            if existing.meta_extra != meta.extra {
                existing.meta_extra = meta.extra;
                changed = true;
            }
            // The owner's edition authoritatively declares visibility. A channel the
            // owner marks PUBLIC must derive from the root (key = None) — this heals a
            // bundle-time misclassification where an attacker set a public channel's
            // grant key to their own, silently addressing it at a plane only they read.
            // Public → private CONVERSION is DEFERRED: the flip is IGNORED here (the
            // record stays public) until the convert flow (key mint + cursor rebase
            // to the conversion's channel epoch) lands — the send side refuses to
            // publish one, and a foreign client's conversion won't move us.
            if !meta.private && (existing.private || existing.key.is_some()) {
                existing.private = false;
                existing.key = None;
                changed = true;
            }
            changed
        }
        None if !meta.private => {
            // A public channel derives its Chat Plane from the community_root at the
            // current root epoch (key = None); its stored epoch mirrors the root.
            out.channels.push(ChannelV2 {
                id,
                name: meta.name,
                private: false,
                key: None,
                epoch: out.root_epoch,
                voice: meta.voice,
                meta_custom: meta.custom,
                meta_extra: meta.extra,
            });
            true
        }
        None => {
            // A brand-new PRIVATE channel: record it KEYLESS at epoch 0 (the root
            // generation — CORD-03 §2 numbers the first private key epoch 1). The
            // epoch then doubles as [`follow_rekeys`]' scan cursor. Until a rotation
            // delivers a key, every read/send/subscribe path skips the channel; the
            // root-fallback in `channel_secret` is never taken for it.
            out.channels.push(ChannelV2 {
                id,
                name: meta.name,
                private: true,
                key: None,
                epoch: Epoch(0),
                voice: meta.voice,
                meta_custom: meta.custom,
                meta_extra: meta.extra,
            });
            true
        }
    }
}

// ── Live rekey-follow (CORD-06 §2/§3) ────────────────────────────────────────

/// The outcome of a rekey-follow pass.
pub struct RekeyFollow {
    /// The community after adopting every rotation it could catch up on, or `None`
    /// if nothing advanced.
    pub updated: Option<CommunityV2>,
    /// A base rotation removed us — the caller tears the local hold down (the
    /// updated community is not persisted in that case).
    pub self_removed: bool,
    /// An owner tombstone sits on the dissolved plane (CORD-02 §9) — the local
    /// flag is already set; the caller surfaces the death and stops following.
    pub dissolved: bool,
}

/// The most archived base roots a channel-rekey lookup fans across per step. A
/// standalone rekey rides the minter's then-current root and a removal's rides the
/// PRIOR root (CORD-06 §3), so a follower whose base already advanced must look
/// back. A channel stranded DEEPER than this (its next-epoch crate addressed under
/// an older root than the fan reaches) only heals via a fresh invite bundle — the
/// walk is strictly sequential, so a later rotation can't be reached either.
const MAX_ADDRESSING_ROOTS: usize = 8;

/// The base roots a channel rekey may be addressed under, freshest first: the
/// current root plus the archived priors, capped at [`MAX_ADDRESSING_ROOTS`].
/// CORD-06 D2: a removal-forced channel rekey rides the PRIOR root — so the
/// follower's fetch fan ([`follow_rekeys`]) and the stream-auth registration
/// (`streamauth::register_community`) MUST cover the SAME set. A plane the
/// fetch addresses but auth never registered is invisible on an AUTH-gating
/// relay: the REQ is CLOSED, the rotation crate never arrives, and the channel
/// wedges at its old epoch while the base advances.
pub(crate) fn channel_rekey_addressing_roots(cur_root: [u8; 32], cid_hex: &str) -> Vec<[u8; 32]> {
    let mut roots: Vec<[u8; 32]> = vec![cur_root];
    let mut archived = crate::db::community::held_epoch_keys(cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX)
        .unwrap_or_default();
    archived.sort_by(|a, b| b.0 .0.cmp(&a.0 .0));
    for (_, r) in archived {
        if !roots.contains(&r) {
            roots.push(r);
        }
    }
    roots.truncate(MAX_ADDRESSING_ROOTS);
    roots
}

/// Follow rekeys for a held community: advance the base (root) epoch and each
/// Private channel's epoch as far as authorized rotations allow, adopting the
/// fresh key we're still a recipient of at each step and dropping a scope we've
/// been removed from. Persists the result. Called when a rekey wrap arrives in
/// realtime so a long-running bot keeps decrypting after a rotation instead of
/// going silent.
///
/// **Authority (CORD-06 §Authority):** a BASE rotation is honored from the owner
/// only — the deliberate mirror of the owner-only Refounding send (a non-owner's
/// ban silences + strips; the read-cut is the owner's). A CHANNEL rotation is
/// honored from the owner or a `MANAGE_CHANNELS` holder under the PERSISTED
/// roster (folded + persisted by `follow_control`), minus the banlist — so an
/// admin-created private channel keys up on every member.
///
/// **Addressing fans across held base roots:** each channel step queries its
/// next-epoch rekey address under the current root AND the archived prior roots,
/// so a base adopt landing before a Refounding's prior-root-addressed channel
/// rekeys (or before a creation delivery minted under an older root) can't
/// strand the channel.
///
/// **Continuity + fork resolution are spec-strict:** a rotation must extend the
/// exact `(epoch, key)` I hold, one epoch at a time; a same-epoch fork resolves
/// by the lexicographically lowest new key ([`rekey::lowest_key_winner`]), so
/// every follower converges. An incomplete rotation (a missing chunk) never
/// concludes removal — it just waits. A KEYLESS channel (announced by vsk-2, key
/// not yet delivered) holds no chain, so continuity is vacuous for it (CORD-06
/// §2: "a convergence check, not a secrecy mechanism") — authority is its
/// boundary; its epoch is the scan cursor, advancing past complete rotations
/// that exclude us so the walk converges on the channel's current epoch.
/// Diagnostic: run the base-rotation fetch+parse pipeline for a wedged community
/// and report, per rotation found at the next-epoch base plane, WHY
/// `follow_rekeys` did or didn't adopt it — the exact `advance_scope` gate that
/// tripped. Read-only. Every rotator/owner is a PUBLIC key; no secret material
/// is returned.
#[cfg(debug_assertions)]
pub async fn debug_explain_base_rekey<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
) -> Result<serde_json::Value, String> {
    let my_xonly = me_pk()?.to_bytes();
    let owner = community.owner()?;
    let owner_hex = owner.to_hex();
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    let roster = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    let banned = crate::db::community::get_community_banlist(&cid_hex).unwrap_or_default();
    let held_epoch = community.root_epoch;
    let held_key = community.community_root;
    let next = Epoch(held_epoch.0.saturating_add(1));
    let group = base_rekey_group_key(&held_key, community.id(), next);
    let chunks = fetch_rekey_chunks(transport, &community.relays, &group).await?;
    let rotations = rekey::collect_rotations(&chunks);

    let reports: Vec<serde_json::Value> = rotations
        .iter()
        .map(|r| {
            let rotator_is_owner = r.rotator == owner;
            // CORD-06 §Authority: a Refounding is authorized by BAN in the folded
            // Roster, not owner-identity — report that gate, not just owner-equality.
            let rotator_authorized = rotator_is_owner
                || (!banned.contains(&r.rotator.to_hex())
                    && roster.is_authorized(&r.rotator.to_hex(), Some(&owner_hex), crate::community::roles::Permissions::BAN));
            let scope_ok = r.scope.id32() == rekey::RekeyScope::Root.id32();
            let epoch_ok = r.new_epoch.0 == next.0;
            let complete = r.is_complete();
            let continuity = format!("{:?}", r.continuity(held_epoch, &held_key));
            let has_my_blob = rekey::find_my_blob(&r.blobs, &r.rotator.to_bytes(), &my_xonly, r.scope, r.new_epoch).is_some();
            // Is the OWNER a recipient? A non-owner Refounding that drops the owner
            // is a takeover attempt — this tells whether an "owner must be kept"
            // adopt-block would be safe here (it would falsely reject a legitimate
            // rotation that happened to exclude the owner).
            let owner_kept = r.rotator == owner
                || rekey::find_my_blob(&r.blobs, &r.rotator.to_bytes(), &owner.to_bytes(), r.scope, r.new_epoch).is_some();
            // The exact reason follow_rekeys skipped/rejected this rotation, in gate order.
            let verdict = if !rotator_authorized {
                "REJECTED: rotator holds no BAN authority in the folded roster"
            } else if !scope_ok {
                "REJECTED: scope is not Root"
            } else if !epoch_ok {
                "REJECTED: new_epoch != held+1"
            } else if !complete {
                "WAIT: rotation incomplete (missing chunk) — never concludes removal"
            } else if continuity != "Extends" {
                "REJECTED: continuity does not extend my held root (FORK/GAP)"
            } else if has_my_blob {
                "ADOPT: authorized + complete + continuous + my blob present"
            } else {
                "REMOVED: complete authorized rotation with no blob for me"
            };
            serde_json::json!({
                "rotator": r.rotator.to_hex(),
                "rotator_is_recorded_owner": rotator_is_owner,
                "rotator_authorized_ban": rotator_authorized,
                "scope_is_root": scope_ok,
                "new_epoch": r.new_epoch.0,
                "prev_epoch": r.prev_epoch.0,
                "declared_chunks": r.declared_chunks,
                "held_chunks": r.held_chunks.iter().copied().collect::<Vec<_>>(),
                "is_complete": complete,
                "continuity_vs_held_root": continuity,
                "my_blob_present": has_my_blob,
                "owner_kept": owner_kept,
                "blob_count": r.blobs.len(),
                "verdict": verdict,
            })
        })
        .collect();

    Ok(serde_json::json!({
        "recorded_owner": owner.to_hex(),
        "held_root_epoch": held_epoch.0,
        "probing_next_epoch": next.0,
        "base_plane_pk": group.pk_hex(),
        "raw_chunks_parsed": chunks.len(),
        "rotations_found": rotations.len(),
        "rotations": reports,
    }))
}

pub async fn follow_rekeys<T: Transport + ?Sized>(
    transport: &T,
    community: &CommunityV2,
    session: &SessionGuard,
) -> Result<RekeyFollow, String> {
    // Death wins every race (CORD-02 §9): a dissolved community honors no epoch advance
    // past its tombstone — don't adopt a rotation into a grave.
    let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
    if crate::db::community::get_community_dissolved(&cid_hex).unwrap_or(false) {
        return Ok(RekeyFollow { updated: None, self_removed: false, dissolved: true });
    }
    // An offline member must also LEARN of a death: the tombstone rides its own
    // public plane, which the live sub watches but no catch-up fetch touched —
    // without this, a member who slept through a dissolution follows (and posts
    // into) a grave forever. Fail-open on transport failure: availability is
    // never death.
    if is_dissolved(transport, community).await {
        if session.is_valid() {
            let _ = crate::db::community::set_community_dissolved(&cid_hex);
        }
        return Ok(RekeyFollow { updated: None, self_removed: false, dissolved: true });
    }
    let signer = crate::signer::active_signer()?;
    let my_pk = me_pk()?;
    let my_xonly = my_pk.to_bytes();
    let owner = community.owner()?;
    let owner_hex = owner.to_hex();
    let mut cur = community.clone();
    let mut changed = false;

    // The rotator/admissibility gates read the PERSISTED roster (folded by a prior
    // follow_control; the worker folds control right after this rekey pass). This
    // is "one pass late" for the rotator-AUTHORIZATION direction (a newly-granted
    // admin's rotation adopts a pass late, never early — safe). It is fail-OPEN for
    // the base-admissibility protected-set: a superior whose grant this receiver
    // has not yet folded is not in `roster.grants`, so a non-owner Refounding
    // excluding them can be adopted within that propagation window. Bounded — the
    // owner is ALWAYS hard-protected below (independent of the roster) and can
    // counter-refound; and it is inherent to eventual consistency (one cannot gate
    // on a grant never seen). Tightening this (fold control before the first rekey,
    // or gate non-owner adoption on roster freshness) is a follow-on.
    let roster = crate::db::community::get_community_roles(&cid_hex).unwrap_or_default();
    let banned = crate::db::community::get_community_banlist(&cid_hex).unwrap_or_default();
    let me_hex = my_pk.to_hex();
    // CORD-06 §Authority: "a rotation cites the Grant it acts under like any
    // authority action (CORD-04's `vac`), so a just-demoted admin's rotation is
    // never honored by a lagging client." Persisted heads ARE the right floor
    // here (unlike the roster fold, which must resolve in-pass): a rotation is
    // judged against a roster we already folded, and `follow_control` — v2's only
    // roster writer — persists the heads in the same pass it writes the roster.
    // A joiner who sees a rotation before folding control simply parks it and
    // heals on the next follow, which runs control first.
    let cited_ok = |rot: &rekey::Rotation| -> bool {
        citation_is_synced(&cid_hex, &owner_hex, &rot.rotator.to_hex(), rot.citation.as_ref())
    };
    let channel_rotator_ok = |rotator: &PublicKey| -> bool {
        if *rotator == owner {
            return true;
        }
        let rh = rotator.to_hex();
        !banned.contains(&rh) && roster.is_authorized(&rh, Some(&owner_hex), crate::community::roles::Permissions::MANAGE_CHANNELS)
    };
    // Concluding MY removal takes more than the bit: the rotator must strictly
    // outrank ME (CORD-06 §Authority — "the Rotator must strictly outrank every
    // removed target"), so an equal-rank admin can never silently evict a peer
    // (or the owner) by minting a complete rotation that skips their blob.
    let channel_rotator_outranks_me = |rotator: &PublicKey| -> bool {
        if *rotator == owner {
            return true;
        }
        let rh = rotator.to_hex();
        !banned.contains(&rh) && roster.can_act_on_member(&rh, Some(&owner_hex), &me_hex, crate::community::roles::Permissions::MANAGE_CHANNELS)
    };
    // CORD-06 §Authority: a Refounding requires the BAN permission in the folded
    // Roster (NOT owner-identity) — any admin holding BAN may perform it, checked
    // against the Roster exactly like a channel rekey checks MANAGE_CHANNELS. The
    // owner is always authorized. (Owner-only here silently wedged every member
    // whose community was refounded by a non-owner admin.)
    let base_rotator_ok = |rotator: &PublicKey| -> bool {
        if *rotator == owner {
            return true;
        }
        let rh = rotator.to_hex();
        !banned.contains(&rh) && roster.is_authorized(&rh, Some(&owner_hex), crate::community::roles::Permissions::BAN)
    };
    // Concluding MY removal via a base rotation takes more than the bit: the
    // rotator must strictly outrank ME with BAN (CORD-06 §Authority — "the
    // Rotator must strictly outrank every removed target"), so an equal-rank
    // admin can never evict a peer (or the owner) by minting a rotation that
    // skips their blob. Adoption (I hold a blob) only needs `base_rotator_ok`.
    let base_rotator_outranks_me = |rotator: &PublicKey| -> bool {
        if *rotator == owner {
            return true;
        }
        let rh = rotator.to_hex();
        !banned.contains(&rh) && roster.can_act_on_member(&rh, Some(&owner_hex), &me_hex, crate::community::roles::Permissions::BAN)
    };

    // Bound the catch-up: each real step consumes a valid authorized rotation, so a
    // finite chain terminates naturally; the cap defends against a relay feeding a
    // pathological set.
    const MAX_STEPS: usize = 128;
    for _ in 0..MAX_STEPS {
        let mut advanced = false;

        // The roots a channel rekey may be addressed under (re-read each pass —
        // a base adopt below changes the head, and its predecessor is already
        // archived). Shared with streamauth so the auth registration covers
        // exactly this fan.
        let addressing_roots = channel_rekey_addressing_roots(cur.community_root, &cid_hex);

        // Private channels first: a removal-forced channel rekey rides the PRIOR
        // root (CORD-06 D2), so read channels before a base adopt moves it.
        let channel_ids: Vec<ChannelId> = cur.channels.iter().filter(|c| c.private).map(|c| c.id).collect();
        for cid in channel_ids {
            let (held_key, held_epoch) = match cur.channel(&cid) {
                Some(ch) => (ch.key, ch.epoch),
                None => continue,
            };
            let next = Epoch(held_epoch.0.saturating_add(1));
            let ch_hex = crate::simd::hex::bytes_to_hex_32(&cid.0);
            let mut batches: Vec<(Vec<rekey::RekeyChunk>, Option<(Epoch, [u8; 32])>)> = Vec::new();
            // root #0 = current, #1.. = archived priors (indices only — root
            // bytes are key material and must never reach a log).
            for (ri, root) in addressing_roots.iter().enumerate() {
                let group = channel_rekey_group_key(root, &cid, next);
                let chunks = match fetch_rekey_chunks(transport, &cur.relays, &group).await {
                    Ok(c) => c,
                    Err(e) => {
                        crate::log_warn!(
                            "[v2:follow {}] ch {} next e{} root#{}/{}: rekey plane fetch failed: {}",
                            &cid_hex[..8], &ch_hex[..8], next.0, ri, addressing_roots.len(), e
                        );
                        return Err(e);
                    }
                };
                if chunks.is_empty() {
                    continue;
                }
                crate::log_debug!(
                    "[v2:follow {}] ch {} next e{} root#{}/{}: {} rekey chunk(s)",
                    &cid_hex[..8], &ch_hex[..8], next.0, ri, addressing_roots.len(), chunks.len()
                );
                batches.push((chunks, held_key.map(|k| (held_epoch, k))));
            }
            // Keyless-adopt residual (documented, deferred hardening): a malicious
            // AUTHORIZED admin can fork a keyless member onto an orphan low-key
            // rotation nothing extends (keyed members' continuity filters it out).
            // Recoverable via a fresh bundle; an insider with MANAGE_CHANNELS can
            // exclude the member outright anyway, so the marginal harm is the wedge
            // outliving their demotion.
            match advance_scope(&batches, RekeyScope::Channel(cid), &channel_rotator_ok, &channel_rotator_outranks_me, &cited_ok, &signer, &my_xonly, next).await {
                Advance::Adopt { new_key } => {
                    if let Some(ch) = cur.channels.iter_mut().find(|c| c.id.0 == cid.0) {
                        ch.key = Some(new_key);
                        ch.epoch = next;
                    }
                    crate::log_debug!("[v2:follow {}] ch {} ADOPTED e{}", &cid_hex[..8], &ch_hex[..8], next.0);
                    // The adopter's own multi-epoch archive (the minter archived at
                    // mint) — this channel's history stays readable across rotations.
                    // fetch_channel compensates for the CURRENT epoch, so a failed
                    // archive only bites after the NEXT rotation — surface it.
                    if let Err(e) = crate::db::community::store_epoch_key(&cid_hex, &crate::simd::hex::bytes_to_hex_32(&cid.0), next.0, &new_key) {
                        crate::log_warn!("v2: channel epoch-key archive failed (history across this rotation may not read back): {e}");
                    }
                    advanced = true;
                    changed = true;
                }
                Advance::Removed => {
                    match held_key {
                        // A complete rotation dropped my blob — cut from the channel.
                        Some(_) => {
                            cur.channels.retain(|c| c.id.0 != cid.0);
                        }
                        // Keyless scan: this epoch's rotation completed without me.
                        // Advance the cursor so the walk converges on the channel's
                        // CURRENT epoch — my entry point is its next rotation (whose
                        // recipients are the members at that time) or a fresh bundle.
                        None => {
                            if let Some(ch) = cur.channels.iter_mut().find(|c| c.id.0 == cid.0) {
                                ch.epoch = next;
                            }
                        }
                    }
                    advanced = true;
                    changed = true;
                }
                Advance::Stay => {}
            }
        }

        // Base rotation (Refounding): advances the root + root_epoch, re-addressing
        // every public channel, the guestbook, and the control plane by derivation
        // (refresh_subscription recomputes the author-set from the new root).
        {
            let held_epoch = cur.root_epoch;
            let held_key = cur.community_root;
            let next = Epoch(held_epoch.0.saturating_add(1));
            let group = base_rekey_group_key(&cur.community_root, cur.id(), next);
            let chunks = fetch_rekey_chunks(transport, &cur.relays, &group).await?;
            let batches = vec![(chunks, Some((held_epoch, held_key)))];
            // A non-owner Refounding may only remove members the rotator strictly
            // OUTRANKS. The protected set is the owner plus every grant-holder the
            // rotator can't act on with BAN (a peer or superior) — excluding one is
            // an authority-escalation takeover, so its rotation is inadmissible.
            // Plain members hold no grant and are always outranked by a BAN-holder,
            // so removing them is legitimate and needs no memberlist.
            let base_admissible = |r: &rekey::Rotation| -> bool {
                if r.rotator == owner {
                    return true; // the owner is supreme.
                }
                // Uncited (or citing a Grant we haven't synced) → skip entirely:
                // neither adopt nor conclude a removal, exactly like an
                // unauthorized rotation. It parks and heals on the next follow.
                if !cited_ok(r) {
                    return false;
                }
                let rotator_hex = r.rotator.to_hex();
                let has_blob = |xonly: &[u8; 32]| {
                    rekey::find_my_blob(&r.blobs, &r.rotator.to_bytes(), xonly, r.scope, r.new_epoch).is_some()
                };
                // The owner is never a valid removed target.
                if !has_blob(&owner.to_bytes()) {
                    return false;
                }
                for g in &roster.grants {
                    if g.member == rotator_hex || g.member == owner_hex || banned.contains(&g.member) {
                        continue; // self, owner (checked), or an already-authorized removal.
                    }
                    // A grant-holder the rotator can't act on is a peer/superior.
                    if !roster.can_act_on_member(&rotator_hex, Some(&owner_hex), &g.member, crate::community::roles::Permissions::BAN) {
                        if let Ok(pk) = PublicKey::from_hex(&g.member) {
                            if !has_blob(&pk.to_bytes()) {
                                return false; // a peer/superior was excluded.
                            }
                        }
                    }
                }
                true
            };
            match advance_scope(&batches, RekeyScope::Root, &base_rotator_ok, &base_rotator_outranks_me, &base_admissible, &signer, &my_xonly, next).await {
                Advance::Adopt { new_key } => {
                    cur.community_root = new_key;
                    cur.root_epoch = next;
                    // Archive on adopt: without this, a member who lived through TWO
                    // Refoundings loses the middle epoch's public history (only the
                    // minter archived it).
                    if let Err(e) = crate::db::community::store_epoch_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, next.0, &new_key) {
                        crate::log_warn!("v2: base epoch-key archive failed (this epoch's history may not read back after the next rotation): {e}");
                    }
                    advanced = true;
                    changed = true;
                }
                Advance::Removed => {
                    if !session.is_valid() {
                        return Err("account changed during rekey follow".to_string());
                    }
                    return Ok(RekeyFollow { updated: None, self_removed: true, dissolved: false });
                }
                Advance::Stay => {}
            }
        }

        if !advanced {
            break;
        }
    }

    if !changed {
        return Ok(RekeyFollow { updated: None, self_removed: false, dissolved: false });
    }
    if !session.is_valid() {
        return Err("account changed during rekey follow".to_string());
    }
    // A leave/delete raced this follow: saving would resurrect the community row
    // (the save is an upsert) with no floor rows behind it.
    if crate::db::community::community_protocol(community.id())?.is_none() {
        return Ok(RekeyFollow { updated: None, self_removed: false, dissolved: false });
    }
    crate::db::community::save_community_v2(&cur)?;
    // Carry my own live links across the rotation someone ELSE performed
    // (CORD-05 §2). The refounder refreshes only the bundles they can reach —
    // their own — so without this every other creator's links keep vending the
    // superseded root and drop new joiners onto a dead epoch, which is exactly
    // the stranding the stable-URL refresh exists to prevent. Best-effort and
    // idempotent: a creator with no links for this community returns early, and
    // a failure only delays the heal until the next adoption or refound.
    let _ = refresh_public_links(transport, &cur).await;
    Ok(RekeyFollow { updated: Some(cur), self_removed: false, dissolved: false })
}

/// One scope's catch-up decision from the rekey chunks fetched at its next-epoch
/// address.
enum Advance {
    /// Adopt this fresh key for `next_epoch`.
    Adopt { new_key: [u8; 32] },
    /// A complete owner rotation at `next_epoch` dropped my blob — I'm removed.
    Removed,
    /// No owner rotation extends my held epoch (yet) — keep the current key.
    Stay,
}

/// Fetch + parse every seal-verified 3303 chunk at a rekey plane address.
async fn fetch_rekey_chunks<T: Transport + ?Sized>(
    transport: &T,
    relays: &[String],
    group: &GroupKey,
) -> Result<Vec<rekey::RekeyChunk>, String> {
    // A rekey plane address is community_root-derived, so ANY member can seal junk
    // 3303s there — a flood (or, organically, a large community's own multi-chunk
    // rotation past the newest window) could bury the genuine owner/admin rotation
    // in a single fixed page. PAGE backwards (inclusive until + wrap-id dedup, the
    // control pager's discipline) so a buried authorized chunk is still recovered;
    // the seal + authority filter downstream drops the junk. Bounded — a sustained
    // flood past this depth degrades to "adopt one pass late", never a false state.
    const REKEY_PAGE: usize = 200;
    const REKEY_MAX_PAGES: usize = 6;
    let mut out = Vec::new();
    let mut seen: std::collections::HashSet<nostr_sdk::prelude::EventId> = std::collections::HashSet::new();
    let mut until: Option<u64> = None;
    let mut oldest: Option<u64> = None;
    for _ in 0..REKEY_MAX_PAGES {
        let query = Query {
            kinds: vec![stream::KIND_WRAP],
            authors: vec![group.pk_hex()],
            until,
            limit: Some(REKEY_PAGE),
            ..Default::default()
        };
        // Authenticate AS the rekey plane key: on AUTH-gating relays (Ditto) the
        // shared user-authed client's REQ for a plane's events is CLOSED, so an
        // offline rotation catch-up would return nothing and wedge at the old
        // epoch. `fetch_plane` rides a connection authed as the plane itself.
        let wraps = transport.fetch_plane(group.keys(), &query, relays).await?;
        let mut fresh = 0usize;
        for w in &wraps {
            if !seen.insert(w.id) {
                continue;
            }
            fresh += 1;
            let at = w.created_at.as_secs();
            if oldest.is_none_or(|o| at < o) {
                oldest = Some(at);
            }
            if let Ok(opened) = stream::open_wrap(w, group) {
                if let Ok(chunk) = rekey::parse_rekey_chunk(&opened) {
                    out.push(chunk);
                }
            }
        }
        // Drained, or a same-second wall the pager can't step past (second-granular
        // until) — either way stop; the accumulated set is what advance_scope folds.
        if fresh == 0 || wraps.len() < REKEY_PAGE {
            break;
        }
        match oldest {
            Some(o) if o > 0 => until = Some(o),
            _ => break,
        }
    }
    Ok(out)
}

/// Decide how a scope advances from per-addressing-root chunk batches (pure). Each
/// batch pairs the chunks fetched under one root with the continuity to demand of
/// them: a rotation qualifies when it's rotator-authorized (`rotator_ok`),
/// complete, targets the immediate `next_epoch`, and — when I hold a chain —
/// extends my exact `(epoch, key)`. A KEYLESS batch (`held` = None) has no chain
/// to extend, so it qualifies on authority + completeness alone (CORD-06 §2:
/// continuity is "a convergence check, not a secrecy mechanism"; the rotator's
/// seal authority is the boundary). Among qualifying rotations carrying my blob
/// the lexicographically lowest new key wins (convergent). All complete
/// candidates without my blob conclude Removed for a KEYED holder only when one
/// came from a rotator who may remove ME (`rotator_may_remove_me`, the CORD-06
/// strict-outrank rule) — else Stay; for a keyless holder they merely advance the
/// scan cursor (any bit-holder's real rotation is scan progress, never a loss).
async fn advance_scope<S: crate::signer::VectorSigner + ?Sized>(
    batches: &[(Vec<rekey::RekeyChunk>, Option<(Epoch, [u8; 32])>)],
    scope: RekeyScope,
    rotator_ok: &(dyn Fn(&PublicKey) -> bool + Sync),
    rotator_may_remove_me: &(dyn Fn(&PublicKey) -> bool + Sync),
    admissible: &(dyn Fn(&rekey::Rotation) -> bool + Sync),
    signer: &S,
    my_xonly: &[u8; 32],
    next_epoch: Epoch,
) -> Advance {
    let mut winners: Vec<[u8; 32]> = Vec::new();
    let mut saw_complete_candidate = false;
    let mut saw_outranking_candidate = false;
    let keyed = batches.iter().any(|(_, held)| held.is_some());
    for (chunks, held) in batches {
        let rotations = rekey::collect_rotations(chunks);
        for r in &rotations {
            if !rotator_ok(&r.rotator) || r.scope.id32() != scope.id32() || r.new_epoch.0 != next_epoch.0 || !r.is_complete() {
                continue;
            }
            if let Some((held_epoch, held_key)) = held {
                if r.continuity(*held_epoch, held_key) != Continuity::Extends {
                    continue;
                }
            }
            // CORD-06 §Authority: a rotator must strictly OUTRANK every removed
            // target. An authorized-but-inadmissible rotation (one that excludes
            // the owner or a peer/superior the rotator can't act on) is a takeover
            // attempt — skip it entirely, so it neither adopts nor concludes a
            // removal (it forks; the honest chain wins).
            if !admissible(r) {
                continue;
            }
            saw_complete_candidate = true;
            saw_outranking_candidate |= rotator_may_remove_me(&r.rotator);
            if let Some(blob) = rekey::find_my_blob(&r.blobs, &r.rotator.to_bytes(), my_xonly, r.scope, r.new_epoch) {
                if let Ok(k) = rekey::open_blob(signer, &r.rotator, r.scope, r.new_epoch, blob).await {
                    winners.push(k);
                }
            }
        }
    }
    if !winners.is_empty() {
        // `collect_rotations` correlates on `(rotator, scope, new_epoch, prev_commit)`,
        // so a single rotator's blobs merge into ONE rotation (and a retried Refounding
        // MINT-OR-REUSES its root, so it never emits two distinct roots to fork on).
        // The lowest-key tiebreak engages only for CONCURRENT DISTINCT rotators racing
        // the same epoch (separate rotations): every follower converges on the same
        // lowest new key. A wrap served under two addressing roots can't double-count:
        // each rekey wrap opens under exactly one root's group key.
        let idx = rekey::lowest_key_winner(&winners).expect("winners is non-empty");
        return Advance::Adopt { new_key: winners[idx] };
    }
    if saw_complete_candidate && (!keyed || saw_outranking_candidate) {
        Advance::Removed
    } else {
        Advance::Stay
    }
}

#[cfg(test)]
mod tests {
    use crate::ClientRelayExt;
    use nostr_sdk::prelude::FinalizeEvent;
    use super::super::super::transport::memory::MemoryRelay;
    use super::*;
    use crate::community::roles::{MemberGrant, Permissions, Role, RoleScope};

    /// A distinct npub-shaped account-dir name (bech32 charset) per counter.
    fn account_name(n: u32) -> String {
        const B: &[u8] = b"qpzry9x8gf2tvdw0s3jn54khce6mua7l";
        let mut acct = String::from("npub1");
        let mut v = n as usize;
        for _ in 0..58 {
            acct.push(B[v % 32] as char);
            v = v / 32 + 7;
        }
        acct
    }

    /// One test participant: its identity keys and its isolated account DB dir.
    struct Actor {
        keys: Keys,
        account: String,
    }

    /// Two participants sharing one relay but isolated per-account DBs — the
    /// cross-account harness a real invite/join loop needs. `swap_to` mirrors a
    /// live `swap_session`: re-point the DB pool + rebind the identity + clear
    /// the per-account id caches, so account A's community is invisible to B
    /// until B legitimately joins.
    struct TestBed {
        _tmp: tempfile::TempDir,
        _guard: std::sync::MutexGuard<'static, ()>,
        relay: MemoryRelay,
        relays: Vec<String>,
    }

    impl TestBed {
        fn new() -> (TestBed, Actor, Actor) {
            static N: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(70_000);
            let guard = crate::db::DB_TEST_GUARD.lock().unwrap_or_else(|e| e.into_inner());
            crate::db::close_database();
            crate::db::clear_id_caches();
            let tmp = tempfile::tempdir().unwrap();
            crate::db::set_app_data_dir(tmp.path().to_path_buf());

            let mk = || {
                let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                let account = account_name(n);
                std::fs::create_dir_all(tmp.path().join(&account)).unwrap();
                crate::db::set_current_account(account.clone()).unwrap();
                crate::db::init_database(&account).unwrap();
                Actor { keys: Keys::generate(), account }
            };
            let owner = mk();
            let member = mk();
            let _ = crate::state::take_nostr_client();
            let bed = TestBed {
                _tmp: tmp,
                _guard: guard,
                relay: MemoryRelay::new(),
                relays: vec!["wss://r".to_string()],
            };
            (bed, owner, member)
        }

        /// Become `actor`: swap the account DB + identity, as a real session swap.
        /// Bumps the session generation like production `swap_session` does — so any task a
        /// prior actor spawned (e.g. the migration finalize) dies at its SessionGuard check
        /// instead of racing this actor's DB (a cross-test flake that can't happen in prod).
        fn swap_to(&self, actor: &Actor) {
            crate::state::bump_session_generation();
            crate::db::set_current_account(actor.account.clone()).unwrap();
            crate::db::init_database(&actor.account).unwrap();
            crate::db::clear_id_caches();
            crate::state::MY_SECRET_KEY.store_from_keys(&actor.keys, &[]);
            crate::state::set_my_public_key(actor.keys.public_key());
        }
    }

    /// Legacy single-actor helper (the create/send tests below).
    fn init_test_db() -> (tempfile::TempDir, std::sync::MutexGuard<'static, ()>, Keys) {
        let guard = crate::db::DB_TEST_GUARD.lock().unwrap_or_else(|e| e.into_inner());
        crate::db::close_database();
        crate::db::clear_id_caches();
        let tmp = tempfile::tempdir().unwrap();
        static N: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(50_000);
        let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        let acct = account_name(n);
        std::fs::create_dir_all(tmp.path().join(&acct)).unwrap();
        crate::db::set_app_data_dir(tmp.path().to_path_buf());
        crate::db::set_current_account(acct.clone()).unwrap();
        crate::db::init_database(&acct).unwrap();
        let _ = crate::state::take_nostr_client();
        let owner = Keys::generate();
        crate::state::MY_SECRET_KEY.store_from_keys(&owner, &[]);
        crate::state::set_my_public_key(owner.public_key());
        (tmp, guard, owner)
    }

    /// A transport that simulates a session swap landing DURING a fetch await —
    /// so a join straddling the fetch sees an invalid session and aborts.
    struct SwapMidFetch {
        inner: MemoryRelay,
    }
    #[async_trait::async_trait]
    impl Transport for SwapMidFetch {
        async fn fetch_plane(&self, _plane: &Keys, query: &Query, relays: &[String]) -> Result<Vec<Event>, String> { self.fetch(query, relays).await }
        async fn publish(&self, e: &Event, r: &[String]) -> Result<(), String> {
            self.inner.publish(e, r).await
        }
        async fn publish_durable(&self, e: &Event, r: &[String]) -> Result<(), String> {
            self.inner.publish_durable(e, r).await
        }
        async fn fetch(&self, q: &Query, r: &[String]) -> Result<Vec<Event>, String> {
            let out = self.inner.fetch(q, r).await;
            crate::state::bump_session_generation();
            out
        }
    }

    /// Bumps the session generation on the first `publish_durable` — the rekey
    /// crate a private-channel create ships before it writes anything locally.
    struct SwapMidPublish {
        inner: MemoryRelay,
    }
    #[async_trait::async_trait]
    impl Transport for SwapMidPublish {
        async fn fetch_plane(&self, _plane: &Keys, query: &Query, relays: &[String]) -> Result<Vec<Event>, String> { self.fetch(query, relays).await }
        async fn publish(&self, e: &Event, r: &[String]) -> Result<(), String> {
            self.inner.publish(e, r).await
        }
        async fn publish_durable(&self, e: &Event, r: &[String]) -> Result<(), String> {
            let out = self.inner.publish_durable(e, r).await;
            crate::state::bump_session_generation();
            out
        }
        async fn fetch(&self, q: &Query, r: &[String]) -> Result<Vec<Event>, String> {
            self.inner.fetch(q, r).await
        }
    }

    /// A transport whose `fetch` returns a FIXED, UNSORTED event list — modelling
    /// the production `LiveTransport` union (first-responding relay's batch, no
    /// global newest-first sort), which `MemoryRelay` hides by sorting. This is
    /// the only harness that can exercise the revocation-race ordering.
    struct FixedFetch {
        events: Vec<Event>,
    }
    #[async_trait::async_trait]
    impl Transport for FixedFetch {
        async fn fetch_plane(&self, _plane: &Keys, query: &Query, relays: &[String]) -> Result<Vec<Event>, String> { self.fetch(query, relays).await }
        async fn publish(&self, _e: &Event, _r: &[String]) -> Result<(), String> {
            Ok(())
        }
        async fn publish_durable(&self, _e: &Event, _r: &[String]) -> Result<(), String> {
            Ok(())
        }
        async fn fetch(&self, _q: &Query, _r: &[String]) -> Result<Vec<Event>, String> {
            Ok(self.events.clone())
        }
    }

    /// Fetch a pending Direct Invite (kind 3313 giftwrap) addressed to `me` — the
    /// indexed inbox query CORD-05 §6 defines: `{1059, #p:[me], #k:["3313"]}`.
    async fn fetch_direct_invite(relay: &MemoryRelay, relays: &[String], me: &PublicKey) -> Event {
        let q = Query {
            kinds: vec![stream::KIND_WRAP],
            p_tags: vec![me.to_hex()],
            k_tags: vec!["3313".to_string()],
            ..Default::default()
        };
        relay.fetch(&q, relays).await.unwrap().into_iter().next().expect("a direct invite is waiting")
    }

    #[tokio::test]
    async fn create_persists_and_reloads_a_v2_community() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let relays = vec!["wss://r".to_string()];

        let created = create_community(&relay, "Vectorville", relays.clone(), Some("hi".into())).await.unwrap();
        assert!(created.identity.verify());
        assert_eq!(created.owner().unwrap(), owner.public_key());
        assert_eq!(created.channels.len(), 1);

        // Protocol dispatch sees it as v2, and it reloads byte-faithfully.
        assert_eq!(
            crate::db::community::community_protocol(created.id()).unwrap(),
            Some(crate::community::ConcordProtocol::V2)
        );
        let loaded = crate::db::community::load_community_v2(created.id()).unwrap().expect("reloads");
        assert_eq!(loaded.name, "Vectorville");
        assert_eq!(loaded.community_root, created.community_root);
        assert_eq!(loaded.identity, created.identity);
        assert_eq!(loaded.channels[0].id.0, created.channels[0].id.0);
        assert!(!loaded.channels[0].private);

        // The genesis control editions + the owner Join landed on the relay.
        assert!(relay.count_on("wss://r") >= 3, "2 genesis editions + 1 guestbook join");
    }

    #[tokio::test]
    async fn owner_sends_and_reads_back_a_message() {
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Chat", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;

        let id1 = send_message(&relay, &community, &general, "hello world").await.unwrap();
        let id2 = send_message(&relay, &community, &general, "second message").await.unwrap();
        assert_ne!(id1, id2);

        let page = fetch_channel(&relay, &community, &general, 100).await.unwrap();
        let texts: Vec<String> = page
            .iter()
            .filter_map(|f| match &f.event {
                ChatEvent::Message { .. } => Some(f.event.opened().rumor.content.clone()),
                _ => None,
            })
            .collect();
        assert_eq!(texts, vec!["hello world", "second message"], "messages round-trip in ms order");
    }

    #[tokio::test]
    async fn a_second_member_reads_the_public_channel_from_the_root() {
        // A member who holds the community_root (via an invite bundle, modeled
        // here by cloning the community) reads the owner's public-channel message
        // — public channels need no key delivery, they derive from the root.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Public", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        send_message(&relay, &community, &general, "everyone can read this").await.unwrap();

        // The "member" reconstructs the same read coordinates from the root.
        let member_view = community.clone();
        let page = fetch_channel(&relay, &member_view, &general, 100).await.unwrap();
        assert_eq!(page.len(), 1);
        assert!(matches!(&page[0].event, ChatEvent::Message { .. }));
        assert_eq!(page[0].event.opened().rumor.content, "everyone can read this");
    }

    // ── Two-actor end-to-end (the create → invite → join → message loop) ──────

    async fn texts_in<T: crate::community::transport::Transport + ?Sized>(relay: &T, community: &CommunityV2, channel: &ChannelId) -> Vec<String> {
        fetch_channel(relay, community, channel, 100)
            .await
            .unwrap()
            .iter()
            .filter_map(|f| match &f.event {
                ChatEvent::Message { .. } => Some(f.event.opened().rumor.content.clone()),
                _ => None,
            })
            .collect()
    }

    #[tokio::test]
    async fn direct_invite_full_loop_owner_and_member_converse() {
        let (bed, owner, member) = TestBed::new();

        // Owner creates a community, posts, and Direct-Invites the member's npub.
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Guild", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        send_message(&bed.relay, &community, &general, "owner: welcome!").await.unwrap();
        send_direct_invite(&bed.relay, &community, &member.keys.public_key(), None, None).await.unwrap();

        // Member (a DIFFERENT account, no prior knowledge) finds + accepts the invite.
        bed.swap_to(&member);
        assert!(
            crate::db::community::load_community_v2(community.id()).unwrap().is_none(),
            "the member does not hold the community before joining"
        );
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let joined = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap();
        assert_eq!(joined.id().0, community.id().0, "joined the same community");
        assert!(joined.identity.verify(), "the joiner independently verifies the owner commitment");
        assert_eq!(joined.owner().unwrap(), owner.keys.public_key());

        // The member reads the owner's public-channel history and replies.
        assert_eq!(texts_in(&bed.relay, &joined, &general).await, vec!["owner: welcome!"]);
        send_message(&bed.relay, &joined, &general, "member: thanks for the invite").await.unwrap();

        // The owner reads the member's reply.
        bed.swap_to(&owner);
        assert_eq!(
            texts_in(&bed.relay, &community, &general).await,
            vec!["owner: welcome!", "member: thanks for the invite"],
            "both actors' messages interleave in ms order on the shared channel"
        );

        // The Guestbook memberlist now folds both participants.
        let members = memberlist(&bed.relay, &community).await.unwrap();
        assert!(members.contains(&owner.keys.public_key()), "owner is a member (genesis Join)");
        assert!(members.contains(&member.keys.public_key()), "member is a member (invite Join)");
        assert_eq!(members.len(), 2);
    }

    /// Join-time ban gate: an honest client whose npub is on the authorized banlist
    /// refuses to join — no Guestbook Join publish, no local write — through the shared
    /// accept path every door (direct invite, parked, public link, migration) funnels into.
    #[tokio::test]
    async fn a_banned_member_is_refused_at_join_time() {
        let (bed, owner, member) = TestBed::new();

        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "NoEntry", bed.relays.clone(), None).await.unwrap();
        send_direct_invite(&bed.relay, &community, &member.keys.public_key(), None, None).await.unwrap();
        set_banlist(&bed.relay, &community, &[member.keys.public_key().to_hex()]).await.unwrap();

        bed.swap_to(&member);
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let err = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap_err();
        assert!(err.contains("banned"), "refusal names the reason: {err}");
        assert!(
            crate::db::community::load_community_v2(community.id()).unwrap().is_none(),
            "a refused join persists nothing"
        );

        // The gate is the LAST word only for banned members: an unbanned bystander with
        // the same invite path still joins (the gate doesn't over-refuse).
        bed.swap_to(&owner);
        set_banlist(&bed.relay, &community, &[]).await.unwrap();
        bed.swap_to(&member);
        let joined = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap();
        assert_eq!(joined.id().0, community.id().0, "unban restores joinability");
    }

    /// End-to-end member migration: a member holding a v1 community folds the owner's
    /// migration dissolution, opens `m`, joins the v2 twin (ban-gated), and the flip
    /// re-parents the stitched channel rows + stamps the fence — all from the single event.
    #[tokio::test]
    async fn member_migrates_v1_to_v2_from_the_dissolution_payload() {
        use crate::community::migration;
        let (bed, owner, member) = TestBed::new();

        // Owner builds the v2 twin (real, verifiable on the shared relay).
        bed.swap_to(&owner);
        let v2 = create_community(&bed.relay, "Guild v2", bed.relays.clone(), None).await.unwrap();
        let v2_hex = crate::simd::hex::bytes_to_hex_32(&v2.identity.community_id.0);
        let jm = join_material(&v2);

        // The member holds a v1 community owned by the SAME owner identity (the migration
        // premise) — construct + save it, and hold its server root.
        bed.swap_to(&member);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        let v1_cid = v1.id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();
        let v1_channel = v1.channels[0].id.to_hex();

        // The dissolution payload: v2 JoinMaterial sealed under the v1 server root.
        let m = migration::seal_m(v1.server_root_key.as_bytes(), &serde_json::to_vec(&jm).unwrap()).unwrap();
        let signpost = migration::MigrationSignpost {
            v2_community_id: v2_hex.clone(),
            owner_xonly: owner.keys.public_key().to_hex(),
            owner_salt: crate::simd::hex::bytes_to_hex_32(&v2.identity.owner_salt),
            relays: bed.relays.clone(),
            name: "Guild".into(),
            primary_channel: v1_channel.clone(),
            root_epoch: 0,
        };
        let content = migration::build_migration_content(&signpost, Some(m)).unwrap();
        crate::db::community::set_migration_pointer(&v1_cid, &content).unwrap();

        // Drive the migration: opens m, joins v2 (ban-gated), flips.
        let flipped = migration::drive_migration(&bed.relay, &v1).await.unwrap();
        assert_eq!(flipped.as_deref(), Some(v2_hex.as_str()), "the flip completed to the v2 twin");

        // Fence: the v1 community is terminally marked, and the v2 twin is held + joined.
        assert_eq!(crate::db::community::get_migrated_to(&v1_cid).unwrap().as_deref(), Some(v2_hex.as_str()));
        assert!(crate::db::community::get_community_dissolved(&v1_cid).unwrap(), "flip also seals v1 (fence layer 0)");
        assert!(crate::db::community::load_community_v2(&v2.identity.community_id).unwrap().is_some(), "v2 twin held");
        let _ = v1_channel;

        // Idempotent: a second drive is a no-op (already flipped).
        assert_eq!(migration::drive_migration(&bed.relay, &v1).await.unwrap(), None);
    }

    /// The OWNER wizard end-to-end: build the twin (primary channel reuses the v1 id),
    /// seal + publish the carrier, flip the owner. Then a MEMBER holding the v1 community
    /// folds the same carrier and stitches — proving the channel-STITCH the earlier test
    /// couldn't (that twin had mismatched ids).
    #[tokio::test]
    async fn owner_wizard_then_member_migrate_and_stitch() {
        use crate::community::migration;
        let (bed, owner, member) = TestBed::new();
        let unlocked = migration::MIGRATION_UNLOCK_AT + 1;

        // Owner holds a v1 community (they created it) with one channel.
        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        let v1_cid = v1.id.to_hex();
        let v1_channel = v1.channels[0].id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();

        // Run the wizard.
        let v2_hex = migration::migrate_community_to_v2(&bed.relay, &v1, unlocked).await.unwrap();
        assert_eq!(crate::db::community::get_migrated_to(&v1_cid).unwrap().as_deref(), Some(v2_hex.as_str()),
            "owner's own client flipped to v2");
        // The owner's v1 channel row re-parented to the twin (stitch), because the twin's
        // primary channel REUSES the v1 channel id.
        assert_eq!(crate::db::community::community_id_for_channel(&v1_channel).unwrap().as_deref(), Some(v2_hex.as_str()),
            "owner channel stitched to v2");

        // A MEMBER holding the same v1 community folds the carrier and migrates.
        bed.swap_to(&member);
        let mut m_v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        // The member's v1 community must be the SAME id + root the owner published under.
        m_v1.id = v1.id;
        m_v1.server_root_key = v1.server_root_key.clone();
        m_v1.channels[0].id = v1.channels[0].id;
        m_v1.owner_attestation = v1.owner_attestation.clone();
        crate::db::community::save_community(&m_v1).unwrap();

        // Fold the carrier off the relay: the dissolution arm seals, persists the pointer,
        // AND auto-drives the flip — the live one-event member experience, no manual step.
        crate::community::service::fetch_and_apply_control(&bed.relay, &m_v1).await.unwrap();
        assert!(crate::db::community::get_community_dissolved(&v1_cid).unwrap(), "member sees v1 sealed");
        assert_eq!(crate::db::community::get_migrated_to(&v1_cid).unwrap().as_deref(), Some(v2_hex.as_str()),
            "the FOLD ITSELF flipped the member (auto-drive)");
        assert!(crate::db::community::load_community_v2(&crate::community::CommunityId(crate::simd::hex::hex_to_bytes_32(&v2_hex))).unwrap().is_some(),
            "member holds the v2 twin");
        // A manual re-drive is an idempotent no-op.
        assert_eq!(migration::drive_migration(&bed.relay, &m_v1).await.unwrap(), None);
    }

    /// The wizard records the twin in the cross-device community list, like every other v2
    /// join/create path. Sibling devices normally discover the twin by folding the carrier
    /// themselves, but one that no longer holds the v1 community has no carrier to fold, so
    /// the list is its only route in.
    #[tokio::test]
    async fn wizard_publishes_the_twin_to_the_cross_device_list() {
        use crate::community::migration;
        let (bed, owner, _member) = TestBed::new();
        let unlocked = migration::MIGRATION_UNLOCK_AT + 1;

        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        let v1_cid = v1.id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();

        let v2_hex = migration::migrate_community_to_v2(&bed.relay, &v1, unlocked).await.unwrap();

        // The twin is live in the published list, so a fresh/carrier-less device finds it.
        let list = fetch_community_list(&bed.relay, &bed.relays).await.unwrap()
            .expect("the wizard published a community list");
        assert!(list.is_live(&v2_hex), "the twin must be live in the cross-device list");
        // The v1 community is NOT tombstoned there: a tombstone reads as "you left" and
        // `sync_community_list` would tear down a sibling's v1 row before it can fold the
        // carrier, stranding it. The local `migrated_to` fence is what stops v1 ghosts.
        assert!(
            !list.tombstones.iter().any(|t| t.community_id == v1_cid),
            "migration must not tombstone the v1 community"
        );
    }

    /// The wizard takes the same per-cid claim the member drive does, so a double-fired
    /// command (or the owner's own carrier self-fold racing the wizard's phase 2→3 gap)
    /// cannot run two wizards: the second would re-mint a twin before the ledger lands
    /// (the double-mint orphan) and race its flip against the first.
    #[tokio::test]
    async fn wizard_refuses_while_a_drive_holds_the_claim() {
        use crate::community::migration;
        let (bed, owner, _member) = TestBed::new();
        let unlocked = migration::MIGRATION_UNLOCK_AT + 1;

        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        let v1_cid = v1.id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();

        // Simulate the concurrent drive holding the cid (what the live carrier fold does).
        migration::test_hold_drive_claim(&v1_cid);
        let err = migration::migrate_community_to_v2(&bed.relay, &v1, unlocked).await.unwrap_err();
        assert!(err.contains("already in progress"), "second wizard refused, got: {err}");
        // Refused BEFORE minting: no twin, no ledger, nothing to orphan.
        assert!(crate::db::community::get_migration_ledger(&v1_cid).unwrap().is_none(), "no ledger row was written");
        assert!(crate::db::community::get_migrated_to(&v1_cid).unwrap().is_none(), "no flip happened");

        // Once the drive releases, the wizard runs normally.
        migration::test_release_drive_claim(&v1_cid);
        let v2_hex = migration::migrate_community_to_v2(&bed.relay, &v1, unlocked).await.unwrap();
        assert_eq!(crate::db::community::get_migrated_to(&v1_cid).unwrap().as_deref(), Some(v2_hex.as_str()));
    }

    /// The flip runs UNDER the twin's follow lock, so it can never straddle a follow
    /// worker's whole-row save (which deletes channel rows absent from its pre-flip,
    /// channel-less struct — pruning exactly the rows the flip just re-parented).
    /// Proves the lock actually serializes rather than being a no-op: with the lock held
    /// the wizard cannot reach its flip, and it completes once released.
    #[tokio::test]
    async fn wizard_flip_waits_for_an_in_flight_follow_pass() {
        use crate::community::migration;
        let (bed, owner, _member) = TestBed::new();
        let unlocked = migration::MIGRATION_UNLOCK_AT + 1;
        // Shared across the spawned wizard, so both halves see the same relay state.
        let relay = std::sync::Arc::new(MemoryRelay::new());

        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        let v1_cid = v1.id.to_hex();
        let v1_channel = v1.channels[0].id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();

        // Phase 1 alone, so the twin's id (and therefore its follow lock) is known before
        // the flip runs — exactly what a follow worker would have loaded.
        let twin = create_migration_twin(
            &*relay, "Guild", bed.relays.clone(), None,
            (v1.channels[0].id, "general".to_string()),
        ).await.unwrap();
        let v2_id = twin.identity.community_id;
        let v2_hex = crate::simd::hex::bytes_to_hex_32(&v2_id.0);
        crate::db::community::set_migration_ledger(&v1_cid, &v2_hex, migration::PHASE_TWIN_MINTED, "").unwrap();

        // A follow pass is in flight: it holds the lock across its network stage.
        let held = crate::community::v2::realtime::follow_lock(&v2_id).lock_owned().await;

        let wizard = tokio::spawn({
            let relay = relay.clone();
            let v1 = v1.clone();
            async move { migration::migrate_community_to_v2(&*relay, &v1, unlocked).await }
        });

        // The wizard runs its network phases but must BLOCK at the flip.
        tokio::time::sleep(std::time::Duration::from_millis(300)).await;
        assert!(!wizard.is_finished(), "the flip must wait for the in-flight follow pass");
        assert!(
            crate::db::community::get_migrated_to(&v1_cid).unwrap().is_none(),
            "the fence must not be stamped while the follow lock is held"
        );

        // The follow pass finishes; the flip proceeds.
        drop(held);
        let flipped = wizard.await.unwrap().unwrap();
        assert_eq!(flipped, v2_hex, "the wizard completed onto the SAME twin (resumed, never re-minted)");
        assert_eq!(
            crate::db::community::community_id_for_channel(&v1_channel).unwrap().as_deref(),
            Some(v2_hex.as_str()),
            "the channel row is stitched to the twin, not pruned"
        );
    }

    /// THE LYNCHPIN: a banned-but-never-cut v1 member CAN open `m` (they hold the v1
    /// root — no read-cut ever rotated it), but the wizard cloned the v1 banlist onto the
    /// twin, so the ban-gated accept refuses them: no Guestbook Join, no flip, room stays
    /// sealed. This is the exact residual JSKitty accepted, proven enforced.
    #[tokio::test]
    async fn banned_never_cut_member_opens_m_but_cannot_migrate() {
        use crate::community::migration;
        let (bed, owner, banned) = TestBed::new();
        let unlocked = migration::MIGRATION_UNLOCK_AT + 1;

        // Owner's v1 community with the member on the BANLIST (never read-cut: epoch 0).
        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        let v1_cid = v1.id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();
        crate::db::community::set_community_banlist(&v1_cid, &[banned.keys.public_key().to_hex()], 1_000).unwrap();

        let v2_hex = migration::migrate_community_to_v2(&bed.relay, &v1, unlocked).await.unwrap();

        // The banned member holds the same v1 (same root — never cut) and folds the carrier.
        bed.swap_to(&banned);
        let mut m_v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        m_v1.id = v1.id;
        m_v1.server_root_key = v1.server_root_key.clone();
        m_v1.channels[0].id = v1.channels[0].id;
        m_v1.owner_attestation = v1.owner_attestation.clone();
        crate::db::community::save_community(&m_v1).unwrap();
        crate::community::service::fetch_and_apply_control(&bed.relay, &m_v1).await.unwrap();

        // They hold the pointer AND can open `m` — but the drive is REFUSED at the ban gate.
        let raw = crate::db::community::get_migration_pointer(&v1_cid).unwrap().expect("pointer lands");
        let payload = migration::parse_migration_payload(&raw).unwrap();
        assert!(payload.m.is_some());
        let err = migration::drive_migration(&bed.relay, &m_v1).await.unwrap_err();
        assert!(err.contains("banned"), "refused at the join-time ban gate: {err}");
        assert!(crate::db::community::get_migrated_to(&v1_cid).unwrap().is_none(), "no flip");
        assert!(
            crate::db::community::load_community_v2(&crate::community::CommunityId(crate::simd::hex::hex_to_bytes_32(&v2_hex))).unwrap().is_none(),
            "banned member never acquires the v2 twin"
        );
    }

    /// Wizard resume never double-mints: a re-run after the TWIN_MINTED ledger row exists
    /// completes on the SAME v2 identity — with a NON-vacuous phase-1b re-run (a sibling
    /// channel + a banlist entry crash-recovered end-to-end, sibling stitched). Plus the
    /// crash-heal: flip landed but the FLIPPED ledger write didn't → re-run reports success.
    #[tokio::test]
    async fn wizard_resume_continues_on_the_same_twin() {
        use crate::community::migration;
        let (bed, owner, banned) = TestBed::new();
        let unlocked = migration::MIGRATION_UNLOCK_AT + 1;

        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        // A second channel + a banned member make the resumed phase-1b tail REAL work.
        let mut sibling = v1.channels[0].clone();
        sibling.id = crate::community::ChannelId(crate::community::random_32());
        sibling.name = "offtopic".into();
        v1.channels.push(sibling.clone());
        let v1_cid = v1.id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();
        crate::db::community::set_community_banlist(&v1_cid, &[banned.keys.public_key().to_hex()], 1_000).unwrap();

        // Simulate a crash right after the mint: build the twin + ledger TWIN_MINTED, stop
        // BEFORE the sibling channel + banlist clone ever ran.
        let twin = create_migration_twin(&bed.relay, &v1.name, bed.relays.clone(), None, (v1.channels[0].id, "general".into())).await.unwrap();
        let minted_hex = crate::simd::hex::bytes_to_hex_32(&twin.identity.community_id.0);
        crate::db::community::set_migration_ledger(&v1_cid, &minted_hex, migration::PHASE_TWIN_MINTED, "").unwrap();

        // The re-run resumes onto the SAME identity, re-runs 1b, and completes.
        let v2_hex = migration::migrate_community_to_v2(&bed.relay, &v1, unlocked).await.unwrap();
        assert_eq!(v2_hex, minted_hex, "no second twin was minted");
        let (ledger_v2, phase, _) = crate::db::community::get_migration_ledger(&v1_cid).unwrap().unwrap();
        assert_eq!(ledger_v2, minted_hex);
        assert_eq!(phase, migration::PHASE_FLIPPED);
        // The crash-recovered sibling stitched too, and the banlist clone landed on the wire
        // (folding the twin's control plane yields the banned npub).
        assert_eq!(
            crate::db::community::community_id_for_channel(&sibling.id.to_hex()).unwrap().as_deref(),
            Some(minted_hex.as_str()),
            "sibling channel re-parented by the resumed run"
        );
        let twin_reloaded = crate::db::community::load_community_v2(&twin.identity.community_id).unwrap().unwrap();
        let (_, _, wire_banlist) = verify_owner_root_and_reconcile(&bed.relay, twin_reloaded.clone())
            .await
            .map(|(c, h, b)| (c, h, b))
            .unwrap();
        assert!(wire_banlist.contains(&banned.keys.public_key().to_hex()),
            "the resumed banlist clone is folded from the twin's wire control plane");

        // Crash-heal: roll the ledger back to CARRIER_PUBLISHED (flip landed, ledger behind)
        // → the re-run reports SUCCESS and heals, never "already been migrated".
        crate::db::community::set_migration_ledger(&v1_cid, &minted_hex, migration::PHASE_CARRIER_PUBLISHED, "").unwrap();
        let healed = migration::migrate_community_to_v2(&bed.relay, &v1, unlocked).await.unwrap();
        assert_eq!(healed, minted_hex);
        let (_, phase, _) = crate::db::community::get_migration_ledger(&v1_cid).unwrap().unwrap();
        assert_eq!(phase, migration::PHASE_FLIPPED, "ledger healed to FLIPPED");

        // Resume past a SELF-SEAL: a fold sealed the community after the carrier but
        // before the flip write (dissolved=1, migrated_to still NULL, ledger at
        // CARRIER_PUBLISHED). A wizard resume must NOT read this as a foreign dissolution.
        // Reuse THIS bed (a second TestBed would re-lock DB_TEST_GUARD and deadlock) with a
        // fresh v1 owned by the same owner.
        let mut v1b = crate::community::Community::create("Guild2", "general", bed.relays.clone());
        let v1b_cid = v1b.id.to_hex();
        v1b.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1b_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1b).unwrap();
        let twin2 = create_migration_twin(&bed.relay, &v1b.name, bed.relays.clone(), None, (v1b.channels[0].id, "general".into())).await.unwrap();
        let twin2_hex = crate::simd::hex::bytes_to_hex_32(&twin2.identity.community_id.0);
        crate::db::community::set_migration_ledger(&v1b_cid, &twin2_hex, migration::PHASE_CARRIER_PUBLISHED, "").unwrap();
        crate::db::community::set_community_dissolved(&v1b_cid).unwrap(); // the self-seal
        let resumed = migration::migrate_community_to_v2(&bed.relay, &v1b, unlocked).await.unwrap();
        assert_eq!(resumed, twin2_hex, "resume past a self-seal completes, not false-terminal");
        assert_eq!(crate::db::community::get_migrated_to(&v1b_cid).unwrap().as_deref(), Some(twin2_hex.as_str()));
    }

    /// The birth refound SEEDS the roster: rolling a genesis (epoch 0) twin to epoch 1 with an
    /// explicit member list makes those members fold into the memberlist WITHOUT any of them
    /// publishing a Join — the anti-ghost-town seed for not-yet-migrated v1 members (who hold
    /// no v2 keys). Genesis had no snapshot power; epoch 1 (owner = minting refounder) does.
    #[tokio::test]
    async fn birth_refound_seeds_an_explicit_roster() {
        let (bed, owner, _m) = TestBed::new();
        bed.swap_to(&owner);
        let twin = create_migration_twin(&bed.relay, "Guild", bed.relays.clone(), None,
            (ChannelId(crate::community::random_32()), "general".into())).await.unwrap();
        assert_eq!(twin.root_epoch, Epoch(0), "twin starts at genesis");
        // Two strangers who never join — pure seeded members.
        let ghost_a = Keys::generate().public_key();
        let ghost_b = Keys::generate().public_key();

        let rolled = refound_at_birth(&bed.relay, &twin, &[owner.keys.public_key(), ghost_a, ghost_b]).await.unwrap();
        assert_eq!(rolled.root_epoch, Epoch(1), "birth refound advanced the twin to epoch 1");

        // The memberlist folds all three from the epoch-1 snapshot, though only the owner
        // ever published a Join.
        let members = memberlist(&bed.relay, &rolled).await.unwrap();
        assert!(members.contains(&owner.keys.public_key()), "owner in the roster");
        assert!(members.contains(&ghost_a) && members.contains(&ghost_b), "never-joined members are seeded (no ghost town)");

        // The compacted control plane still verifies (owner genesis carried to epoch 1) — a
        // fresh joiner at epoch 1 folds it. And a genesis-epoch snapshot has NO power: rolling
        // a fresh twin's snapshot only counts because the owner minted epoch 1.
        let (_, _, _banlist) = verify_owner_root_and_reconcile(&bed.relay, rolled.clone()).await
            .expect("the epoch-1 twin verifies from its compacted control plane");

        // RESUME IDEMPOTENCE: a re-call on the already-refounded twin is a no-op (returns
        // epoch 1), never a double-advance to epoch 2 — the crash-between-wire-and-ledger case.
        let again = refound_at_birth(&bed.relay, &rolled, &[owner.keys.public_key(), ghost_a, ghost_b]).await.unwrap();
        assert_eq!(again.root_epoch, Epoch(1), "re-running the birth refound does not advance past epoch 1");
        assert_eq!(crate::db::community::load_community_v2(&twin.identity.community_id).unwrap().unwrap().root_epoch, Epoch(1));
    }

    /// A banned entry in the seed list must NOT wedge the verify-back: fold_members
    /// subtracts the banlist, so a banned seed is never "readable" — the defensive filter drops
    /// it before the snapshot, so the refound still completes instead of aborting forever.
    #[tokio::test]
    async fn birth_refound_ignores_a_banned_seed_entry() {
        let (bed, owner, _m) = TestBed::new();
        bed.swap_to(&owner);
        let twin = create_migration_twin(&bed.relay, "Guild", bed.relays.clone(), None,
            (ChannelId(crate::community::random_32()), "general".into())).await.unwrap();
        let good = Keys::generate().public_key();
        let banned = Keys::generate();
        // Ban `banned` on the twin, then hand refound a seed list that (wrongly) includes them.
        set_banlist(&bed.relay, &twin, &[banned.public_key().to_hex()]).await.unwrap();
        let twin = crate::db::community::load_community_v2(&twin.identity.community_id).unwrap().unwrap();

        let rolled = refound_at_birth(&bed.relay, &twin, &[owner.keys.public_key(), good, banned.public_key()]).await
            .expect("a banned seed entry is filtered, not a permanent verify-back wedge");
        assert_eq!(rolled.root_epoch, Epoch(1));
        let members = memberlist(&bed.relay, &rolled).await.unwrap();
        assert!(members.contains(&good), "the non-banned seed lands");
        assert!(!members.contains(&banned.public_key()), "the banned seed is not a member");
    }

    /// The "late migrator never misses an epoch" property: a SEEDED-but-never-landed
    /// member (in the roster only via the birth snapshot, holding no keys, never posted) is a
    /// RECIPIENT of a subsequent OWNER refound — so a rotation that happens before they migrate
    /// still mints them a rekey blob to walk forward on. Verified by checking the ghost lands
    /// in the refound's memberlist-derived recipient set (they get a base-rekey blob).
    #[tokio::test]
    async fn a_seeded_member_receives_a_later_refound_rekey() {
        let (bed, owner, _m) = TestBed::new();
        bed.swap_to(&owner);
        let twin = create_migration_twin(&bed.relay, "Guild", bed.relays.clone(), None,
            (ChannelId(crate::community::random_32()), "general".into())).await.unwrap();
        let ghost = Keys::generate();
        // Birth refound seeds the ghost (never joins, holds no keys).
        let rolled = refound_at_birth(&bed.relay, &twin, &[owner.keys.public_key(), ghost.public_key()]).await.unwrap();
        assert!(memberlist(&bed.relay, &rolled).await.unwrap().contains(&ghost.public_key()), "ghost is seeded");

        // A later OWNER refound (epoch 1→2) derives its rekey recipients from memberlist(),
        // which folds the snapshot — so the ghost IS a recipient (a base-rekey blob is minted
        // for them by construction) AND is re-snapshotted at epoch 2. Surviving in the epoch-2
        // memberlist proves both: the refound saw them as a member and carried them forward, so
        // a late migrator who opens `m` (epoch 1) can then walk their epoch-2 blob forward.
        let refounded = refound_community(&bed.relay, &rolled, &[]).await.unwrap();
        assert_eq!(refounded.root_epoch, Epoch(2), "the later refound advanced the epoch");
        assert!(
            memberlist(&bed.relay, &refounded).await.unwrap().contains(&ghost.public_key()),
            "a seeded member is a recipient of + re-seeded by a later refound (never misses an epoch)"
        );
    }

    /// Governance survives migration: a v1 ADMIN is re-granted @admin on the twin (holds
    /// MANAGE_ROLES there), while a plain member is not.
    #[tokio::test]
    async fn v1_admin_stays_admin_across_migration() {
        use crate::community::migration;
        use crate::community::roles::{CommunityRoles, MemberGrant, Role};
        let (bed, owner, admin) = TestBed::new();
        let unlocked = migration::MIGRATION_UNLOCK_AT + 1;

        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        let v1_cid = v1.id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();
        // v1 governance: one Admin role, granted to `admin`.
        let admin_role = Role::admin("a1".repeat(32));
        let roles = CommunityRoles {
            roles: vec![admin_role.clone()],
            grants: vec![MemberGrant { member: admin.keys.public_key().to_hex(), role_ids: vec![admin_role.role_id.clone()] }],
        };
        crate::db::community::set_community_roles(&v1_cid, &roles, 1_000).unwrap();

        let v2_hex = migration::migrate_community_to_v2(&bed.relay, &v1, unlocked).await.unwrap();
        let twin = crate::db::community::load_community_v2(&crate::community::CommunityId(crate::simd::hex::hex_to_bytes_32(&v2_hex))).unwrap().unwrap();

        // Fold the twin's authority from the wire: the admin holds MANAGE_ROLES, a stranger doesn't.
        let authority = fetch_authority(&bed.relay, &twin).await;
        assert!(
            authority.roles.is_authorized(&admin.keys.public_key().to_hex(), Some(&owner.keys.public_key().to_hex()), Permissions::MANAGE_ROLES),
            "the v1 admin is an admin on the v2 twin"
        );
        assert!(
            !authority.roles.is_authorized(&Keys::generate().public_key().to_hex(), Some(&owner.keys.public_key().to_hex()), Permissions::MANAGE_ROLES),
            "a non-admin gains no authority"
        );
    }

    /// The sweep converges on a PLAIN dissolution (owner-signed, no payload) but a
    /// non-owner tombstone (member-mintable) must NOT mark it checked — else a partial-relay
    /// probe returning only a stranger's record would permanently stop the sweep before the
    /// owner's real carrier is ever fetched.
    #[tokio::test]
    async fn sweep_marks_checked_only_on_an_owner_tombstone() {
        use crate::community::migration;
        let (bed, owner, stranger) = TestBed::new();

        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        let v1_cid = v1.id.to_hex();
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1_cid)
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();

        // A STRANGER publishes a (payload-less) tombstone at the dissolved coordinate, and
        // the community is locally sealed (as if folded on an old build) but not yet checked.
        let inner = crate::community::roster::build_group_dissolved_edition(&stranger.keys, &v1.id, 500).unwrap();
        let outer = crate::community::roster::seal_dissolved_edition(&Keys::generate(), &inner, &v1.id).unwrap();
        bed.relay.publish_durable(&outer, &bed.relays).await.unwrap();
        crate::db::community::set_community_dissolved(&v1_cid).unwrap();

        // Sweep: the only record is a stranger's → NOT marked checked (still a candidate).
        migration::sweep_dissolved_for_migration(&bed.relay).await;
        assert!(
            crate::db::community::migration_sweep_candidates().unwrap().contains(&v1_cid),
            "a stranger-only probe must not converge the sweep"
        );

        // Now the OWNER publishes a plain dissolution → sweep marks it checked.
        let owner_inner = crate::community::roster::build_group_dissolved_edition(&owner.keys, &v1.id, 600).unwrap();
        let owner_outer = crate::community::roster::seal_dissolved_edition(&Keys::generate(), &owner_inner, &v1.id).unwrap();
        bed.relay.publish_durable(&owner_outer, &bed.relays).await.unwrap();
        migration::sweep_dissolved_for_migration(&bed.relay).await;
        assert!(
            !crate::db::community::migration_sweep_candidates().unwrap().contains(&v1_cid),
            "an owner plain-dissolution converges the sweep"
        );
    }

    /// Wizard preflight refuses before the timelock and for non-owners.
    #[tokio::test]
    async fn wizard_preflight_gates_timelock_and_ownership() {
        use crate::community::migration;
        let (bed, owner, _member) = TestBed::new();
        bed.swap_to(&owner);
        let mut v1 = crate::community::Community::create("Guild", "general", bed.relays.clone());
        v1.owner_attestation = Some({
            crate::community::owner::build_owner_attestation_unsigned(owner.keys.public_key(), &v1.id.to_hex())
                .finalize(&owner.keys).unwrap().as_json()
        });
        crate::db::community::save_community(&v1).unwrap();

        // Before the unlock → refused, nothing published.
        let err = migration::migrate_community_to_v2(&bed.relay, &v1, migration::MIGRATION_UNLOCK_AT - 1).await.unwrap_err();
        assert!(err.contains("not unlocked"), "{err}");
        assert!(crate::db::community::get_migration_ledger(&v1.id.to_hex()).unwrap().is_none(), "no ledger row before unlock");
    }

    #[tokio::test]
    async fn public_link_full_loop() {
        let (bed, owner, member) = TestBed::new();

        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Public Guild", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        send_message(&bed.relay, &community, &general, "come on in").await.unwrap();
        // Mint a shareable link (a non-stock relay so the fragment carries it).
        let link = mint_public_link(&bed.relay, &community, "https://vectorapp.io", None, None).await.unwrap();
        assert!(link.url.starts_with("https://vectorapp.io/invite/"));
        assert!(link.url.contains('#'), "the fragment carries the token");

        // Member joins purely from the URL string.
        bed.swap_to(&member);
        let joined = accept_public_link(&bed.relay, &link.url).await.unwrap();
        assert_eq!(joined.id().0, community.id().0);
        assert_eq!(texts_in(&bed.relay, &joined, &general).await, vec!["come on in"]);
    }

    #[test]
    fn bundle_of_snapshots_the_held_icon() {
        let owner = Keys::generate();
        let g = control::genesis(&owner, control::CommunityMetadata { name: "Logo".into(), ..Default::default() }, 1_000).unwrap();
        let mut c = CommunityV2::from_genesis(&g, "Logo", None, vec!["wss://r".into()], 0);
        let icon = control::ImageRef { url: "https://blossom.example/i".into(), key: "k".into(), nonce: "n".into(), hash: "h".into(), extra: Default::default() };
        c.icon = Some(icon.clone());
        let bundle = bundle_of(&c, BundleAudience::Link, None, None, None);
        assert_eq!(bundle.icon, Some(icon), "a parked invite renders the real logo from the mint-time snapshot");
    }

    #[test]
    fn addressing_roots_fan_current_plus_archived_bounded_and_deduped() {
        // follow_rekeys' fetch fan AND streamauth's plane registration share
        // this. A channel rekey rides the PRIOR root (CORD-06 D2), so the set
        // MUST include archived roots or an AUTH-gated relay never serves the
        // rotation crate → the channel stalls at its old epoch.
        let (_tmp, _guard, _owner) = init_test_db();
        let cur_root = [9u8; 32];
        let cid = crate::community::CommunityId([1u8; 32]);
        let cid_hex = cid.to_hex();

        // No archives yet → just the current root.
        let roots = channel_rekey_addressing_roots(cur_root, &cid_hex);
        assert_eq!(roots, vec![cur_root], "with no archived roots the fan is the current root alone");

        // Archive two prior roots (freshest-first ordering is asserted below).
        crate::db::community::store_epoch_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, 0, &[1u8; 32]).unwrap();
        crate::db::community::store_epoch_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, 1, &[2u8; 32]).unwrap();
        let roots = channel_rekey_addressing_roots(cur_root, &cid_hex);
        assert_eq!(roots[0], cur_root, "current root leads");
        assert!(roots.contains(&[1u8; 32]) && roots.contains(&[2u8; 32]), "both archived roots are in the fan");
        assert_eq!(roots.len(), 3, "current + 2 archived, no dupes");
        // Freshest-archived-first (epoch 1 before epoch 0).
        assert_eq!(roots[1], [2u8; 32], "higher archived epoch is addressed before the lower");

        // A stored root equal to the CURRENT one must not duplicate.
        crate::db::community::store_epoch_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, 2, &cur_root).unwrap();
        let roots = channel_rekey_addressing_roots(cur_root, &cid_hex);
        assert_eq!(roots.iter().filter(|r| **r == cur_root).count(), 1, "the current root is never duplicated");

        // Cap: many archives truncate to MAX_ADDRESSING_ROOTS.
        for e in 3..20u64 {
            crate::db::community::store_epoch_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, e, &[e as u8; 32]).unwrap();
        }
        let roots = channel_rekey_addressing_roots(cur_root, &cid_hex);
        assert_eq!(roots.len(), MAX_ADDRESSING_ROOTS, "the fan is bounded so a relay can't feed an unbounded walk");
    }

    #[tokio::test]
    async fn public_link_preview_shows_live_name_and_icon_without_joining() {
        let (bed, owner, member) = TestBed::new();

        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Soapbox", bed.relays.clone(), None).await.unwrap();
        // The icon lives on the Control Plane, never in the bundle — publish it
        // as a metadata edition so the preview must FOLD to see it.
        let icon = control::ImageRef {
            url: "https://blossom.example/soap".into(),
            key: "k".into(),
            nonce: "n".into(),
            hash: "h".into(),
            extra: Default::default(),
        };
        let mut meta = community.metadata();
        meta.icon = Some(icon.clone());
        edit_community_metadata(&bed.relay, &community, &meta).await.unwrap();
        // An any-host base — the naddr#fragment payload is domain-agnostic.
        let link = mint_public_link(&bed.relay, &community, "https://armada.buzz", None, None).await.unwrap();

        // A NON-member previews: the real name + the live icon, nothing persisted.
        bed.swap_to(&member);
        let preview = preview_public_link(&bed.relay, &link.url).await.unwrap();
        assert_eq!(preview.name, "Soapbox");
        assert_eq!(preview.icon, Some(icon), "the icon folds from the live Control Plane, not the bundle");
        assert!(
            crate::db::community::load_community_v2(preview.id()).unwrap().is_none(),
            "previewing must not persist a membership"
        );
    }

    #[tokio::test]
    async fn a_previewed_join_reuses_the_verified_fold() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "FastJoin", bed.relays.clone(), None).await.unwrap();
        let link = mint_public_link(&bed.relay, &community, "https://vectorapp.io", None, None).await.unwrap();

        bed.swap_to(&member);
        let _ = preview_public_link(&bed.relay, &link.url).await.unwrap();
        let joined = accept_public_link(&bed.relay, &link.url).await.unwrap();
        assert_eq!(joined.id().0, community.id().0);
        assert!(joined.created_at_ms > 0, "the handoff stamps the JOIN's acquisition time, not the preview's");
        // The slot was CONSUMED by the join — proving the handoff path ran (a
        // verify re-walk would have left the preview's entry in place).
        assert!(VERIFIED_PREVIEW.lock().unwrap().is_none(), "the handoff slot must be consumed by the join");
    }

    #[tokio::test]
    async fn guestbook_store_seeds_syncs_incrementally_and_matches_the_live_fold() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "GB", bed.relays.clone(), None).await.unwrap();
        let link = mint_public_link(&bed.relay, &community, "https://vectorapp.io", None, None).await.unwrap();

        bed.swap_to(&member);
        let joined = accept_public_link(&bed.relay, &link.url).await.unwrap();

        // Seed from zero: the stored fold equals the authoritative live fold.
        let session = SessionGuard::capture();
        assert!(!sync_guestbook(&bed.relay, &joined, &session).await.unwrap().is_empty(), "the seed folds fresh events");
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&joined.id().0);
        let (_, cursor) = crate::db::community::get_guestbook(&cid_hex).unwrap();
        assert!(cursor > 0, "the cursor advanced past zero");
        let stored: std::collections::BTreeSet<_> = stored_memberlist(&joined).unwrap().into_iter().collect();
        let live: std::collections::BTreeSet<_> = memberlist(&bed.relay, &joined).await.unwrap().into_iter().collect();
        assert_eq!(stored, live, "stored fold == live fold after the seed");
        assert!(stored.contains(&member.keys.public_key()));

        // Nothing new on the plane → an idle re-sync folds nothing.
        assert!(sync_guestbook(&bed.relay, &joined, &session).await.unwrap().is_empty());

        // The owner kicks the member; a CURSOR catch-up folds the kick in — no full walk.
        bed.swap_to(&owner);
        kick_member(&bed.relay, &community, &member.keys.public_key()).await.unwrap();
        bed.swap_to(&member);
        let session = SessionGuard::capture();
        assert!(!sync_guestbook(&bed.relay, &joined, &session).await.unwrap().is_empty(), "the kick lands incrementally");
        assert!(
            !stored_memberlist(&joined).unwrap().contains(&member.keys.public_key()),
            "an owner kick removes the member from the stored fold"
        );
    }

    #[tokio::test]
    async fn a_preview_then_revoke_still_refuses_the_join() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "RevokeRace", bed.relays.clone(), None).await.unwrap();
        let link = mint_public_link(&bed.relay, &community, "https://vectorapp.io", None, None).await.unwrap();

        // Member previews (warming the verified handoff), THEN the owner revokes.
        bed.swap_to(&member);
        let p = preview_public_link(&bed.relay, &link.url).await.unwrap();
        assert_eq!(p.name, "RevokeRace");
        bed.swap_to(&owner);
        let tombstone = invite::build_revocation(&link.link_signer).unwrap();
        bed.relay.publish_durable(&tombstone, &bed.relays).await.unwrap();

        // The join MUST refuse: the handoff skips only the root re-verify, never
        // the bundle re-fetch that carries the revocation gate.
        bed.swap_to(&member);
        let err = accept_public_link(&bed.relay, &link.url).await.unwrap_err();
        assert!(err.contains("revoked"), "got: {err}");
    }

    #[tokio::test]
    async fn a_revoked_link_refuses_to_join() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Revoked", bed.relays.clone(), None).await.unwrap();
        let link = mint_public_link(&bed.relay, &community, "https://vectorapp.io", None, None).await.unwrap();
        // Owner retires the link (re-posts the coordinate as a tombstone).
        let tombstone = invite::build_revocation(&link.link_signer).unwrap();
        bed.relay.publish_durable(&tombstone, &bed.relays).await.unwrap();

        bed.swap_to(&member);
        let err = accept_public_link(&bed.relay, &link.url).await.unwrap_err();
        assert!(err.contains("revoked"), "a retired link finds the grave, not keys: {err}");
    }

    #[tokio::test]
    async fn an_expired_direct_invite_refuses_to_join() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Expired", bed.relays.clone(), None).await.unwrap();
        // Hand-mint an invite that expired in the past.
        let inviter = owner.keys.clone();
        let mut bundle = bundle_of(&community, BundleAudience::Link, Some(inviter.public_key()), Some(1_000), None);
        bundle.expires_at = Some(1_000); // unix ms, long past
        let wrap = invite::build_direct_invite(&inviter, &member.keys.public_key(), &bundle).unwrap();
        bed.relay.publish(&wrap, &bed.relays).await.unwrap();

        bed.swap_to(&member);
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let err = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap_err();
        assert!(err.contains("expired"), "a past-expiry invite refuses to join: {err}");
    }

    #[tokio::test]
    async fn a_tombstone_beats_a_live_bundle_regardless_of_fetch_order() {
        // The revocation-durability fix: if ANY signer-valid tombstone is among the
        // fetched events, refuse — even when a Live bundle is returned FIRST (the
        // production union has no newest-first sort, so a stale relay's Live can lead).
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Rev", bed.relays.clone(), None).await.unwrap();
        let link = mint_public_link(&bed.relay, &community, "https://vectorapp.io", None, None).await.unwrap();
        let tombstone = invite::build_revocation(&link.link_signer).unwrap();

        // A relay union that hands back [Live, tombstone] — Live FIRST. Old
        // `events.first()` would join the Live; the scan-all fix must refuse.
        let union = FixedFetch { events: vec![link.bundle_event.clone(), tombstone] };

        bed.swap_to(&member);
        let err = accept_public_link(&union, &link.url).await.unwrap_err();
        assert!(err.contains("revoked"), "a tombstone must beat a Live returned first: {err}");
    }

    #[test]
    fn from_bundle_refuses_an_over_cap_bundle_before_allocating() {
        // The accept-side DoS bound: from_bundle (which accept_bundle calls)
        // rejects a >256-channel bundle via validate() BEFORE the Vec allocation.
        // (The Direct-Invite wire path is additionally bounded by NIP-44's 64KB
        // cap, which trips even earlier — but the count guard is the real defense
        // for the single-layer public-link bundle.)
        let owner = Keys::generate();
        let identity = super::super::control::CommunityIdentity::mint(&owner.public_key());
        let hex = crate::simd::hex::bytes_to_hex_32;
        let root = [0x11u8; 32];
        let mut bundle = CommunityInvite {
            community_id: hex(&identity.community_id.0),
            owner: hex(&identity.owner_xonly),
            owner_salt: hex(&identity.owner_salt),
            community_root: hex(&root),
            root_epoch: 0,
            channels: vec![],
            relays: vec!["wss://r".into()],
            name: "X".into(),
            icon: None,
            expires_at: None,
            creator_npub: None,
            label: None,
            extra: Default::default(),
        };
        bundle.channels = (0..=invite::MAX_BUNDLE_CHANNELS)
            .map(|i| {
                let mut id = [0u8; 32];
                id[..8].copy_from_slice(&(i as u64).to_be_bytes());
                invite::ChannelGrant { id: hex(&id), key: hex(&root), epoch: 0, name: "x".into() }
            })
            .collect();
        assert!(CommunityV2::from_bundle(&bundle, 0).is_err(), "an over-cap bundle is refused before allocating");
    }

    #[tokio::test]
    async fn a_join_swap_between_fetch_and_save_aborts_and_leaves_the_other_account_clean() {
        // The SessionGuard straddle: a public-link accept fetches then saves. If the
        // account swaps in that window, the join must abort — never write A's
        // community into B's DB. SwapMidFetch bumps the session generation during
        // the fetch await, exactly as a real swap_session would.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Straddle", bed.relays.clone(), None).await.unwrap();
        let link = mint_public_link(&bed.relay, &community, "https://vectorapp.io", None, None).await.unwrap();
        // A fresh swap-injecting transport holding the same bundle event.
        let swap_relay = SwapMidFetch { inner: MemoryRelay::new() };
        swap_relay.inner.publish_durable(&link.bundle_event, &bed.relays).await.unwrap();

        bed.swap_to(&member);
        let err = accept_public_link(&swap_relay, &link.url).await.unwrap_err();
        assert!(err.contains("account changed"), "a swap mid-join must abort: {err}");
        assert!(
            crate::db::community::load_community_v2(community.id()).unwrap().is_none(),
            "the aborted join wrote nothing to the (member) account DB"
        );
    }

    #[tokio::test]
    async fn the_owner_is_a_member_even_without_a_fetched_genesis_join() {
        // The owner is derived from the self-certifying community_id, so the
        // memberlist includes them independent of any Guestbook fetch.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Owned", vec!["wss://r".into()], None).await.unwrap();
        // A memberlist over an EMPTY guestbook (fetch a community-relay-less view)
        // still contains the owner.
        let empty = MemoryRelay::new();
        let members = memberlist(&empty, &community).await.unwrap();
        assert_eq!(members, vec![owner.public_key()], "owner present with no fetched Join");
    }

    #[tokio::test]
    async fn an_expiring_minted_invite_refuses_after_the_deadline() {
        // The mint path can now produce an expiring invite, and the accept gate
        // trips on it (end-to-end through the real service, not a hand-built bundle).
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Timed", bed.relays.clone(), None).await.unwrap();
        send_direct_invite(&bed.relay, &community, &member.keys.public_key(), Some(1_000), Some("beta".into()))
            .await
            .unwrap();

        bed.swap_to(&member);
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        assert!(
            accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap_err().contains("expired"),
            "a minted expiring invite refuses past its deadline"
        );
    }

    #[tokio::test]
    async fn a_member_who_leaves_drops_from_the_memberlist() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Leaving", bed.relays.clone(), None).await.unwrap();
        send_direct_invite(&bed.relay, &community, &member.keys.public_key(), None, None).await.unwrap();

        bed.swap_to(&member);
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let joined = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap();
        // Let the leave land strictly after the join.
        tokio::time::sleep(std::time::Duration::from_millis(2)).await;
        leave_community(&bed.relay, &joined).await.unwrap();

        bed.swap_to(&owner);
        let members = memberlist(&bed.relay, &community).await.unwrap();
        assert!(members.contains(&owner.keys.public_key()));
        assert!(!members.contains(&member.keys.public_key()), "a member who left drops from the list");
    }

    #[tokio::test]
    async fn a_swapped_member_cannot_see_the_owners_community_until_joining() {
        // Multi-account isolation: after the swap, the member's DB holds nothing
        // of the owner's community — the dual-stack storage is per-account.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Private-so-far", bed.relays.clone(), None).await.unwrap();
        assert!(crate::db::community::load_community_v2(community.id()).unwrap().is_some());

        bed.swap_to(&member);
        assert!(
            crate::db::community::load_community_v2(community.id()).unwrap().is_none(),
            "the owner's community must be invisible in the member's account DB"
        );
        assert_eq!(crate::db::community::list_community_ids().unwrap().len(), 0);
    }

    // ── Live control-follow ──────────────────────────────────────────────────

    /// Publish an owner-grammar channel edition straight to the control plane,
    /// signed by `signer` (the owner for a legit edit, a stranger for the
    /// authority test). `version`/`deleted` drive add-vs-rename-vs-delete.
    /// The entity's current head `self_hash` on the relay (highest version wins),
    /// so a helper can chain a new edition the way a real owner client does.
    async fn head_hash_on_relay(relay: &MemoryRelay, community: &CommunityV2, entity_id: &[u8; 32]) -> Option<[u8; 32]> {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let query = Query { kinds: vec![stream::KIND_WRAP], authors: vec![group.pk_hex()], limit: Some(500), ..Default::default() };
        let wraps = relay.fetch(&query, &community.relays).await.ok()?;
        let mut head: Option<(u64, [u8; 32])> = None;
        for w in &wraps {
            if let Ok((ed, _)) = control::open_control_edition(w, &group) {
                if ed.entity_id == *entity_id && head.is_none_or(|(v, _)| ed.version > v) {
                    head = Some((ed.version, ed.self_hash));
                }
            }
        }
        head.map(|(_, h)| h)
    }

    /// The `vac` a non-owner signer must attach, read off the Grant they were
    /// given on the relay (CORD-04 §5). The owner cites nothing. Mirrors what a
    /// real client does via `my_authority_citation`, so the fixtures publish the
    /// shape Vector actually emits.
    async fn cite_on_relay(
        relay: &MemoryRelay,
        community: &CommunityV2,
        signer: &Keys,
    ) -> Option<crate::community::edition::AuthorityCitation> {
        if community.owner().ok() == Some(signer.public_key()) {
            return None;
        }
        let entity_id = crate::community::v2::derive::grant_locator(community.id(), &signer.public_key().to_bytes());
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let query = Query { kinds: vec![stream::KIND_WRAP], authors: vec![group.pk_hex()], limit: Some(500), ..Default::default() };
        let wraps = relay.fetch(&query, &community.relays).await.ok()?;
        let mut head: Option<(u64, [u8; 32])> = None;
        for w in &wraps {
            if let Ok((ed, _)) = control::open_control_edition(w, &group) {
                if ed.entity_id == entity_id && head.is_none_or(|(v, _)| ed.version > v) {
                    head = Some((ed.version, ed.self_hash));
                }
            }
        }
        head.map(|(version, edition_hash)| crate::community::edition::AuthorityCitation { entity_id, version, edition_hash })
    }

    async fn publish_channel_edition(
        relay: &MemoryRelay,
        community: &CommunityV2,
        signer: &Keys,
        channel_id: &ChannelId,
        name: &str,
        private: bool,
        version: u64,
        deleted: bool,
    ) {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let prev = head_hash_on_relay(relay, community, &channel_id.0).await;
        let meta = control::ChannelMetadata { name: name.into(), private, deleted: deleted.then_some(true), ..Default::default() };
        let content = serde_json::to_string(&meta).unwrap();
        let rumor = control::build_edition_rumor(signer.public_key(), vsk::CHANNEL_METADATA, &channel_id.0, version, prev.as_ref(), &content, 1_000, None);
        let (wrap, _) = control::seal_control_edition(&rumor, &group, signer, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();
    }

    /// Publish an owner-grammar community-metadata edition (rename etc.), chained
    /// to the current relay head like a real owner client.
    async fn publish_community_meta(relay: &MemoryRelay, community: &CommunityV2, signer: &Keys, name: &str, version: u64) {
        publish_community_meta_at(relay, community, signer, name, version, 1_000).await;
    }

    /// As [`publish_community_meta`] with an explicit timestamp, for tests that need
    /// relay-side newest-first ordering (paging/eviction scenarios).
    async fn publish_community_meta_at(relay: &MemoryRelay, community: &CommunityV2, signer: &Keys, name: &str, version: u64, at_secs: u64) {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let prev = head_hash_on_relay(relay, community, &community.id().0).await;
        let meta = control::CommunityMetadata { name: name.into(), ..Default::default() };
        let content = serde_json::to_string(&meta).unwrap();
        let cite = cite_on_relay(relay, community, signer).await;
        let rumor = control::build_edition_rumor(signer.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, version, prev.as_ref(), &content, at_secs, cite.as_ref());
        let (wrap, _) = control::seal_control_edition(&rumor, &group, signer, Timestamp::from_secs(at_secs)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();
    }

    #[test]
    fn metadata_apply_captures_undriven_fields_for_republish() {
        let owner = Keys::generate();
        let g = control::genesis(&owner, control::CommunityMetadata { name: "A".into(), ..Default::default() }, 1_000).unwrap();
        let mut held = CommunityV2::from_genesis(&g, "A", None, vec!["wss://r".into()], 0);
        let general = held.channels[0].id;

        // A foreign vsk-0 head carrying custom + unknown fields folds them in…
        let mut custom = serde_json::Map::new();
        custom.insert("accent".into(), serde_json::Value::from("#89f0b6"));
        let mut extra = serde_json::Map::new();
        extra.insert("vnd_flag".into(), serde_json::Value::Bool(true));
        let meta = control::CommunityMetadata { name: "A".into(), custom: Some(custom.clone()), extra: extra.clone(), ..Default::default() };
        assert!(apply_community_metadata(&mut held, meta), "gaining custom/extra is a change");
        assert_eq!(held.meta_custom, Some(custom.clone()));
        assert_eq!(held.meta_extra, extra);
        // …and the next local edit's base document republishes them verbatim.
        assert_eq!(held.metadata().custom, Some(custom));
        assert_eq!(held.metadata().extra, held.meta_extra);

        // Same contract for a vsk-2 channel head (voice included).
        let mut ch_custom = serde_json::Map::new();
        ch_custom.insert("slowmode".into(), serde_json::Value::from(30));
        let ch_meta = control::ChannelMetadata {
            name: "general".into(),
            private: false,
            voice: Some(true),
            deleted: None,
            custom: Some(ch_custom.clone()),
            extra: Default::default(),
        };
        assert!(apply_channel_metadata(&mut held, general, ch_meta), "gaining voice/custom is a change");
        let ch = held.channel(&general).unwrap();
        assert_eq!(ch.voice, Some(true));
        assert_eq!(ch.meta_custom, Some(ch_custom.clone()));
        let rename = { let mut d = ch.metadata(); d.name = "lounge".into(); d };
        assert_eq!(rename.voice, Some(true), "our rename edition carries the foreign voice flag");
        assert_eq!(rename.custom, Some(ch_custom));
    }

    #[test]
    fn community_metadata_apply_sets_and_clears_images() {
        let owner = Keys::generate();
        let g = control::genesis(&owner, control::CommunityMetadata { name: "A".into(), ..Default::default() }, 1_000).unwrap();
        let mut held = CommunityV2::from_genesis(&g, "A", None, vec!["wss://r".into()], 0);

        let icon = control::ImageRef {
            url: "https://blossom.example/i".into(),
            key: "k".into(),
            nonce: "n".into(),
            hash: "h".into(),
            extra: Default::default(),
        };
        let with_icon = control::CommunityMetadata { name: "A".into(), icon: Some(icon.clone()), ..Default::default() };
        assert!(apply_community_metadata(&mut held, with_icon), "gaining an icon is a change");
        assert_eq!(held.icon.as_ref(), Some(&icon));

        // An edition is the FULL document: a head without the icon removes it.
        let without = control::CommunityMetadata { name: "A".into(), ..Default::default() };
        assert!(apply_community_metadata(&mut held, without), "losing the icon is a change");
        assert_eq!(held.icon, None);
    }

    /// Publish a Role edition (vsk 1) signed by `signer`, chained to the current head.
    async fn publish_role(relay: &MemoryRelay, community: &CommunityV2, signer: &Keys, role: &Role, version: u64) {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let role_id = crate::simd::hex::hex_to_bytes_32_checked(&role.role_id).unwrap();
        let prev = head_hash_on_relay(relay, community, &role_id).await;
        let content = crate::community::v2::roles::role_content_json(role).unwrap();
        let cite = cite_on_relay(relay, community, signer).await;
        let rumor = control::build_edition_rumor(signer.public_key(), vsk::ROLE, &role_id, version, prev.as_ref(), &content, 1_000, cite.as_ref());
        let (wrap, _) = control::seal_control_edition(&rumor, &group, signer, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();
    }

    /// Publish a Grant edition (vsk 3) signed by `signer`, at grant_locator(cid, member).
    async fn publish_grant(relay: &MemoryRelay, community: &CommunityV2, signer: &Keys, member: &PublicKey, role_ids: Vec<String>, version: u64) {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let eid = crate::community::v2::derive::grant_locator(community.id(), &member.to_bytes());
        let prev = head_hash_on_relay(relay, community, &eid).await;
        let grant = MemberGrant { member: member.to_hex(), role_ids };
        let content = crate::community::v2::roles::grant_content_json(&grant).unwrap();
        let cite = cite_on_relay(relay, community, signer).await;
        let rumor = control::build_edition_rumor(signer.public_key(), vsk::GRANT, &eid, version, prev.as_ref(), &content, 1_000, cite.as_ref());
        let (wrap, _) = control::seal_control_edition(&rumor, &group, signer, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();
    }

    /// Publish a Banlist edition (vsk 4) signed by `signer`, at banlist_locator(cid).
    async fn publish_banlist(relay: &MemoryRelay, community: &CommunityV2, signer: &Keys, banned: &[String], version: u64) {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let eid = crate::community::v2::derive::banlist_locator(community.id());
        let prev = head_hash_on_relay(relay, community, &eid).await;
        let content = crate::community::v2::roles::banlist_content_json(banned).unwrap();
        let cite = cite_on_relay(relay, community, signer).await;
        let rumor = control::build_edition_rumor(signer.public_key(), vsk::BANLIST, &eid, version, prev.as_ref(), &content, 1_000, cite.as_ref());
        let (wrap, _) = control::seal_control_edition(&rumor, &group, signer, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();
    }

    fn admin_role(role_id: &str, perms: u64) -> Role {
        Role { role_id: role_id.into(), name: "Admin".into(), position: 1, permissions: Permissions(perms), scope: RoleScope::Server, color: 0 }
    }

    // ── CORD-04 §1 author-aware fold: a seat-holder (holds community_root, so can seal
    // any control edition) must not be able to SUPPRESS a role or grant by forging a
    // higher version at its coordinate. Owner-only signers mask this entirely, so every
    // attacker below signs as a NON-owner member.

    #[tokio::test]
    async fn a_non_owner_cannot_suppress_the_admin_role_by_forging_a_higher_version() {
        let (bed, owner, attacker) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "AttackA", bed.relays.clone(), None).await.unwrap();
        let victim = Keys::generate().public_key();
        grant_admin(&bed.relay, &community, &victim).await.unwrap();

        // The admin role sits at a deterministic, publicly-computable coordinate.
        let admin_rid = fetch_authority(&bed.relay, &community)
            .await
            .roles
            .roles
            .iter()
            .find(|r| r.permissions.contains(Permissions::ADMIN_ALL))
            .unwrap()
            .role_id
            .clone();
        // Attacker forges v2 of that exact role, stripping its powers.
        publish_role(
            &bed.relay,
            &community,
            &attacker.keys,
            &Role { role_id: admin_rid.clone(), name: "pwned".into(), position: 1, permissions: Permissions(0), scope: RoleScope::Server, color: 0 },
            2,
        )
        .await;

        let authority = fold_authority(&community, &fetch_control(&bed.relay, &community).await, &load_floors(&community));
        assert!(authority.roles.is_admin(&victim.to_hex()), "the forged strip is DROPPED; the owner's admin role survives beneath it");
        assert!(
            authority.heads.iter().any(|h| h.entity_hex == admin_rid && h.version == 1),
            "the floor advances only to the AUTHORIZED head (owner v1)"
        );
        assert!(!authority.heads.iter().any(|h| h.version == 2), "the forged v2 never poisons the floor");
    }

    #[tokio::test]
    async fn a_non_owner_cannot_strip_a_members_grant_by_forging_a_higher_version() {
        let (bed, owner, attacker) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "AttackC", bed.relays.clone(), None).await.unwrap();
        let victim = Keys::generate();
        grant_admin(&bed.relay, &community, &victim.public_key()).await.unwrap();

        // Attacker forges a higher-version EMPTY grant at the victim's grant coordinate.
        publish_grant(&bed.relay, &community, &attacker.keys, &victim.public_key(), vec![], 9).await;

        let authority = fold_authority(&community, &fetch_control(&bed.relay, &community).await, &load_floors(&community));
        assert!(
            authority.roles.is_admin(&victim.public_key().to_hex()),
            "the forged strip is dropped; the owner's grant survives and the victim keeps admin"
        );
    }

    #[tokio::test]
    async fn forged_low_id_roles_by_a_non_owner_never_enter_the_authorized_roster() {
        let (bed, owner, attacker) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "AttackB", bed.relays.clone(), None).await.unwrap();
        let victim = Keys::generate().public_key();
        grant_admin(&bed.relay, &community, &victim).await.unwrap();

        // Low-id roles that WOULD evict the admin from a pre-authorize cap — but they're
        // unauthorized, so the post-authorize cap never sees them.
        for i in 0u8..6 {
            let rid = crate::simd::hex::bytes_to_hex_32(&[i; 32]);
            publish_role(&bed.relay, &community, &attacker.keys, &admin_role(&rid, Permissions::ADMIN_ALL), 1).await;
        }

        let authority = fold_authority(&community, &fetch_control(&bed.relay, &community).await, &load_floors(&community));
        assert!(authority.roles.is_admin(&victim.to_hex()), "the legit admin survives the forged flood");
        assert_eq!(authority.roles.roles.len(), 1, "only the owner's admin role is authorized; every forgery is dropped");
    }

    /// A canonical (order-independent) fingerprint of an AuthoritySet's authorized
    /// roster + banlist — two clients converge iff these match.
    fn authority_fingerprint(a: &AuthoritySet) -> String {
        let mut roles = a.roles.roles.clone();
        roles.sort_by(|x, y| x.role_id.cmp(&y.role_id));
        let mut grants = a.roles.grants.clone();
        for g in &mut grants {
            g.role_ids.sort();
        }
        grants.sort_by(|x, y| x.member.cmp(&y.member));
        let banned: Vec<&String> = a.banned.iter().collect();
        serde_json::json!({ "roles": roles, "grants": grants, "banned": banned }).to_string()
    }

    #[tokio::test]
    async fn the_v2_authority_fold_is_order_independent() {
        // THE core consensus property: two honest clients that receive the SAME
        // control editions in DIFFERENT arrival orders must resolve the IDENTICAL
        // authorized roster + banlist (author-aware select_authorized + banlist
        // fold + cap, all deterministic). A divergence here would fork the
        // community's moderation state between honest members.
        let (bed, owner, _a) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Determinism", bed.relays.clone(), None).await.unwrap();

        // A rich control plane: two admins, an extra role, two grants (one of them a
        // grant to a member the owner then bans), a banlist, a rename, a channel.
        let admin1 = Keys::generate().public_key();
        let admin2 = Keys::generate().public_key();
        grant_admin(&bed.relay, &community, &admin1).await.unwrap();
        grant_admin(&bed.relay, &community, &admin2).await.unwrap();
        let mod_rid = "5c".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&mod_rid, Permissions::KICK | Permissions::MANAGE_MESSAGES), 1).await;
        let member = Keys::generate().public_key();
        publish_grant(&bed.relay, &community, &owner.keys, &member, vec![mod_rid.clone()], 1).await;
        let banned_member = Keys::generate().public_key();
        publish_grant(&bed.relay, &community, &owner.keys, &banned_member, vec![mod_rid], 1).await;
        set_banlist(&bed.relay, &community, &[banned_member.to_hex()]).await.unwrap();
        let meta = control::CommunityMetadata { name: "Renamed".into(), relays: community.relays.clone(), ..Default::default() };
        edit_community_metadata(&bed.relay, &community, &meta).await.unwrap();
        create_public_channel(&bed.relay, &community, "extra").await.unwrap();

        let editions = fetch_control(&bed.relay, &community).await;
        let floors = load_floors(&community);
        assert!(editions.len() >= 6, "a rich plane was built ({} editions)", editions.len());

        let baseline = authority_fingerprint(&fold_authority(&community, &editions, &floors));

        // Fold under many arrival permutations: reversed, and several deterministic
        // rotations/interleavings. Every one must match the baseline.
        let mut orders: Vec<Vec<ParsedEdition>> = Vec::new();
        let mut rev = editions.clone();
        rev.reverse();
        orders.push(rev);
        for shift in [1usize, 3, 5, 7] {
            let n = editions.len();
            orders.push((0..n).map(|i| editions[(i + shift) % n].clone()).collect());
        }
        // A deterministic "shuffle": interleave from both ends.
        let mut zip = Vec::with_capacity(editions.len());
        let (mut lo, mut hi) = (0isize, editions.len() as isize - 1);
        while lo <= hi {
            zip.push(editions[lo as usize].clone());
            if lo != hi {
                zip.push(editions[hi as usize].clone());
            }
            lo += 1;
            hi -= 1;
        }
        orders.push(zip);

        for (i, order) in orders.iter().enumerate() {
            let got = authority_fingerprint(&fold_authority(&community, order, &floors));
            assert_eq!(got, baseline, "arrival order #{i} must resolve the identical authority (consensus)");
        }
        // Sanity: the fingerprint reflects real state (the banned member is out, the
        // honest admins are in).
        assert!(baseline.contains(&admin1.to_hex()) || baseline.contains(&member.to_hex()), "grants are present in the fingerprint");
        assert!(baseline.contains(&banned_member.to_hex()), "the banlist entry is in the fingerprint");
    }

    /// A transport that ACKs publishes but ERRORS every fetch — a relay outage / withhold.
    struct FetchErrors(MemoryRelay);
    #[async_trait::async_trait]
    impl crate::community::transport::Transport for FetchErrors {
        async fn fetch_plane(&self, _plane: &Keys, query: &Query, relays: &[String]) -> Result<Vec<Event>, String> { self.fetch(query, relays).await }
        async fn publish(&self, e: &Event, r: &[String]) -> Result<(), String> {
            self.0.publish(e, r).await
        }
        async fn fetch(&self, _q: &Query, _r: &[String]) -> Result<Vec<Event>, String> {
            Err("relay down".to_string())
        }
        async fn publish_durable(&self, e: &Event, r: &[String]) -> Result<(), String> {
            self.0.publish_durable(e, r).await
        }
    }

    #[tokio::test]
    async fn fetch_authority_retains_the_persisted_banlist_on_a_transport_error() {
        let (bed, owner, victim) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "BanRetain", bed.relays.clone(), None).await.unwrap();
        let victim_hex = victim.keys.public_key().to_hex();
        // A ban is persisted locally (as a completed set_banlist + follow leaves it).
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        crate::db::community::set_community_banlist(&cid_hex, &[victim_hex.clone()], 1).unwrap();

        // A relay that ERRORS on fetch must degrade FAIL-SAFE: retain the ban, never
        // return an empty banlist (which would silently un-ban on withheld data).
        let down = FetchErrors(MemoryRelay::new());
        let view = fetch_authority(&down, &community).await;
        assert!(view.banned.contains(&victim_hex), "a transport error retains the persisted banlist");
    }

    #[tokio::test]
    async fn follow_control_retains_the_roster_when_a_floored_role_ages_out() {
        let (bed, owner, _m) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Complete", bed.relays.clone(), None).await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let (a, b) = (Keys::generate().public_key(), Keys::generate().public_key());
        let rid = crate::simd::hex::bytes_to_hex_32(&[0x7c; 32]);

        // Full state on relay1: an Admin role + two grants → both fold + persist as admins.
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::ADMIN_ALL), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &a, vec![rid.clone()], 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &b, vec![rid.clone()], 1).await;
        let session = crate::state::SessionGuard::capture();
        follow_control(&bed.relay, &community, &session).await.unwrap();
        assert!(crate::db::community::get_community_roles(&cid_hex).unwrap().is_admin(&a.to_hex()), "seeded");

        // relay2 serves A's grant but NOT the role (aged out of the window): the fold
        // drops both admins yet raises no gap. The completeness gate must RETAIN the
        // stored roster rather than persist the lossy one.
        let relay2 = MemoryRelay::new();
        publish_grant(&relay2, &community, &owner.keys, &a, vec![rid.clone()], 1).await;
        follow_control(&relay2, &community, &session).await.unwrap();
        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        assert!(roster.is_admin(&a.to_hex()) && roster.is_admin(&b.to_hex()), "a floored-but-unfetched role retains the stored roster");
    }

    #[tokio::test]
    async fn an_uncited_metadata_or_banlist_edition_is_dropped() {
        // CORD-04 §5 covers EVERY control entity, not just the delegation chain.
        // Vector already gated roles and grants in-fold; metadata, channels and
        // the banlist resolved on permission alone, so a client one sweep behind
        // honored an edit from an admin whose demotion it had not read yet.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Base", vec!["wss://r".into()], None).await.unwrap();
        let admin = Keys::generate();
        let rid = "a7".repeat(32);
        publish_role(&relay, &community, &owner, &admin_role(&rid, Permissions::MANAGE_METADATA | Permissions::BAN), 1).await;
        publish_grant(&relay, &community, &owner, &admin.public_key(), vec![rid], 1).await;

        // The admin acts WITHOUT citing (what every pre-citation client emitted).
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let meta = control::CommunityMetadata { name: "Uncited Rename".into(), ..Default::default() };
        let rumor = control::build_edition_rumor(
            admin.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, 2,
            head_hash_on_relay(&relay, &community, &community.id().0).await.as_ref(),
            &serde_json::to_string(&meta).unwrap(), 1_000, None,
        );
        let (wrap, _) = control::seal_control_edition(&rumor, &group, &admin, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();

        let ban_eid = crate::community::v2::derive::banlist_locator(community.id());
        let victim = Keys::generate().public_key().to_hex();
        let ban_rumor = control::build_edition_rumor(
            admin.public_key(), vsk::BANLIST, &ban_eid, 1, None,
            &serde_json::to_string(&vec![victim.clone()]).unwrap(), 1_000, None,
        );
        let (ban_wrap, _) = control::seal_control_edition(&ban_rumor, &group, &admin, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&ban_wrap, &community.relays).await.unwrap();

        let session = SessionGuard::capture();
        let updated = follow_control(&relay, &community, &session).await.unwrap();
        assert!(
            updated.as_ref().is_none_or(|c| c.name != "Uncited Rename"),
            "an uncited metadata edit must not be honored",
        );
        let authority = fetch_authority(&relay, &community).await;
        assert!(!authority.banned.contains(&victim), "an uncited banlist edition must not be honored");
        // The positive case (this same admin, citing, lands) is
        // `an_authorized_admin_edits_metadata_but_a_demoted_one_cannot` — its
        // helper cites, so it proves the gate is the CITATION and not the
        // permission. Re-proving it here would need a fresh chain anyway: a
        // cited edition chaining onto the rejected one above is gapped, not
        // refused.
    }

    #[tokio::test]
    async fn an_authorized_admin_edits_metadata_but_a_demoted_one_cannot() {
        // CORD-04 §5: an admin holding MANAGE_METADATA renames the community; once the
        // owner revokes the grant, the (now unauthorized) admin's further edit drops
        // and the name holds at the last authorized state.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Base", vec!["wss://r".into()], None).await.unwrap();
        let admin = Keys::generate();
        let rid = "a1".repeat(32);
        publish_role(&relay, &community, &owner, &admin_role(&rid, Permissions::MANAGE_METADATA), 1).await;
        publish_grant(&relay, &community, &owner, &admin.public_key(), vec![rid.clone()], 1).await;
        publish_community_meta(&relay, &community, &admin, "Admin Rename", 2).await;

        let session = SessionGuard::capture();
        let updated = follow_control(&relay, &community, &session).await.unwrap().expect("admin edit authorized");
        assert_eq!(updated.name, "Admin Rename", "an admin with MANAGE_METADATA renames");

        publish_grant(&relay, &community, &owner, &admin.public_key(), vec![], 2).await; // revoke
        publish_community_meta(&relay, &community, &admin, "Demoted Rename", 3).await;
        let _ = follow_control(&relay, &community, &session).await.unwrap();
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(held.name, "Admin Rename", "a demoted admin's edit is dropped; the name holds");
    }

    #[tokio::test]
    async fn a_roleless_member_cannot_edit_metadata() {
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Guarded", vec!["wss://r".into()], None).await.unwrap();
        let stranger = Keys::generate();
        publish_community_meta(&relay, &community, &stranger, "Hijacked", 2).await;
        let session = SessionGuard::capture();
        assert!(
            follow_control(&relay, &community, &session).await.unwrap().is_none(),
            "a roleless member's metadata edit never folds"
        );
    }

    #[tokio::test]
    async fn a_self_signed_grant_is_not_authority() {
        // The self-promotion defense: a member self-signs both a role and a grant of
        // it to themselves. authorize_delegation drops both (their signer never traces
        // to the owner), so their metadata edit stays unauthorized.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "NoSelfPromo", vec!["wss://r".into()], None).await.unwrap();
        let rogue = Keys::generate();
        let rid = "b2".repeat(32);
        publish_role(&relay, &community, &rogue, &admin_role(&rid, Permissions::ADMIN_ALL), 1).await;
        publish_grant(&relay, &community, &rogue, &rogue.public_key(), vec![rid.clone()], 1).await;
        publish_community_meta(&relay, &community, &rogue, "Seized", 2).await;
        let session = SessionGuard::capture();
        assert!(
            follow_control(&relay, &community, &session).await.unwrap().is_none(),
            "a self-signed grant confers no authority"
        );
    }

    #[tokio::test]
    async fn the_banlist_is_enforced_only_from_a_ban_holder() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Bans", vec!["wss://r".into()], None).await.unwrap();
        let target = "cc".repeat(32);

        // A non-BAN-holder's banlist edition is folded but NOT enforced.
        let rogue = Keys::generate();
        publish_banlist(&relay, &community, &rogue, &[target.clone()], 1).await;
        let floors = load_floors(&community);
        let editions = fetch_control(&relay, &community).await;
        let authority = fold_authority(&community, &editions, &floors);
        assert!(authority.banned.is_empty(), "a non-owner (no BAN) banlist is not enforced");

        // The owner (supreme, holds BAN) bans the target: now enforced.
        publish_banlist(&relay, &community, &owner, &[target.clone()], 2).await;
        let editions = fetch_control(&relay, &community).await;
        let authority = fold_authority(&community, &editions, &floors);
        assert!(authority.banned.contains(&target), "the owner's banlist is enforced");
    }

    #[tokio::test]
    async fn a_banned_admin_loses_all_authority() {
        // CORD-04 §4: a banned npub vanishes — even holding an un-stripped grant, a
        // banned admin's authority is dropped and their edits refused.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "BanAuth", vec!["wss://r".into()], None).await.unwrap();
        let admin = Keys::generate();
        let rid = "e5".repeat(32);
        publish_role(&relay, &community, &owner, &admin_role(&rid, Permissions::MANAGE_METADATA), 1).await;
        publish_grant(&relay, &community, &owner, &admin.public_key(), vec![rid.clone()], 1).await;
        publish_banlist(&relay, &community, &owner, &[admin.public_key().to_hex()], 1).await; // ban, grant left intact
        publish_community_meta(&relay, &community, &admin, "Banned Rename", 2).await;

        let session = SessionGuard::capture();
        assert!(
            follow_control(&relay, &community, &session).await.unwrap().is_none(),
            "a banned admin's edit is dropped even with an unstripped grant"
        );
        let authority = fold_authority(&community, &fetch_control(&relay, &community).await, &load_floors(&community));
        assert!(authority.banned.contains(&admin.public_key().to_hex()));
        assert!(
            !authority.roles.is_authorized(&admin.public_key().to_hex(), Some(&owner.public_key().to_hex()), Permissions::MANAGE_METADATA),
            "a banned admin holds no bit"
        );
    }

    #[tokio::test]
    async fn a_ban_holder_cannot_ban_a_superior_or_the_owner() {
        // CORD-04 §3/§5: BAN needs the bit AND a strict outrank of the target. A mod
        // (pos 2, holds BAN) can ban a lower member but NOT a superior admin (pos 1)
        // and NOT the owner (supreme, unbannable).
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Ranks", vec!["wss://r".into()], None).await.unwrap();
        let admin = Keys::generate();
        let moder = Keys::generate();
        let stranger = Keys::generate();
        let (admin_rid, mod_rid) = ("a1".repeat(32), "b2".repeat(32));
        publish_role(&relay, &community, &owner, &Role { role_id: admin_rid.clone(), name: "Admin".into(), position: 1, permissions: Permissions(Permissions::ADMIN_ALL), scope: RoleScope::Server, color: 0 }, 1).await;
        publish_role(&relay, &community, &owner, &Role { role_id: mod_rid.clone(), name: "Mod".into(), position: 2, permissions: Permissions(Permissions::BAN), scope: RoleScope::Server, color: 0 }, 1).await;
        publish_grant(&relay, &community, &owner, &admin.public_key(), vec![admin_rid], 1).await;
        publish_grant(&relay, &community, &owner, &moder.public_key(), vec![mod_rid], 1).await;
        publish_banlist(&relay, &community, &moder, &[admin.public_key().to_hex(), owner.public_key().to_hex(), stranger.public_key().to_hex()], 1).await;

        let authority = fold_authority(&community, &fetch_control(&relay, &community).await, &load_floors(&community));
        assert!(!authority.banned.contains(&admin.public_key().to_hex()), "a mod cannot ban a superior admin");
        assert!(!authority.banned.contains(&owner.public_key().to_hex()), "nobody can ban the owner");
        assert!(authority.banned.contains(&stranger.public_key().to_hex()), "the mod CAN ban a lower-ranked member");
    }

    #[tokio::test]
    async fn an_unauthorized_higher_banlist_cannot_unban() {
        // CORD-04 §4 anti-roster fail-CLOSED: a rogue's higher-version empty banlist
        // must not erase the owner's ban (author-aware head selection + persisted
        // banlist retention).
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "NoUnban", vec!["wss://r".into()], None).await.unwrap();
        let target = "cc".repeat(32);
        publish_banlist(&relay, &community, &owner, &[target.clone()], 1).await;
        let session = SessionGuard::capture();
        follow_control(&relay, &community, &session).await.unwrap(); // persists the ban

        let rogue = Keys::generate();
        publish_banlist(&relay, &community, &rogue, &[], 2).await; // unauthorized higher, empty
        let authority = fold_authority(&community, &fetch_control(&relay, &community).await, &load_floors(&community));
        assert!(authority.banned.contains(&target), "an unauthorized higher banlist cannot un-ban");
    }

    #[tokio::test]
    async fn the_community_list_syncs_a_membership_to_a_fresh_device() {
        // CORD-02 §8: create publishes the 13302; a fresh device (community dropped
        // locally, the 13302 + genesis still on the relay) rehydrates it on sync.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let relays = vec!["wss://r".to_string()];
        let community = create_community(&relay, "Synced", relays.clone(), None).await.unwrap();
        crate::db::community::delete_community(&crate::simd::hex::bytes_to_hex_32(&community.id().0)).unwrap();
        assert!(crate::db::community::load_community_v2(community.id()).unwrap().is_none());

        let rehydrated = sync_community_list(&relay, &relays).await.unwrap().joined;
        assert_eq!(rehydrated.len(), 1, "the left-behind membership rehydrates");
        assert_eq!(rehydrated[0].id().0, community.id().0);
        assert!(crate::db::community::load_community_v2(community.id()).unwrap().is_some(), "and is now held locally");
    }

    #[tokio::test]
    async fn a_leave_tombstones_the_membership_so_sync_does_not_rejoin() {
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let relays = vec!["wss://r".to_string()];
        let community = create_community(&relay, "Left", relays.clone(), None).await.unwrap();
        leave_community(&relay, &community).await.unwrap(); // tombstones the 13302 + deletes

        let rehydrated = sync_community_list(&relay, &relays).await.unwrap().joined;
        assert!(rehydrated.is_empty(), "a tombstoned membership is not rejoined on sync");
    }

    #[tokio::test]
    async fn accepting_the_same_bundle_twice_is_idempotent() {
        // A bot restart or a duplicate invite delivery: accepting the SAME bundle
        // again must upsert cleanly — same community_id, no duplicate channels, no
        // corruption, the keys unchanged.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Idem", bed.relays.clone(), None).await.unwrap();
        create_public_channel(&bed.relay, &community, "extra").await.unwrap();
        let community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let bundle = serde_json::to_string(&bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None)).unwrap();

        bed.swap_to(&member);
        let first = accept_parked_invite(&bed.relay, &bundle, None).await.unwrap();
        let channels_after_first = first.channels.len();
        let root_after_first = first.community_root;

        // Accept the identical bundle again (restart / redelivery).
        let second = accept_parked_invite(&bed.relay, &bundle, None).await.unwrap();
        assert_eq!(second.id().0, first.id().0, "same community_id");
        assert_eq!(second.channels.len(), channels_after_first, "no duplicate channels on re-accept");
        assert_eq!(second.community_root, root_after_first, "root unchanged");

        // The persisted state is a single clean community with the expected channels.
        let reloaded = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(reloaded.channels.len(), channels_after_first, "the DB holds one clean channel set");
        assert_eq!(crate::db::community::list_community_ids().unwrap().iter().filter(|id| id.0 == community.id().0).count(), 1, "exactly one community row");
    }

    #[tokio::test]
    async fn a_severed_member_can_be_unbanned_and_re_admitted() {
        // The full moderation HEAL lifecycle: ban (banlist + grant strip + refound)
        // severs a member; the owner then unbans + sends a FRESH invite carrying the
        // NEW root; the member rejoins at the new epoch and converses again. Proves
        // a ban is reversible end-to-end, not a one-way door.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let mut community = create_community(&bed.relay, "Redeemable", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        send_direct_invite(&bed.relay, &community, &member.keys.public_key(), None, None).await.unwrap();
        send_message(&bed.relay, &community, &general, "owner: welcome").await.unwrap();

        bed.swap_to(&member);
        let invite = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let joined = accept_direct_invite(&bed.relay, &invite).await.unwrap();
        assert!(texts_in(&bed.relay, &joined, &general).await.contains(&"owner: welcome".to_string()));

        // Owner bans the member (CORD-04 §6 three-removal) → refound severs them.
        bed.swap_to(&owner);
        set_banlist(&bed.relay, &community, &[member.keys.public_key().to_hex()]).await.unwrap();
        grant_roles(&bed.relay, &community, &member.keys.public_key(), vec![]).await.unwrap();
        community = refound_community(&bed.relay, &community, &[member.keys.public_key()]).await.unwrap();
        assert_eq!(community.root_epoch, Epoch(1));
        send_message(&bed.relay, &community, &general, "owner: after the ban").await.unwrap();

        // The member's follow concludes severance (no blob at the new epoch).
        bed.swap_to(&member);
        let session = SessionGuard::capture();
        assert!(follow_rekeys(&bed.relay, &joined, &session).await.unwrap().self_removed, "the member is cryptographically severed");

        // Owner unbans + re-invites: build the fresh epoch-1 bundle (accept it
        // directly, so the test picks the NEW invite unambiguously rather than an
        // arbitrary one of the two pending 3313s).
        bed.swap_to(&owner);
        set_banlist(&bed.relay, &community, &[]).await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(community.root_epoch, Epoch(1), "the owner's bundle carries epoch 1");
        let fresh_bundle = serde_json::to_string(&bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None)).unwrap();

        // Member accepts the fresh invite → rejoins at epoch 1, reads current + posts.
        bed.swap_to(&member);
        let rejoined = accept_parked_invite(&bed.relay, &fresh_bundle, None).await.unwrap();
        assert_eq!(rejoined.root_epoch, Epoch(1), "rejoined at the current epoch");
        assert_eq!(rejoined.community_root, community.community_root, "holds the NEW root");
        let seen = texts_in(&bed.relay, &rejoined, &general).await;
        assert!(seen.contains(&"owner: after the ban".to_string()), "reads post-ban history with the new root");
        send_message(&bed.relay, &rejoined, &general, "member: i am back").await.unwrap();

        bed.swap_to(&owner);
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert!(
            texts_in(&bed.relay, &community, &general).await.contains(&"member: i am back".to_string()),
            "the re-admitted member converses again at the new epoch"
        );
        // And they're back in the memberlist.
        let members = memberlist(&bed.relay, &community).await.unwrap();
        assert!(members.contains(&member.keys.public_key()), "the re-admitted member is in the list");
    }

    #[tokio::test]
    async fn dissolution_blocks_a_join() {
        // CORD-02 §9: the owner dissolves; a would-be joiner resolves the grave and
        // refuses to join.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Doomed", bed.relays.clone(), None).await.unwrap();
        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        dissolve_community(&bed.relay, &community).await.unwrap();
        assert!(crate::db::community::load_community_v2(community.id()).unwrap().unwrap().dissolved, "the owner's local hold is sealed");

        bed.swap_to(&member);
        let err = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap_err();
        assert!(err.contains("dissolved"), "a join refuses a dissolved community: {err}");
    }

    #[tokio::test]
    async fn dissolution_seals_writes_but_not_reads() {
        // CORD-02 §9: sealed means NO further activity, ever. Reads must survive —
        // the history stays browsable, and only explicit user intent deletes it.
        let (bed, owner, _member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Doomed", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        send_message(&bed.relay, &community, &general, "before the end").await.unwrap();

        dissolve_community(&bed.relay, &community).await.unwrap();
        let sealed = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();

        for err in [
            send_message(&bed.relay, &sealed, &general, "after the end").await.unwrap_err(),
            send_reaction(&bed.relay, &sealed, &general, &"a".repeat(64), &"b".repeat(64), crate::community::v2::kind::MESSAGE, "+", None)
                .await
                .unwrap_err(),
            send_edit(&bed.relay, &sealed, &general, &"a".repeat(64), "revised").await.unwrap_err(),
        ] {
            assert!(err.contains("dissolved"), "every write is refused, got: {err}");
        }
        assert!(
            texts_in(&bed.relay, &sealed, &general).await.contains(&"before the end".to_string()),
            "but the history still reads"
        );
    }

    #[tokio::test]
    async fn only_the_owner_can_dissolve() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Mine", bed.relays.clone(), None).await.unwrap();
        bed.swap_to(&member);
        assert!(dissolve_community(&bed.relay, &community).await.is_err(), "only the owner can dissolve");
        assert!(!is_dissolved(&bed.relay, &community).await, "and no tombstone was published");
    }

    #[tokio::test]
    async fn a_foreign_tombstone_is_not_death() {
        // A non-owner sealing the dissolved plane is noise (verify_dissolved is
        // owner-gated), so the community is not treated as dead.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Safe", vec!["wss://r".into()], None).await.unwrap();
        let rogue = Keys::generate();
        let rumor = crate::community::v2::dissolution::dissolved_tombstone_rumor(rogue.public_key(), community.id(), 1_000);
        let wrap = crate::community::v2::dissolution::seal_dissolved(&rumor, community.id(), &rogue, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();
        assert!(!is_dissolved(&relay, &community).await, "a foreign-signed tombstone is not death");
    }

    #[tokio::test]
    async fn a_public_channel_reads_history_across_a_refounding() {
        // CORD-03 §3: after a Refounding rolls the base root, a Public channel's
        // pre-rotation messages stay readable (the prior epoch's root is archived and
        // the read fans out across held epochs).
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "History", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        send_message(&relay, &community, &general, "before the refounding").await.unwrap();

        let refounded = refound_community(&relay, &community, &[]).await.unwrap();
        assert_eq!(refounded.root_epoch, Epoch(1), "the epoch advanced");
        send_message(&relay, &refounded, &general, "after the refounding").await.unwrap();

        let texts = texts_in(&relay, &refounded, &general).await;
        assert!(texts.contains(&"before the refounding".to_string()), "the epoch-0 message is still readable");
        assert!(texts.contains(&"after the refounding".to_string()), "the epoch-1 message reads too");
    }

    #[tokio::test]
    async fn refounding_aborts_when_control_state_is_withheld() {
        // B1 coverage gate (CORD-06 §3): a relay serving none of the committed control
        // heads must ABORT the Refounding — never silently drop state (e.g. unban a
        // member at the new epoch a fresh joiner bootstraps).
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Withheld", vec!["wss://good".into()], None).await.unwrap();
        publish_banlist(&relay, &community, &owner, &["cc".repeat(32)], 1).await;
        let session = SessionGuard::capture();
        follow_control(&relay, &community, &session).await.unwrap(); // seed the banlist floor

        // Re-point the held community to an EMPTY relay + save, so the Refounding (which
        // reloads fresh state) fetches none of the committed heads.
        let mut moved = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        moved.relays = vec!["wss://empty".into()];
        crate::db::community::save_community_v2(&moved).unwrap();

        let err = refound_community(&relay, &moved, &[]).await.unwrap_err();
        assert!(err.contains("was not served"), "a withheld control head aborts the refounding: {err}");
        assert_eq!(
            crate::db::community::load_community_v2(community.id()).unwrap().unwrap().root_epoch,
            Epoch(0),
            "the epoch did NOT advance (zero published state)"
        );
    }

    #[tokio::test]
    async fn refounding_rolls_the_root_and_severs_a_removed_member() {
        // CORD-06 §3: the owner re-founds, removing a member. The base root rolls, the
        // epoch advances, and the removed member's rekey-follow concludes they're cut.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Refound", bed.relays.clone(), None).await.unwrap();
        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&member);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();

        bed.swap_to(&owner);
        let refounded = refound_community(&bed.relay, &community, &[member.keys.public_key()]).await.unwrap();
        assert_eq!(refounded.root_epoch, Epoch(1), "the epoch advanced");
        assert_ne!(refounded.community_root, community.community_root, "the base root rolled");
        // The owner still reads the compacted control plane at the new epoch.
        assert_eq!(
            crate::db::community::load_community_v2(community.id()).unwrap().unwrap().root_epoch,
            Epoch(1),
            "the owner committed the new epoch"
        );

        // The removed member, following rekeys, is severed (no blob in the rotation).
        // Guard captured AFTER the swap: it must belong to the ACTING account (the harness
        // swap now bumps the generation exactly like a production swap_session).
        bed.swap_to(&member);
        let session = SessionGuard::capture();
        let follow = follow_rekeys(&bed.relay, &joined, &session).await.unwrap();
        assert!(follow.self_removed, "the removed member is cut by the re-founding");
    }

    #[tokio::test]
    async fn a_ban_holding_admin_can_re_found_but_not_evict_a_superior() {
        // CORD-06 §Authority: a Refounding requires BAN, not owner-identity. A
        // non-owner admin granted BAN CAN re-found (and every member follows it —
        // see the receive-side test), but the "strictly outrank every removed
        // target" rule still holds: they can't use it to evict the owner.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Guarded", bed.relays.clone(), None).await.unwrap();
        let rid = "b0".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::BAN), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &member.keys.public_key(), vec![rid], 1).await;
        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&member);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        // Fold the roster so this member's own DB reflects their BAN grant (the
        // authority check reads the folded Roster, not the bundle).
        let _ = follow_control(&bed.relay, &joined, &SessionGuard::capture()).await;
        let joined = crate::db::community::load_community_v2(joined.id()).unwrap().unwrap();
        // Can't evict the owner (no one outranks the owner).
        assert!(refound_community(&bed.relay, &joined, &[owner.keys.public_key()]).await.is_err(), "a BAN-holder can't re-found to evict the owner");
        // But CAN re-found removing a plain member they outrank (here, nobody).
        assert!(refound_community(&bed.relay, &joined, &[]).await.is_ok(), "a BAN-holding admin can re-found");
    }

    #[tokio::test]
    async fn follow_rekeys_adopts_an_authorized_non_owner_base_rotation() {
        // A BAN-holding ADMIN (not the owner) re-founds, and every member must
        // follow it — owner-only receive silently strands members whose community
        // was refounded by an admin (CORD-06 §Authority: "a Refounding requires
        // BAN", checked against the folded Roster).
        let (bed, owner, me) = TestBed::new();
        let admin = Keys::generate();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "AdminRefound", bed.relays.clone(), None).await.unwrap();
        let rid = "b0".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::BAN), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &admin.public_key(), vec![rid], 1).await;

        // I (a plain member) join, then fold the roster so I know the admin holds BAN.
        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&me);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        let _ = follow_control(&bed.relay, &joined, &SessionGuard::capture()).await;
        let joined = crate::db::community::load_community_v2(joined.id()).unwrap().unwrap();

        // The admin re-founds keeping the owner + me — the owner must always be a
        // recipient of a non-owner Refounding.
        let new_root = [0xC7; 32];
        publish_base_rotation(&bed.relay, &joined, &admin, &[owner.keys.public_key(), me.keys.public_key()], &new_root, &joined.community_root).await;

        let updated = follow_rekeys(&bed.relay, &joined, &SessionGuard::capture()).await.unwrap().updated
            .expect("an authorized admin's Refounding is adopted");
        assert_eq!(updated.root_epoch, Epoch(1), "advanced past the admin's rotation");
        assert_eq!(updated.community_root, new_root, "adopted the admin's fresh root");
    }

    #[tokio::test]
    async fn adopting_someone_elses_rotation_refreshes_my_own_live_links() {
        // CORD-05 §2: a link shared once keeps working across rotations, because
        // its bundle is re-posted behind the same URL. The Refounder can only
        // refresh the bundles they hold signer secrets for — their OWN — so
        // every other creator has to heal their links when they ADOPT the
        // rotation. Without that, an admin's links keep vending the superseded
        // root and drop new joiners onto a dead epoch, which is precisely the
        // stranding the stable-URL refresh exists to prevent.
        let (bed, owner, me) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "LinkHeal", bed.relays.clone(), None).await.unwrap();
        let rid = "b1".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::BAN), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &me.keys.public_key(), vec![rid], 1).await;

        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&me);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        let _ = follow_control(&bed.relay, &joined, &SessionGuard::capture()).await;
        let joined = crate::db::community::load_community_v2(joined.id()).unwrap().unwrap();

        // I mint a link of my own at the CURRENT epoch.
        let minted = mint_public_link(&bed.relay, &joined, "https://x", None, None).await.unwrap();
        let vended_before = fetch_public_bundle(&bed.relay, &minted.url).await.unwrap();
        assert_eq!(vended_before.root_epoch, 0, "my link vends the epoch I minted it at");

        // The OWNER re-founds. Their refresh can't touch my bundle: only I hold
        // its signer secret.
        let new_root = [0xD4; 32];
        publish_base_rotation(&bed.relay, &joined, &owner.keys, &[owner.keys.public_key(), me.keys.public_key()], &new_root, &joined.community_root).await;

        let updated = follow_rekeys(&bed.relay, &joined, &SessionGuard::capture()).await.unwrap().updated
            .expect("the owner's Refounding is adopted");
        assert_eq!(updated.root_epoch, Epoch(1), "I advanced to the new epoch");

        let vended_after = fetch_public_bundle(&bed.relay, &minted.url).await.unwrap();
        assert_eq!(vended_after.root_epoch, 1, "my link must now vend the NEW epoch, not strand its joiners");
        assert_eq!(
            crate::simd::hex::hex_to_bytes_32(&vended_after.community_root),
            new_root,
            "and the new root behind the same URL",
        );
    }

    #[tokio::test]
    async fn follow_rekeys_refuses_a_refounding_that_excludes_the_owner() {
        // Authority escalation: a BAN-admin can't use a Refounding to evict the
        // OWNER (no one outranks the owner). Excluding them makes the rotation
        // inadmissible — members fork-reject it rather than migrate to the coup.
        let (bed, owner, me) = TestBed::new();
        let admin = Keys::generate();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "NoCoup", bed.relays.clone(), None).await.unwrap();
        let rid = "b0".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::BAN), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &admin.public_key(), vec![rid], 1).await;

        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&me);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        let _ = follow_control(&bed.relay, &joined, &SessionGuard::capture()).await;
        let joined = crate::db::community::load_community_v2(joined.id()).unwrap().unwrap();

        // The admin re-founds delivering to me but NOT the owner — a takeover.
        publish_base_rotation(&bed.relay, &joined, &admin, &[me.keys.public_key()], &[0xEE; 32], &joined.community_root).await;
        let follow = follow_rekeys(&bed.relay, &joined, &SessionGuard::capture()).await.unwrap();
        assert!(follow.updated.is_none() && !follow.self_removed, "an owner-excluding Refounding is not adopted");
    }

    #[tokio::test]
    async fn follow_rekeys_refuses_a_refounding_that_excludes_a_peer_admin() {
        // Authority escalation: two equal-rank BAN-admins — neither strictly
        // outranks the other, so one can't Refound the other out. Excluding a
        // peer makes the rotation inadmissible.
        let (bed, owner, me) = TestBed::new();
        let admin_a = Keys::generate();
        let admin_b = Keys::generate(); // the peer admin the rotation excludes.
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Peers", bed.relays.clone(), None).await.unwrap();
        let rid = "b0".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::BAN), 1).await;
        // Both A and B hold the SAME role (same position 1) → peers.
        publish_grant(&bed.relay, &community, &owner.keys, &admin_a.public_key(), vec![rid.clone()], 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &admin_b.public_key(), vec![rid], 1).await;

        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&me);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        let _ = follow_control(&bed.relay, &joined, &SessionGuard::capture()).await;
        let joined = crate::db::community::load_community_v2(joined.id()).unwrap().unwrap();

        // Admin A re-founds keeping the owner + me but EXCLUDING peer admin B.
        publish_base_rotation(&bed.relay, &joined, &admin_a, &[owner.keys.public_key(), me.keys.public_key()], &[0xDD; 32], &joined.community_root).await;

        let follow = follow_rekeys(&bed.relay, &joined, &SessionGuard::capture()).await.unwrap();
        assert!(follow.updated.is_none() && !follow.self_removed, "excluding an equal-rank peer admin is inadmissible");
    }

    #[tokio::test]
    async fn a_retried_refounding_reuses_the_same_root() {
        // B1 idempotency: minting for the same (scope, epoch) twice yields the SAME
        // root, so a retried Refounding re-delivers one root — never a double-mint fork.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Retry", vec!["wss://r".into()], None).await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let first = mint_or_reuse_rotation_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, 1).unwrap();
        let second = mint_or_reuse_rotation_key(&cid_hex, crate::community::SERVER_ROOT_SCOPE_HEX, 1).unwrap();
        assert_eq!(first, second, "a retry reuses the archived root, never double-mints");
    }

    #[tokio::test]
    async fn a_mid_rank_admin_cannot_demote_a_role_that_outranks_them() {
        // CORD-04 §2 rank inversion. Minting at a position you outrank is
        // necessary but NOT sufficient: an edition replaces the entity, so a
        // gate that only reads the NEW position lets an admin at position 5
        // rewrite the position-1 role to position 9. Every check passes (9 is
        // beneath them), and the role that outranked them — plus everyone
        // holding it — is now beneath them.
        let (bed, owner, attacker) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Ranks", bed.relays.clone(), None).await.unwrap();

        // A senior role at position 1, and a mid role at position 5 the attacker holds.
        let senior = "a1".repeat(32);
        let mid = "a5".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys,
            &Role { role_id: senior.clone(), name: "Senior".into(), position: 1, permissions: Permissions(Permissions::BAN), scope: RoleScope::Server, color: 0 }, 1).await;
        publish_role(&bed.relay, &community, &owner.keys,
            &Role { role_id: mid.clone(), name: "Mid".into(), position: 5, permissions: Permissions(Permissions::MANAGE_ROLES), scope: RoleScope::Server, color: 0 }, 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &attacker.keys.public_key(), vec![mid.clone()], 1).await;

        // The attacker republishes the SENIOR role, dropping it beneath themselves.
        publish_role(&bed.relay, &community, &attacker.keys,
            &Role { role_id: senior.clone(), name: "Senior".into(), position: 9, permissions: Permissions(Permissions::BAN), scope: RoleScope::Server, color: 0 }, 2).await;

        let authority = fetch_authority(&bed.relay, &community).await;
        let folded_senior = authority.roles.role(&senior).expect("the senior role survives the fold");
        assert_eq!(
            folded_senior.position, 1,
            "a role may only be repositioned by someone who outranks where it STOOD, not just where it lands",
        );
    }

    #[tokio::test]
    async fn a_non_owner_admins_edition_cites_its_grant_and_the_owners_does_not() {
        // CORD-04 §5. Armada's reader REQUIRES this on every non-owner control
        // edition (`citationOk`: "a non-owner action MUST cite its grant"), so
        // an uncited Vector admin's ban/role/channel edit was silently dropped
        // by every Armada client — only the owner's actions crossed. The
        // citation must name the actor's OWN grant coordinate, at the version
        // and edition hash the verifier can match against a grant it holds.
        let (bed, owner, admin) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Cited", bed.relays.clone(), None).await.unwrap();
        let rid = "c1".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::BAN | Permissions::MANAGE_METADATA), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &admin.keys.public_key(), vec![rid], 1).await;

        // The owner's own edition carries NO citation: their rank is the id.
        let owner_meta = control::CommunityMetadata { name: "By Owner".into(), relays: community.relays.clone(), ..Default::default() };
        edit_community_metadata(&bed.relay, &community, &owner_meta).await.unwrap();
        let owner_ed = fetch_control(&bed.relay, &community).await.into_iter()
            .filter(|e| e.author == owner.keys.public_key() && e.vsk == vsk::COMMUNITY_METADATA)
            .max_by_key(|e| e.version).expect("the owner's metadata edition");
        assert!(owner_ed.authority.is_none(), "the owner cites nothing — rank comes from the community id");

        // The admin JOINS and folds — the citation names the grant head their own
        // client has actually synced, so the fold must have persisted it.
        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&admin);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        let _ = follow_control(&bed.relay, &joined, &SessionGuard::capture()).await;
        let joined = crate::db::community::load_community_v2(joined.id()).unwrap().unwrap();
        set_banlist(&bed.relay, &joined, &["ee".repeat(32)]).await.unwrap();

        let ban_ed = fetch_control(&bed.relay, &joined).await.into_iter()
            .find(|e| e.author == admin.keys.public_key() && e.vsk == vsk::BANLIST)
            .expect("the admin's banlist edition");
        let cite = ban_ed.authority.as_ref().expect("a non-owner MUST cite its grant");
        assert_eq!(
            cite.entity_id,
            crate::community::v2::derive::grant_locator(community.id(), &admin.keys.public_key().to_bytes()),
            "the citation must name the ACTOR'S OWN grant coordinate",
        );
        assert!(cite.version >= 1, "pinned to a real grant version");
    }

    #[tokio::test]
    async fn a_folded_metadata_edition_cannot_push_the_relay_set_past_the_cap() {
        // `cap_relays` is the truncate-on-read invariant everywhere else, and the
        // fold is a boundary like any other: MANAGE_METADATA makes an editor
        // authorized, not trusted. An oversize list costs every member a fan-out
        // per publish and the slowest of N per fetch — and Armada caps at 5, so
        // an uncapped fold also splits the two clients' operative sets.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Fanout", vec!["wss://a".into()], None).await.unwrap();

        let many: Vec<String> = (0..30).map(|i| format!("wss://r{i}")).collect();
        let meta = control::CommunityMetadata { name: "Fanout".into(), relays: many, ..Default::default() };
        edit_community_metadata(&relay, &community, &meta).await.unwrap();

        let updated = follow_control(&relay, &community, &SessionGuard::capture()).await.unwrap()
            .expect("the metadata edition is folded");
        assert_eq!(
            updated.relays.len(),
            crate::community::MAX_COMMUNITY_RELAYS,
            "a folded relay list must be truncated, never adopted whole",
        );

        // …and the fold must SETTLE: comparing an oversize edition against the
        // capped working set would never be equal, so every later fold would
        // report a change and re-save forever.
        let again = follow_control(&relay, &updated, &SessionGuard::capture()).await.unwrap();
        assert!(again.is_none(), "re-folding the same oversize edition must be a no-op");
    }

    #[tokio::test]
    async fn adopting_a_rotation_writes_no_registry_where_i_never_minted() {
        // One Invite List spans every community, so "I hold links" must never be
        // read as "I hold links HERE". A member with links elsewhere adopting a
        // rotation would otherwise publish an empty Registry edition into this
        // community — a control-plane write and a version bump on a coordinate
        // they never owned, every rotation, forever.
        let (bed, owner, me) = TestBed::new();
        bed.swap_to(&owner);
        let host = create_community(&bed.relay, "Host", bed.relays.clone(), None).await.unwrap();
        let elsewhere = create_community(&bed.relay, "Elsewhere", bed.relays.clone(), None).await.unwrap();
        let rid = "b2".repeat(32);
        publish_role(&bed.relay, &host, &owner.keys, &admin_role(&rid, Permissions::BAN), 1).await;
        publish_grant(&bed.relay, &host, &owner.keys, &me.keys.public_key(), vec![rid], 1).await;

        let bundle = bundle_of(&host, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&me);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        let _ = follow_control(&bed.relay, &joined, &SessionGuard::capture()).await;
        let joined = crate::db::community::load_community_v2(joined.id()).unwrap().unwrap();

        // My only link lives in a DIFFERENT community.
        mint_public_link(&bed.relay, &elsewhere, "https://other", None, None).await.unwrap();

        let before = bed.relay.stored_count();
        let new_root = [0xE1; 32];
        publish_base_rotation(&bed.relay, &joined, &owner.keys, &[owner.keys.public_key(), me.keys.public_key()], &new_root, &joined.community_root).await;
        let rotation_events = bed.relay.stored_count() - before;

        let after_adopt = bed.relay.stored_count();
        follow_rekeys(&bed.relay, &joined, &SessionGuard::capture()).await.unwrap();
        assert_eq!(
            bed.relay.stored_count(),
            after_adopt,
            "adopting a rotation must publish NOTHING when I minted no links here",
        );
        assert!(rotation_events > 0, "the rotation itself did publish (guards the counter)");
    }

    #[tokio::test]
    async fn an_expired_link_stops_keeping_the_community_public() {
        // CORD-05 §1/§5: expiry is the one way a link dies with no user action.
        // A joiner is refused by `InviteBundle::expired`, so leaving the link in
        // the Registry states a door that isn't there — the aggregate never
        // empties and the community reads Public forever, silently inverting
        // every gate that hangs off that reading.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Lapsing", vec!["wss://r".into()], None).await.unwrap();

        // A link that lapsed a minute ago.
        let past = now_ms() - 60_000;
        mint_public_link(&relay, &community, "https://x", Some(past), None).await.unwrap();
        assert!(
            !community_is_public(&relay, &community).await,
            "an already-expired link must never read as a live door",
        );

        // …and one that hasn't, to prove the filter isn't just dropping everything.
        mint_public_link(&relay, &community, "https://y", Some(now_ms() + 600_000), None).await.unwrap();
        assert!(community_is_public(&relay, &community).await, "an unexpired link is still live");
    }

    #[tokio::test]
    async fn minting_a_link_makes_the_community_public_and_revoke_makes_it_private() {
        // CORD-05 §5: the Registry is the Public/Private source of truth. Minting a
        // link publishes it (Public); retiring the last link empties it (Private).
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Invitable", vec!["wss://r".into()], None).await.unwrap();
        assert!(!community_is_public(&relay, &community).await, "a fresh community is Private");

        let minted = mint_public_link(&relay, &community, "https://x", None, None).await.unwrap();
        assert!(community_is_public(&relay, &community).await, "a live link makes it Public");
        let list = fetch_invite_list(&relay, &community.relays).await.unwrap().expect("the 13303 list was published");
        assert_eq!(list.entries.len(), 1, "the minted link is recorded across devices");

        let token_hex = crate::simd::hex::bytes_to_hex_16(&minted.token);
        revoke_public_link(&relay, &community, &token_hex).await.unwrap();
        assert!(!community_is_public(&relay, &community).await, "retiring the last link makes it Private again");
        let after = fetch_invite_list(&relay, &community.relays).await.unwrap().unwrap();
        assert!(after.entries.is_empty() && after.tombstones.len() == 1, "the link is tombstoned in the invite list");
    }

    #[tokio::test]
    async fn the_registry_is_cached_locally_so_public_private_is_a_sync_read() {
        // Every caller reads the `invite_registry` COLUMN, never the async fold. v2
        // published the Registry to the plane but never mirrored it locally, so every
        // v2 community read Private no matter how many live links it had.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Cached", vec!["wss://r".into()], None).await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let cached = || crate::db::community::get_community_invite_registry(&cid_hex).unwrap();
        // The per-creator split is a SEPARATE table, and it drives the "first link flips
        // the community Public" confirm — an empty one re-asks on every later link.
        let per_creator = || crate::db::community::get_invite_link_sets(&cid_hex).unwrap();
        assert!(cached().is_empty(), "a fresh community caches an empty registry");
        assert!(per_creator().is_empty(), "…and no per-creator sets");

        let minted = mint_public_link(&relay, &community, "https://x", None, None).await.unwrap();
        assert!(!cached().is_empty(), "minting caches the registry, so the UI reads Public without folding");
        let sets = per_creator();
        assert_eq!(sets.len(), 1, "the minting creator gets a set");
        assert_eq!(sets[0].locators.len(), 1, "carrying exactly their one live link");

        // Both caches must SHRINK too — a union-only mirror would strand it Public.
        let token_hex = crate::simd::hex::bytes_to_hex_16(&minted.token);
        revoke_public_link(&relay, &community, &token_hex).await.unwrap();
        assert!(cached().is_empty(), "retiring the last link empties the cache back to Private");
        assert!(per_creator().is_empty(), "…and clears the per-creator sets");
    }

    #[tokio::test]
    async fn a_rogue_registry_fork_cannot_retire_the_owners_live_link() {
        // Registries are coordinate-bound to their creator, but `fold_head` picks an
        // equal-version winner AUTHOR-BLIND, by lowest inner id — and an author grinds
        // that freely by varying content. Folding before authorising would let any
        // member occupy the owner's registry head, fail the authority check, and drop
        // the whole registry: a live invite link silently retired, flipping the
        // community to Private and steering a moderator into the wrong ban remedy.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Forked", vec!["wss://r".into()], None).await.unwrap();
        mint_public_link(&relay, &community, "https://x", None, None).await.unwrap();
        assert!(community_is_public(&relay, &community).await, "a live link makes it Public");

        let cid = community.id();
        let control = control_group_key(&community.community_root, cid, community.root_epoch);
        let eid = crate::community::v2::derive::invite_links_locator(cid, &owner.public_key().to_bytes());

        let query = Query {
            kinds: vec![stream::KIND_WRAP],
            authors: vec![control.pk_hex()],
            limit: Some(FOLLOW_PAGE),
            ..Default::default()
        };
        let wraps = relay.fetch(&query, &community.relays).await.unwrap();
        let target = wraps
            .iter()
            .filter_map(|w| control::open_control_edition(w, &control).ok().map(|(e, _)| e))
            .filter(|e| e.entity_id == eid)
            .max_by_key(|e| e.version)
            .expect("the owner published a registry");

        // Grind a same-version fork under the owner's coordinate that OUTRANKS the
        // real head on the tiebreak (~2 tries against a uniform id).
        let rogue = Keys::generate();
        let mut planted = false;
        for n in 0..4_000u64 {
            let content = format!("[{{\"token\":\"{n:032x}\",\"url\":\"https://evil\",\"expires_at\":0}}]");
            let rumor = control::build_edition_rumor(
                rogue.public_key(),
                vsk::INVITE_LINKS,
                &eid,
                target.version,
                target.prev_hash.as_ref(),
                &content,
                9_000,
                None,
            );
            let (w, _) = control::seal_control_edition(&rumor, &control, &rogue, Timestamp::from_secs(9_000)).unwrap();
            let (ed, _) = control::open_control_edition(&w, &control).unwrap();
            if ed.inner_id < target.inner_id {
                relay.publish(&w, &community.relays).await.unwrap();
                planted = true;
                break;
            }
        }
        assert!(planted, "the test needs a fork that wins the tiebreak");

        assert!(
            community_is_public(&relay, &community).await,
            "an unauthorised fork must not retire the owner's live link"
        );
    }

    #[tokio::test]
    async fn a_registry_from_a_non_create_invite_holder_does_not_make_it_public() {
        // The CREATE_INVITE gate: a rogue publishing a registry can't fake Public.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Gated", vec!["wss://r".into()], None).await.unwrap();
        let rogue = Keys::generate();
        // Rogue publishes a registry edition at THEIR coordinate with a fake signer.
        let eid = crate::community::v2::derive::invite_links_locator(community.id(), &rogue.public_key().to_bytes());
        let content = crate::community::v2::invite::build_registry_content(&[Keys::generate().public_key()]);
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let rumor = control::build_edition_rumor(rogue.public_key(), vsk::INVITE_LINKS, &eid, 1, None, &content, 1_000, None);
        let (wrap, _) = control::seal_control_edition(&rumor, &group, &rogue, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();
        let _ = owner;
        assert!(!community_is_public(&relay, &community).await, "a non-CREATE_INVITE registry is ignored");
    }

    #[tokio::test]
    async fn full_lifecycle_e2e() {
        // The whole stack end to end across two accounts: create -> Public link ->
        // owner grants an admin -> member joins + reads history -> admin edits metadata
        // (authorized fold) -> owner bans the member (CORD-04 §6: banlist + strip +
        // Refounding) -> the banned member is severed AND stays banned across the new
        // epoch -> pre-ban history still reads -> owner dissolves -> sealed.
        let (bed, owner, member) = TestBed::new();

        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Lifecycle", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        send_message(&bed.relay, &community, &general, "owner: welcome").await.unwrap();

        // Public link → the community reads Public.
        let _minted = mint_public_link(&bed.relay, &community, "https://x", None, None).await.unwrap();
        assert!(community_is_public(&bed.relay, &community).await, "a live link makes it Public");

        // Owner defines + grants an Admin role (MANAGE_METADATA among the bits).
        let rid = "aa".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::ADMIN_ALL), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &member.keys.public_key(), vec![rid], 1).await;

        // Member joins from the bundle + reads the owner's message.
        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&member);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        assert_eq!(texts_in(&bed.relay, &joined, &general).await, vec!["owner: welcome"]);
        // The admin renames the community.
        publish_community_meta(&bed.relay, &joined, &member.keys, "Lifecycle Renamed", 2).await;

        // Owner follows: the admin's rename folds (authorized).
        bed.swap_to(&owner);
        let session = SessionGuard::capture();
        let updated = follow_control(&bed.relay, &community, &session).await.unwrap().expect("the admin edit folds");
        assert_eq!(updated.name, "Lifecycle Renamed", "an authorized admin's metadata edit is honored");

        // Ban the member (the three-removal composition, in order).
        set_banlist(&bed.relay, &updated, &[member.keys.public_key().to_hex()]).await.unwrap();
        grant_roles(&bed.relay, &updated, &member.keys.public_key(), vec![]).await.unwrap();
        let refounded = refound_community(&bed.relay, &updated, &[member.keys.public_key()]).await.unwrap();
        assert_eq!(refounded.root_epoch, Epoch(1), "the ban rolled the root");
        // The ban survives the Refounding (the banlist head compacted forward).
        let post = fold_authority(&refounded, &fetch_control(&bed.relay, &refounded).await, &load_floors(&refounded));
        assert!(post.banned.contains(&member.keys.public_key().to_hex()), "the ban survives the re-founding");
        // Pre-ban history still reads across the new epoch.
        assert!(
            texts_in(&bed.relay, &refounded, &general).await.contains(&"owner: welcome".to_string()),
            "pre-refounding history stays readable"
        );

        // The banned member's rekey-follow concludes they're severed. Guard captured AFTER
        // the swap (the harness swap bumps the generation like production).
        bed.swap_to(&member);
        let session = SessionGuard::capture();
        let follow = follow_rekeys(&bed.relay, &joined, &session).await.unwrap();
        assert!(follow.self_removed, "the banned member is cryptographically cut");

        // Owner dissolves → sealed.
        bed.swap_to(&owner);
        dissolve_community(&bed.relay, &refounded).await.unwrap();
        assert!(crate::db::community::load_community_v2(community.id()).unwrap().unwrap().dissolved, "the community is sealed");
    }

    /// The deep two-account e2e the way a real deployment runs: owner (A) + member (B)
    /// over one shared relay, create → channels (public + private) → converse both ways →
    /// persist (get_messages-level) → react/edit/delete → moderate (ban/unban) → dissolve.
    /// Every account, community, channel, and action is LOGGED (run with --nocapture) so it
    /// doubles as a reference transcript and a re-runnable regression.
    #[tokio::test]
    async fn a_forged_edition_cannot_suppress_a_role_across_a_refounding() {
        // A member forges a higher-version role edition at the admin coordinate before a
        // refounding. The compaction must carry the AUTHORIZED floor head, not the
        // author-blind version tip — else the forgery is re-anchored, honest folders drop
        // it, and the admin role vanishes at the new epoch (silent suppression).
        let (bed, owner, member) = TestBed::new();
        let attacker = Keys::generate();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "NoSuppress", bed.relays.clone(), None).await.unwrap();
        let rid = crate::simd::hex::bytes_to_hex_32(&[0xa1; 32]);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::ADMIN_ALL), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &member.keys.public_key(), vec![rid.clone()], 1).await;
        // Owner folds → the authorized role/grant heads are floored.
        let session = SessionGuard::capture();
        follow_control(&bed.relay, &community, &session).await.unwrap();
        assert!(fetch_authority(&bed.relay, &community).await.roles.is_admin(&member.keys.public_key().to_hex()), "member is admin pre-attack");

        // The attacker (a non-owner) forges v2 of the admin role, chaining onto v1.
        publish_role(&bed.relay, &community, &attacker, &Role { role_id: rid.clone(), name: "pwn".into(), position: 1, permissions: Permissions(0), scope: RoleScope::Server, color: 0 }, 2).await;

        // Owner refounds (keeping everyone).
        let refounded = refound_community(&bed.relay, &community, &[]).await.unwrap();
        assert_eq!(refounded.root_epoch, Epoch(1), "root rolled");

        // Post-refound, the admin role SURVIVES (the authorized floor head was carried).
        let post = fold_authority(&refounded, &fetch_control(&bed.relay, &refounded).await, &load_floors(&refounded));
        assert!(post.roles.is_admin(&member.keys.public_key().to_hex()), "the admin role survives the refounding despite the forgery");
    }

    #[tokio::test]
    async fn memberlist_survives_a_refounding_via_the_snapshot() {
        // A silent survivor (didn't re-post at the new epoch) must stay in the memberlist
        // after a refounding — the owner's 3312 snapshot re-seeds them (CORD-02 §5).
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Snapshot", bed.relays.clone(), None).await.unwrap();

        // Member joins (a Guestbook Join at epoch 0).
        let bundle = serde_json::to_string(&bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None)).unwrap();
        bed.swap_to(&member);
        accept_parked_invite(&bed.relay, &bundle, None).await.unwrap();
        bed.swap_to(&owner);
        assert!(memberlist(&bed.relay, &community).await.unwrap().contains(&member.keys.public_key()), "member present pre-refound");

        // Owner refounds keeping everyone (removed = []); survivors are snapshotted to epoch 1.
        let refounded = refound_community(&bed.relay, &community, &[]).await.unwrap();
        assert_eq!(refounded.root_epoch, Epoch(1), "the root rolled");

        // The member is STILL a member at epoch 1 purely via the snapshot (never re-posted).
        let members = memberlist(&bed.relay, &refounded).await.unwrap();
        assert!(members.contains(&member.keys.public_key()), "a silent survivor stays a member after the refounding");
        assert!(members.contains(&owner.keys.public_key()), "owner is always a member");
    }

    #[tokio::test]
    async fn e2e_two_accounts_channels_converse_moderate() {
        use crate::community::v2::inbound::{apply_chat_to_state, persist_chat};
        use nostr_sdk::prelude::ToBech32;
        let (bed, a, b) = TestBed::new();
        let (a_npub, b_npub) = (a.keys.public_key().to_bech32().unwrap(), b.keys.public_key().to_bech32().unwrap());
        let (a_hex, b_hex) = (a.keys.public_key().to_hex(), b.keys.public_key().to_hex());
        println!("\n===== Concord v2 deep e2e =====");
        println!("[acct] A (owner)  = {a_npub}");
        println!("[acct] B (member) = {b_npub}");

        // ── A creates the community + a PRIVATE channel + two extra PUBLIC channels ──
        bed.swap_to(&a);
        let mut community = create_community(&bed.relay, "Deep E2E", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        println!("[create] community {} · #general {}", crate::simd::hex::bytes_to_hex_32(&community.id().0), crate::simd::hex::bytes_to_hex_32(&general.0));

        // A PRIVATE channel via the REAL create path: an independent key minted at
        // channel-epoch 1, delivered over the rekey plane (A is the only member yet),
        // then announced (vsk 2) — later carried to B in the join bundle.
        let priv_id = create_private_channel(&bed.relay, &community, "mods").await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let priv_ch = community.channel(&priv_id).unwrap();
        assert!(priv_ch.private && priv_ch.key.is_some() && priv_ch.epoch == Epoch(1), "born-private: keyed at epoch 1");
        println!("[channel] +private #mods {} (native create: key over the rekey plane)", crate::simd::hex::bytes_to_hex_32(&priv_id.0));

        // Two more PUBLIC channels via the real create path.
        let announcements = create_public_channel(&bed.relay, &community, "announcements").await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let random = create_public_channel(&bed.relay, &community, "random").await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        println!("[channel] +public #announcements {} · #random {}", crate::simd::hex::bytes_to_hex_32(&announcements.0), crate::simd::hex::bytes_to_hex_32(&random.0));
        assert_eq!(community.channels.len(), 4, "general + mods + announcements + random");

        // A talks in a few channels.
        let m1 = send_message(&bed.relay, &community, &general, "A: welcome to the deep e2e").await.unwrap();
        send_message(&bed.relay, &community, &announcements, "A: read the rules").await.unwrap();
        send_message(&bed.relay, &community, &priv_id, "A: mods-only channel").await.unwrap();
        println!("[msg] A posted in #general / #announcements / #mods");

        // ── A grants B admin, mints a public link, B joins from the bundle ──
        let admin_rid = crate::simd::hex::bytes_to_hex_32(&[0xa1; 32]);
        publish_role(&bed.relay, &community, &a.keys, &admin_role(&admin_rid, Permissions::ADMIN_ALL), 1).await;
        publish_grant(&bed.relay, &community, &a.keys, &b.keys.public_key(), vec![admin_rid], 1).await;
        let link = mint_public_link(&bed.relay, &community, "https://vectorapp.io", None, None).await.unwrap();
        assert!(community_is_public(&bed.relay, &community).await, "a live link makes it Public");
        println!("[invite] granted B @admin · minted link {}", link.url);

        // A private channel is readable only by granted role-holders (CORD-03), so
        // B is added to its access list before the bundle is minted.
        grant_channel_access(&bed.relay, &community, &priv_id, &b.keys.public_key()).await.unwrap();
        let bundle_json = serde_json::to_string(&bundle_of(&community, BundleAudience::Member(b.keys.public_key()), Some(a.keys.public_key()), None, None)).unwrap();
        bed.swap_to(&b);
        let mut b_view = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        println!("[join] B joined; sees {} channels", b_view.channels.len());
        assert_eq!(b_view.channels.len(), 4, "B receives all four channels (incl. the private one's key) in the bundle");
        assert!(b_view.channels.iter().any(|c| c.id.0 == priv_id.0 && c.private && c.key.is_some()), "B holds the private channel key");
        assert!(texts_in(&bed.relay, &b_view, &general).await.contains(&"A: welcome to the deep e2e".to_string()), "B reads A's #general history");
        assert!(texts_in(&bed.relay, &b_view, &priv_id).await.contains(&"A: mods-only channel".to_string()), "B reads the PRIVATE channel with the bundle key");
        // B folds the control plane (persisting the roster) — the live worker does
        // this right after any join; B's admin standing gates B's channel ops below.
        let session_b = SessionGuard::capture();
        if let Some(fresh) = follow_control(&bed.relay, &b_view, &session_b).await.unwrap() {
            b_view = fresh;
        }
        println!("[follow] B folded control (roster persisted: B is @admin)");

        // ── Conversation both ways + persistence (get_messages-level) ──
        send_message(&bed.relay, &b_view, &general, "B: thanks, glad to be here").await.unwrap();
        send_message(&bed.relay, &b_view, &priv_id, "B: mods checking in").await.unwrap();
        println!("[msg] B replied in #general + #mods");
        // Persist B's own #general view into the shared store (what sync/live ingest does)
        // and confirm it reads back via STATE — get_messages parity.
        let my_pk = b.keys.public_key();
        let gh = crate::simd::hex::bytes_to_hex_32(&general.0);
        for f in fetch_channel(&bed.relay, &b_view, &general, 100).await.unwrap() {
            let outcome = { let mut st = crate::state::STATE.lock().await; apply_chat_to_state(&mut st, &f.event, &gh, &my_pk) };
            if let Some(o) = outcome { persist_chat(&gh, &o).await; }
        }
        assert!(crate::db::events::event_exists(&m1).unwrap(), "A's message persisted into B's shared store (get_messages backfill)");
        println!("[persist] #general history persisted into the shared events store");

        // B (admin) reacts to + the author edits/deletes — the chat-op surface.
        send_reaction(&bed.relay, &b_view, &general, &m1, &a_hex, super::super::kind::MESSAGE, "🔥", None).await.unwrap();
        bed.swap_to(&a);
        let m_edit = send_message(&bed.relay, &community, &general, "A: this will be edited").await.unwrap();
        send_edit(&bed.relay, &community, &general, &m_edit, "A: edited!").await.unwrap();
        let m_del = send_message(&bed.relay, &community, &general, "A: this will be deleted").await.unwrap();
        send_delete(&bed.relay, &community, &general, &m_del, super::super::kind::MESSAGE).await.unwrap();
        println!("[ops] reaction + edit + delete round-tripped");

        // ── B creates a channel as admin, A folds it in ──
        bed.swap_to(&b);
        let bugs = create_public_channel(&bed.relay, &b_view, "bug-reports").await.unwrap();
        println!("[channel] B(admin) +public #bug-reports {}", crate::simd::hex::bytes_to_hex_32(&bugs.0));
        bed.swap_to(&a);
        let session = SessionGuard::capture();
        if let Some(updated) = follow_control(&bed.relay, &community, &session).await.unwrap() {
            community = updated;
        }
        assert!(community.channels.iter().any(|c| c.id.0 == bugs.0), "A folds in B's authorized new channel");
        println!("[follow] A folded in B's #bug-reports (now {} channels)", community.channels.len());

        // ── A creates a SECOND private channel while B is already a member. B is
        // NOT on its access list, so B learns the channel exists (control-follow,
        // keyless) and gets no key: CORD-03's private channel is readable only by
        // granted role-holders, never by every member. B keys up if and when A
        // grants them the channel's access role and vends the key ──
        let vault = create_private_channel(&bed.relay, &community, "vault").await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        send_message(&bed.relay, &community, &vault, "A: vault is open").await.unwrap();
        println!("[channel] +private #vault {} (B is unentitled — no delivery)", crate::simd::hex::bytes_to_hex_32(&vault.0));
        bed.swap_to(&b);
        let session_b2 = SessionGuard::capture();
        if let Some(fresh) = follow_control(&bed.relay, &b_view, &session_b2).await.unwrap() {
            b_view = fresh;
        }
        let ch = b_view.channel(&vault).expect("B recorded the announced private channel");
        assert!(ch.private && ch.key.is_none() && ch.epoch == Epoch(0), "B's record is keyless at cursor 0");
        let rf = follow_rekeys(&bed.relay, &b_view, &session_b2).await.unwrap();
        if let Some(fresh) = rf.updated {
            b_view = fresh;
        }
        let ch = b_view.channel(&vault).expect("still recorded");
        assert!(ch.key.is_none(), "an unentitled member is never delivered the key");
        assert!(
            texts_in(&bed.relay, &b_view, &vault).await.is_empty(),
            "and reads nothing from it"
        );
        assert!(
            send_message(&bed.relay, &b_view, &vault, "B: in the vault").await.is_err(),
            "an unentitled member cannot post into the channel either"
        );
        bed.swap_to(&a);
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        println!("[private] #vault stayed sealed to the unentitled B (no key, no read, no send)");

        // ── Members ──
        let members = memberlist(&bed.relay, &community).await.unwrap();
        let member_hexes: std::collections::BTreeSet<String> = members.iter().map(|m| m.to_hex()).collect();
        assert!(member_hexes.contains(&a_hex) && member_hexes.contains(&b_hex), "A + B both in the memberlist");
        println!("[members] {} members: A + B present", members.len());

        // ── Moderate: ban B (banlist + strip + refound), verify severance + survival ──
        set_banlist(&bed.relay, &community, &[b_hex.clone()]).await.unwrap();
        grant_roles(&bed.relay, &community, &b.keys.public_key(), vec![]).await.unwrap();
        let refounded = refound_community(&bed.relay, &community, &[b.keys.public_key()]).await.unwrap();
        assert_eq!(refounded.root_epoch, Epoch(1), "the ban rolled the root");
        let post = fold_authority(&refounded, &fetch_control(&bed.relay, &refounded).await, &load_floors(&refounded));
        assert!(post.banned.contains(&b_hex), "the ban survives the refounding");
        assert!(texts_in(&bed.relay, &refounded, &general).await.iter().any(|t| t == "A: welcome to the deep e2e"), "pre-ban history reads across the new epoch");
        assert!(
            texts_in(&bed.relay, &refounded, &priv_id).await.iter().any(|t| t == "A: mods-only channel"),
            "PRIVATE history reads across the channel's own rotation (per-channel multi-epoch archive)"
        );
        println!("[ban] B banned; root rolled to epoch 1; ban survives; pre-ban history intact (public + private)");
        // B concludes it's severed.
        bed.swap_to(&b);
        let session_b3 = SessionGuard::capture();
        assert!(follow_rekeys(&bed.relay, &b_view, &session_b3).await.unwrap().self_removed, "B is cryptographically cut by the ban-refound");
        println!("[ban] B's rekey-follow: self_removed = true (severed)");

        // ── Unban: A lifts the ban ──
        bed.swap_to(&a);
        set_banlist(&bed.relay, &refounded, &[]).await.unwrap();
        let after_unban = fold_authority(&refounded, &fetch_control(&bed.relay, &refounded).await, &load_floors(&refounded));
        assert!(!after_unban.banned.contains(&b_hex), "the unban clears B from the banlist");
        println!("[unban] B removed from the banlist (re-invitable)");

        // ── Dissolve ──
        dissolve_community(&bed.relay, &refounded).await.unwrap();
        assert!(crate::db::community::load_community_v2(community.id()).unwrap().unwrap().dissolved, "the community is sealed");
        println!("[dissolve] community sealed (read-only)\n===== e2e PASS =====\n");
    }

    /// The same scenario on a REAL relay with TWO throwaway accounts, off by default. It
    /// LOGS both nsecs (+ every id) so you can inspect the run and RE-RUN against the same
    /// accounts by exporting `VECTOR_E2E_NSEC_A` / `_B`. Set `VECTOR_E2E_LOG=<path>` to also
    /// append the transcript to a file, `VECTOR_E2E_RELAY=<url>` to pick the relay.
    ///   cargo test -p vector-core -- --ignored --nocapture live_e2e_two_accounts
    #[tokio::test]
    #[ignore]
    async fn live_e2e_two_accounts() {
        use crate::community::transport::LiveTransport;
        use nostr_sdk::prelude::ToBech32;

        let relay = std::env::var("VECTOR_E2E_RELAY").unwrap_or_else(|_| "wss://jskitty.com/nostr".to_string());
        let relays = vec![relay.clone()];
        let _g = crate::db::DB_TEST_GUARD.lock().unwrap_or_else(|e| e.into_inner());
        crate::db::close_database();
        crate::db::clear_id_caches();
        let tmp = tempfile::tempdir().unwrap();
        crate::db::set_app_data_dir(tmp.path().to_path_buf());

        // Throwaway (or bring-your-own via env for a re-run against the same accounts).
        let a = std::env::var("VECTOR_E2E_NSEC_A").ok().and_then(|n| Keys::parse(&n).ok()).unwrap_or_else(Keys::generate);
        let b = std::env::var("VECTOR_E2E_NSEC_B").ok().and_then(|n| Keys::parse(&n).ok()).unwrap_or_else(Keys::generate);

        let log = |line: String| {
            println!("{line}");
            if let Ok(p) = std::env::var("VECTOR_E2E_LOG") {
                use std::io::Write;
                if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(&p) {
                    let _ = writeln!(f, "{line}");
                }
            }
        };
        log(format!("===== LIVE Concord v2 e2e on {relay} ====="));
        log(format!("VECTOR_E2E_NSEC_A={}  ({})", a.secret_key().to_bech32().unwrap(), a.public_key().to_bech32().unwrap()));
        log(format!("VECTOR_E2E_NSEC_B={}  ({})", b.secret_key().to_bech32().unwrap(), b.public_key().to_bech32().unwrap()));

        for k in [&a, &b] {
            let npub = k.public_key().to_bech32().unwrap();
            std::fs::create_dir_all(tmp.path().join(&npub)).unwrap();
            crate::db::set_current_account(npub.clone()).unwrap();
            crate::db::init_database(&npub).unwrap();
        }
        // One relay connection: a v2 wrap is pre-signed (ephemeral p-key) and its seal is
        // signed by MY_SECRET_KEY, so publishing needs no per-account client signer.
        let client = crate::nostr_client_builder().build();
        client.add_managed_relay(relay.as_str()).await.ok();
        client.connect().await;
        crate::state::set_nostr_client(client);
        let transport = LiveTransport::with_timeout(std::time::Duration::from_secs(15));
        let become_acct = |k: &Keys| {
            let npub = k.public_key().to_bech32().unwrap();
            crate::db::set_current_account(npub.clone()).unwrap();
            crate::db::init_database(&npub).unwrap();
            crate::db::clear_id_caches();
            crate::state::MY_SECRET_KEY.store_from_keys(k, &[]);
            crate::state::set_my_public_key(k.public_key());
        };
        let settle = || tokio::time::sleep(std::time::Duration::from_secs(2));

        // A: create + a channel + grant B admin + mint link.
        become_acct(&a);
        let mut community = create_community(&transport, "Live E2E", relays.clone(), None).await.expect("create");
        let general = community.channels[0].id;
        log(format!("[create] community {} · #general {}", crate::simd::hex::bytes_to_hex_32(&community.id().0), crate::simd::hex::bytes_to_hex_32(&general.0)));
        send_message(&transport, &community, &general, "A: live hello").await.expect("send");
        let ann = create_public_channel(&transport, &community, "announcements").await.expect("channel");
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        log(format!("[channel] +public #announcements {}", crate::simd::hex::bytes_to_hex_32(&ann.0)));
        grant_admin(&transport, &community, &b.public_key()).await.expect("grant admin");
        let link = mint_public_link(&transport, &community, "https://vectorapp.io", None, None).await.expect("mint");
        log(format!("[invite] B granted @admin · link {}", link.url));
        let bundle_json = serde_json::to_string(&bundle_of(&community, BundleAudience::Link, Some(a.public_key()), None, None)).unwrap();
        settle().await;

        // B: join + read A's history + reply.
        become_acct(&b);
        let b_view = accept_parked_invite(&transport, &bundle_json, None).await.expect("join");
        log(format!("[join] B joined; {} channels", b_view.channels.len()));
        settle().await;
        let page = fetch_channel(&transport, &b_view, &general, 50).await.expect("fetch");
        let seen: Vec<String> = page.iter().map(|f| f.event.opened().rumor.content.clone()).collect();
        log(format!("[read] B sees #general: {seen:?}"));
        assert!(seen.iter().any(|t| t == "A: live hello"), "B reads A's message over the real relay");
        send_message(&transport, &b_view, &general, "B: live reply").await.expect("reply");

        // B posts a NIP-22 kind-1111 THREADED REPLY to A's message (the shape Armada
        // sends) directly onto the chat plane — proving the cross-client thread
        // RECEIVE path works live, not just in the offline fixture.
        let hello = page.iter().find(|f| f.event.opened().rumor.content == "A: live hello").expect("A's message");
        let hello_id = hello.event.opened().rumor_id.to_hex();
        let bkeys = crate::state::MY_SECRET_KEY.to_keys().unwrap();
        let cgroup = channel_group_key(&b_view.community_root, &general, b_view.root_epoch);
        let reply_rumor = chat::build_comment_rumor(bkeys.public_key(), &general, b_view.root_epoch, "B: threaded reply to hello", &hello_id, super::super::kind::MESSAGE, &a.public_key().to_hex(), None, &[], now_ms());
        let (reply_wrap, _) = chat::seal_chat_rumor(&reply_rumor, &cgroup, &bkeys, Timestamp::from_secs(now_ms() / 1000), false).expect("seal 1111");
        transport.publish(&reply_wrap, &b_view.relays).await.expect("publish 1111");
        log("[thread] B published a kind-1111 threaded reply to A's message".to_string());
        settle().await;

        // A reads the thread reply back, rendered inline with A's message as parent.
        become_acct(&a);
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let a_page = fetch_channel(&transport, &community, &general, 50).await.expect("A fetch");
        let thread = a_page.iter().find(|f| f.event.opened().rumor.content == "B: threaded reply to hello").expect("A sees the 1111");
        if let chat::ChatEvent::Message { reply_to, opened, .. } = &thread.event {
            assert_eq!(opened.rumor.kind.as_u16(), super::super::kind::COMMENT, "wire kind preserved as 1111");
            assert_eq!(reply_to.as_ref().map(|r| crate::simd::hex::bytes_to_hex_32(&r.id)), Some(hello_id.clone()), "the 1111 renders inline with A's message as parent");
        } else {
            panic!("the 1111 parsed as a Message");
        }
        log("[thread] A read B's threaded reply, parent resolved — cross-client 1111 interop OK".to_string());
        become_acct(&b);
        settle().await;

        // A: create a PRIVATE channel while B is already a member — B is a recipient
        // of the creation delivery, so B keys up from the rekey plane over the real
        // relay (no bundle involved), then the two converse on it.
        become_acct(&a);
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let vault = create_private_channel(&transport, &community, "vault").await.expect("private channel");
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        send_message(&transport, &community, &vault, "A: vault live").await.expect("vault send");
        log(format!("[channel] +private #vault {} (key delivered over the rekey plane)", crate::simd::hex::bytes_to_hex_32(&vault.0)));
        settle().await;

        become_acct(&b);
        let session_b = SessionGuard::capture();
        let mut b_view = crate::db::community::load_community_v2(b_view.id()).unwrap().unwrap();
        if let Some(fresh) = follow_control(&transport, &b_view, &session_b).await.expect("B control follow") {
            b_view = fresh;
        }
        if let Some(fresh) = follow_rekeys(&transport, &b_view, &session_b).await.expect("B rekey follow").updated {
            b_view = fresh;
        }
        let vch = b_view.channel(&vault).expect("B folded the vault");
        assert!(vch.key.is_some() && vch.epoch == Epoch(1), "B adopted the vault key from the live rekey plane");
        let vseen = texts_in(&transport, &b_view, &vault).await;
        log(format!("[read] B sees #vault: {vseen:?}"));
        assert!(vseen.iter().any(|t| t == "A: vault live"), "B reads the private channel with the ADOPTED key");
        send_message(&transport, &b_view, &vault, "B: in the live vault").await.expect("vault reply");
        settle().await;

        become_acct(&a);
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert!(
            texts_in(&transport, &community, &vault).await.iter().any(|t| t == "B: in the live vault"),
            "A reads B's private reply"
        );
        log("[private] two-way #vault conversation over the live relay".to_string());

        // A: ban B (three-removal) + dissolve.
        set_banlist(&transport, &community, &[b.public_key().to_hex()]).await.expect("banlist");
        grant_roles(&transport, &community, &b.public_key(), vec![]).await.expect("strip");
        let refounded = refound_community(&transport, &community, &[b.public_key()]).await.expect("refound");
        log(format!("[ban] B banned; root → epoch {}", refounded.root_epoch.0));
        settle().await;
        dissolve_community(&transport, &refounded).await.expect("dissolve");
        log("[dissolve] community sealed".to_string());
        log("===== LIVE e2e PASS =====".to_string());
    }

    #[tokio::test]
    async fn an_offline_member_learns_of_a_dissolution_on_catch_up() {
        // The tombstone rides its own public plane, watched live — an OFFLINE
        // member's catch-up must fetch it too, or they follow (and post into) a
        // grave forever.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Doomed", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        send_direct_invite(&bed.relay, &community, &member.keys.public_key(), None, None).await.unwrap();

        bed.swap_to(&member);
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let joined = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap();

        // The owner dissolves while the member sleeps.
        bed.swap_to(&owner);
        dissolve_community(&bed.relay, &community).await.unwrap();

        // The member's catch-up learns of the death, seals, and refuses to post.
        bed.swap_to(&member);
        let session = SessionGuard::capture();
        let follow = follow_rekeys(&bed.relay, &joined, &session).await.unwrap();
        assert!(follow.dissolved, "the catch-up surfaces the tombstone");
        assert!(!follow.self_removed && follow.updated.is_none());
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&joined.id().0);
        assert!(crate::db::community::get_community_dissolved(&cid_hex).unwrap(), "sealed read-only locally");
        let err = send_message(&bed.relay, &joined, &general, "into the void").await.unwrap_err();
        assert!(err.contains("dissolved"), "sends refuse a grave: {err}");
        // Subsequent follows take the local fast path — still dissolved, no churn.
        let again = follow_rekeys(&bed.relay, &joined, &session).await.unwrap();
        assert!(again.dissolved && again.updated.is_none());
    }

    #[tokio::test]
    async fn a_wide_community_survives_refoundings_and_an_offline_member_converges() {
        // Scale stress: MANY private channels, each rotated on every Refounding.
        // A member offline across two refoundings must converge on all of them
        // (the per-channel rotation fan in refound + the follow's channel×root×step
        // loops stay bounded) with every channel's history readable.
        const PRIV_CHANNELS: usize = 6;
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let mut community = create_community(&bed.relay, "Wide", bed.relays.clone(), None).await.unwrap();
        let mut priv_ids = Vec::new();
        for i in 0..PRIV_CHANNELS {
            let id = create_private_channel(&bed.relay, &community, &format!("priv{i}")).await.unwrap();
            community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
            send_message(&bed.relay, &community, &id, &format!("priv{i} epoch0")).await.unwrap();
            priv_ids.push(id);
        }
        // Private channels are readable only by granted role-holders (CORD-03).
        for id in &priv_ids {
            grant_channel_access(&bed.relay, &community, id, &member.keys.public_key()).await.unwrap();
        }
        let bundle_json = serde_json::to_string(&bundle_of(&community, BundleAudience::Member(member.keys.public_key()), Some(owner.keys.public_key()), None, None)).unwrap();

        // Member joins at epoch 0 with all channel keys, then goes offline.
        bed.swap_to(&member);
        let member_view = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        assert_eq!(member_view.channels.iter().filter(|c| c.private && c.key.is_some()).count(), PRIV_CHANNELS, "joined with all private keys");

        // Two refoundings (each rotates the base + every private channel).
        bed.swap_to(&owner);
        for epoch in 1..=2u64 {
            community = refound_community(&bed.relay, &community, &[]).await.unwrap();
            assert_eq!(community.root_epoch, Epoch(epoch));
            for id in &priv_ids {
                send_message(&bed.relay, &community, id, &format!("{} epoch{epoch}", crate::simd::hex::bytes_to_hex_32(&id.0))).await.unwrap();
            }
        }

        // Member returns: bounded follow to quiescence.
        bed.swap_to(&member);
        let session = SessionGuard::capture();
        let mut passes = 0;
        loop {
            passes += 1;
            assert!(passes <= 8, "a wide catch-up must converge, not churn (pass {passes})");
            let cur = crate::db::community::load_community_v2(member_view.id()).unwrap().unwrap();
            let rk = follow_rekeys(&bed.relay, &cur, &session).await.unwrap();
            assert!(!rk.self_removed);
            let cur = crate::db::community::load_community_v2(member_view.id()).unwrap().unwrap();
            let ctl = follow_control(&bed.relay, &cur, &session).await.unwrap();
            if rk.updated.is_none() && ctl.is_none() {
                break;
            }
        }
        let caught_up = crate::db::community::load_community_v2(member_view.id()).unwrap().unwrap();
        assert_eq!(caught_up.root_epoch, Epoch(2), "walked both refoundings");
        // Every private channel converged to the owner's current key + reads all epochs.
        for id in &priv_ids {
            let mine = caught_up.channel(id).expect("channel survived");
            let theirs = community.channel(id).unwrap();
            assert_eq!(mine.key, theirs.key, "channel {} converged on the owner key", crate::simd::hex::bytes_to_hex_32(&id.0));
            assert_eq!(mine.epoch, theirs.epoch, "…at the same epoch");
            let texts = texts_in(&bed.relay, &caught_up, id).await;
            let id_hex = crate::simd::hex::bytes_to_hex_32(&id.0);
            assert!(texts.iter().any(|t| t.contains("epoch0")), "channel {id_hex} reads epoch-0 history");
            for epoch in 1..=2u64 {
                assert!(texts.iter().any(|t| t.contains(&format!("epoch{epoch}"))), "channel {id_hex} reads epoch-{epoch} history");
            }
        }
    }

    #[tokio::test]
    async fn an_offline_member_catches_up_across_three_refoundings() {
        // The deep offline-online scenario: a member sleeps through THREE
        // Refoundings, per-refound private-channel rotations, a mid-life private
        // channel CREATED while they slept, a public channel, a rename, and a
        // ban — then returns and converges by follow alone (no rejoin).
        use nostr_sdk::prelude::ToBech32;
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let mut community = create_community(&bed.relay, "Sleeper", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        let mods = create_private_channel(&bed.relay, &community, "mods").await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        send_message(&bed.relay, &community, &general, "epoch0: hello").await.unwrap();
        send_message(&bed.relay, &community, &mods, "epoch0: mods secret").await.unwrap();
        // Private channels are readable only by granted role-holders (CORD-03).
        grant_channel_access(&bed.relay, &community, &mods, &member.keys.public_key()).await.unwrap();
        let bundle_json = serde_json::to_string(&bundle_of(&community, BundleAudience::Member(member.keys.public_key()), Some(owner.keys.public_key()), None, None)).unwrap();

        // Member joins at epoch 0, then goes OFFLINE.
        bed.swap_to(&member);
        let member_view = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        assert_eq!(member_view.root_epoch, Epoch(0));

        // While they sleep, the owner reshapes everything across three epochs.
        bed.swap_to(&owner);
        let stranger = Keys::generate();
        for epoch in 1..=3u64 {
            community = refound_community(&bed.relay, &community, &[]).await.unwrap();
            assert_eq!(community.root_epoch, Epoch(epoch));
            send_message(&bed.relay, &community, &general, &format!("epoch{epoch}: general news")).await.unwrap();
            send_message(&bed.relay, &community, &mods, &format!("epoch{epoch}: mods word")).await.unwrap();
        }
        let news = create_public_channel(&bed.relay, &community, "news").await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let vault = create_private_channel(&bed.relay, &community, "vault").await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        // The sleeper is on this channel's access list, so the refoundings that
        // follow deliver its key to them (CORD-03).
        grant_channel_access(&bed.relay, &community, &vault, &member.keys.public_key()).await.unwrap();
        community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        send_message(&bed.relay, &community, &vault, "epoch3: vault opened").await.unwrap();
        set_banlist(&bed.relay, &community, &[stranger.public_key().to_hex()]).await.unwrap();
        let meta = control::CommunityMetadata { name: "Sleeper Reborn".into(), relays: community.relays.clone(), ..Default::default() };
        edit_community_metadata(&bed.relay, &community, &meta).await.unwrap();

        // The member RETURNS: rekey+control follow to quiescence (the worker's
        // loop, driven explicitly). Bounded — convergence must be fast.
        bed.swap_to(&member);
        let session = SessionGuard::capture();
        let mut passes = 0;
        loop {
            passes += 1;
            assert!(passes <= 6, "catch-up must converge, not churn");
            let cur = crate::db::community::load_community_v2(member_view.id()).unwrap().unwrap();
            let rekeyed = follow_rekeys(&bed.relay, &cur, &session).await.unwrap();
            assert!(!rekeyed.self_removed, "the member was never removed");
            let cur = crate::db::community::load_community_v2(member_view.id()).unwrap().unwrap();
            let controlled = follow_control(&bed.relay, &cur, &session).await.unwrap();
            if rekeyed.updated.is_none() && controlled.is_none() {
                break;
            }
        }
        let caught_up = crate::db::community::load_community_v2(member_view.id()).unwrap().unwrap();

        // Base + name converged.
        assert_eq!(caught_up.root_epoch, Epoch(3), "walked all three refoundings");
        assert_eq!(caught_up.community_root, community.community_root, "landed on the owner's root");
        assert_eq!(caught_up.name, "Sleeper Reborn");
        // Channels: renamed set incl. the mid-sleep public + private ones.
        assert!(caught_up.channels.iter().any(|c| c.id.0 == news.0), "folded the new public channel");
        let m = caught_up.channel(&mods).expect("mods survived");
        let owner_mods = community.channel(&mods).unwrap();
        assert_eq!(m.epoch, owner_mods.epoch, "mods walked every per-refound rotation");
        assert_eq!(m.key, owner_mods.key, "…to the owner's exact key");
        let v = caught_up.channel(&vault).expect("vault folded in");
        // The sleeper is on vault's access list, but it was created AFTER the last
        // refounding — no rotation followed the grant, so no blob was ever
        // addressed to them. They hold the channel keyless until the grant's own
        // key vend lands (CORD-05 §6), which is what a rekey-only walk cannot do.
        assert!(v.private && v.key.is_none(), "vault folds in keyless: entitled, but never delivered");
        // Banlist survived the compactions.
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&caught_up.id().0);
        let banned = crate::db::community::get_community_banlist(&cid_hex).unwrap();
        assert!(banned.contains(&stranger.public_key().to_hex()), "the ban folded through");
        // History reads across EVERY epoch (public via base-root archive, private
        // via the per-channel archive built during the walk).
        let gen_texts = texts_in(&bed.relay, &caught_up, &general).await;
        for epoch in 0..=3u64 {
            let needle = if epoch == 0 { "epoch0: hello".to_string() } else { format!("epoch{epoch}: general news") };
            assert!(gen_texts.contains(&needle), "general history spans epoch {epoch}: {gen_texts:?}");
        }
        let mods_texts = texts_in(&bed.relay, &caught_up, &mods).await;
        for epoch in 0..=3u64 {
            let needle = if epoch == 0 { "epoch0: mods secret".to_string() } else { format!("epoch{epoch}: mods word") };
            assert!(mods_texts.contains(&needle), "private history spans epoch {epoch}: {mods_texts:?}");
        }
        // Keyless (above) means unreadable — a rekey walk cannot substitute for the
        // key vend that a grant carries.
        assert!(texts_in(&bed.relay, &caught_up, &vault).await.is_empty());
        // And the member can still speak.
        send_message(&bed.relay, &caught_up, &general, "member: good morning").await.unwrap();
        bed.swap_to(&owner);
        assert!(
            texts_in(&bed.relay, &community, &general).await.contains(&"member: good morning".to_string()),
            "the caught-up member converses at the new epoch ({})",
            member.keys.public_key().to_bech32().unwrap()
        );
    }

    /// Seal `n` messages onto a community's #general, one per second starting at
    /// `base_secs` (distinct wrap seconds so relay-side `until` paging engages).
    async fn flood_general(relay: &MemoryRelay, community: &CommunityV2, author: &Keys, n: usize, base_secs: u64) {
        let general = community.channels[0].id;
        let group = channel_group_key(&community.community_root, &general, community.root_epoch);
        for i in 0..n {
            let at = base_secs + i as u64;
            let rumor = chat::build_message_rumor(author.public_key(), &general, community.root_epoch, &format!("msg {i}"), None, &[], vec![], at * 1000);
            let (wrap, _) = chat::seal_chat_rumor(&rumor, &group, author, Timestamp::from_secs(at), false).unwrap();
            relay.publish(&wrap, &community.relays).await.unwrap();
        }
    }

    #[tokio::test]
    async fn the_history_walk_pages_past_a_multi_page_burst() {
        // A bot offline through 120 messages must catch ALL of them, not the
        // newest page — the v1 sync-gap class, closed by until-paging.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Burst", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        flood_general(&relay, &community, &owner, 120, 10_000).await;

        let all = fetch_channel_history(&relay, &community, &general, 50, 8, None, None, crate::community::transport::Evidence::Quorum, |_| true).await.unwrap();
        assert_eq!(all.len(), 120, "the walk pages the whole burst");
        // Oldest→newest, no duplicates.
        let contents: Vec<String> = all.iter().map(|f| f.event.opened().rumor.content.clone()).collect();
        assert_eq!(contents.first().map(String::as_str), Some("msg 0"));
        assert_eq!(contents.last().map(String::as_str), Some("msg 119"));
        let unique: std::collections::HashSet<&String> = contents.iter().collect();
        assert_eq!(unique.len(), 120, "wrap-id + rumor-id dedup holds across page boundaries");

        // The single-page fetch stays a single page.
        let one = fetch_channel(&relay, &community, &general, 50).await.unwrap();
        assert_eq!(one.len(), 50, "fetch_channel is one newest page");
        assert_eq!(one.last().map(|f| f.event.opened().rumor.content.clone()).as_deref(), Some("msg 119"));
    }

    #[tokio::test]
    async fn a_start_until_cursor_pages_history_from_that_point_backwards() {
        // The back-paging cursor: a walk that starts at an explicit `until`
        // returns only what lies at-or-before it, oldest→newest — the relay-side
        // half of the SDK's walk-until-dry loop.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Paged", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        flood_general(&relay, &community, &owner, 120, 10_000).await;

        let older = fetch_channel_history(
            &relay, &community, &general, 50, 8, None, Some(10_059),
            crate::community::transport::Evidence::Quorum, |_| true,
        )
        .await
        .unwrap();
        let contents: Vec<String> = older.iter().map(|f| f.event.opened().rumor.content.clone()).collect();
        assert_eq!(contents.len(), 60, "everything at-or-before the cursor, nothing after");
        assert_eq!(contents.first().map(String::as_str), Some("msg 0"));
        assert_eq!(contents.last().map(String::as_str), Some("msg 59"));
    }

    #[tokio::test]
    async fn the_history_walk_stops_when_the_caller_is_caught_up() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Caught", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        flood_general(&relay, &community, &owner, 120, 10_000).await;

        // The caller says "I hold everything" after the first page — no deeper fetch.
        let mut pages = 0usize;
        let got = fetch_channel_history(&relay, &community, &general, 50, 8, None, None, crate::community::transport::Evidence::Quorum, |_| {
            pages += 1;
            false
        })
        .await
        .unwrap();
        assert_eq!(pages, 1, "the early stop is consulted once");
        assert_eq!(got.len(), 50, "only the newest page is fetched");
        assert_eq!(got.last().map(|f| f.event.opened().rumor.content.clone()).as_deref(), Some("msg 119"));
    }

    #[tokio::test]
    async fn a_same_second_history_wall_terminates_instead_of_looping() {
        // 60 messages in ONE second with a 25-wrap page: a second-granular
        // `until` can never page past the wall — the walk must step over it
        // (bounded loss, logged) rather than spin.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Wall", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        let group = channel_group_key(&community.community_root, &general, community.root_epoch);
        for i in 0..60usize {
            let rumor = chat::build_message_rumor(owner.public_key(), &general, community.root_epoch, &format!("burst {i}"), None, &[], vec![], 5_000_000 + i as u64);
            let (wrap, _) = chat::seal_chat_rumor(&rumor, &group, &owner, Timestamp::from_secs(5_000), false).unwrap();
            relay.publish(&wrap, &community.relays).await.unwrap();
        }
        let got = fetch_channel_history(&relay, &community, &general, 25, 8, None, None, crate::community::transport::Evidence::Quorum, |_| true).await.unwrap();
        assert!(got.len() >= 25, "at least the relay page is read");
        assert!(got.len() <= 60, "sane bound");
        // Termination is the assertion: reaching here means the wall didn't loop.
    }

    #[tokio::test]
    async fn a_grant_revoke_survives_a_withholding_relay() {
        // Floor persistence on the delegation plane: after the owner revokes an admin,
        // a relay serving only the OLD (still owner-signed) grant can't resurrect it.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Revoke", vec!["wss://good".into()], None).await.unwrap();
        let admin = Keys::generate();
        let rid = "d4".repeat(32);
        publish_role(&relay, &community, &owner, &admin_role(&rid, Permissions::MANAGE_METADATA), 1).await;
        publish_grant(&relay, &community, &owner, &admin.public_key(), vec![rid.clone()], 1).await;
        let session = SessionGuard::capture();
        follow_control(&relay, &community, &session).await.unwrap(); // seed floors incl. the grant at v1
        publish_grant(&relay, &community, &owner, &admin.public_key(), vec![], 2).await; // revoke → grant floor v2
        follow_control(&relay, &community, &session).await.unwrap();

        // A stale relay serves only the grant prefix (v1, the live grant).
        inject_stale_prefix(&relay, &community, 1, "wss://stale").await;
        let mut stale = community.clone();
        stale.relays = vec!["wss://stale".into()];
        let floors = load_floors(&community);
        let editions = fetch_control(&relay, &stale).await;
        let authority = fold_authority(&stale, &editions, &floors);
        assert!(
            !authority.roles.is_authorized(&admin.public_key().to_hex(), Some(&owner.public_key().to_hex()), Permissions::MANAGE_METADATA),
            "the persisted grant floor refuses the rolled-back (re-granted) view"
        );
    }

    /// Load the current-epoch floors for a community (test mirror of follow_control).
    fn load_floors(community: &CommunityV2) -> Floors {
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        crate::db::community::get_all_edition_heads_full(&cid_hex)
            .unwrap_or_default()
            .into_iter()
            .filter(|(_, f)| f.0 == community.root_epoch.0)
            .map(|(e, f)| (e, (f.1, f.2, f.3)))
            .collect()
    }

    /// Fetch + open every control edition at a community's control plane (test helper).
    async fn fetch_control(relay: &MemoryRelay, community: &CommunityV2) -> Vec<ParsedEdition> {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let q = Query { kinds: vec![stream::KIND_WRAP], authors: vec![group.pk_hex()], limit: Some(500), ..Default::default() };
        relay
            .fetch(&q, &community.relays)
            .await
            .unwrap_or_default()
            .iter()
            .filter_map(|w| control::open_control_edition(w, &group).ok().map(|(ed, _)| ed))
            .collect()
    }

    #[tokio::test]
    async fn follow_control_is_a_noop_on_a_freshly_created_community() {
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Fresh", vec!["wss://r".into()], None).await.unwrap();
        let session = SessionGuard::capture();
        // Only the genesis editions exist; folding them reproduces the held view.
        assert!(follow_control(&relay, &community, &session).await.unwrap().is_none());
    }

    #[tokio::test]
    async fn follow_control_adds_a_new_public_channel_and_re_subscribes_it() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Grow", vec!["wss://r".into()], None).await.unwrap();
        let new_id = ChannelId([0x5a; 32]);
        publish_channel_edition(&relay, &community, &owner, &new_id, "announcements", false, 1, false).await;

        let session = SessionGuard::capture();
        let updated = follow_control(&relay, &community, &session).await.unwrap().expect("a new channel changed the view");
        assert_eq!(updated.channels.len(), 2);
        let added = updated.channel(&new_id).expect("the new channel folded in");
        assert_eq!(added.name, "announcements");
        assert!(!added.private);
        assert_eq!(added.key, None, "a public channel derives from the root (no stored key)");

        // The new channel is now in the realtime author-set (it would be subscribed).
        let authors = super::super::realtime::plane_authors(std::slice::from_ref(&updated));
        let addr = channel_group_key(&updated.community_root, &new_id, updated.root_epoch).pk();
        assert!(authors.contains(&addr), "the added channel joins the live subscription");

        // Persisted: a reload sees it too.
        let reloaded = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert!(reloaded.channel(&new_id).is_some());
    }

    #[tokio::test]
    async fn follow_control_renames_the_community_and_an_existing_channel() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Old Name", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        // A v2 metadata edition renames the community; a v2 channel edition renames #general.
        publish_community_meta(&relay, &community, &owner, "New Name", 2).await;
        publish_channel_edition(&relay, &community, &owner, &general, "lobby", false, 2, false).await;

        let session = SessionGuard::capture();
        let updated = follow_control(&relay, &community, &session).await.unwrap().unwrap();
        assert_eq!(updated.name, "New Name");
        assert_eq!(updated.channel(&general).unwrap().name, "lobby");
        assert_eq!(updated.channels.len(), 1, "a rename doesn't add a channel");
    }

    #[tokio::test]
    async fn follow_control_deletes_a_channel() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Prune", vec!["wss://r".into()], None).await.unwrap();
        let extra = ChannelId([0x77; 32]);
        let session = SessionGuard::capture();

        // The channel is first added and folded into the held view.
        publish_channel_edition(&relay, &community, &owner, &extra, "temp", false, 1, false).await;
        let with_extra = follow_control(&relay, &community, &session).await.unwrap().expect("added");
        assert!(with_extra.channel(&extra).is_some());

        // Then it's tombstoned — the delete (higher version) folds the held one back out.
        publish_channel_edition(&relay, &community, &owner, &extra, "temp", false, 2, true).await;
        let updated = follow_control(&relay, &with_extra, &session).await.unwrap().expect("removed");
        assert!(updated.channel(&extra).is_none(), "a deleted channel folds out");
        assert_eq!(updated.channels.len(), 1, "only #general remains");
    }

    /// Re-inject only the OLD prefix (every edition at/below `max_version`) of a
    /// community's control plane onto a second relay URL — the withholding-relay
    /// simulation: everything it serves is genuinely owner-signed, just stale.
    async fn inject_stale_prefix(relay: &MemoryRelay, community: &CommunityV2, max_version: u64, stale_relay: &str) {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let query = Query { kinds: vec![stream::KIND_WRAP], authors: vec![group.pk_hex()], limit: Some(500), ..Default::default() };
        let wraps = relay.fetch(&query, &community.relays).await.unwrap();
        for w in &wraps {
            if let Ok((ed, _)) = control::open_control_edition(w, &group) {
                if ed.version <= max_version {
                    relay.inject(w, &[stale_relay.to_string()]);
                }
            }
        }
    }

    #[tokio::test]
    async fn a_withholding_relay_cannot_roll_back_a_rename() {
        // W2 persisted floor: after adopting the owner's v2 rename, a relay serving
        // only the (owner-signed) v1 genesis must not revert the held name.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Original", vec!["wss://good".into()], None).await.unwrap();
        publish_community_meta(&relay, &community, &owner, "Renamed", 2).await;

        let session = SessionGuard::capture();
        let updated = follow_control(&relay, &community, &session).await.unwrap().expect("rename adopted");
        assert_eq!(updated.name, "Renamed");

        // The stale relay holds only the genesis prefix; point the follow at it.
        inject_stale_prefix(&relay, &community, 1, "wss://stale").await;
        let mut stale_view = updated.clone();
        stale_view.relays = vec!["wss://stale".into()];
        assert!(
            follow_control(&relay, &stale_view, &session).await.unwrap().is_none(),
            "a stale-only relay must not change the held view"
        );
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(held.name, "Renamed", "the persisted floor refuses the rollback");
    }

    #[tokio::test]
    async fn a_withholding_relay_cannot_resurrect_a_deleted_channel() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Prune2", vec!["wss://good".into()], None).await.unwrap();
        let extra = ChannelId([0x44; 32]);
        let session = SessionGuard::capture();

        // A same-content metadata edit: no visible change (None), but the floor must
        // still advance to v2 (so the genesis metadata can't re-present below).
        publish_community_meta(&relay, &community, &owner, "Prune2", 2).await;
        assert!(follow_control(&relay, &community, &session).await.unwrap().is_none());

        publish_channel_edition(&relay, &community, &owner, &extra, "temp", false, 1, false).await;
        let with_extra = follow_control(&relay, &community, &session).await.unwrap().expect("added");
        publish_channel_edition(&relay, &community, &owner, &extra, "temp", false, 2, true).await;
        let pruned = follow_control(&relay, &with_extra, &session).await.unwrap().expect("removed");
        assert!(pruned.channel(&extra).is_none());

        // The stale relay serves the add (v1) but withholds the delete (v2).
        inject_stale_prefix(&relay, &community, 1, "wss://stale").await;
        let mut stale_view = pruned.clone();
        stale_view.relays = vec!["wss://stale".into()];
        assert!(
            follow_control(&relay, &stale_view, &session).await.unwrap().is_none(),
            "the withheld delete must not resurrect the channel"
        );
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert!(held.channel(&extra).is_none(), "the deleted channel stays deleted");
    }

    #[tokio::test]
    async fn a_new_epoch_bootstraps_past_an_old_epoch_floor() {
        // The Armada-convergence carve-out: a Refounding compacts the chain and
        // re-wraps a detached head at the NEW epoch's control plane. The old epoch's
        // floor must not block it — epoch-filtering makes the entity bootstrap.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Before", vec!["wss://good".into()], None).await.unwrap();
        let session = SessionGuard::capture();
        publish_community_meta(&relay, &community, &owner, "Edited", 2).await;
        let updated = follow_control(&relay, &community, &session).await.unwrap().expect("edit adopted");
        assert_eq!(updated.name, "Edited");

        // Refounding lands (epoch bump saved by the rekey path); the compacted head
        // arrives DETACHED (high version, no prev) on the new epoch's plane.
        let mut refounded = updated.clone();
        refounded.root_epoch = crate::community::Epoch(1);
        crate::db::community::save_community_v2(&refounded).unwrap();
        publish_community_meta(&relay, &refounded, &owner, "Compacted", 5).await;

        let adopted = follow_control(&relay, &refounded, &session).await.unwrap().expect("compacted head adopted");
        assert_eq!(adopted.name, "Compacted", "a fresh epoch bootstraps despite the dangling prev");
        // The persisted floor is stamped with the epoch the FOLD ran under.
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let heads = crate::db::community::get_all_edition_heads_epoched(&cid_hex).unwrap();
        assert!(
            heads.get(&cid_hex).is_some_and(|(e, v, _)| *e == 1 && *v == 5),
            "the adopted head carries the fold's epoch + version"
        );
    }

    #[tokio::test]
    async fn a_same_version_owner_fork_at_the_floor_converges_to_the_deterministic_winner() {
        // Two owner-signed editions at the SAME version (publish retry / two owner
        // devices): every client must land on the lower-inner-id winner. A hash-strict
        // floor would wedge here forever while Armada converges — the floor must
        // CONVERGE instead (the v1 decide() rule).
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Fork", vec!["wss://r".into()], None).await.unwrap();
        let session = SessionGuard::capture();
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let genesis_hash = head_hash_on_relay(&relay, &community, &community.id().0).await.unwrap();

        publish_community_meta(&relay, &community, &owner, "Ours", 2).await;
        let ours = follow_control(&relay, &community, &session).await.unwrap().expect("ours adopted");
        assert_eq!(ours.name, "Ours");

        // Our committed v2 edition's tiebreak id.
        let our_inner = {
            let q = Query { kinds: vec![stream::KIND_WRAP], authors: vec![group.pk_hex()], limit: Some(500), ..Default::default() };
            let wraps = relay.fetch(&q, &community.relays).await.unwrap();
            wraps
                .iter()
                .find_map(|w| {
                    control::open_control_edition(w, &group)
                        .ok()
                        .filter(|(ed, _)| ed.version == 2 && ed.vsk == vsk::COMMUNITY_METADATA)
                        .map(|(ed, _)| ed.inner_id)
                })
                .unwrap()
        };

        // Craft the concurrent fork so it WINS the deterministic tiebreak (vary the
        // authored timestamp until its inner id is lower).
        let meta = control::CommunityMetadata { name: "Theirs".into(), ..Default::default() };
        let content = serde_json::to_string(&meta).unwrap();
        let mut ts = 2_000u64;
        let fork_wrap = loop {
            let rumor = control::build_edition_rumor(owner.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, 2, Some(&genesis_hash), &content, ts, None);
            let inner = rumor.id.unwrap().to_bytes();
            if inner < our_inner {
                break control::seal_control_edition(&rumor, &group, &owner, Timestamp::from_secs(ts)).unwrap().0;
            }
            ts += 1;
        };
        relay.publish(&fork_wrap, &community.relays).await.unwrap();

        let converged = follow_control(&relay, &ours, &session).await.unwrap().expect("fork winner adopted");
        assert_eq!(converged.name, "Theirs", "the floor converges to the lower-inner-id winner");
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let held = crate::db::community::get_edition_head_inner_id(&cid_hex, &cid_hex).unwrap();
        assert!(held.is_some_and(|h| h < our_inner), "the persisted floor's tiebreak key moved to the winner");
    }

    #[tokio::test]
    async fn an_anchored_prefix_applies_while_a_gap_above_awaits_the_missing_link() {
        // v2 chains to the floor; v4 arrives but its v3 link is withheld. The
        // chain-verified prefix (v2) applies NOW — refuse-downgrade holds for it —
        // while the detached v4 waits. When v3 lands, the chain heals to v4.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Prefix", vec!["wss://r".into()], None).await.unwrap();
        let session = SessionGuard::capture();
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);

        publish_community_meta(&relay, &community, &owner, "Two", 2).await;
        let v2_hash = head_hash_on_relay(&relay, &community, &community.id().0).await.unwrap();

        // Craft v3 (held back) and v4 (published, chained to the withheld v3).
        let c3 = serde_json::to_string(&control::CommunityMetadata { name: "Three".into(), ..Default::default() }).unwrap();
        let r3 = control::build_edition_rumor(owner.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, 3, Some(&v2_hash), &c3, 3_000, None);
        let (w3, _) = control::seal_control_edition(&r3, &group, &owner, Timestamp::from_secs(3_000)).unwrap();
        let (ed3, _) = control::open_control_edition(&w3, &group).unwrap();
        let c4 = serde_json::to_string(&control::CommunityMetadata { name: "Four".into(), ..Default::default() }).unwrap();
        let r4 = control::build_edition_rumor(owner.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, 4, Some(&ed3.self_hash), &c4, 4_000, None);
        let (w4, _) = control::seal_control_edition(&r4, &group, &owner, Timestamp::from_secs(4_000)).unwrap();
        relay.publish(&w4, &community.relays).await.unwrap();

        let updated = follow_control(&relay, &community, &session).await.unwrap().expect("the verified prefix applies");
        assert_eq!(updated.name, "Two", "the anchored prefix lands; the detached v4 does not");

        relay.publish(&w3, &community.relays).await.unwrap();
        let healed = follow_control(&relay, &updated, &session).await.unwrap().expect("the chain heals");
        assert_eq!(healed.name, "Four", "once the link arrives, the head advances past the prefix");
    }

    #[tokio::test]
    async fn paging_rescues_a_floor_link_evicted_from_the_newest_window() {
        // The held floor is v2; the owner publishes v3, then a flood of foreign junk
        // wraps fills the newest window, then v4. Page 1 sees only v4 (detached →
        // gapped); paging older must recover v3 (and the floor link) and heal to v4.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Paged", vec!["wss://r".into()], None).await.unwrap();
        let session = SessionGuard::capture();
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);

        publish_community_meta(&relay, &community, &owner, "Two", 2).await;
        let base = follow_control(&relay, &community, &session).await.unwrap().expect("floor at v2");
        publish_community_meta(&relay, &base, &owner, "Three", 3).await; // ts 1_000 (old)
        let v3_hash = head_hash_on_relay(&relay, &community, &community.id().0).await.unwrap();

        // Rogue flood occupying the newest window (sealed to the control plane, but
        // non-owner — the authority gate drops them; they only crowd the page).
        let rogue = Keys::generate();
        for i in 0..(FOLLOW_PAGE as u64 - 1) {
            let rumor = control::build_edition_rumor(rogue.public_key(), vsk::CHANNEL_METADATA, &[0xCC; 32], 1, None, "{\"name\":\"junk\",\"private\":false}", 4_000 + i, None);
            let (w, _) = control::seal_control_edition(&rumor, &group, &rogue, Timestamp::from_secs(4_000 + i)).unwrap();
            relay.publish(&w, &community.relays).await.unwrap();
        }
        // v4 chained to the real v3 (crafted directly: the flood also blinds the
        // helper's own newest-window head lookup), timestamped newest of all.
        let c4 = serde_json::to_string(&control::CommunityMetadata { name: "Four".into(), ..Default::default() }).unwrap();
        let r4 = control::build_edition_rumor(owner.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, 4, Some(&v3_hash), &c4, 10_000, None);
        let (w4, _) = control::seal_control_edition(&r4, &group, &owner, Timestamp::from_secs(10_000)).unwrap();
        relay.publish(&w4, &community.relays).await.unwrap();

        let healed = follow_control(&relay, &base, &session).await.unwrap().expect("paging recovered the chain");
        assert_eq!(healed.name, "Four", "the gap paged past the flood to the floor link");
    }

    #[tokio::test]
    async fn a_follow_after_delete_does_not_resurrect_the_community() {
        // A leave/delete racing an in-flight follow: the follow must not re-insert
        // the community row or floor rows past delete_community's wipe.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Gone", vec!["wss://r".into()], None).await.unwrap();
        publish_community_meta(&relay, &community, &owner, "Edited", 2).await;
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        crate::db::community::delete_community(&cid_hex).unwrap();

        let session = SessionGuard::capture();
        assert!(
            follow_control(&relay, &community, &session).await.unwrap().is_none(),
            "a follow racing a delete is a no-op"
        );
        assert!(crate::db::community::load_community_v2(community.id()).unwrap().is_none(), "the community stays deleted");
        assert!(crate::db::community::edition_head_entity_ids(&cid_hex).unwrap().is_empty(), "no orphan floor rows");
    }

    #[tokio::test]
    async fn a_rekey_follow_after_delete_does_not_resurrect_the_community() {
        // The rekey sibling of the follow_control guard: an owner rotation adopted
        // mid-race must not upsert the community row back after a leave/delete.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "GoneKeys", vec!["wss://r".into()], None).await.unwrap();
        let new_root = [0xB2; 32];
        publish_base_rotation(&relay, &community, &owner, &[owner.public_key()], &new_root, &community.community_root).await;
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        crate::db::community::delete_community(&cid_hex).unwrap();

        let session = SessionGuard::capture();
        let follow = follow_rekeys(&relay, &community, &session).await.unwrap();
        assert!(follow.updated.is_none() && !follow.self_removed, "a rekey follow racing a delete adopts nothing");
        assert!(crate::db::community::load_community_v2(community.id()).unwrap().is_none(), "the community stays deleted");
    }

    #[tokio::test]
    async fn a_joiner_bootstraps_the_highest_head_across_a_lost_middle_edition() {
        // {v1, v3} on the relays with v2 lost at publish time (a rate-limiting relay
        // that still ACKed): the genesis anchors, so an anchored-prefix-first fold
        // would take v1 and SEED the joiner's floor there — pinning them below the
        // head Armada shows, forever. A joiner (floor 0) must bootstrap v3.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Skip", bed.relays.clone(), None).await.unwrap();
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let genesis_hash = head_hash_on_relay(&bed.relay, &community, &community.id().0).await.unwrap();

        // v2 is crafted but NEVER published; v3 chains to it and is published.
        let c2 = serde_json::to_string(&control::CommunityMetadata { name: "Two".into(), ..Default::default() }).unwrap();
        let r2 = control::build_edition_rumor(owner.keys.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, 2, Some(&genesis_hash), &c2, 2_000, None);
        let (w2, _) = control::seal_control_edition(&r2, &group, &owner.keys, Timestamp::from_secs(2_000)).unwrap();
        let (ed2, _) = control::open_control_edition(&w2, &group).unwrap();
        let c3 = serde_json::to_string(&control::CommunityMetadata { name: "Three".into(), ..Default::default() }).unwrap();
        let r3 = control::build_edition_rumor(owner.keys.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, 3, Some(&ed2.self_hash), &c3, 3_000, None);
        let (w3, _) = control::seal_control_edition(&r3, &group, &owner.keys, Timestamp::from_secs(3_000)).unwrap();
        bed.relay.publish(&w3, &community.relays).await.unwrap();

        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        bed.swap_to(&member);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, None).await.unwrap();
        assert_eq!(joined.name, "Three", "the joiner bootstraps the highest signed head, not the anchored stale prefix");
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&joined.id().0);
        let head = crate::db::community::get_edition_head(&cid_hex, &cid_hex).unwrap();
        assert!(head.is_some_and(|(v, _)| v == 3), "the seeded floor is the bootstrap head");
    }

    #[tokio::test]
    async fn a_losing_same_version_fork_cannot_replace_the_held_floor() {
        // The refusal half of fork convergence: a relay withholding OUR committed
        // floor edition while serving only a same-version fork with a HIGHER inner
        // id must be treated as withholding — held state and floor unchanged.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Fork2", vec!["wss://good".into()], None).await.unwrap();
        let session = SessionGuard::capture();
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let genesis_hash = head_hash_on_relay(&relay, &community, &community.id().0).await.unwrap();

        publish_community_meta(&relay, &community, &owner, "Ours", 2).await;
        let ours = follow_control(&relay, &community, &session).await.unwrap().expect("ours adopted");
        assert_eq!(ours.name, "Ours");
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let held_before = crate::db::community::get_edition_head(&cid_hex, &cid_hex).unwrap().unwrap();
        let our_inner = crate::db::community::get_edition_head_inner_id(&cid_hex, &cid_hex).unwrap().unwrap();

        // Grind the fork to LOSE the tiebreak (higher inner id), then serve it —
        // with the genesis but WITHOUT our v2 — from a withholding relay.
        let meta = control::CommunityMetadata { name: "Theirs".into(), ..Default::default() };
        let content = serde_json::to_string(&meta).unwrap();
        let mut ts = 5_000u64;
        let fork_wrap = loop {
            let rumor = control::build_edition_rumor(owner.public_key(), vsk::COMMUNITY_METADATA, &community.id().0, 2, Some(&genesis_hash), &content, ts, None);
            if rumor.id.unwrap().to_bytes() > our_inner {
                break control::seal_control_edition(&rumor, &group, &owner, Timestamp::from_secs(ts)).unwrap().0;
            }
            ts += 1;
        };
        inject_stale_prefix(&relay, &community, 1, "wss://stale").await; // genesis only
        relay.inject(&fork_wrap, &["wss://stale".to_string()]);
        let mut stale_view = ours.clone();
        stale_view.relays = vec!["wss://stale".into()];

        assert!(
            follow_control(&relay, &stale_view, &session).await.unwrap().is_none(),
            "a losing fork served without our floor edition changes nothing"
        );
        let held_after = crate::db::community::get_edition_head(&cid_hex, &cid_hex).unwrap().unwrap();
        assert_eq!(held_after, held_before, "the floor row is untouched");
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(held.name, "Ours", "the held state is untouched");
    }

    #[tokio::test]
    async fn follow_control_ignores_a_non_owner_edition() {
        // A member holds the community_root, so they CAN seal a control edition —
        // but they aren't the owner, so the authority gate drops it (first cut:
        // owner-only). The rogue channel must never appear.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Guarded", vec!["wss://r".into()], None).await.unwrap();
        let rogue = Keys::generate();
        let rogue_id = ChannelId([0x99; 32]);
        publish_channel_edition(&relay, &community, &rogue, &rogue_id, "backdoor", false, 1, false).await;

        let session = SessionGuard::capture();
        assert!(
            follow_control(&relay, &community, &session).await.unwrap().is_none(),
            "a non-owner control edition is not folded"
        );
    }

    #[tokio::test]
    async fn follow_control_records_a_new_private_channel_keyless_and_unreadable() {
        // A Private channel's key rides the rekey plane, not the control edition —
        // control-follow records it KEYLESS (epoch 0, the rekey-scan cursor), and
        // every read/send path refuses it until the key lands (never the root plane).
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Priv", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = ChannelId([0x33; 32]);
        publish_channel_edition(&relay, &community, &owner, &priv_id, "mods", true, 1, false).await;

        let session = SessionGuard::capture();
        let updated = follow_control(&relay, &community, &session)
            .await
            .unwrap()
            .expect("the keyless record is a change");
        let ch = updated.channel(&priv_id).expect("the private channel is recorded");
        assert!(ch.private && ch.key.is_none(), "recorded keyless");
        assert_eq!(ch.epoch, Epoch(0), "epoch 0 = the root generation (scan cursor)");
        assert!(updated.channel_read_coords(ch).is_empty(), "unreadable until keyed");
        assert!(
            fetch_channel(&relay, &updated, &priv_id, 50).await.unwrap().is_empty(),
            "a keyless fetch returns empty (and never queries the root plane)"
        );
        assert!(
            send_message(&relay, &updated, &priv_id, "nope").await.is_err(),
            "a keyless send refuses"
        );
        // The keyless record round-trips (the stored placeholder never surfaces
        // as a real key).
        let reloaded = crate::db::community::load_community_v2(updated.id()).unwrap().unwrap();
        let rch = reloaded.channel(&priv_id).unwrap();
        assert!(rch.private && rch.key.is_none() && rch.epoch == Epoch(0), "keyless survives reload");
        // And a bundle minted while keyless never carries the placeholder — a
        // MEMBER audience, so it's the keyless filter proving it (the link
        // filter would drop the channel for the weaker reason).
        let bundle = bundle_of(&reloaded, BundleAudience::Member(Keys::generate().public_key()), None, None, None);
        assert!(
            !bundle.channels.iter().any(|c| c.id == crate::simd::hex::bytes_to_hex_32(&priv_id.0)),
            "an ungrantable keyless channel stays out of invite bundles"
        );
    }

    #[tokio::test]
    async fn a_link_bundle_never_carries_a_private_channel_key() {
        // A link's audience holds no Role by construction (CORD-05), so a HELD
        // private key must never ride a link bundle — anyone with the URL would
        // get the channel. A member bundle carries it; a link bundle only the
        // public channels.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Leak", vec!["wss://r".into()], None).await.unwrap();
        create_private_channel(&relay, &community, "mods").await.unwrap();
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let priv_hex = held
            .channels
            .iter()
            .find(|c| c.private)
            .map(|c| crate::simd::hex::bytes_to_hex_32(&c.id.0))
            .expect("the private channel is held WITH its key");

        let link = bundle_of(&held, BundleAudience::Link, None, None, None);
        assert!(
            !link.channels.iter().any(|c| c.id == priv_hex),
            "a held private key must never ride a link bundle"
        );
        assert!(
            link.channels.iter().any(|c| c.id != priv_hex),
            "the public channels still ride it"
        );

        // A member bundle grants it only to the ENTITLED. An unrelated npub holds
        // no scoped role, so it gets nothing; the creator (granted the companion
        // access role at create) gets the key.
        let stranger = bundle_of(&held, BundleAudience::Member(Keys::generate().public_key()), None, None, None);
        assert!(
            !stranger.channels.iter().any(|c| c.id == priv_hex),
            "an unentitled member gets no private key"
        );
        let mine = bundle_of(&held, BundleAudience::Member(me_pk().unwrap()), None, None, None);
        assert!(
            mine.channels.iter().any(|c| c.id == priv_hex),
            "the creator is entitled via the companion access role"
        );
    }

    #[tokio::test]
    async fn a_private_channel_mints_its_access_role_and_entitlement_follows_the_grant() {
        // CORD-03/04: the roles scoped to a channel ARE its access list. Proven
        // against a NON-owner so the owner-is-always-entitled rule can't carry it.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Scoped", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = create_private_channel(&relay, &community, "mods").await.unwrap();
        let chan_hex = crate::simd::hex::bytes_to_hex_32(&priv_id.0);
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);

        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        let access = roster.channel_roles(&chan_hex);
        assert_eq!(access.len(), 1, "the channel minted exactly one access role");
        assert!(
            access[0].permissions == crate::community::roles::Permissions::empty(),
            "the access role confers READ access (key possession), never authority"
        );
        assert_eq!(access[0].name, "mods", "named for its channel");

        // A stranger holds no scoped role: unentitled, and no key rides their bundle.
        let stranger = Keys::generate().public_key();
        let owner_hex = community.owner().unwrap().to_hex();
        assert!(!roster.is_entitled(Some(&owner_hex), &stranger.to_hex(), &chan_hex, &[], &[]));

        // Granting the access role entitles them; revoking un-entitles them. Both
        // proven through the roster, which is what routes keys.
        let role_id = access[0].role_id.clone();
        assert!(
            roster.is_entitled(Some(&owner_hex), &stranger.to_hex(), &chan_hex, std::slice::from_ref(&role_id), &[]),
            "the grant overlay entitles before the fold catches up"
        );

        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        grant_channel_access(&relay, &held, &priv_id, &stranger).await.unwrap();
        let after = crate::db::community::get_community_roles(&cid_hex).unwrap();
        assert!(
            after.is_entitled(Some(&owner_hex), &stranger.to_hex(), &chan_hex, &[], &[]),
            "the grant landed in the local roster (the fold runs later)"
        );
        let vend = bundle_of(&held, BundleAudience::Member(stranger), None, None, None);
        assert!(
            vend.channels.iter().any(|c| c.id == chan_hex),
            "a now-entitled member's bundle carries the channel key"
        );

        revoke_channel_access(&relay, &held, &priv_id, &stranger).await.unwrap();
        let after = crate::db::community::get_community_roles(&cid_hex).unwrap();
        assert!(
            !after.is_entitled(Some(&owner_hex), &stranger.to_hex(), &chan_hex, &[], &[]),
            "the revoke dropped the access role"
        );
        let rotated = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(
            rotated.channel(&priv_id).unwrap().epoch,
            Epoch(2),
            "the revoke rotated the channel — a removal that doesn't rekey severs nobody"
        );

        // The access summary a bot reads back: roles, holders, and key state.
        let access = crate::VectorCore.channel_access(&cid_hex, &chan_hex).unwrap();
        assert_eq!(access["private"], true);
        assert_eq!(access["readable"], true, "we minted it, so we hold its key");
        assert_eq!(access["roles"].as_array().unwrap().len(), 1, "one access role");
        let holders = access["members"].as_array().unwrap();
        let me_npub = {
            use nostr_sdk::prelude::ToBech32;
            me_pk().unwrap().to_bech32().unwrap()
        };
        assert_eq!(holders.len(), 1, "only the creator holds it — the revoked member is gone");
        assert_eq!(holders[0], serde_json::json!(me_npub), "and that holder is the creator");
    }

    #[tokio::test]
    async fn a_vended_key_parks_until_the_fold_proves_the_grant_then_adopts() {
        // JSKitty's race: the vend can land BEFORE the control fold that proves
        // the grant. It must park quietly (a lagging fold is not an anomaly) and
        // be adopted on the re-judge once the roster catches up.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Vend", bed.relays.clone(), None).await.unwrap();
        let priv_id = create_private_channel(&bed.relay, &community, "mods").await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let chan_hex = crate::simd::hex::bytes_to_hex_32(&priv_id.0);
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let real_key = held.channel(&priv_id).unwrap().key.unwrap();
        let owner_hex = community.owner().unwrap().to_hex();

        // Judge as the MEMBER — the owner is always entitled, so only a non-owner
        // can exercise the grant rule at all.
        bed.swap_to(&member);
        let me = member.keys.public_key().to_hex();
        // Their fold has the channel (control-follow records it keyless) but not
        // yet the grant that entitles them.
        let mut member_view = held.clone();
        if let Some(c) = member_view.channels.iter_mut().find(|c| c.id.0 == priv_id.0) {
            c.key = None;
            c.epoch = Epoch(0);
        }

        // Ungranted → PARK, never refuse: this is exactly the "not synced enough
        // to judge" case, and it must stay quiet and retryable.
        let empty = crate::community::roles::CommunityRoles::default();
        assert!(matches!(
            judge_channel_key_vend(&member_view, &empty, &priv_id, Epoch(1), &owner_hex),
            VendVerdict::Park(_)
        ));

        // A channel our fold says is PUBLIC never heals — that's a spoof shape.
        let mut public_view = member_view.clone();
        if let Some(c) = public_view.channels.iter_mut().find(|c| c.id.0 == priv_id.0) {
            c.private = false;
        }
        assert!(matches!(
            judge_channel_key_vend(&public_view, &empty, &priv_id, Epoch(1), &owner_hex),
            VendVerdict::Refuse(_)
        ));

        // An unknown channel parks (our fold may simply be behind), never refuses.
        assert!(matches!(
            judge_channel_key_vend(&member_view, &empty, &ChannelId([0x77; 32]), Epoch(1), &owner_hex),
            VendVerdict::Park(_)
        ));

        // Park the vend, then re-judge with a roster that still lacks our grant:
        // it must SURVIVE, not be discarded.
        crate::db::community::park_channel_key(&cid_hex, &chan_hex, 1, &real_key, &owner_hex).unwrap();
        crate::db::community::set_community_roles(&cid_hex, &empty, 0).unwrap();
        crate::db::community::save_community_v2(&member_view).unwrap();
        let session = SessionGuard::capture();
        let reloaded = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert!(absorb_parked_channel_keys(&reloaded, &session).is_empty(), "unprovable vend adopts nothing");
        assert_eq!(
            crate::db::community::get_pending_channel_keys(&cid_hex).unwrap().len(),
            1,
            "and stays parked for the next fold"
        );

        // The fold catches up: our grant lands, so the same vend now adopts.
        let access = crate::community::roles::Role {
            role_id: "44".repeat(32),
            name: "mods".into(),
            position: u32::MAX - 1,
            permissions: crate::community::roles::Permissions::empty(),
            scope: crate::community::roles::RoleScope::Channel(chan_hex.clone()),
            color: 0,
        };
        let folded = crate::community::roles::CommunityRoles {
            grants: vec![crate::community::roles::MemberGrant { member: me.clone(), role_ids: vec![access.role_id.clone()] }],
            roles: vec![access],
        };
        crate::db::community::set_community_roles(&cid_hex, &folded, 1).unwrap();
        let reloaded = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let adopted = absorb_parked_channel_keys(&reloaded, &session);
        assert_eq!(adopted.len(), 1, "the re-judge adopts once the grant folds");

        let after = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let ch = after.channel(&priv_id).unwrap();
        assert_eq!(ch.key, Some(real_key), "adopted the vended key");
        assert_eq!(ch.epoch, Epoch(1));
        assert!(
            crate::db::community::get_pending_channel_keys(&cid_hex).unwrap().is_empty(),
            "and the park is discharged"
        );
    }

    #[tokio::test]
    async fn a_vend_at_epoch_zero_is_adopted_onto_a_keyless_channel() {
        // Live cross-client finding: a peer that mints born-private channels at
        // epoch 0 vends epoch 0, which collides with our keyless cursor (also 0).
        // The monotonic guard (`new > current`) would refuse the only key we are
        // ever offered, and refuse it SILENTLY. First delivery is not a rotation.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "EpochZero", bed.relays.clone(), None).await.unwrap();
        let priv_id = create_private_channel(&bed.relay, &community, "mods").await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let chan_hex = crate::simd::hex::bytes_to_hex_32(&priv_id.0);
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let vended = [0x5a; 32];
        let owner_hex = community.owner().unwrap().to_hex();

        bed.swap_to(&member);
        // The member's view: channel known, keyless, parked at the epoch-0 cursor.
        let mut member_view = held.clone();
        if let Some(c) = member_view.channels.iter_mut().find(|c| c.id.0 == priv_id.0) {
            c.key = None;
            c.epoch = Epoch(0);
        }
        crate::db::community::save_community_v2(&member_view).unwrap();

        // Entitle them, then park a vend AT EPOCH 0 (what the peer actually sends).
        let access = crate::community::roles::Role {
            role_id: "77".repeat(32),
            name: "mods".into(),
            position: u32::MAX - 1,
            permissions: crate::community::roles::Permissions::empty(),
            scope: crate::community::roles::RoleScope::Channel(chan_hex.clone()),
            color: 0,
        };
        let roster = crate::community::roles::CommunityRoles {
            grants: vec![crate::community::roles::MemberGrant {
                member: member.keys.public_key().to_hex(),
                role_ids: vec![access.role_id.clone()],
            }],
            roles: vec![access],
        };
        crate::db::community::set_community_roles(&cid_hex, &roster, 1).unwrap();
        crate::db::community::park_channel_key(&cid_hex, &chan_hex, 0, &vended, &owner_hex).unwrap();

        let session = SessionGuard::capture();
        let reloaded = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let adopted = absorb_parked_channel_keys(&reloaded, &session);
        assert_eq!(adopted.len(), 1, "an epoch-0 vend onto a keyless channel is adopted");

        let after = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let ch = after.channel(&priv_id).unwrap();
        assert_eq!(ch.key, Some(vended), "the key actually landed on the row");
        assert_eq!(ch.epoch, Epoch(0), "at the epoch the vendor named");
        assert!(
            !after.channel_read_coords(ch).is_empty(),
            "and the channel is readable — the whole point"
        );
        assert!(
            crate::db::community::get_pending_channel_keys(&cid_hex).unwrap().is_empty(),
            "the park is discharged"
        );
    }

    #[tokio::test]
    async fn a_wildly_ahead_vend_epoch_is_refused_not_seated() {
        // The channel head is MONOTONIC, so over-advancing it can never be walked
        // back: every genuine rotation afterwards lands at head+1, reads as stale,
        // and the channel dies for us with no heal path at all. An entitled
        // insider vending a garbage key costs isolation (accepted); one vending a
        // garbage EPOCH would cost the channel permanently, which is not.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Poison", bed.relays.clone(), None).await.unwrap();
        let priv_id = create_private_channel(&bed.relay, &community, "mods").await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let chan_hex = crate::simd::hex::bytes_to_hex_32(&priv_id.0);
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let owner_hex = community.owner().unwrap().to_hex();

        bed.swap_to(&member);
        let mut member_view = held.clone();
        if let Some(c) = member_view.channels.iter_mut().find(|c| c.id.0 == priv_id.0) {
            c.key = None;
            c.epoch = Epoch(0);
        }
        crate::db::community::save_community_v2(&member_view).unwrap();
        let access = crate::community::roles::Role {
            role_id: "99".repeat(32),
            name: "mods".into(),
            position: u32::MAX - 1,
            permissions: crate::community::roles::Permissions::empty(),
            scope: crate::community::roles::RoleScope::Channel(chan_hex.clone()),
            color: 0,
        };
        let roster = crate::community::roles::CommunityRoles {
            grants: vec![crate::community::roles::MemberGrant {
                member: member.keys.public_key().to_hex(),
                role_ids: vec![access.role_id.clone()],
            }],
            roles: vec![access],
        };
        crate::db::community::set_community_roles(&cid_hex, &roster, 1).unwrap();
        let reloaded = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();

        // Everything else about this vend is valid — only the epoch is absurd.
        assert!(matches!(
            judge_channel_key_vend(&reloaded, &roster, &priv_id, Epoch(1 << 40), &owner_hex),
            VendVerdict::Refuse(_)
        ));
        // REFUSED, not parked: a row nothing can ever discharge is its own leak.
        crate::db::community::park_channel_key(&cid_hex, &chan_hex, 1 << 40, &[0xEE; 32], &owner_hex).unwrap();
        let session = SessionGuard::capture();
        assert!(absorb_parked_channel_keys(&reloaded, &session).is_empty(), "a poison epoch adopts nothing");
        assert!(
            crate::db::community::get_pending_channel_keys(&cid_hex).unwrap().is_empty(),
            "and the row is discharged rather than parked forever"
        );
        // The head is untouched, so the genuine vend still lands afterwards.
        let after = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(after.channel(&priv_id).unwrap().epoch, Epoch(0), "head never advanced");
        assert!(matches!(
            judge_channel_key_vend(&after, &roster, &priv_id, Epoch(1), &owner_hex),
            VendVerdict::Accept
        ));
    }

    #[tokio::test]
    async fn a_channel_rename_lands_locally_without_waiting_for_the_fold() {
        // The fold is the authority but runs later, so publishing alone leaves the
        // edit reading back stale — it looks like the rename silently failed.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Renames", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = create_private_channel(&relay, &community, "mods").await.unwrap();
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let key_before = held.channel(&priv_id).unwrap().key;

        let mut meta = held.channel(&priv_id).unwrap().metadata();
        meta.name = "staff".into();
        edit_channel_metadata(&relay, &held, &priv_id, &meta).await.unwrap();

        let after = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let ch = after.channel(&priv_id).unwrap();
        assert_eq!(ch.name, "staff", "the rename is visible immediately");
        assert!(ch.private, "and privacy survives the edit");
        assert_eq!(ch.key, key_before, "as does the key — a rename is not a rotation");
    }

    #[tokio::test]
    async fn a_channel_rename_carries_its_companion_access_role() {
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Renames", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = create_private_channel(&relay, &community, "mods").await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let chan_hex = crate::simd::hex::bytes_to_hex_32(&priv_id.0);

        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        let before = roster.channel_roles(&chan_hex);
        assert_eq!(before.len(), 1, "one companion role, minted at create");
        assert_eq!(before[0].name, "mods", "named after the channel it gates");
        let role_id = before[0].role_id.clone();

        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let mut meta = held.channel(&priv_id).unwrap().metadata();
        meta.name = "staff".into();
        edit_channel_metadata(&relay, &held, &priv_id, &meta).await.unwrap();

        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        let after = roster.channel_roles(&chan_hex);
        assert_eq!(after.len(), 1, "renamed in place, never duplicated");
        assert_eq!(after[0].role_id, role_id, "a rename is a versioned edit of the same id");
        assert_eq!(after[0].name, "staff", "the access role followed the channel");
        assert_eq!(
            after[0].permissions,
            crate::community::roles::Permissions::empty(),
            "and still confers read access, never authority"
        );
    }

    #[tokio::test]
    async fn a_customised_access_role_name_survives_a_channel_rename() {
        // The label is cosmetic — entitlement rides the scope. Overwriting a name
        // someone chose deliberately is the surprising half of "keep them in step".
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Renames", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = create_private_channel(&relay, &community, "mods").await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let chan_hex = crate::simd::hex::bytes_to_hex_32(&priv_id.0);

        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        let mut role = roster.channel_roles(&chan_hex)[0].clone();
        role.name = "Lab Insiders".into();
        set_role(&relay, &community, &role).await.unwrap();
        merge_local_roster(&cid_hex, Some(&role), None);

        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let mut meta = held.channel(&priv_id).unwrap().metadata();
        meta.name = "staff".into();
        edit_channel_metadata(&relay, &held, &priv_id, &meta).await.unwrap();

        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        assert_eq!(
            roster.channel_roles(&chan_hex)[0].name,
            "Lab Insiders",
            "a deliberate name is left alone"
        );
    }

    #[tokio::test]
    async fn a_squatted_park_row_cannot_suppress_the_genuine_vend() {
        // Parking is reachable by ANY npub that can gift-wrap us — the bundle
        // self-certifies and its inputs are public for a public community. With a
        // single slot per channel, a stranger could pre-park and the admin's real
        // vend would be a silent no-op, leaving the member keyless with no retry.
        // Candidates + judge-them-all is what closes that.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Squat", bed.relays.clone(), None).await.unwrap();
        let priv_id = create_private_channel(&bed.relay, &community, "mods").await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let chan_hex = crate::simd::hex::bytes_to_hex_32(&priv_id.0);
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let real_key = held.channel(&priv_id).unwrap().key.unwrap();
        let owner_hex = community.owner().unwrap().to_hex();

        bed.swap_to(&member);
        let mut member_view = held.clone();
        if let Some(c) = member_view.channels.iter_mut().find(|c| c.id.0 == priv_id.0) {
            c.key = None;
            c.epoch = Epoch(0);
        }
        crate::db::community::save_community_v2(&member_view).unwrap();
        let access = crate::community::roles::Role {
            role_id: "aa".repeat(32),
            name: "mods".into(),
            position: u32::MAX - 1,
            permissions: crate::community::roles::Permissions::empty(),
            scope: crate::community::roles::RoleScope::Channel(chan_hex.clone()),
            color: 0,
        };
        let roster = crate::community::roles::CommunityRoles {
            grants: vec![crate::community::roles::MemberGrant {
                member: member.keys.public_key().to_hex(),
                role_ids: vec![access.role_id.clone()],
            }],
            roles: vec![access],
        };
        crate::db::community::set_community_roles(&cid_hex, &roster, 1).unwrap();

        // A stranger squats FIRST, at a higher epoch than the genuine vend.
        let stranger = Keys::generate().public_key().to_hex();
        crate::db::community::park_channel_key(&cid_hex, &chan_hex, 9, &[0xBA; 32], &stranger).unwrap();
        // The admin's real vend arrives after, at the true epoch.
        crate::db::community::park_channel_key(&cid_hex, &chan_hex, 1, &real_key, &owner_hex).unwrap();
        assert_eq!(
            crate::db::community::get_pending_channel_keys(&cid_hex).unwrap().len(),
            2,
            "the squatter never displaces the genuine vend — both are candidates"
        );

        let session = SessionGuard::capture();
        let reloaded = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let adopted = absorb_parked_channel_keys(&reloaded, &session);
        assert_eq!(adopted.len(), 1, "exactly one adoption");

        let after = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let ch = after.channel(&priv_id).unwrap();
        assert_eq!(ch.key, Some(real_key), "the OWNER's key won, not the squatter's");
        assert_eq!(ch.epoch, Epoch(1), "at the genuine epoch");
        assert!(
            crate::db::community::get_pending_channel_keys(&cid_hex).unwrap().is_empty(),
            "and every candidate for the channel is discharged"
        );
    }

    #[tokio::test]
    async fn revoking_without_a_folded_access_role_refuses_instead_of_evicting_everyone() {
        // With no access role folded, the retained-set filter matches NOBODY, so
        // the rotation would cut off every legitimately entitled member while the
        // Grant it published revoked nothing. Reachable with no attacker: the
        // channel was made on another admin's client and its role hasn't folded.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "NoRole", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = create_private_channel(&relay, &community, "mods").await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let held = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        let before = held.channel(&priv_id).unwrap().epoch;

        // Neither the cache nor the plane serves the access role — a withholding
        // relay, or a channel minted on another admin's client. (Wiping only the
        // cache is no longer enough: the revoke re-fetches authority first.)
        crate::db::community::set_community_roles(&cid_hex, &crate::community::roles::CommunityRoles::default(), 0).unwrap();
        let mut blind = held.clone();
        blind.relays = vec!["wss://empty".into()];
        let err = revoke_channel_access(&relay, &blind, &priv_id, &Keys::generate().public_key())
            .await
            .unwrap_err();
        assert!(err.contains("has not folded"), "refuses with a retryable reason: {err}");

        let after = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(after.channel(&priv_id).unwrap().epoch, before, "and rotates nothing");
    }

    // ── Live rekey-follow ────────────────────────────────────────────────────

    /// Publish an owner-grammar base rotation (Refounding) delivering `new_root`
    /// to each recipient. `rotator` is the seal signer (owner for a legit rotation,
    /// a stranger for the authority test); `prev_key` is the root it claims to
    /// extend (mismatch → a fork).
    async fn publish_base_rotation(
        relay: &MemoryRelay,
        community: &CommunityV2,
        rotator: &Keys,
        recipients: &[PublicKey],
        new_root: &[u8; 32],
        prev_key: &[u8; 32],
    ) {
        let new_epoch = Epoch(community.root_epoch.0 + 1);
        let prev_epoch = community.root_epoch;
        let prev_commit = super::super::derive::epoch_key_commitment(prev_epoch, prev_key);
        let group = base_rekey_group_key(&community.community_root, community.id(), new_epoch);
        let blobs: Vec<_> = recipients
            .iter()
            .map(|r| rekey::build_blob_local(rotator.secret_key(), &rotator.public_key().to_bytes(), r, RekeyScope::Root, new_epoch, new_root).unwrap())
            .collect();
        let events = rekey::build_rekey_chunks_local(rotator, &group, RekeyScope::Root, new_epoch, prev_epoch, &prev_commit, &blobs, 2_000, my_authority_citation(community, &rotator.public_key()).as_ref()).unwrap();
        for e in &events {
            relay.publish(e, &community.relays).await.unwrap();
        }
    }

    /// Attach a Private channel (key + epoch) to a held community and persist it.
    fn add_private_channel(community: &mut CommunityV2, id: ChannelId, key: [u8; 32], epoch: Epoch) {
        community.channels.push(ChannelV2 { id, name: "mods".into(), private: true, key: Some(key), epoch, voice: None, meta_custom: None, meta_extra: Default::default() });
        crate::db::community::save_community_v2(community).unwrap();
    }

    #[tokio::test]
    async fn follow_rekeys_is_a_noop_without_rotations() {
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Still", vec!["wss://r".into()], None).await.unwrap();
        let session = SessionGuard::capture();
        let follow = follow_rekeys(&relay, &community, &session).await.unwrap();
        assert!(follow.updated.is_none() && !follow.self_removed, "no rotation → nothing to adopt");
    }

    #[tokio::test]
    async fn follow_rekeys_adopts_an_owner_base_rotation() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Refound", vec!["wss://r".into()], None).await.unwrap();
        let new_root = [0xB1; 32];
        // Owner rotates the base to epoch 1, delivering the new root to me.
        publish_base_rotation(&relay, &community, &owner, &[owner.public_key()], &new_root, &community.community_root).await;

        let session = SessionGuard::capture();
        let updated = follow_rekeys(&relay, &community, &session).await.unwrap().updated.expect("adopted");
        assert_eq!(updated.root_epoch, Epoch(1), "advanced one epoch");
        assert_eq!(updated.community_root, new_root, "adopted the fresh root");
        // The public channel now reads under the NEW root/epoch (its address moved).
        let addr = super::super::realtime::plane_authors(std::slice::from_ref(&updated));
        let general = updated.channels[0].id;
        let new_chat = channel_group_key(&new_root, &general, Epoch(1)).pk();
        assert!(addr.contains(&new_chat), "the public channel re-addresses under the new root");
    }

    #[tokio::test]
    async fn follow_rekeys_adopts_an_owner_private_channel_rotation() {
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let mut community = create_community(&relay, "PrivRot", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = ChannelId([0x33; 32]);
        add_private_channel(&mut community, priv_id, [0x44; 32], Epoch(0));

        // Owner rotates the private channel to epoch 1 with a fresh key, delivered to me.
        let new_key = [0x55; 32];
        let prev_commit = super::super::derive::epoch_key_commitment(Epoch(0), &[0x44; 32]);
        let group = channel_rekey_group_key(&community.community_root, &priv_id, Epoch(1));
        let blob = rekey::build_blob_local(owner.secret_key(), &owner.public_key().to_bytes(), &owner.public_key(), RekeyScope::Channel(priv_id), Epoch(1), &new_key).unwrap();
        let events = rekey::build_rekey_chunks_local(&owner, &group, RekeyScope::Channel(priv_id), Epoch(1), Epoch(0), &prev_commit, &[blob], 2_000, None).unwrap();
        for e in &events {
            relay.publish(e, &community.relays).await.unwrap();
        }

        let session = SessionGuard::capture();
        let updated = follow_rekeys(&relay, &community, &session).await.unwrap().updated.expect("adopted");
        let ch = updated.channel(&priv_id).unwrap();
        assert_eq!(ch.epoch, Epoch(1), "the private channel advanced an epoch");
        assert_eq!(ch.key, Some(new_key), "adopted the fresh channel key");
        assert_eq!(updated.root_epoch, Epoch(0), "the base is untouched by a channel rotation");
    }

    #[tokio::test]
    async fn follow_rekeys_ignores_a_non_owner_rotation() {
        // A member holds the community_root, so they can derive the rekey group key
        // and mint a rotation — but they aren't the owner, so it's not adopted.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Guarded", vec!["wss://r".into()], None).await.unwrap();
        let rogue = Keys::generate();
        publish_base_rotation(&relay, &community, &rogue, &[rogue.public_key()], &[0xEE; 32], &community.community_root).await;

        let session = SessionGuard::capture();
        let follow = follow_rekeys(&relay, &community, &session).await.unwrap();
        assert!(follow.updated.is_none() && !follow.self_removed, "a non-owner rotation is not adopted");
    }

    #[tokio::test]
    async fn follow_rekeys_ignores_a_rotation_off_the_wrong_prev() {
        // A rotation whose prevcommit doesn't match the key I hold is a fork, not an
        // extension — never adopted (would splice me onto an unrelated chain).
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Forked", vec!["wss://r".into()], None).await.unwrap();
        // prev_key ≠ the real community_root → the continuity check reads Fork.
        publish_base_rotation(&relay, &community, &owner, &[owner.public_key()], &[0xB2; 32], &[0x00; 32]).await;

        let session = SessionGuard::capture();
        let follow = follow_rekeys(&relay, &community, &session).await.unwrap();
        assert!(follow.updated.is_none(), "a fork off the wrong prev is not adopted");
    }

    #[tokio::test]
    async fn follow_rekeys_holds_on_an_incomplete_rotation() {
        // A 2-chunk rotation with only chunk 1 present can never conclude — not an
        // adoption, and crucially NOT a removal (a missing chunk might carry my blob).
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Partial", vec!["wss://r".into()], None).await.unwrap();
        let new_epoch = Epoch(1);
        let prev_commit = super::super::derive::epoch_key_commitment(Epoch(0), &community.community_root);
        let group = base_rekey_group_key(&community.community_root, community.id(), new_epoch);
        // Chunk 1 of a declared 2, carrying someone else's blob (not mine).
        let other = Keys::generate();
        let blob = rekey::build_blob_local(owner.secret_key(), &owner.public_key().to_bytes(), &other.public_key(), RekeyScope::Root, new_epoch, &[0xB3; 32]).unwrap();
        let rumor = rekey::build_rekey_rumor(owner.public_key(), RekeyScope::Root, new_epoch, Epoch(0), &prev_commit, &[blob], 1, 2, 2_000, None).unwrap();
        let (wrap, _) = rekey::seal_rekey_chunk(&rumor, &group, &owner, Timestamp::from_secs(2_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();

        let session = SessionGuard::capture();
        let follow = follow_rekeys(&relay, &community, &session).await.unwrap();
        assert!(follow.updated.is_none() && !follow.self_removed, "an incomplete rotation neither adopts nor removes");
    }

    #[tokio::test]
    async fn follow_rekeys_removes_a_member_dropped_by_a_base_rotation() {
        // Realistic two-actor removal: the owner Refounds the base and delivers the
        // new root to a THIRD party, not the member — a complete rotation with no
        // blob for the member is a removal.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Evict", bed.relays.clone(), None).await.unwrap();
        send_direct_invite(&bed.relay, &community, &member.keys.public_key(), None, None).await.unwrap();

        bed.swap_to(&member);
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let joined = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap();

        // Owner rotates, delivering only to a stranger (the member is dropped).
        bed.swap_to(&owner);
        let stranger = Keys::generate();
        publish_base_rotation(&bed.relay, &community, &owner.keys, &[stranger.public_key()], &[0xC4; 32], &community.community_root).await;

        // The member's follow concludes removal (a complete rotation without their blob).
        bed.swap_to(&member);
        let session = SessionGuard::capture();
        let follow = follow_rekeys(&bed.relay, &joined, &session).await.unwrap();
        assert!(follow.self_removed, "a complete base rotation dropping the member removes them");
        assert!(follow.updated.is_none(), "a removed member adopts nothing");
    }

    #[tokio::test]
    async fn follow_rekeys_finds_a_channel_rekey_under_an_archived_prior_root() {
        // PROTO-B2 regression: a Refounding's channel rekeys ride the PRIOR root
        // (CORD-06 §3). A follower who adopted the BASE first (the live window:
        // the base crate landed and was walked before the channel crates) must
        // still find them — the lookup fans across the archived roots, not just
        // the current one.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let mut community = create_community(&relay, "Strand", vec!["wss://r".into()], None).await.unwrap();
        let root0 = community.community_root;
        let priv_id = ChannelId([0x33; 32]);
        let key1 = [0x44; 32];
        add_private_channel(&mut community, priv_id, key1, Epoch(1));

        // The refounder's channel rekey (1 → 2), sealed + addressed under the PRIOR
        // root (root0), delivering the fresh key to me.
        let key2 = [0x55; 32];
        let prev_commit = super::super::derive::epoch_key_commitment(Epoch(1), &key1);
        let group = channel_rekey_group_key(&root0, &priv_id, Epoch(2));
        let blob = rekey::build_blob_local(owner.secret_key(), &owner.public_key().to_bytes(), &owner.public_key(), RekeyScope::Channel(priv_id), Epoch(2), &key2).unwrap();
        for e in rekey::build_rekey_chunks_local(&owner, &group, RekeyScope::Channel(priv_id), Epoch(2), Epoch(1), &prev_commit, &[blob], 2_000, None).unwrap() {
            relay.publish(&e, &community.relays).await.unwrap();
        }

        // Simulate the base having ALREADY advanced (the stranding order): the head
        // moved to a fresh root while root0 sits in the epoch-key archive (where
        // genesis put it).
        community.community_root = [0xB7; 32];
        community.root_epoch = Epoch(1);
        crate::db::community::save_community_v2(&community).unwrap();

        let session = SessionGuard::capture();
        let updated = follow_rekeys(&relay, &community, &session).await.unwrap().updated.expect("the prior-root crate is found");
        let ch = updated.channel(&priv_id).unwrap();
        assert_eq!(ch.epoch, Epoch(2), "the channel advanced despite the moved base");
        assert_eq!(ch.key, Some(key2), "adopted the key delivered under the prior root");
    }

    #[tokio::test]
    async fn follow_rekeys_keyless_cursor_walks_past_an_excluding_rotation_then_adopts() {
        // A keyless private channel (announced by vsk-2, key not yet held) has no
        // chain, so its epoch is a scan cursor: a complete rotation that excludes
        // us advances the cursor (never a removal — we were never in); a later
        // rotation that includes us is the entry point.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let mut community = create_community(&relay, "Cursor", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = ChannelId([0x66; 32]);
        community.channels.push(ChannelV2 { id: priv_id, name: "vault".into(), private: true, key: None, epoch: Epoch(0), voice: None, meta_custom: None, meta_extra: Default::default() });
        crate::db::community::save_community_v2(&community).unwrap();
        let community = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert!(community.channel(&priv_id).unwrap().key.is_none(), "keyless survives the round-trip");

        // Epoch 1: the creation delivery went to a stranger only (pre-dates us).
        let stranger = Keys::generate();
        let key1 = [0x71; 32];
        let pc1 = super::super::derive::epoch_key_commitment(Epoch(0), &community.community_root);
        let g1 = channel_rekey_group_key(&community.community_root, &priv_id, Epoch(1));
        let b1 = rekey::build_blob_local(owner.secret_key(), &owner.public_key().to_bytes(), &stranger.public_key(), RekeyScope::Channel(priv_id), Epoch(1), &key1).unwrap();
        for e in rekey::build_rekey_chunks_local(&owner, &g1, RekeyScope::Channel(priv_id), Epoch(1), Epoch(0), &pc1, &[b1], 2_000, None).unwrap() {
            relay.publish(&e, &community.relays).await.unwrap();
        }
        // Epoch 2: a later rotation includes ME (e.g. a removal-forced re-mint whose
        // recipient set is the CURRENT members).
        let key2 = [0x72; 32];
        let pc2 = super::super::derive::epoch_key_commitment(Epoch(1), &key1);
        let g2 = channel_rekey_group_key(&community.community_root, &priv_id, Epoch(2));
        let b2 = rekey::build_blob_local(owner.secret_key(), &owner.public_key().to_bytes(), &owner.public_key(), RekeyScope::Channel(priv_id), Epoch(2), &key2).unwrap();
        for e in rekey::build_rekey_chunks_local(&owner, &g2, RekeyScope::Channel(priv_id), Epoch(2), Epoch(1), &pc2, &[b2], 2_100, None).unwrap() {
            relay.publish(&e, &community.relays).await.unwrap();
        }

        // ONE follow: the cursor walks 0→1 (excluded, still keyless) and 1→2 (my
        // blob — adopt), because each real step re-loops.
        let session = SessionGuard::capture();
        let updated = follow_rekeys(&relay, &community, &session).await.unwrap().updated.expect("the walk lands on the included epoch");
        let ch = updated.channel(&priv_id).unwrap();
        assert_eq!(ch.epoch, Epoch(2), "cursor walked through the excluding epoch to the included one");
        assert_eq!(ch.key, Some(key2), "adopted the delivery that includes us");
    }

    #[tokio::test]
    async fn follow_rekeys_honors_an_admin_channel_rotation_but_never_a_strangers() {
        // CORD-06 §Authority: a CHANNEL rekey is honored from the owner or a
        // MANAGE_CHANNELS holder under the persisted roster — so an admin-run
        // rotation keys members up; a mere keyholder's forgery never does.
        use crate::community::roles::{CommunityRoles, MemberGrant, Role};
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let mut community = create_community(&relay, "AdminRot", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = ChannelId([0x88; 32]);
        let key1 = [0x91; 32];
        add_private_channel(&mut community, priv_id, key1, Epoch(1));

        // Persist a roster granting `admin` the Admin role (MANAGE_CHANNELS ⊂ ADMIN_ALL).
        let admin = Keys::generate();
        let role = Role::admin("aa".repeat(32));
        let roster = CommunityRoles {
            roles: vec![role.clone()],
            grants: vec![MemberGrant { member: admin.public_key().to_hex(), role_ids: vec![role.role_id.clone()] }],
        };
        seed_roster_with_heads(&community, &roster, 1_000);

        // The ADMIN rotates the channel 1 → 2, delivering to me: adopted.
        let key2 = [0x92; 32];
        let pc = super::super::derive::epoch_key_commitment(Epoch(1), &key1);
        let g2 = channel_rekey_group_key(&community.community_root, &priv_id, Epoch(2));
        let me_pk = crate::state::MY_SECRET_KEY.to_keys().unwrap().public_key();
        let blob = rekey::build_blob_local(admin.secret_key(), &admin.public_key().to_bytes(), &me_pk, RekeyScope::Channel(priv_id), Epoch(2), &key2).unwrap();
        for e in rekey::build_rekey_chunks_local(&admin, &g2, RekeyScope::Channel(priv_id), Epoch(2), Epoch(1), &pc, &[blob], 2_000, my_authority_citation(&community, &admin.public_key()).as_ref()).unwrap() {
            relay.publish(&e, &community.relays).await.unwrap();
        }
        let session = SessionGuard::capture();
        let updated = follow_rekeys(&relay, &community, &session).await.unwrap().updated.expect("an admin rotation is honored");
        assert_eq!(updated.channel(&priv_id).unwrap().key, Some(key2), "adopted the admin's key");

        // A STRANGER (keyholder, no roster standing) rotates 2 → 3: refused.
        let rogue = Keys::generate();
        let key3 = [0x93; 32];
        let pc3 = super::super::derive::epoch_key_commitment(Epoch(2), &key2);
        let g3 = channel_rekey_group_key(&updated.community_root, &priv_id, Epoch(3));
        let rb = rekey::build_blob_local(rogue.secret_key(), &rogue.public_key().to_bytes(), &me_pk, RekeyScope::Channel(priv_id), Epoch(3), &key3).unwrap();
        for e in rekey::build_rekey_chunks_local(&rogue, &g3, RekeyScope::Channel(priv_id), Epoch(3), Epoch(2), &pc3, &[rb], 2_100, None).unwrap() {
            relay.publish(&e, &updated.relays).await.unwrap();
        }
        let follow = follow_rekeys(&relay, &updated, &session).await.unwrap();
        assert!(follow.updated.is_none(), "a stranger's channel rotation is never adopted");
    }

    #[tokio::test]
    async fn a_non_outranking_admins_rotation_never_concludes_my_removal() {
        // CORD-06 §Authority: the Rotator must strictly OUTRANK every removed
        // target. An equal-rank bit-holder's complete rotation that skips my blob
        // must read Stay (my record survives); the OWNER's reads Removed. Needs a
        // two-account bed: the follower must be a NON-owner admin.
        use crate::community::roles::{CommunityRoles, MemberGrant, Role};
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Outrank", bed.relays.clone(), None).await.unwrap();

        // The MEMBER's device: holds the community + the private channel, with a
        // persisted roster granting the member AND a peer the same Admin role.
        bed.swap_to(&member);
        let mut held = community.clone();
        let priv_id = ChannelId([0xAB; 32]);
        let key1 = [0xA1; 32];
        add_private_channel(&mut held, priv_id, key1, Epoch(1));
        let peer = Keys::generate();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let role = Role::admin("bb".repeat(32));
        let roster = CommunityRoles {
            roles: vec![role.clone()],
            grants: vec![
                MemberGrant { member: peer.public_key().to_hex(), role_ids: vec![role.role_id.clone()] },
                MemberGrant { member: member.keys.public_key().to_hex(), role_ids: vec![role.role_id.clone()] },
            ],
        };
        crate::db::community::set_community_roles(&cid_hex, &roster, 1_000).unwrap();

        // The equal-rank PEER rotates 1 → 2 delivering only to themselves.
        let key2 = [0xA2; 32];
        let pc = super::super::derive::epoch_key_commitment(Epoch(1), &key1);
        let g2 = channel_rekey_group_key(&held.community_root, &priv_id, Epoch(2));
        let pb = rekey::build_blob_local(peer.secret_key(), &peer.public_key().to_bytes(), &peer.public_key(), RekeyScope::Channel(priv_id), Epoch(2), &key2).unwrap();
        for e in rekey::build_rekey_chunks_local(&peer, &g2, RekeyScope::Channel(priv_id), Epoch(2), Epoch(1), &pc, &[pb], 2_000, my_authority_citation(&held, &peer.public_key()).as_ref()).unwrap() {
            bed.relay.publish(&e, &held.relays).await.unwrap();
        }
        let session = SessionGuard::capture();
        let follow = follow_rekeys(&bed.relay, &held, &session).await.unwrap();
        assert!(follow.updated.is_none(), "an equal-rank rotation excluding me is Stay, never my removal");
        let reloaded = crate::db::community::load_community_v2(held.id()).unwrap().unwrap();
        assert!(reloaded.channel(&priv_id).is_some(), "my channel record survives the peer's rotation");

        // The OWNER's rotation excluding me IS a removal (owner outranks everyone).
        let key3 = [0xA3; 32];
        let stranger = Keys::generate();
        let ob = rekey::build_blob_local(owner.keys.secret_key(), &owner.keys.public_key().to_bytes(), &stranger.public_key(), RekeyScope::Channel(priv_id), Epoch(2), &key3).unwrap();
        for e in rekey::build_rekey_chunks_local(&owner.keys, &g2, RekeyScope::Channel(priv_id), Epoch(2), Epoch(1), &pc, &[ob], 2_100, None).unwrap() {
            bed.relay.publish(&e, &held.relays).await.unwrap();
        }
        let follow = follow_rekeys(&bed.relay, &held, &session).await.unwrap();
        let updated = follow.updated.expect("the owner's removal folds");
        assert!(updated.channel(&priv_id).is_none(), "the owner's exclusion cuts my channel record");
    }

    #[tokio::test]
    async fn converting_a_public_channel_to_private_is_refused() {
        // The conversion (CORD-03 §2) is a key rotation this build doesn't mint yet:
        // the producer refuses the flag flip, so no reader is left unkeyable.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "NoConvert", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        let meta = control::ChannelMetadata { name: "general".into(), private: true, voice: None, deleted: None, custom: None, extra: Default::default() };
        let err = edit_channel_metadata(&relay, &community, &general, &meta).await.unwrap_err();
        assert!(err.contains("not supported"), "conversion is refused at the producer: {err}");
        // A rename of the same public channel still works.
        let meta = control::ChannelMetadata { name: "lobby".into(), private: false, voice: None, deleted: None, custom: None, extra: Default::default() };
        edit_channel_metadata(&relay, &community, &general, &meta).await.unwrap();
    }

    /// Publish a 13302 (signed by `me`) carrying a leave tombstone for `cid_hex` at
    /// `removed_at` — simulating a sibling device having left that community.
    async fn publish_remote_tombstone(relay: &MemoryRelay, me: &Keys, relays: &[String], cid_hex: &str, removed_at: u64) {
        let doc = super::super::list::CommunityList {
            entries: vec![],
            tombstones: vec![super::super::list::Tombstone { community_id: cid_hex.to_string(), removed_at, extra: Default::default() }],
            extra: Default::default(),
        };
        let event = super::super::list::build_list_event(me, &doc).unwrap();
        relay.publish(&event, relays).await.unwrap();
    }

    #[tokio::test]
    async fn joining_one_community_does_not_resurrect_a_sibling_left_community() {
        // W1 (send side): a sibling device left X (a remote tombstone). Joining a
        // DIFFERENT community must not re-add X to the 13302 with added_at=now,
        // which would silently undo the leave everywhere.
        let (_tmp, _guard, me) = init_test_db();
        let relay = MemoryRelay::new();
        let x = create_community(&relay, "X", vec!["wss://r".into()], None).await.unwrap();
        let x_hex = crate::simd::hex::bytes_to_hex_32(&x.id().0);

        // A sibling leaves X: a remote tombstone strictly newer than X's add.
        publish_remote_tombstone(&relay, &me, &x.relays, &x_hex, now_ms() + 10_000).await;

        // Now join a different community Y → republish(just_joined = Y).
        let y = create_community(&relay, "Y", vec!["wss://r".into()], None).await.unwrap();
        republish_community_list(&relay, Some(y.id())).await.unwrap();

        // X must still read as LEFT in the published list; Y must be live.
        let list = fetch_community_list(&relay, &x.relays).await.unwrap().unwrap();
        assert!(!list.is_live(&x_hex), "joining Y did not resurrect the sibling-left X");
        assert!(list.is_live(&crate::simd::hex::bytes_to_hex_32(&y.id().0)), "Y is live");
    }

    #[tokio::test]
    async fn sync_tears_down_a_community_a_sibling_left() {
        // W1 (receive side): a community still held locally that the synced 13302
        // shows tombstoned-and-not-live is torn down, so a leave propagates.
        let (_tmp, _guard, me) = init_test_db();
        let relay = MemoryRelay::new();
        let x = create_community(&relay, "Leaveme", vec!["wss://r".into()], None).await.unwrap();
        let x_hex = crate::simd::hex::bytes_to_hex_32(&x.id().0);
        assert!(crate::db::community::load_community_v2(x.id()).unwrap().is_some(), "held before sync");

        publish_remote_tombstone(&relay, &me, &x.relays, &x_hex, now_ms() + 10_000).await;
        sync_community_list(&relay, &x.relays).await.unwrap();
        assert!(crate::db::community::load_community_v2(x.id()).unwrap().is_none(), "the sibling's leave tore X down locally");
    }

    #[tokio::test]
    async fn a_rejoined_community_survives_a_stale_tombstone_on_sync() {
        // The re-join case must NOT be torn down: a fresh join re-adds live (beating
        // the tombstone), so a later sync keeps it.
        let (_tmp, _guard, me) = init_test_db();
        let relay = MemoryRelay::new();
        let x = create_community(&relay, "Rejoin", vec!["wss://r".into()], None).await.unwrap();
        let x_hex = crate::simd::hex::bytes_to_hex_32(&x.id().0);
        // A stale tombstone from a prior leave (OLDER than the current hold's re-add).
        publish_remote_tombstone(&relay, &me, &x.relays, &x_hex, 1).await;
        // Re-record the membership (a re-join) → live entry at now >> 1.
        republish_community_list(&relay, Some(x.id())).await.unwrap();
        sync_community_list(&relay, &x.relays).await.unwrap();
        assert!(crate::db::community::load_community_v2(x.id()).unwrap().is_some(), "a re-joined community is not torn down by a stale tombstone");
    }

    #[tokio::test]
    async fn a_failed_remote_fetch_never_clobbers_the_published_list() {
        // W2: a transient fetch failure during republish must not drive the
        // replaceable-event write (which would drop other entries / regress seeds).
        let (_tmp, _guard, _me) = init_test_db();
        let good = MemoryRelay::new();
        let community = create_community(&good, "Seeded", vec!["wss://r".into()], None).await.unwrap();
        assert!(fetch_community_list(&good, &community.relays).await.unwrap().is_some());

        // A transport whose fetch always errors: republish must bail, publishing nothing.
        struct FetchErrors;
        #[async_trait::async_trait]
        impl Transport for FetchErrors {
            async fn fetch_plane(&self, _plane: &Keys, query: &Query, relays: &[String]) -> Result<Vec<Event>, String> { self.fetch(query, relays).await }
            async fn publish(&self, _e: &Event, _r: &[String]) -> Result<(), String> {
                panic!("republish must NOT publish when the remote fetch failed");
            }
            async fn publish_durable(&self, _e: &Event, _r: &[String]) -> Result<(), String> {
                Ok(())
            }
            async fn fetch(&self, _q: &Query, _r: &[String]) -> Result<Vec<Event>, String> {
                Err("relay unreachable".to_string())
            }
        }
        // Returns Ok (best-effort) but must not have published (the panic guards it).
        republish_community_list(&FetchErrors, Some(community.id())).await.unwrap();
    }

    #[tokio::test]
    async fn a_granted_member_survives_a_refounding_even_with_no_guestbook_join() {
        // B1 regression: refound_community's recipient set = memberlist. A member
        // the owner GRANTED a role to but who never left a (surviving) Guestbook
        // Join — a lurking admin, or one whose Join aged out of the window — must
        // still be a rekey recipient, or the Refounding SEVERS them. The folded
        // roster's granted members are the consensus-complete backstop.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Backstop", vec!["wss://r".into()], None).await.unwrap();

        // A lurker gets an admin grant but publishes NO Guestbook Join and no chat.
        let lurker = Keys::generate();
        let rid = "b1".repeat(32);
        publish_role(&relay, &community, &owner, &admin_role(&rid, Permissions::ADMIN_ALL), 1).await;
        publish_grant(&relay, &community, &owner, &lurker.public_key(), vec![rid.clone()], 1).await;

        // memberlist includes the lurker purely via the roster backstop.
        let members = memberlist(&relay, &community).await.unwrap();
        assert!(members.contains(&lurker.public_key()), "a granted member with no Join is still a member");

        // A banned grantee whose grant wasn't stripped is NOT re-admitted.
        let banned_grantee = Keys::generate();
        publish_grant(&relay, &community, &owner, &banned_grantee.public_key(), vec![rid], 1).await;
        set_banlist(&relay, &community, &[banned_grantee.public_key().to_hex()]).await.unwrap();
        let members = memberlist(&relay, &community).await.unwrap();
        assert!(members.contains(&lurker.public_key()), "the honest grantee still counts");
        assert!(!members.contains(&banned_grantee.public_key()), "a banned grantee is not re-admitted by the union");

        // And the Refounding actually delivers the new root to the lurker.
        let refounded = refound_community(&relay, &community, &[]).await.unwrap();
        assert_eq!(refounded.root_epoch, Epoch(1));
        let base_group = base_rekey_group_key(&community.community_root, community.id(), Epoch(1));
        let chunks = fetch_rekey_chunks(&relay, &community.relays, &base_group).await.unwrap();
        let rotations = rekey::collect_rotations(&chunks);
        let lurker_x = lurker.public_key().to_bytes();
        let delivered = rotations.iter().any(|r| {
            rekey::find_my_blob(&r.blobs, &r.rotator.to_bytes(), &lurker_x, r.scope, r.new_epoch).is_some()
        });
        assert!(delivered, "the Refounding delivered the new root to the granted lurker");
    }

    #[tokio::test]
    async fn the_memberlist_pages_past_a_guestbook_flood() {
        // The roleless-member half of B1: >500 Guestbook events must not evict an
        // honest member's Join from the counted set (an insider can flood throwaway
        // Joins to force exactly this). The pager sees them all.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "GBFlood", vec!["wss://r".into()], None).await.unwrap();
        let gb = super::super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch);

        // An honest member's Join (oldest), then 600 throwaway Joins on top.
        let honest = Keys::generate();
        let join = guestbook::build_join_rumor(honest.public_key(), None, 1_000);
        let (w, _) = guestbook::seal_guestbook_rumor(&join, &gb, &honest, Timestamp::from_secs(1)).unwrap();
        relay.publish(&w, &community.relays).await.unwrap();
        for i in 0..600u64 {
            let throwaway = Keys::generate();
            let j = guestbook::build_join_rumor(throwaway.public_key(), None, 2_000 + i);
            let (w, _) = guestbook::seal_guestbook_rumor(&j, &gb, &throwaway, Timestamp::from_secs(2 + i)).unwrap();
            relay.publish(&w, &community.relays).await.unwrap();
        }

        let members = memberlist(&relay, &community).await.unwrap();
        assert!(members.contains(&honest.public_key()), "the honest member's aged-out Join is still counted past the flood");
    }

    #[tokio::test]
    async fn a_rekey_plane_flood_cannot_bury_a_genuine_rotation() {
        // An insider floods the next-epoch rekey address (community_root-derived,
        // so any member can seal there) with >200 junk 3303s to push the owner's
        // genuine rotation out of a single fetch window. The paginated fetch must
        // still recover it and adopt.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Flooded", vec!["wss://r".into()], None).await.unwrap();
        let new_root = [0xD9; 32];
        let new_epoch = Epoch(1);
        let group = base_rekey_group_key(&community.community_root, community.id(), new_epoch);

        // The GENUINE owner rotation lands first (oldest).
        publish_base_rotation(&relay, &community, &owner, &[owner.public_key()], &new_root, &community.community_root).await;

        // Then a member floods 260 well-formed-but-unauthorized junk chunks ON TOP
        // (newer), burying the genuine one past the 200 newest.
        let rogue = Keys::generate();
        let prev_commit = super::super::derive::epoch_key_commitment(Epoch(0), &community.community_root);
        for i in 0..260u64 {
            let blob = rekey::build_blob_local(rogue.secret_key(), &rogue.public_key().to_bytes(), &rogue.public_key(), RekeyScope::Root, new_epoch, &[0xEE; 32]).unwrap();
            let rumor = rekey::build_rekey_rumor(rogue.public_key(), RekeyScope::Root, new_epoch, Epoch(0), &prev_commit, &[blob], 1, 1, 3_000 + i, None).unwrap();
            let (wrap, _) = rekey::seal_rekey_chunk(&rumor, &group, &rogue, Timestamp::from_secs(3_000 + i)).unwrap();
            relay.publish(&wrap, &community.relays).await.unwrap();
        }

        let session = SessionGuard::capture();
        let updated = follow_rekeys(&relay, &community, &session).await.unwrap().updated.expect("the genuine rotation is recovered past the flood");
        assert_eq!(updated.root_epoch, Epoch(1));
        assert_eq!(updated.community_root, new_root, "adopted the owner's root, not a junk one");
    }

    #[tokio::test]
    async fn a_swap_during_create_private_channel_aborts_without_a_write() {
        // create_private_channel publishes the key crate, then the channel
        // edition, then whole-row-saves. A swap anywhere in that window must
        // abort — never mint a channel into the swapped-in account, and never
        // leave a half-published key crate adopted locally.
        let (bed, owner, _member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "SwapCreate", bed.relays.clone(), None).await.unwrap();
        let before = crate::db::community::load_community_v2(community.id()).unwrap().unwrap().channels.len();

        // The key-crate publish inside create bumps the generation mid-flight.
        let swap_relay = SwapMidPublish { inner: MemoryRelay::new() };
        let err = create_private_channel(&swap_relay, &community, "ghost").await.unwrap_err();
        assert!(err.contains("account changed"), "a swap mid-create aborts: {err}");
        let after = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert_eq!(after.channels.len(), before, "no channel row was written");
        assert!(!after.channels.iter().any(|c| c.name == "ghost"), "the ghost channel never persisted");
    }

    #[tokio::test]
    async fn an_uncited_admin_rotation_is_not_adopted() {
        // CORD-06 §Authority: "a rotation cites the Grant it acts under like any
        // authority action, so a just-demoted admin's rotation is never honored by
        // a lagging client." An uncited rotation is skipped entirely — neither
        // adopted nor allowed to conclude a removal.
        use crate::community::roles::{CommunityRoles, MemberGrant, Role};
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let mut community = create_community(&relay, "Uncited", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = ChannelId([0x8A; 32]);
        let key1 = [0x93; 32];
        add_private_channel(&mut community, priv_id, key1, Epoch(1));

        let admin = Keys::generate();
        let role = Role::admin("cf".repeat(32));
        let roster = CommunityRoles {
            roles: vec![role.clone()],
            grants: vec![MemberGrant { member: admin.public_key().to_hex(), role_ids: vec![role.role_id.clone()] }],
        };
        seed_roster_with_heads(&community, &roster, 1_000);

        let key2 = [0x94; 32];
        let pc = super::super::derive::epoch_key_commitment(Epoch(1), &key1);
        let g2 = channel_rekey_group_key(&community.community_root, &priv_id, Epoch(2));
        let me_pk = crate::state::MY_SECRET_KEY.to_keys().unwrap().public_key();
        let blob = rekey::build_blob_local(admin.secret_key(), &admin.public_key().to_bytes(), &me_pk, RekeyScope::Channel(priv_id), Epoch(2), &key2).unwrap();
        // Authorized admin, correct continuity, my blob present — but NO citation.
        for e in rekey::build_rekey_chunks_local(&admin, &g2, RekeyScope::Channel(priv_id), Epoch(2), Epoch(1), &pc, &[blob], 2_000, None).unwrap() {
            relay.publish(&e, &community.relays).await.unwrap();
        }

        let out = follow_rekeys(&relay, &community, &SessionGuard::capture()).await.unwrap();
        assert!(out.updated.is_none(), "an uncited rotation is not adopted");

        // The SAME rotation, cited, is adopted — proving the refusal was the
        // citation and not the rank or the continuity.
        let cited = my_authority_citation(&community, &admin.public_key());
        assert!(cited.is_some(), "the seeded head yields a citation");
        let blob2 = rekey::build_blob_local(admin.secret_key(), &admin.public_key().to_bytes(), &me_pk, RekeyScope::Channel(priv_id), Epoch(2), &key2).unwrap();
        for e in rekey::build_rekey_chunks_local(&admin, &g2, RekeyScope::Channel(priv_id), Epoch(2), Epoch(1), &pc, &[blob2], 2_100, cited.as_ref()).unwrap() {
            relay.publish(&e, &community.relays).await.unwrap();
        }
        let out = follow_rekeys(&relay, &community, &SessionGuard::capture()).await.unwrap();
        assert!(out.updated.is_some(), "the cited rotation IS adopted");
    }

    #[tokio::test]
    async fn two_admins_racing_a_channel_rotation_converge_on_one_key() {
        // CORD-06 §Failure-and-races: two DISTINCT authorized rotators mint the
        // same channel epoch concurrently (reachable — both hold MANAGE_CHANNELS).
        // Every follower must converge on the SAME key (the lexicographically
        // lowest), so the community never permanently forks. (Retaining the losing
        // fork's key for its race-window messages needs a multi-key-per-epoch
        // archive — a deferred refinement shared with v1; convergence, the
        // security-critical property, is what this pins.)
        use crate::community::roles::{CommunityRoles, MemberGrant, Role};
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let mut community = create_community(&relay, "Race", vec!["wss://r".into()], None).await.unwrap();
        let priv_id = ChannelId([0xC0; 32]);
        let key1 = [0xC1; 32];
        add_private_channel(&mut community, priv_id, key1, Epoch(1));

        // Two admins (a, b) both hold the Admin role; I hold the channel key.
        let (a, b) = (Keys::generate(), Keys::generate());
        let role = Role::admin("ce".repeat(32));
        let roster = CommunityRoles {
            roles: vec![role.clone()],
            grants: [&a, &b].iter().map(|k| MemberGrant { member: k.public_key().to_hex(), role_ids: vec![role.role_id.clone()] }).collect(),
        };
        seed_roster_with_heads(&community, &roster, 1_000);

        // Both rotate 1 → 2, each delivering their OWN fresh key to me, off the
        // same prevcommit — a genuine same-epoch fork.
        let me_pk = crate::state::MY_SECRET_KEY.to_keys().unwrap().public_key();
        let pc = super::super::derive::epoch_key_commitment(Epoch(1), &key1);
        let group = channel_rekey_group_key(&community.community_root, &priv_id, Epoch(2));
        let key_a = [0x0A; 32];
        let key_b = [0xFB; 32]; // higher — a's must win regardless of publish order
        for (signer, k) in [(&a, &key_a), (&b, &key_b)] {
            let blob = rekey::build_blob_local(signer.secret_key(), &signer.public_key().to_bytes(), &me_pk, RekeyScope::Channel(priv_id), Epoch(2), k).unwrap();
            for e in rekey::build_rekey_chunks_local(signer, &group, RekeyScope::Channel(priv_id), Epoch(2), Epoch(1), &pc, &[blob], 2_000, my_authority_citation(&community, &signer.public_key()).as_ref()).unwrap() {
                relay.publish(&e, &community.relays).await.unwrap();
            }
        }

        let session = SessionGuard::capture();
        let updated = follow_rekeys(&relay, &community, &session).await.unwrap().updated.expect("adopts a winner");
        let adopted = updated.channel(&priv_id).unwrap().key.unwrap();
        assert_eq!(adopted, key_a, "converges on the lexicographically lowest key (deterministic across clients)");

        // A SECOND follower (fresh, holding the same epoch-1 key) converges identically.
        let mut peer = community.clone();
        if let Some(c) = peer.channels.iter_mut().find(|c| c.id.0 == priv_id.0) {
            c.key = Some(key1);
            c.epoch = Epoch(1);
        }
        // Re-run the same fold from the peer's identical starting point → same winner.
        let updated2 = follow_rekeys(&relay, &peer, &session).await.unwrap().updated.expect("peer adopts");
        assert_eq!(updated2.channel(&priv_id).unwrap().key.unwrap(), key_a, "every follower lands on the identical key");
    }

    #[tokio::test]
    async fn create_private_channel_refuses_a_member_without_manage_channels() {
        // The local mirror of the reader's gate: an unauthorized member is refused
        // BEFORE any publish (no floor pollution, no orphan key crate).
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Gate", bed.relays.clone(), None).await.unwrap();
        send_direct_invite(&bed.relay, &community, &member.keys.public_key(), None, None).await.unwrap();

        bed.swap_to(&member);
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let joined = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap();
        let err = create_private_channel(&bed.relay, &joined, "sneaky").await.unwrap_err();
        assert!(err.contains("MANAGE_CHANNELS"), "refused with the permission it lacks: {err}");
        let err = create_public_channel(&bed.relay, &joined, "sneaky-too").await.unwrap_err();
        assert!(err.contains("MANAGE_CHANNELS"), "public creation gates identically: {err}");
    }

    // ── Audit regressions ────────────────────────────────────────────────────

    #[tokio::test]
    async fn accept_rejects_a_bundle_with_a_forged_community_root() {
        // The eclipse: community_id commits only to (owner, salt) — both semi-public
        // — so a forged invite pairs the REAL triple with an attacker root, and every
        // plane derives from it. The join-time owner-genesis check must refuse.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Real", bed.relays.clone(), None).await.unwrap();

        let fake = crate::simd::hex::bytes_to_hex_32(&[0xEE; 32]);
        let mut forged = bundle_of(&community, BundleAudience::Link, None, None, None);
        forged.community_root = fake.clone();
        for ch in &mut forged.channels {
            ch.key = fake.clone();
        }
        let attacker = Keys::generate();
        let wrap = invite::build_direct_invite(&attacker, &member.keys.public_key(), &forged).unwrap();
        bed.relay.publish(&wrap, &bed.relays).await.unwrap();

        bed.swap_to(&member);
        let invite_wrap = fetch_direct_invite(&bed.relay, &bed.relays, &member.keys.public_key()).await;
        let err = accept_direct_invite(&bed.relay, &invite_wrap).await.unwrap_err();
        assert!(err.contains("could not verify"), "a forged root fails the owner-genesis check: {err}");
        assert!(
            crate::db::community::load_community_v2(community.id()).unwrap().is_none(),
            "a rejected join persists nothing"
        );
    }

    #[tokio::test]
    async fn accept_verifies_a_rotated_plane_whose_metadata_head_is_admin_signed() {
        // CORD-06 compaction re-wraps CURRENT heads with their original signatures,
        // so a rotated plane whose metadata an admin last edited carries no
        // owner-signed vsk-0. The join anchor there is the community-bound metadata
        // head plus any owner-signed edition under the same root.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Rotated", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;

        let mut rotated = community.clone();
        rotated.community_root = [0x5A; 32];
        rotated.root_epoch = Epoch(1);
        let admin = Keys::generate();
        publish_community_meta(&bed.relay, &rotated, &admin, "Rotated", 3).await;
        publish_channel_edition(&bed.relay, &rotated, &owner.keys, &general, "general", false, 2, false).await;

        bed.swap_to(&member);
        let bundle = bundle_of(&rotated, BundleAudience::Link, None, None, None);
        let session = SessionGuard::capture();
        let joined = accept_bundle(&bed.relay, &session, &bundle, None, true).await.unwrap();
        assert_eq!(joined.root_epoch, Epoch(1), "the rotated root is adopted");
    }

    #[tokio::test]
    async fn only_an_actual_join_publishes_a_guestbook_join() {
        // A Guestbook Join is a member's own word that they JOINED. A re-accept of
        // a held community and a cross-device key sync (announce_join=false) must
        // both stay silent — each re-publish renders as "<user> has joined" spam.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Quiet", bed.relays.clone(), None).await.unwrap();

        let gb_pk = super::super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch).pk_hex();
        async fn gb_count(relay: &MemoryRelay, gb_pk: &str, relays: &[String]) -> usize {
            let q = Query { kinds: vec![stream::KIND_WRAP], authors: vec![gb_pk.to_string()], ..Default::default() };
            relay.fetch(&q, relays).await.map(|v| v.len()).unwrap_or(0)
        }
        let baseline = gb_count(&bed.relay, &gb_pk, &bed.relays).await; // the owner's creation Join

        bed.swap_to(&member);
        let bundle = bundle_of(&community, BundleAudience::Link, None, None, None);
        let session = SessionGuard::capture();
        accept_bundle(&bed.relay, &session, &bundle, None, true).await.unwrap();
        assert_eq!(gb_count(&bed.relay, &gb_pk, &bed.relays).await, baseline + 1, "a first join announces exactly once");

        accept_bundle(&bed.relay, &session, &bundle, None, true).await.unwrap();
        assert_eq!(gb_count(&bed.relay, &gb_pk, &bed.relays).await, baseline + 1, "a re-accept of a held community stays silent");

        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        crate::db::community::delete_community(&cid_hex).unwrap();
        accept_bundle(&bed.relay, &session, &bundle, None, false).await.unwrap();
        assert_eq!(gb_count(&bed.relay, &gb_pk, &bed.relays).await, baseline + 1, "a cross-device key sync is not a membership event");
    }

    #[tokio::test]
    async fn accept_refuses_a_rotated_plane_with_no_owner_signed_edition() {
        // The fallback's second half is load-bearing: a community-bound metadata
        // head alone is self-signable by anyone who knows the (public) community_id.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "NoOwner", bed.relays.clone(), None).await.unwrap();

        let mut rotated = community.clone();
        rotated.community_root = [0x5B; 32];
        rotated.root_epoch = Epoch(1);
        let attacker = Keys::generate();
        publish_community_meta(&bed.relay, &rotated, &attacker, "NoOwner", 3).await;

        bed.swap_to(&member);
        let bundle = bundle_of(&rotated, BundleAudience::Link, None, None, None);
        let session = SessionGuard::capture();
        let err = accept_bundle(&bed.relay, &session, &bundle, None, true).await.unwrap_err();
        assert!(err.contains("could not verify"), "no owner-signed edition → refuse: {err}");
    }

    #[tokio::test]
    async fn accept_requires_the_strict_owner_genesis_on_an_epoch_zero_plane() {
        // The fallback applies to rotated planes only: at epoch 0 the spec guarantees
        // an owner-signed genesis, so owner material without it stays insufficient.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Strict", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;

        let mut fake = community.clone();
        fake.community_root = [0x5C; 32]; // epoch stays 0
        let admin = Keys::generate();
        publish_community_meta(&bed.relay, &fake, &admin, "Strict", 2).await;
        publish_channel_edition(&bed.relay, &fake, &owner.keys, &general, "general", false, 2, false).await;

        bed.swap_to(&member);
        let bundle = bundle_of(&fake, BundleAudience::Link, None, None, None);
        let session = SessionGuard::capture();
        let err = accept_bundle(&bed.relay, &session, &bundle, None, true).await.unwrap_err();
        assert!(err.contains("could not verify"), "epoch 0 demands the owner genesis: {err}");
    }

    #[tokio::test]
    async fn follow_control_heals_a_bundle_misclassified_public_channel() {
        // A bundle can set a PUBLIC channel's grant key to the attacker's, so the
        // joiner addresses it at a plane only the attacker reads. The owner's genuine
        // public:false edition must override it on follow.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Heal", vec!["wss://r".into()], None).await.unwrap();
        let general = community.channels[0].id;
        let mut poisoned = community.clone();
        poisoned.channels[0].private = true;
        poisoned.channels[0].key = Some([0x66; 32]);
        crate::db::community::save_community_v2(&poisoned).unwrap();

        let session = SessionGuard::capture();
        let healed = follow_control(&relay, &poisoned, &session).await.unwrap().expect("healed");
        let ch = healed.channel(&general).unwrap();
        assert!(!ch.private, "the owner's public declaration overrides the bundle");
        assert_eq!(ch.key, None, "a healed public channel derives from the root");
    }

    #[tokio::test]
    async fn a_deleted_channel_does_not_resurrect_on_reload() {
        // save_community_v2 must prune orphan channel rows, or a control-follow delete
        // reappears (with a stale key) on the next reload.
        let (_tmp, _guard, owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Prune", vec!["wss://r".into()], None).await.unwrap();
        let extra = ChannelId([0x77; 32]);
        let session = SessionGuard::capture();
        publish_channel_edition(&relay, &community, &owner, &extra, "temp", false, 1, false).await;
        let with_extra = follow_control(&relay, &community, &session).await.unwrap().unwrap();
        assert!(with_extra.channel(&extra).is_some());
        publish_channel_edition(&relay, &community, &owner, &extra, "temp", false, 2, true).await;
        let after = follow_control(&relay, &with_extra, &session).await.unwrap().unwrap();
        assert!(after.channel(&extra).is_none());

        let reloaded = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        assert!(reloaded.channel(&extra).is_none(), "a deleted channel must not resurrect on reload");
        assert_eq!(reloaded.channels.len(), 1);
    }

    #[tokio::test]
    async fn a_channel_owned_by_another_community_is_skipped_not_clobbered() {
        // channel_id is the sole DB primary key, so a bundle/replay reusing another
        // community's channel_id must NOT overwrite that row. It's skipped (not an
        // error — erroring would wedge all of this community's control persistence).
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let a = create_community(&relay, "A", vec!["wss://r".into()], None).await.unwrap();
        let a_channel = a.channels[0].id;
        let mut b = create_community(&relay, "B", vec!["wss://r".into()], None).await.unwrap();
        let b_channel = b.channels[0].id;
        // B's set includes a phantom whose id collides with A's channel.
        b.channels.push(ChannelV2 { id: a_channel, name: "phantom".into(), private: false, key: None, epoch: b.root_epoch, voice: None, meta_custom: None, meta_extra: Default::default() });

        crate::db::community::save_community_v2(&b).expect("save succeeds, the phantom is skipped");
        // A's channel row is untouched.
        let a_reloaded = crate::db::community::load_community_v2(a.id()).unwrap().unwrap();
        assert!(!a_reloaded.channels.iter().any(|c| c.private), "A's channel is untouched");
        assert_eq!(a_reloaded.channels[0].id.0, a_channel.0);
        // B keeps its own channel but never acquired a row for the foreign id.
        let b_reloaded = crate::db::community::load_community_v2(b.id()).unwrap().unwrap();
        assert!(b_reloaded.channel(&b_channel).is_some(), "B's own channel persists");
        assert!(b_reloaded.channel(&a_channel).is_none(), "the foreign-owned channel is skipped, not stolen");
    }

    /// A single relay that CAPS every query below the page size (modelling a real
    /// relay's maxFilterLimit) and honors `until` — so the join-verify walk MUST
    /// paginate to reach an old genesis. MemoryRelay can't model this (it unions then
    /// truncates the whole set), which is why a MemoryRelay flood test gives false
    /// confidence about the production `LiveTransport` behaviour.
    struct CappedRelay {
        events: Vec<Event>,
        cap: usize,
    }
    #[async_trait::async_trait]
    impl Transport for CappedRelay {
        async fn fetch_plane(&self, _plane: &Keys, query: &Query, relays: &[String]) -> Result<Vec<Event>, String> { self.fetch(query, relays).await }
        async fn publish(&self, _e: &Event, _r: &[String]) -> Result<(), String> {
            Ok(())
        }
        async fn publish_durable(&self, _e: &Event, _r: &[String]) -> Result<(), String> {
            Ok(())
        }
        async fn fetch(&self, q: &Query, _r: &[String]) -> Result<Vec<Event>, String> {
            let mut m: Vec<Event> = self
                .events
                .iter()
                .filter(|e| q.authors.is_empty() || q.authors.contains(&e.pubkey.to_hex()))
                .filter(|e| q.until.is_none_or(|u| e.created_at.as_secs() <= u))
                .cloned()
                .collect();
            m.sort_by(|a, b| b.created_at.cmp(&a.created_at)); // newest first
            m.truncate(self.cap.min(q.limit.unwrap_or(usize::MAX)));
            Ok(m)
        }
    }

    #[tokio::test]
    async fn refound_aborts_when_the_control_plane_cannot_be_read_in_full() {
        // CORD-06 §3: a Refounder that cannot fold every Control Event must abort.
        // `until` is inclusive, so a page-wide block of same-second wraps is a wall
        // no cursor steps past — everything older (the genesis editions, a Banlist)
        // is unreachable. Compacting THAT view carries only what was read into the
        // new epoch, dropping the rest for every member, permanently. Any member can
        // build the wall: the plane key comes from the community root they hold.
        let (_tmp, _guard, _owner) = init_test_db();
        let memory = MemoryRelay::new();
        let community = create_community(&memory, "Walled", vec!["wss://r".into()], None).await.unwrap();
        let control = control_group_key(&community.community_root, community.id(), community.root_epoch);

        let rogue = Keys::generate();
        let mut events: Vec<Event> = Vec::new();
        for i in 0..FOLLOW_PAGE {
            let content = format!("{{\"name\":\"junk{i}\",\"private\":false}}");
            let rumor = control::build_edition_rumor(
                rogue.public_key(),
                vsk::CHANNEL_METADATA,
                &[0xAB; 32],
                1,
                None,
                &content,
                9_000,
                None,
            );
            let (w, _) = control::seal_control_edition(&rumor, &control, &rogue, Timestamp::from_secs(9_000)).unwrap();
            events.push(w);
        }
        let relay = CappedRelay { events, cap: FOLLOW_PAGE };

        let err = refound_community(&relay, &community, &[])
            .await
            .expect_err("a plane that can't be read whole must never be compacted");
        assert!(err.contains("too deep to read in full"), "unexpected error: {err}");
    }

    #[tokio::test]
    async fn verify_pages_a_capped_relay_past_a_flood_to_the_genesis() {
        // The join-verify DoS mitigation, tested against a relay that caps below PAGE
        // (production behaviour MemoryRelay hides): a rogue root-holder buries the
        // genesis under junk, and the `until`-walk must page past it. Uses fixed OLD
        // timestamps so `until = now` includes everything and the walk is deterministic.
        let (_tmp, _guard, owner) = init_test_db();
        let meta = control::CommunityMetadata { name: "Capped".into(), relays: vec!["wss://r".into()], ..Default::default() };
        let g = control::genesis(&owner, meta, 1_000).unwrap();
        let community = CommunityV2::from_genesis(&g, "Capped", None, vec!["wss://r".into()], 1_000);

        let control = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let rogue = Keys::generate();
        let mut events: Vec<Event> = g.wraps.to_vec();
        for i in 0..250u64 {
            let rumor = control::build_edition_rumor(rogue.public_key(), vsk::CHANNEL_METADATA, &[0xAB; 32], 1, None, "{\"name\":\"junk\",\"private\":false}", 1_001 + i, None);
            let (wrap, _) = control::seal_control_edition(&rumor, &control, &rogue, Timestamp::from_secs(1_001 + i)).unwrap();
            events.push(wrap);
        }
        // Cap 100/query forces the walk across ~3 pages down to the genesis at ts 1000.
        let relay = CappedRelay { events, cap: 100 };
        let verified = verify_owner_root_and_reconcile(&relay, community.clone()).await;
        assert!(verified.is_ok(), "the until-walk pages a capped relay past the flood to the genesis: {:?}", verified.err());
    }

    #[tokio::test]
    async fn accept_parked_invite_joins_from_the_stored_bundle() {
        // The 3313 receive path: an invite is parked as its bundle JSON, then accepted
        // from the stored bundle (re-verifying the owner root over the network).
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Parked", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        send_message(&bed.relay, &community, &general, "owner: hi").await.unwrap();
        let bundle = bundle_of(&community, BundleAudience::Link, Some(owner.keys.public_key()), None, None);
        let bundle_json = serde_json::to_string(&bundle).unwrap();
        let inviter_hex = owner.keys.public_key().to_hex();

        bed.swap_to(&member);
        let joined = accept_parked_invite(&bed.relay, &bundle_json, Some(&inviter_hex)).await.unwrap();
        assert_eq!(joined.id().0, community.id().0, "joined the community from the parked bundle");
        assert!(joined.identity.verify());
        assert_eq!(texts_in(&bed.relay, &joined, &general).await, vec!["owner: hi"]);
        // The join seeded the verified fold as the member's initial floor, so their
        // first follow can't roll below the state the join just showed.
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&joined.id().0);
        assert!(
            crate::db::community::get_edition_head(&cid_hex, &cid_hex).unwrap().is_some(),
            "the joiner's control floor is seeded from the join-time fold"
        );

        // The Guestbook memberlist now folds both participants.
        bed.swap_to(&owner);
        let members = memberlist(&bed.relay, &community).await.unwrap();
        assert!(members.contains(&member.keys.public_key()), "the parked-invite joiner is a member");
    }

    #[tokio::test]
    async fn accept_parked_invite_rejects_a_forged_root() {
        // A forged-root parked bundle (real identity triple, attacker-chosen root) fails
        // accept — the shared accept path re-verifies the owner root, so a parked invite
        // gets the same eclipse protection as a live one.
        let (_tmp, _guard, _owner) = init_test_db();
        let relay = MemoryRelay::new();
        let community = create_community(&relay, "Real", vec!["wss://r".into()], None).await.unwrap();
        let mut forged = bundle_of(&community, BundleAudience::Link, None, None, None);
        let fake = crate::simd::hex::bytes_to_hex_32(&[0xEE; 32]);
        forged.community_root = fake.clone();
        for ch in &mut forged.channels {
            ch.key = fake.clone();
        }
        let bundle_json = serde_json::to_string(&forged).unwrap();

        let err = accept_parked_invite(&relay, &bundle_json, None).await.unwrap_err();
        assert!(err.contains("could not verify"), "a forged-root parked bundle fails definitively: {err}");
    }

    #[test]
    fn v2_and_v1_bundles_are_distinguishable_by_parse() {
        // The protocol discriminator the facade list/accept relies on: a v2 bundle
        // (self-certifying: owner + owner_salt + community_root) parses; a v1-shaped
        // one does not, so a parked invite routes to the right accept path.
        let owner = Keys::generate();
        let identity = super::super::control::CommunityIdentity::mint(&owner.public_key());
        let hex = crate::simd::hex::bytes_to_hex_32;
        let v2 = invite::CommunityInvite {
            community_id: hex(&identity.community_id.0),
            owner: hex(&identity.owner_xonly),
            owner_salt: hex(&identity.owner_salt),
            community_root: hex(&[0x11; 32]),
            root_epoch: 0,
            channels: vec![],
            relays: vec!["wss://r".into()],
            name: "V2".into(),
            icon: None,
            expires_at: None,
            creator_npub: None,
            label: None,
            extra: Default::default(),
        };
        let v2_json = serde_json::to_string(&v2).unwrap();
        assert!(invite::CommunityInvite::from_bundle_json(&v2_json).is_ok(), "a real v2 bundle parses");
        let v1_like = r#"{"community_id":"aa","name":"X","relays":[]}"#;
        assert!(invite::CommunityInvite::from_bundle_json(v1_like).is_err(), "a v1 bundle is not a v2 bundle");
    }

    #[tokio::test]
    async fn verify_rejects_a_cross_community_owner_edition_replay() {
        // The eclipse-via-replay: an owner-signed edition from community X (eid == X.id)
        // rewrapped onto a FORGED community T's fake control plane must NOT authenticate
        // T. T's genesis has eid == T.id, so X's edition — a genuine owner signature but
        // a different eid — is not a valid proof of T's root. This is why "any owner
        // edition" is unsound and the eid==community_id genesis pin is required.
        let (_tmp, _guard, owner) = init_test_db();

        // Community X (real), owned by `owner`.
        let gx = control::genesis(&owner, control::CommunityMetadata { name: "X".into(), ..Default::default() }, 1_000).unwrap();
        let x_control = control_group_key(&gx.community_root, &gx.identity.community_id, Epoch(0));
        let (_ed, opened) = control::open_control_edition(&gx.wraps[0], &x_control).unwrap();

        // Forged community T: the real owner triple but an ATTACKER-chosen root.
        let t_identity = control::CommunityIdentity::mint(&owner.public_key());
        let fake_root = [0xEE; 32];
        let t = CommunityV2 {
            identity: t_identity,
            community_root: fake_root,
            root_epoch: Epoch(0),
            name: "T".into(),
            description: None,
            icon: None,
            banner: None,
            meta_custom: None,
            meta_extra: Default::default(),
            relays: vec!["wss://r".into()],
            channels: vec![],
            dissolved: false,
            created_at_ms: 0,
        };
        // Rewrap X's owner-signed genesis onto T's fake control plane (the attacker
        // controls the fake root, so they can derive its control group key).
        let t_control = control_group_key(&fake_root, t.id(), t.root_epoch);
        let (replayed, _) = stream::rewrap_seal(&opened.seal, &t_control, Timestamp::from_secs(1_000)).unwrap();
        let relay = MemoryRelay::new();
        relay.publish(&replayed, &t.relays).await.unwrap();

        let verified = verify_owner_root_and_reconcile(&relay, t.clone()).await;
        assert!(verified.is_err(), "a cross-community owner-edition replay must not authenticate a forged root");
    }

    /// LIVE smoke test (network) — ignored by default. Creates a v2 community on a
    /// REAL relay via `LiveTransport`, sends a message, fetches it back, and mints
    /// a public link. A fresh throwaway identity in an isolated temp data dir, so
    /// it never touches real accounts. Run explicitly:
    /// ```sh
    /// cargo test -p vector-core -- --ignored --nocapture live_smoke
    /// ```
    #[tokio::test]
    #[ignore = "hits a real relay over the network"]
    async fn live_smoke_create_send_fetch_on_a_real_relay() {
        use crate::community::transport::LiveTransport;
        use nostr_sdk::prelude::ToBech32;

        let relay = std::env::var("VECTOR_SMOKE_RELAY").unwrap_or_else(|_| "wss://jskitty.com/nostr".to_string());
        let relays = vec![relay.clone()];

        // Isolated account + data dir (a fresh throwaway key — never a real account).
        let _g = crate::db::DB_TEST_GUARD.lock().unwrap_or_else(|e| e.into_inner());
        crate::db::close_database();
        crate::db::clear_id_caches();
        let tmp = tempfile::tempdir().unwrap();
        // Bring your own key (VECTOR_SMOKE_NSEC) to create a community you can log
        // into elsewhere; otherwise a fresh throwaway.
        let keys = match std::env::var("VECTOR_SMOKE_NSEC") {
            Ok(n) => Keys::parse(&n).expect("VECTOR_SMOKE_NSEC is not a valid nsec"),
            Err(_) => Keys::generate(),
        };
        let npub = keys.public_key().to_bech32().unwrap();
        // Off by default (never leak secrets from a committed test); set
        // VECTOR_SMOKE_PRINT_NSEC=1 to print the owner nsec for cross-client login.
        if std::env::var("VECTOR_SMOKE_PRINT_NSEC").is_ok() {
            println!("[smoke] OWNER nsec (throwaway — do NOT reuse): {}", keys.secret_key().to_bech32().unwrap());
        }
        std::fs::create_dir_all(tmp.path().join(&npub)).unwrap();
        crate::db::set_app_data_dir(tmp.path().to_path_buf());
        crate::db::set_current_account(npub.clone()).unwrap();
        crate::db::init_database(&npub).unwrap();
        crate::state::MY_SECRET_KEY.store_from_keys(&keys, &[]);
        crate::state::set_my_public_key(keys.public_key());
        println!("[smoke] throwaway identity {npub}");

        // A live client (LiveTransport rides the global NOSTR_CLIENT + warms relays).
        let client = crate::nostr_client_builder().build();
        client.add_managed_relay(relay.as_str()).await.ok();
        client.connect().await;
        crate::state::set_nostr_client(client);
        let transport = LiveTransport::with_timeout(std::time::Duration::from_secs(15));

        // Create → send → fetch-back → verify.
        let community = create_community(&transport, "V2 Live Smoke", relays.clone(), None).await.expect("create");
        let general = community.channels[0].id;
        println!("[smoke] created community {} on {relay}", crate::simd::hex::bytes_to_hex_32(&community.id().0));

        let text = "hello from a Vector Concord v2 live smoke test";
        let sent_id = send_message(&transport, &community, &general, text).await.expect("send");
        println!("[smoke] sent message {sent_id}");

        // Give the relay a moment to store + be ready to serve it.
        tokio::time::sleep(std::time::Duration::from_secs(3)).await;

        let page = fetch_channel(&transport, &community, &general, 50).await.expect("fetch");
        let texts: Vec<String> = page
            .iter()
            .filter_map(|f| match &f.event {
                ChatEvent::Message { .. } => Some(f.event.opened().rumor.content.clone()),
                _ => None,
            })
            .collect();
        println!("[smoke] fetched {} message(s) back: {texts:?}", texts.len());
        assert!(texts.contains(&text.to_string()), "the message did not round-trip through the real relay");

        // Mint a shareable v2 link (the thing a bot hands out).
        let link = mint_public_link(&transport, &community, "https://vectorapp.io", None, None).await.expect("mint link");
        println!("[smoke] invite link: {}", link.url);
        println!("[smoke] PASS — v2 create+send+fetch+invite round-tripped on {relay}");
    }

    #[tokio::test]
    async fn chat_ops_react_edit_delete_round_trip() {
        let (bed, owner, _member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Ops", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        let me_hex = owner.keys.public_key().to_hex();

        let msg_id = send_message(&bed.relay, &community, &general, "original").await.unwrap();
        send_reaction(&bed.relay, &community, &general, &msg_id, &me_hex, super::super::kind::MESSAGE, ":fire:", Some(("fire", "https://e/f.png")))
            .await
            .unwrap();
        send_edit(&bed.relay, &community, &general, &msg_id, "edited").await.unwrap();
        send_delete(&bed.relay, &community, &general, &msg_id, super::super::kind::MESSAGE).await.unwrap();

        let page = fetch_channel(&bed.relay, &community, &general, 50).await.unwrap();
        let target = crate::simd::hex::hex_to_bytes_32(&msg_id);
        let mut saw = (false, false, false);
        for f in &page {
            match &f.event {
                ChatEvent::Reaction { target: t, emoji, emoji_url, .. } if *t == target => {
                    assert_eq!(emoji, ":fire:");
                    assert_eq!(emoji_url.as_deref(), Some("https://e/f.png"));
                    saw.0 = true;
                }
                ChatEvent::Edit { target: t, new_content, .. } if *t == target => {
                    assert_eq!(new_content, "edited");
                    saw.1 = true;
                }
                ChatEvent::Delete { target: t, .. } if *t == target => saw.2 = true,
                _ => {}
            }
        }
        assert!(saw.0 && saw.1 && saw.2, "reaction/edit/delete all round-trip: {saw:?}");
    }

    #[tokio::test]
    async fn a_typing_signal_rides_the_ephemeral_wrap_and_is_never_stored() {
        let (bed, owner, _member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Typ", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        let group = channel_group_key(&community.community_root, &general, community.root_epoch);

        // A live subscriber sees the 21059 wrap and it opens as Typing…
        let mut sub = bed.relay.subscribe(Query {
            kinds: vec![stream::KIND_WRAP_EPHEMERAL],
            authors: vec![group.pk_hex()],
            ..Default::default()
        });
        send_typing(&bed.relay, &community, &general).await.unwrap();
        let wrap = sub.try_recv().expect("the typing wrap streams to a live subscriber");
        let opened = match chat::open_chat_event(&wrap, &group, &general, community.root_epoch) {
            Ok(ChatEvent::Typing { opened }) => opened,
            other => panic!("the ephemeral wrap must open as a Typing event, got {other:?}"),
        };

        // …while nothing durable is stored (relays never keep the ephemeral tier),
        // so channel history stays free of typing noise…
        let page = fetch_channel(&bed.relay, &community, &general, 50).await.unwrap();
        assert!(page.iter().all(|f| !matches!(f.event, ChatEvent::Typing { .. })));

        // …and no scrub key is retained (there is no durable wrap to ever delete).
        assert!(
            crate::db::community::get_message_key(&opened.rumor_id.to_hex()).unwrap().is_none(),
            "ephemeral sends must not retain scrub keys"
        );
    }

    #[tokio::test]
    async fn a_durable_send_retains_the_wrap_scrub_key_and_full_delete_nukes_the_relay_copy() {
        let (bed, owner, _member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Nuke", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        let group = channel_group_key(&community.community_root, &general, community.root_epoch);

        let id = send_message(&bed.relay, &community, &general, "scrub me").await.unwrap();

        // Retained: the row maps the rumor id to the exact published wrap, holds the
        // key that SIGNED that wrap (same-author NIP-09), and the relay set.
        let (keys, outer_hex, relays) =
            crate::db::community::get_message_key(&id).unwrap().expect("a durable send retains its scrub key");
        assert_eq!(relays, community.relays);
        let wrap_query = Query {
            kinds: vec![stream::KIND_WRAP],
            authors: vec![group.pk_hex()],
            ..Default::default()
        };
        let wraps = bed.relay.fetch(&wrap_query, &community.relays).await.unwrap();
        let wrap = wraps.iter().find(|w| w.id.to_hex() == outer_hex).expect("retained outer id is the published wrap");
        assert_eq!(keys.public_key(), wrap.pubkey, "retained key is the wrap's author");

        // Reactions ride the same retention (revoke_reaction's relay-nuke layer).
        let me_hex = owner.keys.public_key().to_hex();
        let rid = send_reaction(&bed.relay, &community, &general, &id, &me_hex, super::super::kind::MESSAGE, "🔥", None)
            .await
            .unwrap();
        assert!(crate::db::community::get_message_key(&rid).unwrap().is_some(), "reaction sends retain too");

        // The shared v1 delete path (Layer 1 of delete_community_message / revoke_reaction)
        // scrubs the wrap off the relay via the retained key, then consumes the row.
        crate::community::service::delete_message(&bed.relay, &id).await.unwrap();
        assert!(crate::db::community::get_message_key(&id).unwrap().is_none(), "key consumed after the scrub");
        let after = bed.relay.fetch(&wrap_query, &community.relays).await.unwrap();
        assert!(!after.iter().any(|w| w.id.to_hex() == outer_hex), "wrap scrubbed from the relay");
    }

    #[tokio::test]
    async fn backfill_heals_scrub_keys_for_own_pre_retention_messages_only() {
        let (bed, owner, _member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Heal", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        let group = channel_group_key(&community.community_root, &general, community.root_epoch);

        // Simulate a pre-retention / other-device send: our message on the relay,
        // but no local mapping row.
        let id = send_message(&bed.relay, &community, &general, "old send").await.unwrap();
        crate::db::community::delete_message_key(&id).unwrap();
        assert!(crate::db::community::get_message_key(&id).unwrap().is_none());

        // A stranger member's message rides the same channel.
        let mkeys = Keys::generate();
        let rumor = chat::build_message_rumor(mkeys.public_key(), &general, community.root_epoch, "foreign", None, &[], vec![], 6_000);
        let foreign_id = rumor.id.unwrap().to_hex();
        let (fw, _) = chat::seal_chat_rumor(&rumor, &group, &mkeys, Timestamp::from_secs(6), false).unwrap();
        bed.relay.publish(&fw, &community.relays).await.unwrap();

        // One history open re-derives the mapping for the OWN message…
        fetch_channel(&bed.relay, &community, &general, 50).await.unwrap();
        let (keys, _outer, relays) =
            crate::db::community::get_message_key(&id).unwrap().expect("backfill heals own unretained rows");
        assert_eq!(keys.public_key(), group.pk(), "healed key is the wrap's signing key");
        assert_eq!(relays, community.relays);

        // …and never manufactures one for a foreign author.
        assert!(crate::db::community::get_message_key(&foreign_id).unwrap().is_none());

        // The healed row is a working full delete: the shared path scrubs the wrap.
        crate::community::service::delete_message(&bed.relay, &id).await.unwrap();
        let left = fetch_channel(&bed.relay, &community, &general, 50).await.unwrap();
        assert!(
            !left.iter().any(|f| f.event.opened().rumor_id.to_hex() == id),
            "healed message scrubbed from the relay"
        );
    }

    #[tokio::test]
    async fn send_chat_message_threads_the_reply_and_extra_tags() {
        let (bed, owner, _member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Re", bed.relays.clone(), None).await.unwrap();
        let general = community.channels[0].id;
        let me_hex = owner.keys.public_key().to_hex();

        let parent_id = send_message(&bed.relay, &community, &general, "parent").await.unwrap();
        let imeta = nostr_sdk::prelude::Tag::custom(
            "imeta",
            ["url https://e/blob".to_string(), "m image/png".to_string()],
        );
        let child_id = send_chat_message(
            &bed.relay, &community, &general, "child",
            Some((parent_id.as_str(), me_hex.as_str())), &[], vec![imeta],
        )
        .await
        .unwrap();

        let page = fetch_channel(&bed.relay, &community, &general, 50).await.unwrap();
        let child = page
            .iter()
            .find_map(|f| match &f.event {
                ChatEvent::Message { opened, reply_to, .. } if opened.rumor_id.to_hex() == child_id => Some((opened, reply_to)),
                _ => None,
            })
            .expect("the reply message round-trips");
        let reply = child.1.as_ref().expect("the reply reference is carried");
        assert_eq!(crate::simd::hex::bytes_to_hex_32(&reply.id), parent_id);
        assert_eq!(reply.author, Some(owner.keys.public_key()));
        assert!(
            child.0.rumor.tags.iter().any(|t| t.kind() == "imeta"),
            "the imeta attachment tag rides the rumor verbatim"
        );
    }

    #[tokio::test]
    async fn a_kick_needs_kick_authority_and_removes_the_target() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Kick", bed.relays.clone(), None).await.unwrap();

        // The target announces a Join (as an accepted invite would).
        let gb = super::super::derive::guestbook_group_key(&community.community_root, community.id(), community.root_epoch);
        let join = guestbook::build_join_rumor(member.keys.public_key(), None, 2_000);
        let (wrap, _) = guestbook::seal_guestbook_rumor(&join, &gb, &member.keys, Timestamp::from_secs(2)).unwrap();
        bed.relay.publish(&wrap, &bed.relays).await.unwrap();
        let before = memberlist(&bed.relay, &community).await.unwrap();
        assert!(before.contains(&member.keys.public_key()), "the join lands first");

        // An unprivileged member's kick of the owner is refused locally…
        bed.swap_to(&member);
        let err = kick_member(&bed.relay, &community, &owner.keys.public_key()).await.unwrap_err();
        assert!(err.contains("not authorized"), "unprivileged kick refused: {err}");

        // …and the owner (supreme, no grant needed) kicks the member out.
        bed.swap_to(&owner);
        kick_member(&bed.relay, &community, &member.keys.public_key()).await.unwrap();
        let after = memberlist(&bed.relay, &community).await.unwrap();
        assert!(!after.contains(&member.keys.public_key()), "the kicked member leaves the fold");
        assert!(after.contains(&owner.keys.public_key()), "the owner remains");
    }

    #[tokio::test]
    async fn a_rejoin_survives_a_stale_kick_and_an_uncaught_up_store() {
        // The self-eviction race: on a REJOIN the guestbook store starts empty while the
        // control fold has already re-derived the member's old ban mark, so the MEMBERLIST
        // legitimately excludes them for that window. A stale Kick landing there used to
        // read as an authorized eviction and the client nuked its own community.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Rejoin", bed.relays.clone(), None).await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let (o, m) = (owner.keys.public_key(), member.keys.public_key());
        let join = |at: u64, id: u8| guestbook::GuestbookEvent {
            rumor_id: [id; 32],
            entry: guestbook::GuestbookEntry::Join { member: m, invited_by: None, at_ms: at },
        };
        let kick = |at: u64, id: u8| guestbook::GuestbookEvent {
            rumor_id: [id; 32],
            entry: guestbook::GuestbookEntry::Kick { actor: o, target: m, citation: None, at_ms: at },
        };

        // An authorized kick after their join stands.
        crate::db::community::set_guestbook(&cid_hex, &[join(1_000, 1), kick(2_000, 2)], 2).unwrap();
        assert!(stored_kick_verdict(&community, &m), "an authorized kick after the join is honored");

        // A rejoin supersedes it — latest entry wins (CORD-02 §5).
        crate::db::community::set_guestbook(&cid_hex, &[join(1_000, 1), kick(2_000, 2), join(3_000, 3)], 3).unwrap();
        assert!(!stored_kick_verdict(&community, &m), "a Join newer than the kick clears the verdict");

        // The catch-up window itself: nothing folded yet decides nothing.
        crate::db::community::set_guestbook(&cid_hex, &[], 0).unwrap();
        assert!(!stored_kick_verdict(&community, &m), "an empty store is not an eviction");

        // And the memberlist is NOT a substitute: with the store empty it excludes them,
        // which is exactly the false positive this verdict replaced.
        assert!(
            !stored_memberlist(&community).unwrap().contains(&m),
            "the memberlist excludes an un-caught-up member — why it can't gate a kick"
        );
    }

    /// Seed a roster the way production does: `follow_control` writes the roster
    /// AND the folded edition heads in one pass, so a citation against a grant is
    /// resolvable. Seeding the roster alone yields a client that can never satisfy
    /// any `vac` — a shape no v2 production path produces.
    fn seed_roster_with_heads(community: &CommunityV2, roster: &crate::community::roles::CommunityRoles, at: i64) {
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        crate::db::community::set_community_roles(&cid_hex, roster, at).unwrap();
        for g in &roster.grants {
            let Some(m) = crate::simd::hex::hex_to_bytes_32_checked(&g.member) else { continue };
            let eid = super::super::derive::grant_locator(community.id(), &m);
            let entity_hex = crate::simd::hex::bytes_to_hex_32(&eid);
            crate::db::community::set_edition_head_at_epoch(&cid_hex, &entity_hex, 1, &[0xA1; 32], &[0xA2; 32], community.root_epoch.0).unwrap();
        }
    }

    /// Publish an edition CITING a specific grant version (CORD-04 §5's `vac`).
    async fn publish_grant_citing(
        relay: &MemoryRelay,
        community: &CommunityV2,
        signer: &Keys,
        member: &PublicKey,
        role_ids: Vec<String>,
        version: u64,
        citation: Option<&crate::community::edition::AuthorityCitation>,
    ) {
        let group = control_group_key(&community.community_root, community.id(), community.root_epoch);
        let eid = crate::community::v2::derive::grant_locator(community.id(), &member.to_bytes());
        let prev = head_hash_on_relay(relay, community, &eid).await;
        let grant = MemberGrant { member: member.to_hex(), role_ids };
        let content = crate::community::v2::roles::grant_content_json(&grant).unwrap();
        let rumor = control::build_edition_rumor(signer.public_key(), vsk::GRANT, &eid, version, prev.as_ref(), &content, 1_000, citation);
        let (wrap, _) = control::seal_control_edition(&rumor, &group, signer, Timestamp::from_secs(1_000)).unwrap();
        relay.publish(&wrap, &community.relays).await.unwrap();
    }

    #[tokio::test]
    async fn an_uncited_admin_edition_is_not_folded_but_a_cited_one_is() {
        // CORD-04 §5 on the CONTROL PLANE: "a verifier won't act on the edition
        // until it has synced at least that Grant". The citation resolves against
        // the heads THIS fold accepted — an external floor would refuse every
        // non-owner edition on a bootstrap and the roster could never fold.
        let (bed, owner, admin) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Cited", bed.relays.clone(), None).await.unwrap();
        let admin_pk = admin.keys.public_key();
        let rid = "c3".repeat(32);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::admin().0), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &admin_pk, vec![rid.clone()], 1).await;

        // The admin grants a bystander, citing NOTHING.
        // A LOWER role (position 5) — an admin at position 1 may grant beneath
        // themselves but never at their own rank (equal cannot act on equal).
        let low_rid = "c4".repeat(32);
        let mut low = admin_role(&low_rid, Permissions::admin().0);
        low.position = 5;
        publish_role(&bed.relay, &community, &owner.keys, &low, 1).await;

        let bystander = Keys::generate().public_key();
        publish_grant_citing(&bed.relay, &community, &admin.keys, &bystander, vec![low_rid.clone()], 1, None).await;
        let view = fetch_authority(&bed.relay, &community).await;
        assert!(
            !view.roles.grants.iter().any(|g| g.member == bystander.to_hex()),
            "an uncited non-owner edition is not folded"
        );
        // The owner's own editions still fold — supreme cites nothing.
        assert!(view.roles.is_admin(&admin_pk.to_hex()), "the owner-authored grant folds");

        // Same edition, now citing the admin's real grant: honored. (follow_control
        // is what PERSISTS the folded heads a citation is built from.)
        let _ = follow_control(&bed.relay, &community, &SessionGuard::capture()).await;
        let entity_id = crate::community::v2::derive::grant_locator(community.id(), &admin_pk.to_bytes());
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let entity_hex = crate::simd::hex::bytes_to_hex_32(&entity_id);
        let (version, edition_hash) = crate::db::community::get_edition_head(&cid_hex, &entity_hex).unwrap().unwrap();
        let cite = crate::community::edition::AuthorityCitation { entity_id, version, edition_hash };
        publish_grant_citing(&bed.relay, &community, &admin.keys, &bystander, vec![low_rid], 2, Some(&cite)).await;

        let view = fetch_authority(&bed.relay, &community).await;
        assert!(
            view.roles.grants.iter().any(|g| g.member == bystander.to_hex()),
            "the same edition WITH its synced citation folds"
        );
    }

    #[tokio::test]
    async fn a_join_landing_inside_the_ban_window_survives_the_unban() {
        // The invite is deliberately ungated, so a fresh Join can arrive seconds
        // BEFORE the unban edition. It must reach the store (banned = a fold
        // verdict, not a storage verdict) so the unban resurrects the member —
        // dropped at ingest, they stayed invisible forever.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Window", bed.relays.clone(), None).await.unwrap();
        let member_pk = member.keys.public_key();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);

        // Locally banned (edition folded at t=1000s), with the outliving mark.
        crate::db::community::set_community_banlist(&cid_hex, &[member_pk.to_hex()], 1_000).unwrap();
        crate::db::community::merge_community_ban_marks(&cid_hex, &[(member_pk.to_hex(), 1_000u64)].into_iter().collect()).unwrap();

        // Their Join lands 60s after the ban mark, while the banlist still says banned.
        let join = guestbook::GuestbookEvent {
            rumor_id: [9u8; 32],
            entry: guestbook::GuestbookEntry::Join { member: member_pk, invited_by: None, at_ms: 1_060_000 },
        };
        assert!(ingest_guestbook_event(&community, join, 1_060).unwrap(), "stored while banned");
        assert!(
            !stored_memberlist(&community).unwrap().contains(&member_pk),
            "while banned, the fold keeps them out"
        );

        // The unban folds: same store, no refetch needed — the Join resurrects them.
        crate::db::community::set_community_banlist(&cid_hex, &[], 2_000).unwrap();
        assert!(
            stored_memberlist(&community).unwrap().contains(&member_pk),
            "after the unban the raced Join makes them a member again"
        );
    }

    #[tokio::test]
    async fn a_stale_root_admin_write_is_refused_not_misdirected() {
        // The ban→unban race: a Ban's refound buries the old root over several
        // publishes while a concurrently-issued command still holds the
        // pre-commit struct. That unban used to land on the buried control
        // plane — "succeeding" while no reader would ever fold it — and a
        // concurrently-minted invite stranded its joiner on the dead epoch.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Race", bed.relays.clone(), None).await.unwrap();
        let member_pk = member.keys.public_key();

        set_banlist(&bed.relay, &community, &[member_pk.to_hex()]).await.unwrap();
        let _rotated = refound_community(&bed.relay, &community, &[member_pk]).await.unwrap();

        // The stale-struct unban is REFUSED (retryable), never misdirected.
        let err = set_banlist(&bed.relay, &community, &[]).await.unwrap_err();
        assert!(err.contains("re-founded"), "unban: {err}");
        // A stale invite must not mint dead-epoch key material.
        let err = send_direct_invite(&bed.relay, &community, &member_pk, None, None).await.unwrap_err();
        assert!(err.contains("re-founded"), "invite: {err}");
        // Neither is a kick allowed to ride the buried guestbook.
        let err = kick_member(&bed.relay, &community, &member_pk).await.unwrap_err();
        assert!(err.contains("re-founded"), "kick: {err}");

        // The retry path: a fresh load lands the unban on the LIVING plane.
        let fresh = crate::db::community::load_community_v2(community.id()).unwrap().unwrap();
        set_banlist(&bed.relay, &fresh, &[]).await.unwrap();
        let view = fetch_authority(&bed.relay, &fresh).await;
        assert!(view.banned.is_empty(), "the retried unban actually unbans");
    }

    #[tokio::test]
    async fn an_uncited_kick_from_an_admin_is_not_honored() {
        // CORD-04 §5: a non-owner authority action must name the Grant it acts
        // under, and the reader refuses until it holds that Grant. Emitting the
        // `vac` without checking it buys nothing — a demoted admin's kick would
        // still land on any client that hadn't synced the demotion.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Uncited", bed.relays.clone(), None).await.unwrap();
        let admin = Keys::generate();
        let member_pk = member.keys.public_key();
        grant_admin(&bed.relay, &community, &admin.public_key()).await.unwrap();

        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let view = fetch_authority(&bed.relay, &community).await;
        crate::db::community::set_community_roles(&cid_hex, &view.roles, 1_000).unwrap();

        let entity_id = super::super::derive::grant_locator(community.id(), &admin.public_key().to_bytes());
        let entity_hex = crate::simd::hex::bytes_to_hex_32(&entity_id);
        let (version, edition_hash) = crate::db::community::get_edition_head(&cid_hex, &entity_hex).unwrap().unwrap();
        let cite = crate::community::edition::AuthorityCitation { entity_id, version, edition_hash };

        let joined = guestbook::GuestbookEvent {
            rumor_id: [1u8; 32],
            entry: guestbook::GuestbookEntry::Join { member: member_pk, invited_by: None, at_ms: 1_000 },
        };
        let kick = |citation, id: u8, at| guestbook::GuestbookEvent {
            rumor_id: [id; 32],
            entry: guestbook::GuestbookEntry::Kick { actor: admin.public_key(), target: member_pk, citation, at_ms: at },
        };
        let roles = crate::db::community::get_community_roles(&cid_hex).unwrap();
        let empty_bans = std::collections::BTreeSet::new();
        let empty_marks = std::collections::BTreeMap::new();
        let fold = |evs: &[guestbook::GuestbookEvent]| {
            fold_members(&community, evs, Default::default(), &roles, &empty_bans, &empty_marks).unwrap()
        };

        assert!(
            fold(&[joined.clone(), kick(None, 2, 2_000)]).contains(&member_pk),
            "an uncited kick from an admin is not honored"
        );
        assert!(
            !fold(&[joined, kick(Some(cite), 3, 3_000)]).contains(&member_pk),
            "the same kick WITH its synced citation removes them"
        );
    }

    #[tokio::test]
    async fn kicking_an_admin_strips_their_roles_first() {
        // CORD-04 §6 composition: Role Removal THEN the directive. Kicking without the
        // strip leaves the target out of the memberlist but still holding every
        // management bit, so every client keeps honoring their control editions.
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Compose", bed.relays.clone(), None).await.unwrap();
        let member_pk = member.keys.public_key();
        let member_hex = member_pk.to_hex();
        let owner_hex = owner.keys.public_key().to_hex();

        grant_admin(&bed.relay, &community, &member_pk).await.unwrap();
        assert!(fetch_authority(&bed.relay, &community).await.roles.is_admin(&member_hex));

        kick_member(&bed.relay, &community, &member_pk).await.unwrap();

        let view = fetch_authority(&bed.relay, &community).await;
        assert!(!view.roles.is_admin(&member_hex), "the kick stripped their rank");
        assert!(
            !view.roles.is_authorized(&member_hex, Some(&owner_hex), Permissions::MANAGE_ROLES),
            "a kicked admin holds no bit"
        );
        assert!(
            !memberlist(&bed.relay, &community).await.unwrap().contains(&member_pk),
            "and the directive still removed them"
        );
    }

    #[tokio::test]
    async fn grant_admin_mints_one_deterministic_role_and_revoke_strips_it() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Adm", bed.relays.clone(), None).await.unwrap();
        let member_pk = member.keys.public_key();
        let member_hex = member_pk.to_hex();
        let owner_hex = owner.keys.public_key().to_hex();

        grant_admin(&bed.relay, &community, &member_pk).await.unwrap();
        let view = fetch_authority(&bed.relay, &community).await;
        assert!(view.roles.is_admin(&member_hex), "the grant folds as admin");
        assert!(view.roles.is_authorized(&member_hex, Some(&owner_hex), Permissions::MANAGE_ROLES));

        // A second grant (any device) converges on the SAME role entity — and a
        // repeat is a no-op, not a version bump.
        let second = Keys::generate().public_key();
        grant_admin(&bed.relay, &community, &second).await.unwrap();
        grant_admin(&bed.relay, &community, &member_pk).await.unwrap();
        let view = fetch_authority(&bed.relay, &community).await;
        assert_eq!(view.roles.roles.len(), 1, "one Admin role, never a fork");
        assert!(view.roles.is_admin(&member_hex) && view.roles.is_admin(&second.to_hex()));
        let grant = view.roles.grants.iter().find(|g| g.member == member_hex).unwrap();
        assert_eq!(grant.role_ids.len(), 1, "no duplicate role id in the grant");

        // Revoke strips ONLY the admin role and de-authorizes.
        revoke_admin(&bed.relay, &community, &member_pk).await.unwrap();
        let view = fetch_authority(&bed.relay, &community).await;
        assert!(!view.roles.is_admin(&member_hex), "revoked");
        assert!(view.roles.is_admin(&second.to_hex()), "the other admin is untouched");
        assert!(!view.roles.is_authorized(&member_hex, Some(&owner_hex), Permissions::KICK));
    }

    #[tokio::test]
    async fn follow_control_persists_the_roster_for_sync_local_reads() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Persist", bed.relays.clone(), None).await.unwrap();
        let cid_hex = crate::simd::hex::bytes_to_hex_32(&community.id().0);
        let member_hex = member.keys.public_key().to_hex();
        grant_admin(&bed.relay, &community, &member.keys.public_key()).await.unwrap();

        // The passive follow folds + persists; the read is then LOCAL (v1 parity).
        let session = crate::state::SessionGuard::capture();
        follow_control(&bed.relay, &community, &session).await.unwrap();
        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        assert!(roster.is_admin(&member_hex), "the persisted roster reads back without a fetch");

        // A withholding relay serves nothing — an empty fold raises no gap flag, and
        // the stored roster must be RETAINED, never wiped.
        let withholding = MemoryRelay::new();
        let _ = follow_control(&withholding, &community, &session).await;
        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        assert!(roster.is_admin(&member_hex), "withholding never shrinks standing");

        // A real revocation (a NEWER grant edition) does replace it.
        revoke_admin(&bed.relay, &community, &member.keys.public_key()).await.unwrap();
        follow_control(&bed.relay, &community, &session).await.unwrap();
        let roster = crate::db::community::get_community_roles(&cid_hex).unwrap();
        assert!(!roster.is_admin(&member_hex), "the revoke folds + persists");
    }

    #[tokio::test]
    async fn grant_admin_is_refused_for_a_non_owner_and_publishes_nothing() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "NoSquat", bed.relays.clone(), None).await.unwrap();

        bed.swap_to(&member);
        let err = grant_admin(&bed.relay, &community, &member.keys.public_key()).await.unwrap_err();
        assert!(err.contains("owner"), "refused before any publish: {err}");

        // The deterministic admin-role entity stays unsquatted — the owner's later
        // legitimate mint is version 1 and folds cleanly.
        bed.swap_to(&owner);
        let view = fetch_authority(&bed.relay, &community).await;
        assert!(view.roles.roles.is_empty(), "no role edition landed");
        grant_admin(&bed.relay, &community, &member.keys.public_key()).await.unwrap();
        let view = fetch_authority(&bed.relay, &community).await;
        assert!(view.roles.is_admin(&member.keys.public_key().to_hex()));
    }

    #[tokio::test]
    async fn grant_admin_merges_other_roles_and_refuses_a_withheld_grant() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Merge", bed.relays.clone(), None).await.unwrap();
        let member_pk = member.keys.public_key();

        // The member already holds a Mod role, granted through the real send path
        // (so this device's floors track both entities).
        let mod_rid = crate::simd::hex::bytes_to_hex_32(&[0x66; 32]);
        set_role(&bed.relay, &community, &admin_role(&mod_rid, Permissions::BAN)).await.unwrap();
        grant_roles(&bed.relay, &community, &member_pk, vec![mod_rid.clone()]).await.unwrap();

        // A relay that withholds the control plane must refuse the merge — a blind
        // push would erase the Mod role at a higher version.
        let withholding = MemoryRelay::new();
        let err = grant_admin(&withholding, &community, &member_pk).await.unwrap_err();
        assert!(err.contains("could not be fetched"), "withheld grant refused: {err}");

        // Against the full relay the merge preserves the Mod role.
        grant_admin(&bed.relay, &community, &member_pk).await.unwrap();
        let view = fetch_authority(&bed.relay, &community).await;
        let grant = view.roles.grants.iter().find(|g| g.member == member_pk.to_hex()).unwrap();
        assert_eq!(grant.role_ids.len(), 2, "admin ADDED to the existing grant, not replacing it");
        assert!(grant.role_ids.contains(&mod_rid));
    }

    #[tokio::test]
    async fn fetch_authority_reflects_a_granted_admin() {
        let (bed, owner, member) = TestBed::new();
        bed.swap_to(&owner);
        let community = create_community(&bed.relay, "Auth", bed.relays.clone(), None).await.unwrap();
        let rid = crate::simd::hex::bytes_to_hex_32(&[0x5a; 32]);
        publish_role(&bed.relay, &community, &owner.keys, &admin_role(&rid, Permissions::ADMIN_ALL), 1).await;
        publish_grant(&bed.relay, &community, &owner.keys, &member.keys.public_key(), vec![rid], 1).await;

        let view = fetch_authority(&bed.relay, &community).await;
        let member_hex = member.keys.public_key().to_hex();
        assert!(view.roles.is_admin(&member_hex), "the granted member folds as admin");
        assert!(
            view.roles.is_authorized(&member_hex, Some(&owner.keys.public_key().to_hex()), Permissions::KICK),
            "an ADMIN_ALL grant carries KICK"
        );
        assert!(view.banned.is_empty());
    }
}