fix(concord): v1 accepted writes into a dissolved community

CORD-02 §9 seals a dissolved community: no peer accepts another event, ever.
v2 enforces that in `chat_send_context`, which every v2 send routes through.
v1 has no shared send gate, so message, file, typing and hide each let a write
through — it would sit pending forever with no reason given.

Guarded on the write paths, deliberately NOT on `resolve_channel`: reads share
it and a sealed community must stay browsable. The file check moves ahead of
the encrypt + upload, matching that path's existing rule of never spending an
upload on an unroutable send.

`dissolved` is also surfaced now — in the core listing, as `Community::
is_dissolved()`, and in the agent tool description. Without it a bot cannot
tell a sealed room from a live one and retries into a tombstone forever.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: JSKitty

crates/vector-agent/src/tools.rs

@@ -452,7 +452,7 @@ impl VectorAgent {
 
     // === Communities ===
 
-    #[tool(description = "List all Vector Communities held locally (owned or joined), each with its channels and channel ids. Use a channel id as the chat_id for get_messages.")]
+    #[tool(description = "List all Vector Communities held locally (owned or joined), each with its channels and channel ids. Use a channel id as the chat_id for get_messages. `dissolved: true` means the community is permanently sealed — its history still reads, but no message or change will EVER be accepted again, so do not try to post there.")]
     async fn list_communities(&self) -> Result<CallToolResult, McpError> {
         let communities = self.core.list_communities().await;
         let json = serde_json::to_string_pretty(&communities).unwrap_or_else(|_| "[]".into());

crates/vector-core/src/community/v2/service.rs

@@ -7764,6 +7764,34 @@ mod tests {
         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();

crates/vector-core/src/lib.rs

@@ -1077,6 +1077,11 @@ impl VectorCore {
                             "name": c.name,
                             "description": c.description,
                             "is_owner": is_owner,
+                            // A dissolved community is SEALED: the row survives (history
+                            // is never auto-deleted) but no write is ever accepted again.
+                            // Without this a bot cannot tell it from a live one and
+                            // retries sends into a tombstone forever.
+                            "dissolved": c.dissolved,
                             // `readable` is the field a bot needs and could never
                             // compute: a private channel we've been told about but
                             // hold no key for is enumerable-but-unreadable, which
@@ -1102,6 +1107,7 @@ impl VectorCore {
                             "name": c.name,
                             "description": c.description,
                             "is_owner": crate::community::service::is_proven_owner(&c),
+                            "dissolved": c.dissolved,
                             "channels": c.channels.iter()
                                 .map(|ch| serde_json::json!({ "channel_id": ch.id.to_hex(), "name": ch.name }))
                                 .collect::<Vec<_>>(),
@@ -1871,6 +1877,7 @@ impl VectorCore {
                 .map_err(VectorError::Other);
         }
         let (community, channel) = self.resolve_channel(channel_id)?;
+        Self::ensure_v1_writable(&community)?;
         let author_pk = state::my_public_key().ok_or_else(|| VectorError::Other("Not logged in".into()))?;
         let reply = replied_to.filter(|r| !r.is_empty());
         let ms = std::time::SystemTime::now()
@@ -1941,6 +1948,20 @@ impl VectorCore {
             Some(_) => None,
             None => Some(self.resolve_channel(channel_id)?),
         };
+        // Same fail-fast rationale as the routing check above: a sealed community
+        // (CORD-02 §9) accepts nothing, so refuse before the encrypt + upload rather
+        // than burning a Blossom round-trip on a send that can never land. v2's own
+        // gate is inside the send, which is too late to save the upload.
+        match (&v2_target, &v1_target) {
+            (Some(c), _) => {
+                let cid = crate::simd::hex::bytes_to_hex_32(&c.id().0);
+                if crate::db::community::get_community_dissolved(&cid).unwrap_or(false) {
+                    return Err(VectorError::Other("this community has been dissolved".into()));
+                }
+            }
+            (None, Some((c, _))) => Self::ensure_v1_writable(c)?,
+            _ => {}
+        }
         let author_pk = state::my_public_key().ok_or_else(|| VectorError::Other("Not logged in".into()))?;
 
         let file_hash = crate::crypto::sha256_hex(&bytes);
@@ -2045,6 +2066,7 @@ impl VectorCore {
                 .map_err(VectorError::Other);
         }
         let (community, channel) = self.resolve_channel(channel_id)?;
+        Self::ensure_v1_writable(&community)?;
         let transport = LiveTransport::with_timeout(std::time::Duration::from_secs(8));
         service::publish_typing_signal(&transport, &community, &channel)
             .await
@@ -2299,6 +2321,7 @@ impl VectorCore {
     ) -> Result<()> {
         use crate::community::{envelope, inbound, service, transport::LiveTransport};
         let (community, channel) = self.resolve_channel(channel_id)?;
+        Self::ensure_v1_writable(&community)?;
         let author_pk = state::my_public_key().ok_or_else(|| VectorError::Other("Not logged in".into()))?;
         let ms = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
@@ -3218,6 +3241,19 @@ impl VectorCore {
     }
 
     /// Resolve a channel id to its owning Community + the Channel (with its secret key).
+    /// Refuse a WRITE into a sealed community (CORD-02 §9). Once dissolved, no honest
+    /// peer accepts another event, so a send would sit pending forever with no reason
+    /// given. v2 enforces this inside `chat_send_context`; v1 has no shared send gate,
+    /// so each write path calls this.
+    ///
+    /// Reads are deliberately untouched — a dissolved community stays browsable.
+    fn ensure_v1_writable(community: &crate::community::Community) -> Result<()> {
+        if crate::db::community::get_community_dissolved(&community.id.to_hex()).unwrap_or(false) {
+            return Err(VectorError::Other("this community has been dissolved".into()));
+        }
+        Ok(())
+    }
+
     fn resolve_channel(
         &self,
         channel_id: &str,

crates/vector-sdk/src/lib.rs

@@ -1042,6 +1042,33 @@ impl Community {
             .unwrap_or_default()
     }
 
+    /// Whether this community has been DISSOLVED (permanently sealed by its owner).
+    ///
+    /// The local history survives — it is never auto-deleted — but the tombstone means
+    /// no relay will ever accept another message or control edit, by anyone. A bot that
+    /// does not check this retries sends into a sealed room forever, so gate any
+    /// unattended posting loop on it.
+    ///
+    /// ```no_run
+    /// # async fn f(bot: &vector_sdk::VectorBot) -> Result<(), Box<dyn std::error::Error>> {
+    /// for community in bot.communities().await {
+    ///     if community.is_dissolved().await { continue; }
+    ///     // ...safe to post
+    /// }
+    /// # Ok(()) }
+    /// ```
+    pub async fn is_dissolved(&self) -> bool {
+        self.core
+            .list_communities()
+            .await
+            .into_iter()
+            .find(|v| {
+                v.get("community_id").or_else(|| v.get("id")).and_then(|i| i.as_str()) == Some(self.id.as_str())
+            })
+            .and_then(|v| v.get("dissolved").and_then(|d| d.as_bool()))
+            .unwrap_or(false)
+    }
+
     /// A handle to one channel of this community by id.
     pub fn channel(&self, channel_id: impl Into<String>) -> Channel {
         Channel { core: self.core, id: channel_id.into(), kind: ChannelKind::Community }