diff --git a/.release/desktop-candidate.json b/.release/desktop-candidate.json
index 3957e635acc..b8516ee3463 100644
--- a/.release/desktop-candidate.json
+++ b/.release/desktop-candidate.json
@@ -1,10 +1,10 @@
 {
   "schema": 2,
-  "version": "0.5.10",
-  "base_sha": "f35930104bcbdb1332ff13735214ecb9fce1fc7b",
-  "previous_tag": "desktop-v0.5.9",
-  "previous_base_sha": "f8f2ef0440e7a074223ec04dc3b32d817b8b9d9b",
-  "previous_merge_sha": "538e5e113fc33571f939c87b925567fd4e277109",
-  "tag": "desktop-v0.5.10",
-  "commit_count": 18
+  "version": "0.5.11",
+  "base_sha": "4749bc7be3cdb78c2db4ce4864775ba7ab60b4cc",
+  "previous_tag": "desktop-v0.5.10",
+  "previous_base_sha": "f35930104bcbdb1332ff13735214ecb9fce1fc7b",
+  "previous_merge_sha": "4b3570671eb2786594267758af18784ac6e82972",
+  "tag": "desktop-v0.5.11",
+  "commit_count": 16
 }
diff --git a/AGENTS.md b/AGENTS.md
index c0875305f66..f3793f5a29c 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -172,8 +172,8 @@ place.
 | `.github/workflows/upstream-sync-merge.yml` | new | The deterministic (01:30) sync stage — the one that preserves the merge parent. Plain git, no AI. Optional `SYNC_PUSH_TOKEN` secret: a branch pushed with `GITHUB_TOKEN` does not start new workflow runs, so set a PAT if CI stops firing on sync PRs |
 | `.github/workflows/upstream-sync-ci-status.yml` | new | Labels an open sync PR `sync-ci-green`/`sync-ci-red` once checks settle, and re-requests the Copilot review that gh-aw's `reviewers:` fails to attach. Deliberately does not merge |
 | `migrations/0027_wallet_binding_fts.sql`, `0028_wallet_binding_fts_kind_move.sql` | new, and **kept after the feature was removed** | Search exclusions for the withdrawn NIP-SW wallet binding. They have already run on live databases and sqlx checksums applied migrations, so deleting them breaks startup validation. What they leave behind — a `search_tsv` expression excluding a kind nobody publishes — is inert, and unwinding it would rewrite a generated column across the whole events table for nothing. **Never edit or delete an applied migration**; add a follow-on |
-| `migrations/0029_channels_id_lookup_index.sql`, `0030_long_reaction_payloads.sql` | upstream's `0027_channels_id_lookup_index.sql` and `0028_long_reaction_payloads.sql`, **renumbered**; contents byte-identical | The fork holds 0027 and 0028, so upstream's own new migrations have to arrive above them. Two syncs running, so treat this as the standing cost of the fork's migration block rather than a special case. See [Upstream migrations arrive renumbered](#upstream-migrations-arrive-renumbered) |
-| `crates/buzz-db/src/migration.rs` | `migrations.len()` assertion is 30, not upstream's 28; upstream's channel-index assertion reads `migrations[28].version == 29`, its long-reaction assertion reads `migrations[29].version == 30`, and the highest applied version is `Some(30)` | Counts embedded migrations, so it moves whenever *either* side adds one. `0027` landed without bumping it and left the test failing on `main`; fixed in PR #9. Beyond the count, every upstream assertion that indexes `migrations[…]` past 25 or names a version above 26 has to be shifted by the fork's two — see the section below for why the test suite will *not* catch it if you forget |
+| `migrations/0029_channels_id_lookup_index.sql`, `0030_long_reaction_payloads.sql`, `0031_community_deletion.sql`, `0032_community_deletion_recovery.sql` | upstream's `0027_channels_id_lookup_index.sql`, `0028_long_reaction_payloads.sql`, `0029_community_deletion.sql` and `0030_community_deletion_recovery.sql`, **renumbered**; contents byte-identical | The fork holds 0027 and 0028, so upstream's own new migrations have to arrive above them. Four syncs running, so treat this as the standing cost of the fork's migration block rather than a special case. See [Upstream migrations arrive renumbered](#upstream-migrations-arrive-renumbered) |
+| `crates/buzz-db/src/migration.rs` | `migrations.len()` assertion is 32, not upstream's 30; upstream's channel-index assertion reads `migrations[28].version == 29`, long-reaction `migrations[29].version == 30`, deletion `migrations[30].version == 31`, deletion-recovery `migrations[31].version == 32`; and `deletion_surface_parity_between_migration_0029_and_schema_sql` looks up `version == 31` | Counts embedded migrations, so it moves whenever *either* side adds one. `0027` landed without bumping it and left the test failing on `main`; fixed in PR #9. Beyond the count, every upstream assertion that indexes `migrations[…]` past 25 or names a version above 26 has to be shifted by the fork's two — see the section below for why the test suite will *not* catch it if you forget. **The highest-applied-version assertion is no longer a fork patch**: upstream's 2026-08-13 range replaced the hardcoded `Some(30)` with a `latest_version` derived from `MIGRATOR`, so it now tracks the renumber on its own — take upstream's version if it ever conflicts again |
 | `.github/workflows/macos-canary.yml` | new; `push` trigger on `main` with desktop path filters | Unsigned macOS canary; upstream only has a *signed* one, which a fork cannot run. Builds automatically when `desktop/**`, `crates/**` or the root `Cargo.*` change, so the newest artifact always matches `main` — it was dispatch-only, and the sole artifact went 13 commits stale. Free: the repo is public, so GitHub-hosted macOS runners are unbilled. Stages the artifact and the usage notes under the product name read from `tauri.conf.json`, not a hardcoded one, so the brand rename below cannot publish a build under the old name. Sets `signingIdentity: "-"` in its inline config and runs **without** `--no-sign`, which would silently discard it; asserts the bundle signature of the `.app` inside the mounted DMG. Its **sidecar list must track upstream's non-Windows lanes**: `tauri.conf.json`'s `externalBin` is shared, and `scripts/bundle-sidecars.sh` exits 1 on a missing binary, so a sidecar upstream adds breaks this workflow without ever conflicting — `buzz-backend-kubernetes` (#4289) did exactly that in the 2026-08-03 sync |
 | `Dockerfile` | `buzz-paymaster` added to the cargo build, the strip step, and both `COPY` stages | The sponsor ships in the relay's image so there is one publish pipeline and one immutable `:sha-<7>` tag for `deploy-aws.yml` to pin. Four one-line additions, each inside an existing parallel list, so a conflict resolves as *keep ours, take upstream's*. It is **not** the `ENTRYPOINT` — `infra/aws/paymaster.tf` overrides `entryPoint` |
 | `.github/aw/actions-lock.json` | new | gh-aw action SHA pins |
@@ -245,12 +245,16 @@ database**, so the side with *applied history* keeps it — the fork. Same shape
 collision, opposite resolution, because "already deployed" points at different
 parties in the two cases.
 
-It has now happened twice running — `0027_channels_id_lookup_index.sql` (upstream
-#4647) in the 2026-08-05 sync, then `0028_long_reaction_payloads.sql` (upstream #3833)
-in the 2026-08-06 sync, renumbered to `0029` and `0030`. Expect it on any sync that
-touches `migrations/`, and note that the *second* collision is the more dangerous
-shape: upstream's 0028 landed on the fork's 0028, so the two files sorted adjacent and
-the tree looked plausible. **A new file under `migrations/` is the tripwire — check the
+It has now happened on three separate syncs, covering four migrations —
+`0027_channels_id_lookup_index.sql` (upstream #4647) in the 2026-08-05 sync, then
+`0028_long_reaction_payloads.sql` (upstream #3833) in the 2026-08-06 sync, then
+`0029_community_deletion.sql` **and** `0030_community_deletion_recovery.sql`
+(upstream #4425) together in the 2026-08-13 sync; renumbered to `0029`, `0030`,
+`0031` and `0032`. Expect it on any sync that touches `migrations/`, and note that
+the *second* collision is the more dangerous shape: upstream's 0028 landed on the
+fork's 0028, so the two files sorted adjacent and the tree looked plausible. The
+2026-08-13 sync was that shape twice over — both of upstream's new files landed on
+fork-held integers. **A new file under `migrations/` is the tripwire — check the
 version integer before reading anything else in the diff.**
 
 The first one is worth keeping in full because it shows exactly how the failure hides
@@ -297,10 +301,28 @@ merge cleanly into a tree where both are wrong:
 |------|----------|--------------------------------------|
 | 2026-08-05 | 0027 → 0029 | `migrations[26].version == 27` → `migrations[28].version == 29`; `applied_versions(…).last() == Some(27)` → `Some(29)` |
 | 2026-08-06 | 0028 → 0030 | `migrations[27].version == 28` → `migrations[29].version == 30`; `migrations.len()` 28 → 30; `applied_versions(…).last()` → `Some(30)` |
+| 2026-08-13 | 0029 → 0031 **and** 0030 → 0032 | `migrations[28].version == 29` → `migrations[30].version == 31`; `migrations[29].version == 30` → `migrations[31].version == 32`; `migrations.len()` 30 → 32; **and a version-literal lookup**, `find(\|m\| m.version == 29)` → `31`, in `deletion_surface_parity_between_migration_0029_and_schema_sql` |
 
 Only `migrations.len()` arrives as a *conflict*; every indexed assertion arrives as
 clean context, which is why the diff will not point you at them. Grep the test module
-for the old integer instead. A cheap independent check that the rename actually took:
+for the old integer instead.
+
+**Grepping for the index is not enough — there is a third shape.** The 2026-08-13
+sync added `deletion_surface_parity_between_migration_0029_and_schema_sql`, which
+resolves its migration with `MIGRATOR.iter().find(|m| m.version == 29)` rather than
+by index. Fixing the count and both indexed assertions left it silently reading the
+*fork's* 0029 (the channels index), where it found zero deletion tables and failed.
+So sweep for all three: `migrations.len()`, `migrations[N]`, and `version == N`.
+Unlike the indexed assertions this one does fail loudly, which is the only reason it
+was caught — do not rely on that holding for the next one.
+
+That sync also renumbered **two** migrations at once, and upstream's second file
+(`0030_community_deletion_recovery.sql`) landed exactly on the fork's own `0030`.
+Renumber the whole upstream block in one pass and keep its internal order; the
+recovery migration alters tables the deletion migration creates, so a reordering
+that happens to dodge the collision would still fail at runtime.
+
+A cheap independent check that the rename actually took:
 
 ```bash
 ls migrations/*.sql | sed 's|.*/||' | cut -d_ -f1 | sort | uniq -d
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 63783b36b8b..aa19e933d16 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,31 @@
 # Changelog
 
+## v0.5.11
+
+### Desktop and shared changes
+
+- perf(desktop): persist channel snapshot hash ([#5684](https://github.com/block/buzz/pull/5684)) ([`c86443c5997c96c42829ce200e73e6e6efe52d96`](https://github.com/block/buzz/commit/c86443c5997c96c42829ce200e73e6e6efe52d96))
+- fix(agent): raise output limit and allow 3 recoveries ([#5475](https://github.com/block/buzz/pull/5475)) ([`72d56e7bd3a94fa3ee20b5a50bd1b868a9329d9c`](https://github.com/block/buzz/commit/72d56e7bd3a94fa3ee20b5a50bd1b868a9329d9c))
+- fix(desktop): defer foreground resume work ([#5696](https://github.com/block/buzz/pull/5696)) ([`59f613c404958d8ac99525b4aaaf26843257de31`](https://github.com/block/buzz/commit/59f613c404958d8ac99525b4aaaf26843257de31))
+- perf(desktop): coalesce thread-activity localStorage writes ([#5693](https://github.com/block/buzz/pull/5693)) ([`c6c6e7eca70d6b526c43af925e596e8616b19fb8`](https://github.com/block/buzz/commit/c6c6e7eca70d6b526c43af925e596e8616b19fb8))
+- Batch observer-store publications per relay envelope ([#5680](https://github.com/block/buzz/pull/5680)) ([`c3b0ccf383fe4ee936abbe6b9c9134b5728cc2b5`](https://github.com/block/buzz/commit/c3b0ccf383fe4ee936abbe6b9c9134b5728cc2b5))
+- feat(buzz-acp): idle re-sleep for woken lazy pools ([#5682](https://github.com/block/buzz/pull/5682)) ([`dc2dbfe0f570abb818d3f3da8a71ea235555ed27`](https://github.com/block/buzz/commit/dc2dbfe0f570abb818d3f3da8a71ea235555ed27))
+- fix(desktop): preserve agent mention separator after send ([#5623](https://github.com/block/buzz/pull/5623)) ([`a8e5c89e23b85ee93306f2c3c11d8fe6300cd360`](https://github.com/block/buzz/commit/a8e5c89e23b85ee93306f2c3c11d8fe6300cd360))
+- fix(link-previews): proxy sent preview media ([#5627](https://github.com/block/buzz/pull/5627)) ([`884ed8a5d35dfba3892fc40437f39e08856dec7d`](https://github.com/block/buzz/commit/884ed8a5d35dfba3892fc40437f39e08856dec7d))
+- feat(deletion): add durable whole-community deletion ([#4425](https://github.com/block/buzz/pull/4425)) ([`8a2c9af2dbe0cf315e77f43a4560d3572da5e554`](https://github.com/block/buzz/commit/8a2c9af2dbe0cf315e77f43a4560d3572da5e554))
+- fix(desktop): preserve live channel timelines ([#5662](https://github.com/block/buzz/pull/5662)) ([`63d14a0e95c8d5ae19f3f80123027729ec209bb2`](https://github.com/block/buzz/commit/63d14a0e95c8d5ae19f3f80123027729ec209bb2))
+- Refine channel settings and profile panels ([#5574](https://github.com/block/buzz/pull/5574)) ([`63f961c7e4818a1d29f1185002c123e486bd4a19`](https://github.com/block/buzz/commit/63f961c7e4818a1d29f1185002c123e486bd4a19))
+- fix(deps): bump webbrowser to 1.2.4 for RUSTSEC-2026-0257 ([#5659](https://github.com/block/buzz/pull/5659)) ([`c966b862fe8b9018c68c384b1680ca0173d0128c`](https://github.com/block/buzz/commit/c966b862fe8b9018c68c384b1680ca0173d0128c))
+- fix(desktop): launch Databricks OAuth from passive model discovery ([#5607](https://github.com/block/buzz/pull/5607)) ([`1ff98fa685fdb7133dbc18437d23dcdeeb42ce6e`](https://github.com/block/buzz/commit/1ff98fa685fdb7133dbc18437d23dcdeeb42ce6e))
+
+### Other repository changes
+
+- feat(acp): report standard adapter usage ([#4950](https://github.com/block/buzz/pull/4950)) ([`4749bc7be3cdb78c2db4ce4864775ba7ab60b4cc`](https://github.com/block/buzz/commit/4749bc7be3cdb78c2db4ce4864775ba7ab60b4cc))
+- fix(mobile): settle hydrated threads on latest reply ([#4702](https://github.com/block/buzz/pull/4702)) ([`7634fe74563ea7f3c86fb6017a0ad647a9934477`](https://github.com/block/buzz/commit/7634fe74563ea7f3c86fb6017a0ad647a9934477))
+- feat(acp): deliver channel description in prompt [Context] ([#4552](https://github.com/block/buzz/pull/4552)) ([`6e0631f6b5d2139e4e080bf94e27ecee8a3d4d74`](https://github.com/block/buzz/commit/6e0631f6b5d2139e4e080bf94e27ecee8a3d4d74))
+
+[Compare desktop-v0.5.10...desktop-v0.5.11](https://github.com/block/buzz/compare/desktop-v0.5.10...desktop-v0.5.11)
+
 ## v0.5.10
 
 ### Desktop and shared changes
diff --git a/Cargo.lock b/Cargo.lock
index a512a8e2107..302f50f294a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -904,6 +904,7 @@ dependencies = [
  "buzz-auth",
  "buzz-core",
  "buzz-db",
+ "buzz-deletion",
  "buzz-media",
  "buzz-pubsub",
  "buzz-search",
@@ -1112,6 +1113,28 @@ dependencies = [
  "uuid 1.23.1",
 ]
 
+[[package]]
+name = "buzz-deletion"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "buzz-core",
+ "buzz-db",
+ "buzz-media",
+ "chrono",
+ "clap",
+ "deadpool-redis",
+ "hex",
+ "redis",
+ "serde",
+ "serde_json",
+ "sqlx",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-util",
+ "uuid 1.23.1",
+]
+
 [[package]]
 name = "buzz-dev-mcp"
 version = "0.1.0"
@@ -1306,6 +1329,7 @@ dependencies = [
  "buzz-core",
  "buzz-datastore-tracing",
  "buzz-db",
+ "buzz-deletion",
  "buzz-media",
  "buzz-pubsub",
  "buzz-relay-mesh",
@@ -1465,6 +1489,7 @@ version = "0.1.0"
 dependencies = [
  "buzz-core",
  "buzz-db",
+ "buzz-deletion",
  "chrono",
  "cron",
  "dashmap",
@@ -6511,6 +6536,17 @@ dependencies = [
  "objc2-encode",
 ]
 
+[[package]]
+name = "objc2-app-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
+dependencies = [
+ "bitflags 2.13.0",
+ "objc2",
+ "objc2-foundation",
+]
+
 [[package]]
 name = "objc2-core-foundation"
 version = "0.3.2"
@@ -11508,15 +11544,15 @@ dependencies = [
 
 [[package]]
 name = "webbrowser"
-version = "1.2.1"
+version = "1.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fc95580916af1e68ff6a7be07446fc5db73ebf71cf092de939bbf5f7e189f72"
+checksum = "62c35be770821a214dbc362fc26908c853e776c0004294d0b10b8a6bad582f94"
 dependencies = [
- "core-foundation 0.10.1",
  "jni 0.22.4",
  "log",
  "ndk-context",
  "objc2",
+ "objc2-app-kit",
  "objc2-foundation",
  "url",
  "web-sys",
diff --git a/Cargo.toml b/Cargo.toml
index 7705a27f22a..ed6fe20945d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,7 @@ members = [
     "crates/buzz-test-client",
     "crates/buzz-ws-client",
     "crates/buzz-admin",
+    "crates/buzz-deletion",
     "crates/buzz-workflow",
     "crates/buzz-media",
     "crates/buzz-paymaster",
@@ -136,6 +137,7 @@ schemars = { version = "1", default-features = false }
 buzz-core = { path = "crates/buzz-core" }
 buzz-conformance = { path = "crates/buzz-conformance" }
 buzz-db = { path = "crates/buzz-db" }
+buzz-deletion = { path = "crates/buzz-deletion" }
 buzz-auth = { path = "crates/buzz-auth" }
 buzz-pubsub = { path = "crates/buzz-pubsub" }
 buzz-search = { path = "crates/buzz-search" }
diff --git a/crates/buzz-acp/src/acp.rs b/crates/buzz-acp/src/acp.rs
index 8460372abab..f04b8eeec0d 100644
--- a/crates/buzz-acp/src/acp.rs
+++ b/crates/buzz-acp/src/acp.rs
@@ -14,7 +14,9 @@ use tokio::process::{Child, ChildStdin, ChildStdout};
 use tokio_util::codec::{FramedRead, LinesCodec, LinesCodecError};
 
 use crate::observer::{ObserverContext, ObserverHandle};
-use crate::usage::{TurnUsage, UsageTracker};
+use crate::usage::{
+    PromptResponseUsage, StandardAdapterKind, StandardUsageTracker, TurnUsage, UsageTracker,
+};
 
 /// Maximum allowed size of a single NDJSON line from the agent's stdout.
 /// Lines exceeding this limit are rejected to prevent OOM from rogue agents.
@@ -206,11 +208,12 @@ pub struct AcpClient {
     /// outside of a goose-native turn — the read loop's steer arm is
     /// disabled in that case.
     steer_rx: Option<tokio::sync::mpsc::Receiver<crate::pool::SteerRequest>>,
-    /// Usage tracker — accumulates cumulative token counts from
-    /// `_goose/unstable/session/update` notifications and computes per-turn
-    /// deltas. Both goose and buzz-agent emit this notification; goose gates
-    /// on client capability advertisement, buzz-agent emits unconditionally.
+    /// Usage tracker for goose/buzz-agent's cumulative notification format.
     goose_usage: UsageTracker,
+    /// Per-turn prompt-response usage and Claude's optional cumulative cost.
+    standard_usage: StandardUsageTracker,
+    /// Known adapter identity for prompt-response usage mapping.
+    standard_adapter: Option<StandardAdapterKind>,
 }
 
 /// Recursively merge `overlay` into `base`, with `overlay` winning on scalar/shape
@@ -523,6 +526,14 @@ impl AcpClient {
         // console-subsystem child process spawned from a GUI/non-console parent.
         configure_no_window(&mut cmd);
 
+        let standard_adapter =
+            match crate::config::normalize_agent_command_identity(command).as_str() {
+                "claude-agent-acp" | "claude-code-acp" | "claude-code" | "claudecode" => {
+                    Some(StandardAdapterKind::Claude)
+                }
+                "codex" | "codex-acp" => Some(StandardAdapterKind::Codex),
+                _ => None,
+            };
         let mut child = cmd.spawn()?;
 
         let stdin = child
@@ -550,6 +561,8 @@ impl AcpClient {
             steering_supported: false,
             steer_rx: None,
             goose_usage: UsageTracker::default(),
+            standard_usage: StandardUsageTracker::default(),
+            standard_adapter,
         })
     }
 
@@ -776,6 +789,7 @@ impl AcpClient {
         // prompt so that any setup notifications recorded earlier are not
         // misattributed to this turn.
         self.goose_usage.begin_turn(session_id);
+        self.standard_usage.begin_turn(session_id);
 
         self.last_prompt_id = Some(self.next_id);
         let id = self.next_id;
@@ -821,7 +835,7 @@ impl AcpClient {
                 self.current_hard_deadline = None;
             }
         }
-        self.parse_stop_reason(&result?)
+        self.parse_prompt_response(session_id, &result?)
     }
 
     /// Send a `session/cancel` **notification** (no `id` field, no response expected).
@@ -867,18 +881,13 @@ impl AcpClient {
         self.steering_supported
     }
 
-    /// Consume and return the per-turn usage record computed from the most
-    /// recent `_goose/unstable/session/update` notification.
-    ///
-    /// Returns `None` if no usage update arrived since the last call (i.e.
-    /// the harness did not emit one for this turn, or this is not a goose
-    /// agent). Must be called at most once per turn; subsequent calls return
-    /// `None` until the next `usage_update` notification is recorded.
-    ///
-    /// Intended for consumption by `publish_agent_turn_metric` in `pool.rs` to
-    /// publish a kind 44200 NIP-AM event.
+    /// Consume per-turn usage for NIP-AM publishing. Goose/buzz-agent is an
+    /// exclusive cumulative path; standard ACP prompt usage is used only when
+    /// goose emitted nothing for this turn.
     pub fn take_turn_usage(&mut self) -> Option<TurnUsage> {
-        self.goose_usage.take()
+        let goose_usage = self.goose_usage.take();
+        let standard_usage = self.standard_usage.take();
+        goose_usage.or(standard_usage)
     }
 
     /// Notify the usage tracker that buzz-acp just spawned a new session.
@@ -889,6 +898,7 @@ impl AcpClient {
     /// never when attaching to a pre-existing session.
     pub(crate) fn notify_session_spawned(&mut self, session_id: &str) {
         self.goose_usage.seed_zero_baseline(session_id);
+        self.standard_usage.seed_zero_baseline(session_id);
     }
 
     /// Install a per-turn steer request channel for goose-native
@@ -1048,7 +1058,7 @@ impl AcpClient {
                 remaining,
             )
             .await?;
-        self.parse_stop_reason(&result)
+        self.parse_prompt_response(session_id, &result)
     }
 
     /// Serialize `value` as a single NDJSON line and flush to the agent's stdin.
@@ -1831,6 +1841,10 @@ impl AcpClient {
                 }
                 false
             }
+            "usage_update" => {
+                self.handle_standard_usage_update(msg);
+                false
+            }
             "keepalive" => false,
             other => {
                 tracing::debug!(target: "acp::update", "session/update: {other}");
@@ -1839,6 +1853,30 @@ impl AcpClient {
         }
     }
 
+    /// Record the standard ACP cumulative cost notification when emitted by
+    /// Claude. Unlike Goose's payload, `used`/`size` are context occupancy and
+    /// are intentionally not mapped to token accounting.
+    fn handle_standard_usage_update(&mut self, msg: &serde_json::Value) {
+        if self.standard_adapter != Some(StandardAdapterKind::Claude) {
+            return;
+        }
+        let session_id = match msg
+            .pointer("/params/sessionId")
+            .and_then(serde_json::Value::as_str)
+        {
+            Some(session_id) => session_id,
+            None => return,
+        };
+        let cost = match msg
+            .pointer("/params/update/cost/amount")
+            .and_then(serde_json::Value::as_f64)
+        {
+            Some(cost) => cost,
+            None => return,
+        };
+        self.standard_usage.record_cost(session_id, cost);
+    }
+
     /// Parse a `_goose/unstable/session/update` notification and record the
     /// usage snapshot in the per-session tracker.
     ///
@@ -1970,6 +2008,28 @@ impl AcpClient {
         Ok(())
     }
 
+    /// Parse a completed prompt response and retain its optional per-turn usage.
+    fn parse_prompt_response(
+        &mut self,
+        session_id: &str,
+        result: &serde_json::Value,
+    ) -> Result<StopReason, AcpError> {
+        let stop_reason = self.parse_stop_reason(result)?;
+        if let Some(adapter) = self.standard_adapter {
+            match serde_json::from_value::<PromptResponseUsage>(result["usage"].clone()) {
+                Ok(usage) => self
+                    .standard_usage
+                    .record_prompt_usage(session_id, usage, adapter),
+                Err(_) if result.get("usage").is_some() => tracing::debug!(
+                    target: "acp::usage",
+                    "session/prompt response contained malformed standard usage"
+                ),
+                Err(_) => {}
+            }
+        }
+        Ok(stop_reason)
+    }
+
     /// Parse `stopReason` from a `session/prompt` result value.
     fn parse_stop_reason(&self, result: &serde_json::Value) -> Result<StopReason, AcpError> {
         let raw = result["stopReason"].as_str().ok_or_else(|| {
@@ -2899,6 +2959,30 @@ mod tests {
             .expect("failed to spawn test script")
     }
 
+    #[cfg(unix)]
+    async fn spawn_named_script(name: &str, script: &str) -> (AcpClient, std::path::PathBuf) {
+        use std::os::unix::fs::PermissionsExt;
+
+        let dir = std::env::temp_dir().join(format!(
+            "buzz-acp-{name}-{}-{}",
+            std::process::id(),
+            uuid::Uuid::new_v4()
+        ));
+        std::fs::create_dir_all(&dir).expect("create temp adapter dir");
+        let path = dir.join(name);
+        std::fs::write(&path, format!("#!/usr/bin/env bash\n{script}\n"))
+            .expect("write fake adapter");
+        let mut permissions = std::fs::metadata(&path)
+            .expect("adapter metadata")
+            .permissions();
+        permissions.set_mode(0o755);
+        std::fs::set_permissions(&path, permissions).expect("chmod fake adapter");
+        let client = AcpClient::spawn(path.to_str().expect("utf8 path"), &[], &[], false)
+            .await
+            .expect("spawn named fake adapter");
+        (client, dir)
+    }
+
     /// Spawn a probe script whose file name carries a runtime identity (e.g.
     /// `hermes-acp`) and return the value of `var` as the child observed it.
     /// `<unset>` means the child did not receive the var.
@@ -4275,6 +4359,254 @@ mod tests {
         }
     }
 
+    // ── Standard ACP prompt-response usage ─────────────────────────────────
+
+    fn prompt_response_usage(
+        input: u64,
+        output: u64,
+        total: u64,
+        cached_read: Option<u64>,
+        cached_write: Option<u64>,
+    ) -> serde_json::Value {
+        let mut usage = serde_json::json!({
+            "inputTokens": input,
+            "outputTokens": output,
+            "totalTokens": total,
+        });
+        if let Some(cached_read) = cached_read {
+            usage["cachedReadTokens"] = serde_json::json!(cached_read);
+        }
+        if let Some(cached_write) = cached_write {
+            usage["cachedWriteTokens"] = serde_json::json!(cached_write);
+        }
+        serde_json::json!({"stopReason": "end_turn", "usage": usage})
+    }
+
+    fn standard_cost_update(session_id: &str, cost: f64) -> serde_json::Value {
+        serde_json::json!({
+            "jsonrpc": "2.0",
+            "method": "session/update",
+            "params": {
+                "sessionId": session_id,
+                "update": {
+                    "sessionUpdate": "usage_update",
+                    "cost": {"amount": cost, "currency": "USD"}
+                }
+            }
+        })
+    }
+
+    #[tokio::test]
+    async fn claude_prompt_response_usage_merges_with_cumulative_cost() {
+        let mut client = spawn_inert_client().await;
+        client.standard_adapter = Some(StandardAdapterKind::Claude);
+        client.notify_session_spawned("claude-session");
+        client.standard_usage.begin_turn("claude-session");
+        client.handle_session_update(&standard_cost_update("claude-session", 0.042));
+        assert_eq!(
+            client
+                .parse_prompt_response(
+                    "claude-session",
+                    &prompt_response_usage(100, 20, 175, Some(30), Some(25)),
+                )
+                .unwrap(),
+            StopReason::EndTurn
+        );
+
+        let usage = client.take_turn_usage().expect("prompt usage");
+        assert!(usage.delta_reliable, "response tokens need no baseline");
+        assert_eq!(usage.turn_input_tokens, Some(155));
+        assert_eq!(usage.turn_output_tokens, Some(20));
+        assert_eq!(
+            usage.turn_total_tokens, None,
+            "Claude total is adapter-derived"
+        );
+        assert_eq!(usage.turn_cache_read_tokens, Some(30));
+        assert_eq!(usage.turn_cache_write_tokens, Some(25));
+        assert_eq!(usage.turn_cost_usd, Some(0.042));
+        assert_eq!(usage.cumulative_cost_usd, Some(0.042));
+        assert_eq!(usage.cumulative_input_tokens, None);
+        assert_eq!(usage.cumulative_output_tokens, None);
+    }
+
+    #[tokio::test]
+    async fn codex_prompt_response_usage_preserves_provider_total_without_cost() {
+        let mut client = spawn_inert_client().await;
+        client.standard_adapter = Some(StandardAdapterKind::Codex);
+        client.standard_usage.begin_turn("codex-session");
+        client.handle_session_update(&standard_cost_update("codex-session", 0.042));
+        client
+            .parse_prompt_response(
+                "codex-session",
+                &prompt_response_usage(90, 10, 140, Some(40), None),
+            )
+            .unwrap();
+
+        let usage = client.take_turn_usage().expect("prompt usage");
+        assert!(usage.delta_reliable);
+        assert_eq!(usage.turn_input_tokens, Some(130));
+        assert_eq!(usage.turn_output_tokens, Some(10));
+        assert_eq!(usage.turn_total_tokens, Some(140));
+        assert_eq!(usage.turn_cache_read_tokens, Some(40));
+        assert_eq!(usage.turn_cache_write_tokens, None);
+        assert_eq!(
+            usage.cumulative_cost_usd, None,
+            "Codex cost update is ignored"
+        );
+        assert_eq!(usage.cumulative_input_tokens, None);
+        assert_eq!(usage.cumulative_output_tokens, None);
+    }
+
+    #[tokio::test]
+    async fn standard_prompt_input_overflow_fails_closed() {
+        let mut client = spawn_inert_client().await;
+        client.standard_adapter = Some(StandardAdapterKind::Claude);
+        client.standard_usage.begin_turn("overflow-session");
+        client
+            .parse_prompt_response(
+                "overflow-session",
+                &prompt_response_usage(u64::MAX, 10, u64::MAX, Some(1), None),
+            )
+            .unwrap();
+
+        assert!(
+            client.take_turn_usage().is_none(),
+            "overflow without another valid signal must not emit all-null usage"
+        );
+    }
+
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn claude_named_adapter_wire_lifecycle_records_prompt_and_cost() {
+        let script = r#"
+            read -r REQ
+            ID=$(printf '%s' "$REQ" | sed -E 's/.*"id":([0-9]+).*/\1/')
+            echo '{"jsonrpc":"2.0","method":"session/update","params":{"sessionId":"wire-session","update":{"sessionUpdate":"usage_update","cost":{"amount":0.5,"currency":"USD"}}}}'
+            echo '{"jsonrpc":"2.0","id":'"$ID"',"result":{"stopReason":"end_turn","usage":{"inputTokens":7,"outputTokens":3,"totalTokens":10,"cachedReadTokens":2}}}'
+            sleep 1
+        "#;
+        let (mut client, dir) = spawn_named_script("claude-code", script).await;
+        assert_eq!(client.standard_adapter, Some(StandardAdapterKind::Claude));
+        client.notify_session_spawned("wire-session");
+
+        let stop = client
+            .session_prompt_with_idle_timeout(
+                "wire-session",
+                "hello",
+                std::time::Duration::from_secs(2),
+                std::time::Duration::from_secs(5),
+            )
+            .await
+            .expect("wire prompt");
+        assert_eq!(stop, StopReason::EndTurn);
+
+        let usage = client.take_turn_usage().expect("wire usage");
+        assert_eq!(usage.turn_seq, 1);
+        assert_eq!(usage.turn_input_tokens, Some(9));
+        assert_eq!(usage.turn_output_tokens, Some(3));
+        assert_eq!(usage.turn_cost_usd, Some(0.5));
+        assert_eq!(usage.cumulative_cost_usd, Some(0.5));
+        drop(client);
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn claude_cost_only_record_survives_missing_prompt_usage() {
+        let mut client = spawn_inert_client().await;
+        client.standard_adapter = Some(StandardAdapterKind::Claude);
+        client.notify_session_spawned("cost-only-session");
+        client.standard_usage.begin_turn("cost-only-session");
+        client.handle_session_update(&standard_cost_update("cost-only-session", 0.125));
+
+        let usage = client.take_turn_usage().expect("cost-only usage");
+        assert_eq!(usage.turn_seq, 1);
+        assert!(usage.delta_reliable);
+        assert_eq!(usage.turn_input_tokens, None);
+        assert_eq!(usage.turn_cost_usd, Some(0.125));
+        assert_eq!(usage.cumulative_cost_usd, Some(0.125));
+    }
+
+    #[tokio::test]
+    async fn attached_claude_session_does_not_invent_first_cost_delta() {
+        let mut client = spawn_inert_client().await;
+        client.standard_adapter = Some(StandardAdapterKind::Claude);
+        client.standard_usage.begin_turn("attached-session");
+        client.handle_session_update(&standard_cost_update("attached-session", 1.25));
+        client
+            .parse_prompt_response(
+                "attached-session",
+                &prompt_response_usage(10, 2, 12, None, None),
+            )
+            .unwrap();
+
+        let usage = client.take_turn_usage().expect("attached usage");
+        assert_eq!(usage.turn_cost_usd, None);
+        assert_eq!(usage.cumulative_cost_usd, Some(1.25));
+    }
+
+    #[tokio::test]
+    async fn standard_usage_two_prompts_preserve_both_monotonic_sequences() {
+        let mut client = spawn_inert_client().await;
+        client.standard_adapter = Some(StandardAdapterKind::Claude);
+        client.notify_session_spawned("two-prompt-session");
+
+        client.standard_usage.begin_turn("two-prompt-session");
+        client.handle_session_update(&standard_cost_update("two-prompt-session", 0.1));
+        client
+            .parse_prompt_response(
+                "two-prompt-session",
+                &prompt_response_usage(10, 2, 12, None, None),
+            )
+            .unwrap();
+        let initial = client.take_turn_usage().expect("initial prompt usage");
+
+        client.standard_usage.begin_turn("two-prompt-session");
+        client.handle_session_update(&standard_cost_update("two-prompt-session", 0.25));
+        client
+            .parse_prompt_response(
+                "two-prompt-session",
+                &prompt_response_usage(20, 3, 23, None, None),
+            )
+            .unwrap();
+        let user = client.take_turn_usage().expect("user prompt usage");
+
+        assert_eq!((initial.turn_seq, user.turn_seq), (1, 2));
+        assert_eq!(
+            (initial.turn_input_tokens, user.turn_input_tokens),
+            (Some(10), Some(20))
+        );
+        assert_eq!(
+            (initial.turn_cost_usd, user.turn_cost_usd),
+            (Some(0.1), Some(0.15))
+        );
+    }
+
+    #[tokio::test]
+    async fn goose_usage_stays_exclusive_and_drains_standard_usage() {
+        let mut client = spawn_inert_client().await;
+        client.standard_adapter = Some(StandardAdapterKind::Claude);
+        client.goose_usage.begin_turn("goose-session");
+        client.standard_usage.begin_turn("goose-session");
+        client.handle_goose_usage_update(&goose_usage_update_msg("goose-session", 1000, 200, None));
+        client
+            .parse_prompt_response(
+                "goose-session",
+                &prompt_response_usage(100, 20, 120, None, None),
+            )
+            .unwrap();
+
+        let usage = client.take_turn_usage().expect("goose usage");
+        assert_eq!(usage.cumulative_input_tokens, Some(1000));
+        assert_eq!(
+            usage.turn_input_tokens, None,
+            "goose first delta remains exclusive"
+        );
+        assert!(
+            client.take_turn_usage().is_none(),
+            "standard usage was drained"
+        );
+    }
+
     // ── Goose usage notification integration ──────────────────────────────
 
     /// Build a `_goose/unstable/session/update` JSON-RPC notification.
diff --git a/crates/buzz-acp/src/config.rs b/crates/buzz-acp/src/config.rs
index 35aaec188db..f9e7bf1ed8a 100644
--- a/crates/buzz-acp/src/config.rs
+++ b/crates/buzz-acp/src/config.rs
@@ -482,6 +482,13 @@ pub struct CliArgs {
     /// Connect and subscribe before starting the ACP/LLM subprocess pool.
     #[arg(long, env = "BUZZ_ACP_LAZY_POOL", default_value_t = false)]
     pub lazy_pool: bool,
+
+    /// Tear the woken pool back down to the lazy empty-slot state after this
+    /// many seconds with no dispatched turn in flight and an empty queue,
+    /// releasing worker subprocesses until the next accepted event re-wakes.
+    /// Requires `--lazy-pool`; ignored otherwise. 0 disables idle re-sleep.
+    #[arg(long, env = "BUZZ_ACP_IDLE_POOL_SLEEP", default_value_t = 0)]
+    pub idle_pool_sleep: u64,
 }
 
 /// Merged NIP-01 subscription filter for a single channel.
@@ -559,6 +566,10 @@ pub struct Config {
     pub exit_after_inactivity_secs: u64,
     /// Whether ACP/LLM subprocess initialization is deferred until accepted work arrives.
     pub lazy_pool: bool,
+    /// Seconds with no dispatched turn in flight and an empty queue before a
+    /// woken lazy pool is torn back down to the empty-slot state. 0 = disabled.
+    /// Only meaningful when `lazy_pool` is true.
+    pub idle_pool_sleep_secs: u64,
     /// Agent owner pubkey (hex). Used for `--respond-to=owner-only` gate.
     /// Replaces the old REST-based owner lookup.
     pub agent_owner: Option<String>,
@@ -1107,6 +1118,7 @@ impl Config {
             relay_observer: args.relay_observer,
             exit_after_inactivity_secs: args.exit_after_inactivity,
             lazy_pool: args.lazy_pool,
+            idle_pool_sleep_secs: args.idle_pool_sleep,
             agent_owner: args.agent_owner.map(|s| s.trim().to_ascii_lowercase()),
             no_base_prompt: args.no_base_prompt,
             base_prompt_content,
@@ -1478,6 +1490,7 @@ mod tests {
             relay_observer: false,
             exit_after_inactivity_secs: 0,
             lazy_pool: false,
+            idle_pool_sleep_secs: 0,
             agent_owner: None,
             no_base_prompt: false,
             base_prompt_content: None,
@@ -2198,6 +2211,22 @@ channels = "ALL"
         assert!(!CliArgs::parse_from(["buzz-acp", "--private-key", &key]).lazy_pool);
     }
 
+    #[test]
+    fn idle_pool_sleep_defaults_disabled_and_accepts_cli_value() {
+        let key = "0".repeat(64);
+        let default = CliArgs::parse_from(["buzz-acp", "--private-key", &key]);
+        assert_eq!(default.idle_pool_sleep, 0);
+
+        let configured = CliArgs::parse_from([
+            "buzz-acp",
+            "--private-key",
+            &key,
+            "--idle-pool-sleep",
+            "300",
+        ]);
+        assert_eq!(configured.idle_pool_sleep, 300);
+    }
+
     #[test]
     fn lazy_pool_cli_flag_enables_deferred_startup() {
         let key = "0".repeat(64);
diff --git a/crates/buzz-acp/src/lib.rs b/crates/buzz-acp/src/lib.rs
index fa348eeb3cf..27b9000b7bb 100644
--- a/crates/buzz-acp/src/lib.rs
+++ b/crates/buzz-acp/src/lib.rs
@@ -1468,6 +1468,33 @@ fn inactivity_expired(
     !bound.is_zero() && !turn_in_flight && now.duration_since(last_activity) >= bound
 }
 
+/// Whether a woken lazy pool may be torn back down to the empty-slot state.
+///
+/// True only when the pool is ready, the idle bound has elapsed with no
+/// dispatched turn or heartbeat in flight and no in-flight prompt tasks, no
+/// work is queued, and no wake/respawn task is running. The queue and task
+/// gates make teardown race-safe with enqueue/wake: an event that landed in
+/// the queue (or a wake/respawn already in flight) blocks this decision, so a
+/// queued batch is never stranded — the caller's next loop iteration will
+/// dispatch or wake it instead.
+#[allow(clippy::too_many_arguments)]
+fn idle_pool_sleep_due(
+    pool_ready: bool,
+    last_activity: tokio::time::Instant,
+    now: tokio::time::Instant,
+    bound: Duration,
+    turn_in_flight: bool,
+    prompt_tasks_in_flight: bool,
+    work_queued: bool,
+    wake_or_respawn_in_flight: bool,
+) -> bool {
+    pool_ready
+        && !work_queued
+        && !prompt_tasks_in_flight
+        && !wake_or_respawn_in_flight
+        && inactivity_expired(last_activity, now, bound, turn_in_flight)
+}
+
 #[cfg(test)]
 mod inactivity_tests {
     use super::*;
@@ -1512,6 +1539,179 @@ mod inactivity_tests {
     }
 }
 
+#[cfg(test)]
+mod idle_pool_sleep_tests {
+    use super::*;
+
+    // The all-clear baseline: pool ready, bound elapsed, nothing busy or
+    // queued. Every negative case below flips exactly one gate off this.
+    fn ready_after_bound() -> (tokio::time::Instant, tokio::time::Instant, Duration) {
+        let started = tokio::time::Instant::now();
+        (
+            started,
+            started + Duration::from_secs(61),
+            Duration::from_secs(60),
+        )
+    }
+
+    #[test]
+    fn sleeps_when_ready_idle_and_quiet() {
+        let (last, now, bound) = ready_after_bound();
+        assert!(idle_pool_sleep_due(
+            true, last, now, bound, false, false, false, false
+        ));
+    }
+
+    #[test]
+    fn zero_bound_never_sleeps() {
+        let (last, now, _) = ready_after_bound();
+        assert!(!idle_pool_sleep_due(
+            true,
+            last,
+            now,
+            Duration::ZERO,
+            false,
+            false,
+            false,
+            false
+        ));
+    }
+
+    #[test]
+    fn not_ready_never_sleeps() {
+        // A still-sleeping (or waking) pool must not "re-sleep".
+        let (last, now, bound) = ready_after_bound();
+        assert!(!idle_pool_sleep_due(
+            false, last, now, bound, false, false, false, false
+        ));
+    }
+
+    #[test]
+    fn active_turn_defers_sleep() {
+        let (last, now, bound) = ready_after_bound();
+        assert!(!idle_pool_sleep_due(
+            true, last, now, bound, true, false, false, false
+        ));
+    }
+
+    #[test]
+    fn in_flight_prompt_task_defers_sleep() {
+        let (last, now, bound) = ready_after_bound();
+        assert!(!idle_pool_sleep_due(
+            true, last, now, bound, false, true, false, false
+        ));
+    }
+
+    #[test]
+    fn queued_work_at_boundary_defers_sleep() {
+        // Enqueue-at-teardown protection: a batch sitting in the queue blocks
+        // teardown so it is never stranded — the loop dispatches it instead.
+        let (last, now, bound) = ready_after_bound();
+        assert!(!idle_pool_sleep_due(
+            true, last, now, bound, false, false, true, false
+        ));
+    }
+
+    #[test]
+    fn wake_or_respawn_in_flight_defers_sleep() {
+        let (last, now, bound) = ready_after_bound();
+        assert!(!idle_pool_sleep_due(
+            true, last, now, bound, false, false, false, true
+        ));
+    }
+
+    #[test]
+    fn recent_activity_defers_sleep() {
+        // Activity 50s ago under a 60s bound: not yet idle.
+        let started = tokio::time::Instant::now();
+        let recent = started + Duration::from_secs(50);
+        let now = started + Duration::from_secs(59);
+        assert!(!idle_pool_sleep_due(
+            true,
+            recent,
+            now,
+            Duration::from_secs(60),
+            false,
+            false,
+            false,
+            false
+        ));
+    }
+
+    fn slot(respawn_in_flight: bool) -> SlotCircuit {
+        SlotCircuit {
+            crash_times: Vec::new(),
+            open_until: None,
+            respawn_in_flight,
+        }
+    }
+
+    // The call-site signal for the `wake_or_respawn_in_flight` gate is
+    // `any_respawn_in_flight(&crash_history)`, NOT `!respawn_tasks.is_empty()`.
+    // Regression for the PR #5682 review blocker: completed respawn tasks are
+    // never joined from the `respawn_tasks` JoinSet (their payloads arrive
+    // out-of-band via `respawn_rx`), so `!is_empty()` stays true forever after
+    // the first refill/crash recovery and the pool could never re-sleep. The
+    // authoritative signal clears per-slot when the payload is received.
+    #[test]
+    fn respawn_in_flight_signal_gates_then_clears_for_sleep() {
+        let (last, now, bound) = ready_after_bound();
+
+        // A respawn in flight for any slot defers sleep.
+        let busy = [slot(false), slot(true), slot(false)];
+        assert!(any_respawn_in_flight(&busy));
+        assert!(!idle_pool_sleep_due(
+            true,
+            last,
+            now,
+            bound,
+            false,
+            false,
+            false,
+            any_respawn_in_flight(&busy),
+        ));
+
+        // Once the respawn completes (payload received → flag cleared), the
+        // signal goes false and the otherwise-quiet pool becomes sleep-eligible
+        // — even though a naive `!JoinSet.is_empty()` would still be stuck true.
+        let quiet = [slot(false), slot(false), slot(false)];
+        assert!(!any_respawn_in_flight(&quiet));
+        assert!(idle_pool_sleep_due(
+            true,
+            last,
+            now,
+            bound,
+            false,
+            false,
+            false,
+            any_respawn_in_flight(&quiet),
+        ));
+    }
+
+    // The reaper (`respawn_tasks.join_next().now_or_never()` loop) must drain
+    // completed handles so the JoinSet does not grow without bound and so
+    // `!respawn_tasks.is_empty()` cannot become a permanent busy bit if anyone
+    // ever reintroduces it as the gate signal.
+    #[tokio::test]
+    async fn completed_respawn_tasks_are_reaped_from_the_joinset() {
+        let mut respawn_tasks: tokio::task::JoinSet<()> = tokio::task::JoinSet::new();
+        respawn_tasks.spawn(async {});
+        respawn_tasks.spawn(async {});
+        // Let both tasks run to completion.
+        tokio::task::yield_now().await;
+        tokio::time::sleep(Duration::from_millis(10)).await;
+
+        // The reaper drains finished handles non-blockingly.
+        while respawn_tasks.join_next().now_or_never().flatten().is_some() {}
+
+        assert!(
+            respawn_tasks.is_empty(),
+            "completed respawn tasks must be reaped so the set does not wedge \
+             the idle-sleep gate or grow unbounded"
+        );
+    }
+}
+
 pub fn run() -> Result<()> {
     config::propagate_legacy_env_vars();
     tokio_main()
@@ -1900,6 +2100,27 @@ async fn tokio_main() -> Result<()> {
         ))
     };
 
+    // Idle pool re-sleep: tear a woken lazy pool back down to the empty-slot
+    // state after `idle_pool_sleep_bound` of quiet, releasing worker
+    // subprocesses. The next accepted event re-wakes it through the same lazy
+    // path. Only meaningful under `lazy_pool`; the tick arm additionally gates
+    // on `pool_ready`, so a still-sleeping pool never re-sleeps. Reuses the
+    // `last_activity` clock the dispatch path already maintains.
+    let idle_pool_sleep_bound = if config.lazy_pool {
+        Duration::from_secs(config.idle_pool_sleep_secs)
+    } else {
+        Duration::ZERO
+    };
+    let mut idle_pool_sleep_reaper = if idle_pool_sleep_bound.is_zero() {
+        None
+    } else {
+        let interval = idle_pool_sleep_bound.min(Duration::from_secs(30));
+        Some(tokio::time::interval_at(
+            tokio::time::Instant::now() + interval,
+            interval,
+        ))
+    };
+
     // Runs at the TOP of every loop iteration via Instant check — cannot be
     // starved by the biased select. Slot refill spawns background tasks so
     // spawn_and_init never blocks the main loop.
@@ -2107,6 +2328,17 @@ async fn tokio_main() -> Result<()> {
                 }
             }
         }
+        // Reap completed respawn handles from the JoinSet. Payloads are
+        // delivered out-of-band through `respawn_rx` (drained above), so the
+        // JoinSet is never joined by the normal flow — Tokio retains finished
+        // tasks until `join_next`, so without this the set grows on every
+        // refill/crash recovery and `!respawn_tasks.is_empty()` would stay true
+        // forever. Non-blocking (`now_or_never`), same pattern as
+        // `drain_ready_join_results` for `pool.join_set`. The authoritative
+        // in-flight signal is `any_respawn_in_flight(&crash_history)` (each
+        // slot's `respawn_in_flight` is cleared when its payload is received),
+        // not JoinSet occupancy.
+        while respawn_tasks.join_next().now_or_never().flatten().is_some() {}
         // Flush requeued events that were waiting for a live agent. Without
         // this, batches requeued during crash recovery sit idle until the
         // next relay event arrives — which can be minutes on quiet channels.
@@ -2599,6 +2831,56 @@ async fn tokio_main() -> Result<()> {
                     }
                     None
                 }
+                _ = async {
+                    match idle_pool_sleep_reaper.as_mut() {
+                        Some(timer) => timer.tick().await,
+                        None => std::future::pending().await,
+                    }
+                } => {
+                    let _ = result_rx; // end split borrow before touching pool
+                    // A wake in flight (pool not yet ready) is covered by the
+                    // pool_ready gate; respawn tasks and in-flight prompt tasks
+                    // are the remaining "busy" signals. Never sleep mid-work:
+                    // `has_undispatched_work()` (not `has_flushable_work()`)
+                    // keeps `work_queued` true for a retry-throttled batch too,
+                    // so a failed turn awaiting backoff is never stranded — the
+                    // next iteration dispatches or re-wakes it.
+                    if idle_pool_sleep_due(
+                        pool_ready,
+                        last_activity,
+                        tokio::time::Instant::now(),
+                        idle_pool_sleep_bound,
+                        queue.has_in_flight() || heartbeat_in_flight,
+                        !pool.join_set.is_empty(),
+                        queue.has_undispatched_work(),
+                        !wake_tasks.is_empty()
+                            || any_respawn_in_flight(&crash_history),
+                    ) {
+                        tracing::info!(
+                            idle_pool_sleep_seconds = config.idle_pool_sleep_secs,
+                            "idle pool sleep bound reached — tearing pool back to lazy state"
+                        );
+                        shutdown_agent_pool(&mut pool).await;
+                        // Return to the exact pre-wake lazy state: empty slots,
+                        // Listening lifecycle. The top-of-loop wake path re-wakes
+                        // on the next accepted event. No second lifecycle.
+                        pool = AgentPool::from_slots(
+                            (0..config.agents).map(|_| None).collect(),
+                        );
+                        pool_ready = false;
+                        pool_lifecycle = PoolLifecycle::listening();
+                        last_activity = tokio::time::Instant::now();
+                        emit_runtime_lifecycle(
+                            observer.as_ref(),
+                            &runtime_start_nonce,
+                            &pubkey_hex,
+                            &config.relay_url,
+                            "listening",
+                            None,
+                        );
+                    }
+                    None
+                }
                 _ = async {
                     match heartbeat.as_mut() {
                         Some(hb) => hb.tick().await,
@@ -5031,6 +5313,7 @@ mod author_gate_tests {
                 relay::ChannelInfo {
                     name: "dm".into(),
                     channel_type: "dm".into(),
+                    description: None,
                 },
             ),
             (
@@ -5038,6 +5321,7 @@ mod author_gate_tests {
                 relay::ChannelInfo {
                     name: "stream".into(),
                     channel_type: "stream".into(),
+                    description: None,
                 },
             ),
         ]);
@@ -5054,6 +5338,7 @@ mod author_gate_tests {
             relay::ChannelInfo {
                 name: "unknown".into(),
                 channel_type: "unknown".into(),
+                description: None,
             },
         )]);
         assert!(
@@ -6249,6 +6534,7 @@ mod build_mcp_servers_tests {
             relay_observer: false,
             exit_after_inactivity_secs: 0,
             lazy_pool: false,
+            idle_pool_sleep_secs: 0,
             agent_owner: None,
             no_base_prompt: false,
             base_prompt_content: None,
@@ -6471,6 +6757,7 @@ mod error_outcome_emission_tests {
             relay_observer: false,
             exit_after_inactivity_secs: 0,
             lazy_pool: false,
+            idle_pool_sleep_secs: 0,
             agent_owner: None,
             no_base_prompt: false,
             base_prompt_content: None,
diff --git a/crates/buzz-acp/src/pool.rs b/crates/buzz-acp/src/pool.rs
index 33bd5507fb3..e38fa9b83e4 100644
--- a/crates/buzz-acp/src/pool.rs
+++ b/crates/buzz-acp/src/pool.rs
@@ -524,6 +524,7 @@ impl ChannelInfoResolver {
                     PromptChannelInfo {
                         name: info.name,
                         channel_type: info.channel_type,
+                        description: info.description,
                     },
                 ))
             })
@@ -1849,6 +1850,16 @@ pub async fn run_prompt_task(
                     if !agent.has_system_prompt_support() {
                         agent.state.mark_channel_delivery_success(*cid, true, []);
                     }
+                    let usage = agent.acp.take_turn_usage();
+                    publish_agent_turn_metric(
+                        &ctx,
+                        usage,
+                        Some(*cid),
+                        &session_id,
+                        &format!("{turn_id}:initial"),
+                        Some(acp_stop_to_core(&stop_reason)),
+                    )
+                    .await;
                 }
                 Err(AcpError::AgentExited) => {
                     agent.state.invalidate_all();
@@ -1873,7 +1884,17 @@ pub async fn run_prompt_task(
                         .cancel_with_cleanup(&session_id, ctx.idle_timeout)
                         .await
                     {
-                        Ok(_) => {
+                        Ok(stop_reason) => {
+                            let usage = agent.acp.take_turn_usage();
+                            publish_agent_turn_metric(
+                                &ctx,
+                                usage,
+                                Some(*cid),
+                                &session_id,
+                                &format!("{turn_id}:initial"),
+                                Some(acp_stop_to_core(&stop_reason)),
+                            )
+                            .await;
                             agent.state.invalidate(&source);
                         }
                         Err(AcpError::AgentExited) => {
@@ -2577,17 +2598,25 @@ pub(crate) async fn fetch_channel_info(
                 let ev = events.first()?;
                 let tags = ev.get("tags")?.as_array()?;
                 let mut name = None;
+                let mut description = None;
                 for tag in tags {
                     if let Some(arr) = tag.as_array() {
-                        if arr.first().and_then(|v| v.as_str()) == Some("name") {
-                            name = arr.get(1).and_then(|v| v.as_str());
+                        match arr.first().and_then(|v| v.as_str()) {
+                            Some("name") => name = arr.get(1).and_then(|v| v.as_str()),
+                            Some("about") => description = arr.get(1).and_then(|v| v.as_str()),
+                            _ => {}
                         }
                     }
                 }
                 let channel_type = crate::relay::channel_type_from_tags(tags);
+                let description = description
+                    .map(|s| s.trim())
+                    .filter(|s| !s.is_empty())
+                    .map(str::to_string);
                 Some(PromptChannelInfo {
                     name: name.unwrap_or(UNKNOWN_CHANNEL_NAME).to_string(),
                     channel_type,
+                    description,
                 })
             }
             Ok(Err(e)) => {
@@ -5803,6 +5832,7 @@ done"#
                 crate::relay::ChannelInfo {
                     name: "test-dm".into(),
                     channel_type: "dm".into(),
+                    description: None,
                 },
             )]),
             RestClient {
@@ -5964,6 +5994,7 @@ printf '%s\n' '{{"jsonrpc":"2.0","id":0,"result":{{"stopReason":"end_turn"}}}}'"
                 crate::relay::ChannelInfo {
                     name: "test-dm".into(),
                     channel_type: "dm".into(),
+                    description: None,
                 },
             )]),
             RestClient {
@@ -7855,6 +7886,38 @@ printf '%s\n' '{{"jsonrpc":"2.0","id":0,"result":{{"stopReason":"end_turn"}}}}'"
         server.abort();
     }
 
+    /// A channel's `about` tag is parsed through the lazy-fetch path and
+    /// delivered as the resolved description.
+    #[tokio::test]
+    async fn test_channel_resolver_delivers_description() {
+        let id = Uuid::new_v4();
+        let response = channel_metadata_response(
+            id,
+            &[
+                ["name", "team-chat"],
+                ["t", "stream"],
+                ["about", "Engineering discussions"],
+            ],
+        );
+        let (resolver, _requests, server) = counting_resolver(response).await;
+
+        let info = resolver.resolve(id).await.expect("should resolve");
+        assert_eq!(info.description.as_deref(), Some("Engineering discussions"));
+        server.abort();
+    }
+
+    /// A metadata event with no `about` tag yields no description.
+    #[tokio::test]
+    async fn test_channel_resolver_absent_description_when_no_about_tag() {
+        let id = Uuid::new_v4();
+        let response = channel_metadata_response(id, &[["name", "buzz-dev"], ["t", "stream"]]);
+        let (resolver, _requests, server) = counting_resolver(response).await;
+
+        let info = resolver.resolve(id).await.expect("should resolve");
+        assert_eq!(info.description, None);
+        server.abort();
+    }
+
     /// A DM carries no useful name, so it gets the bare agent title (and no
     /// canvas section).
     #[tokio::test]
diff --git a/crates/buzz-acp/src/queue.rs b/crates/buzz-acp/src/queue.rs
index 3bf19622429..dabee13afd5 100644
--- a/crates/buzz-acp/src/queue.rs
+++ b/crates/buzz-acp/src/queue.rs
@@ -590,6 +590,39 @@ impl EventQueue {
             .any(|id| !self.in_flight_channels.contains(id))
     }
 
+    /// Returns `true` if any undispatched work remains for a channel that is
+    /// NOT currently in-flight — *including* work held back only by a
+    /// `retry_after` backoff throttle.
+    ///
+    /// This is deliberately broader than [`has_flushable_work`](Self::has_flushable_work):
+    /// that method excludes `retry_after`-throttled channels because they are
+    /// not flushable *right now*, but the events are still queued and MUST be
+    /// delivered once the backoff deadline passes. Idle-pool-sleep teardown
+    /// must gate on this, not on flushability — a failed turn requeued with a
+    /// future backoff deadline is real queued work, and sleeping on it (while
+    /// the maintenance timer is disabled and lazy re-wake is itself gated by
+    /// flushability) would strand the batch until unrelated traffic arrives.
+    ///
+    /// Covers the three tables where undispatched, non-in-flight work can
+    /// live: non-empty `queues` (throttled or not), pending `cancelled_batches`,
+    /// and `withheld_native_steer` events. Read-only (no in-flight expiry) —
+    /// in-flight liveness is gated separately by [`has_in_flight`](Self::has_in_flight).
+    pub fn has_undispatched_work(&self) -> bool {
+        let has_queued = self
+            .queues
+            .iter()
+            .any(|(id, q)| !q.is_empty() && !self.in_flight_channels.contains(id));
+        let has_cancelled = self
+            .cancelled_batches
+            .keys()
+            .any(|id| !self.in_flight_channels.contains(id));
+        let has_withheld = self
+            .withheld_native_steer
+            .iter()
+            .any(|(id, v)| !v.is_empty() && !self.in_flight_channels.contains(id));
+        has_queued || has_cancelled || has_withheld
+    }
+
     /// Number of channels with pending events.
     pub fn pending_channels(&self) -> usize {
         self.queues.len()
@@ -1003,6 +1036,8 @@ pub struct ContextMessage {
 pub struct PromptChannelInfo {
     pub name: String,
     pub channel_type: String,
+    /// Channel description from the kind-39000 `about` tag, if present.
+    pub description: Option<String>,
 }
 
 /// Minimal profile fields needed to label users in ACP prompts.
@@ -1231,6 +1266,48 @@ fn resolve_reply_anchor(
     )
 }
 
+/// Maximum length (in characters) of a channel description rendered into `[Context]`.
+///
+/// Limits prompt bloat from unusually long descriptions; a raw embedded newline
+/// in a description must not be able to spoof another `[Context]` field, so
+/// multiline text is collapsed to single-space-joined lines before truncation.
+const MAX_DESCRIPTION_LEN: usize = 500;
+
+/// Append a `Description: …` line to a `[Context]` block when non-empty.
+///
+/// Collapses internal newlines (any `\r\n`, `\r`, or `\n`) to a single space
+/// so a multi-line description cannot inject a fake `[Context]` field line.
+/// Truncates at [`MAX_DESCRIPTION_LEN`] characters with a `…` marker.
+fn append_channel_description(s: &mut String, channel_info: Option<&PromptChannelInfo>) {
+    let desc = match channel_info.and_then(|ci| ci.description.as_deref()) {
+        Some(d) if !d.is_empty() => d,
+        _ => return,
+    };
+    // Collapse newlines to spaces so the description can never spoof another field.
+    let collapsed: String = desc
+        .split(['\n', '\r'])
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .collect::<Vec<_>>()
+        .join(" ");
+    if collapsed.is_empty() {
+        return;
+    }
+    // Truncate at a character boundary (not byte boundary) to avoid splitting
+    // multi-byte sequences.
+    let truncated = if collapsed.chars().count() > MAX_DESCRIPTION_LEN {
+        let end = collapsed
+            .char_indices()
+            .nth(MAX_DESCRIPTION_LEN)
+            .map(|(i, _)| i)
+            .unwrap_or(collapsed.len());
+        format!("{}…", &collapsed[..end])
+    } else {
+        collapsed
+    };
+    s.push_str(&format!("\nDescription: {truncated}"));
+}
+
 /// Format a `[Context]` hints section based on event scope.
 ///
 /// `reply_anchor` is the pre-resolved `--reply-to` target for this turn (see
@@ -1301,9 +1378,10 @@ fn format_context_hints(
         let mut s = format!(
             "[Context]\n\
              Scope: thread\n\
-             Channel: {channel_display}\n\
-             Thread root: {root}"
+             Channel: {channel_display}"
         );
+        append_channel_description(&mut s, channel_info);
+        s.push_str(&format!("\nThread root: {root}"));
         if let Some(ref parent) = thread_tags.parent_event_id {
             if parent != root {
                 s.push_str(&format!("\nParent: {parent}"));
@@ -1318,8 +1396,11 @@ fn format_context_hints(
         let mut s = format!(
             "[Context]\n\
              Scope: channel\n\
-             Channel: {channel_display}\n\
-             Hint: Use `buzz messages get --channel <UUID>` for recent messages if needed."
+             Channel: {channel_display}"
+        );
+        append_channel_description(&mut s, channel_info);
+        s.push_str(
+            "\nHint: Use `buzz messages get --channel <UUID>` for recent messages if needed.",
         );
         if let Some(event_id) = reply_anchor {
             append_new_thread_reply_instruction(&mut s, event_id);
@@ -2202,6 +2283,85 @@ mod tests {
         assert_eq!(batch2.events[1].event.content, "msg2");
     }
 
+    // ── Retry-throttled work must block idle-pool-sleep teardown ────────────
+    //
+    // Regression for the PR #5682 review blocker: a failed turn requeued with a
+    // future backoff deadline is real queued work. `has_flushable_work()`
+    // returns false for it (throttled → not flushable *now*), so gating
+    // idle-pool-sleep on flushability would tear down the pool while the batch
+    // sits waiting — and because lazy re-wake is itself gated on flushability
+    // and the maintenance timer is disabled while sleeping, the batch would be
+    // stranded until unrelated traffic arrived. `has_undispatched_work()` must
+    // see the throttled batch so the sleep gate keeps the pool alive.
+    #[test]
+    fn test_retry_throttled_batch_is_undispatched_but_not_flushable() {
+        let mut queue = EventQueue::new(DedupMode::Queue);
+        let ch = Uuid::new_v4();
+        queue.push(make_queued(ch, "msg1"));
+        queue.push(make_queued(ch, "msg2"));
+
+        // Drive a real failure → requeue-with-backoff → mark_complete cycle.
+        let batch = queue.flush_next().unwrap();
+        assert_eq!(batch.events.len(), 2);
+        assert!(
+            queue.requeue(batch).is_none(),
+            "batch requeued, not dead-lettered"
+        );
+        queue.mark_complete(ch);
+
+        // The batch is back in the queue, no longer in-flight, and throttled by
+        // a future `retry_after`. BASE_RETRY_DELAY guarantees the deadline is in
+        // the future, so this is not timing-fragile.
+        assert!(
+            queue
+                .retry_after
+                .get(&ch)
+                .is_some_and(|&t| t > Instant::now()),
+            "requeue must have set a future backoff deadline"
+        );
+        assert!(!queue.has_in_flight(), "turn completed, nothing in-flight");
+
+        // The bug: throttled work is invisible to flushability...
+        assert!(
+            !queue.has_flushable_work(),
+            "throttled batch must NOT be flushable yet"
+        );
+        // ...but it IS undispatched work the sleep gate must protect.
+        assert!(
+            queue.has_undispatched_work(),
+            "retry-throttled batch MUST count as undispatched work"
+        );
+    }
+
+    #[test]
+    fn test_has_undispatched_work_false_when_truly_empty_or_in_flight() {
+        let mut queue = EventQueue::new(DedupMode::Queue);
+        let ch = Uuid::new_v4();
+
+        // Empty queue: no undispatched work.
+        assert!(!queue.has_undispatched_work());
+
+        // Dispatched batch (in-flight): the events left the queue, and an
+        // in-flight turn is gated separately (has_in_flight), so this must be
+        // false — otherwise the pool could never sleep after any turn.
+        queue.push(make_queued(ch, "msg1"));
+        assert!(
+            queue.has_undispatched_work(),
+            "queued-but-not-flushed is undispatched"
+        );
+        let batch = queue.flush_next().unwrap();
+        assert!(queue.has_in_flight());
+        assert!(
+            !queue.has_undispatched_work(),
+            "in-flight work is not undispatched — it is gated by has_in_flight"
+        );
+
+        // Completed cleanly (no requeue): fully drained, nothing left.
+        queue.mark_complete(batch.channel_id);
+        assert!(!queue.has_undispatched_work());
+        assert!(!queue.has_in_flight());
+    }
+
     #[test]
     fn test_requeue_interleaves_with_other_channels() {
         let mut queue = EventQueue::new(DedupMode::Queue);
@@ -3087,6 +3247,7 @@ mod tests {
         let ci = PromptChannelInfo {
             name: "engineering".into(),
             channel_type: "stream".into(),
+            description: None,
         };
 
         let prompt = format_prompt(
@@ -3118,6 +3279,7 @@ mod tests {
         let ci = PromptChannelInfo {
             name: "DM".into(),
             channel_type: "dm".into(),
+            description: None,
         };
 
         let prompt = format_prompt(
@@ -3230,6 +3392,7 @@ mod tests {
         let ci = PromptChannelInfo {
             name: "DM".into(),
             channel_type: "dm".into(),
+            description: None,
         };
         let ctx = ConversationContext::Dm {
             messages: vec![ContextMessage {
@@ -3488,6 +3651,7 @@ mod tests {
         let ci = PromptChannelInfo {
             name: "DM".into(),
             channel_type: "dm".into(),
+            description: None,
         };
         // Thread context fetched (as the fetch path does for DM replies).
         let ctx = ConversationContext::Thread {
@@ -3587,6 +3751,7 @@ mod tests {
         let ci = PromptChannelInfo {
             name: "DM".into(),
             channel_type: "dm".into(),
+            description: None,
         };
 
         let trigger_only_prompt = format_prompt(
@@ -3635,6 +3800,7 @@ mod tests {
         let ci = PromptChannelInfo {
             name: "DM".into(),
             channel_type: "dm".into(),
+            description: None,
         };
 
         // No context fetched — hints only.
@@ -4130,6 +4296,7 @@ mod tests {
         let ci = PromptChannelInfo {
             name: "DM".into(),
             channel_type: "dm".into(),
+            description: None,
         };
 
         let prompt = format_prompt(
@@ -4193,6 +4360,7 @@ mod tests {
         let ci = PromptChannelInfo {
             name: "DM".into(),
             channel_type: "dm".into(),
+            description: None,
         };
 
         let prompt = format_prompt(
@@ -4961,4 +5129,254 @@ mod tests {
             "second extend must not move deadline backward (monotonic)"
         );
     }
+
+    // ── channel description delivery ─────────────────────────────────────────
+
+    #[test]
+    fn test_append_channel_description_adds_description_line() {
+        let ci = PromptChannelInfo {
+            name: "team".into(),
+            channel_type: "stream".into(),
+            description: Some("Engineering discussions".into()),
+        };
+        let mut s = "[Context]\nScope: channel\nChannel: team (#abc)".to_string();
+        append_channel_description(&mut s, Some(&ci));
+        assert!(
+            s.contains("\nDescription: Engineering discussions"),
+            "description must be appended; got: {s}"
+        );
+    }
+
+    #[test]
+    fn test_append_channel_description_absent_when_none() {
+        let ci = PromptChannelInfo {
+            name: "team".into(),
+            channel_type: "stream".into(),
+            description: None,
+        };
+        let mut s = "[Context]\nScope: channel".to_string();
+        append_channel_description(&mut s, Some(&ci));
+        assert!(
+            !s.contains("Description:"),
+            "no description must be appended when None; got: {s}"
+        );
+    }
+
+    #[test]
+    fn test_append_channel_description_absent_when_channel_info_none() {
+        let mut s = "[Context]\nScope: channel".to_string();
+        append_channel_description(&mut s, None);
+        assert!(
+            !s.contains("Description:"),
+            "no description must be appended when channel_info is None; got: {s}"
+        );
+    }
+
+    #[test]
+    fn test_append_channel_description_collapses_newlines_spoof_prevention() {
+        // A multiline description must not be able to inject a fake [Context] field.
+        let ci = PromptChannelInfo {
+            name: "team".into(),
+            channel_type: "stream".into(),
+            description: Some("Line one\nScope: injected\nLine two".into()),
+        };
+        let mut s = "[Context]\nScope: channel".to_string();
+        append_channel_description(&mut s, Some(&ci));
+        // The whole description is on a single Description line — no injected field.
+        let desc_line = s.lines().find(|l| l.starts_with("Description:")).unwrap();
+        assert_eq!(
+            desc_line, "Description: Line one Scope: injected Line two",
+            "multiline description must collapse to one line, never a fake field"
+        );
+        assert_eq!(
+            s.lines().filter(|l| l.starts_with("Description:")).count(),
+            1,
+            "exactly one Description line is rendered"
+        );
+    }
+
+    #[test]
+    fn test_append_channel_description_truncates_at_cap() {
+        let long_desc = "x".repeat(600);
+        let ci = PromptChannelInfo {
+            name: "team".into(),
+            channel_type: "stream".into(),
+            description: Some(long_desc),
+        };
+        let mut s = "[Context]\nScope: channel".to_string();
+        append_channel_description(&mut s, Some(&ci));
+        let desc_line = s.lines().find(|l| l.starts_with("Description:")).unwrap();
+        assert!(
+            desc_line.ends_with('…'),
+            "truncated description must end with '…'; got: {desc_line}"
+        );
+        // Value = first MAX_DESCRIPTION_LEN chars + the "…" marker.
+        let value = desc_line.strip_prefix("Description: ").unwrap();
+        assert_eq!(
+            value.chars().count(),
+            MAX_DESCRIPTION_LEN + 1,
+            "truncated value is exactly the cap plus the ellipsis marker"
+        );
+    }
+
+    #[test]
+    fn test_append_channel_description_multibyte_truncation_is_char_safe() {
+        // Truncation must land on a char boundary, never split a multi-byte code point.
+        let long_desc = "é".repeat(600);
+        let ci = PromptChannelInfo {
+            name: "team".into(),
+            channel_type: "stream".into(),
+            description: Some(long_desc),
+        };
+        let mut s = "[Context]\nScope: channel".to_string();
+        append_channel_description(&mut s, Some(&ci));
+        let desc_line = s.lines().find(|l| l.starts_with("Description:")).unwrap();
+        let value = desc_line.strip_prefix("Description: ").unwrap();
+        assert_eq!(value.chars().count(), MAX_DESCRIPTION_LEN + 1);
+    }
+
+    #[test]
+    fn test_append_channel_description_whitespace_only_is_absent() {
+        let ci = PromptChannelInfo {
+            name: "team".into(),
+            channel_type: "stream".into(),
+            description: Some("\n  \r\n \n".into()),
+        };
+        let mut s = "[Context]\nScope: channel".to_string();
+        append_channel_description(&mut s, Some(&ci));
+        assert!(
+            !s.contains("Description:"),
+            "a whitespace-only description collapses to empty and is not rendered; got: {s}"
+        );
+    }
+
+    fn description_batch(ch: Uuid, event: Event) -> FlushBatch {
+        FlushBatch {
+            channel_id: ch,
+            events: vec![BatchEvent {
+                event,
+                prompt_tag: "test".into(),
+                received_at: Instant::now(),
+            }],
+            cancelled_events: vec![],
+            cancel_reason: None,
+        }
+    }
+
+    #[test]
+    fn test_format_prompt_includes_description_in_context_for_channel_turn() {
+        let ch = Uuid::new_v4();
+        let batch = description_batch(ch, make_event("what should we build?"));
+        let ci = PromptChannelInfo {
+            name: "engineering".into(),
+            channel_type: "stream".into(),
+            description: Some("Engineering discussions and planning.".into()),
+        };
+        let prompt = format_prompt(
+            &batch,
+            &FormatPromptArgs {
+                channel_info: Some(&ci),
+                has_system_prompt_support: true,
+                ..Default::default()
+            },
+        )
+        .join("\n\n");
+        assert!(
+            prompt.contains("Scope: channel"),
+            "channel-scope turn expected; got: {prompt}"
+        );
+        assert!(
+            prompt.contains("Description: Engineering discussions and planning."),
+            "description must appear in [Context] for channel turns; got: {prompt}"
+        );
+    }
+
+    #[test]
+    fn test_format_prompt_includes_description_in_context_for_thread_turn() {
+        let ch = Uuid::new_v4();
+        let event = make_event_with_tags(
+            "reply in thread",
+            vec![vec![
+                "e".into(),
+                "root123".into(),
+                "".into(),
+                "reply".into(),
+            ]],
+        );
+        let batch = description_batch(ch, event);
+        let ci = PromptChannelInfo {
+            name: "engineering".into(),
+            channel_type: "stream".into(),
+            description: Some("Engineering discussions and planning.".into()),
+        };
+        let prompt = format_prompt(
+            &batch,
+            &FormatPromptArgs {
+                channel_info: Some(&ci),
+                has_system_prompt_support: true,
+                ..Default::default()
+            },
+        )
+        .join("\n\n");
+        assert!(
+            prompt.contains("Scope: thread"),
+            "thread-scope turn expected; got: {prompt}"
+        );
+        assert!(
+            prompt.contains("Description: Engineering discussions and planning."),
+            "description must appear in [Context] for thread turns; got: {prompt}"
+        );
+    }
+
+    #[test]
+    fn test_format_prompt_excludes_description_for_dm_turn() {
+        let ch = Uuid::new_v4();
+        let batch = description_batch(ch, make_event("hey"));
+        let ci = PromptChannelInfo {
+            name: "DM".into(),
+            channel_type: "dm".into(),
+            description: Some("This should not appear.".into()),
+        };
+        let prompt = format_prompt(
+            &batch,
+            &FormatPromptArgs {
+                channel_info: Some(&ci),
+                has_system_prompt_support: true,
+                ..Default::default()
+            },
+        )
+        .join("\n\n");
+        assert!(
+            prompt.contains("Scope: dm"),
+            "dm-scope turn expected; got: {prompt}"
+        );
+        assert!(
+            !prompt.contains("Description:"),
+            "DM turn must not include a Description field; got: {prompt}"
+        );
+    }
+
+    #[test]
+    fn test_format_prompt_no_description_when_channel_metadata_unresolved() {
+        let ch = Uuid::new_v4();
+        let batch = description_batch(ch, make_event("what should we build?"));
+        // channel_info None models unresolved metadata: no name, no description.
+        let prompt = format_prompt(
+            &batch,
+            &FormatPromptArgs {
+                channel_info: None,
+                has_system_prompt_support: true,
+                ..Default::default()
+            },
+        )
+        .join("\n\n");
+        assert!(
+            prompt.contains("Scope: channel"),
+            "channel-scope turn expected; got: {prompt}"
+        );
+        assert!(
+            !prompt.contains("Description:"),
+            "unresolved metadata must not render a Description field; got: {prompt}"
+        );
+    }
 }
diff --git a/crates/buzz-acp/src/relay.rs b/crates/buzz-acp/src/relay.rs
index 2cbb82411fd..17a818867dd 100644
--- a/crates/buzz-acp/src/relay.rs
+++ b/crates/buzz-acp/src/relay.rs
@@ -136,6 +136,8 @@ use crate::config::ChannelFilter;
 pub struct ChannelInfo {
     pub name: String,
     pub channel_type: String,
+    /// Channel description from the kind-39000 `about` tag, if present.
+    pub description: Option<String>,
 }
 
 pub(crate) fn channel_type_from_tags(tags: &[serde_json::Value]) -> String {
@@ -175,7 +177,7 @@ pub(crate) fn merge_discovered_channels(
     channel_uuids: Vec<Uuid>,
     meta_events: &serde_json::Value,
 ) -> HashMap<Uuid, ChannelInfo> {
-    let mut meta_map: HashMap<Uuid, (String, String)> = HashMap::new();
+    let mut meta_map: HashMap<Uuid, (String, String, Option<String>)> = HashMap::new();
     let mut archived: std::collections::HashSet<Uuid> = std::collections::HashSet::new();
     if let Some(arr) = meta_events.as_array() {
         for ev in arr {
@@ -186,11 +188,13 @@ pub(crate) fn merge_discovered_channels(
             let mut d_val = None;
             let mut name = None;
             let mut is_archived = false;
+            let mut description = None;
             for tag in tags {
                 if let Some(arr) = tag.as_array() {
                     match arr.first().and_then(|v| v.as_str()) {
                         Some("d") => d_val = arr.get(1).and_then(|v| v.as_str()),
                         Some("name") => name = arr.get(1).and_then(|v| v.as_str()),
+                        Some("about") => description = arr.get(1).and_then(|v| v.as_str()),
                         Some("archived") => {
                             is_archived = arr.get(1).and_then(|v| v.as_str()) == Some("true")
                         }
@@ -206,7 +210,11 @@ pub(crate) fn merge_discovered_channels(
                     }
                     let ch_name = name.unwrap_or("unknown").to_string();
                     let ch_type = channel_type_from_tags(tags);
-                    meta_map.insert(uuid, (ch_name, ch_type));
+                    let ch_desc = description
+                        .map(|s| s.trim())
+                        .filter(|s| !s.is_empty())
+                        .map(str::to_string);
+                    meta_map.insert(uuid, (ch_name, ch_type, ch_desc));
                 }
             }
         }
@@ -217,10 +225,17 @@ pub(crate) fn merge_discovered_channels(
         if archived.contains(&uuid) {
             continue;
         }
-        let (name, channel_type) = meta_map
+        let (name, channel_type, description) = meta_map
             .remove(&uuid)
-            .unwrap_or_else(|| ("unknown".to_string(), "unknown".to_string()));
-        map.insert(uuid, ChannelInfo { name, channel_type });
+            .unwrap_or_else(|| ("unknown".to_string(), "unknown".to_string(), None));
+        map.insert(
+            uuid,
+            ChannelInfo {
+                name,
+                channel_type,
+                description,
+            },
+        );
     }
     map
 }
@@ -4163,6 +4178,46 @@ mod tests {
         assert!(map.contains_key(&ch), "archived=false is treated as live");
     }
 
+    #[test]
+    fn merge_discovered_channels_parses_about_as_description() {
+        let ch = Uuid::new_v4();
+        let meta = serde_json::json!([meta_event(
+            ch,
+            "team",
+            &["t", "stream", "about", "Engineering discussions"]
+        )]);
+
+        let map = merge_discovered_channels(vec![ch], &meta);
+
+        assert_eq!(
+            map[&ch].description.as_deref(),
+            Some("Engineering discussions")
+        );
+    }
+
+    #[test]
+    fn merge_discovered_channels_blank_about_is_none() {
+        let ch = Uuid::new_v4();
+        let meta = serde_json::json!([meta_event(ch, "team", &["about", "   "])]);
+
+        let map = merge_discovered_channels(vec![ch], &meta);
+
+        assert_eq!(
+            map[&ch].description, None,
+            "a whitespace-only about tag is trimmed away to None"
+        );
+    }
+
+    #[test]
+    fn merge_discovered_channels_missing_about_is_none() {
+        let ch = Uuid::new_v4();
+        let meta = serde_json::json!([meta_event(ch, "team", &["t", "stream"])]);
+
+        let map = merge_discovered_channels(vec![ch], &meta);
+
+        assert_eq!(map[&ch].description, None);
+    }
+
     #[test]
     fn parse_ok_accepted() {
         let text = r#"["OK","abc123",true,""]"#;
diff --git a/crates/buzz-acp/src/usage.rs b/crates/buzz-acp/src/usage.rs
index 1eb3eba3b17..2197b99ef5f 100644
--- a/crates/buzz-acp/src/usage.rs
+++ b/crates/buzz-acp/src/usage.rs
@@ -244,6 +244,158 @@ pub struct TurnUsage {
     pub pricing_identity: Option<buzz_core::agent_turn_metric::PricingIdentity>,
 }
 
+/// Per-turn usage carried by a standard ACP `session/prompt` response.
+/// Adapter input excludes cache reads and writes, so NIP-AM input must add
+/// those subsets with checked arithmetic.
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct PromptResponseUsage {
+    pub input_tokens: u64,
+    pub output_tokens: u64,
+    pub total_tokens: u64,
+    pub cached_read_tokens: Option<u64>,
+    pub cached_write_tokens: Option<u64>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum StandardAdapterKind {
+    Claude,
+    Codex,
+}
+
+#[derive(Debug, Default)]
+struct StandardSessionState {
+    published_seq: u64,
+    last_cost: Option<f64>,
+    cost_poisoned: bool,
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct StandardUsageTracker {
+    sessions: HashMap<String, StandardSessionState>,
+    in_flight_session: Option<String>,
+    pending_cost: Option<(String, f64)>,
+    pending_prompt: Option<(String, PromptResponseUsage, StandardAdapterKind)>,
+}
+
+impl StandardUsageTracker {
+    pub(crate) fn seed_zero_baseline(&mut self, session_id: &str) {
+        self.sessions
+            .entry(session_id.to_string())
+            .or_insert_with(|| StandardSessionState {
+                published_seq: 0,
+                last_cost: Some(0.0),
+                cost_poisoned: false,
+            });
+    }
+
+    pub(crate) fn begin_turn(&mut self, session_id: &str) {
+        self.in_flight_session = Some(session_id.to_string());
+        self.pending_cost = None;
+        self.pending_prompt = None;
+    }
+
+    /// Claude's `usage_update.cost.amount` is a raw session-cumulative total.
+    pub(crate) fn record_cost(&mut self, session_id: &str, cost: f64) {
+        if cost.is_finite() && cost >= 0.0 && self.in_flight_session.as_deref() == Some(session_id)
+        {
+            self.pending_cost = Some((session_id.to_string(), cost));
+        }
+    }
+
+    pub(crate) fn record_prompt_usage(
+        &mut self,
+        session_id: &str,
+        usage: PromptResponseUsage,
+        adapter: StandardAdapterKind,
+    ) {
+        if self.in_flight_session.as_deref() == Some(session_id) {
+            self.pending_prompt = Some((session_id.to_string(), usage, adapter));
+        }
+    }
+
+    pub(crate) fn take(&mut self) -> Option<TurnUsage> {
+        self.in_flight_session = None;
+        let prompt = self.pending_prompt.take();
+        let cost = self.pending_cost.take();
+        let session_id = prompt
+            .as_ref()
+            .map(|(session_id, _, _)| session_id.clone())
+            .or_else(|| cost.as_ref().map(|(session_id, _)| session_id.clone()))?;
+
+        let (inclusive_input, output_tokens, total_tokens, cache_read, cache_write) = match prompt {
+            Some((_, usage, adapter)) => {
+                let inclusive_input = usage
+                    .input_tokens
+                    .checked_add(usage.cached_read_tokens.unwrap_or(0))
+                    .and_then(|input| input.checked_add(usage.cached_write_tokens.unwrap_or(0)));
+                let total_tokens =
+                    (adapter == StandardAdapterKind::Codex).then_some(usage.total_tokens);
+                (
+                    inclusive_input,
+                    inclusive_input.map(|_| usage.output_tokens),
+                    inclusive_input.and(total_tokens),
+                    inclusive_input.and(usage.cached_read_tokens),
+                    inclusive_input.and(usage.cached_write_tokens),
+                )
+            }
+            None => (None, None, None, None, None),
+        };
+
+        let state = self.sessions.entry(session_id.clone()).or_default();
+        let cumulative_cost = cost.map(|(_, cost)| cost);
+        let turn_cost = match (state.cost_poisoned, state.last_cost, cumulative_cost) {
+            (false, Some(previous), Some(current)) if current >= previous => {
+                let delta = current - previous;
+                delta.is_finite().then_some(delta)
+            }
+            _ => None,
+        };
+        if let Some(current) = cumulative_cost {
+            // A decrease means the cumulative series restarted or is corrupt.
+            // Poison the baseline rather than deriving a later delta across the
+            // discontinuity. The raw cumulative value still remains observable.
+            if state.last_cost.is_some_and(|previous| current < previous) {
+                state.cost_poisoned = true;
+                state.last_cost = None;
+            } else if !state.cost_poisoned {
+                state.last_cost = Some(current);
+            }
+        }
+
+        // Input overflow invalidates the standard prompt counters. Emit only if
+        // another valid signal (normally Claude cost) remains; NIP-AM forbids an
+        // otherwise all-null usage record.
+        if inclusive_input.is_none() && cumulative_cost.is_none() {
+            return None;
+        }
+
+        state.published_seq += 1;
+        Some(TurnUsage {
+            session_id,
+            turn_seq: state.published_seq,
+            // Standard prompt counters are per-turn already. A cost-only record
+            // is reliable only when a seeded/previous cumulative baseline made
+            // the cost delta provable.
+            delta_reliable: inclusive_input.is_some() || turn_cost.is_some(),
+            turn_input_tokens: inclusive_input,
+            turn_output_tokens: output_tokens,
+            turn_total_tokens: total_tokens,
+            turn_cost_usd: turn_cost,
+            turn_cache_read_tokens: cache_read,
+            turn_cache_write_tokens: cache_write,
+            cumulative_input_tokens: None,
+            cumulative_output_tokens: None,
+            cumulative_total_tokens: None,
+            cumulative_cost_usd: cumulative_cost,
+            cumulative_cache_read_tokens: None,
+            cumulative_cache_write_tokens: None,
+            model: None,
+            pricing_identity: None,
+        })
+    }
+}
+
 /// Tracks per-session cumulative usage state across turns.
 ///
 /// Cheap to construct. Usage lifecycle per turn:
diff --git a/crates/buzz-admin/Cargo.toml b/crates/buzz-admin/Cargo.toml
index 7a69e146bb9..00c2804cbcf 100644
--- a/crates/buzz-admin/Cargo.toml
+++ b/crates/buzz-admin/Cargo.toml
@@ -13,6 +13,7 @@ path = "src/main.rs"
 
 [dependencies]
 buzz-db = { workspace = true }
+buzz-deletion = { workspace = true }
 buzz-core = { workspace = true }
 buzz-auth = { workspace = true }
 buzz-pubsub = { workspace = true }
diff --git a/crates/buzz-admin/src/deletions.rs b/crates/buzz-admin/src/deletions.rs
new file mode 100644
index 00000000000..64cb8bd732a
--- /dev/null
+++ b/crates/buzz-admin/src/deletions.rs
@@ -0,0 +1,19 @@
+//! Thin `buzz-admin deletions` adapter.
+
+pub use buzz_deletion::Command as DeletionsCommand;
+
+/// Delegate to the shared durable deletion engine.
+pub async fn run(command: DeletionsCommand) -> anyhow::Result<i32> {
+    buzz_deletion::run(command).await
+}
+
+#[cfg(test)]
+mod tests {
+    use clap::Parser;
+
+    #[test]
+    fn continuous_worker_command_is_not_exposed() {
+        let command = crate::Cli::try_parse_from(["buzz-admin", "deletions", "worker"]);
+        assert!(command.is_err());
+    }
+}
diff --git a/crates/buzz-admin/src/main.rs b/crates/buzz-admin/src/main.rs
index bb30ddfae4f..580d5865913 100644
--- a/crates/buzz-admin/src/main.rs
+++ b/crates/buzz-admin/src/main.rs
@@ -20,6 +20,8 @@
 //! newest timestamp and collide on the bumped second. run.sh serialization is
 //! the guard against parallel adds (e.g. `xargs -P`).
 
+mod deletions;
+
 use std::sync::Arc;
 
 use anyhow::Result;
@@ -81,6 +83,11 @@ enum Command {
         #[command(subcommand)]
         command: ProductFeedbackCommand,
     },
+    /// Durable CLI-only whole-community deletion control plane.
+    Deletions {
+        #[command(subcommand)]
+        command: deletions::DeletionsCommand,
+    },
     /// Emit kind:39000/39002 events for channels missing them.
     ///
     /// Channels created via direct SQL (seed scripts, pre-migration data) won't
@@ -148,6 +155,7 @@ async fn run(cli: Cli) -> Result<i32> {
         Command::ProductFeedback {
             command: ProductFeedbackCommand::List { limit },
         } => cmd_list_product_feedback(limit).await,
+        Command::Deletions { command } => deletions::run(command).await,
         Command::ReconcileChannels { relay_key } => {
             reconcile_channels(relay_key).await?;
             Ok(0)
diff --git a/crates/buzz-agent/README.md b/crates/buzz-agent/README.md
index 5d942777d5e..0bc03db7813 100644
--- a/crates/buzz-agent/README.md
+++ b/crates/buzz-agent/README.md
@@ -153,7 +153,8 @@ Everything is environment variables. No flags, no config files. (We are a subpro
 | `BUZZ_AGENT_SYSTEM_PROMPT` | built-in | Inline system prompt. |
 | `BUZZ_AGENT_SYSTEM_PROMPT_FILE` | — | File path. Mutually exclusive with the above. |
 | `BUZZ_AGENT_MAX_ROUNDS` | `0` | Tool-loop iteration cap. 0 = unlimited. |
-| `BUZZ_AGENT_MAX_OUTPUT_TOKENS` | `32768` | Per LLM call. Headroom for large tool-call inputs (e.g. file writes via heredoc); Sonnet 4 / Opus 4 cap at 64K. |
+| `BUZZ_AGENT_MAX_OUTPUT_TOKENS` | `65536` | Desired per-call ceiling. Set this at or below the served model's output limit for each agent deployment. Proactive handoff is independently based on 90% of `BUZZ_AGENT_MAX_CONTEXT_TOKENS`. |
+| `BUZZ_AGENT_MAX_TOKEN_RECOVERIES` | `3` | Retries after a successful response is truncated at the output-token limit. `0` disables recovery; the finite value and `BUZZ_AGENT_MAX_ROUNDS` prevent infinite retries. |
 | `BUZZ_AGENT_MAX_CONTEXT_TOKENS` | `200000` | Provider context window used by the handoff gate. |
 | `BUZZ_AGENT_MAX_HANDOFFS` | `10` | Max context handoffs per session before falling back to truncation. |
 | `BUZZ_AGENT_LLM_TIMEOUT_SECS` | `240` | Max seconds with no response bytes before abandoning an LLM call (per-read inactivity, not wall-clock). |
diff --git a/crates/buzz-agent/src/agent.rs b/crates/buzz-agent/src/agent.rs
index 0805fddb12d..9258ce449f3 100644
--- a/crates/buzz-agent/src/agent.rs
+++ b/crates/buzz-agent/src/agent.rs
@@ -31,12 +31,7 @@ const UNSUPPORTED_IMAGE_TOOL_MESSAGE: &str = "The current model does not support
 /// its output-token limit. This is a user message rather than a synthetic tool
 /// result because truncation can happen without a tool call (and an unpaired
 /// tool result is invalid on every provider wire format).
-const MAX_TOKENS_RECOVERY_MESSAGE: &str = "Your previous response exceeded the model's output token limit and was truncated. Any incomplete tool call was not run. Continue the task, breaking the work or tool call into smaller steps and keeping the response concise.";
-
-/// A provider can repeatedly spend its entire output allowance without making
-/// progress, while `max_rounds` is unbounded by default. Keep the in-turn rescue
-/// finite so a persistently truncating model eventually surfaces `max_tokens`.
-const MAX_TOKENS_RECOVERIES_PER_RUN: u32 = 2;
+const MAX_TOKENS_RECOVERY_MESSAGE: &str = "Your previous response reached the model's output token limit and was truncated. Any incomplete tool calls were discarded and were not run. Stop prolonged internal reasoning now. Use the available tools immediately: write a script or artifact to a file and run it in small, verifiable steps instead of emitting the entire solution inline. Continue the task concisely from the preserved text.";
 
 /// Remove image blocks that the provider has explicitly rejected while keeping
 /// their surrounding tool result (and therefore the tool-call/result pairing)
@@ -667,9 +662,10 @@ impl RunCtx<'_> {
                     tool_calls: Vec::new(),
                     reasoning_details: response.reasoning_details,
                 });
-                if max_tokens_recoveries >= MAX_TOKENS_RECOVERIES_PER_RUN {
+                if max_tokens_recoveries >= self.cfg.max_token_recoveries {
                     tracing::warn!(
                         recoveries = max_tokens_recoveries,
+                        max_recoveries = self.cfg.max_token_recoveries,
                         "provider repeatedly hit output token limit; recovery budget exhausted"
                     );
                     return Ok(StopReason::MaxTokens);
@@ -677,8 +673,7 @@ impl RunCtx<'_> {
                 max_tokens_recoveries = max_tokens_recoveries.saturating_add(1);
                 tracing::warn!(
                     recovery = max_tokens_recoveries,
-                    max_recoveries = MAX_TOKENS_RECOVERIES_PER_RUN,
-                    discarded_tool_calls = response.tool_calls.len(),
+                    max_recoveries = self.cfg.max_token_recoveries,
                     "provider hit output token limit; asking model to continue in smaller steps"
                 );
                 self.history
diff --git a/crates/buzz-agent/src/config.rs b/crates/buzz-agent/src/config.rs
index 501d3123d79..b29bf3d2fb8 100644
--- a/crates/buzz-agent/src/config.rs
+++ b/crates/buzz-agent/src/config.rs
@@ -781,6 +781,10 @@ pub struct Config {
     pub system_prompt: String,
     pub max_rounds: u32,
     pub max_output_tokens: u32,
+    /// Maximum number of retries after a provider returns a successful but
+    /// output-truncated response. Zero disables truncation recovery. This is
+    /// independent of `max_rounds`, which still bounds all successful calls.
+    pub max_token_recoveries: u32,
     pub llm_timeout: Duration,
     pub tool_timeout: Duration,
     pub mcp_init_timeout: Duration,
@@ -931,7 +935,8 @@ impl Config {
             anthropic_api_version: env_or("ANTHROPIC_API_VERSION", "2023-06-01"),
             openai_api,
             max_rounds: parse_env("BUZZ_AGENT_MAX_ROUNDS", 0)?,
-            max_output_tokens: parse_env("BUZZ_AGENT_MAX_OUTPUT_TOKENS", 32_768)?,
+            max_output_tokens: parse_env("BUZZ_AGENT_MAX_OUTPUT_TOKENS", 65_536)?,
+            max_token_recoveries: parse_env("BUZZ_AGENT_MAX_TOKEN_RECOVERIES", 3u32)?,
             llm_timeout: Duration::from_secs(parse_env("BUZZ_AGENT_LLM_TIMEOUT_SECS", 240)?),
             tool_timeout: Duration::from_secs(parse_env("BUZZ_AGENT_TOOL_TIMEOUT_SECS", 660)?),
             mcp_init_timeout: Duration::from_secs(parse_env(
@@ -983,6 +988,7 @@ impl Config {
             openai_api: OpenAiApi::Chat,
             max_rounds: 0,
             max_output_tokens: 1,
+            max_token_recoveries: 0,
             llm_timeout: Duration::from_secs(30),
             tool_timeout: Duration::from_secs(30),
             mcp_init_timeout: Duration::from_secs(30),
diff --git a/crates/buzz-agent/src/handoff.rs b/crates/buzz-agent/src/handoff.rs
index 4748678059d..869fbe06664 100644
--- a/crates/buzz-agent/src/handoff.rs
+++ b/crates/buzz-agent/src/handoff.rs
@@ -59,8 +59,7 @@ impl RunCtx<'_> {
         }
         if *handoff_attempts >= self.cfg.max_handoffs {
             let projected = self.projected_handoff_input_tokens();
-            let threshold =
-                token_threshold(self.cfg.max_context_tokens, self.cfg.max_output_tokens);
+            let threshold = token_threshold(self.cfg.max_context_tokens);
             tracing::warn!(
                 session_id = self.session_id,
                 reason = "preflight",
@@ -246,7 +245,7 @@ impl RunCtx<'_> {
         match *self.last_request_input_tokens {
             Some(_) => {
                 self.projected_handoff_input_tokens()
-                    >= token_threshold(self.cfg.max_context_tokens, self.cfg.max_output_tokens)
+                    >= token_threshold(self.cfg.max_context_tokens)
             }
             None => {
                 let bytes: usize = self
@@ -257,7 +256,6 @@ impl RunCtx<'_> {
                 bytes
                     > byte_fallback_threshold(
                         self.cfg.max_context_tokens,
-                        self.cfg.max_output_tokens,
                         self.cfg.max_history_bytes,
                     )
             }
@@ -495,28 +493,20 @@ fn estimate_tokens_from_bytes(bytes: usize) -> u64 {
     (bytes as u64).div_ceil(CONSERVATIVE_BYTES_PER_TOKEN)
 }
 
-/// Input-token count at which to hand off. Caps at the configured fraction of
-/// the window and also leaves room for `max_output_tokens`, so input + output
-/// can't together exceed the window. Free function so the policy math is unit
-/// testable without constructing a [`RunCtx`].
-fn token_threshold(max_context_tokens: u64, max_output_tokens: u32) -> u64 {
+/// Input-token count at which to hand off. Uses 90% of the configured context
+/// window, independent of the request's output allowance. Free function so the
+/// policy math is unit testable without constructing a [`RunCtx`].
+fn token_threshold(max_context_tokens: u64) -> u64 {
     // Integer math: handoff threshold is 90%, i.e. window * 9 / 10.
-    let fractional = max_context_tokens / 10 * 9;
-    let output_reserved = max_context_tokens.saturating_sub(u64::from(max_output_tokens));
-    fractional.min(output_reserved)
+    max_context_tokens / 10 * 9
 }
 
 /// Conservative byte cap used only before any usage is known. Maps the token
 /// threshold to bytes at the conservative bytes/token ratio (so the cap is
 /// small and the handoff fires early), clamped to the configured byte budget
 /// so it can only ever be more conservative than the old byte-only behavior.
-fn byte_fallback_threshold(
-    max_context_tokens: u64,
-    max_output_tokens: u32,
-    max_history_bytes: usize,
-) -> usize {
-    let derived = token_threshold(max_context_tokens, max_output_tokens)
-        .saturating_mul(CONSERVATIVE_BYTES_PER_TOKEN);
+fn byte_fallback_threshold(max_context_tokens: u64, max_history_bytes: usize) -> usize {
+    let derived = token_threshold(max_context_tokens).saturating_mul(CONSERVATIVE_BYTES_PER_TOKEN);
     let byte_cap = max_history_bytes / 10 * 9;
     usize::try_from(derived).unwrap_or(usize::MAX).min(byte_cap)
 }
@@ -605,36 +595,23 @@ mod tests {
     }
 
     #[test]
-    fn token_threshold_uses_fraction_when_output_is_small() {
-        // 200k window, 1k output. fractional = 0.9*200000 = 180000;
-        // output_reserved = 200000-1000 = 199000; min = 180000.
-        assert_eq!(token_threshold(200_000, 1_000), 180_000);
-    }
-
-    #[test]
-    fn token_threshold_reserves_output_headroom() {
-        // Large output relative to window: the output-reserve term dominates,
-        // keeping input+output within the window.
-        // 100k window, 40k output: fractional=90k, reserved=60k -> 60k.
-        assert_eq!(token_threshold(100_000, 40_000), 60_000);
-    }
-
-    #[test]
-    fn token_threshold_saturates_when_output_exceeds_window() {
-        // Degenerate (config validation forbids this, but math must not panic):
-        // reserved saturates to 0, so threshold is 0 -> always hand off.
-        assert_eq!(token_threshold(1000, 5000), 0);
+    fn token_threshold_is_independent_of_output_allowance() {
+        // Handoff always begins at 90% of the input context budget, including
+        // when the request's output allowance grows or exceeds the window.
+        assert_eq!(token_threshold(200_000), 180_000);
+        assert_eq!(token_threshold(100_000), 90_000);
+        assert_eq!(token_threshold(1_000), 900);
     }
 
     #[test]
     fn byte_fallback_is_conservative_and_capped() {
         // Derived = token_threshold * 1 (1 byte/token upper bound). For
-        // 200k/1k: 180000 bytes, well under a 16 MiB byte budget, so derived
-        // wins (early handoff).
-        let t = byte_fallback_threshold(200_000, 1_000, 16 * 1024 * 1024);
+        // 200k window: 180000 bytes, well under a 16 MiB byte budget, so the
+        // derived threshold wins (early handoff).
+        let t = byte_fallback_threshold(200_000, 16 * 1024 * 1024);
         assert_eq!(t, 180_000);
         // With a tiny byte budget the cap wins -> never exceeds it (window*90%).
-        let capped = byte_fallback_threshold(200_000, 1_000, 8192);
+        let capped = byte_fallback_threshold(200_000, 8192);
         assert_eq!(capped, 8192 / 10 * 9);
     }
 
diff --git a/crates/buzz-agent/src/llm.rs b/crates/buzz-agent/src/llm.rs
index 1f3cac3df49..a963de1e7c1 100644
--- a/crates/buzz-agent/src/llm.rs
+++ b/crates/buzz-agent/src/llm.rs
@@ -1135,7 +1135,7 @@ fn map_stop(s: Option<&str>) -> ProviderStop {
     match s {
         Some("end_turn" | "stop") => ProviderStop::EndTurn,
         Some("tool_use" | "tool_calls") => ProviderStop::ToolUse,
-        Some("max_tokens" | "length") => ProviderStop::MaxTokens,
+        Some("max_tokens" | "length" | "model_context_window_exceeded") => ProviderStop::MaxTokens,
         Some("refusal" | "content_filter") => ProviderStop::Refusal,
         _ => ProviderStop::Other,
     }
@@ -2589,6 +2589,7 @@ mod tests {
             system_prompt: "system".into(),
             max_rounds: 10,
             max_output_tokens: 1024,
+            max_token_recoveries: 3,
             llm_timeout: Duration::from_secs(10),
             tool_timeout: Duration::from_secs(10),
             mcp_init_timeout: Duration::from_secs(10),
@@ -3104,6 +3105,17 @@ mod tests {
         assert!(r.tool_calls.is_empty());
     }
 
+    #[test]
+    fn anthropic_context_window_exhaustion_is_truncation() {
+        let v = serde_json::json!({
+            "stop_reason": "model_context_window_exceeded",
+            "content": [{"type": "text", "text": "partial text"}],
+        });
+        let r = parse_anthropic(v).unwrap();
+        assert_eq!(r.stop, ProviderStop::MaxTokens);
+        assert_eq!(r.text, "partial text");
+    }
+
     #[test]
     fn truncated_anthropic_tool_use_is_discarded_not_rejected() {
         let v = serde_json::json!({
diff --git a/crates/buzz-agent/src/types.rs b/crates/buzz-agent/src/types.rs
index a814a27cf7c..10ac65b46ef 100644
--- a/crates/buzz-agent/src/types.rs
+++ b/crates/buzz-agent/src/types.rs
@@ -687,11 +687,11 @@ mod tests {
         // Regression: a single ~3.1M-base64-byte `view_image` result on an
         // otherwise-empty history must NOT exceed the default pre-usage
         // handoff cap. The gate's byte-fallback threshold with the shipped
-        // defaults (max_context_tokens=200_000, max_output_tokens=32_768) is
-        // min(200_000*9/10, 200_000-32_768) = 167_232 "bytes". Before the fix
+        // defaults (max_context_tokens=200_000) is 200_000*9/10 = 180_000
+        // "bytes". Before the fix
         // this item counted ~3.1M and tripped instantly.
         let item = image_item(3_118_884);
-        const DEFAULT_PRE_USAGE_THRESHOLD: usize = 167_232;
+        const DEFAULT_PRE_USAGE_THRESHOLD: usize = 180_000;
         assert!(
             item.context_pressure_bytes() <= DEFAULT_PRE_USAGE_THRESHOLD,
             "one image charged {} bytes of context pressure, over the {} threshold",
diff --git a/crates/buzz-agent/tests/regressions.rs b/crates/buzz-agent/tests/regressions.rs
index a972f9b2429..6a4f347f6bb 100644
--- a/crates/buzz-agent/tests/regressions.rs
+++ b/crates/buzz-agent/tests/regressions.rs
@@ -2314,6 +2314,27 @@ fn reply_guard_rejects_unparseable_toggle() {
     );
 }
 
+#[test]
+fn max_token_recoveries_rejects_unparseable_value() {
+    let out = std::process::Command::new(env!("CARGO_BIN_EXE_buzz-agent"))
+        .env("BUZZ_AGENT_PROVIDER", "openai")
+        .env("OPENAI_COMPAT_API_KEY", "test")
+        .env("OPENAI_COMPAT_MODEL", "fake-model")
+        .env("BUZZ_AGENT_MAX_TOKEN_RECOVERIES", "unbounded")
+        .stdin(Stdio::null())
+        .output()
+        .expect("run buzz-agent");
+    assert!(
+        !out.status.success(),
+        "invalid recovery budget was accepted"
+    );
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(
+        stderr.contains("BUZZ_AGENT_MAX_TOKEN_RECOVERIES"),
+        "expected offending key in config error: {stderr}"
+    );
+}
+
 /// A prompt large enough that the recovery ladder's halving stays above
 /// `HANDOFF_MIN_PROMPT_BUDGET_BYTES` (4 KiB) for all three rungs.
 ///
@@ -2494,9 +2515,11 @@ async fn max_tokens_recovers_in_turn_without_running_partial_tool_call() {
     );
     assert!(
         serialized.contains("output token limit")
-            && serialized.contains("smaller steps")
-            && serialized.contains("tool call"),
-        "retry lacks actionable truncation feedback: {retry}"
+            && serialized.contains("Stop prolonged internal reasoning")
+            && serialized.contains("Use the available tools immediately")
+            && serialized.contains("write a script or artifact")
+            && serialized.contains("small, verifiable steps"),
+        "retry lacks the tool-first truncation directive: {retry}"
     );
     assert!(
         !serialized.contains("partial-call") && !serialized.contains("tool_call_id"),
@@ -2542,7 +2565,14 @@ async fn repeated_max_tokens_is_bounded() {
         .map(|_| openai_max_tokens("still truncated", json!([])))
         .collect();
     let llm = spawn_capturing_llm(responses).await;
-    let mut h = Harness::spawn_with_env(&llm.url, &[("BUZZ_AGENT_MAX_ROUNDS", "0")]).await;
+    let mut h = Harness::spawn_with_env(
+        &llm.url,
+        &[
+            ("BUZZ_AGENT_MAX_ROUNDS", "0"),
+            ("BUZZ_AGENT_MAX_TOKEN_RECOVERIES", "2"),
+        ],
+    )
+    .await;
     let sid = init_session(&mut h, json!([])).await;
     let prompt_id = h
         .send(
@@ -2561,6 +2591,93 @@ async fn repeated_max_tokens_is_bounded() {
     h.shutdown().await;
 }
 
+/// The default value is the exact number of retries: three recoveries produce
+/// four truncating requests, then surface `max_tokens` without another call.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn default_max_tokens_recovery_budget_is_exact() {
+    let responses = (0..5)
+        .map(|_| openai_max_tokens("truncated", json!([])))
+        .collect();
+    let llm = spawn_capturing_llm(responses).await;
+    let mut h = Harness::spawn(&llm.url).await;
+    let sid = init_session(&mut h, json!([])).await;
+    let prompt_id = h
+        .send(
+            "session/prompt",
+            json!({"sessionId": sid, "prompt": [{"type":"text","text":"go"}]}),
+        )
+        .await;
+    let reply = h.recv_until(|v| v["id"] == json!(prompt_id)).await;
+    assert_eq!(reply["result"]["stopReason"], "max_tokens", "{reply}");
+    let requests = llm.captured.lock().await;
+    assert_eq!(requests.len(), 4);
+    assert_eq!(
+        requests[0]["max_completion_tokens"], 65_536,
+        "default output ceiling must be carried on the actual request path"
+    );
+    drop(requests);
+    h.shutdown().await;
+}
+
+/// Zero means disabled, not unlimited: the first truncated response is terminal
+/// and no recovery directive is sent.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn zero_max_token_recoveries_disables_retry() {
+    let llm = spawn_capturing_llm(vec![
+        openai_max_tokens("truncated", json!([])),
+        openai_text("must not be requested"),
+    ])
+    .await;
+    let mut h =
+        Harness::spawn_with_env(&llm.url, &[("BUZZ_AGENT_MAX_TOKEN_RECOVERIES", "0")]).await;
+    let sid = init_session(&mut h, json!([])).await;
+    let prompt_id = h
+        .send(
+            "session/prompt",
+            json!({"sessionId": sid, "prompt": [{"type":"text","text":"go"}]}),
+        )
+        .await;
+    let reply = h.recv_until(|v| v["id"] == json!(prompt_id)).await;
+    assert_eq!(reply["result"]["stopReason"], "max_tokens", "{reply}");
+    assert_eq!(llm.captured.lock().await.len(), 1);
+    h.shutdown().await;
+}
+
+/// A successful recovery may proceed directly to a real tool call. This pins
+/// that only tool calls from the truncated response are discarded.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn max_tokens_recovery_can_proceed_to_tool_call() {
+    let llm = spawn_capturing_llm(vec![
+        openai_max_tokens(
+            "partial",
+            json!([{"id":"discard-me","type":"function","function":{"name":"dev__shell","arguments":"{\"command\":\"false\"}"}}]),
+        ),
+        openai_tool_call("kept-call", "fake__tool_0", json!({})),
+        openai_text("done"),
+    ])
+    .await;
+    let mut h = Harness::spawn(&llm.url).await;
+    let sid = init_session_with_fake_mcp(&mut h, &[("FAKE_MCP_TOOL_COUNT", "1")]).await;
+    let prompt_id = h
+        .send(
+            "session/prompt",
+            json!({"sessionId": sid, "prompt": [{"type":"text","text":"go"}]}),
+        )
+        .await;
+    let reply = h.recv_until(|v| v["id"] == json!(prompt_id)).await;
+    assert_eq!(reply["result"]["stopReason"], "end_turn", "{reply}");
+    let requests = llm.captured.lock().await;
+    assert_eq!(requests.len(), 3);
+    let wire = requests[1].to_string();
+    assert!(
+        !wire.contains("discard-me"),
+        "discarded call leaked: {wire}"
+    );
+    assert!(requests[2].to_string().contains("kept-call"));
+    drop(requests);
+    h.shutdown().await;
+}
+
 /// A successful recovery must actually send the recovered completion, even when
 /// `max_rounds` is finite. `round` is incremented BEFORE the completion that
 /// gets rejected, so a naive `continue` after recovery re-enters the loop with
diff --git a/crates/buzz-db/src/channel.rs b/crates/buzz-db/src/channel.rs
index fecb6b0ac98..3ca9b3d901c 100644
--- a/crates/buzz-db/src/channel.rs
+++ b/crates/buzz-db/src/channel.rs
@@ -1506,6 +1506,7 @@ pub async fn reap_expired_ephemeral_channels(pool: &PgPool) -> Result<Vec<Reaped
            AND ch.archived_at IS NULL \
            AND ch.deleted_at IS NULL \
            AND c.archived_at IS NULL \
+           AND community_write_allowed(ch.community_id) \
          RETURNING ch.community_id, c.host, ch.id",
     )
     .fetch_all(pool)
diff --git a/crates/buzz-db/src/deletion.rs b/crates/buzz-db/src/deletion.rs
new file mode 100644
index 00000000000..fbe69f22a68
--- /dev/null
+++ b/crates/buzz-db/src/deletion.rs
@@ -0,0 +1,4707 @@
+//! Durable whole-community deletion lifecycle and PostgreSQL adapter.
+//!
+//! This module owns request inventory, approval, claims, fencing, checkpoints,
+//! retries, tombstoning, and logical verification. CLI claim-loop policy and
+//! external storage adapters live above it; they never implement state changes.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::fmt;
+use std::str::FromStr;
+use std::time::Duration;
+
+use buzz_core::CommunityId;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use sqlx::{AssertSqlSafe, PgConnection, PgPool, Postgres, Row, Transaction};
+use uuid::Uuid;
+
+use crate::error::{DbError, Result};
+
+/// Default PostgreSQL lease duration for one claimed deletion request.
+pub const DEFAULT_LEASE_DURATION: Duration = Duration::from_secs(60);
+/// Durable name of the schema manifest's PostgreSQL component.
+pub const POSTGRES_STORE_NAME: &str = "postgres";
+/// Durable name of the object-store manifest component.
+pub const OBJECT_STORE_NAME: &str = "object_store";
+/// Durable name of the Redis/cache manifest component.
+pub const REDIS_STORE_NAME: &str = "redis";
+
+/// Deployment-global advisory-lock key serializing schema migration with
+/// destructive deletion.
+///
+/// [`crate::migration::run_migrations`] holds the exclusive session lock for
+/// its entire run; destructive catalog validation, purge, and final logical
+/// verification hold the shared transaction-scoped counterpart. Exact catalog
+/// equality is therefore stable for the whole destructive interval, not just
+/// the instant it is checked. The value is arbitrary (ASCII `buzzdel1`) but
+/// permanently stable: changing it silently drops the exclusion contract
+/// against replicas still holding the old key during a rolling deploy.
+pub const SCHEMA_DESTRUCTION_LOCK_KEY: i64 = 0x62757a7a64656c31;
+
+/// Control-plane tables that survive the community data purge.
+pub const CONTROL_PLANE_TABLES: &[&str] = &[
+    "community_deletion_approvals",
+    "community_deletion_checkpoints",
+    "community_deletion_executor_heartbeats",
+    "community_deletion_requests",
+    "community_serving_write_leases",
+];
+
+/// Expected community-scoped tables purged by V1.
+///
+/// Catalog inventory compares the live database against this exact set before
+/// approval and again before PostgreSQL purge. A new tenant table therefore
+/// blocks deletion until this manifest is intentionally updated.
+pub const EXPECTED_SCOPED_TABLES: &[&str] = &[
+    "api_tokens",
+    "archived_identities",
+    "audit_log",
+    "channel_members",
+    "channels",
+    "community_bans",
+    "delivery_log",
+    "event_mentions",
+    "events",
+    "git_repo_names",
+    "join_policy_acceptances",
+    "moderation_actions",
+    "moderation_reports",
+    "parameterized_event_watermarks",
+    "pubkey_allowlist",
+    "push_leases",
+    "push_match_queue",
+    "push_wake_outbox",
+    "reactions",
+    "relay_invites",
+    "relay_members",
+    "scheduled_workflow_fires",
+    "subscriptions",
+    "thread_metadata",
+    "users",
+    "workflow_approvals",
+    "workflow_runs",
+    "workflows",
+];
+
+/// Foreign-key-safe child-before-parent order for the PostgreSQL purge.
+pub const PURGE_SCOPED_TABLES: &[&str] = &[
+    "workflow_approvals",
+    "scheduled_workflow_fires",
+    "workflow_runs",
+    "push_wake_outbox",
+    "join_policy_acceptances",
+    "moderation_reports",
+    "subscriptions",
+    "api_tokens",
+    "channel_members",
+    "thread_metadata",
+    "moderation_actions",
+    "workflows",
+    "event_mentions",
+    "reactions",
+    "push_match_queue",
+    "push_leases",
+    "relay_invites",
+    "delivery_log",
+    "events",
+    "parameterized_event_watermarks",
+    "git_repo_names",
+    "archived_identities",
+    "audit_log",
+    "community_bans",
+    "pubkey_allowlist",
+    "relay_members",
+    "users",
+    "channels",
+];
+
+/// Fixed lifecycle order. There are no backwards or skipping transitions.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DeletionStage {
+    /// Request exists but has not frozen its inventory.
+    Submitted,
+    /// PostgreSQL and storage inventory has been frozen.
+    Inventoried,
+    /// An operator explicitly approved the frozen inventory digest.
+    Approved,
+    /// Universal serving-path write fence is active.
+    Fenced,
+    /// In-flight serving writes have drained behind the durable fence.
+    Drained,
+    /// Tenant-owned S3/media and Git pointer bindings were removed.
+    BindingsRemoved,
+    /// Tenant-scoped PostgreSQL rows were purged.
+    PostgresPurged,
+    /// Redis/community process-cache namespace was purged.
+    CachePurged,
+    /// Cross-store logical absence was verified.
+    LogicallyVerified,
+    /// Logical deletion complete; shared CAS physical expiry is deferred.
+    RetentionPending,
+    /// Operator cancelled before irreversible object deletion began.
+    Aborted,
+}
+
+impl DeletionStage {
+    /// Next legal stage, if this is not terminal.
+    pub const fn next(self) -> Option<Self> {
+        match self {
+            Self::Submitted => Some(Self::Inventoried),
+            Self::Inventoried => Some(Self::Approved),
+            Self::Approved => Some(Self::Fenced),
+            Self::Fenced => Some(Self::Drained),
+            Self::Drained => Some(Self::BindingsRemoved),
+            Self::BindingsRemoved => Some(Self::PostgresPurged),
+            Self::PostgresPurged => Some(Self::CachePurged),
+            Self::CachePurged => Some(Self::LogicallyVerified),
+            Self::LogicallyVerified => Some(Self::RetentionPending),
+            Self::RetentionPending | Self::Aborted => None,
+        }
+    }
+
+    /// Whether execution may claim this stage.
+    pub const fn runnable(self) -> bool {
+        matches!(
+            self,
+            Self::Approved
+                | Self::Fenced
+                | Self::Drained
+                | Self::BindingsRemoved
+                | Self::PostgresPurged
+                | Self::CachePurged
+                | Self::LogicallyVerified
+        )
+    }
+}
+
+impl fmt::Display for DeletionStage {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = match self {
+            Self::Submitted => "submitted",
+            Self::Inventoried => "inventoried",
+            Self::Approved => "approved",
+            Self::Fenced => "fenced",
+            Self::Drained => "drained",
+            Self::BindingsRemoved => "bindings_removed",
+            Self::PostgresPurged => "postgres_purged",
+            Self::CachePurged => "cache_purged",
+            Self::LogicallyVerified => "logically_verified",
+            Self::RetentionPending => "retention_pending",
+            Self::Aborted => "aborted",
+        };
+        f.write_str(value)
+    }
+}
+
+impl FromStr for DeletionStage {
+    type Err = DbError;
+
+    fn from_str(value: &str) -> std::result::Result<Self, Self::Err> {
+        match value {
+            "submitted" => Ok(Self::Submitted),
+            "inventoried" => Ok(Self::Inventoried),
+            "approved" => Ok(Self::Approved),
+            "fenced" => Ok(Self::Fenced),
+            "drained" => Ok(Self::Drained),
+            "bindings_removed" => Ok(Self::BindingsRemoved),
+            "postgres_purged" => Ok(Self::PostgresPurged),
+            "cache_purged" => Ok(Self::CachePurged),
+            "logically_verified" => Ok(Self::LogicallyVerified),
+            "retention_pending" => Ok(Self::RetentionPending),
+            "aborted" => Ok(Self::Aborted),
+            other => Err(DbError::DeletionSafety(format!(
+                "unknown community deletion stage: {other}"
+            ))),
+        }
+    }
+}
+
+/// Durable community deletion request.
+#[derive(Debug, Clone, Serialize)]
+pub struct DeletionRequest {
+    /// Request identifier.
+    pub id: Uuid,
+    /// Target community.
+    #[serde(serialize_with = "serialize_community_id")]
+    pub community_id: CommunityId,
+    /// Permanently reserved canonical host.
+    pub community_host: String,
+    /// Current lifecycle stage.
+    pub stage: DeletionStage,
+    /// Stage at which the current consecutive retry streak started.
+    pub retry_stage: Option<DeletionStage>,
+    /// Operator identity that submitted the request.
+    pub requested_by: String,
+    /// Optional request reason.
+    pub reason: Option<String>,
+    /// Frozen catalog manifest.
+    pub schema_manifest: Option<serde_json::Value>,
+    /// Frozen community-prefix storage manifest observed at submission.
+    pub storage_manifest: Option<serde_json::Value>,
+    /// Destructive storage manifest frozen after the durable fence.
+    pub destructive_storage_manifest: Option<serde_json::Value>,
+    /// Frozen inventory aggregate.
+    pub inventory_manifest: Option<serde_json::Value>,
+    /// Hex SHA-256 of the frozen inventory.
+    pub inventory_digest: Option<String>,
+    /// Durable community fence generation.
+    pub fence_generation: Option<i64>,
+    /// Current claim owner.
+    pub lease_owner: Option<String>,
+    /// Monotonic claim generation.
+    pub lease_generation: i64,
+    /// Claim expiry.
+    pub lease_until: Option<DateTime<Utc>>,
+    /// Number of claims.
+    pub attempts: i32,
+    /// Number of consecutive failed execution attempts at `retry_stage`.
+    pub retry_count: i32,
+    /// Last bounded error.
+    pub last_error: Option<String>,
+    /// Earliest time a transient failure may be claimed again.
+    pub next_attempt_at: DateTime<Utc>,
+    /// Permanent fail-closed block reason.
+    pub blocked_reason: Option<String>,
+    /// Submission time.
+    pub created_at: DateTime<Utc>,
+    /// Last lifecycle update.
+    pub updated_at: DateTime<Utc>,
+    /// Archive timestamp captured before quiescing changed serving state.
+    pub pre_quiesce_archived_at: Option<DateTime<Utc>>,
+    /// Whether the pre-quiesce archive value has been captured (including null).
+    pub quiescing_started_at: Option<DateTime<Utc>>,
+    /// Operator that terminally aborted the request.
+    pub aborted_by: Option<String>,
+    /// Reason recorded for terminal abort.
+    pub abort_reason: Option<String>,
+    /// Abort completion time.
+    pub aborted_at: Option<DateTime<Utc>>,
+    /// Terminal logical-deletion time.
+    pub completed_at: Option<DateTime<Utc>>,
+}
+
+/// Frozen PostgreSQL catalog inventory.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SchemaManifest {
+    /// Sorted community-scoped table names.
+    pub scoped_tables: Vec<String>,
+    /// Per-table row counts for the target.
+    pub row_counts: BTreeMap<String, i64>,
+    /// Sorted tables with the universal write-fence trigger.
+    pub fenced_tables: Vec<String>,
+}
+
+/// Frozen storage inventory supplied by the object-store adapter: slim
+/// per-prefix summaries for the target community. The concrete key list never
+/// lives on the request row — the destructive freeze persists it as chunked
+/// `community_deletion_manifest_keys` rows that must hash to these digests.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct StorageManifest {
+    /// Adapter schema version.
+    pub version: i32,
+    /// Per-prefix frozen summaries, strictly sorted by prefix.
+    pub prefixes: Vec<PrefixManifest>,
+}
+
+/// Frozen summary of one community-scoped key prefix.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct PrefixManifest {
+    /// Exact community-scoped listing prefix.
+    pub prefix: String,
+    /// Objects under the prefix at enumeration time.
+    pub object_count: u64,
+    /// Total object bytes under the prefix at enumeration time.
+    pub total_bytes: u64,
+    /// Hex SHA-256 of the newline-terminated ascending key stream.
+    pub keys_digest: String,
+}
+
+/// One frozen chunk of the destructive key list.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ManifestKeyChunk {
+    /// Position in the frozen chunk sequence.
+    pub chunk_no: i64,
+    /// The tenant prefix every key in this chunk lives under.
+    pub prefix: String,
+    /// Strictly ascending keys.
+    pub keys: Vec<String>,
+}
+
+/// One durable fleet-wide object-store taxonomy sweep record.
+#[derive(Debug, Clone, Serialize)]
+pub struct TaxonomySweep {
+    /// Sweep identity.
+    pub id: Uuid,
+    /// Listing start time.
+    pub started_at: DateTime<Utc>,
+    /// Record time.
+    pub completed_at: DateTime<Utc>,
+    /// Total objects listed.
+    pub listed_objects: i64,
+    /// Exact count of keys outside the known writer taxonomy.
+    pub unknown_object_count: i64,
+    /// Bounded sample of unknown keys.
+    pub unknown_key_sample: Vec<String>,
+    /// Fleet object cap the sweep ran under.
+    pub object_cap: i64,
+}
+
+type TaxonomySweepRow = (
+    Uuid,
+    DateTime<Utc>,
+    DateTime<Utc>,
+    i64,
+    i64,
+    sqlx::types::Json<Vec<String>>,
+    i64,
+);
+
+/// Streaming SHA-256 over a strictly ascending key stream.
+///
+/// The executor's prefix enumeration and the destructive freeze's chunk
+/// validation both fold keys through this, so "the chunk rows are exactly
+/// the frozen enumeration" reduces to digest equality. Each key is hashed
+/// with a trailing newline so concatenation cannot alias two streams.
+pub struct KeyStreamDigest {
+    hasher: Sha256,
+    last: Option<String>,
+    count: u64,
+}
+
+impl Default for KeyStreamDigest {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl KeyStreamDigest {
+    /// Start an empty stream.
+    pub fn new() -> Self {
+        Self {
+            hasher: Sha256::new(),
+            last: None,
+            count: 0,
+        }
+    }
+
+    /// Fold the next key. Keys must arrive strictly ascending — S3
+    /// `ListObjectsV2` order — so one out-of-order or duplicate key fails
+    /// closed instead of silently producing a different digest.
+    pub fn fold(&mut self, key: &str) -> Result<()> {
+        if self.last.as_deref().is_some_and(|last| last >= key) {
+            return Err(DbError::DeletionSafety(format!(
+                "storage key stream is not strictly ascending at {key}"
+            )));
+        }
+        self.hasher.update(key.as_bytes());
+        self.hasher.update(b"\n");
+        self.last = Some(key.to_owned());
+        self.count += 1;
+        Ok(())
+    }
+
+    /// Hex digest and key count of everything folded.
+    pub fn finish(self) -> (String, u64) {
+        (hex::encode(self.hasher.finalize()), self.count)
+    }
+}
+
+/// Full frozen inventory approved at the destructive boundary.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct FrozenInventory {
+    /// PostgreSQL catalog state.
+    pub schema: SchemaManifest,
+    /// Object-store state.
+    pub storage: StorageManifest,
+}
+
+impl FrozenInventory {
+    /// Canonical JSON bytes and SHA-256 digest used to bind approval.
+    pub fn digest(&self) -> Result<Vec<u8>> {
+        Ok(Sha256::digest(serde_json::to_vec(self)?).to_vec())
+    }
+}
+
+/// One durable unit checkpoint.
+#[derive(Debug, Clone, Serialize)]
+pub struct DeletionCheckpoint {
+    /// Stage containing the unit.
+    pub stage: String,
+    /// Stable unit key.
+    pub unit_key: String,
+    /// `started`, `completed`, or `failed`.
+    pub status: String,
+    /// Claim generation that last touched it.
+    pub lease_generation: i64,
+    /// Attempt count for this unit.
+    pub attempts: i32,
+    /// Structured bounded details.
+    pub detail: serde_json::Value,
+    /// Last failure.
+    pub error: Option<String>,
+    /// Start time.
+    pub started_at: DateTime<Utc>,
+    /// Completion time.
+    pub completed_at: Option<DateTime<Utc>>,
+}
+
+/// Full inspect response.
+#[derive(Debug, Clone, Serialize)]
+pub struct DeletionInspection {
+    /// Durable request.
+    pub request: DeletionRequest,
+    /// Explicit approval evidence, if present.
+    pub approval: Option<DeletionApproval>,
+    /// Unit checkpoints.
+    pub checkpoints: Vec<DeletionCheckpoint>,
+}
+
+/// Explicit approval evidence.
+#[derive(Debug, Clone, Serialize)]
+pub struct DeletionApproval {
+    /// Hex frozen inventory digest.
+    pub inventory_digest: String,
+    /// Approving operator identity.
+    pub approved_by: String,
+    /// Optional approval note.
+    pub note: Option<String>,
+    /// Approval timestamp.
+    pub approved_at: DateTime<Utc>,
+}
+
+/// Monotonic lease token required by every execution mutation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LeaseToken {
+    /// Request id.
+    pub request_id: Uuid,
+    /// Executor identity.
+    pub owner: String,
+    /// Monotonic lease generation.
+    pub generation: i64,
+    /// Target community.
+    pub community_id: CommunityId,
+    /// Community fence generation, once fenced.
+    pub fence_generation: Option<i64>,
+}
+
+/// A claimed request with its durable token.
+#[derive(Debug, Clone)]
+pub struct ClaimedDeletion {
+    /// Request snapshot.
+    pub request: DeletionRequest,
+    /// Required token.
+    pub lease: LeaseToken,
+}
+
+/// Short-lived durable lease for an external serving side effect.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ServingWriteLease {
+    /// Lease row identifier.
+    pub id: Uuid,
+    /// Community protected by this lease.
+    pub community_id: CommunityId,
+    /// Operation category for diagnostics.
+    pub operation: String,
+    /// Process/executor identity.
+    pub owner: String,
+    /// Monotonic lease generation.
+    pub generation: i64,
+    /// Community fence generation observed when the lease was acquired.
+    pub fence_generation: i64,
+    /// Lease expiry.
+    pub lease_until: DateTime<Utc>,
+}
+
+/// Validate the minimum catalog contract used by serving-path fences.
+pub const REQUIRED_SERVING_TABLES: &[&str] = &[
+    "communities",
+    "community_serving_write_leases",
+    "community_deletion_requests",
+];
+
+/// Bounded-cardinality operational snapshot for the hot serving-lease table.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ServingLeaseStats {
+    /// Unexpired serving-write leases.
+    pub active: i64,
+    /// Expired rows awaiting cleanup.
+    pub expired: i64,
+    /// PostgreSQL's estimated dead tuples for the lease table.
+    pub dead_tuples: i64,
+}
+
+/// PostgreSQL deletion adapter. Clone is cheap.
+#[derive(Clone)]
+pub struct DeletionStore {
+    pool: PgPool,
+}
+
+impl DeletionStore {
+    /// Construct from the writer pool used by [`crate::Db`].
+    pub(crate) fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+
+    /// Check deletion control-plane/schema connectivity.
+    ///
+    /// Probe the deployed catalog rather than SQLx's migration ledger. Buzz also
+    /// supports desired-state schema application through `pgschema`, which creates
+    /// the same deletion objects without creating `_sqlx_migrations`.
+    pub async fn ping(&self) -> bool {
+        sqlx::query_scalar::<_, bool>(
+            "SELECT to_regclass('community_deletion_requests') IS NOT NULL",
+        )
+        .fetch_one(&self.pool)
+        .await
+        .unwrap_or(false)
+    }
+
+    /// Persist a request. Only active non-tombstone communities may be submitted.
+    pub async fn submit(
+        &self,
+        community_host: &str,
+        requested_by: &str,
+        reason: Option<&str>,
+    ) -> Result<DeletionRequest> {
+        let row = sqlx::query(
+            r#"
+            WITH target AS (
+                SELECT id, host
+                FROM communities
+                WHERE lower(host) = lower($1)
+                  AND deletion_state = 'active'
+                  AND deleted_at IS NULL
+            ), inserted AS (
+                INSERT INTO community_deletion_requests
+                    (community_id, community_host, requested_by, reason)
+                SELECT id, host, $2, $3 FROM target
+                ON CONFLICT (community_id) WHERE stage <> 'aborted' DO NOTHING
+                RETURNING *
+            )
+            SELECT * FROM inserted
+            UNION ALL
+            SELECT request.*
+            FROM community_deletion_requests request
+            JOIN target ON target.id = request.community_id
+            WHERE request.stage = 'submitted'
+              AND request.requested_by = $2
+              AND NOT EXISTS (SELECT 1 FROM inserted)
+            LIMIT 1
+            "#,
+        )
+        .bind(community_host)
+        .bind(requested_by)
+        .bind(reason)
+        .fetch_optional(&self.pool)
+        .await?;
+        match row {
+            Some(row) => row_to_request(row),
+            None => Err(DbError::DeletionSafety(format!(
+                "community {community_host:?} is missing, already requested, fenced, or tombstoned"
+            ))),
+        }
+    }
+
+    /// List requests newest first with a hard bound.
+    pub async fn list(&self, limit: i64) -> Result<Vec<DeletionRequest>> {
+        let rows = sqlx::query(
+            "SELECT * FROM community_deletion_requests ORDER BY created_at DESC LIMIT $1",
+        )
+        .bind(limit.clamp(1, 1000))
+        .fetch_all(&self.pool)
+        .await?;
+        rows.into_iter().map(row_to_request).collect()
+    }
+
+    /// Read one request.
+    pub async fn get(&self, request_id: Uuid) -> Result<DeletionRequest> {
+        let row = sqlx::query("SELECT * FROM community_deletion_requests WHERE id = $1")
+            .bind(request_id)
+            .fetch_optional(&self.pool)
+            .await?
+            .ok_or_else(|| DbError::NotFound(format!("community deletion {request_id}")))?;
+        row_to_request(row)
+    }
+
+    /// Inspect request, approval, checkpoints, and retention holds.
+    pub async fn inspect(&self, request_id: Uuid) -> Result<DeletionInspection> {
+        let request = self.get(request_id).await?;
+        let approval_row = sqlx::query(
+            "SELECT inventory_digest, approved_by, note, approved_at \
+             FROM community_deletion_approvals WHERE request_id = $1",
+        )
+        .bind(request_id)
+        .fetch_optional(&self.pool)
+        .await?;
+        let approval = approval_row
+            .map(|row| {
+                Ok::<DeletionApproval, DbError>(DeletionApproval {
+                    inventory_digest: hex::encode(row.try_get::<Vec<u8>, _>("inventory_digest")?),
+                    approved_by: row.try_get("approved_by")?,
+                    note: row.try_get("note")?,
+                    approved_at: row.try_get("approved_at")?,
+                })
+            })
+            .transpose()?;
+        let checkpoints = sqlx::query(
+            "SELECT stage, unit_key, status, lease_generation, attempts, detail, error, \
+                    started_at, completed_at \
+             FROM community_deletion_checkpoints WHERE request_id = $1 ORDER BY sequence",
+        )
+        .bind(request_id)
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .map(|row| {
+            Ok(DeletionCheckpoint {
+                stage: row.try_get("stage")?,
+                unit_key: row.try_get("unit_key")?,
+                status: row.try_get("status")?,
+                lease_generation: row.try_get("lease_generation")?,
+                attempts: row.try_get("attempts")?,
+                detail: row.try_get("detail")?,
+                error: row.try_get("error")?,
+                started_at: row.try_get("started_at")?,
+                completed_at: row.try_get("completed_at")?,
+            })
+        })
+        .collect::<Result<Vec<_>>>()?;
+        Ok(DeletionInspection {
+            request,
+            approval,
+            checkpoints,
+        })
+    }
+
+    /// Validate the deletion catalog contract required by relay serving.
+    pub async fn validate_serving_catalog(&self) -> Result<()> {
+        let runtime_columns = sqlx::query(
+            "SELECT attname, format_type(atttypid, atttypmod) AS type_name, attnotnull \
+             FROM pg_attribute WHERE attrelid = 'communities'::regclass \
+               AND attname IN ('deletion_state', 'deletion_fence_generation', 'deleted_at') \
+               AND NOT attisdropped ORDER BY attname",
+        )
+        .fetch_all(&self.pool)
+        .await?;
+        let column_contract = runtime_columns
+            .iter()
+            .map(|row| {
+                Ok::<_, DbError>((
+                    row.try_get::<String, _>("attname")?,
+                    row.try_get::<String, _>("type_name")?,
+                    row.try_get::<bool, _>("attnotnull")?,
+                ))
+            })
+            .collect::<Result<BTreeSet<_>>>()?;
+        let expected_columns = BTreeSet::from([
+            (
+                "deleted_at".to_string(),
+                "timestamp with time zone".to_string(),
+                false,
+            ),
+            (
+                "deletion_fence_generation".to_string(),
+                "bigint".to_string(),
+                true,
+            ),
+            ("deletion_state".to_string(), "text".to_string(), true),
+        ]);
+        if column_contract != expected_columns {
+            return Err(DbError::DeletionSafety(
+                "community serving fence columns are missing or incompatible".to_string(),
+            ));
+        }
+
+        let required_tables = REQUIRED_SERVING_TABLES
+            .iter()
+            .copied()
+            .map(str::to_owned)
+            .collect::<BTreeSet<_>>();
+        let required_table_names = REQUIRED_SERVING_TABLES
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>();
+        let live_tables: BTreeSet<String> = sqlx::query_scalar(
+            "SELECT table_name FROM information_schema.tables \
+             WHERE table_schema = 'public' AND table_name = ANY($1) \
+             ORDER BY table_name",
+        )
+        .bind(&required_table_names)
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .collect();
+        if live_tables != required_tables {
+            return Err(DbError::DeletionSafety(format!(
+                "community serving fence tables missing: {}",
+                required_tables
+                    .difference(&live_tables)
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .join(",")
+            )));
+        }
+
+        let required_fences = EXPECTED_SCOPED_TABLES
+            .iter()
+            .copied()
+            .map(str::to_owned)
+            .collect::<BTreeSet<_>>();
+        let live_fences = self.live_fenced_tables().await?;
+        let missing_fences = required_fences
+            .difference(&live_fences)
+            .cloned()
+            .collect::<Vec<_>>();
+        if !missing_fences.is_empty() {
+            return Err(DbError::DeletionSafety(format!(
+                "community serving write fences missing: {}",
+                missing_fences.join(",")
+            )));
+        }
+
+        let required_objects_present: bool = sqlx::query_scalar(
+            "SELECT to_regprocedure('community_deletion_lock_key(uuid)') IS NOT NULL \
+                AND to_regprocedure('community_write_allowed(uuid)') IS NOT NULL \
+                AND (SELECT provolatile = 'v' FROM pg_proc \
+                     WHERE oid = 'community_write_allowed(uuid)'::regprocedure) \
+                AND to_regprocedure('assert_community_write_allowed(uuid)') IS NOT NULL \
+                AND to_regprocedure('enforce_community_write_fence()') IS NOT NULL \
+                AND EXISTS (SELECT 1 FROM pg_trigger t \
+                    JOIN pg_class c ON c.oid = t.tgrelid \
+                    JOIN pg_proc p ON p.oid = t.tgfoid \
+                    WHERE c.relname = 'communities' \
+                      AND p.proname = 'enforce_community_tombstone' \
+                      AND NOT t.tgisinternal AND t.tgenabled = 'O')",
+        )
+        .fetch_one(&self.pool)
+        .await?;
+        if !required_objects_present {
+            return Err(DbError::DeletionSafety(
+                "community serving fence functions or tombstone trigger are missing".to_string(),
+            ));
+        }
+        Ok(())
+    }
+
+    /// Validate the exact live scoped-table and write-fence catalog for destruction.
+    ///
+    /// Exact table and fence equality rejects unknown tenant data even
+    /// while unrelated SQLx migrations continue to advance. This pool-based
+    /// check is an early rejection only; destructive transactions revalidate
+    /// on their own connection under [`SCHEMA_DESTRUCTION_LOCK_KEY`].
+    pub async fn validate_catalog(&self) -> Result<()> {
+        let mut conn = self.pool.acquire().await?;
+        validate_catalog_on(&mut conn).await
+    }
+
+    /// Build and validate a live PostgreSQL schema inventory.
+    ///
+    /// Row counts are observational evidence captured at submission. They bind
+    /// operator approval to the target's visible PostgreSQL footprint, but the
+    /// executor still revalidates the structural catalog and proves zero rows
+    /// after purge rather than requiring these live counts to remain unchanged.
+    pub async fn inventory_schema(&self, community: CommunityId) -> Result<SchemaManifest> {
+        self.validate_catalog().await?;
+        let live_tables = self.live_scoped_tables().await?;
+        let fenced_tables = self.live_fenced_tables().await?;
+        let mut row_counts = BTreeMap::new();
+        for table in &live_tables {
+            let sql = format!("SELECT count(*)::BIGINT FROM {table} WHERE community_id = $1");
+            let count: i64 = sqlx::query_scalar(AssertSqlSafe(sql))
+                .bind(community.as_uuid())
+                .fetch_one(&self.pool)
+                .await?;
+            row_counts.insert(table.clone(), count);
+        }
+        Ok(SchemaManifest {
+            scoped_tables: live_tables.into_iter().collect(),
+            row_counts,
+            fenced_tables: fenced_tables.into_iter().collect(),
+        })
+    }
+
+    /// Freeze inventory and move submitted → inventoried atomically.
+    pub async fn freeze_inventory(
+        &self,
+        request_id: Uuid,
+        inventory: &FrozenInventory,
+    ) -> Result<DeletionRequest> {
+        validate_storage_manifest(&inventory.storage)?;
+        let digest = inventory.digest()?;
+        let schema = serde_json::to_value(&inventory.schema)?;
+        let storage = serde_json::to_value(&inventory.storage)?;
+        let frozen = serde_json::to_value(inventory)?;
+        let row = sqlx::query(
+            r#"
+            UPDATE community_deletion_requests
+            SET stage = 'inventoried', schema_manifest = $2, storage_manifest = $3,
+                inventory_manifest = $4, inventory_digest = $5,
+                inventory_frozen_at = now(), updated_at = now(),
+                last_error = NULL, last_error_at = NULL
+            WHERE id = $1 AND stage = 'submitted' AND blocked_at IS NULL
+            RETURNING *
+            "#,
+        )
+        .bind(request_id)
+        .bind(schema)
+        .bind(storage)
+        .bind(frozen)
+        .bind(digest)
+        .fetch_optional(&self.pool)
+        .await?
+        .ok_or_else(|| {
+            DbError::DeletionSafety(format!(
+                "deletion {request_id} is not an unblocked submitted request"
+            ))
+        })?;
+        row_to_request(row)
+    }
+
+    /// Approve the exact frozen inventory and move inventoried → approved.
+    pub async fn approve(
+        &self,
+        request_id: Uuid,
+        approved_by: &str,
+        note: Option<&str>,
+    ) -> Result<DeletionRequest> {
+        let mut tx = self.pool.begin().await?;
+        let (community_id, digest, inventory_manifest): (Uuid, Vec<u8>, serde_json::Value) =
+            sqlx::query_as(
+                "SELECT community_id, inventory_digest, inventory_manifest \
+                 FROM community_deletion_requests \
+                 WHERE id = $1 AND stage = 'inventoried' AND blocked_at IS NULL FOR UPDATE",
+            )
+            .bind(request_id)
+            .fetch_optional(&mut *tx)
+            .await?
+            .ok_or_else(|| {
+                DbError::DeletionSafety(format!(
+                    "deletion {request_id} is not an unblocked inventoried request"
+                ))
+            })?;
+        let inventory: FrozenInventory = serde_json::from_value(inventory_manifest)?;
+        let recomputed_digest = inventory.digest()?;
+        if digest.as_slice() != recomputed_digest {
+            return Err(DbError::DeletionSafety(format!(
+                "deletion {request_id} frozen inventory digest does not match its manifest"
+            )));
+        }
+        sqlx::query(
+            "INSERT INTO community_deletion_approvals \
+             (request_id, community_id, inventory_digest, approved_by, note) \
+             VALUES ($1, $2, $3, $4, $5)",
+        )
+        .bind(request_id)
+        .bind(community_id)
+        .bind(&digest)
+        .bind(approved_by)
+        .bind(note)
+        .execute(&mut *tx)
+        .await?;
+        let row = sqlx::query(
+            "UPDATE community_deletion_requests \
+             SET stage = 'approved', updated_at = now(), next_attempt_at = now() \
+             WHERE id = $1 AND stage = 'inventoried' AND blocked_at IS NULL \
+             RETURNING *",
+        )
+        .bind(request_id)
+        .fetch_optional(&mut *tx)
+        .await?
+        .ok_or_else(|| {
+            DbError::DeletionSafety(format!(
+                "deletion {request_id} changed before approval could be recorded"
+            ))
+        })?;
+        tx.commit().await?;
+        row_to_request(row)
+    }
+
+    /// Claim a specific runnable request. Expired claims may be reclaimed.
+    pub async fn claim_specific(
+        &self,
+        request_id: Uuid,
+        owner: &str,
+        lease_duration: Duration,
+    ) -> Result<Option<ClaimedDeletion>> {
+        self.claim(Some(request_id), owner, lease_duration).await
+    }
+
+    /// Claim the oldest runnable request. Expired claims may be reclaimed.
+    pub async fn claim_next(
+        &self,
+        owner: &str,
+        lease_duration: Duration,
+    ) -> Result<Option<ClaimedDeletion>> {
+        self.claim(None, owner, lease_duration).await
+    }
+
+    async fn claim(
+        &self,
+        request_id: Option<Uuid>,
+        owner: &str,
+        lease_duration: Duration,
+    ) -> Result<Option<ClaimedDeletion>> {
+        let lease_seconds = i64::try_from(lease_duration.as_secs()).unwrap_or(i64::MAX);
+        let mut tx = self.pool.begin().await?;
+        let candidate = sqlx::query(
+            r#"SELECT request.* FROM community_deletion_requests request
+            JOIN community_deletion_approvals approval ON approval.request_id = request.id
+             AND approval.community_id = request.community_id
+             AND approval.inventory_digest = request.inventory_digest
+            WHERE ($1::uuid IS NULL OR request.id = $1)
+              AND request.stage IN ('approved', 'fenced', 'drained', 'bindings_removed',
+                                    'postgres_purged', 'cache_purged', 'logically_verified')
+              AND request.blocked_at IS NULL AND request.next_attempt_at <= now()
+              AND (request.lease_until IS NULL OR request.lease_until < now())
+            ORDER BY request.created_at, request.id
+            FOR UPDATE OF request SKIP LOCKED LIMIT 1"#,
+        )
+        .bind(request_id)
+        .fetch_optional(&mut *tx)
+        .await?;
+        let Some(candidate_row) = candidate else {
+            tx.commit().await?;
+            return Ok(None);
+        };
+        let candidate = row_to_request(candidate_row)?;
+        if let Err(error) = validate_catalog_on(&mut tx).await {
+            let message = bound_text(&error.to_string(), 4096);
+            sqlx::query(
+                r#"INSERT INTO community_deletion_checkpoints
+                    (request_id, stage, unit_key, status, lease_generation, error)
+                VALUES ($1, $2, 'claim:catalog_validation', 'failed', $3, $4)
+                ON CONFLICT (request_id, stage, unit_key) DO UPDATE
+                SET status = 'failed', lease_generation = EXCLUDED.lease_generation,
+                    attempts = community_deletion_checkpoints.attempts + 1,
+                    error = EXCLUDED.error, completed_at = NULL"#,
+            )
+            .bind(candidate.id)
+            .bind(candidate.stage.to_string())
+            .bind(candidate.lease_generation.max(1))
+            .bind(&message)
+            .execute(&mut *tx)
+            .await?;
+            sqlx::query(
+                "UPDATE community_deletion_requests SET blocked_at = now(), blocked_reason = $2, \
+                 last_error = $2, last_error_at = now(), lease_owner = NULL, lease_until = NULL, \
+                 updated_at = now() WHERE id = $1",
+            )
+            .bind(candidate.id)
+            .bind(&message)
+            .execute(&mut *tx)
+            .await?;
+            tx.commit().await?;
+            return Ok(None);
+        }
+        let row = sqlx::query(
+            "UPDATE community_deletion_requests SET lease_owner = $2, \
+             lease_generation = lease_generation + 1, \
+             lease_until = now() + make_interval(secs => $3), attempts = attempts + 1, \
+             updated_at = now() WHERE id = $1 RETURNING *",
+        )
+        .bind(candidate.id)
+        .bind(owner)
+        .bind(lease_seconds)
+        .fetch_one(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        let request = row_to_request(row)?;
+        let lease = LeaseToken {
+            request_id: request.id,
+            owner: owner.to_owned(),
+            generation: request.lease_generation,
+            community_id: request.community_id,
+            fence_generation: request.fence_generation,
+        };
+        Ok(Some(ClaimedDeletion { request, lease }))
+    }
+
+    /// Verify that a deletion lease/fence token is still current for a stage.
+    pub async fn verify_execution_token(
+        &self,
+        token: &LeaseToken,
+        stage: DeletionStage,
+    ) -> Result<()> {
+        let mut tx = self.pool.begin().await?;
+        if let Some(generation) = token.fence_generation {
+            verify_lease_and_fence(&mut tx, token, stage, generation).await?;
+        } else {
+            verify_lease(&mut tx, token, stage).await?;
+        }
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Renew an owned claim and persist executor liveness.
+    pub async fn heartbeat(
+        &self,
+        token: &LeaseToken,
+        executor_mode: &str,
+        lease_duration: Duration,
+        draining: bool,
+    ) -> Result<()> {
+        let lease_seconds = i64::try_from(lease_duration.as_secs()).unwrap_or(i64::MAX);
+        let mut tx = self.pool.begin().await?;
+        let affected = sqlx::query(
+            "UPDATE community_deletion_requests request \
+             SET lease_until = now() + make_interval(secs => $4), updated_at = now() \
+             WHERE request.id = $1 AND request.lease_owner = $2 \
+               AND request.lease_generation = $3 AND request.lease_until >= now() \
+               AND request.blocked_at IS NULL \
+               AND request.stage IN ('approved', 'fenced', 'drained', 'bindings_removed', \
+                                      'postgres_purged', 'cache_purged', 'logically_verified') \
+               AND EXISTS (SELECT 1 FROM community_deletion_approvals approval \
+                   WHERE approval.request_id = request.id \
+                     AND approval.community_id = request.community_id \
+                     AND approval.inventory_digest = request.inventory_digest)",
+        )
+        .bind(token.request_id)
+        .bind(&token.owner)
+        .bind(token.generation)
+        .bind(lease_seconds)
+        .execute(&mut *tx)
+        .await?
+        .rows_affected();
+        if affected != 1 {
+            return Err(stale_lease_error(token));
+        }
+        sqlx::query(
+            "INSERT INTO community_deletion_executor_heartbeats \
+             (executor_id, mode, request_id, draining) VALUES ($1, $2, $3, $4) \
+             ON CONFLICT (executor_id) DO UPDATE SET mode = EXCLUDED.mode, \
+                 request_id = EXCLUDED.request_id, heartbeat_at = now(), \
+                 draining = EXCLUDED.draining, stopped_at = NULL",
+        )
+        .bind(&token.owner)
+        .bind(executor_mode)
+        .bind(token.request_id)
+        .bind(draining)
+        .execute(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Mark an executor stopped and release its current claim if still owned.
+    pub async fn stop_executor(&self, token: Option<&LeaseToken>, executor_id: &str) -> Result<()> {
+        let mut tx = self.pool.begin().await?;
+        if let Some(token) = token {
+            sqlx::query(
+                "UPDATE community_deletion_requests \
+                 SET lease_owner = NULL, lease_until = NULL, updated_at = now() \
+                 WHERE id = $1 AND lease_owner = $2 AND lease_generation = $3",
+            )
+            .bind(token.request_id)
+            .bind(&token.owner)
+            .bind(token.generation)
+            .execute(&mut *tx)
+            .await?;
+        }
+        sqlx::query(
+            "UPDATE community_deletion_executor_heartbeats \
+             SET request_id = NULL, draining = true, heartbeat_at = now(), stopped_at = now() \
+             WHERE executor_id = $1",
+        )
+        .bind(executor_id)
+        .execute(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Persist quiescing intent before waiting for active serving leases.
+    ///
+    /// This is the irreversible fail-closed point: a request intentionally has
+    /// no automatic unquiesce/unblock transition after operator approval.
+    ///
+    /// The transition takes the same exclusive advisory lock as serving lease
+    /// acquisition, so after commit no newer external effect can be admitted.
+    /// Already-acquired leases remain renewable, verifiable, and releasable so
+    /// admitted remote effects retain their exclusion proof until completion.
+    pub async fn begin_quiescing(&self, token: &LeaseToken) -> Result<()> {
+        let mut tx = self.pool.begin().await?;
+        verify_lease(&mut tx, token, DeletionStage::Approved).await?;
+        sqlx::query("SELECT pg_advisory_xact_lock(community_deletion_lock_key($1))")
+            .bind(token.community_id.as_uuid())
+            .execute(&mut *tx)
+            .await?;
+        verify_lease(&mut tx, token, DeletionStage::Approved).await?;
+        let (generation, archived_at): (i64, Option<DateTime<Utc>>) = sqlx::query_as(
+            "SELECT deletion_fence_generation, archived_at FROM communities WHERE id = $1 FOR UPDATE",
+        )
+        .bind(token.community_id.as_uuid())
+        .fetch_one(&mut *tx)
+        .await?;
+        sqlx::query(
+            "UPDATE community_deletion_requests SET pre_quiesce_archived_at = $2, \
+                    quiescing_started_at = now(), updated_at = now() \
+             WHERE id = $1 AND quiescing_started_at IS NULL",
+        )
+        .bind(token.request_id)
+        .bind(archived_at)
+        .execute(&mut *tx)
+        .await?;
+        set_executor_gucs(&mut tx, token.community_id, generation).await?;
+        let affected = sqlx::query(
+            "UPDATE communities SET deletion_state = 'quiescing', \
+                    archived_at = COALESCE(archived_at, now()) \
+             WHERE id = $1 AND deletion_state IN ('active', 'quiescing') \
+               AND deleted_at IS NULL",
+        )
+        .bind(token.community_id.as_uuid())
+        .execute(&mut *tx)
+        .await?
+        .rows_affected();
+        if affected != 1 {
+            return Err(DbError::DeletionSafety(format!(
+                "community {} cannot enter quiescing",
+                token.community_id
+            )));
+        }
+        checkpoint_completed_tx(
+            &mut tx,
+            token,
+            DeletionStage::Approved,
+            "quiesce_serving_writes",
+            serde_json::json!({"community_state": "quiescing"}),
+        )
+        .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Acquire the universal durable fence after all pre-quiesce serving leases drain.
+    pub async fn fence(&self, token: &LeaseToken) -> Result<i64> {
+        let mut tx = self.pool.begin().await?;
+        verify_lease(&mut tx, token, DeletionStage::Approved).await?;
+        sqlx::query("SELECT pg_advisory_xact_lock(community_deletion_lock_key($1))")
+            .bind(token.community_id.as_uuid())
+            .execute(&mut *tx)
+            .await?;
+        verify_lease(&mut tx, token, DeletionStage::Approved).await?;
+        let active_serving_writes = sqlx::query(
+            "SELECT count(*)::BIGINT AS active_count, \
+                    COALESCE(array_agg(DISTINCT operation ORDER BY operation), ARRAY[]::TEXT[]) AS operations \
+             FROM community_serving_write_leases \
+             WHERE community_id = $1 AND lease_until >= now()",
+        )
+        .bind(token.community_id.as_uuid())
+        .fetch_one(&mut *tx)
+        .await?;
+        let active_count: i64 = active_serving_writes.try_get("active_count")?;
+        if active_count > 0 {
+            return Err(DbError::ServingWritesNotDrained {
+                community_id: *token.community_id.as_uuid(),
+                active_count,
+                operations: active_serving_writes.try_get("operations")?,
+            });
+        }
+        let current_generation: i64 = sqlx::query_scalar(
+            "SELECT deletion_fence_generation FROM communities WHERE id = $1 FOR UPDATE",
+        )
+        .bind(token.community_id.as_uuid())
+        .fetch_one(&mut *tx)
+        .await?;
+        let generation = current_generation.checked_add(1).ok_or_else(|| {
+            DbError::DeletionSafety("community deletion fence generation overflow".to_string())
+        })?;
+        set_executor_gucs(&mut tx, token.community_id, generation).await?;
+        let affected = sqlx::query(
+            "UPDATE communities SET deletion_state = 'fenced', \
+                    deletion_fence_generation = $2, archived_at = COALESCE(archived_at, now()) \
+             WHERE id = $1 AND deletion_state = 'quiescing'",
+        )
+        .bind(token.community_id.as_uuid())
+        .bind(generation)
+        .execute(&mut *tx)
+        .await?
+        .rows_affected();
+        if affected != 1 {
+            return Err(DbError::DeletionSafety(format!(
+                "community {} is no longer quiescing while fencing",
+                token.community_id
+            )));
+        }
+        advance_request_tx(
+            &mut tx,
+            token,
+            DeletionStage::Approved,
+            DeletionStage::Fenced,
+            Some(generation),
+        )
+        .await?;
+        checkpoint_completed_tx(
+            &mut tx,
+            token,
+            DeletionStage::Approved,
+            "activate_fence",
+            serde_json::json!({"fence_generation": generation}),
+        )
+        .await?;
+        tx.commit().await?;
+        Ok(generation)
+    }
+
+    /// Freeze the exact post-fence storage binding manifest.
+    pub async fn freeze_destructive_storage_manifest(
+        &self,
+        token: &LeaseToken,
+        manifest: &StorageManifest,
+    ) -> Result<()> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        // Serialize the freeze boundary with chunk INSERTs. The database trigger
+        // takes the same request-row lock before admitting each new chunk.
+        sqlx::query("SELECT id FROM community_deletion_requests WHERE id = $1 FOR UPDATE")
+            .bind(token.request_id)
+            .fetch_optional(&mut *tx)
+            .await?
+            .ok_or_else(|| {
+                DbError::DeletionSafety(format!(
+                    "deletion request {} disappeared before manifest freeze",
+                    token.request_id
+                ))
+            })?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::Fenced, generation).await?;
+        validate_storage_manifest(manifest)?;
+        // The chunk rows are the concrete delete list; the freeze commits only
+        // if they hash to the manifest's frozen per-prefix digests. Loading the
+        // full chunk stream is a one-time freeze-boundary cost proportional to
+        // this community's bindings, never the fleet bucket.
+        let chunks: Vec<(i64, String, sqlx::types::Json<Vec<String>>)> = sqlx::query_as(
+            "SELECT chunk_no, prefix, keys FROM community_deletion_manifest_keys \
+             WHERE request_id = $1 ORDER BY chunk_no",
+        )
+        .bind(token.request_id)
+        .fetch_all(&mut *tx)
+        .await?;
+        validate_manifest_key_chunks(manifest, &chunks)?;
+        let affected = sqlx::query(
+            "UPDATE community_deletion_requests \
+             SET destructive_storage_manifest = COALESCE(destructive_storage_manifest, $4), \
+                 destructive_storage_frozen_at = COALESCE(destructive_storage_frozen_at, now()), \
+                 updated_at = now() \
+             WHERE id = $1 AND lease_owner = $2 AND lease_generation = $3 \
+               AND stage = 'fenced' \
+               AND (destructive_storage_manifest IS NULL \
+                    OR destructive_storage_manifest = $4) \
+             RETURNING id",
+        )
+        .bind(token.request_id)
+        .bind(&token.owner)
+        .bind(token.generation)
+        .bind(serde_json::to_value(manifest)?)
+        .fetch_optional(&mut *tx)
+        .await?;
+        if affected.is_none() {
+            return Err(DbError::DeletionSafety(format!(
+                "destructive storage manifest changed or deletion lease is stale for request {}",
+                token.request_id
+            )));
+        }
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Remove key chunks left by an interrupted destructive freeze.
+    ///
+    /// The chunk-table guard rejects this once the destructive manifest has
+    /// frozen, so a retried freeze can only rewrite chunks that were never
+    /// bound to a committed manifest.
+    pub async fn clear_manifest_key_chunks(&self, token: &LeaseToken) -> Result<()> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::Fenced, generation).await?;
+        sqlx::query("DELETE FROM community_deletion_manifest_keys WHERE request_id = $1")
+            .bind(token.request_id)
+            .execute(&mut *tx)
+            .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Append one immutable chunk of the destructive key list.
+    pub async fn append_manifest_key_chunk(
+        &self,
+        token: &LeaseToken,
+        chunk_no: i64,
+        prefix: &str,
+        keys: &[String],
+    ) -> Result<()> {
+        if keys.is_empty() {
+            return Err(DbError::DeletionSafety(
+                "refusing to persist an empty manifest key chunk".to_string(),
+            ));
+        }
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::Fenced, generation).await?;
+        sqlx::query(
+            "INSERT INTO community_deletion_manifest_keys \
+             (request_id, chunk_no, prefix, keys) VALUES ($1, $2, $3, $4)",
+        )
+        .bind(token.request_id)
+        .bind(chunk_no)
+        .bind(prefix)
+        .bind(sqlx::types::Json(keys))
+        .execute(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Return the next frozen chunk not yet confirmed deleted, in chunk order.
+    pub async fn next_pending_manifest_chunk(
+        &self,
+        token: &LeaseToken,
+    ) -> Result<Option<ManifestKeyChunk>> {
+        let row: Option<(i64, String, sqlx::types::Json<Vec<String>>)> = sqlx::query_as(
+            "SELECT chunk_no, prefix, keys FROM community_deletion_manifest_keys \
+             WHERE request_id = $1 AND deleted_at IS NULL ORDER BY chunk_no LIMIT 1",
+        )
+        .bind(token.request_id)
+        .fetch_optional(&self.pool)
+        .await?;
+        Ok(row.map(|(chunk_no, prefix, keys)| ManifestKeyChunk {
+            chunk_no,
+            prefix,
+            keys: keys.0,
+        }))
+    }
+
+    /// Return `(total, deleted)` chunk counts for one request.
+    pub async fn manifest_chunk_progress(&self, request_id: Uuid) -> Result<(i64, i64)> {
+        sqlx::query_as(
+            "SELECT count(*), count(deleted_at) FROM community_deletion_manifest_keys \
+             WHERE request_id = $1",
+        )
+        .bind(request_id)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(Into::into)
+    }
+
+    /// Stamp one chunk's keys durably removed and checkpoint it atomically.
+    pub async fn mark_manifest_chunk_deleted(
+        &self,
+        token: &LeaseToken,
+        chunk_no: i64,
+        detail: serde_json::Value,
+    ) -> Result<()> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::Drained, generation).await?;
+        let affected = sqlx::query(
+            "UPDATE community_deletion_manifest_keys SET deleted_at = now() \
+             WHERE request_id = $1 AND chunk_no = $2 AND deleted_at IS NULL",
+        )
+        .bind(token.request_id)
+        .bind(chunk_no)
+        .execute(&mut *tx)
+        .await?
+        .rows_affected();
+        if affected != 1 {
+            return Err(DbError::DeletionSafety(format!(
+                "manifest key chunk {chunk_no} is missing or already stamped for request {}",
+                token.request_id
+            )));
+        }
+        checkpoint_completed_tx(
+            &mut tx,
+            token,
+            DeletionStage::Drained,
+            &format!("chunk:{chunk_no}"),
+            detail,
+        )
+        .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Record one completed fleet-wide taxonomy sweep.
+    pub async fn record_taxonomy_sweep(
+        &self,
+        started_at: DateTime<Utc>,
+        listed_objects: u64,
+        unknown_object_count: u64,
+        unknown_key_sample: &[String],
+        object_cap: u64,
+    ) -> Result<TaxonomySweep> {
+        let listed = i64::try_from(listed_objects)
+            .map_err(|_| DbError::DeletionSafety("sweep object count overflow".to_string()))?;
+        let unknown = i64::try_from(unknown_object_count)
+            .map_err(|_| DbError::DeletionSafety("sweep unknown count overflow".to_string()))?;
+        let cap = i64::try_from(object_cap)
+            .map_err(|_| DbError::DeletionSafety("sweep object cap overflow".to_string()))?;
+        // Completion is authoritative database time. Small positive sweeper
+        // skew is clamped at that boundary; materially future starts are rejected.
+        let row: Option<(Uuid, DateTime<Utc>, DateTime<Utc>)> = sqlx::query_as(
+            "INSERT INTO storage_taxonomy_sweeps \
+             (started_at, completed_at, listed_objects, unknown_object_count, \
+              unknown_key_sample, object_cap) \
+             SELECT LEAST($1, db_now), db_now, $2, $3, $4, $5 \
+             FROM (SELECT clock_timestamp() AS db_now) clock \
+             WHERE $1 <= db_now + interval '5 minutes' \
+             RETURNING id, started_at, completed_at",
+        )
+        .bind(started_at)
+        .bind(listed)
+        .bind(unknown)
+        .bind(sqlx::types::Json(unknown_key_sample))
+        .bind(cap)
+        .fetch_optional(&self.pool)
+        .await?;
+        let (id, started_at, completed_at) = row.ok_or_else(|| {
+            DbError::DeletionSafety(
+                "taxonomy sweep start time is more than five minutes in the future".to_string(),
+            )
+        })?;
+        Ok(TaxonomySweep {
+            id,
+            started_at,
+            completed_at,
+            listed_objects: listed,
+            unknown_object_count: unknown,
+            unknown_key_sample: unknown_key_sample.to_vec(),
+            object_cap: cap,
+        })
+    }
+
+    /// Return the most recently completed taxonomy sweep, if any.
+    pub async fn latest_taxonomy_sweep(&self) -> Result<Option<TaxonomySweep>> {
+        let row: Option<TaxonomySweepRow> = sqlx::query_as(
+            "SELECT id, started_at, completed_at, listed_objects, unknown_object_count, \
+                    unknown_key_sample, object_cap \
+             FROM storage_taxonomy_sweeps ORDER BY completed_at DESC LIMIT 1",
+        )
+        .fetch_optional(&self.pool)
+        .await?;
+        Ok(row.map(
+            |(id, started_at, completed_at, listed, unknown, sample, cap)| TaxonomySweep {
+                id,
+                started_at,
+                completed_at,
+                listed_objects: listed,
+                unknown_object_count: unknown,
+                unknown_key_sample: sample.0,
+                object_cap: cap,
+            },
+        ))
+    }
+
+    /// Return whether all pre-fence external side-effect leases have expired or released.
+    pub async fn serving_writes_drained(&self, community: CommunityId) -> Result<bool> {
+        sqlx::query_scalar(
+            "SELECT NOT EXISTS(SELECT 1 FROM community_serving_write_leases \
+             WHERE community_id = $1 AND lease_until >= now())",
+        )
+        .bind(community.as_uuid())
+        .fetch_one(&self.pool)
+        .await
+        .map_err(Into::into)
+    }
+
+    /// Verify fence ownership and record that serving writes drained.
+    pub async fn mark_drained(&self, token: &LeaseToken) -> Result<()> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::Fenced, generation).await?;
+        let active_serving_writes: bool = sqlx::query_scalar(
+            "SELECT EXISTS(SELECT 1 FROM community_serving_write_leases \
+             WHERE community_id = $1 AND lease_until >= now())",
+        )
+        .bind(token.community_id.as_uuid())
+        .fetch_one(&mut *tx)
+        .await?;
+        if active_serving_writes {
+            return Err(DbError::DeletionSafety(
+                "serving writes have not drained".to_string(),
+            ));
+        }
+        advance_request_tx(
+            &mut tx,
+            token,
+            DeletionStage::Fenced,
+            DeletionStage::Drained,
+            Some(generation),
+        )
+        .await?;
+        checkpoint_completed_tx(
+            &mut tx,
+            token,
+            DeletionStage::Fenced,
+            "serving_writes_drained",
+            serde_json::json!({"fence_generation": generation}),
+        )
+        .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Mark storage binding removal after adapter verification.
+    pub async fn mark_bindings_removed(
+        &self,
+        token: &LeaseToken,
+        detail: serde_json::Value,
+    ) -> Result<()> {
+        self.advance_with_checkpoint(
+            token,
+            DeletionStage::Drained,
+            DeletionStage::BindingsRemoved,
+            "remove_storage_bindings",
+            detail,
+        )
+        .await
+    }
+
+    /// Purge every scoped PostgreSQL table, preserve the community tombstone, and
+    /// move bindings_removed → postgres_purged in one transaction.
+    pub async fn purge_postgres(&self, token: &LeaseToken) -> Result<BTreeMap<String, u64>> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        // Revalidate the exact catalog inside the purge transaction under the
+        // shared schema/destruction lock. Migrations hold the exclusive
+        // counterpart for their entire run, so no migration can commit a new
+        // scoped table between this validation and the purge commit.
+        lock_schema_destruction_shared(&mut tx).await?;
+        validate_catalog_on(&mut tx).await?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::BindingsRemoved, generation).await?;
+        set_executor_gucs(&mut tx, token.community_id, generation).await?;
+        // Migration 0011 fences hard deletion of NIP-RS rows against legacy
+        // writers. Whole-community deletion is an intentional hard-delete path,
+        // and the transaction is already bound to an approved, fenced tenant.
+        sqlx::query("SELECT set_config('buzz.nip_rs_hard_delete', 'on', true)")
+            .execute(&mut *tx)
+            .await?;
+
+        // Preserve deployment-global operator evidence while severing tenant provenance.
+        for table in ["product_feedback", "rate_limit_violations"] {
+            let sql = format!("UPDATE {table} SET community_id = NULL WHERE community_id = $1");
+            let affected = sqlx::query(AssertSqlSafe(sql))
+                .bind(token.community_id.as_uuid())
+                .execute(&mut *tx)
+                .await?
+                .rows_affected();
+            checkpoint_completed_tx(
+                &mut tx,
+                token,
+                DeletionStage::BindingsRemoved,
+                &format!("clear_provenance:{table}"),
+                serde_json::json!({"rows": affected}),
+            )
+            .await?;
+        }
+
+        let mut deleted = BTreeMap::new();
+        // The order is child-before-parent/FK-safe, not alphabetical. Cascades
+        // can make later units observe zero rows; each scoped WHERE stays idempotent.
+        for table in PURGE_SCOPED_TABLES {
+            let sql = format!("DELETE FROM {table} WHERE community_id = $1");
+            let affected = sqlx::query(AssertSqlSafe(sql))
+                .bind(token.community_id.as_uuid())
+                .execute(&mut *tx)
+                .await?
+                .rows_affected();
+            deleted.insert((*table).to_owned(), affected);
+            checkpoint_completed_tx(
+                &mut tx,
+                token,
+                DeletionStage::BindingsRemoved,
+                &format!("purge:{table}"),
+                serde_json::json!({"rows": affected}),
+            )
+            .await?;
+        }
+
+        let affected = sqlx::query(
+            "UPDATE communities SET deletion_state = 'tombstone', \
+                    deleted_at = COALESCE(deleted_at, now()), \
+                    archived_at = COALESCE(archived_at, now()), \
+                    signing_key = NULL, icon = NULL \
+             WHERE id = $1 AND deletion_state = 'fenced' \
+               AND deletion_fence_generation = $2",
+        )
+        .bind(token.community_id.as_uuid())
+        .bind(generation)
+        .execute(&mut *tx)
+        .await?
+        .rows_affected();
+        if affected != 1 {
+            return Err(DbError::DeletionSafety(format!(
+                "community {} tombstone update affected {affected} rows",
+                token.community_id
+            )));
+        }
+        advance_request_tx(
+            &mut tx,
+            token,
+            DeletionStage::BindingsRemoved,
+            DeletionStage::PostgresPurged,
+            Some(generation),
+        )
+        .await?;
+        checkpoint_completed_tx(
+            &mut tx,
+            token,
+            DeletionStage::BindingsRemoved,
+            "postgres_tombstone_committed",
+            serde_json::to_value(&deleted)?,
+        )
+        .await?;
+        tx.commit().await?;
+        Ok(deleted)
+    }
+
+    /// Mark cache purge after Redis adapter verification.
+    pub async fn mark_cache_purged(
+        &self,
+        token: &LeaseToken,
+        detail: serde_json::Value,
+    ) -> Result<()> {
+        self.advance_with_checkpoint(
+            token,
+            DeletionStage::PostgresPurged,
+            DeletionStage::CachePurged,
+            "purge_cache_namespace",
+            detail,
+        )
+        .await
+    }
+
+    /// Verify PostgreSQL logical absence without advancing the cross-store stage.
+    ///
+    /// The caller must verify object storage and Redis too, then call
+    /// [`Self::mark_logically_verified`]. Keeping the transition separate makes
+    /// a crash after any partial verification safely repeat the whole proof.
+    pub async fn verify_postgres_logically_deleted(&self, token: &LeaseToken) -> Result<()> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        // The absence proof is only as strong as the surface it iterates:
+        // validate the live catalog under the shared schema/destruction lock
+        // so a scoped table committed after the purge fails this stage closed
+        // instead of silently escaping verification.
+        lock_schema_destruction_shared(&mut tx).await?;
+        validate_catalog_on(&mut tx).await?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::CachePurged, generation).await?;
+        let tombstone: bool = sqlx::query_scalar(
+            "SELECT EXISTS(SELECT 1 FROM communities WHERE id = $1 \
+             AND deletion_state = 'tombstone' AND deleted_at IS NOT NULL \
+             AND deletion_fence_generation = $2)",
+        )
+        .bind(token.community_id.as_uuid())
+        .bind(generation)
+        .fetch_one(&mut *tx)
+        .await?;
+        if !tombstone {
+            return Err(DbError::DeletionSafety(format!(
+                "community {} tombstone/fence verification failed",
+                token.community_id
+            )));
+        }
+        for table in EXPECTED_SCOPED_TABLES {
+            let sql =
+                format!("SELECT EXISTS(SELECT 1 FROM {table} WHERE community_id = $1 LIMIT 1)");
+            let remains: bool = sqlx::query_scalar(AssertSqlSafe(sql))
+                .bind(token.community_id.as_uuid())
+                .fetch_one(&mut *tx)
+                .await?;
+            if remains {
+                return Err(DbError::DeletionSafety(format!(
+                    "logical verification found tenant rows in {table}"
+                )));
+            }
+        }
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Commit the cross-store logical verification checkpoint and drop the
+    /// frozen key chunks in the same transaction.
+    ///
+    /// The chunk rows are working data, not audit evidence — per-prefix
+    /// counts, digests, and checkpoint history stay on the request row, and
+    /// the raw key list of a deleted community should not be retained.
+    /// Blocked requests never reach this transition, so their chunks survive
+    /// for resumption or operator inspection.
+    pub async fn mark_logically_verified(
+        &self,
+        token: &LeaseToken,
+        detail: serde_json::Value,
+    ) -> Result<()> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::CachePurged, generation).await?;
+        advance_request_tx(
+            &mut tx,
+            token,
+            DeletionStage::CachePurged,
+            DeletionStage::LogicallyVerified,
+            Some(generation),
+        )
+        .await?;
+        checkpoint_completed_tx(
+            &mut tx,
+            token,
+            DeletionStage::CachePurged,
+            "verify_cross_store_absence",
+            detail,
+        )
+        .await?;
+        sqlx::query("DELETE FROM community_deletion_manifest_keys WHERE request_id = $1")
+            .bind(token.request_id)
+            .execute(&mut *tx)
+            .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Finish logical deletion and enter the physical-expiry pending state.
+    pub async fn mark_retention_pending(
+        &self,
+        token: &LeaseToken,
+        detail: serde_json::Value,
+    ) -> Result<()> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        verify_lease_and_fence(&mut tx, token, DeletionStage::LogicallyVerified, generation)
+            .await?;
+        checkpoint_completed_tx(
+            &mut tx,
+            token,
+            DeletionStage::LogicallyVerified,
+            "retention_physical_expiry_pending",
+            detail,
+        )
+        .await?;
+        let affected = sqlx::query(
+            "UPDATE community_deletion_requests \
+             SET stage = 'retention_pending', completed_at = now(), updated_at = now(), \
+                 lease_owner = NULL, lease_until = NULL, retry_count = 0, retry_stage = NULL, \
+                 last_error = NULL, last_error_at = NULL \
+             WHERE id = $1 AND stage = 'logically_verified' \
+               AND lease_owner = $2 AND lease_generation = $3 AND lease_until >= now() \
+               AND fence_generation = $4",
+        )
+        .bind(token.request_id)
+        .bind(&token.owner)
+        .bind(token.generation)
+        .bind(generation)
+        .execute(&mut *tx)
+        .await?
+        .rows_affected();
+        if affected != 1 {
+            return Err(stale_lease_error(token));
+        }
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Persist a retryable unit failure and release the claim.
+    ///
+    /// The eighth consecutive failure at the same stage becomes a durable
+    /// block. A successful stage transition clears the streak; an operator may
+    /// use [`Self::unblock`] after remediating an exhausted dependency failure.
+    pub async fn record_retry(
+        &self,
+        token: &LeaseToken,
+        stage: DeletionStage,
+        unit_key: &str,
+        error: &str,
+        retry_after: Duration,
+    ) -> Result<()> {
+        let bounded = bound_text(error, 4096);
+        let retry_seconds = i64::try_from(retry_after.as_secs()).unwrap_or(i64::MAX);
+        let mut tx = self.pool.begin().await?;
+        verify_lease(&mut tx, token, stage).await?;
+        let (retry_count, retry_stage): (i32, Option<String>) = sqlx::query_as(
+            "SELECT retry_count, retry_stage FROM community_deletion_requests WHERE id = $1 FOR UPDATE",
+        )
+        .bind(token.request_id)
+        .fetch_one(&mut *tx)
+        .await?;
+        let stage_name = stage.to_string();
+        let consecutive_retries = if retry_stage.as_deref() == Some(stage_name.as_str()) {
+            retry_count.saturating_add(1)
+        } else {
+            1
+        };
+        let exhausted = consecutive_retries >= 8;
+        checkpoint_failed_tx(&mut tx, token, stage, unit_key, &bounded).await?;
+        sqlx::query(
+            "UPDATE community_deletion_requests \
+             SET retry_count = $7, retry_stage = $8, last_error = $4, last_error_at = now(), \
+                 next_attempt_at = CASE WHEN $6 THEN next_attempt_at \
+                                        ELSE now() + make_interval(secs => $5) END, \
+                 blocked_at = CASE WHEN $6 THEN now() ELSE blocked_at END, \
+                 blocked_reason = CASE WHEN $6 THEN $4 ELSE blocked_reason END, \
+                 lease_owner = NULL, lease_until = NULL, updated_at = now() \
+             WHERE id = $1 AND lease_owner = $2 AND lease_generation = $3",
+        )
+        .bind(token.request_id)
+        .bind(&token.owner)
+        .bind(token.generation)
+        .bind(&bounded)
+        .bind(retry_seconds)
+        .bind(exhausted)
+        .bind(consecutive_retries)
+        .bind(stage_name)
+        .execute(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Terminally abort an approved or fenced request before object deletion begins.
+    pub async fn abort(
+        &self,
+        request_id: Uuid,
+        aborted_by: &str,
+        reason: &str,
+    ) -> Result<DeletionRequest> {
+        let aborted_by = aborted_by.trim();
+        let reason = reason.trim();
+        if aborted_by.is_empty() || reason.is_empty() {
+            return Err(DbError::DeletionSafety(
+                "abort requires non-empty operator identity and reason".to_string(),
+            ));
+        }
+        let mut tx = self.pool.begin().await?;
+        let community_id: CommunityId = sqlx::query_scalar::<_, Uuid>(
+            "SELECT community_id FROM community_deletion_requests WHERE id = $1",
+        )
+        .bind(request_id)
+        .fetch_optional(&mut *tx)
+        .await?
+        .map(CommunityId::from_uuid)
+        .ok_or_else(|| DbError::NotFound(format!("community deletion {request_id}")))?;
+        // Every lifecycle transition takes the community lock before any row lock.
+        // Inverting this order lets abort and the executor deadlock each other.
+        sqlx::query("SELECT pg_advisory_xact_lock(community_deletion_lock_key($1))")
+            .bind(community_id.as_uuid())
+            .execute(&mut *tx)
+            .await?;
+        let row = sqlx::query("SELECT * FROM community_deletion_requests WHERE id = $1 FOR UPDATE")
+            .bind(request_id)
+            .fetch_optional(&mut *tx)
+            .await?
+            .ok_or_else(|| DbError::NotFound(format!("community deletion {request_id}")))?;
+        let request = row_to_request(row)?;
+        if request.community_id != community_id {
+            return Err(DbError::DeletionSafety(format!(
+                "deletion {request_id} changed community while abort waited for the community lock"
+            )));
+        }
+        if !matches!(
+            request.stage,
+            DeletionStage::Approved | DeletionStage::Fenced
+        ) {
+            return Err(DbError::DeletionSafety(format!(
+                "deletion {request_id} at stage {} cannot be aborted",
+                request.stage
+            )));
+        }
+        let active_writes: i64 = sqlx::query_scalar(
+            "SELECT count(*)::BIGINT FROM community_serving_write_leases \
+             WHERE community_id = $1 AND lease_until >= now()",
+        )
+        .bind(request.community_id.as_uuid())
+        .fetch_one(&mut *tx)
+        .await?;
+        if active_writes > 0 {
+            return Err(DbError::DeletionSafety(format!(
+                "deletion {request_id} cannot abort while {active_writes} serving write lease(s) remain active"
+            )));
+        }
+        let (old_generation, current_archived_at): (i64, Option<DateTime<Utc>>) = sqlx::query_as(
+            "SELECT deletion_fence_generation, archived_at FROM communities WHERE id = $1 FOR UPDATE",
+        )
+        .bind(request.community_id.as_uuid())
+        .fetch_one(&mut *tx)
+        .await?;
+        let new_generation = old_generation.checked_add(1).ok_or_else(|| {
+            DbError::DeletionSafety("community deletion fence generation overflow".to_string())
+        })?;
+        let restored_archived_at = if request.quiescing_started_at.is_some() {
+            request.pre_quiesce_archived_at
+        } else {
+            current_archived_at
+        };
+        set_executor_gucs(&mut tx, request.community_id, new_generation).await?;
+        let restored = sqlx::query(
+            "UPDATE communities SET deletion_state = 'active', deletion_fence_generation = $2, \
+             archived_at = $3 WHERE id = $1 AND deletion_state IN ('active', 'quiescing', 'fenced') \
+             AND deleted_at IS NULL",
+        )
+        .bind(request.community_id.as_uuid())
+        .bind(new_generation)
+        .bind(restored_archived_at)
+        .execute(&mut *tx)
+        .await?
+        .rows_affected();
+        if restored != 1 {
+            return Err(DbError::DeletionSafety(format!(
+                "community {} cannot be restored during abort",
+                request.community_id
+            )));
+        }
+        sqlx::query(
+            "INSERT INTO community_deletion_checkpoints \
+             (request_id, stage, unit_key, status, lease_generation, detail, completed_at) \
+             VALUES ($1, $2, $3, 'completed', $4, $5, now())",
+        )
+        .bind(request.id)
+        .bind(request.stage.to_string())
+        .bind(format!("operator_abort:{}", Uuid::new_v4()))
+        .bind(request.lease_generation.max(1))
+        .bind(serde_json::json!({
+            "aborted_by": bound_text(aborted_by, 512),
+            "reason": bound_text(reason, 4096),
+            "old_fence_generation": old_generation,
+            "new_fence_generation": new_generation,
+        }))
+        .execute(&mut *tx)
+        .await?;
+        let row = sqlx::query(
+            "UPDATE community_deletion_requests SET stage = 'aborted', aborted_by = $2, \
+             abort_reason = $3, aborted_at = now(), completed_at = now(), fence_generation = $4, \
+             lease_owner = NULL, lease_until = NULL, lease_generation = lease_generation + 1, \
+             blocked_at = NULL, blocked_reason = NULL, retry_count = 0, retry_stage = NULL, \
+             next_attempt_at = now(), updated_at = now() WHERE id = $1 RETURNING *",
+        )
+        .bind(request.id)
+        .bind(bound_text(aborted_by, 512))
+        .bind(bound_text(reason, 4096))
+        .bind(new_generation)
+        .fetch_one(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        row_to_request(row)
+    }
+
+    /// operator checkpoint and only makes runnable stages immediately claimable.
+    /// Clear a fail-closed block after an operator has remediated its cause.
+    ///
+    /// Recovery preserves the immutable target, approval, inventory, stage,
+    /// fence generation, and prior failure checkpoint. It appends an auditable
+    pub async fn unblock(
+        &self,
+        request_id: Uuid,
+        unblocked_by: &str,
+        reason: &str,
+    ) -> Result<DeletionRequest> {
+        let unblocked_by = unblocked_by.trim();
+        let reason = reason.trim();
+        if unblocked_by.is_empty() || reason.is_empty() {
+            return Err(DbError::InvalidData(
+                "unblock requires non-empty operator identity and remediation reason".to_string(),
+            ));
+        }
+
+        let mut tx = self.pool.begin().await?;
+        let request_row = sqlx::query(
+            "SELECT * FROM community_deletion_requests \
+             WHERE id = $1 AND blocked_at IS NOT NULL FOR UPDATE",
+        )
+        .bind(request_id)
+        .fetch_optional(&mut *tx)
+        .await?
+        .ok_or_else(|| {
+            DbError::DeletionSafety(format!(
+                "deletion {request_id} is missing or is not blocked"
+            ))
+        })?;
+        let request = row_to_request(request_row)?;
+        if matches!(
+            request.stage,
+            DeletionStage::RetentionPending | DeletionStage::Aborted
+        ) {
+            return Err(DbError::DeletionSafety(format!(
+                "blocked deletion {request_id} at terminal stage {} cannot resume",
+                request.stage
+            )));
+        }
+        if request.lease_owner.is_some()
+            && request
+                .lease_until
+                .is_some_and(|lease_until| lease_until >= Utc::now())
+        {
+            return Err(DbError::DeletionSafety(format!(
+                "blocked deletion {request_id} still has a live executor lease"
+            )));
+        }
+
+        let prior_block = request.blocked_reason.clone();
+        sqlx::query(
+            "INSERT INTO community_deletion_checkpoints \
+             (request_id, stage, unit_key, status, lease_generation, detail, completed_at) \
+             VALUES ($1, $2, $3, 'completed', $4, $5, now())",
+        )
+        .bind(request.id)
+        .bind(request.stage.to_string())
+        .bind(format!("operator_unblock:{}", Uuid::new_v4()))
+        .bind(request.lease_generation.max(1))
+        .bind(serde_json::json!({
+            "unblocked_by": bound_text(unblocked_by, 512),
+            "reason": bound_text(reason, 4096),
+            "previous_block": prior_block,
+        }))
+        .execute(&mut *tx)
+        .await?;
+
+        let row = sqlx::query(
+            "UPDATE community_deletion_requests \
+             SET blocked_at = NULL, blocked_reason = NULL, retry_count = 0, retry_stage = NULL, \
+                 last_error = NULL, last_error_at = NULL, next_attempt_at = now(), \
+                 lease_owner = NULL, lease_until = NULL, updated_at = now() \
+             WHERE id = $1 AND blocked_at IS NOT NULL RETURNING *",
+        )
+        .bind(request_id)
+        .fetch_one(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        row_to_request(row)
+    }
+
+    /// Persist a fail-closed setup failure before an identifiable request is claimed.
+    pub async fn block_preclaim_setup(
+        &self,
+        request_id: Uuid,
+        unit_key: &str,
+        error: &str,
+    ) -> Result<DeletionRequest> {
+        let bounded = bound_text(error, 4096);
+        let mut tx = self.pool.begin().await?;
+        let request =
+            sqlx::query("SELECT * FROM community_deletion_requests WHERE id = $1 FOR UPDATE")
+                .bind(request_id)
+                .fetch_optional(&mut *tx)
+                .await?
+                .ok_or_else(|| DbError::NotFound(format!("community deletion {request_id}")))?;
+        let request = row_to_request(request)?;
+        if matches!(
+            request.stage,
+            DeletionStage::RetentionPending | DeletionStage::Aborted
+        ) {
+            return Err(DbError::DeletionSafety(format!(
+                "deletion {request_id} at terminal stage {} cannot record a setup failure",
+                request.stage
+            )));
+        }
+        if request.lease_owner.is_some()
+            && request
+                .lease_until
+                .is_some_and(|lease_until| lease_until >= Utc::now())
+        {
+            return Err(DbError::DeletionSafety(format!(
+                "deletion {request_id} is leased by another executor"
+            )));
+        }
+        sqlx::query(
+            r#"
+            INSERT INTO community_deletion_checkpoints
+                (request_id, stage, unit_key, status, lease_generation, detail, error)
+            VALUES ($1, $2, $3, 'failed', $4, $5, $6)
+            ON CONFLICT (request_id, stage, unit_key) DO UPDATE
+            SET status = 'failed', lease_generation = EXCLUDED.lease_generation,
+                attempts = community_deletion_checkpoints.attempts + 1,
+                detail = EXCLUDED.detail, error = EXCLUDED.error, completed_at = NULL
+            "#,
+        )
+        .bind(request.id)
+        .bind(request.stage.to_string())
+        .bind(unit_key)
+        .bind(request.lease_generation.max(1))
+        .bind(serde_json::json!({"error": &bounded}))
+        .bind(&bounded)
+        .execute(&mut *tx)
+        .await?;
+        let row = sqlx::query(
+            "UPDATE community_deletion_requests \
+             SET blocked_at = now(), blocked_reason = $2, last_error = $2, \
+                 last_error_at = now(), updated_at = now() \
+             WHERE id = $1 RETURNING *",
+        )
+        .bind(request_id)
+        .bind(&bounded)
+        .fetch_one(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        row_to_request(row)
+    }
+
+    /// Persist a fail-closed permanent block and release the claim.
+    pub async fn block(
+        &self,
+        token: &LeaseToken,
+        stage: DeletionStage,
+        unit_key: &str,
+        error: &str,
+    ) -> Result<()> {
+        let bounded = bound_text(error, 4096);
+        let mut tx = self.pool.begin().await?;
+        verify_lease(&mut tx, token, stage).await?;
+        checkpoint_failed_tx(&mut tx, token, stage, unit_key, &bounded).await?;
+        sqlx::query(
+            "UPDATE community_deletion_requests \
+             SET blocked_at = now(), blocked_reason = $4, last_error = $4, \
+                 last_error_at = now(), lease_owner = NULL, lease_until = NULL, updated_at = now() \
+             WHERE id = $1 AND lease_owner = $2 AND lease_generation = $3",
+        )
+        .bind(token.request_id)
+        .bind(&token.owner)
+        .bind(token.generation)
+        .bind(&bounded)
+        .execute(&mut *tx)
+        .await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    /// Take the shared community deletion lock inside an existing transaction.
+    pub async fn guard_transaction(
+        &self,
+        tx: &mut Transaction<'_, Postgres>,
+        community: CommunityId,
+    ) -> Result<()> {
+        sqlx::query("SELECT pg_advisory_xact_lock_shared(community_deletion_lock_key($1))")
+            .bind(community.as_uuid())
+            .execute(&mut **tx)
+            .await?;
+        let state: Option<String> = sqlx::query_scalar(
+            "SELECT deletion_state FROM communities WHERE id = $1 AND deleted_at IS NULL",
+        )
+        .bind(community.as_uuid())
+        .fetch_optional(&mut **tx)
+        .await?;
+        match state.as_deref() {
+            Some("active") => Ok(()),
+            Some(other) => Err(DbError::AccessDenied(format!(
+                "community {community} is write-fenced ({other})"
+            ))),
+            None => Err(DbError::AccessDenied(format!(
+                "community {community} is missing or tombstoned"
+            ))),
+        }
+    }
+
+    /// Take the shared community deletion lock inside an existing transaction
+    /// and authorize a final mutation under an already-admitted serving lease.
+    ///
+    /// The lease is checked in the same transaction as the mutation. During
+    /// quiescing, only this exact unexpired lease and fence generation may
+    /// finish; active communities continue to accept the admitted write too.
+    pub async fn guard_transaction_with_serving_lease(
+        &self,
+        tx: &mut Transaction<'_, Postgres>,
+        lease: &ServingWriteLease,
+    ) -> Result<()> {
+        sqlx::query("SELECT pg_advisory_xact_lock_shared(community_deletion_lock_key($1))")
+            .bind(lease.community_id.as_uuid())
+            .execute(&mut **tx)
+            .await?;
+        let valid: bool = sqlx::query_scalar(
+            "SELECT EXISTS(SELECT 1 FROM community_serving_write_leases lease \
+             JOIN communities community ON community.id = lease.community_id \
+             WHERE lease.id = $1 AND lease.community_id = $2 AND lease.owner = $3 \
+               AND lease.generation = $4 AND lease.fence_generation = $5 \
+               AND lease.lease_until >= now() AND community.deleted_at IS NULL \
+               AND community.deletion_state IN ('active', 'quiescing') \
+               AND community.deletion_fence_generation = lease.fence_generation)",
+        )
+        .bind(lease.id)
+        .bind(lease.community_id.as_uuid())
+        .bind(&lease.owner)
+        .bind(lease.generation)
+        .bind(lease.fence_generation)
+        .fetch_one(&mut **tx)
+        .await?;
+        if !valid {
+            return Err(DbError::AccessDenied(format!(
+                "stale serving write lease {}",
+                lease.id
+            )));
+        }
+        sqlx::query(
+            "SELECT set_config('buzz.serving_write_community', $1, true), \
+                    set_config('buzz.serving_write_lease_id', $2, true), \
+                    set_config('buzz.serving_write_owner', $3, true), \
+                    set_config('buzz.serving_write_generation', $4, true), \
+                    set_config('buzz.serving_write_fence_generation', $5, true)",
+        )
+        .bind(lease.community_id.to_string())
+        .bind(lease.id.to_string())
+        .bind(&lease.owner)
+        .bind(lease.generation.to_string())
+        .bind(lease.fence_generation.to_string())
+        .execute(&mut **tx)
+        .await?;
+        Ok(())
+    }
+
+    /// Acquire a durable, expiring lease for an external serving side effect.
+    ///
+    /// The short transaction shares the same advisory lock as the destructive
+    /// fence. The fence therefore orders after all acquisitions that began
+    /// first, changes lifecycle state, then refuses every later acquisition.
+    pub async fn acquire_serving_write_lease(
+        &self,
+        community: CommunityId,
+        operation: &str,
+        owner: &str,
+        lease_duration: Duration,
+    ) -> Result<ServingWriteLease> {
+        let lease_seconds = i64::try_from(lease_duration.as_secs()).unwrap_or(i64::MAX);
+        let mut tx = self.pool.begin().await?;
+        // The assertion owns both the shared ordering lock and the supported
+        // READ COMMITTED check. The lease table is trigger-excluded, so this
+        // explicit admission is its database-enforced write fence.
+        if let Err(error) = sqlx::query("SELECT assert_community_write_allowed($1)")
+            .bind(community.as_uuid())
+            .execute(&mut *tx)
+            .await
+        {
+            if error.as_database_error().is_some_and(|database_error| {
+                database_error.code().as_deref() == Some("55000")
+                    && database_error.message().starts_with("community write")
+            }) {
+                return Err(DbError::AccessDenied(format!(
+                    "community {community} is write-fenced or missing"
+                )));
+            }
+            return Err(error.into());
+        }
+        let row = sqlx::query(
+            "INSERT INTO community_serving_write_leases \
+             (community_id, operation, owner, fence_generation, lease_until) \
+             SELECT id, $2, $3, deletion_fence_generation, \
+                    now() + make_interval(secs => $4) \
+             FROM communities WHERE id = $1 AND deletion_state = 'active' \
+               AND deleted_at IS NULL \
+             RETURNING id, generation, fence_generation, lease_until",
+        )
+        .bind(community.as_uuid())
+        .bind(operation)
+        .bind(owner)
+        .bind(lease_seconds)
+        .fetch_optional(&mut *tx)
+        .await?
+        .ok_or_else(|| {
+            DbError::AccessDenied(format!("community {community} is write-fenced or missing"))
+        })?;
+        let lease = ServingWriteLease {
+            id: row.try_get("id")?,
+            community_id: community,
+            operation: operation.to_owned(),
+            owner: owner.to_owned(),
+            generation: row.try_get("generation")?,
+            fence_generation: row.try_get("fence_generation")?,
+            lease_until: row.try_get("lease_until")?,
+        };
+        tx.commit().await?;
+        Ok(lease)
+    }
+
+    /// Renew an already-admitted external side-effect lease while the community
+    /// is active or quiescing.
+    ///
+    /// Quiescing rejects new acquisition, but the exact existing, unexpired
+    /// lease must remain renewable until its operation finishes. Otherwise the
+    /// heartbeat would abandon the exclusion proof while remote I/O may still
+    /// commit. Fence generation, owner, generation, expiry, and tombstone checks
+    /// continue to reject stale or post-fence renewal.
+    pub async fn renew_serving_write_lease(
+        &self,
+        lease: &mut ServingWriteLease,
+        lease_duration: Duration,
+    ) -> Result<()> {
+        let lease_seconds = i64::try_from(lease_duration.as_secs()).unwrap_or(i64::MAX);
+        let mut tx = self.pool.begin().await?;
+        sqlx::query("SELECT pg_advisory_xact_lock_shared(community_deletion_lock_key($1))")
+            .bind(lease.community_id.as_uuid())
+            .execute(&mut *tx)
+            .await?;
+        let lease_until: Option<DateTime<Utc>> = sqlx::query_scalar(
+            "UPDATE community_serving_write_leases lease \
+             SET lease_until = now() + make_interval(secs => $6), heartbeat_at = now() \
+             FROM communities community \
+             WHERE lease.id = $1 AND lease.community_id = $2 AND lease.owner = $3 \
+               AND lease.generation = $4 AND lease.fence_generation = $5 \
+               AND lease.lease_until >= now() \
+               AND community.id = lease.community_id \
+               AND community.deletion_state IN ('active', 'quiescing') \
+               AND community.deleted_at IS NULL \
+               AND community.deletion_fence_generation = lease.fence_generation \
+             RETURNING lease.lease_until",
+        )
+        .bind(lease.id)
+        .bind(lease.community_id.as_uuid())
+        .bind(&lease.owner)
+        .bind(lease.generation)
+        .bind(lease.fence_generation)
+        .bind(lease_seconds)
+        .fetch_optional(&mut *tx)
+        .await?;
+        let lease_until = lease_until.ok_or_else(|| {
+            DbError::AccessDenied(format!("stale serving write lease {}", lease.id))
+        })?;
+        tx.commit().await?;
+        lease.lease_until = lease_until;
+        Ok(())
+    }
+
+    /// Release a serving side-effect lease. A stale release is harmless.
+    pub async fn release_serving_write_lease(&self, lease: &ServingWriteLease) -> Result<bool> {
+        let deleted = sqlx::query(
+            "DELETE FROM community_serving_write_leases \
+             WHERE id = $1 AND community_id = $2 AND owner = $3 AND generation = $4 \
+               AND fence_generation = $5",
+        )
+        .bind(lease.id)
+        .bind(lease.community_id.as_uuid())
+        .bind(&lease.owner)
+        .bind(lease.generation)
+        .bind(lease.fence_generation)
+        .execute(&self.pool)
+        .await?
+        .rows_affected();
+        Ok(deleted == 1)
+    }
+
+    /// Check that an external side-effect lease remains current for finalization.
+    ///
+    /// A lease admitted before quiescing may renew, complete, and release; new
+    /// work remains blocked, preserving an accurate drain without abandoning an
+    /// admitted remote effect.
+    pub async fn verify_serving_write_lease(&self, lease: &ServingWriteLease) -> Result<()> {
+        let mut tx = self.pool.begin().await?;
+        sqlx::query("SELECT pg_advisory_xact_lock_shared(community_deletion_lock_key($1))")
+            .bind(lease.community_id.as_uuid())
+            .execute(&mut *tx)
+            .await?;
+        let valid: bool = sqlx::query_scalar(
+            "SELECT EXISTS(SELECT 1 FROM community_serving_write_leases lease \
+             JOIN communities community ON community.id = lease.community_id \
+             WHERE lease.id = $1 AND lease.community_id = $2 AND lease.owner = $3 \
+               AND lease.generation = $4 AND lease.fence_generation = $5 \
+               AND lease.lease_until >= now() \
+               AND community.deleted_at IS NULL \
+               AND community.deletion_state IN ('active', 'quiescing') \
+               AND community.deletion_fence_generation = lease.fence_generation)",
+        )
+        .bind(lease.id)
+        .bind(lease.community_id.as_uuid())
+        .bind(&lease.owner)
+        .bind(lease.generation)
+        .bind(lease.fence_generation)
+        .fetch_one(&mut *tx)
+        .await?;
+        if valid {
+            tx.commit().await?;
+            Ok(())
+        } else {
+            Err(DbError::AccessDenied(format!(
+                "stale serving write lease {}",
+                lease.id
+            )))
+        }
+    }
+
+    /// Delete expired serving leases in a bounded batch.
+    pub async fn reap_expired_serving_write_leases(&self, limit: i64) -> Result<u64> {
+        let affected = sqlx::query(
+            "WITH expired AS ( \
+                 SELECT id FROM community_serving_write_leases \
+                 WHERE lease_until < now() ORDER BY lease_until LIMIT $1 \
+                 FOR UPDATE SKIP LOCKED \
+             ) DELETE FROM community_serving_write_leases lease \
+               USING expired WHERE lease.id = expired.id",
+        )
+        .bind(limit.clamp(1, 10_000))
+        .execute(&self.pool)
+        .await?
+        .rows_affected();
+        Ok(affected)
+    }
+
+    /// Return serving-lease counts and dead-tuple estimate for observability.
+    pub async fn serving_lease_stats(&self) -> Result<ServingLeaseStats> {
+        let row = sqlx::query(
+            "SELECT count(*) FILTER (WHERE lease_until >= now())::BIGINT AS active, \
+                    count(*) FILTER (WHERE lease_until < now())::BIGINT AS expired, \
+                    COALESCE((SELECT n_dead_tup::BIGINT FROM pg_stat_user_tables \
+                              WHERE relname = 'community_serving_write_leases'), 0) AS dead_tuples \
+             FROM community_serving_write_leases",
+        )
+        .fetch_one(&self.pool)
+        .await?;
+        Ok(ServingLeaseStats {
+            active: row.try_get("active")?,
+            expired: row.try_get("expired")?,
+            dead_tuples: row.try_get("dead_tuples")?,
+        })
+    }
+
+    /// Whether a community remains active and serving-write eligible.
+    pub async fn is_serving_active(&self, community: CommunityId) -> Result<bool> {
+        sqlx::query_scalar(
+            "SELECT EXISTS(SELECT 1 FROM communities WHERE id = $1 \
+             AND archived_at IS NULL AND deleted_at IS NULL AND deletion_state = 'active')",
+        )
+        .bind(community.as_uuid())
+        .fetch_one(&self.pool)
+        .await
+        .map_err(Into::into)
+    }
+
+    async fn advance_with_checkpoint(
+        &self,
+        token: &LeaseToken,
+        from: DeletionStage,
+        to: DeletionStage,
+        unit_key: &str,
+        detail: serde_json::Value,
+    ) -> Result<()> {
+        let generation = require_fence_generation(token)?;
+        let mut tx = self.pool.begin().await?;
+        verify_lease_and_fence(&mut tx, token, from, generation).await?;
+        advance_request_tx(&mut tx, token, from, to, Some(generation)).await?;
+        checkpoint_completed_tx(&mut tx, token, from, unit_key, detail).await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    async fn live_scoped_tables(&self) -> Result<BTreeSet<String>> {
+        let mut conn = self.pool.acquire().await?;
+        live_scoped_tables_on(&mut conn).await
+    }
+
+    async fn live_fenced_tables(&self) -> Result<BTreeSet<String>> {
+        let mut conn = self.pool.acquire().await?;
+        live_fenced_tables_on(&mut conn).await
+    }
+}
+
+/// Take the shared schema/destruction advisory lock for the current
+/// transaction.
+///
+/// Transaction-scoped so every abort path — including executor death —
+/// releases it. Migrations hold the exclusive session counterpart for their
+/// whole run (see [`crate::migration::run_migrations`]); shared holders do
+/// not block each other, so concurrent deletion executors are unaffected.
+async fn lock_schema_destruction_shared(conn: &mut PgConnection) -> Result<()> {
+    sqlx::query("SELECT pg_advisory_xact_lock_shared($1)")
+        .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+        .execute(conn)
+        .await?;
+    Ok(())
+}
+
+/// Connection-bound form of [`DeletionStore::validate_catalog`].
+///
+/// Destructive transactions call this on their own transaction after taking
+/// the shared schema/destruction lock, so the validated surface cannot change
+/// before the transaction commits.
+async fn validate_catalog_on(conn: &mut PgConnection) -> Result<()> {
+    let expected = EXPECTED_SCOPED_TABLES
+        .iter()
+        .copied()
+        .map(str::to_owned)
+        .collect::<BTreeSet<_>>();
+    let live_tables = live_scoped_tables_on(conn).await?;
+    if live_tables != expected {
+        let missing = expected
+            .difference(&live_tables)
+            .cloned()
+            .collect::<Vec<_>>();
+        let unknown = live_tables
+            .difference(&expected)
+            .cloned()
+            .collect::<Vec<_>>();
+        return Err(DbError::DeletionSafety(format!(
+            "community deletion catalog drift (missing={}, unknown={})",
+            missing.join(","),
+            unknown.join(",")
+        )));
+    }
+
+    let fenced_tables = live_fenced_tables_on(conn).await?;
+    if fenced_tables != expected {
+        let missing = expected
+            .difference(&fenced_tables)
+            .cloned()
+            .collect::<Vec<_>>();
+        let unknown = fenced_tables
+            .difference(&expected)
+            .cloned()
+            .collect::<Vec<_>>();
+        return Err(DbError::DeletionSafety(format!(
+            "community deletion write-fence drift (missing={}, unknown={})",
+            missing.join(","),
+            unknown.join(",")
+        )));
+    }
+    Ok(())
+}
+
+async fn live_scoped_tables_on(conn: &mut PgConnection) -> Result<BTreeSet<String>> {
+    let rows: Vec<String> = sqlx::query_scalar(
+        r#"
+        SELECT c.relname
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        JOIN pg_attribute a ON a.attrelid = c.oid
+        WHERE n.nspname = 'public'
+          AND c.relkind IN ('r', 'p')
+          AND NOT c.relispartition
+          AND a.attname = 'community_id'
+          AND NOT a.attisdropped
+          AND NOT community_write_fence_excluded_table(c.relname)
+        ORDER BY c.relname
+        "#,
+    )
+    .fetch_all(conn)
+    .await?;
+    Ok(rows.into_iter().collect())
+}
+
+async fn live_fenced_tables_on(conn: &mut PgConnection) -> Result<BTreeSet<String>> {
+    let rows: Vec<String> = sqlx::query_scalar(
+        r#"
+        SELECT c.relname
+        FROM pg_trigger trigger
+        JOIN pg_class c ON c.oid = trigger.tgrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        JOIN pg_proc procedure ON procedure.oid = trigger.tgfoid
+        WHERE n.nspname = 'public'
+          AND NOT trigger.tgisinternal
+          AND NOT c.relispartition
+          AND procedure.proname = 'enforce_community_write_fence'
+          AND trigger.tgenabled = 'O'
+          AND (trigger.tgtype & 1) = 1
+          AND (trigger.tgtype & 2) = 2
+          AND (trigger.tgtype & 4) = 4
+          AND (trigger.tgtype & 8) = 8
+          AND (trigger.tgtype & 16) = 16
+        ORDER BY c.relname
+        "#,
+    )
+    .fetch_all(conn)
+    .await?;
+    Ok(rows.into_iter().collect())
+}
+
+/// Fail closed when a community-prefix inventory has an unsafe shape.
+pub fn validate_storage_manifest(manifest: &StorageManifest) -> Result<()> {
+    if manifest.version != 4 {
+        return Err(DbError::DeletionSafety(format!(
+            "unsupported storage manifest version {}",
+            manifest.version
+        )));
+    }
+    if manifest.prefixes.is_empty() {
+        return Err(DbError::DeletionSafety(
+            "storage manifest has no tenant prefixes".to_string(),
+        ));
+    }
+    if manifest
+        .prefixes
+        .windows(2)
+        .any(|pair| pair[0].prefix >= pair[1].prefix)
+    {
+        return Err(DbError::DeletionSafety(
+            "storage manifest prefixes are not strictly sorted".to_string(),
+        ));
+    }
+    for prefix in &manifest.prefixes {
+        // An empty prefix would enumerate — and delete — the whole bucket.
+        if prefix.prefix.is_empty() {
+            return Err(DbError::DeletionSafety(
+                "storage manifest contains an empty prefix".to_string(),
+            ));
+        }
+        if prefix.keys_digest.len() != 64
+            || !prefix
+                .keys_digest
+                .bytes()
+                .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+        {
+            return Err(DbError::DeletionSafety(format!(
+                "storage manifest digest for {} is not lowercase hex sha-256",
+                prefix.prefix
+            )));
+        }
+    }
+    Ok(())
+}
+
+/// Verify the persisted chunk stream is exactly the frozen enumeration:
+/// contiguous chunk numbers, chunks grouped by manifest prefix order, every
+/// key under its chunk's prefix, and per-prefix digest/count equality.
+fn validate_manifest_key_chunks(
+    manifest: &StorageManifest,
+    chunks: &[(i64, String, sqlx::types::Json<Vec<String>>)],
+) -> Result<()> {
+    let close = |summary: &PrefixManifest, digest: KeyStreamDigest| -> Result<()> {
+        let (hex_digest, count) = digest.finish();
+        if hex_digest != summary.keys_digest || count != summary.object_count {
+            return Err(DbError::DeletionSafety(format!(
+                "frozen key chunks do not match the destructive manifest for prefix {}",
+                summary.prefix
+            )));
+        }
+        Ok(())
+    };
+    let mut remaining = manifest.prefixes.iter();
+    let mut current = remaining.next();
+    let mut digest = KeyStreamDigest::new();
+    for (index, (chunk_no, chunk_prefix, keys)) in chunks.iter().enumerate() {
+        if *chunk_no != i64::try_from(index).unwrap_or(i64::MAX) {
+            return Err(DbError::DeletionSafety(
+                "frozen key chunk sequence has gaps".to_string(),
+            ));
+        }
+        loop {
+            match current {
+                Some(summary) if summary.prefix == *chunk_prefix => break,
+                Some(summary) => {
+                    close(summary, std::mem::take(&mut digest))?;
+                    current = remaining.next();
+                }
+                None => {
+                    return Err(DbError::DeletionSafety(format!(
+                        "frozen key chunk prefix {chunk_prefix} is not in the destructive manifest"
+                    )));
+                }
+            }
+        }
+        if keys.0.is_empty() {
+            return Err(DbError::DeletionSafety(
+                "frozen key chunk is empty".to_string(),
+            ));
+        }
+        for key in &keys.0 {
+            if !key.starts_with(chunk_prefix.as_str()) {
+                return Err(DbError::DeletionSafety(format!(
+                    "frozen key {key} is outside its chunk prefix {chunk_prefix}"
+                )));
+            }
+            digest.fold(key)?;
+        }
+    }
+    if let Some(summary) = current {
+        close(summary, digest)?;
+    }
+    for summary in remaining {
+        close(summary, KeyStreamDigest::new())?;
+    }
+    Ok(())
+}
+
+async fn verify_lease(
+    tx: &mut Transaction<'_, Postgres>,
+    token: &LeaseToken,
+    stage: DeletionStage,
+) -> Result<()> {
+    let valid: bool = sqlx::query_scalar(
+        "SELECT EXISTS(SELECT 1 FROM community_deletion_requests request \
+         JOIN community_deletion_approvals approval ON approval.request_id = request.id \
+          AND approval.community_id = request.community_id \
+          AND approval.inventory_digest = request.inventory_digest \
+         WHERE request.id = $1 AND request.community_id = $5 AND request.stage = $2 \
+           AND request.lease_owner = $3 AND request.lease_generation = $4 \
+           AND request.lease_until >= now() AND request.blocked_at IS NULL)",
+    )
+    .bind(token.request_id)
+    .bind(stage.to_string())
+    .bind(&token.owner)
+    .bind(token.generation)
+    .bind(token.community_id.as_uuid())
+    .fetch_one(&mut **tx)
+    .await?;
+    if valid {
+        Ok(())
+    } else {
+        Err(stale_lease_error(token))
+    }
+}
+
+async fn verify_lease_and_fence(
+    tx: &mut Transaction<'_, Postgres>,
+    token: &LeaseToken,
+    stage: DeletionStage,
+    fence_generation: i64,
+) -> Result<()> {
+    let valid: bool = sqlx::query_scalar(
+        "SELECT EXISTS(SELECT 1 FROM community_deletion_requests request \
+         JOIN communities community ON community.id = request.community_id \
+         JOIN community_deletion_approvals approval ON approval.request_id = request.id \
+          AND approval.community_id = request.community_id \
+          AND approval.inventory_digest = request.inventory_digest \
+         WHERE request.id = $1 AND request.community_id = $6 \
+           AND request.stage = $2 AND request.lease_owner = $3 \
+           AND request.lease_generation = $4 AND request.lease_until >= now() \
+           AND request.blocked_at IS NULL AND request.fence_generation = $5 \
+           AND community.deletion_state IN ('fenced', 'tombstone') \
+           AND community.deletion_fence_generation = $5)",
+    )
+    .bind(token.request_id)
+    .bind(stage.to_string())
+    .bind(&token.owner)
+    .bind(token.generation)
+    .bind(fence_generation)
+    .bind(token.community_id.as_uuid())
+    .fetch_one(&mut **tx)
+    .await?;
+    if valid {
+        Ok(())
+    } else {
+        Err(DbError::AccessDenied(format!(
+            "stale lease or fencing generation for deletion {}",
+            token.request_id
+        )))
+    }
+}
+
+async fn set_executor_gucs(
+    tx: &mut Transaction<'_, Postgres>,
+    community: CommunityId,
+    generation: i64,
+) -> Result<()> {
+    sqlx::query(
+        "SELECT set_config('buzz.deletion_executor_community', $1, true), \
+                set_config('buzz.deletion_fence_generation', $2, true)",
+    )
+    .bind(community.to_string())
+    .bind(generation.to_string())
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+async fn advance_request_tx(
+    tx: &mut Transaction<'_, Postgres>,
+    token: &LeaseToken,
+    from: DeletionStage,
+    to: DeletionStage,
+    fence_generation: Option<i64>,
+) -> Result<()> {
+    if from.next() != Some(to) {
+        return Err(DbError::DeletionSafety(format!(
+            "illegal deletion transition {from} -> {to}"
+        )));
+    }
+    let affected = sqlx::query(
+        "UPDATE community_deletion_requests \
+         SET stage = $5, fence_generation = COALESCE($6, fence_generation), \
+             updated_at = now(), retry_count = 0, retry_stage = NULL, \
+             last_error = NULL, last_error_at = NULL \
+         WHERE id = $1 AND stage = $4 AND lease_owner = $2 \
+           AND lease_generation = $3 AND lease_until >= now() AND blocked_at IS NULL",
+    )
+    .bind(token.request_id)
+    .bind(&token.owner)
+    .bind(token.generation)
+    .bind(from.to_string())
+    .bind(to.to_string())
+    .bind(fence_generation)
+    .execute(&mut **tx)
+    .await?
+    .rows_affected();
+    if affected == 1 {
+        Ok(())
+    } else {
+        Err(stale_lease_error(token))
+    }
+}
+
+async fn checkpoint_completed_tx(
+    tx: &mut Transaction<'_, Postgres>,
+    token: &LeaseToken,
+    stage: DeletionStage,
+    unit_key: &str,
+    detail: serde_json::Value,
+) -> Result<()> {
+    sqlx::query(
+        r#"
+        INSERT INTO community_deletion_checkpoints
+            (request_id, stage, unit_key, status, lease_generation, detail, completed_at)
+        VALUES ($1, $2, $3, 'completed', $4, $5, now())
+        ON CONFLICT (request_id, stage, unit_key) DO UPDATE
+        SET status = 'completed', lease_generation = EXCLUDED.lease_generation,
+            attempts = community_deletion_checkpoints.attempts + 1,
+            detail = EXCLUDED.detail, error = NULL, completed_at = now()
+        "#,
+    )
+    .bind(token.request_id)
+    .bind(stage.to_string())
+    .bind(unit_key)
+    .bind(token.generation)
+    .bind(detail)
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+async fn checkpoint_failed_tx(
+    tx: &mut Transaction<'_, Postgres>,
+    token: &LeaseToken,
+    stage: DeletionStage,
+    unit_key: &str,
+    error: &str,
+) -> Result<()> {
+    sqlx::query(
+        r#"
+        INSERT INTO community_deletion_checkpoints
+            (request_id, stage, unit_key, status, lease_generation, error)
+        VALUES ($1, $2, $3, 'failed', $4, $5)
+        ON CONFLICT (request_id, stage, unit_key) DO UPDATE
+        SET status = 'failed', lease_generation = EXCLUDED.lease_generation,
+            attempts = community_deletion_checkpoints.attempts + 1,
+            error = EXCLUDED.error, completed_at = NULL
+        "#,
+    )
+    .bind(token.request_id)
+    .bind(stage.to_string())
+    .bind(unit_key)
+    .bind(token.generation)
+    .bind(error)
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+fn serialize_community_id<S>(
+    community: &CommunityId,
+    serializer: S,
+) -> std::result::Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.serialize_str(&community.to_string())
+}
+
+fn row_to_request(row: sqlx::postgres::PgRow) -> Result<DeletionRequest> {
+    let community_id: Uuid = row.try_get("community_id")?;
+    let digest: Option<Vec<u8>> = row.try_get("inventory_digest")?;
+    Ok(DeletionRequest {
+        id: row.try_get("id")?,
+        community_id: CommunityId::from_uuid(community_id),
+        community_host: row.try_get("community_host")?,
+        stage: row.try_get::<String, _>("stage")?.parse()?,
+        retry_stage: row
+            .try_get::<Option<String>, _>("retry_stage")?
+            .map(|stage| stage.parse())
+            .transpose()?,
+        requested_by: row.try_get("requested_by")?,
+        reason: row.try_get("reason")?,
+        schema_manifest: row.try_get("schema_manifest")?,
+        storage_manifest: row.try_get("storage_manifest")?,
+        destructive_storage_manifest: row.try_get("destructive_storage_manifest")?,
+        inventory_manifest: row.try_get("inventory_manifest")?,
+        inventory_digest: digest.map(hex::encode),
+        fence_generation: row.try_get("fence_generation")?,
+        lease_owner: row.try_get("lease_owner")?,
+        lease_generation: row.try_get("lease_generation")?,
+        lease_until: row.try_get("lease_until")?,
+        attempts: row.try_get("attempts")?,
+        retry_count: row.try_get("retry_count")?,
+        last_error: row.try_get("last_error")?,
+        next_attempt_at: row.try_get("next_attempt_at")?,
+        blocked_reason: row.try_get("blocked_reason")?,
+        created_at: row.try_get("created_at")?,
+        updated_at: row.try_get("updated_at")?,
+        pre_quiesce_archived_at: row.try_get("pre_quiesce_archived_at")?,
+        quiescing_started_at: row.try_get("quiescing_started_at")?,
+        aborted_by: row.try_get("aborted_by")?,
+        abort_reason: row.try_get("abort_reason")?,
+        aborted_at: row.try_get("aborted_at")?,
+        completed_at: row.try_get("completed_at")?,
+    })
+}
+
+/// Return whether an error is the deletion store's typed ownership-loss class.
+pub fn is_stale_deletion_lease(error: &DbError) -> bool {
+    matches!(error, DbError::AccessDenied(message) if message.starts_with("stale deletion lease ") || message.starts_with("stale lease or fencing generation for deletion "))
+}
+
+fn stale_lease_error(token: &LeaseToken) -> DbError {
+    DbError::AccessDenied(format!(
+        "stale deletion lease {} owner {:?} generation {}",
+        token.request_id, token.owner, token.generation
+    ))
+}
+
+fn require_fence_generation(token: &LeaseToken) -> Result<i64> {
+    token.fence_generation.ok_or_else(|| {
+        DbError::DeletionSafety(format!(
+            "deletion {} has no durable fence generation",
+            token.request_id
+        ))
+    })
+}
+
+fn bound_text(input: &str, max: usize) -> String {
+    if input.len() <= max {
+        return input.to_owned();
+    }
+    let mut end = max;
+    while !input.is_char_boundary(end) {
+        end -= 1;
+    }
+    input[..end].to_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn empty_prefix(prefix: &str) -> PrefixManifest {
+        PrefixManifest {
+            prefix: prefix.to_string(),
+            object_count: 0,
+            total_bytes: 0,
+            keys_digest: KeyStreamDigest::new().finish().0,
+        }
+    }
+
+    fn storage_manifest() -> StorageManifest {
+        StorageManifest {
+            version: 4,
+            prefixes: vec![
+                empty_prefix("_meta/c/"),
+                empty_prefix("_uploads/c/"),
+                empty_prefix("repos/c/"),
+            ],
+        }
+    }
+
+    #[test]
+    fn stage_order_is_exact_and_terminal() {
+        let mut stage = DeletionStage::Submitted;
+        let mut seen = vec![stage];
+        while let Some(next) = stage.next() {
+            stage = next;
+            seen.push(stage);
+        }
+        assert_eq!(
+            seen,
+            vec![
+                DeletionStage::Submitted,
+                DeletionStage::Inventoried,
+                DeletionStage::Approved,
+                DeletionStage::Fenced,
+                DeletionStage::Drained,
+                DeletionStage::BindingsRemoved,
+                DeletionStage::PostgresPurged,
+                DeletionStage::CachePurged,
+                DeletionStage::LogicallyVerified,
+                DeletionStage::RetentionPending,
+            ]
+        );
+        assert!(!DeletionStage::Submitted.runnable());
+        assert!(!DeletionStage::Inventoried.runnable());
+        assert!(DeletionStage::Approved.runnable());
+        assert!(!DeletionStage::RetentionPending.runnable());
+        assert!(!DeletionStage::Aborted.runnable());
+    }
+
+    #[test]
+    fn stale_lease_classifier_does_not_swallow_other_access_denials() {
+        let stale = stale_lease_error(&LeaseToken {
+            request_id: Uuid::new_v4(),
+            owner: "owner".to_string(),
+            generation: 1,
+            community_id: CommunityId::from_uuid(Uuid::new_v4()),
+            fence_generation: None,
+        });
+        assert!(is_stale_deletion_lease(&stale));
+        assert!(!is_stale_deletion_lease(&DbError::AccessDenied(
+            "ordinary authorization failure".to_string()
+        )));
+    }
+
+    #[test]
+    fn storage_manifest_shape_invariants_fail_closed() {
+        assert!(validate_storage_manifest(&storage_manifest()).is_ok());
+
+        let mut unsorted = storage_manifest();
+        unsorted.prefixes.swap(0, 1);
+        assert!(validate_storage_manifest(&unsorted).is_err());
+
+        let mut whole_bucket = storage_manifest();
+        whole_bucket.prefixes[0].prefix = String::new();
+        assert!(validate_storage_manifest(&whole_bucket).is_err());
+
+        let mut malformed_digest = storage_manifest();
+        malformed_digest.prefixes[0].keys_digest = "not-hex".to_string();
+        assert!(validate_storage_manifest(&malformed_digest).is_err());
+    }
+
+    #[test]
+    fn key_stream_digest_requires_strict_order_and_is_chunking_invariant() {
+        let keys = ["a/1", "a/2", "a/3"];
+        let mut whole = KeyStreamDigest::new();
+        for key in keys {
+            whole.fold(key).expect("ascending fold");
+        }
+        // The digest must not depend on where chunk boundaries fall.
+        let mut split = KeyStreamDigest::new();
+        split.fold(keys[0]).expect("chunk one");
+        split.fold(keys[1]).expect("chunk one");
+        split.fold(keys[2]).expect("chunk two");
+        assert_eq!(whole.finish(), split.finish());
+
+        let mut out_of_order = KeyStreamDigest::new();
+        out_of_order.fold("b").expect("first key");
+        assert!(out_of_order.fold("a").is_err());
+        let mut duplicate = KeyStreamDigest::new();
+        duplicate.fold("a").expect("first key");
+        assert!(duplicate.fold("a").is_err());
+    }
+
+    #[test]
+    fn manifest_key_chunks_must_hash_to_the_frozen_summaries() {
+        let keys = vec!["_meta/c/1".to_string(), "_meta/c/2".to_string()];
+        let mut digest = KeyStreamDigest::new();
+        for key in &keys {
+            digest.fold(key).expect("fold");
+        }
+        let (hex_digest, count) = digest.finish();
+        let mut manifest = storage_manifest();
+        manifest.prefixes[0].object_count = count;
+        manifest.prefixes[0].keys_digest = hex_digest;
+
+        let chunk = |chunk_no: i64, keys: &[String]| {
+            (
+                chunk_no,
+                "_meta/c/".to_string(),
+                sqlx::types::Json(keys.to_vec()),
+            )
+        };
+        assert!(validate_manifest_key_chunks(
+            &manifest,
+            &[chunk(0, &keys[..1]), chunk(1, &keys[1..])]
+        )
+        .is_ok());
+        // Missing, reordered, or extra keys change the digest.
+        assert!(validate_manifest_key_chunks(&manifest, &[chunk(0, &keys[..1])]).is_err());
+        // A gap in the chunk sequence is an interrupted write, not a manifest.
+        assert!(validate_manifest_key_chunks(&manifest, &[chunk(1, &keys)]).is_err());
+        // A key outside its chunk's prefix must never freeze.
+        let foreign = vec!["_uploads/other/1".to_string()];
+        assert!(
+            validate_manifest_key_chunks(&manifest, &[chunk(0, &keys), chunk(1, &foreign)])
+                .is_err()
+        );
+        // No chunks at all only matches an all-empty manifest.
+        assert!(validate_manifest_key_chunks(&manifest, &[]).is_err());
+        assert!(validate_manifest_key_chunks(&storage_manifest(), &[]).is_ok());
+    }
+
+    #[test]
+    fn frozen_inventory_digest_is_stable() {
+        let inventory = FrozenInventory {
+            schema: SchemaManifest {
+                scoped_tables: vec!["events".to_string()],
+                row_counts: BTreeMap::from([("events".to_string(), 3)]),
+                fenced_tables: vec!["events".to_string()],
+            },
+            storage: storage_manifest(),
+        };
+        assert_eq!(inventory.digest().unwrap(), inventory.digest().unwrap());
+        assert_eq!(inventory.digest().unwrap().len(), 32);
+    }
+
+    #[test]
+    fn errors_are_utf8_bounded() {
+        let input = format!("{}🛸", "x".repeat(4095));
+        let bounded = bound_text(&input, 4096);
+        assert!(bounded.len() <= 4096);
+        assert!(std::str::from_utf8(bounded.as_bytes()).is_ok());
+    }
+}
+
+#[cfg(test)]
+mod postgres_tests {
+    use super::*;
+    use crate::{CreateCommunityWithOwnerResult, Db, DbConfig};
+
+    async fn store() -> (Db, DeletionStore) {
+        let database_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .unwrap_or_else(|_| "postgres://buzz:buzz_dev@localhost:5432/buzz".to_string());
+        let db = Db::new(&DbConfig {
+            database_url,
+            max_connections: 5,
+            min_connections: 0,
+            ..DbConfig::default()
+        })
+        .await
+        .expect("connect deletion test DB");
+        db.migrate().await.expect("migrate deletion test DB");
+        let store = db.deletion_store();
+        (db, store)
+    }
+
+    fn empty_prefix_manifest(prefix: String) -> PrefixManifest {
+        PrefixManifest {
+            prefix,
+            object_count: 0,
+            total_bytes: 0,
+            keys_digest: KeyStreamDigest::new().finish().0,
+        }
+    }
+
+    fn empty_storage_manifest(community: CommunityId) -> StorageManifest {
+        StorageManifest {
+            version: 4,
+            prefixes: vec![
+                empty_prefix_manifest(format!("_meta/{community}/")),
+                empty_prefix_manifest(format!("_uploads/{community}/")),
+                empty_prefix_manifest(format!("repos/{community}/")),
+            ],
+        }
+    }
+
+    async fn inventoried_request(
+        db: &Db,
+        store: &DeletionStore,
+    ) -> (DeletionRequest, FrozenInventory) {
+        let host = format!("deletion-{}.example", Uuid::new_v4().simple());
+        let community = db
+            .ensure_configured_community(&host)
+            .await
+            .expect("create community");
+        let submitted = store
+            .submit(&host, "test-operator", Some("test deletion"))
+            .await
+            .expect("submit");
+        assert_eq!(submitted.community_id, community.id);
+        let inventory = FrozenInventory {
+            schema: store
+                .inventory_schema(community.id)
+                .await
+                .expect("schema inventory"),
+            storage: empty_storage_manifest(community.id),
+        };
+        let request = store
+            .freeze_inventory(submitted.id, &inventory)
+            .await
+            .expect("freeze inventory");
+        (request, inventory)
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn approval_boundary_blocks_claim_until_exact_inventory_is_approved() {
+        let (db, store) = store().await;
+        let (request, inventory) = inventoried_request(&db, &store).await;
+        assert_eq!(request.stage, DeletionStage::Inventoried);
+        assert!(store
+            .claim_specific(request.id, "executor-a", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim before approval")
+            .is_none());
+
+        // Row counts are frozen observational evidence. Ordinary serving
+        // churn after inventory does not invalidate approval: execution fences,
+        // purges, and verifies the live tenant state independently.
+        db.add_to_allowlist(request.community_id, &[7_u8; 32], &[8_u8; 32], None)
+            .await
+            .expect("post-inventory serving write");
+        let current_schema = store
+            .inventory_schema(request.community_id)
+            .await
+            .expect("live schema after row churn");
+        assert_eq!(
+            current_schema.row_counts["pubkey_allowlist"],
+            inventory.schema.row_counts["pubkey_allowlist"] + 1
+        );
+        assert_eq!(current_schema.scoped_tables, inventory.schema.scoped_tables);
+        assert_eq!(current_schema.fenced_tables, inventory.schema.fenced_tables);
+
+        let mismatched_insert = sqlx::query(
+            "INSERT INTO community_deletion_approvals \
+             (request_id, community_id, inventory_digest, approved_by) \
+             VALUES ($1, $2, $3, 'tampered')",
+        )
+        .bind(request.id)
+        .bind(*request.community_id.as_uuid())
+        .bind(vec![0_u8; 32])
+        .execute(&db.pool)
+        .await;
+        assert!(
+            mismatched_insert.is_err(),
+            "a mismatched approval must be unrepresentable"
+        );
+        let approved = store
+            .approve(request.id, "approver-a", Some("reviewed"))
+            .await
+            .expect("approve");
+        assert_eq!(approved.stage, DeletionStage::Approved);
+        assert_eq!(
+            approved.inventory_digest,
+            Some(hex::encode(inventory.digest().unwrap()))
+        );
+        let mismatched_approval = sqlx::query(
+            "UPDATE community_deletion_approvals SET inventory_digest = $2 WHERE request_id = $1",
+        )
+        .bind(request.id)
+        .bind(vec![0_u8; 32])
+        .execute(&db.pool)
+        .await;
+        assert!(
+            mismatched_approval.is_err(),
+            "approval digest must remain database-bound to the frozen request digest"
+        );
+        let mismatched_request = sqlx::query(
+            "UPDATE community_deletion_requests SET inventory_digest = $2 WHERE id = $1",
+        )
+        .bind(request.id)
+        .bind(vec![1_u8; 32])
+        .execute(&db.pool)
+        .await;
+        assert!(
+            mismatched_request.is_err(),
+            "the frozen request digest must remain bound to its approval"
+        );
+        assert!(store
+            .claim_specific(request.id, "executor-a", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim approved")
+            .is_some());
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn approved_request_cannot_be_retargeted_rewritten_or_claimed_without_approval() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        let other_host = format!("control-{}.example", Uuid::new_v4().simple());
+        let control = db
+            .ensure_configured_community(&other_host)
+            .await
+            .expect("create control community");
+
+        for mutation in [
+            sqlx::query("UPDATE community_deletion_requests SET community_id = $2 WHERE id = $1")
+                .bind(request.id)
+                .bind(*control.id.as_uuid())
+                .execute(&db.pool)
+                .await,
+            sqlx::query("UPDATE community_deletion_requests SET community_host = $2 WHERE id = $1")
+                .bind(request.id)
+                .bind(&other_host)
+                .execute(&db.pool)
+                .await,
+            sqlx::query(
+                "UPDATE community_deletion_requests SET inventory_manifest = '{}'::jsonb WHERE id = $1",
+            )
+            .bind(request.id)
+            .execute(&db.pool)
+            .await,
+            sqlx::query(
+                "UPDATE community_deletion_requests SET storage_manifest = '{}'::jsonb WHERE id = $1",
+            )
+            .bind(request.id)
+            .execute(&db.pool)
+            .await,
+        ] {
+            assert!(mutation.is_err(), "frozen deletion target and inventory must be immutable");
+        }
+
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve request");
+        let claim = store
+            .claim_specific(request.id, "forged-executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim approved request")
+            .expect("approved request is claimable");
+        let approval_delete =
+            sqlx::query("DELETE FROM community_deletion_approvals WHERE request_id = $1")
+                .bind(request.id)
+                .execute(&db.pool)
+                .await;
+        assert!(
+            approval_delete.is_err(),
+            "approval evidence must be immutable"
+        );
+        for approval_update in [
+            "UPDATE community_deletion_approvals SET approved_by = 'forged' WHERE request_id = $1",
+            "UPDATE community_deletion_approvals SET approved_at = now() + interval '1 hour' WHERE request_id = $1",
+            "UPDATE community_deletion_approvals SET note = 'rewritten' WHERE request_id = $1",
+        ] {
+            assert!(
+                sqlx::query(approval_update)
+                    .bind(request.id)
+                    .execute(&db.pool)
+                    .await
+                    .is_err(),
+                "approval evidence updates must be rejected"
+            );
+        }
+        store
+            .verify_execution_token(&claim.lease, DeletionStage::Approved)
+            .await
+            .expect("matching approval keeps lease valid");
+        sqlx::query(
+            "UPDATE community_deletion_requests \
+             SET blocked_at = now(), blocked_reason = 'operator hold' WHERE id = $1",
+        )
+        .bind(request.id)
+        .execute(&db.pool)
+        .await
+        .expect("block claimed request");
+        assert!(
+            store
+                .heartbeat(&claim.lease, "worker", DEFAULT_LEASE_DURATION, false,)
+                .await
+                .is_err(),
+            "blocked requests must not renew destructive leases"
+        );
+
+        let (forged, _) = inventoried_request(&db, &store).await;
+        sqlx::query("UPDATE community_deletion_requests SET stage = 'approved' WHERE id = $1")
+            .bind(forged.id)
+            .execute(&db.pool)
+            .await
+            .expect("forge runnable stage without approval");
+        assert!(store
+            .claim_specific(forged.id, "forged-executor-2", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim forged request")
+            .is_none());
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn retry_exhaustion_blocks_only_the_consecutive_stage_and_progress_resets_it() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+
+        for attempt in 1..=8 {
+            let claim = store
+                .claim_specific(
+                    request.id,
+                    &format!("executor-{attempt}"),
+                    DEFAULT_LEASE_DURATION,
+                )
+                .await
+                .expect("claim retryable request")
+                .expect("request remains claimable before exhaustion");
+            store
+                .record_retry(
+                    &claim.lease,
+                    DeletionStage::Approved,
+                    "dependency",
+                    "dependency unavailable",
+                    Duration::ZERO,
+                )
+                .await
+                .expect("record retry");
+
+            let observed = store.get(request.id).await.expect("load retry state");
+            assert_eq!(observed.retry_count, attempt);
+            assert_eq!(observed.retry_stage, Some(DeletionStage::Approved));
+            assert_eq!(observed.blocked_reason.is_some(), attempt == 8);
+        }
+        assert!(store
+            .claim_specific(request.id, "blocked-executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim blocked request")
+            .is_none());
+
+        let recovered = store
+            .unblock(request.id, "operator", "dependency repaired")
+            .await
+            .expect("unblock exhausted request");
+        assert_eq!(recovered.retry_count, 0);
+        assert_eq!(recovered.retry_stage, None);
+        assert!(recovered.blocked_reason.is_none());
+
+        let claim = store
+            .claim_specific(request.id, "successor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim recovered request")
+            .expect("recovered request is claimable");
+        store
+            .begin_quiescing(&claim.lease)
+            .await
+            .expect("begin quiescing after recovery");
+        store.fence(&claim.lease).await.expect("advance stage");
+        let advanced = store.get(request.id).await.expect("load advanced request");
+        assert_eq!(advanced.stage, DeletionStage::Fenced);
+        assert_eq!(advanced.retry_count, 0);
+        assert_eq!(advanced.retry_stage, None);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn abort_serializes_before_quiescing_without_deadlock() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        let mut gate = db.pool.begin().await.expect("begin lock gate");
+        sqlx::query("SELECT pg_advisory_xact_lock(community_deletion_lock_key($1))")
+            .bind(request.community_id.as_uuid())
+            .execute(&mut *gate)
+            .await
+            .expect("hold community lock");
+
+        let abort_store = store.clone();
+        let aborting = tokio::spawn(async move {
+            abort_store
+                .abort(request.id, "operator", "race recovery")
+                .await
+        });
+        tokio::time::sleep(Duration::from_millis(50)).await;
+        assert!(
+            !aborting.is_finished(),
+            "abort must wait for the community lock"
+        );
+        let forward_store = store.clone();
+        let lease = claim.lease.clone();
+        let forwarding = tokio::spawn(async move { forward_store.begin_quiescing(&lease).await });
+        tokio::time::sleep(Duration::from_millis(50)).await;
+        assert!(
+            !forwarding.is_finished(),
+            "forward transition must queue on the same lock"
+        );
+        gate.commit().await.expect("release lock gate");
+
+        let aborted = tokio::time::timeout(Duration::from_secs(5), aborting)
+            .await
+            .expect("abort must not deadlock")
+            .expect("abort task")
+            .expect("abort wins lock queue");
+        assert_eq!(aborted.stage, DeletionStage::Aborted);
+        let forward_error = tokio::time::timeout(Duration::from_secs(5), forwarding)
+            .await
+            .expect("forward transition must not deadlock")
+            .expect("forward task")
+            .expect_err("post-lock lease verification rejects aborted request");
+        assert!(
+            !matches!(
+                &forward_error,
+                DbError::Sqlx(sqlx::Error::Database(error)) if error.code().as_deref() == Some("40P01")
+            ),
+            "serialization must not report a PostgreSQL deadlock"
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn abort_serializes_before_fence_without_deadlock() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        store.begin_quiescing(&claim.lease).await.expect("quiesce");
+        let mut gate = db.pool.begin().await.expect("begin lock gate");
+        sqlx::query("SELECT pg_advisory_xact_lock(community_deletion_lock_key($1))")
+            .bind(request.community_id.as_uuid())
+            .execute(&mut *gate)
+            .await
+            .expect("hold community lock");
+
+        let abort_store = store.clone();
+        let aborting = tokio::spawn(async move {
+            abort_store
+                .abort(request.id, "operator", "race recovery")
+                .await
+        });
+        tokio::time::sleep(Duration::from_millis(50)).await;
+        assert!(
+            !aborting.is_finished(),
+            "abort must wait for the community lock"
+        );
+        let forward_store = store.clone();
+        let lease = claim.lease.clone();
+        let forwarding = tokio::spawn(async move { forward_store.fence(&lease).await });
+        tokio::time::sleep(Duration::from_millis(50)).await;
+        assert!(
+            !forwarding.is_finished(),
+            "fence must queue on the same lock"
+        );
+        gate.commit().await.expect("release lock gate");
+
+        let aborted = tokio::time::timeout(Duration::from_secs(5), aborting)
+            .await
+            .expect("abort must not deadlock")
+            .expect("abort task")
+            .expect("abort wins lock queue");
+        assert_eq!(aborted.stage, DeletionStage::Aborted);
+        let forward_error = tokio::time::timeout(Duration::from_secs(5), forwarding)
+            .await
+            .expect("fence must not deadlock")
+            .expect("fence task")
+            .expect_err("post-lock lease verification rejects aborted request");
+        assert!(
+            !matches!(
+                &forward_error,
+                DbError::Sqlx(sqlx::Error::Database(error)) if error.code().as_deref() == Some("40P01")
+            ),
+            "serialization must not report a PostgreSQL deadlock"
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn abort_preserves_audit_and_allows_fresh_request() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let aborted = store
+            .abort(request.id, "operator", "cancel deletion")
+            .await
+            .expect("abort");
+        assert_eq!(aborted.stage, DeletionStage::Aborted);
+
+        let replacement = store
+            .submit(
+                &request.community_host,
+                "second-operator",
+                Some("fresh review"),
+            )
+            .await
+            .expect("submit replacement request");
+        assert_ne!(replacement.id, request.id);
+        assert_eq!(replacement.stage, DeletionStage::Submitted);
+        assert!(replacement.inventory_digest.is_none());
+        assert_eq!(
+            store.get(request.id).await.expect("preserved audit").stage,
+            DeletionStage::Aborted
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn preclaim_setup_failure_is_durable_without_a_lease() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let blocked = store
+            .block_preclaim_setup(
+                request.id,
+                "pre_claim:service_setup",
+                "BUZZ_S3_ENDPOINT is required",
+            )
+            .await
+            .expect("record setup failure");
+        assert_eq!(blocked.stage, DeletionStage::Approved);
+        assert_eq!(
+            blocked.blocked_reason.as_deref(),
+            Some("BUZZ_S3_ENDPOINT is required")
+        );
+        assert_eq!(
+            blocked.last_error.as_deref(),
+            Some("BUZZ_S3_ENDPOINT is required")
+        );
+        assert!(blocked.lease_owner.is_none());
+        let inspection = store.inspect(request.id).await.expect("inspect failure");
+        let checkpoint = inspection
+            .checkpoints
+            .iter()
+            .find(|checkpoint| checkpoint.unit_key == "pre_claim:service_setup")
+            .expect("setup failure checkpoint");
+        assert_eq!(checkpoint.status, "failed");
+        assert_eq!(
+            checkpoint.error.as_deref(),
+            Some("BUZZ_S3_ENDPOINT is required")
+        );
+        assert_eq!(checkpoint.attempts, 1);
+        assert!(checkpoint.completed_at.is_none());
+
+        store
+            .unblock(request.id, "operator", "dependency repaired")
+            .await
+            .expect("unblock after first setup failure");
+        let blocked_again = store
+            .block_preclaim_setup(
+                request.id,
+                "pre_claim:service_setup",
+                "BUZZ_REDIS_URL is required",
+            )
+            .await
+            .expect("record repeated setup failure");
+        assert_eq!(
+            blocked_again.blocked_reason.as_deref(),
+            Some("BUZZ_REDIS_URL is required")
+        );
+        assert_eq!(
+            blocked_again.last_error.as_deref(),
+            Some("BUZZ_REDIS_URL is required")
+        );
+        let repeated = store
+            .inspect(request.id)
+            .await
+            .expect("inspect repeated failure");
+        let checkpoint = repeated
+            .checkpoints
+            .iter()
+            .find(|checkpoint| checkpoint.unit_key == "pre_claim:service_setup")
+            .expect("repeated setup failure checkpoint");
+        assert_eq!(checkpoint.status, "failed");
+        assert_eq!(checkpoint.attempts, 2);
+        assert_eq!(
+            checkpoint.error.as_deref(),
+            Some("BUZZ_REDIS_URL is required")
+        );
+        assert_eq!(
+            checkpoint
+                .detail
+                .get("error")
+                .and_then(|value| value.as_str()),
+            Some("BUZZ_REDIS_URL is required")
+        );
+        assert!(checkpoint.completed_at.is_none());
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn operator_unblock_preserves_approval_and_records_recovery() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("approved request is claimable");
+        store
+            .block(
+                &claim.lease,
+                DeletionStage::Approved,
+                "dependency",
+                "operator repair required",
+            )
+            .await
+            .expect("block request");
+
+        assert!(store.unblock(request.id, "", "repair").await.is_err());
+        let recovered = store
+            .unblock(request.id, "operator", "bucket policy repaired")
+            .await
+            .expect("unblock after remediation");
+        assert_eq!(recovered.stage, DeletionStage::Approved);
+        assert!(recovered.blocked_reason.is_none());
+        assert!(recovered.last_error.is_none());
+        assert_eq!(recovered.inventory_digest, request.inventory_digest);
+        assert_eq!(recovered.fence_generation, request.fence_generation);
+        assert!(store
+            .unblock(request.id, "operator", "again")
+            .await
+            .is_err());
+        assert!(store
+            .claim_specific(request.id, "successor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim recovered request")
+            .is_some());
+
+        let inspection = store.inspect(request.id).await.expect("inspect recovery");
+        assert!(inspection.checkpoints.iter().any(|checkpoint| {
+            checkpoint.unit_key.starts_with("operator_unblock:")
+                && checkpoint.detail["unblocked_by"] == "operator"
+                && checkpoint.detail["reason"] == "bucket policy repaired"
+                && checkpoint.detail["previous_block"] == "operator repair required"
+        }));
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn stale_claim_and_fence_generation_fail_closed() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        let mut stale = claim.lease.clone();
+        stale.generation -= 1;
+        assert!(
+            store.fence(&stale).await.is_err(),
+            "stale lease must reject"
+        );
+        let mut wrong_community = claim.lease.clone();
+        wrong_community.community_id = db
+            .ensure_configured_community(&format!(
+                "wrong-lease-community-{}.example",
+                Uuid::new_v4().simple()
+            ))
+            .await
+            .expect("create unrelated community")
+            .id;
+        assert!(
+            store.begin_quiescing(&wrong_community).await.is_err(),
+            "a lease token must remain bound to its durable request community"
+        );
+
+        store.begin_quiescing(&claim.lease).await.expect("quiesce");
+        let generation = store.fence(&claim.lease).await.expect("fence");
+        let mut wrong_fence = claim.lease.clone();
+        wrong_fence.fence_generation = Some(generation + 1);
+        assert!(
+            store.mark_drained(&wrong_fence).await.is_err(),
+            "wrong fence generation must reject"
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn fence_waits_for_open_write_and_rejects_it_after_transition() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+
+        let mut open_write = db
+            .begin_transaction()
+            .await
+            .expect("open write transaction");
+        sqlx::query("INSERT INTO pubkey_allowlist (community_id, pubkey) VALUES ($1, $2)")
+            .bind(request.community_id.as_uuid())
+            .bind(vec![7_u8; 32])
+            .execute(&mut *open_write)
+            .await
+            .expect("write acquires shared deletion lock");
+
+        let store_for_fence = store.clone();
+        let lease = claim.lease.clone();
+        let fencing = tokio::spawn(async move {
+            store_for_fence.begin_quiescing(&lease).await?;
+            store_for_fence.fence(&lease).await
+        });
+        tokio::time::sleep(Duration::from_millis(50)).await;
+        assert!(
+            !fencing.is_finished(),
+            "exclusive fence must wait for open writer"
+        );
+        open_write
+            .commit()
+            .await
+            .expect("pre-fence writer commits first");
+        fencing.await.expect("fence task").expect("fence completes");
+
+        assert!(
+            db.add_to_allowlist(request.community_id, &[8_u8; 32], &[9_u8; 32], None)
+                .await
+                .is_err(),
+            "post-fence serving write must fail"
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn write_assertion_rejects_pinned_snapshot_isolation_before_authorization() {
+        let (db, _) = store().await;
+        let community = db
+            .ensure_configured_community(&format!(
+                "isolation-guard-{}.example",
+                Uuid::new_v4().simple()
+            ))
+            .await
+            .expect("create community")
+            .id;
+
+        for isolation in ["REPEATABLE READ", "SERIALIZABLE"] {
+            let mut tx = db.pool.begin().await.expect("begin isolation probe");
+            sqlx::query(sqlx::AssertSqlSafe(format!(
+                "SET TRANSACTION ISOLATION LEVEL {isolation}"
+            )))
+            .execute(&mut *tx)
+            .await
+            .expect("set transaction isolation");
+            sqlx::query(
+                "SELECT set_config('buzz.deletion_executor_community', $1, true), \
+                        set_config('buzz.deletion_fence_generation', '0', true)",
+            )
+            .bind(community.to_string())
+            .execute(&mut *tx)
+            .await
+            .expect("forge executor authorization");
+            let error = sqlx::query("SELECT assert_community_write_allowed($1)")
+                .bind(community.as_uuid())
+                .execute(&mut *tx)
+                .await
+                .expect_err("pinned snapshot isolation must fail before authorization");
+            assert_eq!(
+                error
+                    .as_database_error()
+                    .and_then(|error| error.code())
+                    .as_deref(),
+                Some("25000")
+            );
+        }
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn quiescing_rejects_new_leases_but_renews_admitted_lease_until_release() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        let mut serving = store
+            .acquire_serving_write_lease(
+                request.community_id,
+                "test_external",
+                "test-owner",
+                DEFAULT_LEASE_DURATION,
+            )
+            .await
+            .expect("serving lease");
+
+        store
+            .begin_quiescing(&claim.lease)
+            .await
+            .expect("persist quiescing");
+        assert!(matches!(
+            store
+                .acquire_serving_write_lease(
+                    request.community_id,
+                    "late_external",
+                    "late-owner",
+                    DEFAULT_LEASE_DURATION,
+                )
+                .await,
+            Err(DbError::AccessDenied(_))
+        ));
+        assert!(store.verify_serving_write_lease(&serving).await.is_ok());
+        let lease_until_before_renewal = serving.lease_until;
+        tokio::time::sleep(Duration::from_millis(10)).await;
+        store
+            .renew_serving_write_lease(&mut serving, DEFAULT_LEASE_DURATION)
+            .await
+            .expect("admitted lease renews while quiescing");
+        assert!(
+            serving.lease_until > lease_until_before_renewal,
+            "renewal must extend the admitted lease"
+        );
+        assert!(matches!(
+            store.fence(&claim.lease).await,
+            Err(DbError::ServingWritesNotDrained {
+                active_count: 1,
+                ..
+            })
+        ));
+        assert!(store
+            .release_serving_write_lease(&serving)
+            .await
+            .expect("release"));
+        assert_eq!(store.fence(&claim.lease).await.expect("fence"), 1);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn sustained_admission_cannot_starve_fence_after_quiescing() {
+        let (db, store) = store().await;
+        let (request, _) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        store.begin_quiescing(&claim.lease).await.expect("quiesce");
+
+        for attempt in 0..100 {
+            assert!(matches!(
+                store
+                    .acquire_serving_write_lease(
+                        request.community_id,
+                        "sustained_admission",
+                        &format!("owner-{attempt}"),
+                        DEFAULT_LEASE_DURATION,
+                    )
+                    .await,
+                Err(DbError::AccessDenied(_))
+            ));
+        }
+        assert_eq!(store.fence(&claim.lease).await.expect("fence"), 1);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn serving_lease_reaper_is_bounded_and_reports_stats() {
+        let (db, store) = store().await;
+        let host = format!("lease-reaper-{}.example", Uuid::new_v4().simple());
+        let community = db
+            .ensure_configured_community(&host)
+            .await
+            .expect("community")
+            .id;
+        for owner in ["expired-a", "expired-b", "expired-c"] {
+            let lease = store
+                .acquire_serving_write_lease(
+                    community,
+                    "reaper_test",
+                    owner,
+                    Duration::from_secs(1),
+                )
+                .await
+                .expect("lease");
+            sqlx::query("UPDATE community_serving_write_leases SET lease_until = now() - interval '1 second' WHERE id = $1")
+                .bind(lease.id)
+                .execute(&db.pool)
+                .await
+                .expect("expire lease");
+        }
+        let before = store.serving_lease_stats().await.expect("stats before");
+        assert!(before.expired >= 3);
+        assert_eq!(store.reap_expired_serving_write_leases(2).await.unwrap(), 2);
+        let after = store.serving_lease_stats().await.expect("stats after");
+        assert_eq!(after.expired, before.expired - 2);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn serving_lease_reaper_remains_global_across_tombstoned_tenant() {
+        let (db, store) = store().await;
+        let active_a = db
+            .ensure_configured_community(&format!("lease-a-{}.example", Uuid::new_v4().simple()))
+            .await
+            .expect("active A")
+            .id;
+        let target = db
+            .ensure_configured_community(&format!("lease-t-{}.example", Uuid::new_v4().simple()))
+            .await
+            .expect("target T")
+            .id;
+        let active_x = db
+            .ensure_configured_community(&format!("lease-x-{}.example", Uuid::new_v4().simple()))
+            .await
+            .expect("active X")
+            .id;
+        store
+            .reap_expired_serving_write_leases(10_000)
+            .await
+            .expect("clear unrelated expired leases");
+        for (community, owner) in [(active_a, "a"), (target, "t"), (active_x, "x")] {
+            let lease = store
+                .acquire_serving_write_lease(
+                    community,
+                    "global_reaper_test",
+                    owner,
+                    DEFAULT_LEASE_DURATION,
+                )
+                .await
+                .expect("acquire lease");
+            sqlx::query(
+                "UPDATE community_serving_write_leases \
+                 SET lease_until = now() - interval '1 second' WHERE id = $1",
+            )
+            .bind(lease.id)
+            .execute(&db.pool)
+            .await
+            .expect("expire lease");
+        }
+        let mut lifecycle = db.pool.begin().await.expect("begin target lifecycle");
+        sqlx::query(
+            "SELECT set_config('buzz.deletion_executor_community', $1, true), \
+                    set_config('buzz.deletion_fence_generation', '1', true)",
+        )
+        .bind(target.to_string())
+        .execute(&mut *lifecycle)
+        .await
+        .expect("authorize tombstone fixture");
+        sqlx::query(
+            "UPDATE communities SET deletion_state = 'tombstone', \
+                    deletion_fence_generation = 1, deleted_at = now() WHERE id = $1",
+        )
+        .bind(target.as_uuid())
+        .execute(&mut *lifecycle)
+        .await
+        .expect("tombstone target");
+        lifecycle.commit().await.expect("commit tombstone fixture");
+
+        assert_eq!(
+            store
+                .reap_expired_serving_write_leases(10)
+                .await
+                .expect("global lease reap"),
+            3
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn checkpointed_resume_is_idempotent_and_tombstone_blocks_name_reuse() {
+        let (db, store) = store().await;
+        let (request, inventory) = inventoried_request(&db, &store).await;
+        let host = request.community_host.clone();
+        let read_state_d_tag = format!("read-state:{}", "a".repeat(32));
+        sqlx::query(
+            "INSERT INTO events \
+             (community_id, id, pubkey, created_at, kind, tags, content, sig, d_tag) \
+             VALUES ($1, $2, $3, now(), 30078, $4, '', $5, $6)",
+        )
+        .bind(request.community_id.as_uuid())
+        .bind(vec![1_u8; 32])
+        .bind(vec![2_u8; 32])
+        .bind(serde_json::json!([
+            ["d", &read_state_d_tag],
+            ["t", "read-state"]
+        ]))
+        .bind(vec![3_u8; 64])
+        .bind(&read_state_d_tag)
+        .execute(&db.pool)
+        .await
+        .expect("insert guarded NIP-RS row");
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        store.begin_quiescing(&claim.lease).await.expect("quiesce");
+        let generation = store.fence(&claim.lease).await.expect("fence");
+        let token = LeaseToken {
+            fence_generation: Some(generation),
+            ..claim.lease
+        };
+        store
+            .freeze_destructive_storage_manifest(&token, &inventory.storage)
+            .await
+            .expect("freeze destructive storage");
+        store
+            .freeze_destructive_storage_manifest(&token, &inventory.storage)
+            .await
+            .expect("identical destructive manifest retry");
+        let mut drifted_storage = inventory.storage.clone();
+        let mut drifted_digest = KeyStreamDigest::new();
+        drifted_digest
+            .fold("media/drifted-after-fence")
+            .expect("fold drifted key");
+        let (drifted_hex, drifted_count) = drifted_digest.finish();
+        drifted_storage.prefixes[0].object_count = drifted_count;
+        drifted_storage.prefixes[0].keys_digest = drifted_hex;
+        assert!(matches!(
+            store
+                .freeze_destructive_storage_manifest(&token, &drifted_storage)
+                .await,
+            Err(DbError::DeletionSafety(_))
+        ));
+        for mutation in [
+            sqlx::query(
+                "UPDATE community_deletion_requests \
+                 SET destructive_storage_manifest = '{}'::jsonb WHERE id = $1",
+            )
+            .bind(request.id)
+            .execute(&db.pool)
+            .await,
+            sqlx::query(
+                "UPDATE community_deletion_requests \
+                 SET destructive_storage_frozen_at = destructive_storage_frozen_at + interval '1 second' \
+                 WHERE id = $1",
+            )
+            .bind(request.id)
+            .execute(&db.pool)
+            .await,
+        ] {
+            assert!(
+                mutation.is_err(),
+                "frozen destructive storage evidence must be immutable"
+            );
+        }
+        store.mark_drained(&token).await.expect("drain");
+        store
+            .mark_bindings_removed(&token, serde_json::json!({"keys": 0}))
+            .await
+            .expect("bindings");
+        let first = store.purge_postgres(&token).await.expect("purge postgres");
+        assert_eq!(first.len(), EXPECTED_SCOPED_TABLES.len());
+        assert!(
+            store.purge_postgres(&token).await.is_err(),
+            "completed stage cannot be replayed under stale checkpoint state"
+        );
+        store
+            .mark_cache_purged(&token, serde_json::json!({"keys": 0}))
+            .await
+            .expect("cache");
+        store
+            .verify_postgres_logically_deleted(&token)
+            .await
+            .expect("logical postgres verify");
+        store
+            .mark_logically_verified(&token, serde_json::json!({"all": true}))
+            .await
+            .expect("mark verified");
+        store
+            .mark_retention_pending(&token, serde_json::json!({"shared_cas": "retained"}))
+            .await
+            .expect("terminal");
+
+        let terminal = store.get(request.id).await.expect("terminal request");
+        assert_eq!(terminal.stage, DeletionStage::RetentionPending);
+        let recreated = db
+            .create_community_with_owner(
+                &host,
+                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            )
+            .await
+            .expect("recreate attempt");
+        assert_eq!(recreated, CreateCommunityWithOwnerResult::HostExists);
+        assert!(db
+            .lookup_community_by_host_for_management(&host)
+            .await
+            .expect("tombstone lookup")
+            .is_some());
+        assert!(db
+            .lookup_community_by_host(&host)
+            .await
+            .expect("serving lookup")
+            .is_none());
+        let direct_delete = sqlx::query("DELETE FROM communities WHERE id = $1")
+            .bind(request.community_id.as_uuid())
+            .execute(&db.pool)
+            .await
+            .expect_err("tombstone row must be permanent");
+        assert!(direct_delete
+            .to_string()
+            .contains("tombstones are permanent"));
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn taxonomy_sweep_uses_database_completion_order() {
+        let (_, store) = store().await;
+        store
+            .record_taxonomy_sweep(Utc::now() + chrono::Duration::minutes(1), 1, 0, &[], 100)
+            .await
+            .expect("record skewed clean sweep");
+        let dirty = store
+            .record_taxonomy_sweep(Utc::now(), 1, 1, &["unknown".to_string()], 100)
+            .await
+            .expect("record later dirty sweep");
+
+        assert_eq!(
+            store
+                .latest_taxonomy_sweep()
+                .await
+                .expect("latest sweep")
+                .unwrap()
+                .id,
+            dirty.id
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn manifest_key_chunks_bind_freeze_execution_and_cleanup() {
+        let (db, store) = store().await;
+        let (request, inventory) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        store.begin_quiescing(&claim.lease).await.expect("quiesce");
+        let generation = store.fence(&claim.lease).await.expect("fence");
+        let token = LeaseToken {
+            fence_generation: Some(generation),
+            ..claim.lease
+        };
+
+        let meta_prefix = format!("_meta/{}/", request.community_id);
+        let keys = vec![
+            format!("{meta_prefix}{}.json", "a".repeat(64)),
+            format!("{meta_prefix}{}.json", "b".repeat(64)),
+        ];
+        store
+            .append_manifest_key_chunk(&token, 0, &meta_prefix, &keys[..1])
+            .await
+            .expect("append chunk 0");
+        store
+            .append_manifest_key_chunk(&token, 1, &meta_prefix, &keys[1..])
+            .await
+            .expect("append chunk 1");
+
+        // A manifest whose digests do not cover the chunk stream must not freeze.
+        assert!(matches!(
+            store
+                .freeze_destructive_storage_manifest(&token, &inventory.storage)
+                .await,
+            Err(DbError::DeletionSafety(_))
+        ));
+        let mut digest = KeyStreamDigest::new();
+        for key in &keys {
+            digest.fold(key).expect("fold key");
+        }
+        let (hex_digest, count) = digest.finish();
+        let mut storage = inventory.storage.clone();
+        storage.prefixes[0].object_count = count;
+        storage.prefixes[0].total_bytes = 2;
+        storage.prefixes[0].keys_digest = hex_digest;
+        store
+            .freeze_destructive_storage_manifest(&token, &storage)
+            .await
+            .expect("freeze manifest matching chunks");
+
+        // Frozen chunks are immutable working data until terminal cleanup.
+        assert!(sqlx::query(
+            "UPDATE community_deletion_manifest_keys SET keys = '[]'::jsonb \
+             WHERE request_id = $1 AND chunk_no = 0",
+        )
+        .bind(request.id)
+        .execute(&db.pool)
+        .await
+        .is_err());
+        assert!(
+            sqlx::query("DELETE FROM community_deletion_manifest_keys WHERE request_id = $1")
+                .bind(request.id)
+                .execute(&db.pool)
+                .await
+                .is_err()
+        );
+        assert!(store.clear_manifest_key_chunks(&token).await.is_err());
+        assert!(
+            sqlx::query(
+                "INSERT INTO community_deletion_manifest_keys \
+                 (request_id, chunk_no, prefix, keys) VALUES ($1, 2, $2, $3)",
+            )
+            .bind(request.id)
+            .bind(&meta_prefix)
+            .bind(sqlx::types::Json(&keys[..1]))
+            .execute(&db.pool)
+            .await
+            .is_err(),
+            "the database must reject chunks appended after freeze"
+        );
+
+        store.mark_drained(&token).await.expect("drained");
+        let first = store
+            .next_pending_manifest_chunk(&token)
+            .await
+            .expect("pending chunk")
+            .expect("chunk 0 pending");
+        assert_eq!(first.chunk_no, 0);
+        assert_eq!(first.keys, keys[..1]);
+        store
+            .mark_manifest_chunk_deleted(&token, 0, serde_json::json!({"deleted": 1}))
+            .await
+            .expect("stamp chunk 0");
+        assert!(
+            matches!(
+                store
+                    .mark_manifest_chunk_deleted(&token, 0, serde_json::json!({}))
+                    .await,
+                Err(DbError::DeletionSafety(_))
+            ),
+            "a chunk stamp is one-way"
+        );
+        let second = store
+            .next_pending_manifest_chunk(&token)
+            .await
+            .expect("pending chunk")
+            .expect("chunk 1 pending after resume");
+        assert_eq!(second.chunk_no, 1);
+        store
+            .mark_manifest_chunk_deleted(&token, 1, serde_json::json!({"deleted": 1}))
+            .await
+            .expect("stamp chunk 1");
+        assert!(store
+            .next_pending_manifest_chunk(&token)
+            .await
+            .expect("pending chunk")
+            .is_none());
+        assert_eq!(
+            store
+                .manifest_chunk_progress(request.id)
+                .await
+                .expect("progress"),
+            (2, 2)
+        );
+
+        store
+            .mark_bindings_removed(&token, serde_json::json!({"deleted_keys": 2}))
+            .await
+            .expect("bindings removed");
+        store.purge_postgres(&token).await.expect("purge postgres");
+        store
+            .mark_cache_purged(&token, serde_json::json!({"keys": 0}))
+            .await
+            .expect("cache purged");
+        store
+            .verify_postgres_logically_deleted(&token)
+            .await
+            .expect("verify postgres");
+        store
+            .mark_logically_verified(&token, serde_json::json!({"all": true}))
+            .await
+            .expect("logically verified");
+        assert_eq!(
+            store
+                .manifest_chunk_progress(request.id)
+                .await
+                .expect("progress after terminal cleanup"),
+            (0, 0)
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn destructive_stages_serialize_with_migrations_and_fail_closed_on_new_scoped_tables() {
+        // The probe table below mutates the live catalog, which every other
+        // test in the shared database validates against. Run the whole
+        // scenario in a dedicated database so concurrent purge/verify tests
+        // never observe the drifted surface; advisory locks are also
+        // per-database, so the parked migration lock cannot stall them.
+        let base_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .unwrap_or_else(|_| "postgres://buzz:buzz_dev@localhost:5432/buzz".to_string());
+        let admin = PgPool::connect(&base_url)
+            .await
+            .expect("connect admin database");
+        let probe_db = format!("buzz_lock_probe_{}", Uuid::new_v4().simple());
+        sqlx::query(AssertSqlSafe(format!("CREATE DATABASE {probe_db}")))
+            .execute(&admin)
+            .await
+            .expect("create probe database");
+        let (base_prefix, _) = base_url.rsplit_once('/').expect("database url has a path");
+        let db = Db::new(&DbConfig {
+            database_url: format!("{base_prefix}/{probe_db}"),
+            max_connections: 5,
+            min_connections: 0,
+            ..DbConfig::default()
+        })
+        .await
+        .expect("connect probe database");
+        db.migrate().await.expect("migrate probe database");
+        let store = db.deletion_store();
+        let (request, inventory) = inventoried_request(&db, &store).await;
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        store.begin_quiescing(&claim.lease).await.expect("quiesce");
+        let generation = store.fence(&claim.lease).await.expect("fence");
+        let token = LeaseToken {
+            fence_generation: Some(generation),
+            ..claim.lease
+        };
+        store
+            .freeze_destructive_storage_manifest(&token, &inventory.storage)
+            .await
+            .expect("freeze destructive storage");
+        store.mark_drained(&token).await.expect("drain");
+        store
+            .mark_bindings_removed(&token, serde_json::json!({"keys": 0}))
+            .await
+            .expect("bindings");
+
+        // Park a migration mid-run through the production lock path: the op
+        // runs on the same connection that owns the exclusive session lock,
+        // exactly as `run_migrations` executes migration SQL.
+        let probe_table = format!("deletion_probe_{}", Uuid::new_v4().simple());
+        let create_probe =
+            format!("CREATE TABLE {probe_table} (community_id UUID NOT NULL, payload TEXT)");
+        let attach_probe =
+            format!("SELECT attach_community_write_fence('{probe_table}'::regclass)");
+        let (started_tx, started_rx) = tokio::sync::oneshot::channel::<()>();
+        let (release_tx, release_rx) = tokio::sync::oneshot::channel::<()>();
+        let migration_pool = db.pool.clone();
+        let (create_probe_sql, attach_probe_sql) = (create_probe.clone(), attach_probe.clone());
+        let migration_run = tokio::spawn(async move {
+            crate::migration::with_exclusive_schema_destruction_lock(
+                &migration_pool,
+                move |mut conn| async move {
+                    let _ = started_tx.send(());
+                    let _ = release_rx.await;
+                    // Explicit DDL transaction: the new scoped table commits
+                    // before the production path releases the exclusive lock.
+                    let outcome: Result<()> = async {
+                        let mut ddl = sqlx::Connection::begin(&mut conn).await?;
+                        sqlx::query(AssertSqlSafe(create_probe_sql))
+                            .execute(&mut *ddl)
+                            .await?;
+                        sqlx::query(AssertSqlSafe(attach_probe_sql))
+                            .execute(&mut *ddl)
+                            .await?;
+                        ddl.commit().await?;
+                        Ok(())
+                    }
+                    .await;
+                    (conn, outcome)
+                },
+            )
+            .await
+        });
+        started_rx.await.expect("parked migration holds the lock");
+        let blocked =
+            tokio::time::timeout(Duration::from_millis(750), store.purge_postgres(&token)).await;
+        assert!(
+            blocked.is_err(),
+            "purge must wait for the in-flight migration instead of validating a stale surface"
+        );
+
+        // The migration commits its new fenced scoped table, then finishes.
+        release_tx.send(()).expect("unpark migration");
+        migration_run
+            .await
+            .expect("join migration run")
+            .expect("locked migration op");
+
+        // Purge revalidates inside its own transaction and fails closed on
+        // the surface this executor does not know.
+        let denied = store.purge_postgres(&token).await;
+        let denied_on_probe = matches!(
+            &denied,
+            Err(DbError::DeletionSafety(message)) if message.contains(&probe_table)
+        );
+        sqlx::query(AssertSqlSafe(format!("DROP TABLE {probe_table}")))
+            .execute(&db.pool)
+            .await
+            .expect("drop probe table");
+        assert!(
+            denied_on_probe,
+            "purge must fail closed on a migration-committed scoped table: {denied:?}"
+        );
+        let after_denied = store.get(request.id).await.expect("request after denial");
+        assert_eq!(after_denied.stage, DeletionStage::BindingsRemoved);
+
+        store
+            .purge_postgres(&token)
+            .await
+            .expect("purge after catalog restored");
+        store
+            .mark_cache_purged(&token, serde_json::json!({"keys": 0}))
+            .await
+            .expect("cache");
+
+        // A scoped table committed after the purge must fail the absence
+        // proof closed rather than silently escaping verification.
+        sqlx::query(AssertSqlSafe(create_probe))
+            .execute(&db.pool)
+            .await
+            .expect("recreate probe scoped table");
+        sqlx::query(AssertSqlSafe(attach_probe))
+            .execute(&db.pool)
+            .await
+            .expect("attach probe fence again");
+        let verify_denied = store.verify_postgres_logically_deleted(&token).await;
+        let verify_denied_on_probe = matches!(
+            &verify_denied,
+            Err(DbError::DeletionSafety(message)) if message.contains(&probe_table)
+        );
+        sqlx::query(AssertSqlSafe(format!("DROP TABLE {probe_table}")))
+            .execute(&db.pool)
+            .await
+            .expect("drop probe table again");
+        assert!(
+            verify_denied_on_probe,
+            "verification must fail closed on a post-purge scoped table: {verify_denied:?}"
+        );
+
+        store
+            .verify_postgres_logically_deleted(&token)
+            .await
+            .expect("verify after catalog restored");
+        store
+            .mark_logically_verified(&token, serde_json::json!({"all": true}))
+            .await
+            .expect("mark verified");
+        store
+            .mark_retention_pending(&token, serde_json::json!({"probe": "clean"}))
+            .await
+            .expect("terminal");
+
+        db.pool.close().await;
+        sqlx::query(AssertSqlSafe(format!(
+            "DROP DATABASE {probe_db} WITH (FORCE)"
+        )))
+        .execute(&admin)
+        .await
+        .expect("drop probe database");
+    }
+
+    /// A database bootstrapped from `schema/schema.sql` (the pgschema
+    /// desired-state path — no migrations) must carry the complete 0028
+    /// deletion surface and run a deletion through every stage.
+    ///
+    /// Before the parity restoration this wedged post-fence:
+    /// `freeze_destructive_storage_manifest` hit the missing
+    /// `community_deletion_manifest_keys` relation only after the write fence
+    /// was already up, leaving the request with no forward path — and even a
+    /// hand-created table would have lacked the immutability guard trigger.
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn desired_state_schema_bootstrap_progresses_beyond_fencing() {
+        let base_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .unwrap_or_else(|_| "postgres://buzz:buzz_dev@localhost:5432/buzz".to_string());
+        let admin = PgPool::connect(&base_url)
+            .await
+            .expect("connect admin database");
+        let probe_db = format!("buzz_desired_state_{}", Uuid::new_v4().simple());
+        sqlx::query(AssertSqlSafe(format!("CREATE DATABASE {probe_db}")))
+            .execute(&admin)
+            .await
+            .expect("create probe database");
+        let (base_prefix, _) = base_url.rsplit_once('/').expect("database url has a path");
+        let probe_url = format!("{base_prefix}/{probe_db}");
+
+        let schema_sql = std::fs::read_to_string(
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../schema/schema.sql"),
+        )
+        .expect("read schema/schema.sql");
+        let bootstrap = PgPool::connect(&probe_url)
+            .await
+            .expect("connect probe database");
+        sqlx::raw_sql(AssertSqlSafe(schema_sql))
+            .execute(&bootstrap)
+            .await
+            .expect("apply desired-state schema");
+        bootstrap.close().await;
+
+        let db = Db::new(&DbConfig {
+            database_url: probe_url,
+            max_connections: 5,
+            min_connections: 0,
+            ..DbConfig::default()
+        })
+        .await
+        .expect("connect desired-state database");
+        let store = db.deletion_store();
+        let (request, inventory) = inventoried_request(&db, &store).await;
+
+        // The immutability guard must exist and enforce: chunk rows are
+        // rejected outside an unfrozen fenced request (this request is still
+        // `inventoried`).
+        let premature_chunk = sqlx::query(
+            "INSERT INTO community_deletion_manifest_keys (request_id, chunk_no, prefix, keys) \
+             VALUES ($1, 0, '_meta/premature/', '[]'::jsonb)",
+        )
+        .bind(request.id)
+        .execute(&db.pool)
+        .await;
+        let guard_enforced = matches!(
+            &premature_chunk,
+            Err(sqlx::Error::Database(db_err)) if db_err.code().as_deref() == Some("23000")
+        );
+        assert!(
+            guard_enforced,
+            "manifest-keys immutability guard must reject pre-fence chunks \
+             with integrity_constraint_violation: {premature_chunk:?}"
+        );
+
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        store.begin_quiescing(&claim.lease).await.expect("quiesce");
+        let generation = store.fence(&claim.lease).await.expect("fence");
+        let token = LeaseToken {
+            fence_generation: Some(generation),
+            ..claim.lease
+        };
+        // The previously wedging stage: first touch of the manifest-keys
+        // relation happens here, after the fence is already up.
+        store
+            .freeze_destructive_storage_manifest(&token, &inventory.storage)
+            .await
+            .expect("freeze destructive storage on desired-state bootstrap");
+        store.mark_drained(&token).await.expect("drain");
+        store
+            .mark_bindings_removed(&token, serde_json::json!({"keys": 0}))
+            .await
+            .expect("bindings");
+        store.purge_postgres(&token).await.expect("purge postgres");
+        store
+            .mark_cache_purged(&token, serde_json::json!({"keys": 0}))
+            .await
+            .expect("cache");
+        store
+            .verify_postgres_logically_deleted(&token)
+            .await
+            .expect("verify postgres");
+        store
+            .mark_logically_verified(&token, serde_json::json!({"all": true}))
+            .await
+            .expect("logically verified");
+        store
+            .mark_retention_pending(&token, serde_json::json!({"bootstrap": "desired-state"}))
+            .await
+            .expect("terminal");
+        let terminal = store.get(request.id).await.expect("terminal request");
+        assert_eq!(terminal.stage, DeletionStage::RetentionPending);
+
+        db.pool.close().await;
+        sqlx::query(AssertSqlSafe(format!(
+            "DROP DATABASE {probe_db} WITH (FORCE)"
+        )))
+        .execute(&admin)
+        .await
+        .expect("drop probe database");
+    }
+}
diff --git a/crates/buzz-db/src/error.rs b/crates/buzz-db/src/error.rs
index f8b8a2eb56b..593eea1cca6 100644
--- a/crates/buzz-db/src/error.rs
+++ b/crates/buzz-db/src/error.rs
@@ -45,6 +45,25 @@ pub enum DbError {
     #[error("invalid data: {0}")]
     InvalidData(String),
 
+    /// A serving write admitted before the lifecycle transition is still live.
+    /// This is an ordinary retryable drain condition, not a safety violation.
+    #[error(
+        "community {community_id} still has {active_count} active serving write lease(s): {operations:?}"
+    )]
+    ServingWritesNotDrained {
+        /// Community whose lifecycle transition must retry.
+        community_id: uuid::Uuid,
+        /// Number of currently unexpired serving-write leases.
+        active_count: i64,
+        /// Distinct operation categories holding those leases.
+        operations: Vec<String>,
+    },
+
+    /// A deletion safety invariant is structurally violated and requires
+    /// operator/code remediation rather than blind retry.
+    #[error("deletion safety error: {0}")]
+    DeletionSafety(String),
+
     /// A stored timestamp value could not be interpreted.
     #[error("invalid timestamp: {0}")]
     InvalidTimestamp(i64),
diff --git a/crates/buzz-db/src/event.rs b/crates/buzz-db/src/event.rs
index e1b45aa3a1d..db150571719 100644
--- a/crates/buzz-db/src/event.rs
+++ b/crates/buzz-db/src/event.rs
@@ -1111,7 +1111,7 @@ pub struct ThreadMetadataParams<'a> {
     pub broadcast: bool,
 }
 
-async fn insert_event_with_thread_metadata_tx(
+pub(crate) async fn insert_event_with_thread_metadata_tx(
     tx: &mut Transaction<'_, Postgres>,
     community_id: CommunityId,
     event: &Event,
diff --git a/crates/buzz-db/src/lib.rs b/crates/buzz-db/src/lib.rs
index cbb14173c98..1ba0909bbfb 100644
--- a/crates/buzz-db/src/lib.rs
+++ b/crates/buzz-db/src/lib.rs
@@ -17,6 +17,8 @@ pub mod api_token;
 pub mod archived_identities;
 /// Channel and membership persistence.
 pub mod channel;
+/// Durable whole-community deletion lifecycle and PostgreSQL adapter.
+pub mod deletion;
 /// Direct message channel persistence.
 pub mod dm;
 /// Database error types.
@@ -651,7 +653,7 @@ impl Db {
     /// `buzz.created_at_floor` GUC — this is what makes the replica fence
     /// proof hold for every insert path that goes through this pool.
     pub async fn new(config: &DbConfig) -> Result<Self> {
-        let pool = Self::connect_pool(config, &config.database_url, true).await?;
+        let pool = Self::connect_pool(config, &config.database_url).await?;
         let read_max_connections = config
             .read_max_connections
             .unwrap_or(config.max_connections);
@@ -671,31 +673,39 @@ impl Db {
         })
     }
 
-    /// Connect one pool with the sizing knobs from `config`.
+    /// Connect the writer pool with all session-level safety premises.
     ///
-    /// `arm_floor_guard` sets the `buzz.created_at_floor` session GUC on
-    /// every connection, arming the deferred commit-time trigger from
-    /// migration 0021. Writer pools must arm it; replica pools are read-only
-    /// so the trigger never fires there.
-    async fn connect_pool(config: &DbConfig, url: &str, arm_floor_guard: bool) -> Result<PgPool> {
-        let mut options = PgPoolOptions::new()
+    /// SQLx stores one `after_connect` hook, so the floor guard and transaction
+    /// isolation assertion must remain in this single closure. Registering a
+    /// second hook replaces the first and silently disarms the floor trigger.
+    async fn connect_pool(config: &DbConfig, url: &str) -> Result<PgPool> {
+        let options = PgPoolOptions::new()
             .max_connections(config.max_connections)
             .min_connections(config.min_connections)
             .acquire_timeout(Duration::from_secs(config.acquire_timeout_secs))
             .max_lifetime(Duration::from_secs(config.max_lifetime_secs))
-            .idle_timeout(Duration::from_secs(config.idle_timeout_secs));
-        if arm_floor_guard {
-            options = options.after_connect(|conn, _meta| {
+            .idle_timeout(Duration::from_secs(config.idle_timeout_secs))
+            .after_connect(|conn, _meta| {
                 Box::pin(async move {
                     // `SET` cannot take bind parameters; `set_config` can.
                     sqlx::query("SELECT set_config('buzz.created_at_floor', $1, false)")
                         .bind(replica_fence::CREATED_AT_FLOOR_SECS.to_string())
-                        .execute(conn)
+                        .execute(&mut *conn)
+                        .await?;
+                    let isolation: String = sqlx::query_scalar("SHOW transaction_isolation")
+                        .fetch_one(&mut *conn)
                         .await?;
+                    if isolation != "read committed" {
+                        return Err(sqlx::Error::Configuration(
+                            format!(
+                                "writer pool requires READ COMMITTED transaction isolation, got {isolation}"
+                            )
+                            .into(),
+                        ));
+                    }
                     Ok(())
                 })
             });
-        }
         Ok(options.connect(url).await?)
     }
 
@@ -720,8 +730,9 @@ impl Db {
     /// are dialed only on first acquire; the ~10-minute reaper never tops
     /// the pool back up, which is fine — routed reads re-fill it on demand.
     ///
-    /// No floor guard: replica sessions are read-only, the trigger never
-    /// fires there (see [`Db::connect_pool`]).
+    /// No floor guard or writer-isolation assertion: replica sessions are
+    /// read-only, so the commit-time trigger from migration 0021 never fires
+    /// here and the write fence that depends on READ COMMITTED is never reached.
     fn connect_read_pool(config: &DbConfig, url: &str, max_connections: u32) -> Result<PgPool> {
         Ok(PgPoolOptions::new()
             .max_connections(max_connections)
@@ -1021,6 +1032,16 @@ impl Db {
         sqlx::query("SELECT 1").execute(&self.pool).await.is_ok()
     }
 
+    /// Validate the minimum deletion fence catalog required by serving paths.
+    pub async fn validate_deletion_serving_catalog(&self) -> Result<()> {
+        self.deletion_store().validate_serving_catalog().await
+    }
+
+    /// Validate the exact live community-deletion tenant catalog for destruction.
+    pub async fn validate_deletion_catalog(&self) -> Result<()> {
+        self.deletion_store().validate_catalog().await
+    }
+
     /// Returns pool utilisation stats for metrics emission.
     ///
     /// `size`  — total connections (idle + active)
@@ -1198,6 +1219,11 @@ impl Db {
         usage::community_hosts(&self.pool).await
     }
 
+    /// Return the shared durable whole-community deletion adapter.
+    pub fn deletion_store(&self) -> deletion::DeletionStore {
+        deletion::DeletionStore::new(self.pool.clone())
+    }
+
     /// Begin a database transaction for atomic multi-statement operations.
     ///
     /// Returns a `'static` transaction because `PgPool` is `Arc`-backed internally.
@@ -1221,6 +1247,8 @@ impl Db {
             FROM communities
             WHERE lower(host) = lower($1)
               AND archived_at IS NULL
+              AND deleted_at IS NULL
+              AND deletion_state = 'active'
             "#,
         )
         .bind(normalized_host)
@@ -1243,7 +1271,7 @@ impl Db {
     #[datastore_span(name = "is_community_active", system = "postgresql")]
     pub async fn is_community_active(&self, community_id: CommunityId) -> Result<bool> {
         let active = sqlx::query_scalar::<_, bool>(
-            "SELECT EXISTS(SELECT 1 FROM communities WHERE id = $1 AND archived_at IS NULL)",
+            "SELECT EXISTS(SELECT 1 FROM communities WHERE id = $1 AND archived_at IS NULL AND deleted_at IS NULL AND deletion_state = 'active')",
         )
         .bind(community_id.as_uuid())
         .fetch_one(&self.pool)
@@ -1331,6 +1359,8 @@ impl Db {
             FROM communities
             WHERE id = $1
               AND archived_at IS NULL
+              AND deleted_at IS NULL
+              AND deletion_state = 'active'
             "#,
         )
         .bind(community_id.as_uuid())
@@ -1404,12 +1434,19 @@ impl Db {
             INSERT INTO communities (host)
             VALUES ($1)
             ON CONFLICT (lower(host)) DO UPDATE SET host = communities.host
+            WHERE communities.deletion_state = 'active'
+              AND communities.deleted_at IS NULL
             RETURNING id, host, (xmax = 0) AS created
             "#,
         )
         .bind(normalized_host)
-        .fetch_one(&self.pool)
-        .await?;
+        .fetch_optional(&self.pool)
+        .await?
+        .ok_or_else(|| {
+            DbError::AccessDenied(format!(
+                "community host {normalized_host:?} is permanently tombstoned"
+            ))
+        })?;
 
         let id: Uuid = row.try_get("id")?;
         let host: String = row.try_get("host")?;
@@ -1490,6 +1527,8 @@ impl Db {
                   AND lower(rm.pubkey) = lower($2)
                   AND rm.role = 'owner'
                   AND c.archived_at IS NULL
+                  AND c.deletion_state = 'active'
+                  AND c.deleted_at IS NULL
                 "#,
             )
             .bind(normalized_host)
@@ -1529,6 +1568,8 @@ impl Db {
                  AND lower(rm.pubkey) = lower($2)
                  AND rm.role = 'owner'
                  AND lower(c.host) <> lower($3)
+                 AND c.deletion_state = 'active'
+                 AND c.deleted_at IS NULL
                RETURNING c.id, c.host, c.archived_at"#,
         )
         .bind(normalized_host)
@@ -1561,6 +1602,8 @@ impl Db {
                  AND rm.community_id = c.id
                  AND lower(rm.pubkey) = lower($2)
                  AND rm.role = 'owner'
+                 AND c.deletion_state = 'active'
+                 AND c.deleted_at IS NULL
                RETURNING c.id, c.host"#,
         )
         .bind(normalized_host)
@@ -1665,6 +1708,49 @@ impl Db {
         Ok(result)
     }
 
+    /// Insert an event while holding and validating an admitted serving-write
+    /// lease under the community ordering lock through commit.
+    ///
+    /// External side effects use a durable lease rather than one long-lived DB
+    /// transaction. Their final database mutation presents that exact lease so
+    /// it may finish during quiescing without admitting any new serving work.
+    pub async fn insert_event_with_serving_write_guard(
+        &self,
+        lease: &deletion::ServingWriteLease,
+        event: &nostr::Event,
+        channel_id: Option<Uuid>,
+    ) -> Result<(StoredEvent, bool)> {
+        let community_id = lease.community_id;
+        let kind_u16 = event.kind.as_u16();
+        let kind_u32 = u32::from(kind_u16);
+        if kind_u32 == buzz_core::kind::KIND_AUTH {
+            return Err(DbError::AuthEventRejected);
+        }
+        if buzz_core::kind::is_ephemeral(kind_u32) {
+            return Err(DbError::EphemeralEventRejected(kind_u16));
+        }
+
+        let mut tx = self.pool.begin().await?;
+        self.deletion_store()
+            .guard_transaction_with_serving_lease(&mut tx, lease)
+            .await?;
+        let result = event::insert_event_with_thread_metadata_tx(
+            &mut tx,
+            community_id,
+            event,
+            channel_id,
+            None,
+        )
+        .await?;
+        tx.commit().await?;
+        if result.1 {
+            if let Err(e) = insert_mentions(&self.pool, community_id, event, channel_id).await {
+                tracing::warn!(event_id = %event.id, "Failed to insert mentions: {e}");
+            }
+        }
+        Ok(result)
+    }
+
     /// Queries events matching the given filter parameters.
     ///
     /// Always reads from the WRITER pool. If the result influences a write
@@ -4086,7 +4172,8 @@ impl Db {
                   WHERE elem->>0 = 'd' LIMIT 1), \
                  '' \
              ) \
-             WHERE kind BETWEEN 30000 AND 39999 AND d_tag IS NULL",
+             WHERE kind BETWEEN 30000 AND 39999 AND d_tag IS NULL \
+               AND community_write_allowed(community_id)",
         )
         .execute(&self.pool)
         .await?;
@@ -8524,6 +8611,76 @@ mod tests {
         drop_scratch_db(&admin, pool, &name).await;
     }
 
+    #[test]
+    fn writer_pool_safety_hook_is_single_and_composed() {
+        let source = include_str!("lib.rs");
+        let connect_pool = source
+            .split("async fn connect_pool")
+            .nth(1)
+            .and_then(|tail| tail.split("const READER_ACQUIRE_TIMEOUT").next())
+            .expect("connect_pool source block");
+        assert_eq!(
+            connect_pool.matches(".after_connect(").count(),
+            1,
+            "SQLx replaces after_connect hooks; writer safety must use exactly one"
+        );
+        assert!(connect_pool.contains("buzz.created_at_floor"));
+        assert!(connect_pool.contains("SHOW transaction_isolation"));
+        assert!(!connect_pool.contains("arm_floor_guard"));
+        assert!(!connect_pool.contains("_arm_floor_guard"));
+        assert!(!connect_pool.contains("allow(unused_variables)"));
+
+        let reader_doc = source
+            .split("fn connect_read_pool")
+            .next()
+            .and_then(|prefix| prefix.rsplit("/// Connect the read-replica").next())
+            .expect("reader pool documentation");
+        assert!(reader_doc.contains("replica sessions are"));
+        assert!(reader_doc.contains("read-only"));
+        assert!(!reader_doc.contains("Db::connect_pool"));
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn writer_pool_rejects_non_read_committed_database_default() {
+        let admin = PgPool::connect(&admin_url().await)
+            .await
+            .expect("connect admin");
+        let (seed_pool, name) = create_scratch_db(&admin, "writer_isolation").await;
+        sqlx::query(sqlx::AssertSqlSafe(format!(
+            "ALTER DATABASE {name} SET default_transaction_isolation = 'repeatable read'"
+        )))
+        .execute(&admin)
+        .await
+        .expect("set unsafe database default");
+        seed_pool.close().await;
+
+        let base = admin_url().await;
+        let idx = base.rfind('/').expect("db url has a path segment");
+        let scratch_url = format!("{}/{}", &base[..idx], name);
+        let error = Db::new(&DbConfig {
+            database_url: scratch_url,
+            max_connections: 1,
+            min_connections: 1,
+            acquire_timeout_secs: 1,
+            ..DbConfig::default()
+        })
+        .await
+        .expect_err("writer pool must reject pinned-snapshot database defaults");
+        assert!(
+            error.to_string().contains("requires READ COMMITTED")
+                || error.to_string().contains("pool timed out"),
+            "unexpected isolation rejection: {error}"
+        );
+
+        sqlx::query(sqlx::AssertSqlSafe(format!(
+            "DROP DATABASE {name} WITH (FORCE)"
+        )))
+        .execute(&admin)
+        .await
+        .expect("drop isolation test database");
+    }
+
     /// The armed writer pool (`Db::new`) must enforce the floor end-to-end
     /// through the public insert APIs, and the session GUC must be verifiably
     /// set on pooled connections.
@@ -8563,6 +8720,14 @@ mod tests {
             crate::replica_fence::CREATED_AT_FLOOR_SECS.to_string(),
             "writer pool must arm the floor guard on every connection"
         );
+        let isolation: String = sqlx::query_scalar("SHOW transaction_isolation")
+            .fetch_one(&db.pool)
+            .await
+            .expect("SHOW writer isolation");
+        assert_eq!(
+            isolation, "read committed",
+            "the same writer after_connect hook must enforce the isolation premise"
+        );
 
         let now_secs = chrono::Utc::now().timestamp() as u64;
         let floor = crate::replica_fence::CREATED_AT_FLOOR_SECS as u64;
diff --git a/crates/buzz-db/src/migration.rs b/crates/buzz-db/src/migration.rs
index 43f464526c3..4ccf987f140 100644
--- a/crates/buzz-db/src/migration.rs
+++ b/crates/buzz-db/src/migration.rs
@@ -4,16 +4,37 @@
 //! multi-tenant rewrite owns a clean consolidated `0001`; legacy single-tenant
 //! cutover/backfill is a separate operator script, not startup migration state.
 
-use sqlx::PgPool;
+use std::future::Future;
 
+use sqlx::{Connection, PgConnection, PgPool};
+
+use crate::deletion::SCHEMA_DESTRUCTION_LOCK_KEY;
 use crate::Result;
 
 static MIGRATOR: sqlx::migrate::Migrator = sqlx::migrate!("../../migrations");
 
 /// Run all pending Buzz database migrations.
+///
+/// The entire run holds the exclusive [`SCHEMA_DESTRUCTION_LOCK_KEY`] session
+/// lock, serializing schema changes against destructive deletion transactions
+/// (which take the shared counterpart while they validate the live catalog
+/// and act on it). Every migration statement executes on the same backend
+/// that owns the lock — see [`with_exclusive_schema_destruction_lock`] for
+/// why that binding, not the explicit unlock, is the safety contract.
+/// Migration execution must never bypass this wrapper — a source lint
+/// (`migration_execution_cannot_bypass_schema_destruction_lock`) enforces
+/// that `MIGRATOR.run` has no other call site.
 pub async fn run_migrations(pool: &PgPool) -> Result<()> {
-    reject_legacy_nip_rs_cardinality_ambiguity(pool).await?;
-    MIGRATOR.run(pool).await?;
+    with_exclusive_schema_destruction_lock(pool, |mut conn| async move {
+        let outcome = run_migrations_locked(&mut conn).await;
+        (conn, outcome)
+    })
+    .await
+}
+
+async fn run_migrations_locked(conn: &mut PgConnection) -> Result<()> {
+    reject_legacy_nip_rs_cardinality_ambiguity(conn).await?;
+    MIGRATOR.run(&mut *conn).await?;
     // The replica-fence proof (see `replica_fence`) requires the commit-time
     // `created_at` floor trigger from migration 0021 — correctly shaped — on
     // the `events` parent and every partition. `CREATE TABLE .. PARTITION OF`
@@ -21,25 +42,61 @@ pub async fn run_migrations(pool: &PgPool) -> Result<()> {
     // PARTITION` or created by an older code path would silently escape the
     // guard, so migration fails closed if any is missing. (The fence probe
     // re-runs this same check at startup on non-migrating relays.)
-    crate::replica_fence::verify_floor_guard_catalog(pool).await?;
+    crate::replica_fence::verify_floor_guard_catalog(&mut *conn).await?;
     Ok(())
 }
 
+/// Run `op` while holding the exclusive schema/destruction session lock.
+///
+/// `op` receives ownership of the detached connection that owns the advisory
+/// lock and must run every statement on it, handing the same connection back
+/// with its outcome. That same-backend lifetime — not the explicit unlock —
+/// is the safety contract: PostgreSQL releases a session lock only when its
+/// backend finishes, so cancelling this future (dropping the connection while
+/// a migration statement is still executing server-side) cannot expose the
+/// lock to shared destructive holders before that statement's backend
+/// terminates. On completion the lock is explicitly released on the returned
+/// connection (success and error alike) and the connection is closed, never
+/// returning a locked session to the pool.
+pub(crate) async fn with_exclusive_schema_destruction_lock<T, F, Fut>(
+    pool: &PgPool,
+    op: F,
+) -> Result<T>
+where
+    F: FnOnce(PgConnection) -> Fut,
+    Fut: Future<Output = (PgConnection, Result<T>)>,
+{
+    let mut lock_conn = pool.acquire().await?.detach();
+    sqlx::query("SELECT pg_advisory_lock($1)")
+        .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+        .execute(&mut lock_conn)
+        .await?;
+    let (mut lock_conn, outcome) = op(lock_conn).await;
+    let unlock = sqlx::query("SELECT pg_advisory_unlock($1)")
+        .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+        .execute(&mut lock_conn)
+        .await;
+    let _ = lock_conn.close().await;
+    let value = outcome?;
+    unlock?;
+    Ok(value)
+}
+
 /// Migration 0007 is checksum-frozen and predates exact NIP-RS tag-cardinality
 /// enforcement. A populated database still on 0001-0006 must not let 0007
 /// irreversibly purge duplicate-tag history. Fail before sqlx starts its
 /// migration transaction so an operator can inspect and repair those rows.
-async fn reject_legacy_nip_rs_cardinality_ambiguity(pool: &PgPool) -> Result<()> {
+async fn reject_legacy_nip_rs_cardinality_ambiguity(conn: &mut PgConnection) -> Result<()> {
     let migrations_table: Option<String> =
         sqlx::query_scalar("SELECT to_regclass('_sqlx_migrations')::text")
-            .fetch_one(pool)
+            .fetch_one(&mut *conn)
             .await?;
     if migrations_table.is_none() {
         return Ok(());
     }
     let applied: Option<i64> =
         sqlx::query_scalar("SELECT max(version) FROM _sqlx_migrations WHERE success")
-            .fetch_one(pool)
+            .fetch_one(&mut *conn)
             .await?;
     if applied.is_none_or(|version| version >= 7) {
         return Ok(());
@@ -83,7 +140,7 @@ async fn reject_legacy_nip_rs_cardinality_ambiguity(pool: &PgPool) -> Result<()>
                )\
          )",
     )
-    .fetch_one(pool)
+    .fetch_one(conn)
     .await?;
 
     if ambiguous {
@@ -348,6 +405,13 @@ mod tests {
             "push_gateway_delivery_request_replays",
             "product_feedback",
             "replica_heartbeat",
+            "community_deletion_requests",
+            "community_deletion_approvals",
+            "community_deletion_checkpoints",
+            "community_deletion_manifest_keys",
+            "storage_taxonomy_sweeps",
+            "community_serving_write_leases",
+            "community_deletion_executor_heartbeats",
         ] {
             if normalized[insert_pos..].contains(&format!("'{value}'")) {
                 globals.insert(value.to_owned());
@@ -561,8 +625,8 @@ mod tests {
         let mut migrations: Vec<_> = MIGRATOR.iter().collect();
         migrations.sort_by_key(|migration| migration.version);
 
-        // FORK-LOCAL PATCH (adrienlacombe/buzz): upstream ships 28 migrations; this
-        // fork adds two of its own, so the count is 30 here.
+        // FORK-LOCAL PATCH (adrienlacombe/buzz): upstream ships 30 migrations; this
+        // fork adds two of its own, so the count is 32 here.
         //
         // The fork's 0027 and 0028 belong to the NIP-SW wallet binding, which this
         // fork has since removed in favour of the Nostr key controlling the Starknet
@@ -576,10 +640,12 @@ mod tests {
         //
         // Because the fork holds 0027 and 0028, upstream's own new migrations arrive
         // renumbered above them: upstream's `0027_channels_id_lookup_index.sql` is
-        // `0029_channels_id_lookup_index.sql` here, and its
-        // `0028_long_reaction_payloads.sql` is `0030_long_reaction_payloads.sql`.
-        // See the assertions for both below.
-        assert_eq!(migrations.len(), 30);
+        // `0029_channels_id_lookup_index.sql` here, its
+        // `0028_long_reaction_payloads.sql` is `0030_long_reaction_payloads.sql`,
+        // its `0029_community_deletion.sql` is `0031_community_deletion.sql`, and
+        // its `0030_community_deletion_recovery.sql` is
+        // `0032_community_deletion_recovery.sql`. See the assertions for each below.
+        assert_eq!(migrations.len(), 32);
         assert_eq!(migrations[0].version, 1);
         assert_eq!(&*migrations[0].description, "initial schema");
         assert!(migrations[0]
@@ -952,14 +1018,8 @@ mod tests {
         assert!(channel_id_index.contains("idx_channels_id_live"));
         assert!(channel_id_index.contains("INCLUDE (community_id)"));
         assert!(channel_id_index.contains("WHERE deleted_at IS NULL"));
-        assert!(
-            !channel_id_index.contains("CREATE UNIQUE INDEX"),
-            "channels.id is not unique across communities — index must not be UNIQUE",
-        );
-        assert!(
-            desired_schema.contains("idx_channels_id_live"),
-            "desired-state schema must carry the channel-id lookup index",
-        );
+        assert!(!channel_id_index.contains("CREATE UNIQUE INDEX"));
+        assert!(desired_schema.contains("idx_channels_id_live"));
 
         // Long reaction payloads (upstream's 0028, FORK-LOCAL PATCH
         // (adrienlacombe/buzz): renumbered to 0030 here because this fork already
@@ -970,6 +1030,46 @@ mod tests {
             long_reactions.contains("ALTER TABLE reactions ALTER COLUMN emoji TYPE VARCHAR(66)")
         );
         assert!(desired_schema.contains("emoji               VARCHAR(66) NOT NULL"));
+
+        // Durable whole-community deletion control plane and universal DB fence
+        // (upstream's 0029, FORK-LOCAL PATCH (adrienlacombe/buzz): renumbered to
+        // 0031 here because this fork already holds 0027 and 0028).
+        assert_eq!(migrations[30].version, 31);
+        let deletion = migrations[30].sql.as_str();
+        assert!(deletion.contains("CREATE TABLE community_deletion_requests"));
+        assert!(deletion.contains("CREATE TABLE community_deletion_approvals"));
+        assert!(deletion.contains("CREATE TABLE community_deletion_checkpoints"));
+        assert!(deletion.contains("CREATE TABLE community_serving_write_leases"));
+        assert!(deletion.contains("CREATE TABLE community_deletion_executor_heartbeats"));
+        assert!(deletion.contains("CREATE FUNCTION community_write_allowed"));
+        assert!(deletion.contains("LANGUAGE plpgsql VOLATILE"));
+        assert!(deletion.contains("CREATE FUNCTION assert_community_write_allowed"));
+        assert!(deletion.contains("current_setting('transaction_isolation') <> 'read committed'"));
+        assert!(deletion.contains("ERRCODE = 'invalid_transaction_state'"));
+        assert!(deletion.contains("CREATE FUNCTION enforce_community_write_fence"));
+        assert!(deletion.contains("CREATE FUNCTION attach_community_write_fence"));
+        assert!(deletion.contains("community_write_fence_excluded_table"));
+        assert!(deletion.contains("CREATE FUNCTION enforce_community_tombstone"));
+        assert!(deletion.contains("community tombstones are permanent"));
+        assert!(deletion.contains("SET LOCAL lock_timeout = '5s'"));
+        assert!(deletion.contains("'active', 'quiescing', 'fenced', 'tombstone'"));
+        assert!(deletion.contains("_operator_global_tables"));
+        assert!(deletion.contains("'submitted', 'inventoried', 'approved', 'fenced', 'drained'"));
+        assert!(deletion.contains("UNIQUE (id, community_id, inventory_digest)"));
+        assert!(deletion.contains("FOREIGN KEY (request_id, community_id, inventory_digest)"));
+        assert!(deletion.contains("prevent_community_deletion_request_retargeting"));
+        assert!(deletion.contains("prevent_community_deletion_approval_removal"));
+
+        assert!(deletion.contains("retry_stage TEXT CHECK"));
+        assert!(desired_schema.contains("retry_stage TEXT CHECK"));
+
+        // Recovery migration alters populated tables and must preserve the same
+        // fail-fast lock behavior as the deletion migration (upstream's 0030,
+        // FORK-LOCAL PATCH (adrienlacombe/buzz): renumbered to 0032 here because
+        // this fork already holds 0027 and 0028).
+        assert_eq!(migrations[31].version, 32);
+        let deletion_recovery = migrations[31].sql.as_str();
+        assert!(deletion_recovery.contains("SET LOCAL lock_timeout = '5s'"));
     }
 
     #[test]
@@ -1115,6 +1215,552 @@ mod tests {
         );
     }
 
+    #[test]
+    fn migration_execution_cannot_bypass_schema_destruction_lock() {
+        fn rust_sources(dir: &std::path::Path, files: &mut Vec<std::path::PathBuf>) {
+            for entry in std::fs::read_dir(dir).expect("read workspace source dir") {
+                let path = entry.expect("read workspace source entry").path();
+                if path.is_dir() {
+                    if path.file_name().is_some_and(|name| name == "target") {
+                        continue;
+                    }
+                    rust_sources(&path, files);
+                } else if path.extension().is_some_and(|ext| ext == "rs") {
+                    files.push(path);
+                }
+            }
+        }
+        fn count(haystack: &str, needle: &str) -> usize {
+            haystack.matches(needle).count()
+        }
+
+        // Build the needles so this test's own source never matches them.
+        let migrate_macro = ["sqlx", "::migrate!"].concat();
+        let migrator_run = ["MIGRATOR", ".run("].concat();
+
+        let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+        let this_file = manifest_dir.join("src/migration.rs");
+        let crates_dir = manifest_dir.parent().expect("workspace crates dir");
+        // The push gateway migrates its own dedicated authority database; it
+        // never holds relay tenant tables, so it is exempt from the relay
+        // schema/destruction lock. The community_id check below keeps that
+        // exemption honest.
+        let push_gateway_exception = crates_dir.join("buzz-push-gateway/src/postgres.rs");
+        let push_gateway_migrations = crates_dir.join("buzz-push-gateway/migrations");
+        for entry in
+            std::fs::read_dir(&push_gateway_migrations).expect("read push gateway migrations")
+        {
+            let path = entry.expect("read push gateway migration entry").path();
+            let sql = std::fs::read_to_string(&path).expect("read push gateway migration");
+            assert!(
+                !sql.to_ascii_lowercase().contains("community_id"),
+                "{} defines community-scoped data; its migrator would bypass the \
+                 schema/destruction lock and must move under buzz-db migrations",
+                path.display()
+            );
+        }
+        let mut files = Vec::new();
+        rust_sources(crates_dir, &mut files);
+        for path in &files {
+            let source = std::fs::read_to_string(path).expect("read rust source");
+            let (macro_hits, run_hits) = (
+                count(&source, &migrate_macro),
+                count(&source, &migrator_run),
+            );
+            if *path == this_file {
+                assert_eq!(
+                    (macro_hits, run_hits),
+                    (1, 1),
+                    "migration.rs must embed the migrator once and run it exactly once, \
+                     inside the locked wrapper"
+                );
+            } else if *path == push_gateway_exception {
+                continue;
+            } else {
+                assert_eq!(
+                    (macro_hits, run_hits),
+                    (0, 0),
+                    "{} embeds or runs a SQLx migrator outside the schema/destruction \
+                     lock contract; route migration execution through \
+                     buzz_db migration::run_migrations",
+                    path.display()
+                );
+            }
+        }
+
+        // Within migration.rs, the single run site must sit inside
+        // `run_migrations_locked`, and the only public entry point must wrap
+        // it in the exclusive session lock.
+        let source = std::fs::read_to_string(&this_file).expect("read migration.rs");
+        let entry = source
+            .find("pub async fn run_migrations(")
+            .expect("public migration entry point");
+        let locked = source
+            .find("async fn run_migrations_locked(")
+            .expect("locked migration body");
+        let wrapper = source
+            .find("async fn with_exclusive_schema_destruction_lock")
+            .expect("exclusive lock wrapper");
+        let run_site = source.find(&migrator_run).expect("migrator run site");
+        assert!(
+            source[entry..locked].contains("with_exclusive_schema_destruction_lock("),
+            "run_migrations must delegate through the exclusive schema/destruction lock"
+        );
+        assert!(
+            run_site > locked && run_site < wrapper,
+            "the migrator run site must live inside run_migrations_locked"
+        );
+        assert!(
+            source[wrapper..].contains("pg_advisory_lock($1)")
+                && source[wrapper..].contains("pg_advisory_unlock($1)"),
+            "the lock wrapper must acquire and explicitly release the session lock"
+        );
+    }
+
+    /// Structural parity between migration 0029's deletion surface and the
+    /// desired-state bootstrap schema (`schema/schema.sql`).
+    ///
+    /// Compares parsed statements, not substrings: every deletion control-
+    /// plane table, function, trigger, and index 0028 creates must exist in
+    /// schema.sql with an identical normalized definition; every operator-
+    /// global registry row 0028 inserts must be inserted by schema.sql; the
+    /// write-fence attachment target sets must be equal; and every column
+    /// 0028 adds to `communities` must exist in the desired-state
+    /// `communities` table. A desired-state bootstrap that passes this test
+    /// cannot silently omit part of the deletion surface the way the
+    /// pre-parity schema.sql omitted `community_deletion_manifest_keys` (and
+    /// its immutability trigger) and `storage_taxonomy_sweeps` — booting
+    /// healthy, then wedging post-fence when the freeze stage first touched
+    /// the missing relation.
+    #[test]
+    fn deletion_surface_parity_between_migration_0029_and_schema_sql() {
+        use std::collections::BTreeMap;
+
+        #[derive(Default)]
+        struct DeletionSurface {
+            tables: BTreeMap<String, String>,
+            functions: BTreeMap<String, String>,
+            triggers: BTreeMap<String, String>,
+            indexes: BTreeSet<String>,
+            registry_rows: BTreeSet<(String, String)>,
+            fence_attachments: BTreeSet<String>,
+            communities_added_columns: BTreeSet<String>,
+        }
+
+        fn quoted_strings(statement: &str) -> Vec<String> {
+            let mut strings = Vec::new();
+            let mut current: Option<String> = None;
+            let mut chars = statement.chars().peekable();
+            while let Some(ch) = chars.next() {
+                match (&mut current, ch) {
+                    (None, '\'') => current = Some(String::new()),
+                    (Some(literal), '\'') => {
+                        if chars.peek() == Some(&'\'') {
+                            literal.push('\'');
+                            chars.next();
+                        } else {
+                            strings.push(current.take().expect("open literal"));
+                        }
+                    }
+                    (Some(literal), other) => literal.push(other),
+                    (None, _) => {}
+                }
+            }
+            strings
+        }
+
+        fn surface(sql: &str) -> DeletionSurface {
+            let mut surface = DeletionSurface::default();
+            for statement in split_sql_statements(sql) {
+                let normalized = normalize_sql(&statement);
+                if normalized.starts_with("create table") {
+                    let table = identifier_after_keyword(&statement, "create table")
+                        .expect("table identifier");
+                    surface.tables.insert(table, normalized.clone());
+                } else if normalized.starts_with("create function")
+                    || normalized.starts_with("create or replace function")
+                {
+                    let function = identifier_after_keyword(&statement, "function")
+                        .expect("function identifier");
+                    surface.functions.insert(function, normalized.clone());
+                } else if normalized.starts_with("create trigger") {
+                    let trigger = identifier_after_keyword(&statement, "create trigger")
+                        .expect("trigger identifier");
+                    surface.triggers.insert(trigger, normalized.clone());
+                } else if normalized.starts_with("create index")
+                    || normalized.starts_with("create unique index")
+                {
+                    surface.indexes.insert(normalized.clone());
+                } else if normalized.starts_with("insert into _operator_global_tables") {
+                    let literals = quoted_strings(&statement);
+                    assert!(
+                        literals.len().is_multiple_of(2),
+                        "operator-global registry insert must be (table_name, reason) rows"
+                    );
+                    for row in literals.chunks(2) {
+                        surface
+                            .registry_rows
+                            .insert((row[0].clone(), row[1].clone()));
+                    }
+                } else if normalized.starts_with("alter table communities") {
+                    for added in normalized.split("add column ").skip(1) {
+                        let column = added
+                            .split_whitespace()
+                            .next()
+                            .expect("added column name")
+                            .to_owned();
+                        surface.communities_added_columns.insert(column);
+                    }
+                }
+                if let Some(position) = normalized.find("attach_community_write_fence('") {
+                    let target = normalized[position + "attach_community_write_fence('".len()..]
+                        .split('\'')
+                        .next()
+                        .expect("fence attachment target")
+                        .to_owned();
+                    surface.fence_attachments.insert(target);
+                }
+            }
+            surface
+        }
+
+        // FORK-LOCAL PATCH (adrienlacombe/buzz): upstream's deletion migration is
+        // 0029; it is 0031 here because this fork already holds 0027 and 0028, so
+        // upstream's own new migrations arrive renumbered above them. Only this
+        // version literal moves — the surrounding names and assertion messages are
+        // left as upstream wrote them so this stays one hunk for the next merge.
+        let migration_0029: &str = MIGRATOR
+            .iter()
+            .find(|migration| migration.version == 31)
+            .expect("embedded migration 0031 (upstream's 0029)")
+            .sql
+            .as_ref();
+        let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .parent()
+            .and_then(std::path::Path::parent)
+            .expect("workspace root");
+        let schema_sql = std::fs::read_to_string(workspace_root.join("schema/schema.sql"))
+            .expect("read schema/schema.sql");
+
+        let migration = surface(migration_0029);
+        let schema = surface(&schema_sql);
+
+        assert_eq!(
+            migration.tables.len(),
+            7,
+            "0029 deletion control plane must define exactly the known tables: {:?}",
+            migration.tables.keys().collect::<Vec<_>>()
+        );
+        assert!(!migration.fence_attachments.is_empty());
+        assert!(!migration.registry_rows.is_empty());
+
+        for (table, definition) in &migration.tables {
+            let in_schema = schema
+                .tables
+                .get(table)
+                .unwrap_or_else(|| panic!("schema.sql is missing deletion table {table}"));
+            if table != "community_deletion_requests" {
+                assert_eq!(
+                    in_schema, definition,
+                    "schema.sql definition of {table} drifted from migration 0029"
+                );
+            }
+        }
+        for (function, definition) in &migration.functions {
+            let in_schema = schema
+                .functions
+                .get(function)
+                .unwrap_or_else(|| panic!("schema.sql is missing deletion function {function}"));
+            if function != "community_write_fence_excluded_table" {
+                assert_eq!(
+                    in_schema, definition,
+                    "schema.sql definition of {function}() drifted from migration 0029"
+                );
+            }
+        }
+        for (trigger, definition) in &migration.triggers {
+            let in_schema = schema
+                .triggers
+                .get(trigger)
+                .unwrap_or_else(|| panic!("schema.sql is missing deletion trigger {trigger}"));
+            assert_eq!(
+                in_schema, definition,
+                "schema.sql definition of trigger {trigger} drifted from migration 0029"
+            );
+        }
+        for index in &migration.indexes {
+            assert!(
+                schema.indexes.contains(index),
+                "schema.sql is missing (or drifted on) deletion index: {index}"
+            );
+        }
+        for row in &migration.registry_rows {
+            assert!(
+                schema.registry_rows.contains(row),
+                "schema.sql is missing operator-global registry row {row:?}"
+            );
+        }
+        let mut expected_fences = migration.fence_attachments.clone();
+        expected_fences.remove("product_feedback");
+        expected_fences.remove("rate_limit_violations");
+        assert_eq!(
+            expected_fences, schema.fence_attachments,
+            "write-fence attachment targets differ after recovery policy"
+        );
+
+        // 0029's ALTER TABLE additions are expressed inline by the
+        // desired-state `communities` definition; require the columns to
+        // exist there (exact definition equality is impossible across the
+        // ALTER/inline representations — behavior is pinned by the
+        // desired-state bootstrap deletion test).
+        let communities_columns = split_sql_statements(&schema_sql)
+            .into_iter()
+            .find_map(|statement| {
+                let (table, body) = create_table_body(&statement)?;
+                (table == "communities").then_some(body)
+            })
+            .expect("schema.sql defines communities");
+        let column_names: BTreeSet<String> = communities_columns
+            .iter()
+            .filter_map(|definition| column_definition_name(definition))
+            .collect();
+        for column in &migration.communities_added_columns {
+            assert!(
+                column_names.contains(column),
+                "schema.sql communities table is missing 0028 column {column}"
+            );
+        }
+        assert!(!migration.communities_added_columns.is_empty());
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn schema_destruction_lock_excludes_shared_holders_and_releases_on_both_paths() {
+        let pool = connect_test_pool().await;
+        async fn assert_exclusive_lock_free(pool: &PgPool) {
+            let mut probe = pool.acquire().await.expect("acquire lock probe");
+            let free: bool = sqlx::query_scalar("SELECT pg_try_advisory_lock($1)")
+                .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+                .fetch_one(&mut *probe)
+                .await
+                .expect("probe try-lock");
+            assert!(free, "schema/destruction session lock must be released");
+            sqlx::query("SELECT pg_advisory_unlock($1)")
+                .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+                .execute(&mut *probe)
+                .await
+                .expect("probe unlock");
+        }
+
+        let probe_pool = pool.clone();
+        with_exclusive_schema_destruction_lock(&pool, move |conn| async move {
+            // While a migration run is in flight, destructive transactions
+            // must be unable to take their shared counterpart.
+            let mut probe = probe_pool.acquire().await.expect("acquire shared probe");
+            let shared_available: bool =
+                sqlx::query_scalar("SELECT pg_try_advisory_lock_shared($1)")
+                    .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+                    .fetch_one(&mut *probe)
+                    .await
+                    .expect("probe shared try-lock");
+            assert!(
+                !shared_available,
+                "exclusive migration lock must exclude shared destructive holders"
+            );
+            (conn, Ok(()))
+        })
+        .await
+        .expect("locked migration op");
+        assert_exclusive_lock_free(&pool).await;
+
+        let failed: Result<()> = with_exclusive_schema_destruction_lock(&pool, |conn| async {
+            (
+                conn,
+                Err(crate::DbError::InvalidData(
+                    "forced migration failure".into(),
+                )),
+            )
+        })
+        .await;
+        assert!(failed.is_err(), "op failure must propagate");
+        assert_exclusive_lock_free(&pool).await;
+    }
+
+    /// Cancellation must not release the exclusion contract while migration
+    /// SQL is still executing server-side.
+    ///
+    /// The op parks an `ALTER TABLE` behind an ACCESS EXCLUSIVE table lock
+    /// held by another session, then the whole locked run is aborted. Because
+    /// the advisory lock lives on the same backend that runs the DDL,
+    /// dropping the client future cannot release it: the backend keeps the
+    /// session lock until it finishes the statement and dies on the closed
+    /// socket. The shared (destructive) counterpart must stay unavailable for
+    /// that entire interval — and the orphaned DDL really does commit after
+    /// cancellation, which is exactly the window the lock has to cover.
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn cancelled_migration_cannot_expose_shared_lock_while_ddl_backend_lives() {
+        use std::time::Instant;
+
+        use sqlx::AssertSqlSafe;
+
+        // Dedicated database: the probe table and the orphaned backend must
+        // stay invisible to concurrent tests in the shared database.
+        let base_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .unwrap_or_else(|_| TEST_DB_URL.to_owned());
+        let admin = PgPool::connect(&base_url)
+            .await
+            .expect("connect admin database");
+        let probe_db = format!("buzz_lock_cancel_{}", uuid::Uuid::new_v4().simple());
+        sqlx::query(AssertSqlSafe(format!("CREATE DATABASE {probe_db}")))
+            .execute(&admin)
+            .await
+            .expect("create probe database");
+        let (base_prefix, _) = base_url.rsplit_once('/').expect("database url has a path");
+        let pool = PgPool::connect(&format!("{base_prefix}/{probe_db}"))
+            .await
+            .expect("connect probe database");
+        sqlx::query("CREATE TABLE schema_lock_cancel_probe (id int)")
+            .execute(&pool)
+            .await
+            .expect("create probe table");
+
+        // Park the migration DDL server-side: the op's ALTER TABLE waits on
+        // this ACCESS EXCLUSIVE lock, pinning the backend mid-statement.
+        let mut blocker = pool.begin().await.expect("open blocker transaction");
+        sqlx::query("LOCK TABLE schema_lock_cancel_probe IN ACCESS EXCLUSIVE MODE")
+            .execute(&mut *blocker)
+            .await
+            .expect("hold probe table lock");
+
+        let (pid_tx, pid_rx) = tokio::sync::oneshot::channel::<i32>();
+        let task_pool = pool.clone();
+        let locked_run = tokio::spawn(async move {
+            with_exclusive_schema_destruction_lock(&task_pool, move |mut conn| async move {
+                let outcome: Result<()> = async {
+                    let pid: i32 = sqlx::query_scalar("SELECT pg_backend_pid()")
+                        .fetch_one(&mut conn)
+                        .await?;
+                    let _ = pid_tx.send(pid);
+                    sqlx::query(
+                        "ALTER TABLE schema_lock_cancel_probe \
+                         ADD COLUMN committed_after_cancel int",
+                    )
+                    .execute(&mut conn)
+                    .await?;
+                    Ok(())
+                }
+                .await;
+                (conn, outcome)
+            })
+            .await
+        });
+        let ddl_pid = pid_rx.await.expect("locked op reports its backend pid");
+        let deadline = Instant::now() + std::time::Duration::from_secs(10);
+        loop {
+            let waiting: bool = sqlx::query_scalar(
+                "SELECT EXISTS (SELECT 1 FROM pg_stat_activity \
+                 WHERE pid = $1 AND wait_event_type = 'Lock')",
+            )
+            .bind(ddl_pid)
+            .fetch_one(&pool)
+            .await
+            .expect("poll DDL wait state");
+            if waiting {
+                break;
+            }
+            assert!(
+                Instant::now() < deadline,
+                "migration DDL never parked on the table lock"
+            );
+            tokio::time::sleep(std::time::Duration::from_millis(25)).await;
+        }
+
+        locked_run.abort();
+        let joined = locked_run.await;
+        assert!(
+            joined.is_err_and(|err| err.is_cancelled()),
+            "locked migration run must abort mid-statement"
+        );
+
+        // The client future is gone, but the DDL backend is alive: the shared
+        // destructive lock must remain unavailable for that whole interval.
+        for _ in 0..20 {
+            let backend_alive: bool =
+                sqlx::query_scalar("SELECT EXISTS (SELECT 1 FROM pg_stat_activity WHERE pid = $1)")
+                    .bind(ddl_pid)
+                    .fetch_one(&pool)
+                    .await
+                    .expect("poll DDL backend liveness");
+            assert!(
+                backend_alive,
+                "parked DDL backend must outlive client cancellation"
+            );
+            let shared_free: bool = sqlx::query_scalar("SELECT pg_try_advisory_lock_shared($1)")
+                .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+                .fetch_one(&pool)
+                .await
+                .expect("probe shared lock");
+            assert!(
+                !shared_free,
+                "cancellation must not expose the shared lock while migration DDL is executing"
+            );
+            tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+        }
+
+        // Release the table lock: the orphaned backend finishes the ALTER,
+        // commits, then exits on the dead socket — only then may shared
+        // destructive holders enter.
+        blocker.rollback().await.expect("release probe table lock");
+        let mut probe = pool.acquire().await.expect("acquire shared-lock probe");
+        let deadline = Instant::now() + std::time::Duration::from_secs(30);
+        loop {
+            let shared_free: bool = sqlx::query_scalar("SELECT pg_try_advisory_lock_shared($1)")
+                .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+                .fetch_one(&mut *probe)
+                .await
+                .expect("probe shared lock after backend exit");
+            if shared_free {
+                sqlx::query("SELECT pg_advisory_unlock_shared($1)")
+                    .bind(SCHEMA_DESTRUCTION_LOCK_KEY)
+                    .execute(&mut *probe)
+                    .await
+                    .expect("release shared probe lock");
+                break;
+            }
+            assert!(
+                Instant::now() < deadline,
+                "shared lock must become available once the DDL backend exits"
+            );
+            tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+        }
+        drop(probe);
+
+        // The cancelled statement committed after the client vanished —
+        // exactly the interval the same-backend lock covered.
+        let committed: bool = sqlx::query_scalar(
+            "SELECT EXISTS (SELECT 1 FROM information_schema.columns \
+             WHERE table_name = 'schema_lock_cancel_probe' \
+               AND column_name = 'committed_after_cancel')",
+        )
+        .fetch_one(&pool)
+        .await
+        .expect("inspect orphaned DDL outcome");
+        assert!(
+            committed,
+            "orphaned migration DDL commits after cancellation; the lock must cover it"
+        );
+
+        pool.close().await;
+        sqlx::query(AssertSqlSafe(format!(
+            "DROP DATABASE {probe_db} WITH (FORCE)"
+        )))
+        .execute(&admin)
+        .await
+        .expect("drop probe database");
+    }
+
     async fn connect_test_pool() -> PgPool {
         let database_url = std::env::var("BUZZ_TEST_DATABASE_URL")
             .or_else(|_| std::env::var("DATABASE_URL"))
@@ -1212,7 +1858,15 @@ mod tests {
         run_migrations(&pool)
             .await
             .expect("retry succeeds after operator repair");
-        assert_eq!(applied_versions(&pool).await.last().copied(), Some(30));
+        let latest_version = MIGRATOR
+            .iter()
+            .map(|migration| migration.version)
+            .max()
+            .expect("embedded migrator is non-empty");
+        assert_eq!(
+            applied_versions(&pool).await.last().copied(),
+            Some(latest_version)
+        );
     }
 
     #[tokio::test]
@@ -1334,5 +1988,163 @@ mod tests {
             search_expression.contains("ELSE NULL::tsvector"),
             "fresh installs must default non-allowlisted kinds to NULL: {search_expression}"
         );
+
+        let active_a = uuid::Uuid::new_v4();
+        let active_b = uuid::Uuid::new_v4();
+        let to_fence = uuid::Uuid::new_v4();
+        for (community, label) in [
+            (active_a, "active-a"),
+            (active_b, "active-b"),
+            (to_fence, "to-fence"),
+        ] {
+            sqlx::query("INSERT INTO communities (id, host) VALUES ($1, $2)")
+                .bind(community)
+                .bind(format!("late-fence-{label}-{}.example", community.simple()))
+                .execute(&pool)
+                .await
+                .expect("insert late-table test community");
+        }
+        sqlx::query(
+            "CREATE TABLE late_created_scoped (\
+                 community_id UUID NOT NULL, id BIGINT PRIMARY KEY, value TEXT NOT NULL\
+             )",
+        )
+        .execute(&pool)
+        .await
+        .expect("create late scoped table");
+        sqlx::query("SELECT attach_community_write_fence('late_created_scoped'::regclass)")
+            .execute(&pool)
+            .await
+            .expect("attach late create fence");
+        sqlx::query("CREATE TABLE late_altered_scoped (id BIGINT PRIMARY KEY)")
+            .execute(&pool)
+            .await
+            .expect("create table before late alter");
+        sqlx::query("ALTER TABLE late_altered_scoped ADD COLUMN community_id UUID NOT NULL")
+            .execute(&pool)
+            .await
+            .expect("add late community id");
+        sqlx::query("SELECT attach_community_write_fence('late_altered_scoped'::regclass)")
+            .execute(&pool)
+            .await
+            .expect("attach late alter fence");
+        let attached: Vec<String> = sqlx::query_scalar(
+            "SELECT c.relname FROM pg_trigger trigger \
+             JOIN pg_class c ON c.oid = trigger.tgrelid \
+             JOIN pg_proc procedure ON procedure.oid = trigger.tgfoid \
+             WHERE c.relname IN ('late_created_scoped', 'late_altered_scoped') \
+               AND procedure.proname = 'enforce_community_write_fence' \
+               AND NOT trigger.tgisinternal ORDER BY c.relname",
+        )
+        .fetch_all(&pool)
+        .await
+        .expect("read late trigger catalog");
+        assert_eq!(attached, vec!["late_altered_scoped", "late_created_scoped"]);
+        let malformed_fence_triggers: i64 = sqlx::query_scalar(
+            "SELECT count(*)::BIGINT FROM pg_trigger trigger \
+             JOIN pg_class c ON c.oid = trigger.tgrelid \
+             JOIN pg_proc procedure ON procedure.oid = trigger.tgfoid \
+             WHERE c.relname IN ('late_created_scoped', 'late_altered_scoped') \
+               AND procedure.proname = 'enforce_community_write_fence' \
+               AND NOT trigger.tgisinternal \
+               AND (trigger.tgenabled <> 'O' OR (trigger.tgtype & 31) <> 31)",
+        )
+        .fetch_one(&pool)
+        .await
+        .expect("validate late trigger mode and operations");
+        assert_eq!(malformed_fence_triggers, 0);
+
+        sqlx::query(
+            "INSERT INTO late_created_scoped (community_id, id, value) \
+             VALUES ($1, 1, 'same'), ($2, 2, 'source-fenced'), \
+                    ($1, 3, 'destination-fenced'), ($1, 4, 'opposite-a'), \
+                    ($3, 5, 'opposite-b')",
+        )
+        .bind(active_a)
+        .bind(to_fence)
+        .bind(active_b)
+        .execute(&pool)
+        .await
+        .expect("seed late table while communities active");
+        sqlx::query("UPDATE late_created_scoped SET value = 'same-ok' WHERE id = 1")
+            .execute(&pool)
+            .await
+            .expect("same-tenant active update");
+        sqlx::query("UPDATE late_created_scoped SET community_id = $1 WHERE id = 1")
+            .bind(active_b)
+            .execute(&pool)
+            .await
+            .expect("active-to-active update");
+
+        let mut fence_connection = pool.acquire().await.expect("fence connection");
+        sqlx::query("BEGIN")
+            .execute(&mut *fence_connection)
+            .await
+            .expect("begin direct fence");
+        sqlx::query(
+            "SELECT set_config('buzz.deletion_executor_community', $1, true), \
+                    set_config('buzz.deletion_fence_generation', '1', true)",
+        )
+        .bind(to_fence.to_string())
+        .execute(&mut *fence_connection)
+        .await
+        .expect("authorize direct fence");
+        sqlx::query(
+            "UPDATE communities SET deletion_state = 'fenced', \
+                    deletion_fence_generation = 1, archived_at = now() WHERE id = $1",
+        )
+        .bind(to_fence)
+        .execute(&mut *fence_connection)
+        .await
+        .expect("fence test destination");
+        sqlx::query("COMMIT")
+            .execute(&mut *fence_connection)
+            .await
+            .expect("commit direct fence");
+
+        let active_to_fenced =
+            sqlx::query("UPDATE late_created_scoped SET community_id = $1 WHERE id = 3")
+                .bind(to_fence)
+                .execute(&pool)
+                .await
+                .expect_err("active to fenced destination must fail");
+        assert!(active_to_fenced
+            .to_string()
+            .contains("community write fenced"));
+        let fenced_to_active =
+            sqlx::query("UPDATE late_created_scoped SET community_id = $1 WHERE id = 2")
+                .bind(active_a)
+                .execute(&pool)
+                .await
+                .expect_err("fenced source to active destination must fail");
+        assert!(fenced_to_active
+            .to_string()
+            .contains("community write fenced"));
+        let row_locations: Vec<(i64, uuid::Uuid)> = sqlx::query_as(
+            "SELECT id, community_id FROM late_created_scoped WHERE id IN (2, 3) ORDER BY id",
+        )
+        .fetch_all(&pool)
+        .await
+        .expect("failed moves preserve row location");
+        assert_eq!(row_locations, vec![(2, to_fence), (3, active_a)]);
+
+        let move_a = sqlx::query("UPDATE late_created_scoped SET community_id = $1 WHERE id = 4")
+            .bind(active_b)
+            .execute(&pool);
+        let move_b = sqlx::query("UPDATE late_created_scoped SET community_id = $1 WHERE id = 5")
+            .bind(active_a)
+            .execute(&pool);
+        tokio::time::timeout(std::time::Duration::from_secs(2), async {
+            let (a, b) = tokio::join!(move_a, move_b);
+            a.expect("opposite active move A");
+            b.expect("opposite active move B");
+        })
+        .await
+        .expect("opposite cross-tenant updates must not deadlock");
+
+        sqlx::query("DROP TABLE late_created_scoped, late_altered_scoped")
+            .execute(&pool)
+            .await
+            .expect("drop late-table fixtures");
     }
 }
diff --git a/crates/buzz-db/src/push.rs b/crates/buzz-db/src/push.rs
index 04b6a7ae363..0b3245ffcc2 100644
--- a/crates/buzz-db/src/push.rs
+++ b/crates/buzz-db/src/push.rs
@@ -852,6 +852,7 @@ where
             WHERE attempts < $3
               AND next_attempt_at <= now()
               AND (state = 'pending' OR (state = 'matching' AND lease_until < now()))
+              AND community_write_allowed(community_id)
             ORDER BY next_attempt_at, created_at
             LIMIT 1
         ),
@@ -933,7 +934,8 @@ where
 pub async fn reap_exhausted_matches(pool: &PgPool) -> Result<u64> {
     Ok(sqlx::query(
         "DELETE FROM push_match_queue WHERE attempts >= $1 \
-         AND (state='pending' OR (state='matching' AND lease_until < now()))",
+         AND (state='pending' OR (state='matching' AND lease_until < now())) \
+         AND community_write_allowed(community_id)",
     )
     .bind(MAX_MATCH_ATTEMPTS)
     .execute(pool)
@@ -2121,6 +2123,128 @@ mod tests {
         );
     }
 
+    async fn seed_matcher_fixture(
+        pool: &PgPool,
+        community: CommunityId,
+        marker: u8,
+        attempts: i32,
+        age_seconds: i64,
+    ) {
+        let event_id = vec![marker; 32];
+        sqlx::query(
+            "INSERT INTO events \
+             (community_id, id, pubkey, created_at, kind, tags, content, sig) \
+             VALUES ($1, $2, $3, to_timestamp(1), 9, '[]', '', $4)",
+        )
+        .bind(community.as_uuid())
+        .bind(&event_id)
+        .bind(vec![marker.saturating_add(20); 32])
+        .bind(vec![marker.saturating_add(30); 64])
+        .execute(pool)
+        .await
+        .expect("seed source event");
+        sqlx::query(
+            "INSERT INTO push_match_queue \
+             (community_id, event_id, attempts, next_attempt_at) \
+             VALUES ($1, $2, $3, now() - make_interval(secs => $4))",
+        )
+        .bind(community.as_uuid())
+        .bind(event_id)
+        .bind(attempts)
+        .bind(age_seconds)
+        .execute(pool)
+        .await
+        .expect("seed matcher row");
+    }
+
+    async fn quiesce_test_community(pool: &PgPool, community: CommunityId) {
+        let mut lifecycle = pool.begin().await.expect("begin lifecycle fixture");
+        sqlx::query(
+            "SELECT set_config('buzz.deletion_executor_community', $1, true), \
+                    set_config('buzz.deletion_fence_generation', '0', true)",
+        )
+        .bind(community.to_string())
+        .execute(&mut *lifecycle)
+        .await
+        .expect("authorize target lifecycle");
+        sqlx::query("UPDATE communities SET deletion_state = 'quiescing' WHERE id = $1")
+            .bind(community.as_uuid())
+            .execute(&mut *lifecycle)
+            .await
+            .expect("quiesce target");
+        lifecycle.commit().await.expect("commit target lifecycle");
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn matcher_claim_skips_quiescing_tenant_while_active_bystanders_progress() {
+        let pool = setup_pool().await;
+        sqlx::query("DELETE FROM push_match_queue WHERE community_write_allowed(community_id)")
+            .execute(&pool)
+            .await
+            .expect("drain active matcher queue");
+        let active_a = make_community(&pool).await;
+        let target = make_community(&pool).await;
+        let active_x = make_community(&pool).await;
+        seed_matcher_fixture(&pool, active_a, 1, 0, 30).await;
+        seed_matcher_fixture(&pool, target, 2, 0, 40).await;
+        seed_matcher_fixture(&pool, active_x, 3, 0, 20).await;
+        quiesce_test_community(&pool, target).await;
+
+        let batch = claim_due_match_batch(&pool, 16, Utc::now() + chrono::Duration::minutes(1))
+            .await
+            .expect("claim active bystander")
+            .expect("active A is claimable despite older target row");
+        assert_eq!(batch.community, active_a);
+        let target_state: String =
+            sqlx::query_scalar("SELECT state FROM push_match_queue WHERE community_id = $1")
+                .bind(target.as_uuid())
+                .fetch_one(&pool)
+                .await
+                .expect("target row remains attributed");
+        assert_eq!(target_state, "pending");
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn exhausted_match_reaper_skips_quiescing_tenant_and_reaps_active_bystanders() {
+        let pool = setup_pool().await;
+        sqlx::query("DELETE FROM push_match_queue WHERE community_write_allowed(community_id)")
+            .execute(&pool)
+            .await
+            .expect("drain active matcher queue");
+        let active_a = make_community(&pool).await;
+        let target = make_community(&pool).await;
+        let active_x = make_community(&pool).await;
+        seed_matcher_fixture(&pool, active_a, 4, MAX_MATCH_ATTEMPTS, 30).await;
+        seed_matcher_fixture(&pool, target, 5, MAX_MATCH_ATTEMPTS, 40).await;
+        seed_matcher_fixture(&pool, active_x, 6, MAX_MATCH_ATTEMPTS, 20).await;
+        quiesce_test_community(&pool, target).await;
+
+        assert_eq!(
+            reap_exhausted_matches(&pool)
+                .await
+                .expect("reap active bystanders"),
+            2
+        );
+        let target_remaining: i64 =
+            sqlx::query_scalar("SELECT count(*) FROM push_match_queue WHERE community_id = $1")
+                .bind(target.as_uuid())
+                .fetch_one(&pool)
+                .await
+                .expect("target exhausted row remains attributed");
+        assert_eq!(target_remaining, 1);
+        for active in [active_a, active_x] {
+            let active_remaining: i64 =
+                sqlx::query_scalar("SELECT count(*) FROM push_match_queue WHERE community_id = $1")
+                    .bind(active.as_uuid())
+                    .fetch_one(&pool)
+                    .await
+                    .expect("active bystander is drained");
+            assert_eq!(active_remaining, 0);
+        }
+    }
+
     /// T2b batch contract: one claim returns jobs from exactly ONE community
     /// (so downstream lease/membership loads are single statements), the
     /// set-wise complete and retry honor the claim fence, and a retried job
diff --git a/crates/buzz-db/src/relay_invite.rs b/crates/buzz-db/src/relay_invite.rs
index 82b71b07bb0..14331b022f5 100644
--- a/crates/buzz-db/src/relay_invite.rs
+++ b/crates/buzz-db/src/relay_invite.rs
@@ -111,6 +111,14 @@ pub async fn mint_relay_invite(
     let now = Utc::now();
     let expires_at = now + chrono::Duration::seconds(ttl_secs as i64);
 
+    // Mint a v2 opaque invite inside the same lifecycle gate as every other
+    // community-scoped database write. The trigger remains the final backstop,
+    // but this typed guard keeps a quiescing community from surfacing as an
+    // opaque SQLSTATE/HTTP 500 at the API boundary.
+    let mut tx = pool.begin().await?;
+    crate::deletion::DeletionStore::new(pool.clone())
+        .guard_transaction(&mut tx, community)
+        .await?;
     let row = sqlx::query(
         "INSERT INTO relay_invites (community_id, token_hash, max_uses, expires_at, created_by) \
          VALUES ($1, $2, $3, $4, $5) \
@@ -121,8 +129,9 @@ pub async fn mint_relay_invite(
     .bind(max_uses)
     .bind(expires_at)
     .bind(created_by)
-    .fetch_one(pool)
+    .fetch_one(&mut *tx)
     .await?;
+    tx.commit().await?;
 
     let invite_id: uuid::Uuid = row.try_get("id")?;
 
@@ -167,6 +176,7 @@ pub async fn reap_expired_relay_invites(pool: &PgPool, cutoff: DateTime<Utc>) ->
          WHERE (community_id, id) IN (\
              SELECT community_id, id FROM relay_invites \
              WHERE expires_at < $1 \
+               AND community_write_allowed(community_id) \
              ORDER BY expires_at \
              LIMIT $2\
          )",
@@ -374,20 +384,53 @@ pub async fn claim_relay_invite(
 mod tests {
     use super::*;
     use crate::relay_members::is_relay_member;
+    use sha2::Digest;
     use sqlx::PgPool;
     use uuid::Uuid;
 
     const TEST_DB_URL: &str = "postgres://buzz:buzz_dev@localhost:5432/buzz"; // sadscan:disable np.postgres.1
 
     async fn setup_pool() -> PgPool {
-        let database_url = std::env::var("BUZZ_TEST_DATABASE_URL")
-            .or_else(|_| std::env::var("DATABASE_URL"))
-            .unwrap_or_else(|_| TEST_DB_URL.to_owned());
-        PgPool::connect(&database_url)
+        PgPool::connect(&test_database_url())
             .await
             .expect("connect to test DB")
     }
 
+    fn test_database_url() -> String {
+        std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .unwrap_or_else(|_| TEST_DB_URL.to_owned())
+    }
+
+    async fn create_scratch_database(prefix: &str) -> (PgPool, String, String) {
+        let admin_url = test_database_url();
+        let admin = PgPool::connect(&admin_url)
+            .await
+            .expect("connect to test database server");
+        let name = format!("{}_{}", prefix, Uuid::new_v4().simple());
+        sqlx::query(sqlx::AssertSqlSafe(format!("CREATE DATABASE {name}")))
+            .execute(&admin)
+            .await
+            .expect("create scratch database");
+        let path_start = admin_url
+            .rfind('/')
+            .expect("database URL has a path segment");
+        let scratch_url = format!("{}/{}", &admin_url[..path_start], name);
+        (admin, name, scratch_url)
+    }
+
+    async fn drop_scratch_database(admin: PgPool, db: crate::Db, name: &str) {
+        db.pool.close().await;
+        drop(db);
+        sqlx::query(sqlx::AssertSqlSafe(format!(
+            "DROP DATABASE IF EXISTS {name} WITH (FORCE)"
+        )))
+        .execute(&admin)
+        .await
+        .expect("drop scratch database");
+        admin.close().await;
+    }
+
     async fn make_test_community(pool: &PgPool) -> CommunityId {
         let id = Uuid::new_v4();
         sqlx::query("INSERT INTO communities (id, host) VALUES ($1, $2)")
@@ -448,6 +491,95 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn mint_after_quiescing_returns_typed_fence_without_persisting() {
+        let (admin, database_name, database_url) =
+            create_scratch_database("relay_invite_fence").await;
+        let db = crate::Db::new(&crate::DbConfig {
+            database_url,
+            max_connections: 5,
+            min_connections: 0,
+            ..crate::DbConfig::default()
+        })
+        .await
+        .expect("connect invite deletion test DB");
+        db.migrate().await.expect("migrate invite deletion test DB");
+        let pool = db.pool.clone();
+        let store = db.deletion_store();
+        let host = format!("relay-invite-fence-{}.example", Uuid::new_v4().simple());
+        let community = db
+            .ensure_configured_community(&host)
+            .await
+            .expect("create fenced invite community")
+            .id;
+        let request = store
+            .submit(&host, "owner", None)
+            .await
+            .expect("submit deletion request");
+        let empty_digest = hex::encode(sha2::Sha256::digest([]));
+        let inventory = crate::deletion::FrozenInventory {
+            schema: store
+                .inventory_schema(community)
+                .await
+                .expect("inventory schema"),
+            storage: crate::deletion::StorageManifest {
+                version: 4,
+                prefixes: [
+                    format!("_meta/{community}/"),
+                    format!("_uploads/{community}/"),
+                    format!("repos/{community}/"),
+                ]
+                .into_iter()
+                .map(|prefix| crate::deletion::PrefixManifest {
+                    prefix,
+                    object_count: 0,
+                    total_bytes: 0,
+                    keys_digest: empty_digest.clone(),
+                })
+                .collect(),
+            },
+        };
+        store
+            .freeze_inventory(request.id, &inventory)
+            .await
+            .expect("freeze inventory");
+        store
+            .approve(request.id, "owner", None)
+            .await
+            .expect("approve deletion");
+        let claim = store
+            .claim_specific(
+                request.id,
+                "executor",
+                crate::deletion::DEFAULT_LEASE_DURATION,
+            )
+            .await
+            .expect("claim deletion")
+            .expect("runnable deletion");
+        store
+            .begin_quiescing(&claim.lease)
+            .await
+            .expect("begin quiescing");
+
+        let error = mint_relay_invite(&pool, community, "owner", 3600, Some(1))
+            .await
+            .expect_err("quiescing must reject invite minting");
+        assert!(matches!(error, crate::error::DbError::AccessDenied(_)));
+
+        let invite_count: i64 =
+            sqlx::query_scalar("SELECT count(*) FROM relay_invites WHERE community_id = $1")
+                .bind(community.as_uuid())
+                .fetch_one(&pool)
+                .await
+                .expect("count relay invites");
+        assert_eq!(invite_count, 0, "rejected mint must not persist an invite");
+
+        drop(store);
+        drop(pool);
+        drop_scratch_database(admin, db, &database_name).await;
+    }
+
     #[tokio::test]
     #[ignore = "requires Postgres"]
     async fn bounded_claim_exhausts_and_existing_member_retry_does_not_consume() {
@@ -615,6 +747,73 @@ mod tests {
         delete_test_community(&pool, community).await;
     }
 
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn retention_sweep_skips_quiescing_tenant_while_active_bystanders_progress() {
+        let (admin, database_name, database_url) =
+            create_scratch_database("relay_invite_liveness").await;
+        let db = crate::Db::new(&crate::DbConfig {
+            database_url,
+            max_connections: 5,
+            min_connections: 0,
+            ..crate::DbConfig::default()
+        })
+        .await
+        .expect("connect invite liveness database");
+        db.migrate()
+            .await
+            .expect("migrate invite liveness database");
+        let pool = db.pool.clone();
+        let active_a = make_test_community(&pool).await;
+        let target = make_test_community(&pool).await;
+        let active_x = make_test_community(&pool).await;
+        let cutoff = Utc::now();
+        for community in [active_a, target, active_x] {
+            sqlx::query(
+                "INSERT INTO relay_invites \
+                 (community_id, token_hash, expires_at, created_by) \
+                 VALUES ($1, $2, $3, 'test')",
+            )
+            .bind(community.as_uuid())
+            .bind(sha2::Sha256::digest(community.as_uuid().as_bytes()).as_slice())
+            .bind(cutoff - chrono::Duration::seconds(1))
+            .execute(&pool)
+            .await
+            .expect("seed expired invite");
+        }
+        let mut lifecycle = pool.begin().await.expect("begin lifecycle fixture");
+        sqlx::query(
+            "SELECT set_config('buzz.deletion_executor_community', $1, true), \
+                    set_config('buzz.deletion_fence_generation', '0', true)",
+        )
+        .bind(target.to_string())
+        .execute(&mut *lifecycle)
+        .await
+        .expect("authorize lifecycle fixture");
+        sqlx::query("UPDATE communities SET deletion_state = 'quiescing' WHERE id = $1")
+            .bind(target.as_uuid())
+            .execute(&mut *lifecycle)
+            .await
+            .expect("quiesce target");
+        lifecycle.commit().await.expect("commit lifecycle fixture");
+
+        assert_eq!(
+            reap_expired_relay_invites(&pool, cutoff)
+                .await
+                .expect("reap active bystanders"),
+            2
+        );
+        let remaining: Vec<Uuid> =
+            sqlx::query_scalar("SELECT community_id FROM relay_invites ORDER BY community_id")
+                .fetch_all(&pool)
+                .await
+                .expect("read remaining invite attribution");
+        assert_eq!(remaining, vec![*target.as_uuid()]);
+
+        drop(pool);
+        drop_scratch_database(admin, db, &database_name).await;
+    }
+
     #[tokio::test]
     #[ignore = "requires Postgres"]
     async fn unlimited_invites_count_each_new_member() {
diff --git a/crates/buzz-db/src/replica_fence.rs b/crates/buzz-db/src/replica_fence.rs
index 98bdd9850eb..83322bea141 100644
--- a/crates/buzz-db/src/replica_fence.rs
+++ b/crates/buzz-db/src/replica_fence.rs
@@ -317,8 +317,13 @@ impl ReplicaFence {
 ///
 /// This is a name-and-shape check only; it cannot detect a sabotaged
 /// function body. [`verify_floor_guard_behavior`] proves the semantics.
+///
+/// Generic over the executor so the migration path can run it on the
+/// lock-holding connection while the startup probe keeps using the pool.
 #[datastore_span(name = "replica_fence_verify_catalog", system = "postgresql")]
-pub async fn verify_floor_guard_catalog(pool: &PgPool) -> crate::Result<()> {
+pub async fn verify_floor_guard_catalog<'e>(
+    executor: impl sqlx::PgExecutor<'e>,
+) -> crate::Result<()> {
     // tgtype bits: 1 = ROW, 2 = BEFORE, 4 = INSERT, 16 = UPDATE, 64 = INSTEAD.
     // Required: ROW + INSERT + UPDATE set, BEFORE + INSTEAD clear.
     let missing: Vec<String> = sqlx::query_scalar(
@@ -345,7 +350,7 @@ pub async fn verify_floor_guard_catalog(pool: &PgPool) -> crate::Result<()> {
         )
         "#,
     )
-    .fetch_all(pool)
+    .fetch_all(executor)
     .await?;
     if !missing.is_empty() {
         return Err(crate::error::DbError::InvalidData(format!(
diff --git a/crates/buzz-db/src/workflow.rs b/crates/buzz-db/src/workflow.rs
index 7a2396c1fd7..ad1fd3a9396 100644
--- a/crates/buzz-db/src/workflow.rs
+++ b/crates/buzz-db/src/workflow.rs
@@ -602,6 +602,7 @@ pub async fn prune_scheduled_workflow_fires_before(
         r#"
         DELETE FROM scheduled_workflow_fires
         WHERE claimed_at < $1
+          AND community_write_allowed(community_id)
         "#,
     )
     .bind(older_than)
diff --git a/crates/buzz-deletion/Cargo.toml b/crates/buzz-deletion/Cargo.toml
new file mode 100644
index 00000000000..8c308b0a8c0
--- /dev/null
+++ b/crates/buzz-deletion/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "buzz-deletion"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+description = "Durable whole-community deletion engine for Buzz"
+
+[dependencies]
+anyhow = { workspace = true }
+thiserror = { workspace = true }
+buzz-core = { workspace = true }
+buzz-db = { workspace = true }
+buzz-media = { workspace = true }
+chrono = { workspace = true }
+clap = { version = "4", features = ["derive"] }
+deadpool-redis = { workspace = true }
+hex = { workspace = true }
+redis = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+tokio = { workspace = true }
+tokio-util = { workspace = true }
+uuid = { workspace = true }
+
+[dev-dependencies]
+sqlx = { workspace = true }
diff --git a/crates/buzz-deletion/src/lib.rs b/crates/buzz-deletion/src/lib.rs
new file mode 100644
index 00000000000..4e27b85fe9f
--- /dev/null
+++ b/crates/buzz-deletion/src/lib.rs
@@ -0,0 +1,2063 @@
+#![deny(unsafe_code)]
+#![warn(missing_docs)]
+//! Shared durable whole-community deletion engine and store adapters.
+
+#[cfg(test)]
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::{Context, Result};
+use buzz_db::deletion::{
+    ClaimedDeletion, DeletionRequest, DeletionStage, DeletionStore, FrozenInventory,
+    KeyStreamDigest, LeaseToken, PrefixManifest, StorageManifest, DEFAULT_LEASE_DURATION,
+};
+use buzz_db::{Db, DbConfig};
+use buzz_media::{is_tenant_owned_key, tenant_prefixes, MediaStorage};
+use clap::Subcommand;
+use serde::Serialize;
+use tokio_util::sync::CancellationToken;
+use uuid::Uuid;
+
+/// Fleet-wide object cap for one observational taxonomy sweep.
+const DEFAULT_SWEEP_OBJECT_CAP: u64 = 10_000_000;
+/// Keys per frozen side-table chunk (one `DeleteObjects`-sized unit × 10).
+const DEFAULT_MANIFEST_CHUNK_KEYS: usize = 10_000;
+/// Unknown keys retained verbatim on a sweep record for diagnosis.
+const SWEEP_UNKNOWN_KEY_SAMPLE: usize = 100;
+/// One S3 LIST page.
+const LIST_PAGE_SIZE: usize = 1000;
+const RETRY_DELAY: Duration = Duration::from_secs(30);
+const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(10);
+
+fn heartbeat_interval() -> Duration {
+    HEARTBEAT_INTERVAL
+}
+
+#[derive(Debug, Clone, thiserror::Error)]
+#[error("deletion execution lease heartbeat failed")]
+struct DeletionLeaseLost;
+
+#[derive(Debug, Clone, thiserror::Error)]
+#[error("{message}")]
+struct ServingWriteLeaseLost {
+    message: String,
+}
+
+/// Return the shared durable deletion store for relay and operator paths.
+pub fn store(db: &Db) -> DeletionStore {
+    db.deletion_store()
+}
+
+/// Durable, heartbeated lease for a serving-path external side effect.
+pub struct ServingWriteGuard {
+    store: DeletionStore,
+    lease: buzz_db::deletion::ServingWriteLease,
+    cancel: CancellationToken,
+    lost: CancellationToken,
+    finished: bool,
+}
+
+impl ServingWriteGuard {
+    /// Verify this side-effect lease is still current before an irreversible call.
+    pub async fn verify(&self) -> Result<()> {
+        if self.lost.is_cancelled() {
+            return Err(ServingWriteLeaseLost {
+                message: "serving write lease heartbeat was lost".to_string(),
+            }
+            .into());
+        }
+        self.store
+            .verify_serving_write_lease(&self.lease)
+            .await
+            .map_err(|error| ServingWriteLeaseLost {
+                message: error.to_string(),
+            })?;
+        Ok(())
+    }
+
+    /// Run an external side effect while observing lease-heartbeat loss.
+    ///
+    /// Dropping the operation future on lease loss prevents a stale caller from
+    /// continuing network I/O after its durable exclusion proof disappears.
+    pub async fn protect<F, T>(&self, operation: F) -> Result<T>
+    where
+        F: std::future::Future<Output = T>,
+    {
+        self.verify().await?;
+        let output = tokio::select! {
+            biased;
+            output = operation => output,
+            _ = self.lost.cancelled() => {
+                return Err(ServingWriteLeaseLost {
+                    message: "serving write lease heartbeat was lost".to_string(),
+                }
+                .into())
+            }
+        };
+        self.verify().await?;
+        Ok(output)
+    }
+
+    /// Whether an error represents loss of a durable serving-write lease.
+    pub fn is_lease_lost(error: &anyhow::Error) -> bool {
+        error.downcast_ref::<ServingWriteLeaseLost>().is_some()
+    }
+
+    /// Whether a serving-write acquisition failed because the tenant is fenced.
+    pub fn acquisition_is_fenced(error: &anyhow::Error) -> bool {
+        matches!(
+            error.downcast_ref::<buzz_db::DbError>(),
+            Some(buzz_db::DbError::AccessDenied(_))
+        )
+    }
+
+    /// Signal fired if the background lease heartbeat fails.
+    pub fn lost(&self) -> CancellationToken {
+        self.lost.clone()
+    }
+
+    /// The durable lease token presented to a final database mutation.
+    pub fn lease(&self) -> &buzz_db::deletion::ServingWriteLease {
+        &self.lease
+    }
+
+    /// Release the lease after the side effect completes.
+    pub async fn finish(mut self) -> Result<()> {
+        self.cancel.cancel();
+        let released = self.store.release_serving_write_lease(&self.lease).await?;
+        self.finished = true;
+        if !released {
+            return Err(ServingWriteLeaseLost {
+                message: "serving write lease was already stale or released".to_string(),
+            }
+            .into());
+        }
+        Ok(())
+    }
+}
+
+impl Drop for ServingWriteGuard {
+    fn drop(&mut self) {
+        self.cancel.cancel();
+        if self.finished {
+            return;
+        }
+        let store = self.store.clone();
+        let lease = self.lease.clone();
+        tokio::spawn(async move {
+            let _ = store.release_serving_write_lease(&lease).await;
+        });
+    }
+}
+
+/// Acquire a serving-side external-effect lease without holding a pool connection.
+///
+/// A separate short database lease per effect is intentional: it is the only
+/// durable proof that deletion can drain S3/Redis/push work across replicas.
+/// PostgreSQL lease-table churn is reaped and exported by the relay pool-metrics
+/// task; operators should watch the deletion lease gauges documented by Helm.
+pub async fn acquire_serving_write(
+    db: &Db,
+    community: buzz_core::CommunityId,
+    operation: &str,
+) -> Result<ServingWriteGuard> {
+    acquire_serving_write_with_heartbeat(db, community, operation, heartbeat_interval()).await
+}
+
+async fn acquire_serving_write_with_heartbeat(
+    db: &Db,
+    community: buzz_core::CommunityId,
+    operation: &str,
+    heartbeat_period: Duration,
+) -> Result<ServingWriteGuard> {
+    let store = store(db);
+    let owner = default_executor_id();
+    let lease = store
+        .acquire_serving_write_lease(community, operation, &owner, DEFAULT_LEASE_DURATION)
+        .await?;
+    let heartbeat_store = store.clone();
+    let mut heartbeat_lease = lease.clone();
+    let cancel = CancellationToken::new();
+    let heartbeat_cancel = cancel.clone();
+    let lost = CancellationToken::new();
+    let heartbeat_lost = lost.clone();
+    tokio::spawn(async move {
+        let mut interval = tokio::time::interval(heartbeat_period);
+        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+        interval.tick().await;
+        loop {
+            tokio::select! {
+                _ = heartbeat_cancel.cancelled() => return,
+                _ = interval.tick() => {
+                    if heartbeat_store
+                        .renew_serving_write_lease(
+                            &mut heartbeat_lease,
+                            DEFAULT_LEASE_DURATION,
+                        )
+                        .await
+                        .is_err()
+                    {
+                        heartbeat_lost.cancel();
+                        return;
+                    }
+                }
+            }
+        }
+    });
+    Ok(ServingWriteGuard {
+        store,
+        lease,
+        cancel,
+        lost,
+        finished: false,
+    })
+}
+
+/// CLI-only whole-community deletion commands.
+#[derive(Subcommand)]
+pub enum Command {
+    /// Persist a deletion request and freeze its initial cross-store inventory.
+    Submit {
+        /// Canonical community host. Defaults to RELAY_URL's authority.
+        #[arg(long)]
+        host: Option<String>,
+        /// Operator identity recorded on the request.
+        #[arg(long)]
+        requested_by: String,
+        /// Optional reason for the request.
+        #[arg(long)]
+        reason: Option<String>,
+    },
+    /// List deletion requests as JSON.
+    List {
+        /// Maximum records.
+        #[arg(long, default_value_t = 100, value_parser = clap::value_parser!(u16).range(1..=1000))]
+        limit: u16,
+    },
+    /// Inspect one request, including approval/checkpoints/errors.
+    Inspect {
+        /// Deletion request UUID.
+        id: Uuid,
+    },
+    /// Explicitly approve the exact frozen inventory digest.
+    Approve {
+        /// Deletion request UUID.
+        id: Uuid,
+        /// Approving operator identity.
+        #[arg(long)]
+        approved_by: String,
+        /// Optional approval note.
+        #[arg(long)]
+        note: Option<String>,
+    },
+    /// Terminally cancel before irreversible object deletion begins.
+    Abort {
+        /// Deletion request UUID.
+        id: Uuid,
+        /// Aborting operator identity.
+        #[arg(long)]
+        aborted_by: String,
+        /// Reason recorded in immutable audit evidence.
+        #[arg(long)]
+        reason: String,
+    },
+    /// Resume a blocked request after remediating its recorded failure.
+    Unblock {
+        /// Deletion request UUID.
+        id: Uuid,
+        /// Operator identity recorded in the recovery checkpoint.
+        #[arg(long)]
+        unblocked_by: String,
+        /// Remediation or change reference recorded in the checkpoint.
+        #[arg(long)]
+        reason: String,
+    },
+    /// Claim and run one request until terminal/blocked.
+    Run {
+        /// Deletion request UUID.
+        id: Uuid,
+        /// Executor identity (defaults to hostname/pid).
+        #[arg(long)]
+        executor_id: Option<String>,
+    },
+    /// Drain the currently runnable deletion queue, then exit.
+    Drain {
+        /// Executor identity (defaults to hostname/pid).
+        #[arg(long)]
+        executor_id: Option<String>,
+    },
+    /// Sweep the whole bucket's key taxonomy and record observational evidence.
+    ///
+    /// This is independent of community deletion. It reports unknown writer
+    /// shapes but never gates submission or destructive progress.
+    Sweep,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum LoopMode {
+    Run,
+    Drain,
+}
+
+impl LoopMode {
+    const fn as_str(self) -> &'static str {
+        match self {
+            Self::Run => "run",
+            Self::Drain => "drain",
+        }
+    }
+}
+
+#[derive(Clone)]
+struct Services {
+    store: DeletionStore,
+    media: Arc<MediaStorage>,
+    redis: deadpool_redis::Pool,
+}
+
+#[derive(Debug, thiserror::Error)]
+enum EngineError {
+    #[error("permanent deletion safety failure: {0}")]
+    Permanent(String),
+    #[error("transient deletion dependency failure: {0}")]
+    Transient(String),
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+struct PermanentSource(#[from] anyhow::Error);
+
+fn permanent(message: impl Into<String>) -> anyhow::Error {
+    EngineError::Permanent(message.into()).into()
+}
+
+fn permanent_source(error: impl Into<anyhow::Error>) -> anyhow::Error {
+    PermanentSource(error.into()).into()
+}
+
+fn transient(message: impl Into<String>) -> anyhow::Error {
+    EngineError::Transient(message.into()).into()
+}
+
+fn is_permanent_error(error: &anyhow::Error) -> bool {
+    error.chain().any(|cause| {
+        cause.is::<PermanentSource>()
+            || matches!(
+                cause.downcast_ref::<buzz_db::DbError>(),
+                Some(buzz_db::DbError::DeletionSafety(_))
+            )
+            || cause
+                .downcast_ref::<EngineError>()
+                .is_some_and(|error| matches!(error, EngineError::Permanent(_)))
+    })
+}
+
+#[derive(Debug, Serialize)]
+struct RunOutput {
+    request_id: Uuid,
+    stage: DeletionStage,
+    retry_count: i32,
+    last_error: Option<String>,
+    next_attempt_at: chrono::DateTime<chrono::Utc>,
+    blocked_reason: Option<String>,
+}
+
+/// Execute one nested deletion command.
+pub async fn run(command: Command) -> Result<i32> {
+    match command {
+        Command::List { limit } => {
+            let store = connect_store().await?;
+            print_json(&store.list(i64::from(limit)).await?)?;
+            Ok(0)
+        }
+        Command::Inspect { id } => {
+            let store = connect_store().await?;
+            print_json(&store.inspect(id).await?)?;
+            Ok(0)
+        }
+        Command::Approve {
+            id,
+            approved_by,
+            note,
+        } => {
+            let store = connect_store().await?;
+            print_json(&store.approve(id, &approved_by, note.as_deref()).await?)?;
+            Ok(0)
+        }
+        Command::Abort {
+            id,
+            aborted_by,
+            reason,
+        } => {
+            let store = connect_store().await?;
+            print_json(&store.abort(id, &aborted_by, &reason).await?)?;
+            Ok(0)
+        }
+        Command::Unblock {
+            id,
+            unblocked_by,
+            reason,
+        } => {
+            let store = connect_store().await?;
+            print_json(&store.unblock(id, &unblocked_by, &reason).await?)?;
+            Ok(0)
+        }
+        Command::Run { id, executor_id } => {
+            let store = connect_store().await?;
+            let services = match connect_services_with_store(store.clone()).await {
+                Ok(services) => services,
+                Err(error) => {
+                    let message = format!("{error:#}");
+                    store
+                        .block_preclaim_setup(id, "pre_claim:service_setup", &message)
+                        .await
+                        .context("record pre-claim service setup failure")?;
+                    return Err(error);
+                }
+            };
+            run_loop(
+                services,
+                LoopMode::Run,
+                Some(id),
+                executor_id.unwrap_or_else(default_executor_id),
+            )
+            .await
+        }
+        command => run_with_services(command, connect_services().await?).await,
+    }
+}
+
+async fn run_with_services(command: Command, services: Services) -> Result<i32> {
+    match command {
+        Command::Submit {
+            host,
+            requested_by,
+            reason,
+        } => {
+            let relay_url = std::env::var("RELAY_URL").ok();
+            let host = resolve_submit_host(host.as_deref(), relay_url.as_deref())?;
+            let request = services
+                .store
+                .submit(&host, &requested_by, reason.as_deref())
+                .await?;
+            let inventory = build_inventory(&services, &request).await?;
+            let request = services
+                .store
+                .freeze_inventory(request.id, &inventory)
+                .await?;
+            print_json(&request)?;
+            Ok(0)
+        }
+        Command::Run { id, executor_id } => {
+            run_loop(
+                services,
+                LoopMode::Run,
+                Some(id),
+                executor_id.unwrap_or_else(default_executor_id),
+            )
+            .await
+        }
+        Command::Drain { executor_id } => {
+            run_loop(
+                services,
+                LoopMode::Drain,
+                None,
+                executor_id.unwrap_or_else(default_executor_id),
+            )
+            .await
+        }
+        Command::Sweep => {
+            let started_at = chrono::Utc::now();
+            let cap = sweep_object_cap();
+            let media = Arc::clone(&services.media);
+            let outcome =
+                buzz_media::sweep_bucket_taxonomy(cap, SWEEP_UNKNOWN_KEY_SAMPLE, move |token| {
+                    let media = Arc::clone(&media);
+                    async move { media.list_page(token, LIST_PAGE_SIZE).await }
+                })
+                .await?;
+            let sweep = services
+                .store
+                .record_taxonomy_sweep(
+                    started_at,
+                    outcome.listed_objects,
+                    outcome.unknown_object_count,
+                    &outcome.unknown_key_sample,
+                    cap,
+                )
+                .await?;
+            print_json(&sweep)?;
+            Ok(i32::from(sweep.unknown_object_count > 0))
+        }
+        Command::List { .. }
+        | Command::Inspect { .. }
+        | Command::Approve { .. }
+        | Command::Abort { .. }
+        | Command::Unblock { .. } => {
+            anyhow::bail!("database-only command reached full-service dispatcher")
+        }
+    }
+}
+
+fn resolve_submit_host(host: Option<&str>, relay_url: Option<&str>) -> Result<String> {
+    if let Some(host) = host {
+        let host = host.trim();
+        if host.is_empty() {
+            anyhow::bail!("--host must not be empty");
+        }
+        return Ok(host.to_owned());
+    }
+
+    let relay_url = relay_url
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .ok_or_else(|| {
+            anyhow::anyhow!("cannot derive community host; pass --host or set RELAY_URL")
+        })?;
+    let host = buzz_core::tenant::relay_url_authority(relay_url);
+    if host.is_empty() {
+        anyhow::bail!(
+            "cannot derive community host from RELAY_URL; pass --host or set a valid RELAY_URL"
+        );
+    }
+    Ok(host)
+}
+
+async fn connect_store() -> Result<DeletionStore> {
+    let database_url = required_env("DATABASE_URL")?;
+    let db = Db::new(&DbConfig {
+        database_url,
+        max_connections: env_parse("BUZZ_DB_POOL_SIZE", 20),
+        ..DbConfig::default()
+    })
+    .await?;
+    Ok(store(&db))
+}
+
+fn resolve_s3_region(buzz_region: Option<String>, aws_region: Option<String>) -> String {
+    buzz_region
+        .and_then(nonempty_s3_region)
+        .or_else(|| aws_region.and_then(nonempty_s3_region))
+        .unwrap_or_else(|| "us-east-1".to_string())
+}
+
+fn nonempty_s3_region(region: String) -> Option<String> {
+    let region = region.trim();
+    (!region.is_empty()).then(|| region.to_string())
+}
+
+fn s3_region_from_env() -> String {
+    resolve_s3_region(
+        std::env::var("BUZZ_S3_REGION").ok(),
+        std::env::var("AWS_REGION").ok(),
+    )
+}
+
+async fn connect_services() -> Result<Services> {
+    let store = connect_store().await?;
+    connect_services_with_store(store).await
+}
+
+async fn connect_services_with_store(store: DeletionStore) -> Result<Services> {
+    let media_config = buzz_media::MediaConfig {
+        s3_endpoint: required_env("BUZZ_S3_ENDPOINT")?,
+        s3_access_key: required_env("BUZZ_S3_ACCESS_KEY")?,
+        s3_secret_key: required_env("BUZZ_S3_SECRET_KEY")?,
+        s3_bucket: required_env("BUZZ_S3_BUCKET")?,
+        s3_region: s3_region_from_env(),
+        s3_addressing_style: std::env::var("BUZZ_S3_ADDRESSING_STYLE")
+            .unwrap_or_else(|_| "path".to_string())
+            .parse()
+            .map_err(anyhow::Error::msg)?,
+        max_image_bytes: 1,
+        max_gif_bytes: 1,
+        max_video_bytes: 1,
+        max_file_bytes: 1,
+        public_base_url: "http://localhost/media".to_string(),
+        upload_records_enabled: false,
+        upload_ip_header: None,
+        upload_port_header: None,
+    };
+    let media = Arc::new(MediaStorage::new(&media_config)?);
+    let redis_url = required_env("REDIS_URL")?;
+    let mut redis_config = deadpool_redis::Config::from_url(&redis_url);
+    redis_config.pool = Some(deadpool_redis::PoolConfig::new(env_parse(
+        "BUZZ_REDIS_POOL_SIZE",
+        16,
+    )));
+    let redis = redis_config
+        .create_pool(Some(deadpool_redis::Runtime::Tokio1))
+        .context("create deletion Redis pool")?;
+    Ok(Services {
+        store,
+        media,
+        redis,
+    })
+}
+
+fn required_env(name: &str) -> Result<String> {
+    std::env::var(name)
+        .ok()
+        .map(|value| value.trim().to_owned())
+        .filter(|value| !value.is_empty())
+        .ok_or_else(|| anyhow::anyhow!("{name} is required for community deletion"))
+}
+
+fn env_parse<T>(name: &str, default: T) -> T
+where
+    T: std::str::FromStr,
+{
+    std::env::var(name)
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(default)
+}
+
+fn validate_frozen_inventory(request: &DeletionRequest) -> Result<FrozenInventory> {
+    let frozen: FrozenInventory = serde_json::from_value(
+        request
+            .inventory_manifest
+            .clone()
+            .ok_or_else(|| permanent("approved request has no frozen inventory"))?,
+    )
+    .map_err(permanent_source)?;
+    let expected_digest = request
+        .inventory_digest
+        .as_deref()
+        .ok_or_else(|| permanent("approved request has no frozen inventory digest"))?;
+    let actual_digest = hex::encode(frozen.digest().map_err(permanent_source)?);
+    if actual_digest != expected_digest {
+        return Err(permanent("approved frozen inventory digest mismatch"));
+    }
+    validate_storage_ownership(request, &frozen.storage)?;
+    Ok(frozen)
+}
+
+fn validate_storage_ownership(request: &DeletionRequest, manifest: &StorageManifest) -> Result<()> {
+    buzz_db::deletion::validate_storage_manifest(manifest)?;
+    let expected = tenant_prefixes(*request.community_id.as_uuid());
+    let actual = manifest
+        .prefixes
+        .iter()
+        .map(|prefix| prefix.prefix.as_str())
+        .collect::<Vec<_>>();
+    if actual != expected.iter().map(String::as_str).collect::<Vec<_>>() {
+        return Err(permanent(
+            "storage manifest prefixes are not the deletion target's tenant prefixes",
+        ));
+    }
+    Ok(())
+}
+
+async fn build_inventory(
+    services: &Services,
+    request: &DeletionRequest,
+) -> Result<FrozenInventory> {
+    let schema = services
+        .store
+        .inventory_schema(request.community_id)
+        .await?;
+    let storage = enumerate_tenant_prefixes(services, request, None, None).await?;
+    Ok(FrozenInventory { schema, storage })
+}
+
+/// Buffered writer for frozen key chunks during the destructive freeze.
+struct ChunkSink<'a> {
+    token: &'a LeaseToken,
+    next_chunk_no: i64,
+    buffered: Vec<String>,
+}
+
+async fn flush_chunk(services: &Services, sink: &mut ChunkSink<'_>, prefix: &str) -> Result<()> {
+    if sink.buffered.is_empty() {
+        return Ok(());
+    }
+    services
+        .store
+        .append_manifest_key_chunk(sink.token, sink.next_chunk_no, prefix, &sink.buffered)
+        .await?;
+    sink.next_chunk_no += 1;
+    sink.buffered.clear();
+    Ok(())
+}
+
+/// Enumerate the target's three tenant prefixes into per-prefix summaries.
+///
+/// Cost is O(tenant objects) regardless of fleet size. Unknown shapes inside
+/// one of the owned prefixes fail closed; keys elsewhere in the shared bucket
+/// are outside this operation's contract. Memory stays bounded at one listing
+/// page plus one buffered chunk — the full key list is never materialized.
+/// When `sink` is supplied, keys are also persisted as side-table chunks
+/// (never spanning prefixes) for the destructive freeze to bind against these
+/// digests.
+async fn enumerate_tenant_prefixes(
+    services: &Services,
+    request: &DeletionRequest,
+    heartbeat_lost: Option<&CancellationToken>,
+    mut sink: Option<&mut ChunkSink<'_>>,
+) -> Result<StorageManifest> {
+    if services.media.bucket_versioning_detected().await? {
+        return Err(permanent(
+            "bucket versioning detected; deletion cannot prove logical absence with delete markers",
+        ));
+    }
+    let community = *request.community_id.as_uuid();
+    let chunk_keys = manifest_chunk_keys();
+    let mut prefixes = Vec::new();
+    for prefix in tenant_prefixes(community) {
+        let mut digest = KeyStreamDigest::new();
+        let mut total_bytes: u64 = 0;
+        let mut continuation = None;
+        loop {
+            if heartbeat_lost.is_some_and(CancellationToken::is_cancelled) {
+                return Err(DeletionLeaseLost.into());
+            }
+            let page = services
+                .media
+                .list_prefix_page(&prefix, continuation.take(), LIST_PAGE_SIZE)
+                .await?;
+            for (key, size) in page.objects {
+                if !is_tenant_owned_key(community, &key) {
+                    return Err(permanent(format!(
+                        "key under a tenant prefix is outside the exact writer taxonomy: {key}"
+                    )));
+                }
+                digest.fold(&key)?;
+                total_bytes = total_bytes.saturating_add(size);
+                if let Some(sink) = sink.as_deref_mut() {
+                    sink.buffered.push(key);
+                    if sink.buffered.len() >= chunk_keys {
+                        flush_chunk(services, sink, &prefix).await?;
+                    }
+                }
+            }
+            if !page.is_truncated {
+                break;
+            }
+            continuation = page.next_continuation_token;
+            if continuation.is_none() {
+                return Err(transient(
+                    "truncated tenant listing page has no continuation token",
+                ));
+            }
+        }
+        if let Some(sink) = sink.as_deref_mut() {
+            flush_chunk(services, sink, &prefix).await?;
+        }
+        let (keys_digest, object_count) = digest.finish();
+        prefixes.push(PrefixManifest {
+            prefix,
+            object_count,
+            total_bytes,
+            keys_digest,
+        });
+    }
+    let manifest = StorageManifest {
+        version: 4,
+        prefixes,
+    };
+    buzz_db::deletion::validate_storage_manifest(&manifest)?;
+    Ok(manifest)
+}
+
+/// Freeze the post-fence, post-drain destructive enumeration: stream the
+/// tenant prefixes into side-table chunks, then bind the chunk stream to the
+/// request row's digests atomically.
+async fn freeze_destructive_manifest(
+    services: &Services,
+    request: &DeletionRequest,
+    token: &LeaseToken,
+    heartbeat_lost: &CancellationToken,
+) -> Result<StorageManifest> {
+    validate_frozen_inventory(request)?;
+    // A prior interrupted freeze may have left partial chunks; they were
+    // never bound to a committed manifest, so rewrite them from scratch.
+    services.store.clear_manifest_key_chunks(token).await?;
+    let mut sink = ChunkSink {
+        token,
+        next_chunk_no: 0,
+        buffered: Vec::new(),
+    };
+    let manifest =
+        enumerate_tenant_prefixes(services, request, Some(heartbeat_lost), Some(&mut sink)).await?;
+    services
+        .store
+        .freeze_destructive_storage_manifest(token, &manifest)
+        .await?;
+    Ok(manifest)
+}
+
+async fn run_loop(
+    services: Services,
+    mode: LoopMode,
+    request_id: Option<Uuid>,
+    executor_id: String,
+) -> Result<i32> {
+    let shutdown = shutdown_token();
+    let mut ran = false;
+    loop {
+        if shutdown.is_cancelled() {
+            services
+                .store
+                .stop_executor(None, &executor_id)
+                .await
+                .context("record executor drain")?;
+            return Ok(0);
+        }
+        let claim = match request_id {
+            Some(id) => {
+                services
+                    .store
+                    .claim_specific(id, &executor_id, DEFAULT_LEASE_DURATION)
+                    .await?
+            }
+            None => {
+                services
+                    .store
+                    .claim_next(&executor_id, DEFAULT_LEASE_DURATION)
+                    .await?
+            }
+        };
+        let Some(claim) = claim else {
+            if mode == LoopMode::Run && !ran {
+                anyhow::bail!(
+                    "deletion request is not runnable, is blocked, or is leased by another executor"
+                );
+            }
+            return Ok(0);
+        };
+        ran = true;
+        let output = execute_claim(&services, mode, claim, &shutdown).await?;
+        print_json(&output)?;
+        let failed = output.last_error.is_some() || output.blocked_reason.is_some();
+        if mode == LoopMode::Run || shutdown.is_cancelled() || failed {
+            return Ok(i32::from(failed));
+        }
+    }
+}
+
+async fn stop_claim_executor(
+    services: &Services,
+    mode: LoopMode,
+    token: &LeaseToken,
+) -> Result<()> {
+    // A failed draining heartbeat must not prevent the generation-checked release
+    // attempt. `stop_executor` cannot clear a successor's reclaimed lease.
+    let _ = services
+        .store
+        .heartbeat(token, mode.as_str(), DEFAULT_LEASE_DURATION, true)
+        .await;
+    services
+        .store
+        .stop_executor(Some(token), &token.owner)
+        .await?;
+    Ok(())
+}
+
+async fn record_stage_failure(
+    services: &Services,
+    token: &LeaseToken,
+    stage: DeletionStage,
+    error: &anyhow::Error,
+) -> Result<bool> {
+    let message = format!("{error:#}");
+    let result = if is_permanent_error(error) {
+        services.store.block(token, stage, "stage", &message).await
+    } else {
+        services
+            .store
+            .record_retry(token, stage, "stage", &message, RETRY_DELAY)
+            .await
+    };
+    match result {
+        Ok(()) => Ok(true),
+        Err(error) if buzz_db::deletion::is_stale_deletion_lease(&error) => Ok(false),
+        Err(error) => Err(error.into()),
+    }
+}
+
+async fn execute_claim(
+    services: &Services,
+    mode: LoopMode,
+    mut claim: ClaimedDeletion,
+    shutdown: &CancellationToken,
+) -> Result<RunOutput> {
+    let token = claim.lease.clone();
+    loop {
+        if shutdown.is_cancelled() {
+            stop_claim_executor(services, mode, &token).await?;
+            let request = services.store.get(token.request_id).await?;
+            return Ok(run_output(request));
+        }
+        services
+            .store
+            .heartbeat(&token, mode.as_str(), DEFAULT_LEASE_DURATION, false)
+            .await?;
+        let stage_result = run_stage_with_heartbeat(services, mode, &claim, shutdown).await;
+        match stage_result {
+            StageOutcome::Completed => {}
+            StageOutcome::Shutdown => {
+                stop_claim_executor(services, mode, &token).await?;
+                let request = services.store.get(token.request_id).await?;
+                return Ok(run_output(request));
+            }
+            StageOutcome::Failed(error) => {
+                let request = services.store.get(token.request_id).await?;
+                if request.lease_owner.as_deref() != Some(&token.owner)
+                    || request.lease_generation != token.generation
+                {
+                    return Ok(run_output(request));
+                }
+                if !record_stage_failure(services, &token, claim.request.stage, &error).await? {
+                    // Ownership expired between the stage failure and durable
+                    // error recording. A successor now owns retry/block policy.
+                    let request = services.store.get(token.request_id).await?;
+                    return Ok(run_output(request));
+                }
+                let request = services.store.get(token.request_id).await?;
+                return Ok(run_output(request));
+            }
+        }
+        let request = services.store.get(token.request_id).await?;
+        if request.stage == DeletionStage::RetentionPending || request.blocked_reason.is_some() {
+            return Ok(run_output(request));
+        }
+        claim.request = request.clone();
+        claim.lease.fence_generation = request.fence_generation;
+    }
+}
+
+enum StageOutcome {
+    Completed,
+    Shutdown,
+    Failed(anyhow::Error),
+}
+
+async fn await_stage<F>(
+    stage: F,
+    shutdown: &CancellationToken,
+    heartbeat_error: &CancellationToken,
+) -> StageOutcome
+where
+    F: std::future::Future<Output = Result<()>>,
+{
+    tokio::select! {
+        biased;
+        _ = shutdown.cancelled() => StageOutcome::Shutdown,
+        _ = heartbeat_error.cancelled() => StageOutcome::Failed(DeletionLeaseLost.into()),
+        result = stage => match result {
+            Ok(()) => StageOutcome::Completed,
+            Err(error) => StageOutcome::Failed(error),
+        },
+    }
+}
+
+async fn run_stage_with_heartbeat(
+    services: &Services,
+    mode: LoopMode,
+    claim: &ClaimedDeletion,
+    shutdown: &CancellationToken,
+) -> StageOutcome {
+    let heartbeat_services = services.clone();
+    let heartbeat_token = claim.lease.clone();
+    let heartbeat_mode = mode.as_str();
+    let heartbeat_shutdown = CancellationToken::new();
+    let heartbeat_cancel = heartbeat_shutdown.clone();
+    let heartbeat_error = CancellationToken::new();
+    let heartbeat_error_signal = heartbeat_error.clone();
+    let heartbeat = tokio::spawn(async move {
+        let mut interval = tokio::time::interval(heartbeat_interval());
+        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+        interval.tick().await;
+        loop {
+            tokio::select! {
+                _ = heartbeat_cancel.cancelled() => return,
+                _ = interval.tick() => {
+                    if heartbeat_services
+                        .store
+                        .heartbeat(
+                            &heartbeat_token,
+                            heartbeat_mode,
+                            DEFAULT_LEASE_DURATION,
+                            false,
+                        )
+                        .await
+                        .is_err()
+                    {
+                        heartbeat_error_signal.cancel();
+                        return;
+                    }
+                }
+            }
+        }
+    });
+
+    let stage = await_stage(
+        execute_stage(services, claim, &heartbeat_error),
+        shutdown,
+        &heartbeat_error,
+    )
+    .await;
+    heartbeat_shutdown.cancel();
+    match heartbeat.await {
+        Ok(()) => stage,
+        Err(error) => {
+            StageOutcome::Failed(anyhow::anyhow!("deletion heartbeat task failed: {error}"))
+        }
+    }
+}
+
+async fn run_guarded_external_step<F, Fut, T>(
+    services: &Services,
+    token: &LeaseToken,
+    stage: DeletionStage,
+    heartbeat_lost: &CancellationToken,
+    operation: F,
+) -> Result<T>
+where
+    F: FnOnce() -> Fut,
+    Fut: std::future::Future<Output = Result<T>>,
+{
+    services.store.verify_execution_token(token, stage).await?;
+    let result = tokio::select! {
+        biased;
+        _ = heartbeat_lost.cancelled() => {
+            return Err(DeletionLeaseLost.into());
+        }
+        result = operation() => result,
+    };
+    let output = result?;
+    services.store.verify_execution_token(token, stage).await?;
+    Ok(output)
+}
+
+async fn execute_stage(
+    services: &Services,
+    claim: &ClaimedDeletion,
+    heartbeat_lost: &CancellationToken,
+) -> Result<()> {
+    let request = &claim.request;
+    let token = token_with_current_fence(&claim.lease, request);
+    if matches!(
+        request.stage,
+        DeletionStage::Approved
+            | DeletionStage::Fenced
+            | DeletionStage::Drained
+            | DeletionStage::BindingsRemoved
+            | DeletionStage::PostgresPurged
+            | DeletionStage::CachePurged
+            | DeletionStage::LogicallyVerified
+    ) {
+        validate_frozen_inventory(request)?;
+    }
+    match request.stage {
+        DeletionStage::Approved => {
+            // Approval binds immutable catalog + community-prefix ownership.
+            // Live row counts and tenant binding keys are deliberately not
+            // equality-bound until the durable fence closes all writers.
+            let live_schema = services
+                .store
+                .inventory_schema(request.community_id)
+                .await?;
+            let frozen = validate_frozen_inventory(request)?;
+            if live_schema.scoped_tables != frozen.schema.scoped_tables
+                || live_schema.fenced_tables != frozen.schema.fenced_tables
+            {
+                return Err(permanent(
+                    "approved structural catalog drifted before fencing",
+                ));
+            }
+            services.store.begin_quiescing(&token).await?;
+            match services.store.fence(&token).await {
+                Ok(_) => {}
+                Err(buzz_db::DbError::ServingWritesNotDrained {
+                    active_count,
+                    operations,
+                    ..
+                }) => {
+                    return Err(transient(format!(
+                        "serving writes not drained before fence: count={active_count}, operations={operations:?}"
+                    )));
+                }
+                Err(error) => return Err(error.into()),
+            }
+        }
+        DeletionStage::Fenced => {
+            services
+                .store
+                .verify_execution_token(&token, DeletionStage::Fenced)
+                .await?;
+            let disconnect = tokio::select! {
+                biased;
+                _ = heartbeat_lost.cancelled() => Err(DeletionLeaseLost.into()),
+                result = publish_disconnect_community(&services.redis, request.community_id) => result,
+            };
+            disconnect?;
+            services
+                .store
+                .verify_execution_token(&token, DeletionStage::Fenced)
+                .await?;
+            if !services
+                .store
+                .serving_writes_drained(request.community_id)
+                .await?
+            {
+                return Err(transient("serving writes have not drained"));
+            }
+            // Freeze the destructive enumeration only after the fence closed
+            // new writers AND every admitted serving write drained: the
+            // post-drain listing is the final storage state, so no tenant key
+            // can appear after the freeze.
+            let destructive = match request.destructive_storage_manifest.clone() {
+                Some(value) => serde_json::from_value(value)?,
+                None => {
+                    freeze_destructive_manifest(services, request, &token, heartbeat_lost).await?
+                }
+            };
+            validate_storage_ownership(request, &destructive)?;
+            services.store.mark_drained(&token).await?;
+        }
+        DeletionStage::Drained => {
+            let storage: StorageManifest = serde_json::from_value(
+                request
+                    .destructive_storage_manifest
+                    .clone()
+                    .context("request has no post-fence destructive storage manifest")?,
+            )?;
+            validate_storage_ownership(request, &storage)?;
+            // Resume = first unstamped chunk. Bulk deletes are idempotent
+            // (missing keys report as deleted), so re-deleting a chunk whose
+            // stamp was lost to a crash is safe.
+            let mut removed: u64 = 0;
+            let mut already_missing: u64 = 0;
+            while let Some(chunk) = services.store.next_pending_manifest_chunk(&token).await? {
+                let outcome = run_guarded_external_step(
+                    services,
+                    &token,
+                    DeletionStage::Drained,
+                    heartbeat_lost,
+                    || async { Ok(services.media.delete_objects(&chunk.keys).await?) },
+                )
+                .await?;
+                if !outcome.versioned_keys.is_empty() {
+                    return Err(permanent(format!(
+                        "bulk delete produced version artifacts; bucket versioning blocks \
+                         deletion: {}",
+                        outcome.versioned_keys.join(",")
+                    )));
+                }
+                if !outcome.failed.is_empty() {
+                    let (key, code, message) = &outcome.failed[0];
+                    return Err(transient(format!(
+                        "bulk delete failed for {} key(s); first: {key}: {code}: {message}",
+                        outcome.failed.len()
+                    )));
+                }
+                let acknowledged = outcome.deleted.saturating_add(outcome.already_missing);
+                if acknowledged != chunk.keys.len() as u64 {
+                    return Err(transient(format!(
+                        "bulk delete acknowledged {acknowledged} of {} keys in chunk {}",
+                        chunk.keys.len(),
+                        chunk.chunk_no
+                    )));
+                }
+                removed += outcome.deleted;
+                already_missing += outcome.already_missing;
+                services
+                    .store
+                    .mark_manifest_chunk_deleted(
+                        &token,
+                        chunk.chunk_no,
+                        serde_json::json!({
+                            "prefix": chunk.prefix,
+                            "keys": chunk.keys.len(),
+                            "deleted": outcome.deleted,
+                            "already_missing": outcome.already_missing,
+                        }),
+                    )
+                    .await?;
+            }
+            let frozen_keys: u64 = storage
+                .prefixes
+                .iter()
+                .map(|prefix| prefix.object_count)
+                .sum();
+            services
+                .store
+                .mark_bindings_removed(
+                    &token,
+                    serde_json::json!({
+                        "deleted_keys": frozen_keys,
+                        "removed_now": removed,
+                        "already_missing": already_missing,
+                    }),
+                )
+                .await?;
+        }
+        DeletionStage::BindingsRemoved => {
+            services.store.purge_postgres(&token).await?;
+        }
+        DeletionStage::PostgresPurged => {
+            services
+                .store
+                .verify_execution_token(&token, DeletionStage::PostgresPurged)
+                .await?;
+            let deleted = purge_redis_namespace(&services.redis, request.community_id).await?;
+            services
+                .store
+                .verify_execution_token(&token, DeletionStage::PostgresPurged)
+                .await?;
+            services
+                .store
+                .mark_cache_purged(&token, serde_json::json!({"deleted_keys": deleted}))
+                .await?;
+        }
+        DeletionStage::CachePurged => {
+            services
+                .store
+                .verify_postgres_logically_deleted(&token)
+                .await?;
+            verify_storage_absence(services, request).await?;
+            verify_redis_absence(&services.redis, request.community_id).await?;
+            services
+                .store
+                .mark_logically_verified(
+                    &token,
+                    serde_json::json!({"postgres": true, "object_store": true, "redis": true}),
+                )
+                .await?;
+        }
+        DeletionStage::LogicallyVerified => {
+            validate_frozen_inventory(request)?;
+            services
+                .store
+                .mark_retention_pending(
+                    &token,
+                    serde_json::json!({
+                        "policy": "member-erasure and fleet-wide shared-CAS GC are out of V1 scope"
+                    }),
+                )
+                .await?;
+        }
+        DeletionStage::Submitted | DeletionStage::Inventoried => {
+            anyhow::bail!("request has not crossed the explicit approval boundary")
+        }
+        DeletionStage::RetentionPending | DeletionStage::Aborted => {}
+    }
+    Ok(())
+}
+
+fn token_with_current_fence(token: &LeaseToken, request: &DeletionRequest) -> LeaseToken {
+    LeaseToken {
+        fence_generation: request.fence_generation,
+        ..token.clone()
+    }
+}
+
+/// Prove logical absence by listing each tenant prefix and requiring it
+/// empty — O(1) requests per prefix, independent of fleet size.
+async fn verify_storage_absence(services: &Services, request: &DeletionRequest) -> Result<()> {
+    for prefix in tenant_prefixes(*request.community_id.as_uuid()) {
+        let page = services.media.list_prefix_page(&prefix, None, 1).await?;
+        if let Some((key, _)) = page.objects.first() {
+            return Err(transient(format!(
+                "logical verification found a live target object binding: {key}"
+            )));
+        }
+    }
+    Ok(())
+}
+
+async fn publish_disconnect_community(
+    pool: &deadpool_redis::Pool,
+    community: buzz_core::CommunityId,
+) -> Result<()> {
+    let mut connection = pool.get().await?;
+    let channel = format!("buzz:{community}:conn-control");
+    let _: u64 = redis::cmd("PUBLISH")
+        .arg(channel)
+        .arg(r#"{"op":"DisconnectCommunity"}"#)
+        .query_async(&mut *connection)
+        .await?;
+    Ok(())
+}
+
+async fn purge_redis_namespace(
+    pool: &deadpool_redis::Pool,
+    community: buzz_core::CommunityId,
+) -> Result<u64> {
+    let mut connection = pool.get().await?;
+    let pattern = format!("buzz:{community}:*");
+    let mut cursor = 0u64;
+    let mut deleted = 0u64;
+    loop {
+        let (next, keys): (u64, Vec<String>) = redis::cmd("SCAN")
+            .arg(cursor)
+            .arg("MATCH")
+            .arg(&pattern)
+            .arg("COUNT")
+            .arg(1000)
+            .query_async(&mut *connection)
+            .await?;
+        if !keys.is_empty() {
+            let count: u64 = redis::cmd("UNLINK")
+                .arg(&keys)
+                .query_async(&mut *connection)
+                .await?;
+            deleted = deleted.saturating_add(count);
+        }
+        if next == 0 {
+            break;
+        }
+        cursor = next;
+    }
+    Ok(deleted)
+}
+
+fn scan_proves_absence(pages: &[(u64, Vec<String>)]) -> bool {
+    pages.last().is_some_and(|(cursor, _)| *cursor == 0)
+        && pages.iter().all(|(_, keys)| keys.is_empty())
+}
+
+async fn scan_redis_namespace(
+    connection: &mut deadpool_redis::Connection,
+    pattern: &str,
+) -> Result<Vec<(u64, Vec<String>)>> {
+    let mut cursor = 0u64;
+    let mut pages = Vec::new();
+    loop {
+        let page: (u64, Vec<String>) = redis::cmd("SCAN")
+            .arg(cursor)
+            .arg("MATCH")
+            .arg(pattern)
+            .arg("COUNT")
+            .arg(1000)
+            .query_async(&mut **connection)
+            .await?;
+        cursor = page.0;
+        pages.push(page);
+        if cursor == 0 {
+            return Ok(pages);
+        }
+    }
+}
+
+async fn verify_redis_absence(
+    pool: &deadpool_redis::Pool,
+    community: buzz_core::CommunityId,
+) -> Result<()> {
+    let mut connection = pool.get().await?;
+    let pattern = format!("buzz:{community}:*");
+    // SCAN is weakly consistent. Two complete empty passes ensure a cursor
+    // rollover or concurrent expiry cannot make one sparse pass look absent.
+    let first = scan_redis_namespace(&mut connection, &pattern).await?;
+    let second = scan_redis_namespace(&mut connection, &pattern).await?;
+    if scan_proves_absence(&first) && scan_proves_absence(&second) {
+        Ok(())
+    } else {
+        Err(transient(
+            "logical verification found a Redis namespace key",
+        ))
+    }
+}
+
+fn sweep_object_cap() -> u64 {
+    std::env::var("BUZZ_DELETION_SWEEP_MAX_OBJECTS")
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .filter(|value| *value > 0)
+        .unwrap_or(DEFAULT_SWEEP_OBJECT_CAP)
+}
+
+fn manifest_chunk_keys() -> usize {
+    std::env::var("BUZZ_DELETION_MANIFEST_CHUNK_KEYS")
+        .ok()
+        .and_then(|value| value.parse::<usize>().ok())
+        .filter(|value| *value > 0)
+        .map(|value| value.min(100_000))
+        .unwrap_or(DEFAULT_MANIFEST_CHUNK_KEYS)
+}
+
+fn default_executor_id() -> String {
+    let hostname = std::env::var("HOSTNAME").unwrap_or_else(|_| "buzz-admin".to_string());
+    format!("{hostname}:{}", std::process::id())
+}
+
+fn shutdown_token() -> CancellationToken {
+    let token = CancellationToken::new();
+    let signal = token.clone();
+    tokio::spawn(async move {
+        #[cfg(unix)]
+        {
+            use tokio::signal::unix::{signal as unix_signal, SignalKind};
+            if let Ok(mut terminate) = unix_signal(SignalKind::terminate()) {
+                tokio::select! {
+                    _ = tokio::signal::ctrl_c() => {},
+                    _ = terminate.recv() => {},
+                }
+            } else {
+                let _ = tokio::signal::ctrl_c().await;
+            }
+        }
+        #[cfg(not(unix))]
+        {
+            let _ = tokio::signal::ctrl_c().await;
+        }
+        signal.cancel();
+    });
+    token
+}
+
+fn run_output(request: DeletionRequest) -> RunOutput {
+    RunOutput {
+        request_id: request.id,
+        stage: request.stage,
+        retry_count: request.retry_count,
+        last_error: request.last_error,
+        next_attempt_at: request.next_attempt_at,
+        blocked_reason: request.blocked_reason,
+    }
+}
+
+fn print_json(value: &impl Serialize) -> Result<()> {
+    println!("{}", serde_json::to_string_pretty(value)?);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn submit_host_prefers_explicit_host() {
+        assert_eq!(
+            resolve_submit_host(Some(" community.example "), Some("wss://ignored.example"))
+                .expect("explicit host"),
+            "community.example"
+        );
+    }
+
+    #[test]
+    fn submit_host_derives_from_relay_url() {
+        assert_eq!(
+            resolve_submit_host(None, Some("wss://relay.example:8443/path"))
+                .expect("relay URL host"),
+            "relay.example:8443"
+        );
+    }
+
+    #[test]
+    fn submit_host_requires_an_explicit_source() {
+        for relay_url in [None, Some(""), Some("   ")] {
+            let error = resolve_submit_host(None, relay_url).expect_err("missing host must fail");
+            assert!(error.to_string().contains("pass --host or set RELAY_URL"));
+        }
+    }
+
+    #[test]
+    fn submit_host_rejects_empty_or_invalid_values() {
+        assert!(resolve_submit_host(Some("   "), Some("wss://relay.example")).is_err());
+        assert!(resolve_submit_host(None, Some("not a URL")).is_err());
+    }
+
+    fn empty_storage_manifest(community: buzz_core::CommunityId) -> StorageManifest {
+        StorageManifest {
+            version: 4,
+            prefixes: tenant_prefixes(*community.as_uuid())
+                .into_iter()
+                .map(|prefix| PrefixManifest {
+                    prefix,
+                    object_count: 0,
+                    total_bytes: 0,
+                    keys_digest: KeyStreamDigest::new().finish().0,
+                })
+                .collect(),
+        }
+    }
+
+    async fn claimed_test_deletion(prefix: &str) -> (Db, Services, ClaimedDeletion) {
+        let database_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .expect("BUZZ_TEST_DATABASE_URL or DATABASE_URL is required");
+        let pool = sqlx::PgPool::connect(&database_url)
+            .await
+            .expect("connect deletion engine test DB");
+        let db = Db::from_pool(pool);
+        db.migrate().await.expect("migrate deletion engine test DB");
+        let store = db.deletion_store();
+        let host = format!("{prefix}-{}.example", Uuid::new_v4().simple());
+        let community = db
+            .ensure_configured_community(&host)
+            .await
+            .expect("create deletion engine test community");
+        let request = store
+            .submit(&host, "test", None)
+            .await
+            .expect("submit deletion request");
+        let inventory = FrozenInventory {
+            schema: store
+                .inventory_schema(community.id)
+                .await
+                .expect("inventory schema"),
+            storage: empty_storage_manifest(community.id),
+        };
+        store
+            .freeze_inventory(request.id, &inventory)
+            .await
+            .expect("freeze deletion inventory");
+        store
+            .approve(request.id, "test", None)
+            .await
+            .expect("approve deletion request");
+        let claim = store
+            .claim_specific(request.id, "test-executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim deletion request")
+            .expect("runnable deletion request");
+        let services = Services {
+            store,
+            media: Arc::new(
+                MediaStorage::new(&buzz_media::MediaConfig {
+                    s3_endpoint: "http://127.0.0.1:1".to_string(),
+                    s3_access_key: "unused".to_string(),
+                    s3_secret_key: "unused".to_string(),
+                    s3_bucket: "unused".to_string(),
+                    s3_region: "us-east-1".to_string(),
+                    s3_addressing_style: buzz_media::S3AddressingStyle::Path,
+                    max_image_bytes: 1,
+                    max_gif_bytes: 1,
+                    max_video_bytes: 1,
+                    max_file_bytes: 1,
+                    public_base_url: "http://localhost/media".to_string(),
+                    upload_records_enabled: false,
+                    upload_ip_header: None,
+                    upload_port_header: None,
+                })
+                .expect("construct unused media service"),
+            ),
+            redis: deadpool_redis::Config::from_url("redis://127.0.0.1:1")
+                .create_pool(Some(deadpool_redis::Runtime::Tokio1))
+                .expect("construct unused Redis pool"),
+        };
+        (db, services, claim)
+    }
+
+    fn deletion_test_media_storage() -> Arc<MediaStorage> {
+        let endpoint = std::env::var("BUZZ_TEST_S3_ENDPOINT")
+            .or_else(|_| std::env::var("BUZZ_S3_ENDPOINT"))
+            .expect("BUZZ_TEST_S3_ENDPOINT or BUZZ_S3_ENDPOINT is required");
+        let access_key = std::env::var("BUZZ_TEST_S3_ACCESS_KEY")
+            .or_else(|_| std::env::var("BUZZ_S3_ACCESS_KEY"))
+            .expect("BUZZ_TEST_S3_ACCESS_KEY or BUZZ_S3_ACCESS_KEY is required");
+        let secret_key = std::env::var("BUZZ_TEST_S3_SECRET_KEY")
+            .or_else(|_| std::env::var("BUZZ_S3_SECRET_KEY"))
+            .expect("BUZZ_TEST_S3_SECRET_KEY or BUZZ_S3_SECRET_KEY is required");
+        let bucket = std::env::var("BUZZ_TEST_S3_BUCKET")
+            .or_else(|_| std::env::var("BUZZ_S3_BUCKET"))
+            .expect("BUZZ_TEST_S3_BUCKET or BUZZ_S3_BUCKET is required");
+        Arc::new(
+            MediaStorage::new(&buzz_media::MediaConfig {
+                s3_endpoint: endpoint,
+                s3_access_key: access_key,
+                s3_secret_key: secret_key,
+                s3_bucket: bucket,
+                s3_region: std::env::var("BUZZ_TEST_S3_REGION")
+                    .or_else(|_| std::env::var("BUZZ_S3_REGION"))
+                    .unwrap_or_else(|_| "us-east-1".to_string()),
+                s3_addressing_style: buzz_media::S3AddressingStyle::Path,
+                max_image_bytes: 1,
+                max_gif_bytes: 1,
+                max_video_bytes: 1,
+                max_file_bytes: 1,
+                public_base_url: "http://localhost/media".to_string(),
+                upload_records_enabled: false,
+                upload_ip_header: None,
+                upload_port_header: None,
+            })
+            .expect("construct deletion test media service"),
+        )
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn approved_stage_allows_post_inventory_row_churn_before_fencing() {
+        let (db, services, claim) = claimed_test_deletion("deletion-row-churn").await;
+        let frozen: FrozenInventory = serde_json::from_value(
+            claim
+                .request
+                .inventory_manifest
+                .clone()
+                .expect("frozen inventory"),
+        )
+        .expect("decode frozen inventory");
+
+        db.add_to_allowlist(claim.request.community_id, &[0x41; 32], &[0x42; 32], None)
+            .await
+            .expect("post-inventory serving write");
+        let live = services
+            .store
+            .inventory_schema(claim.request.community_id)
+            .await
+            .expect("live inventory after serving churn");
+        assert_eq!(live.scoped_tables, frozen.schema.scoped_tables);
+        assert_eq!(live.fenced_tables, frozen.schema.fenced_tables);
+        assert_eq!(
+            live.row_counts["pubkey_allowlist"],
+            frozen.schema.row_counts["pubkey_allowlist"] + 1
+        );
+
+        execute_stage(&services, &claim, &CancellationToken::new())
+            .await
+            .expect("row-count churn must not fail structural revalidation");
+        let fenced = services
+            .store
+            .get(claim.request.id)
+            .await
+            .expect("load fenced request");
+        assert_eq!(fenced.stage, DeletionStage::Fenced);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn frozen_inventory_digest_and_storage_ownership_fail_closed() {
+        let (_, _, claim) = claimed_test_deletion("deletion-integrity").await;
+        assert!(validate_frozen_inventory(&claim.request).is_ok());
+
+        let mut digest_tampered = claim.request.clone();
+        digest_tampered.inventory_manifest = Some(serde_json::json!({
+            "schema": {"scoped_tables": [], "row_counts": {}, "fenced_tables": []},
+            "storage": {"version": 4, "prefixes": []}
+        }));
+        assert!(validate_frozen_inventory(&digest_tampered).is_err());
+
+        // A manifest scoped to another community's prefixes is never the
+        // deletion target's, even when internally valid.
+        let foreign_manifest =
+            empty_storage_manifest(buzz_core::CommunityId::from_uuid(Uuid::new_v4()));
+        assert!(validate_storage_ownership(&claim.request, &foreign_manifest).is_err());
+    }
+
+    /// The non-atomic boundary under test: S3 committed a chunk's deletes,
+    /// then the worker died before the chunk stamp. Resume must re-delete the
+    /// chunk (missing keys report as deleted — idempotent), stamp it, and
+    /// finish the stage.
+    #[tokio::test]
+    #[ignore = "requires Postgres and S3-compatible storage"]
+    async fn drained_stage_resumes_chunk_deleted_before_stamp() {
+        let (_, mut services, claim) = claimed_test_deletion("deletion-chunk-resume").await;
+        services.media = deletion_test_media_storage();
+        let community = claim.request.community_id;
+        let meta_prefix = format!("_meta/{community}/");
+        let keys = vec![
+            format!("{meta_prefix}{}.json", "a".repeat(64)),
+            format!("{meta_prefix}{}.json", "b".repeat(64)),
+        ];
+        for key in &keys {
+            services
+                .media
+                .put(key, b"chunk-resume", "application/json")
+                .await
+                .expect("seed object");
+        }
+
+        services
+            .store
+            .begin_quiescing(&claim.lease)
+            .await
+            .expect("quiesce");
+        let generation = services.store.fence(&claim.lease).await.expect("fence");
+        let token = LeaseToken {
+            fence_generation: Some(generation),
+            ..claim.lease.clone()
+        };
+        // Two single-key chunks so resume order is observable.
+        services
+            .store
+            .append_manifest_key_chunk(&token, 0, &meta_prefix, &keys[..1])
+            .await
+            .expect("append chunk 0");
+        services
+            .store
+            .append_manifest_key_chunk(&token, 1, &meta_prefix, &keys[1..])
+            .await
+            .expect("append chunk 1");
+        let mut digest = KeyStreamDigest::new();
+        for key in &keys {
+            digest.fold(key).expect("fold key");
+        }
+        let (keys_digest, object_count) = digest.finish();
+        let mut storage = empty_storage_manifest(community);
+        storage.prefixes[0] = PrefixManifest {
+            prefix: meta_prefix.clone(),
+            object_count,
+            total_bytes: keys.len() as u64 * "chunk-resume".len() as u64,
+            keys_digest,
+        };
+        services
+            .store
+            .freeze_destructive_storage_manifest(&token, &storage)
+            .await
+            .expect("freeze chunked manifest");
+        services.store.mark_drained(&token).await.expect("drained");
+
+        // Simulate the crash window: chunk 0's key is already gone from S3
+        // but the chunk was never stamped.
+        services
+            .media
+            .delete(&keys[0])
+            .await
+            .expect("simulate committed delete before stamp");
+
+        let resumed = ClaimedDeletion {
+            request: services
+                .store
+                .get(token.request_id)
+                .await
+                .expect("reload drained request"),
+            lease: claim.lease,
+        };
+        execute_stage(&services, &resumed, &CancellationToken::new())
+            .await
+            .expect("Drained stage resumes at the unstamped chunk");
+
+        assert_eq!(
+            services
+                .store
+                .manifest_chunk_progress(token.request_id)
+                .await
+                .expect("chunk progress"),
+            (2, 2)
+        );
+        assert_eq!(
+            services.store.get(token.request_id).await.unwrap().stage,
+            DeletionStage::BindingsRemoved
+        );
+        for key in &keys {
+            assert!(
+                !services.media.head(key).await.expect("verify absence"),
+                "tenant binding {key} must be gone"
+            );
+        }
+    }
+
+    #[test]
+    fn permanent_failures_are_typed_not_string_classified() {
+        let permanent_error = permanent("catalog drift");
+        let transient_error = transient("temporary catalog service reset");
+        let nested = permanent_source(anyhow::anyhow!("schema mismatch")).context("outer");
+        let db_permanent = anyhow::Error::from(buzz_db::DbError::DeletionSafety(
+            "typed catalog drift".to_string(),
+        ));
+        let db_transient = anyhow::Error::from(buzz_db::DbError::Sqlx(sqlx::Error::PoolTimedOut));
+        assert!(is_permanent_error(&permanent_error));
+        assert!(is_permanent_error(&nested));
+        assert!(is_permanent_error(&db_permanent));
+        assert!(!is_permanent_error(&transient_error));
+        assert!(!is_permanent_error(&db_transient));
+    }
+
+    #[test]
+    fn deletion_configuration_requires_every_destructive_dependency() {
+        let variable = format!("BUZZ_DELETION_REQUIRED_TEST_{}", Uuid::new_v4().simple());
+        assert!(required_env(&variable).is_err());
+        std::env::set_var(&variable, "   ");
+        assert!(required_env(&variable).is_err());
+        std::env::set_var(&variable, "configured");
+        assert_eq!(
+            required_env(&variable).expect("configured environment variable"),
+            "configured"
+        );
+        std::env::remove_var(&variable);
+    }
+
+    #[test]
+    fn deletion_s3_region_matches_relay_precedence_and_default() {
+        assert_eq!(resolve_s3_region(None, None), "us-east-1");
+        assert_eq!(
+            resolve_s3_region(Some("   ".to_string()), None),
+            "us-east-1"
+        );
+        assert_eq!(
+            resolve_s3_region(Some("   ".to_string()), Some(" us-west-2 ".to_string())),
+            "us-west-2"
+        );
+        assert_eq!(
+            resolve_s3_region(None, Some("us-west-2".to_string())),
+            "us-west-2"
+        );
+        assert_eq!(
+            resolve_s3_region(
+                Some("eu-central-1".to_string()),
+                Some("us-west-2".to_string())
+            ),
+            "eu-central-1"
+        );
+    }
+
+    #[test]
+    fn redis_absence_requires_terminal_cursor_and_all_pages_empty() {
+        assert!(!scan_proves_absence(&[(9, Vec::new())]));
+        assert!(!scan_proves_absence(&[
+            (9, Vec::new()),
+            (0, vec!["buzz:tenant:late".to_string()]),
+        ]));
+        assert!(scan_proves_absence(&[(9, Vec::new()), (0, Vec::new())]));
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres and S3-compatible storage"]
+    async fn final_storage_verification_rejects_late_target_binding() {
+        let (_, mut services, claim) = claimed_test_deletion("deletion-late-binding").await;
+        services.media = deletion_test_media_storage();
+        let community = claim.request.community_id;
+        let late_key = format!("_meta/{community}/{}.json", "a".repeat(64));
+        services
+            .media
+            .put(&late_key, b"late", "application/json")
+            .await
+            .expect("seed late binding");
+        let error = verify_storage_absence(&services, &claim.request)
+            .await
+            .expect_err("late target binding must fail verification");
+        assert!(format!("{error:#}").contains(&late_key));
+        services
+            .media
+            .delete(&late_key)
+            .await
+            .expect("remove late binding");
+        verify_storage_absence(&services, &claim.request)
+            .await
+            .expect("empty tenant prefixes verify clean");
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn stale_lease_during_failure_recording_is_lost_ownership() {
+        let (_, services, claim) = claimed_test_deletion("deletion-stale-record").await;
+        let database_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .expect("test database URL");
+        let pool = sqlx::PgPool::connect(&database_url)
+            .await
+            .expect("connect stale-record test DB");
+        sqlx::query(
+            "UPDATE community_deletion_requests SET lease_until = now() - interval '1 second' WHERE id = $1",
+        )
+        .bind(claim.request.id)
+        .execute(&pool)
+        .await
+        .expect("expire claim");
+        let recorded = record_stage_failure(
+            &services,
+            &claim.lease,
+            claim.request.stage,
+            &transient("test failure"),
+        )
+        .await
+        .expect("stale ownership is not fatal");
+        assert!(!recorded);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn serving_guard_heartbeats_long_operation_through_quiescing() {
+        let (db, services, claim) = claimed_test_deletion("serving-guard-quiesce").await;
+        let community = claim.request.community_id;
+        let guard = acquire_serving_write_with_heartbeat(
+            &db,
+            community,
+            "test_quiesce",
+            Duration::from_millis(10),
+        )
+        .await
+        .expect("serving guard");
+
+        services
+            .store
+            .begin_quiescing(&claim.lease)
+            .await
+            .expect("quiesce");
+        assert!(
+            services
+                .store
+                .acquire_serving_write_lease(
+                    community,
+                    "late_external",
+                    "late-owner",
+                    DEFAULT_LEASE_DURATION,
+                )
+                .await
+                .is_err(),
+            "quiescing must reject newly admitted work"
+        );
+
+        let completed = Arc::new(AtomicBool::new(false));
+        let operation_completed = Arc::clone(&completed);
+        let result = guard
+            .protect(async move {
+                tokio::time::sleep(Duration::from_millis(75)).await;
+                operation_completed.store(true, Ordering::Relaxed);
+            })
+            .await;
+        assert!(
+            !guard.lost().is_cancelled(),
+            "quiescing must not cancel the admitted lease heartbeat"
+        );
+        result.expect("admitted operation survives quiescing heartbeats");
+        assert!(completed.load(Ordering::Relaxed));
+        assert!(matches!(
+            services.store.fence(&claim.lease).await,
+            Err(buzz_db::DbError::ServingWritesNotDrained {
+                active_count: 1,
+                ..
+            })
+        ));
+
+        guard.finish().await.expect("release serving guard");
+        assert_eq!(services.store.fence(&claim.lease).await.expect("fence"), 1);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn serving_guard_cancels_protected_operation_when_heartbeat_is_lost() {
+        let database_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .expect("BUZZ_TEST_DATABASE_URL or DATABASE_URL is required");
+        let pool = sqlx::PgPool::connect(&database_url)
+            .await
+            .expect("connect serving guard test DB");
+        let db = Db::from_pool(pool.clone());
+        db.migrate().await.expect("migrate serving guard test DB");
+        let community = db
+            .ensure_configured_community(&format!(
+                "serving-guard-{}.example",
+                Uuid::new_v4().simple()
+            ))
+            .await
+            .expect("create test community")
+            .id;
+        let guard = acquire_serving_write_with_heartbeat(
+            &db,
+            community,
+            "test_cancel",
+            Duration::from_millis(10),
+        )
+        .await
+        .expect("serving guard");
+        sqlx::query("DELETE FROM community_serving_write_leases WHERE community_id = $1")
+            .bind(community.as_uuid())
+            .execute(&pool)
+            .await
+            .expect("force heartbeat failure");
+        let completed = Arc::new(AtomicBool::new(false));
+        let operation_completed = Arc::clone(&completed);
+        let result = guard
+            .protect(async move {
+                tokio::time::sleep(Duration::from_secs(1)).await;
+                operation_completed.store(true, Ordering::Relaxed);
+            })
+            .await;
+        assert!(result.is_err(), "lease loss must reject the operation");
+        assert!(
+            !completed.load(Ordering::Relaxed),
+            "lease loss must cancel the protected operation future"
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn guarded_external_step_rejects_preexisting_heartbeat_loss_without_polling_operation() {
+        let (_, services, claim) = claimed_test_deletion("deletion-heartbeat").await;
+        let heartbeat_lost = CancellationToken::new();
+        heartbeat_lost.cancel();
+        let polled = Arc::new(AtomicBool::new(false));
+        let operation_polled = Arc::clone(&polled);
+        let result = run_guarded_external_step(
+            &services,
+            &claim.lease,
+            DeletionStage::Approved,
+            &heartbeat_lost,
+            || async move {
+                operation_polled.store(true, Ordering::Relaxed);
+                Ok(())
+            },
+        )
+        .await;
+        assert!(result.is_err(), "heartbeat loss must abort the side effect");
+        assert!(
+            result
+                .expect_err("heartbeat loss error")
+                .downcast_ref::<DeletionLeaseLost>()
+                .is_some(),
+            "heartbeat loss must stay typed"
+        );
+        assert!(
+            !polled.load(Ordering::Relaxed),
+            "a pre-cancelled heartbeat must win before polling the operation"
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn shutdown_during_stage_releases_claim_without_recording_retry() {
+        let (_, services, claim) = claimed_test_deletion("deletion-shutdown").await;
+        let request_id = claim.request.id;
+        let retry_count = claim.request.retry_count;
+        let shutdown = CancellationToken::new();
+        let cancel = shutdown.clone();
+        let services_for_run = services.clone();
+        let executor = tokio::spawn(async move {
+            execute_claim(&services_for_run, LoopMode::Drain, claim, &shutdown).await
+        });
+        tokio::time::sleep(Duration::from_millis(10)).await;
+        cancel.cancel();
+        let output = tokio::time::timeout(Duration::from_secs(2), executor)
+            .await
+            .expect("shutdown must cancel the active stage")
+            .expect("deletion executor task")
+            .expect("graceful deletion executor shutdown");
+        let request = services
+            .store
+            .get(request_id)
+            .await
+            .expect("load deletion request after shutdown");
+        assert_eq!(output.stage, DeletionStage::Approved);
+        assert_eq!(request.stage, DeletionStage::Approved);
+        assert_eq!(request.retry_count, retry_count);
+        assert!(request.last_error.is_none());
+        assert!(request.lease_owner.is_none());
+        assert!(request.lease_until.is_none());
+    }
+
+    #[tokio::test]
+    async fn stage_wait_treats_shutdown_as_control_flow() {
+        let shutdown = CancellationToken::new();
+        shutdown.cancel();
+        let heartbeat_lost = CancellationToken::new();
+        let outcome = await_stage(
+            std::future::pending::<Result<()>>(),
+            &shutdown,
+            &heartbeat_lost,
+        )
+        .await;
+        assert!(matches!(outcome, StageOutcome::Shutdown));
+    }
+
+    #[tokio::test]
+    async fn stage_wait_prioritizes_heartbeat_loss_over_a_ready_operation() {
+        let shutdown = CancellationToken::new();
+        let heartbeat_lost = CancellationToken::new();
+        heartbeat_lost.cancel();
+        let outcome = await_stage(async { Ok(()) }, &shutdown, &heartbeat_lost).await;
+        match outcome {
+            StageOutcome::Failed(error) => assert!(
+                error.downcast_ref::<DeletionLeaseLost>().is_some(),
+                "heartbeat loss must stay typed"
+            ),
+            StageOutcome::Completed | StageOutcome::Shutdown => {
+                panic!("preexisting heartbeat loss must win")
+            }
+        }
+    }
+}
diff --git a/crates/buzz-media/src/bucket_index.rs b/crates/buzz-media/src/bucket_index.rs
index bb83dc517fa..6c78c2e0a16 100644
--- a/crates/buzz-media/src/bucket_index.rs
+++ b/crates/buzz-media/src/bucket_index.rs
@@ -753,3 +753,258 @@ mod tests {
         );
     }
 }
+
+/// The exact community-scoped listing prefixes owned by one tenant, in
+/// ascending key order: media sidecars, upload records, and Git repository
+/// pointers. Every tenant-owned binding lives under one of these; shared
+/// immutable CAS/thumb/probe data is deliberately outside them (fleet-wide
+/// physical GC is a separate retention phase).
+pub fn tenant_prefixes(community: Uuid) -> [String; 3] {
+    [
+        format!("_meta/{community}/"),
+        format!("_uploads/{community}/"),
+        format!("repos/{community}/"),
+    ]
+}
+
+/// Whether one bucket key is a tenant-owned binding of `community` in the
+/// exact writer taxonomy: a media sidecar, an upload record, or a Git
+/// repository pointer. A malformed key under a tenant prefix is NOT owned —
+/// deletion fails closed on shapes this binary did not write.
+pub fn is_tenant_owned_key(community: Uuid, key: &str) -> bool {
+    match classify_key(key) {
+        KeyClass::Sidecar {
+            community: owner, ..
+        }
+        | KeyClass::Auxiliary {
+            community: owner, ..
+        } => owner == community,
+        KeyClass::Unknown => git_pointer_community(key) == Some(community),
+        KeyClass::Blob { .. } | KeyClass::Thumb { .. } => false,
+    }
+}
+
+/// Whether one bucket key belongs to the fleet's known writer taxonomy:
+/// blob/thumb/sidecar/upload shapes, any community's Git pointer, shared Git
+/// CAS data, or a `probe/` connectivity key.
+pub fn is_known_fleet_key(key: &str) -> bool {
+    !matches!(classify_key(key), KeyClass::Unknown)
+        || git_pointer_community(key).is_some()
+        || is_known_git_shared_key(key)
+        || key.starts_with("probe/")
+}
+
+/// Durable outcome of one fleet-wide taxonomy sweep.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct TaxonomySweepOutcome {
+    /// Total objects listed.
+    pub listed_objects: u64,
+    /// Exact count of keys outside the known writer taxonomy.
+    pub unknown_object_count: u64,
+    /// Bounded sample of unknown keys, in listing order.
+    pub unknown_key_sample: Vec<String>,
+}
+
+/// Fold an entire paginated bucket listing into the fleet taxonomy outcome.
+///
+/// Deleting a tenant while the bucket contains a writer shape this binary
+/// does not understand is unsafe — but that is a *fleet* invariant, not a
+/// per-request one. This sweep records it once; deletion stages then gate on
+/// a recent clean sweep instead of re-listing the whole bucket per request.
+/// Same pagination/cap contract as [`fold_bucket_listing`]; memory is
+/// bounded by `sample_limit`, never the listing size.
+pub async fn sweep_bucket_taxonomy<F, Fut>(
+    cap: u64,
+    sample_limit: usize,
+    mut fetch_page: F,
+) -> Result<TaxonomySweepOutcome, SweepError>
+where
+    F: FnMut(Option<String>) -> Fut,
+    Fut: Future<Output = Result<Page, MediaError>>,
+{
+    let mut outcome = TaxonomySweepOutcome::default();
+    let mut continuation_token = None;
+    loop {
+        let page = fetch_page(continuation_token.take()).await?;
+        outcome.listed_objects += page.objects.len() as u64;
+        if outcome.listed_objects > cap {
+            return Err(SweepError::CapExceeded {
+                seen: outcome.listed_objects,
+                cap,
+            });
+        }
+        for (key, _size) in page.objects {
+            if !is_known_fleet_key(&key) {
+                outcome.unknown_object_count += 1;
+                if outcome.unknown_key_sample.len() < sample_limit {
+                    outcome.unknown_key_sample.push(key);
+                }
+            }
+        }
+        if !page.is_truncated {
+            break;
+        }
+        match page.next_continuation_token {
+            Some(token) => continuation_token = Some(token),
+            None => return Err(SweepError::MalformedPage),
+        }
+    }
+    Ok(outcome)
+}
+
+fn git_pointer_community(key: &str) -> Option<Uuid> {
+    let mut parts = key.split('/');
+    if parts.next()? != "repos" {
+        return None;
+    }
+    let community = parse_canonical_uuid(parts.next()?)?;
+    let owner = parts.next()?;
+    let repo = parts.next()?;
+    let pointer = parts.next()?;
+    if parts.next().is_some()
+        || owner.len() != 64
+        || !owner.bytes().all(|byte| byte.is_ascii_hexdigit())
+        || repo.is_empty()
+        || repo.len() > 64
+        || repo.starts_with('.')
+        || repo.contains("..")
+        || !repo
+            .bytes()
+            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
+        || pointer != "pointer"
+    {
+        return None;
+    }
+    Some(community)
+}
+
+fn is_known_git_shared_key(key: &str) -> bool {
+    ["packs/", "idx/", "manifests/"].iter().any(|prefix| {
+        key.strip_prefix(prefix).is_some_and(|digest| {
+            digest.len() == 64 && digest.bytes().all(|byte| byte.is_ascii_hexdigit())
+        })
+    })
+}
+
+#[cfg(test)]
+mod deletion_taxonomy_tests {
+    use super::*;
+
+    #[test]
+    fn tenant_ownership_is_exact_per_community_and_shape() {
+        let target = Uuid::from_u128(1);
+        let other = Uuid::from_u128(2);
+        let sha = "a".repeat(64);
+
+        assert!(is_tenant_owned_key(
+            target,
+            &format!("_meta/{target}/{sha}.json")
+        ));
+        assert!(is_tenant_owned_key(
+            target,
+            &format!("_uploads/{target}/{sha}/01ARZ3NDEKTSV4RRFFQ69G5FAV.json")
+        ));
+        assert!(is_tenant_owned_key(
+            target,
+            &format!("repos/{target}/{}/repo/pointer", "b".repeat(64))
+        ));
+        // Another tenant's bindings and shared CAS are never owned.
+        assert!(!is_tenant_owned_key(
+            target,
+            &format!("_meta/{other}/{sha}.json")
+        ));
+        assert!(!is_tenant_owned_key(target, &format!("{sha}.png")));
+        // A malformed key under the tenant's own prefix fails closed.
+        assert!(!is_tenant_owned_key(
+            target,
+            &format!("_meta/{target}/not-a-sidecar")
+        ));
+        assert!(!is_tenant_owned_key(
+            target,
+            &format!("repos/{target}/stray-file")
+        ));
+    }
+
+    #[test]
+    fn tenant_prefixes_cover_every_owned_shape_and_sort_ascending() {
+        let community = Uuid::from_u128(7);
+        let prefixes = tenant_prefixes(community);
+        assert!(prefixes.windows(2).all(|pair| pair[0] < pair[1]));
+        let sha = "c".repeat(64);
+        for key in [
+            format!("_meta/{community}/{sha}.json"),
+            format!("_uploads/{community}/{sha}/01ARZ3NDEKTSV4RRFFQ69G5FAV.json"),
+            format!("repos/{community}/{}/repo/pointer", "d".repeat(64)),
+        ] {
+            assert!(
+                prefixes
+                    .iter()
+                    .any(|prefix| key.starts_with(prefix.as_str())),
+                "owned key {key} must live under a tenant prefix"
+            );
+            assert!(is_tenant_owned_key(community, &key));
+        }
+    }
+
+    #[tokio::test]
+    async fn taxonomy_sweep_counts_all_unknowns_but_bounds_the_sample() {
+        let community = Uuid::from_u128(1);
+        let sha = "a".repeat(64);
+        let known = vec![
+            (format!("{sha}.png"), 1),
+            (format!("{sha}.thumb.jpg"), 1),
+            (format!("_meta/{community}/{sha}.json"), 1),
+            (format!("packs/{sha}"), 1),
+            (
+                format!("repos/{community}/{}/repo/pointer", "b".repeat(64)),
+                1,
+            ),
+            ("probe/cas-123.txt".to_string(), 1),
+        ];
+        let pages = [
+            Page {
+                objects: known,
+                next_continuation_token: Some("next".to_string()),
+                is_truncated: true,
+            },
+            Page {
+                objects: vec![
+                    ("future-format/one".to_string(), 1),
+                    ("future-format/two".to_string(), 1),
+                    ("future-format/three".to_string(), 1),
+                ],
+                next_continuation_token: None,
+                is_truncated: false,
+            },
+        ];
+        let outcome = sweep_bucket_taxonomy(100, 2, |token| {
+            let page = match token.as_deref() {
+                None => pages[0].clone(),
+                Some("next") => pages[1].clone(),
+                other => panic!("unexpected continuation token {other:?}"),
+            };
+            async move { Ok(page) }
+        })
+        .await
+        .expect("sweep synthetic listing");
+        assert_eq!(outcome.listed_objects, 9);
+        assert_eq!(outcome.unknown_object_count, 3);
+        assert_eq!(
+            outcome.unknown_key_sample,
+            vec!["future-format/one", "future-format/two"]
+        );
+    }
+
+    #[tokio::test]
+    async fn taxonomy_sweep_fails_closed_past_the_fleet_cap() {
+        let result = sweep_bucket_taxonomy(1, 10, |_token| async {
+            Ok(Page {
+                objects: vec![("a".to_string(), 1), ("b".to_string(), 1)],
+                next_continuation_token: None,
+                is_truncated: false,
+            })
+        })
+        .await;
+        assert!(matches!(result, Err(SweepError::CapExceeded { .. })));
+    }
+}
diff --git a/crates/buzz-media/src/error.rs b/crates/buzz-media/src/error.rs
index c3d180402f1..14ce4afe1e8 100644
--- a/crates/buzz-media/src/error.rs
+++ b/crates/buzz-media/src/error.rs
@@ -54,6 +54,10 @@ pub enum MediaError {
     InsufficientScope,
     #[error("relay membership required")]
     RelayMembershipRequired,
+    #[error("community writes are fenced")]
+    CommunityWriteFenced,
+    #[error("media service temporarily unavailable")]
+    ServiceUnavailable,
     #[error("token revoked")]
     TokenRevoked,
     #[error("pubkey mismatch")]
@@ -138,7 +142,10 @@ impl IntoResponse for MediaError {
                 )
             }
             Self::InsufficientScope => (StatusCode::FORBIDDEN, self.to_string()),
-            Self::RelayMembershipRequired => (StatusCode::FORBIDDEN, self.to_string()),
+            Self::RelayMembershipRequired | Self::CommunityWriteFenced => {
+                (StatusCode::FORBIDDEN, self.to_string())
+            }
+            Self::ServiceUnavailable => (StatusCode::SERVICE_UNAVAILABLE, self.to_string()),
             Self::UploadRateLimitExceeded | Self::UploadConcurrencyLimitReached => {
                 (StatusCode::TOO_MANY_REQUESTS, self.to_string())
             }
@@ -164,6 +171,21 @@ impl IntoResponse for MediaError {
 mod tests {
     use super::*;
 
+    #[test]
+    fn serving_backend_failures_map_to_5xx_but_fences_remain_403() {
+        for error in [
+            MediaError::ServiceUnavailable,
+            MediaError::Internal,
+            MediaError::StorageError("backend".to_string()),
+        ] {
+            assert!(error.into_response().status().is_server_error());
+        }
+        assert_eq!(
+            MediaError::CommunityWriteFenced.into_response().status(),
+            StatusCode::FORBIDDEN
+        );
+    }
+
     #[test]
     fn unsupported_media_maps_to_415() {
         for error in [
diff --git a/crates/buzz-media/src/lib.rs b/crates/buzz-media/src/lib.rs
index 67896d4ef22..b2ff12c16e9 100644
--- a/crates/buzz-media/src/lib.rs
+++ b/crates/buzz-media/src/lib.rs
@@ -14,12 +14,13 @@ pub mod upload_record;
 pub mod validation;
 
 pub use bucket_index::{
-    classify_key, fold_bucket_listing, BucketAggregate, BucketSnapshot, CommunityStorage, KeyClass,
-    Page, SweepError,
+    classify_key, fold_bucket_listing, is_tenant_owned_key, sweep_bucket_taxonomy, tenant_prefixes,
+    BucketAggregate, BucketSnapshot, CommunityStorage, KeyClass, Page, SweepError,
+    TaxonomySweepOutcome,
 };
 pub use config::{MediaConfig, S3AddressingStyle};
 pub use error::MediaError;
-pub use storage::{BlobHeadMeta, BlobMeta, ByteStream, MediaStorage};
+pub use storage::{BlobHeadMeta, BlobMeta, BulkDeleteOutcome, ByteStream, MediaStorage};
 pub use types::BlobDescriptor;
 pub use upload::{process_file_upload, process_upload, process_video_upload};
 pub use upload_record::{
diff --git a/crates/buzz-media/src/storage.rs b/crates/buzz-media/src/storage.rs
index cbf980201fc..0f0aa7af623 100644
--- a/crates/buzz-media/src/storage.rs
+++ b/crates/buzz-media/src/storage.rs
@@ -177,6 +177,47 @@ impl MediaStorage {
         }
     }
 
+    /// Detect whether the bucket has ever had versioning enabled.
+    ///
+    /// rust-s3 exposes no GetBucketVersioning, so this writes and inspects a
+    /// short-lived fleet probe object instead: versioning-enabled (and
+    /// versioning-suspended) buckets stamp new writes with a version id.
+    /// Deletion refuses versioned buckets because bulk deletes without a
+    /// VersionId would only insert delete markers, not prove logical absence.
+    pub async fn bucket_versioning_detected(&self) -> Result<bool, MediaError> {
+        let key = format!("probe/deletion-versioning-{}", uuid::Uuid::new_v4());
+        self.put(&key, b"buzz deletion versioning probe", "text/plain")
+            .await?;
+        let inspected = self.bucket.head_object(&key).await;
+        let removed = self.bucket.delete_object(&key).await;
+        let (head, _) = inspected.map_err(|e| MediaError::StorageError(e.to_string()))?;
+        removed.map_err(|e| MediaError::StorageError(e.to_string()))?;
+        Ok(head.version_id.is_some())
+    }
+
+    /// Bulk-delete up to one manifest chunk of keys via S3 `DeleteObjects`.
+    ///
+    /// Never fails on per-key outcomes: they are folded into
+    /// [`BulkDeleteOutcome`] so the caller owns retry/fail-closed policy.
+    /// Historical MinIO releases report already-absent keys as
+    /// `NoSuchKey`/`NoSuchVersion` errors instead of deleted; both map to
+    /// `already_missing` to keep checkpointed retry idempotent.
+    pub async fn delete_objects(&self, keys: &[String]) -> Result<BulkDeleteOutcome, MediaError> {
+        if keys.is_empty() {
+            return Ok(BulkDeleteOutcome::default());
+        }
+        let identifiers = keys
+            .iter()
+            .map(|key| s3::serde_types::ObjectIdentifier::new(key.clone()))
+            .collect::<Vec<_>>();
+        let result = self
+            .bucket
+            .delete_objects(identifiers)
+            .await
+            .map_err(|e| MediaError::StorageError(e.to_string()))?;
+        Ok(fold_bulk_delete_result(result))
+    }
+
     /// Build the community-scoped sidecar key for a given sha256 (bare hash).
     ///
     /// Raw media bytes remain shared content-addressed CAS (`{sha}.{ext}`), but
@@ -234,6 +275,11 @@ impl MediaStorage {
             .map(|m| m.mime_type)
     }
 
+    /// Probe object-store connectivity and bucket access.
+    pub async fn ping(&self) -> Result<(), MediaError> {
+        self.list_page(None, 1).await.map(|_| ())
+    }
+
     /// One page of a full-bucket listing, for the storage sweep. Wraps
     /// rust-s3's manual `list_page` (NOT the auto-paginating `list`, which
     /// has no cap) and converts the result into the storage-agnostic
@@ -246,11 +292,28 @@ impl MediaStorage {
         &self,
         continuation_token: Option<String>,
         max_keys: usize,
+    ) -> Result<crate::bucket_index::Page, MediaError> {
+        self.list_prefix_page("", continuation_token, max_keys)
+            .await
+    }
+
+    /// One page of a prefix-scoped listing.
+    ///
+    /// Deletion enumerates the target community's exact key prefixes with
+    /// this instead of listing the whole fleet bucket: cost stays
+    /// O(tenant objects) regardless of fleet size. `ListObjectsV2` returns
+    /// keys in ascending UTF-8 binary order, which callers rely on for
+    /// streaming key-stream digests.
+    pub async fn list_prefix_page(
+        &self,
+        prefix: &str,
+        continuation_token: Option<String>,
+        max_keys: usize,
     ) -> Result<crate::bucket_index::Page, MediaError> {
         let (result, _status) = self
             .bucket
             .list_page(
-                String::new(),
+                prefix.to_string(),
                 None,
                 continuation_token,
                 None,
@@ -269,11 +332,93 @@ impl MediaStorage {
     }
 }
 
+/// Per-key outcomes of one bulk `DeleteObjects` call.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct BulkDeleteOutcome {
+    /// Keys the backend reported deleted (S3 reports already-missing keys as
+    /// deleted too — the API is idempotent by design).
+    pub deleted: u64,
+    /// Keys reported absent via legacy MinIO `NoSuchKey`/`NoSuchVersion`
+    /// per-key errors; equivalent to deleted for retry purposes.
+    pub already_missing: u64,
+    /// Keys whose deletion produced a version artifact (delete marker or
+    /// version id) — evidence of bucket versioning, which deletion must
+    /// fail closed on.
+    pub versioned_keys: Vec<String>,
+    /// Remaining per-key failures as `(key, code, message)`.
+    pub failed: Vec<(String, String, String)>,
+}
+
+fn fold_bulk_delete_result(result: s3::serde_types::DeleteObjectsResult) -> BulkDeleteOutcome {
+    let mut outcome = BulkDeleteOutcome::default();
+    for deleted in result.deleted {
+        if deleted.delete_marker == Some(true)
+            || deleted.delete_marker_version_id.is_some()
+            || deleted.version_id.is_some()
+        {
+            outcome.versioned_keys.push(deleted.key);
+        } else {
+            outcome.deleted += 1;
+        }
+    }
+    for error in result.errors {
+        if error.code == "NoSuchKey" || error.code == "NoSuchVersion" {
+            outcome.already_missing += 1;
+        } else {
+            outcome.failed.push((error.key, error.code, error.message));
+        }
+    }
+    outcome
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use std::collections::HashMap;
 
+    /// The bulk-delete fold is the retry-idempotence contract: legacy MinIO
+    /// absent-key errors count as success, version artifacts are surfaced for
+    /// fail-closed handling, and anything else stays a per-key failure.
+    #[test]
+    fn bulk_delete_fold_maps_absent_keys_and_version_artifacts() {
+        use s3::serde_types::{DeleteError, DeleteObjectsResult, DeletedObject};
+        let deleted_object = |key: &str, marker: bool| DeletedObject {
+            key: key.to_string(),
+            version_id: None,
+            delete_marker: marker.then_some(true),
+            delete_marker_version_id: marker.then(|| "v1".to_string()),
+        };
+        let delete_error = |key: &str, code: &str, message: &str| DeleteError {
+            key: key.to_string(),
+            code: code.to_string(),
+            message: message.to_string(),
+            version_id: None,
+        };
+        let result = DeleteObjectsResult {
+            deleted: vec![
+                deleted_object("plain", false),
+                deleted_object("marked", true),
+            ],
+            errors: vec![
+                delete_error("gone", "NoSuchKey", "absent"),
+                delete_error("gone-version", "NoSuchVersion", "absent"),
+                delete_error("denied", "AccessDenied", "nope"),
+            ],
+        };
+        let outcome = fold_bulk_delete_result(result);
+        assert_eq!(outcome.deleted, 1);
+        assert_eq!(outcome.already_missing, 2);
+        assert_eq!(outcome.versioned_keys, vec!["marked".to_string()]);
+        assert_eq!(
+            outcome.failed,
+            vec![(
+                "denied".to_string(),
+                "AccessDenied".to_string(),
+                "nope".to_string()
+            )]
+        );
+    }
+
     fn tenant(n: u128) -> TenantContext {
         TenantContext::resolved(
             CommunityId::from_uuid(uuid::Uuid::from_u128(n)),
@@ -351,6 +496,28 @@ mod tests {
         );
     }
 
+    #[test]
+    fn tenant_key_writers_are_covered_by_deletion_taxonomy() {
+        let ctx = tenant(1);
+        let community = *ctx.community().as_uuid();
+        let sha = "a".repeat(64);
+        let event_id = "01ARZ3NDEKTSV4RRFFQ69G5FAV";
+        let sidecar = MediaStorage::ctx_sidecar_key(&ctx, &sha);
+        let upload = crate::upload_record::upload_record_key(&ctx, &sha, event_id);
+        let prefixes = crate::bucket_index::tenant_prefixes(community);
+
+        for key in [sidecar, upload] {
+            assert!(
+                prefixes.iter().any(|prefix| key.starts_with(prefix)),
+                "tenant writer key {key} is outside deletion prefixes"
+            );
+            assert!(
+                crate::bucket_index::is_tenant_owned_key(community, &key),
+                "tenant writer key {key} is not recognized by deletion taxonomy"
+            );
+        }
+    }
+
     #[test]
     fn sidecar_keys_are_community_scoped() {
         let a = tenant(1);
diff --git a/crates/buzz-relay/Cargo.toml b/crates/buzz-relay/Cargo.toml
index 124457fe4e3..deb2e7e16a5 100644
--- a/crates/buzz-relay/Cargo.toml
+++ b/crates/buzz-relay/Cargo.toml
@@ -20,6 +20,7 @@ buzz-core = { workspace = true }
 buzz-conformance = { workspace = true }
 buzz-db = { workspace = true }
 buzz-datastore-tracing = { workspace = true }
+buzz-deletion = { workspace = true }
 buzz-auth = { workspace = true }
 buzz-pubsub = { workspace = true }
 buzz-audit = { workspace = true }
diff --git a/crates/buzz-relay/src/api/git/manifest.rs b/crates/buzz-relay/src/api/git/manifest.rs
index baf109c1ade..0dfbdb35a4d 100644
--- a/crates/buzz-relay/src/api/git/manifest.rs
+++ b/crates/buzz-relay/src/api/git/manifest.rs
@@ -474,6 +474,17 @@ mod tests {
         m.validate().expect("no parent is fine (first push)");
     }
 
+    #[test]
+    fn pointer_writer_is_covered_by_deletion_taxonomy() {
+        let community = CommunityId::from_uuid(uuid::Uuid::from_u128(1));
+        let owner = "a".repeat(64);
+        let key = pointer_key(community, &owner, "repo");
+        let prefixes = buzz_media::tenant_prefixes(*community.as_uuid());
+
+        assert!(prefixes.iter().any(|prefix| key.starts_with(prefix)));
+        assert!(buzz_media::is_tenant_owned_key(*community.as_uuid(), &key));
+    }
+
     #[test]
     fn pointer_key_strips_dot_git() {
         let c = CommunityId::from_uuid(uuid::Uuid::from_u128(1));
diff --git a/crates/buzz-relay/src/api/git/transport.rs b/crates/buzz-relay/src/api/git/transport.rs
index 53e3f59463c..3b2241046a3 100644
--- a/crates/buzz-relay/src/api/git/transport.rs
+++ b/crates/buzz-relay/src/api/git/transport.rs
@@ -1783,6 +1783,21 @@ pub(crate) struct PushContext {
     pub repo_handle: HydratedRepo,
 }
 
+#[derive(Default)]
+struct FinalizePushHooks {
+    #[cfg(test)]
+    post_cas_gate: Option<Arc<PostCasGate>>,
+    #[cfg(test)]
+    fail_ref_state_insert: bool,
+}
+
+#[cfg(test)]
+#[derive(Default)]
+struct PostCasGate {
+    reached: tokio::sync::Notify,
+    resume: tokio::sync::Notify,
+}
+
 /// Finalize a push request: CAS-commit the new state into the object
 /// store, derive kind:30618 from the committed manifest, and only then
 /// build the success response.
@@ -1793,6 +1808,17 @@ pub(crate) struct PushContext {
 /// constructor of a push 2xx, so the seam is structural (not by
 /// convention).
 async fn finalize_push(state: &Arc<AppState>, ctx: PushContext) -> Response {
+    finalize_push_inner(state, ctx, &FinalizePushHooks::default()).await
+}
+
+async fn finalize_push_inner(
+    state: &Arc<AppState>,
+    ctx: PushContext,
+    hooks: &FinalizePushHooks,
+) -> Response {
+    #[cfg(not(test))]
+    let _ = hooks;
+
     // The push fence, part 0 — **a rejected push publishes nothing.**
     //
     // `ctx.pack.ok` is false when git aborted the ref updates: either the
@@ -1823,10 +1849,41 @@ async fn finalize_push(state: &Arc<AppState>, ctx: PushContext) -> Response {
         return response;
     }
 
+    // An already-running receive-pack may cross the durable fence after
+    // request admission. Revalidate immediately before object-store CAS; DB
+    // trigger fencing alone cannot roll back an S3 pointer mutation.
+    let serving_write = match buzz_deletion::acquire_serving_write(
+        &state.db,
+        ctx.tenant.community(),
+        "git_publish",
+    )
+    .await
+    {
+        Ok(guard) => guard,
+        Err(error) => {
+            warn!(owner = %ctx.owner, repo = %ctx.repo, %error, "push rejected by community deletion fence");
+            return (
+                StatusCode::SERVICE_UNAVAILABLE,
+                "community writes are fenced",
+            )
+                .into_response();
+        }
+    };
+
+    if let Err(error) = serving_write.verify().await {
+        warn!(owner = %ctx.owner, repo = %ctx.repo, %error, "push lost community serving lease");
+        return (
+            StatusCode::SERVICE_UNAVAILABLE,
+            "community write lease lost",
+        )
+            .into_response();
+    }
+
     // Step 7 (CAS). The PushContext binds `parent_state` (observed at
     // hydrate) to the CAS predicate here — no re-reading of the pointer
-    // between hydrate and CAS.
-    let success = match cas_publish(
+    // between hydrate and CAS. Observe serving-lease loss throughout the
+    // potentially long upload/CAS operation, not only at its boundaries.
+    let publish = cas_publish(
         &state.git_store,
         &ctx.tenant,
         ctx.repo_handle.path(),
@@ -1838,72 +1895,87 @@ async fn finalize_push(state: &Arc<AppState>, ctx: PushContext) -> Response {
             max_pack_bytes: state.config.git_max_pack_bytes,
             max_repo_bytes: state.config.git_max_repo_bytes,
         },
-    )
-    .await
-    {
-        Ok(s) => s,
-        Err(CasError::Conflict {
-            winner_manifest_key,
-            ..
-        }) => {
-            warn!(
-                owner = %ctx.owner,
-                repo = %ctx.repo,
-                winner = %winner_manifest_key,
-                "push lost CAS race; tempdir dropped, returning 409"
-            );
-            return (
-                StatusCode::CONFLICT,
-                "push superseded by a concurrent writer; pull and retry",
-            )
-                .into_response();
-        }
-        Err(CasError::ManifestInvalid(e)) => {
-            // 4xx-class: the workspace produced refs/HEAD/oids the
-            // manifest validator rejects (unsafe refname, malformed oid,
-            // empty head, malformed parent). Pre-CAS — no pointer was
-            // written.
-            warn!(
-                owner = %ctx.owner,
-                repo = %ctx.repo,
-                error = %e,
-                "push rejected: manifest validation failed"
-            );
-            return (
-                StatusCode::BAD_REQUEST,
-                "push produced invalid manifest state",
-            )
-                .into_response();
-        }
-        Err(CasError::ResourceLimit(e)) => {
-            warn!(
-                owner = %ctx.owner,
-                repo = %ctx.repo,
-                error = %e,
-                "push rejected: repo exceeds relay resource limits"
-            );
+    );
+    let success = match serving_write.protect(publish).await {
+        Ok(result) => match result {
+            Ok(s) => s,
+            Err(CasError::Conflict {
+                winner_manifest_key,
+                ..
+            }) => {
+                warn!(
+                    owner = %ctx.owner,
+                    repo = %ctx.repo,
+                    winner = %winner_manifest_key,
+                    "push lost CAS race; tempdir dropped, returning 409"
+                );
+                return (
+                    StatusCode::CONFLICT,
+                    "push superseded by a concurrent writer; pull and retry",
+                )
+                    .into_response();
+            }
+            Err(CasError::ManifestInvalid(e)) => {
+                // 4xx-class: the workspace produced refs/HEAD/oids the
+                // manifest validator rejects (unsafe refname, malformed oid,
+                // empty head, malformed parent). Pre-CAS — no pointer was
+                // written.
+                warn!(
+                    owner = %ctx.owner,
+                    repo = %ctx.repo,
+                    error = %e,
+                    "push rejected: manifest validation failed"
+                );
+                return (
+                    StatusCode::BAD_REQUEST,
+                    "push produced invalid manifest state",
+                )
+                    .into_response();
+            }
+            Err(CasError::ResourceLimit(e)) => {
+                warn!(
+                    owner = %ctx.owner,
+                    repo = %ctx.repo,
+                    error = %e,
+                    "push rejected: repo exceeds relay resource limits"
+                );
+                return (
+                    StatusCode::PAYLOAD_TOO_LARGE,
+                    "repository exceeds relay resource limits",
+                )
+                    .into_response();
+            }
+            Err(e) => {
+                // 5xx-class: ManifestReadFailed (parent corruption),
+                // Backend, PackCapture. The tempdir drops on scope exit; no
+                // pointer was written (or, on rare ManifestReadFailed during
+                // winner-fetch, the winner is already installed and the
+                // loser's data is unrelated).
+                error!(
+                    owner = %ctx.owner,
+                    repo = %ctx.repo,
+                    error = %e,
+                    "push failed pre-response"
+                );
+                return (StatusCode::INTERNAL_SERVER_ERROR, "git backend error").into_response();
+            }
+        },
+        Err(error) => {
+            warn!(owner = %ctx.owner, repo = %ctx.repo, %error, "push lost community serving lease during CAS publish");
             return (
-                StatusCode::PAYLOAD_TOO_LARGE,
-                "repository exceeds relay resource limits",
+                StatusCode::SERVICE_UNAVAILABLE,
+                "community write lease lost",
             )
                 .into_response();
         }
-        Err(e) => {
-            // 5xx-class: ManifestReadFailed (parent corruption),
-            // Backend, PackCapture. The tempdir drops on scope exit; no
-            // pointer was written (or, on rare ManifestReadFailed during
-            // winner-fetch, the winner is already installed and the
-            // loser's data is unrelated).
-            error!(
-                owner = %ctx.owner,
-                repo = %ctx.repo,
-                error = %e,
-                "push failed pre-response"
-            );
-            return (StatusCode::INTERNAL_SERVER_ERROR, "git backend error").into_response();
-        }
     };
 
+    #[cfg(test)]
+    if let Some(gate) = &hooks.post_cas_gate {
+        gate.reached.notify_one();
+        gate.resume.notified().await;
+    }
+
     // Derived after CAS: kind:30618 ref-state event over the *committed*
     // manifest's refs/head. Spec §Implementation Correspondence:
     // "kind:30618 is derived after CAS, never the commit." We emit only
@@ -1927,7 +1999,7 @@ async fn finalize_push(state: &Arc<AppState>, ctx: PushContext) -> Response {
         (Some(before), Some(after)) => before != after,
         _ => true, // first push (parent None) or impossible-shape after key → publish
     };
-    if manifest_changed {
+    let publication_result: Result<(), String> = if manifest_changed {
         let inputs = RefStateInputs {
             repo_id: &ctx.repo_id,
             head: &success.manifest.head,
@@ -1938,11 +2010,23 @@ async fn finalize_push(state: &Arc<AppState>, ctx: PushContext) -> Response {
             Ok(event) => {
                 // Relay-signed kind:30618 belongs to the same server-resolved
                 // tenant as the git request that committed the pointer.
-                match state
+                #[cfg(test)]
+                let insert_result = if hooks.fail_ref_state_insert {
+                    Err(buzz_db::DbError::InvalidData(
+                        "injected kind:30618 insert failure".to_string(),
+                    ))
+                } else {
+                    state
+                        .db
+                        .insert_event_with_serving_write_guard(serving_write.lease(), &event, None)
+                        .await
+                };
+                #[cfg(not(test))]
+                let insert_result = state
                     .db
-                    .insert_event(ctx.tenant.community(), &event, None)
-                    .await
-                {
+                    .insert_event_with_serving_write_guard(serving_write.lease(), &event, None)
+                    .await;
+                match insert_result {
                     Ok((stored, true)) => {
                         // Routed through the guarded send path for uniformity;
                         // the access gate no-ops for this globally-scoped
@@ -1959,6 +2043,7 @@ async fn finalize_push(state: &Arc<AppState>, ctx: PushContext) -> Response {
                             manifest = %success.manifest_key,
                             "kind:30618 published (derived after CAS)"
                         );
+                        Ok(())
                     }
                     Ok((_, false)) => {
                         info!(
@@ -1966,26 +2051,41 @@ async fn finalize_push(state: &Arc<AppState>, ctx: PushContext) -> Response {
                             repo = %ctx.repo_id,
                             "kind:30618 deduplicated by relay db"
                         );
+                        Ok(())
                     }
-                    Err(e) => {
-                        warn!(
-                            owner = %ctx.owner,
-                            repo = %ctx.repo_id,
-                            error = %e,
-                            "kind:30618 insert failed; push remains durable in object store"
-                        );
-                    }
+                    Err(error) => Err(format!("kind:30618 insert failed: {error}")),
                 }
             }
-            Err(e) => {
-                warn!(
-                    owner = %ctx.owner,
-                    repo = %ctx.repo_id,
-                    error = %e,
-                    "kind:30618 build failed; push remains durable in object store"
-                );
-            }
+            Err(error) => Err(format!("kind:30618 build failed: {error}")),
         }
+    } else {
+        Ok(())
+    };
+
+    // The admitted serving write spans the complete publication attempt. Fence
+    // acquisition cannot overtake the pointer CAS, durable 30618 insert, or
+    // local fan-out attempt; only now may the lease be released.
+    if let Err(error) = serving_write.finish().await {
+        warn!(owner = %ctx.owner, repo = %ctx.repo, %error, "failed to release community serving lease after push publication");
+        return (
+            StatusCode::SERVICE_UNAVAILABLE,
+            "community write lease lost during publication",
+        )
+            .into_response();
+    }
+    if let Err(error) = publication_result {
+        error!(
+            owner = %ctx.owner,
+            repo = %ctx.repo_id,
+            manifest = %success.manifest_key,
+            %error,
+            "push pointer committed but kind:30618 publication failed"
+        );
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "push committed but ref-state publication failed; retry",
+        )
+            .into_response();
     }
 
     // Only now — after CAS commit and (optional) 30618 emission — build
@@ -2014,12 +2114,14 @@ pub fn git_router(state: Arc<AppState>) -> Router {
 #[cfg(test)]
 mod track_c_tests {
     use super::*;
+    use crate::api::git::hydrate::{hydrate_for_write, HydrationOptions};
     use crate::api::git::manifest::Manifest;
     use buzz_core::CommunityId;
     use nostr::{EventBuilder, Keys, Kind, Tag};
     use std::collections::BTreeMap;
     use std::io::Write;
     use std::process::Output;
+    use tempfile::TempDir;
 
     fn oid_sha1() -> String {
         "cb09a769da1c01f458fa6959d4e8eded38fac8d3".to_string()
@@ -2160,6 +2262,303 @@ mod track_c_tests {
         assert!(remote.join("refs/heads/master").exists());
     }
 
+    async fn run_finalize_git(repo: &Path, args: &[&str]) -> std::process::Output {
+        let mut command = Command::new("git");
+        command.current_dir(repo).args(args);
+        harden_git_env(&mut command);
+        let output = command.output().await.expect("spawn git");
+        assert!(
+            output.status.success(),
+            "git {args:?}: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        output
+    }
+
+    async fn finalize_test_state() -> (Arc<AppState>, sqlx::PgPool) {
+        const TEST_DB_URL: &str = "postgres://buzz:buzz_dev@localhost:5432/buzz"; // sadscan:disable np.postgres.1
+        let mut config = crate::config::Config::from_env().expect("default config loads");
+        config.require_relay_membership = false;
+        config.redis_url = "redis://127.0.0.1:1".to_string();
+        config.database_url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .unwrap_or_else(|_| TEST_DB_URL.to_string());
+        let pool = sqlx::PgPool::connect(&config.database_url)
+            .await
+            .expect("connect test DB");
+        let db = buzz_db::Db::from_pool(pool.clone());
+        db.migrate().await.expect("migrate test DB");
+        let redis_pool = deadpool_redis::Config::from_url(&config.redis_url)
+            .create_pool(Some(deadpool_redis::Runtime::Tokio1))
+            .expect("redis pool");
+        let pubsub = Arc::new(
+            buzz_pubsub::PubSubManager::new(&config.redis_url, redis_pool.clone())
+                .await
+                .expect("pubsub manager"),
+        );
+        let audit = buzz_audit::AuditService::new(pool.clone());
+        let auth = buzz_auth::AuthService::new(config.auth.clone());
+        let search = buzz_search::SearchService::new(pool.clone());
+        let workflow_engine = Arc::new(buzz_workflow::WorkflowEngine::new(
+            db.clone(),
+            buzz_workflow::WorkflowConfig::default(),
+        ));
+        let media_storage = buzz_media::MediaStorage::new(&config.media).expect("media storage");
+        let (state, _audit_shutdown) = AppState::new(
+            config,
+            db,
+            redis_pool,
+            audit,
+            pubsub,
+            auth,
+            search,
+            workflow_engine,
+            Keys::generate(),
+            media_storage,
+        );
+        (Arc::new(state), pool)
+    }
+
+    async fn approved_deletion(
+        state: &AppState,
+        host: &str,
+    ) -> (
+        buzz_db::deletion::DeletionRequest,
+        buzz_db::deletion::ClaimedDeletion,
+    ) {
+        use buzz_db::deletion::{
+            FrozenInventory, KeyStreamDigest, PrefixManifest, StorageManifest,
+            DEFAULT_LEASE_DURATION,
+        };
+
+        let store = state.db.deletion_store();
+        let request = store
+            .submit(host, "git-finalize-test", Some("post-CAS lease regression"))
+            .await
+            .expect("submit deletion");
+        let inventory = FrozenInventory {
+            schema: store
+                .inventory_schema(request.community_id)
+                .await
+                .expect("schema inventory"),
+            storage: StorageManifest {
+                version: 4,
+                prefixes: buzz_media::tenant_prefixes(*request.community_id.as_uuid())
+                    .into_iter()
+                    .map(|prefix| PrefixManifest {
+                        prefix,
+                        object_count: 0,
+                        total_bytes: 0,
+                        keys_digest: KeyStreamDigest::new().finish().0,
+                    })
+                    .collect(),
+            },
+        };
+        store
+            .freeze_inventory(request.id, &inventory)
+            .await
+            .expect("freeze inventory");
+        store
+            .approve(request.id, "git-finalize-test", None)
+            .await
+            .expect("approve deletion");
+        let claim = store
+            .claim_specific(request.id, "git-finalize-test", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim deletion")
+            .expect("won deletion claim");
+        (request, claim)
+    }
+
+    async fn pushed_context(
+        state: &AppState,
+        community: CommunityId,
+        host: &str,
+        owner: String,
+        repo: String,
+        pusher: nostr::PublicKey,
+        scratch: &Path,
+    ) -> PushContext {
+        let tenant = TenantContext::resolved(community, host);
+        let (hydrated, parent_state) = hydrate_for_write(
+            &state.git_store,
+            &tenant,
+            &owner,
+            &repo,
+            HydrationOptions {
+                pack_cache: &state.git_pack_cache,
+                scratch_dir: scratch,
+                max_pack_bytes: 1024 * 1024,
+                max_repo_bytes: 2 * 1024 * 1024,
+            },
+        )
+        .await
+        .expect("hydrate empty test repo");
+        let source = scratch.join("source");
+        tokio::fs::create_dir(&source)
+            .await
+            .expect("source directory");
+        run_finalize_git(&source, &["init", "--quiet", "--initial-branch=main"]).await;
+        run_finalize_git(&source, &["config", "user.email", "finalize@test"]).await;
+        run_finalize_git(&source, &["config", "user.name", "finalize"]).await;
+        tokio::fs::write(source.join("file.txt"), b"committed\n")
+            .await
+            .expect("write source file");
+        run_finalize_git(&source, &["add", "file.txt"]).await;
+        run_finalize_git(&source, &["commit", "--quiet", "-m", "committed"]).await;
+        let remote = hydrated.path().to_str().expect("hydrated path utf8");
+        run_finalize_git(&source, &["push", "--quiet", remote, "main"]).await;
+
+        PushContext {
+            pack: PackOutput {
+                stdout: b"push-ok".to_vec(),
+                ok: true,
+            },
+            parent_state,
+            owner,
+            repo: repo.clone(),
+            repo_id: repo,
+            pusher,
+            tenant,
+            repo_handle: hydrated,
+        }
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres and MinIO"]
+    async fn finalize_push_holds_serving_lease_through_post_cas_publication() {
+        let (state, pool) = finalize_test_state().await;
+        let host = format!("git-finalize-{}.example", uuid::Uuid::new_v4().simple());
+        let community = state
+            .db
+            .ensure_configured_community(&host)
+            .await
+            .expect("create test community")
+            .id;
+        let (request, claim) = approved_deletion(&state, &host).await;
+        let scratch = TempDir::new().expect("scratch");
+        let owner = format!("owner-{}", uuid::Uuid::new_v4().simple());
+        let repo = format!("repo-{}", uuid::Uuid::new_v4().simple());
+        let ctx = pushed_context(
+            &state,
+            community,
+            &host,
+            owner,
+            repo.clone(),
+            Keys::generate().public_key(),
+            scratch.path(),
+        )
+        .await;
+        let gate = Arc::new(PostCasGate::default());
+        let hooks = FinalizePushHooks {
+            post_cas_gate: Some(Arc::clone(&gate)),
+            fail_ref_state_insert: false,
+        };
+        let finalize_state = Arc::clone(&state);
+        let finalize =
+            tokio::spawn(async move { finalize_push_inner(&finalize_state, ctx, &hooks).await });
+
+        gate.reached.notified().await;
+        state
+            .db
+            .deletion_store()
+            .begin_quiescing(&claim.lease)
+            .await
+            .expect("quiesce after CAS");
+        let error = state
+            .db
+            .deletion_store()
+            .fence(&claim.lease)
+            .await
+            .expect_err("post-CAS serving lease must block fence");
+        assert!(matches!(
+            error,
+            buzz_db::DbError::ServingWritesNotDrained { .. }
+        ));
+        assert!(!state
+            .db
+            .deletion_store()
+            .is_serving_active(community)
+            .await
+            .expect("quiescing rejects new serving work"));
+
+        gate.resume.notify_one();
+        let response = finalize.await.expect("finalize task");
+        assert_eq!(response.status(), StatusCode::OK);
+        let mut query = buzz_db::event::EventQuery::for_community(community);
+        query.kinds = Some(vec![30_618]);
+        query.d_tag = Some(repo);
+        let events = state.db.query_events(&query).await.expect("query 30618");
+        assert_eq!(events.len(), 1, "kind:30618 must be durable before release");
+        assert!(state
+            .db
+            .deletion_store()
+            .serving_writes_drained(community)
+            .await
+            .expect("serving lease released"));
+        let generation = state
+            .db
+            .deletion_store()
+            .fence(&claim.lease)
+            .await
+            .expect("fence after publication");
+        assert_eq!(generation, 1);
+        assert_eq!(
+            state
+                .db
+                .deletion_store()
+                .get(request.id)
+                .await
+                .expect("fenced request")
+                .stage,
+            buzz_db::deletion::DeletionStage::Fenced
+        );
+        drop(state);
+        pool.close().await;
+    }
+
+    #[tokio::test]
+    #[ignore = "requires Postgres and MinIO"]
+    async fn finalize_push_db_failure_after_cas_is_not_success_and_releases_lease() {
+        let (state, pool) = finalize_test_state().await;
+        let host = format!(
+            "git-finalize-fail-{}.example",
+            uuid::Uuid::new_v4().simple()
+        );
+        let community = state
+            .db
+            .ensure_configured_community(&host)
+            .await
+            .expect("create test community")
+            .id;
+        let scratch = TempDir::new().expect("scratch");
+        let ctx = pushed_context(
+            &state,
+            community,
+            &host,
+            format!("owner-{}", uuid::Uuid::new_v4().simple()),
+            format!("repo-{}", uuid::Uuid::new_v4().simple()),
+            Keys::generate().public_key(),
+            scratch.path(),
+        )
+        .await;
+        let hooks = FinalizePushHooks {
+            post_cas_gate: None,
+            fail_ref_state_insert: true,
+        };
+
+        let response = finalize_push_inner(&state, ctx, &hooks).await;
+        assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+        assert!(state
+            .db
+            .deletion_store()
+            .serving_writes_drained(community)
+            .await
+            .expect("serving lease released on failure"));
+        drop(state);
+        pool.close().await;
+    }
+
     /// A gzip-encoded request body is transparently inflated before it
     /// reaches the git subprocess. Git's smart-HTTP client gzips the
     /// upload-pack/receive-pack request body past a size threshold (fires
diff --git a/crates/buzz-relay/src/api/invites.rs b/crates/buzz-relay/src/api/invites.rs
index 6104171ccad..d09c7fc6119 100644
--- a/crates/buzz-relay/src/api/invites.rs
+++ b/crates/buzz-relay/src/api/invites.rs
@@ -260,6 +260,19 @@ async fn authenticate(
     Ok((tenant, pubkey))
 }
 
+fn map_mint_error(error: buzz_db::DbError) -> (StatusCode, Json<Value>) {
+    match error {
+        buzz_db::DbError::InvalidData(message) | buzz_db::DbError::DeletionSafety(message) => {
+            api_error(StatusCode::BAD_REQUEST, &message)
+        }
+        buzz_db::DbError::AccessDenied(_) => api_error(
+            StatusCode::SERVICE_UNAVAILABLE,
+            "community writes are temporarily unavailable",
+        ),
+        error => internal_error(&format!("invite mint: {error}")),
+    }
+}
+
 /// Mint an invite code — `POST /api/invites`, NIP-98 signed by an owner/admin.
 ///
 /// Returns the code, its expiry, and a shareable landing-page URL on the
@@ -304,10 +317,7 @@ pub async fn mint_invite(
         .db
         .mint_relay_invite(tenant.community(), &sender_hex, ttl, max_uses)
         .await
-        .map_err(|error| match error {
-            buzz_db::DbError::InvalidData(message) => api_error(StatusCode::BAD_REQUEST, &message),
-            error => internal_error(&format!("invite mint: {error}")),
-        })?;
+        .map_err(map_mint_error)?;
 
     // Same TLS-posture logic as nip98_expected_url: wss deployments get an
     // https landing page URL, ws dev/test deployments get http.
@@ -895,6 +905,19 @@ mod tests {
         }
     }
 
+    #[test]
+    fn mint_fence_errors_map_to_temporary_unavailability() {
+        let (status, body) = super::map_mint_error(buzz_db::DbError::AccessDenied(
+            "community is write-fenced".to_string(),
+        ));
+
+        assert_eq!(status, StatusCode::SERVICE_UNAVAILABLE);
+        assert_eq!(
+            body.0.get("error").and_then(Value::as_str),
+            Some("community writes are temporarily unavailable")
+        );
+    }
+
     #[tokio::test]
     #[ignore = "requires Postgres"]
     async fn malformed_and_unknown_v2_codes_are_forbidden_without_v1_fallback() {
diff --git a/crates/buzz-relay/src/api/media.rs b/crates/buzz-relay/src/api/media.rs
index a2f3640bde5..3b6e07bad66 100644
--- a/crates/buzz-relay/src/api/media.rs
+++ b/crates/buzz-relay/src/api/media.rs
@@ -283,6 +283,19 @@ async fn upload_attribution(
     })
 }
 
+fn serving_write_error(error: anyhow::Error) -> MediaError {
+    if buzz_deletion::ServingWriteGuard::acquisition_is_fenced(&error) {
+        MediaError::CommunityWriteFenced
+    } else {
+        MediaError::ServiceUnavailable
+    }
+}
+
+fn serving_lease_lost(error: anyhow::Error) -> MediaError {
+    tracing::warn!(%error, "media serving-write lease lost");
+    MediaError::ServiceUnavailable
+}
+
 /// PUT `/upload` or the temporary media-only `/media/upload` alias.
 ///
 /// Auth is validated via the [`AuthenticatedUpload`] extractor BEFORE the body
@@ -310,6 +323,11 @@ pub async fn upload_blob(
 ) -> Result<Json<BlobDescriptor>, MediaError> {
     let attribution = upload_attribution(&state, &auth, &headers).await;
 
+    let serving_write =
+        buzz_deletion::acquire_serving_write(&state.db, auth.tenant.community(), "media_upload")
+            .await
+            .map_err(serving_write_error)?;
+
     if auth.route_mode == UploadRouteMode::LegacyMedia {
         metrics::counter!("buzz_media_legacy_upload_route_total").increment(1);
     }
@@ -335,69 +353,86 @@ pub async fn upload_blob(
     }
     let replay = futures_util::stream::iter(replay_chunks.into_iter().map(Ok)).chain(source);
 
-    let mut descriptor = if should_stream_as_video(&sniff) {
-        // Video path: stream body directly to disk — never fully buffered in RAM.
-        let content_length = headers
-            .get("content-length")
-            .and_then(|v| v.to_str().ok())
-            .and_then(|v| v.parse::<u64>().ok());
-        buzz_media::process_video_upload(
-            &state.media_storage,
-            &state.config.media,
-            &auth.tenant,
-            &auth.auth_event,
-            replay,
-            content_length,
-            attribution,
-        )
-        .await?
-    } else {
-        // Non-video path: buffer the body (bounded by the larger of the image
-        // and generic-file caps), then decide image-vs-generic by sniffed MIME.
-        // Images go through the thumbnailing pipeline; non-media attachments
-        // (docs, archives, text, data) take the generic file path and are
-        // served as downloads. Recognized audio/video cannot fall through it.
-        let max = state
-            .config
-            .media
-            .max_image_bytes
-            .max(state.config.media.max_file_bytes);
-        let bytes = axum::body::to_bytes(axum::body::Body::from_stream(replay), max as usize)
-            .await
-            .map_err(|_| MediaError::FileTooLarge { size: 0, max })?;
-
-        let is_image = matches!(
-            infer::get(&bytes).map(|t| t.mime_type()),
-            Some("image/jpeg" | "image/png" | "image/gif" | "image/webp")
-        );
-
-        if is_image {
-            buzz_media::process_upload(
-                &state.media_storage,
-                &state.config.media,
-                &auth.tenant,
-                &auth.auth_event,
-                bytes,
-                attribution,
-            )
-            .await?
-        } else if auth.route_mode == UploadRouteMode::LegacyMedia {
-            let mime = infer::get(&bytes)
-                .map(|kind| kind.mime_type().to_string())
-                .unwrap_or_else(|| "application/octet-stream".to_string());
-            return Err(MediaError::DisallowedContentType(mime));
-        } else {
-            buzz_media::process_file_upload(
-                &state.media_storage,
-                &state.config.media,
-                &auth.tenant,
-                &auth.auth_event,
-                bytes,
-                attribution,
-            )
-            .await?
-        }
-    };
+    serving_write.verify().await.map_err(serving_lease_lost)?;
+
+    let mut descriptor = serving_write
+        .protect(async {
+            Ok(if should_stream_as_video(&sniff) {
+                // Video path: stream body directly to disk — never fully buffered in RAM.
+                let content_length = headers
+                    .get("content-length")
+                    .and_then(|v| v.to_str().ok())
+                    .and_then(|v| v.parse::<u64>().ok());
+                buzz_media::process_video_upload(
+                    &state.media_storage,
+                    &state.config.media,
+                    &auth.tenant,
+                    &auth.auth_event,
+                    replay,
+                    content_length,
+                    attribution,
+                )
+                .await?
+            } else {
+                // Non-video path: buffer the body (bounded by the larger of the image
+                // and generic-file caps), then decide image-vs-generic by sniffed MIME.
+                // Images go through the thumbnailing pipeline; non-media attachments
+                // (docs, archives, text, data) take the generic file path and are
+                // served as downloads. Recognized audio/video cannot fall through it.
+                let max = state
+                    .config
+                    .media
+                    .max_image_bytes
+                    .max(state.config.media.max_file_bytes);
+                let bytes =
+                    axum::body::to_bytes(axum::body::Body::from_stream(replay), max as usize)
+                        .await
+                        .map_err(|_| MediaError::FileTooLarge { size: 0, max })?;
+
+                let is_image = matches!(
+                    infer::get(&bytes).map(|t| t.mime_type()),
+                    Some("image/jpeg" | "image/png" | "image/gif" | "image/webp")
+                );
+
+                if is_image {
+                    buzz_media::process_upload(
+                        &state.media_storage,
+                        &state.config.media,
+                        &auth.tenant,
+                        &auth.auth_event,
+                        bytes,
+                        attribution,
+                    )
+                    .await?
+                } else if auth.route_mode == UploadRouteMode::LegacyMedia {
+                    let mime = infer::get(&bytes)
+                        .map(|kind| kind.mime_type().to_string())
+                        .unwrap_or_else(|| "application/octet-stream".to_string());
+                    return Err(MediaError::DisallowedContentType(mime));
+                } else {
+                    buzz_media::process_file_upload(
+                        &state.media_storage,
+                        &state.config.media,
+                        &auth.tenant,
+                        &auth.auth_event,
+                        bytes,
+                        attribution,
+                    )
+                    .await?
+                }
+            })
+        })
+        .await
+        .map_err(|error| {
+            if buzz_deletion::ServingWriteGuard::is_lease_lost(&error) {
+                serving_lease_lost(error)
+            } else {
+                match error.downcast::<MediaError>() {
+                    Ok(error) => error,
+                    Err(_) => MediaError::Internal,
+                }
+            }
+        })??;
 
     rewrite_descriptor_urls_for_tenant(
         &mut descriptor,
@@ -441,6 +476,7 @@ pub async fn upload_blob(
         }
     }
 
+    serving_write.finish().await.map_err(serving_lease_lost)?;
     Ok(Json(descriptor))
 }
 
@@ -913,6 +949,20 @@ mod tests {
 
     const VALID_HASH: &str = "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789";
 
+    #[test]
+    fn serving_write_error_taxonomy_separates_fence_from_backend_failure() {
+        let fenced = anyhow::Error::from(buzz_db::DbError::AccessDenied("fenced".to_string()));
+        assert!(matches!(
+            serving_write_error(fenced),
+            MediaError::CommunityWriteFenced
+        ));
+        let backend = anyhow::Error::from(buzz_db::DbError::Sqlx(sqlx::Error::PoolTimedOut));
+        assert!(matches!(
+            serving_write_error(backend),
+            MediaError::ServiceUnavailable
+        ));
+    }
+
     #[test]
     fn upload_routes_distinguish_standard_and_legacy_modes() {
         assert_eq!(
diff --git a/crates/buzz-relay/src/audio/handler.rs b/crates/buzz-relay/src/audio/handler.rs
index 16cd56209c7..4c158eab0c4 100644
--- a/crates/buzz-relay/src/audio/handler.rs
+++ b/crates/buzz-relay/src/audio/handler.rs
@@ -25,7 +25,7 @@ use bytes::Bytes;
 use futures_util::{SinkExt, StreamExt};
 use nostr::{EventBuilder, Kind, Tag};
 use serde::Deserialize;
-use tokio::sync::{mpsc, OwnedSemaphorePermit, Semaphore};
+use tokio::sync::{mpsc, watch, OwnedSemaphorePermit, Semaphore};
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, error, info, warn};
 use uuid::Uuid;
@@ -38,7 +38,7 @@ use buzz_core::StoredEvent;
 use buzz_pubsub::EventTopic;
 
 use crate::audio::room::PeerCtrl;
-use crate::state::{run_registered_community_connection, AppState};
+use crate::state::{run_registered_community_connection, AppState, CommunityConnectionControl};
 
 /// Maximum binary frame size: 4 KB is generous for a single Opus packet.
 const MAX_AUDIO_FRAME_BYTES: usize = 4096;
@@ -149,6 +149,7 @@ async fn handle_audio_connection(
     _permit: OwnedSemaphorePermit,
 ) {
     let cancel = CancellationToken::new();
+    let control = CommunityConnectionControl::new(cancel);
     let community_id = tenant.community();
     let registry = Arc::clone(&state.community_connections);
     let check_state = Arc::clone(&state);
@@ -157,9 +158,11 @@ async fn handle_audio_connection(
         &registry,
         Uuid::new_v4(),
         community_id,
-        cancel.clone(),
+        control,
         move || async move { check_state.db.is_community_active(community_id).await },
-        move || handle_active_audio_connection(socket, run_state, tenant, channel_id, cancel),
+        move |control| {
+            handle_active_audio_connection(socket, run_state, tenant, channel_id, control)
+        },
     )
     .await;
 }
@@ -169,8 +172,10 @@ async fn handle_active_audio_connection(
     state: Arc<AppState>,
     tenant: TenantContext,
     channel_id: Uuid,
-    cancel: CancellationToken,
+    control: CommunityConnectionControl,
 ) {
+    let cancel = control.cancellation_token();
+    let disconnect_reason = control.disconnect_reason();
     let (mut ws_send, mut ws_recv) = socket.split();
 
     let challenge = generate_challenge();
@@ -660,7 +665,13 @@ async fn handle_active_audio_connection(
     let (ctrl_tx, ctrl_rx) = mpsc::channel::<WsMessage>(8);
 
     let send_cancel = cancel.child_token();
-    let send_task = tokio::spawn(send_loop(ws_send, data_rx, ctrl_rx, send_cancel));
+    let send_task = tokio::spawn(send_loop(
+        ws_send,
+        data_rx,
+        ctrl_rx,
+        send_cancel,
+        disconnect_reason,
+    ));
 
     let hb_cancel = cancel.clone();
     let hb_missed = Arc::clone(&missed_pongs);
@@ -1056,12 +1067,15 @@ async fn recv_loop(
 ///
 /// Control frames (Ping, Pong, Close, control JSON) are drained first on every
 /// iteration, so heartbeat pings are never starved by audio backpressure.
-async fn send_loop(
-    mut ws_send: futures_util::stream::SplitSink<WebSocket, WsMessage>,
+async fn send_loop<S>(
+    mut ws_send: S,
     mut data_rx: mpsc::Receiver<WsMessage>,
     mut ctrl_rx: mpsc::Receiver<WsMessage>,
     cancel: CancellationToken,
-) {
+    disconnect_reason: watch::Receiver<Option<crate::state::CommunityDisconnectReason>>,
+) where
+    S: futures_util::Sink<WsMessage> + Unpin,
+{
     loop {
         // Priority: drain all pending control frames before data.
         while let Ok(ctrl_msg) = ctrl_rx.try_recv() {
@@ -1073,7 +1087,10 @@ async fn send_loop(
         tokio::select! {
             biased;
             _ = cancel.cancelled() => {
-                let _ = ws_send.send(WsMessage::Close(None)).await;
+                let close = disconnect_reason
+                    .borrow()
+                    .map_or(WsMessage::Close(None), |reason| reason.close_message());
+                let _ = ws_send.send(close).await;
                 break;
             }
             Some(ctrl_msg) = ctrl_rx.recv() => {
@@ -1416,6 +1433,74 @@ mod tests {
         received
     }
 
+    #[tokio::test]
+    async fn audio_send_loop_sends_policy_close_when_community_is_deleted() {
+        use futures_util::Sink;
+
+        struct MockSink {
+            messages: Arc<Mutex<Vec<WsMessage>>>,
+        }
+
+        impl Sink<WsMessage> for MockSink {
+            type Error = std::io::Error;
+
+            fn poll_ready(
+                self: std::pin::Pin<&mut Self>,
+                _cx: &mut std::task::Context<'_>,
+            ) -> std::task::Poll<Result<(), Self::Error>> {
+                std::task::Poll::Ready(Ok(()))
+            }
+
+            fn start_send(
+                self: std::pin::Pin<&mut Self>,
+                item: WsMessage,
+            ) -> Result<(), Self::Error> {
+                self.messages.lock().expect("mock sink poisoned").push(item);
+                Ok(())
+            }
+
+            fn poll_flush(
+                self: std::pin::Pin<&mut Self>,
+                _cx: &mut std::task::Context<'_>,
+            ) -> std::task::Poll<Result<(), Self::Error>> {
+                std::task::Poll::Ready(Ok(()))
+            }
+
+            fn poll_close(
+                self: std::pin::Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> std::task::Poll<Result<(), Self::Error>> {
+                self.poll_flush(cx)
+            }
+        }
+
+        let (_data_tx, data_rx) = mpsc::channel(1);
+        let (_ctrl_tx, ctrl_rx) = mpsc::channel(1);
+        let cancel = CancellationToken::new();
+        let control = CommunityConnectionControl::new(cancel.clone());
+        let disconnect_reason = control.disconnect_reason();
+        let registry = crate::state::CommunityConnectionRegistry::new();
+        let community = buzz_core::CommunityId::from_uuid(Uuid::new_v4());
+        let _guard = registry.register(Uuid::new_v4(), community, control);
+        assert_eq!(registry.disconnect_community(community), 1);
+        let messages = Arc::new(Mutex::new(Vec::new()));
+        let sink = MockSink {
+            messages: Arc::clone(&messages),
+        };
+
+        send_loop(sink, data_rx, ctrl_rx, cancel, disconnect_reason).await;
+
+        let messages = messages.lock().expect("mock sink poisoned");
+        assert_eq!(messages.len(), 1);
+        match &messages[0] {
+            WsMessage::Close(Some(close)) => {
+                assert_eq!(close.code, axum::extract::ws::close_code::POLICY);
+                assert_eq!(close.reason.as_str(), "community deleted");
+            }
+            other => panic!("expected one 1008 deletion close, got {other:?}"),
+        }
+    }
+
     #[tokio::test]
     async fn audio_websocket_parser_rejects_oversized_messages_before_handler_reads_them() {
         assert!(
diff --git a/crates/buzz-relay/src/connection.rs b/crates/buzz-relay/src/connection.rs
index 72a7eb91269..c37421e7e80 100644
--- a/crates/buzz-relay/src/connection.rs
+++ b/crates/buzz-relay/src/connection.rs
@@ -8,7 +8,7 @@ use std::time::Duration;
 
 use axum::extract::ws::{Message as WsMessage, WebSocket};
 use futures_util::{Sink, SinkExt, StreamExt};
-use tokio::sync::{mpsc, Mutex, RwLock};
+use tokio::sync::{mpsc, watch, Mutex, RwLock};
 use tokio_util::sync::CancellationToken;
 use tracing::Instrument as _;
 use tracing::{debug, info, trace, warn};
@@ -20,7 +20,10 @@ use nostr::Filter;
 
 use crate::handlers;
 use crate::protocol::{ClientMessage, RelayMessage};
-use crate::state::{run_registered_community_connection, AppState};
+use crate::state::{
+    run_registered_community_connection, AppState, CommunityConnectionControl,
+    CommunityDisconnectReason,
+};
 use buzz_pubsub::EventTopic;
 
 /// Maximum time a new socket may hold a connection slot without completing NIP-42 auth.
@@ -128,6 +131,7 @@ pub async fn handle_connection(
 ) {
     let conn_id = Uuid::new_v4();
     let cancel = CancellationToken::new();
+    let control = CommunityConnectionControl::new(cancel);
     let community_id = tenant.community();
     let registry = Arc::clone(&state.community_connections);
     let check_state = Arc::clone(&state);
@@ -136,9 +140,9 @@ pub async fn handle_connection(
         &registry,
         conn_id,
         community_id,
-        cancel.clone(),
+        control,
         move || async move { check_state.db.is_community_active(community_id).await },
-        move || handle_active_connection(socket, run_state, addr, tenant, conn_id, cancel),
+        move |control| handle_active_connection(socket, run_state, addr, tenant, conn_id, control),
     )
     .await;
 }
@@ -149,8 +153,10 @@ async fn handle_active_connection(
     addr: SocketAddr,
     tenant: TenantContext,
     conn_id: Uuid,
-    cancel: CancellationToken,
+    control: CommunityConnectionControl,
 ) {
+    let cancel = control.cancellation_token();
+    let disconnect_reason = control.disconnect_reason();
     let permit = match state.conn_semaphore.clone().try_acquire_owned() {
         Ok(p) => p,
         Err(_) => {
@@ -226,7 +232,14 @@ async fn handle_active_connection(
     let (ws_send, ws_recv) = socket.split();
 
     let send_cancel = cancel.child_token();
-    let send_task = tokio::spawn(send_loop(ws_send, rx, ctrl_rx, restart_rx, send_cancel));
+    let send_task = tokio::spawn(send_loop(
+        ws_send,
+        rx,
+        ctrl_rx,
+        restart_rx,
+        send_cancel,
+        disconnect_reason,
+    ));
 
     let missed_pongs = Arc::new(AtomicU8::new(0));
     let heartbeat_cancel = cancel.clone();
@@ -310,8 +323,17 @@ async fn send_loop(
     ctrl_rx: mpsc::Receiver<WsMessage>,
     restart_rx: mpsc::Receiver<RestartClose>,
     cancel: CancellationToken,
+    disconnect_reason: watch::Receiver<Option<CommunityDisconnectReason>>,
 ) {
-    send_loop_inner(ws_send, data_rx, ctrl_rx, restart_rx, cancel).await;
+    send_loop_inner(
+        ws_send,
+        data_rx,
+        ctrl_rx,
+        restart_rx,
+        cancel,
+        disconnect_reason,
+    )
+    .await;
 }
 
 async fn send_loop_inner<S>(
@@ -320,6 +342,7 @@ async fn send_loop_inner<S>(
     mut ctrl_rx: mpsc::Receiver<WsMessage>,
     mut restart_rx: mpsc::Receiver<RestartClose>,
     cancel: CancellationToken,
+    disconnect_reason: watch::Receiver<Option<CommunityDisconnectReason>>,
 ) where
     S: Sink<WsMessage> + Unpin,
 {
@@ -359,7 +382,10 @@ async fn send_loop_inner<S>(
                         break;
                     }
                 }
-                let _ = ws_send.send(WsMessage::Close(None)).await;
+                let close = disconnect_reason
+                    .borrow()
+                    .map_or(WsMessage::Close(None), |reason| reason.close_message());
+                let _ = ws_send.send(close).await;
                 break;
             }
             Some(ctrl_msg) = ctrl_rx.recv() => {
@@ -787,6 +813,17 @@ mod tests {
         }
     }
 
+    fn ordinary_disconnect_reason() -> watch::Receiver<Option<CommunityDisconnectReason>> {
+        let (_tx, rx) = watch::channel(None);
+        rx
+    }
+
+    fn deleted_community_disconnect_reason() -> watch::Receiver<Option<CommunityDisconnectReason>> {
+        let (tx, rx) = watch::channel(None);
+        tx.send_replace(Some(CommunityDisconnectReason::CommunityDeleted));
+        rx
+    }
+
     fn text_payloads(messages: &[WsMessage]) -> Vec<String> {
         messages
             .iter()
@@ -823,7 +860,15 @@ mod tests {
 
         let (sink, state) = MockSink::new(Some(1));
         let (_restart_tx, restart_rx) = mpsc::channel(1);
-        send_loop_inner(sink, data_rx, ctrl_rx, restart_rx, CancellationToken::new()).await;
+        send_loop_inner(
+            sink,
+            data_rx,
+            ctrl_rx,
+            restart_rx,
+            CancellationToken::new(),
+            ordinary_disconnect_reason(),
+        )
+        .await;
 
         let state = state.lock().expect("mock sink poisoned");
         assert_eq!(state.flush_count, 1);
@@ -844,7 +889,15 @@ mod tests {
 
         let (sink, state) = MockSink::new(Some(1));
         let (_restart_tx, restart_rx) = mpsc::channel(1);
-        send_loop_inner(sink, data_rx, ctrl_rx, restart_rx, CancellationToken::new()).await;
+        send_loop_inner(
+            sink,
+            data_rx,
+            ctrl_rx,
+            restart_rx,
+            CancellationToken::new(),
+            ordinary_disconnect_reason(),
+        )
+        .await;
 
         let state = state.lock().expect("mock sink poisoned");
         assert_eq!(state.flush_count, 1);
@@ -870,7 +923,15 @@ mod tests {
 
         let (sink, state) = MockSink::new(Some(2));
         let (_restart_tx, restart_rx) = mpsc::channel(1);
-        send_loop_inner(sink, data_rx, ctrl_rx, restart_rx, CancellationToken::new()).await;
+        send_loop_inner(
+            sink,
+            data_rx,
+            ctrl_rx,
+            restart_rx,
+            CancellationToken::new(),
+            ordinary_disconnect_reason(),
+        )
+        .await;
 
         let state = state.lock().expect("mock sink poisoned");
         assert_eq!(state.flush_count, 2);
@@ -894,7 +955,15 @@ mod tests {
             .expect("queue restart close");
 
         let (sink, state) = MockSink::new(None);
-        send_loop_inner(sink, data_rx, ctrl_rx, restart_rx, CancellationToken::new()).await;
+        send_loop_inner(
+            sink,
+            data_rx,
+            ctrl_rx,
+            restart_rx,
+            CancellationToken::new(),
+            ordinary_disconnect_reason(),
+        )
+        .await;
 
         assert_eq!(flushed_rx.await, Ok(true));
         let state = state.lock().expect("mock sink poisoned");
@@ -923,7 +992,15 @@ mod tests {
             .expect("queue restart close");
 
         let (sink, state) = MockSink::new(Some(1));
-        send_loop_inner(sink, data_rx, ctrl_rx, restart_rx, CancellationToken::new()).await;
+        send_loop_inner(
+            sink,
+            data_rx,
+            ctrl_rx,
+            restart_rx,
+            CancellationToken::new(),
+            ordinary_disconnect_reason(),
+        )
+        .await;
 
         assert_eq!(flushed_rx.await, Ok(false));
         let state = state.lock().expect("mock sink poisoned");
@@ -931,6 +1008,59 @@ mod tests {
         assert_eq!(state.messages.len(), 1, "no fallback close is appended");
     }
 
+    #[tokio::test]
+    async fn send_loop_sends_policy_close_when_community_is_deleted() {
+        let (_data_tx, data_rx) = mpsc::channel(1);
+        let (_ctrl_tx, ctrl_rx) = mpsc::channel(1);
+        let (_restart_tx, restart_rx) = mpsc::channel(1);
+        let cancel = CancellationToken::new();
+        cancel.cancel();
+
+        let (sink, state) = MockSink::new(None);
+        send_loop_inner(
+            sink,
+            data_rx,
+            ctrl_rx,
+            restart_rx,
+            cancel,
+            deleted_community_disconnect_reason(),
+        )
+        .await;
+
+        let state = state.lock().expect("mock sink poisoned");
+        assert_eq!(state.messages.len(), 1);
+        match &state.messages[0] {
+            WsMessage::Close(Some(close)) => {
+                assert_eq!(close.code, axum::extract::ws::close_code::POLICY);
+                assert_eq!(close.reason.as_str(), "community deleted");
+            }
+            other => panic!("expected one 1008 deletion close, got {other:?}"),
+        }
+    }
+
+    #[tokio::test]
+    async fn send_loop_sends_bare_close_for_ordinary_cancellation() {
+        let (_data_tx, data_rx) = mpsc::channel(1);
+        let (_ctrl_tx, ctrl_rx) = mpsc::channel(1);
+        let (_restart_tx, restart_rx) = mpsc::channel(1);
+        let cancel = CancellationToken::new();
+        cancel.cancel();
+
+        let (sink, state) = MockSink::new(None);
+        send_loop_inner(
+            sink,
+            data_rx,
+            ctrl_rx,
+            restart_rx,
+            cancel,
+            ordinary_disconnect_reason(),
+        )
+        .await;
+
+        let state = state.lock().expect("mock sink poisoned");
+        assert_eq!(state.messages.as_slice(), [WsMessage::Close(None)]);
+    }
+
     #[tokio::test]
     async fn send_loop_flushes_queued_control_before_close_on_cancel() {
         // A ban disconnect queues its `OK false "blocked: …"` reason frame on
@@ -951,7 +1081,15 @@ mod tests {
 
         let (sink, state) = MockSink::new(None);
         let (_restart_tx, restart_rx) = mpsc::channel(1);
-        send_loop_inner(sink, data_rx, ctrl_rx, restart_rx, cancel).await;
+        send_loop_inner(
+            sink,
+            data_rx,
+            ctrl_rx,
+            restart_rx,
+            cancel,
+            ordinary_disconnect_reason(),
+        )
+        .await;
 
         let state = state.lock().expect("mock sink poisoned");
         assert_eq!(
@@ -966,8 +1104,8 @@ mod tests {
             other => panic!("expected the ban reason frame first, got {other:?}"),
         }
         assert!(
-            matches!(state.messages[1], WsMessage::Close(_)),
-            "Close is sent only after the reason frame is flushed"
+            matches!(state.messages[1], WsMessage::Close(None)),
+            "ordinary cancellation retains the bare Close after the reason frame"
         );
     }
 }
diff --git a/crates/buzz-relay/src/handlers/command_executor.rs b/crates/buzz-relay/src/handlers/command_executor.rs
index efdb307e157..abb9bb20665 100644
--- a/crates/buzz-relay/src/handlers/command_executor.rs
+++ b/crates/buzz-relay/src/handlers/command_executor.rs
@@ -112,6 +112,12 @@ async fn persist_command_event(
         .begin_transaction()
         .await
         .map_err(|e| IngestError::Internal(format!("error: begin transaction: {e}")))?;
+    buzz_deletion::store(&state.db)
+        .guard_transaction(&mut tx, tenant.community())
+        .await
+        .map_err(|error| {
+            IngestError::Rejected(format!("restricted: community writes are fenced: {error}"))
+        })?;
 
     // INSERT with ON CONFLICT DO NOTHING — idempotency guard.
     let id_bytes = event.id.as_bytes();
diff --git a/crates/buzz-relay/src/handlers/event.rs b/crates/buzz-relay/src/handlers/event.rs
index a67797385b8..ccba40f3282 100644
--- a/crates/buzz-relay/src/handlers/event.rs
+++ b/crates/buzz-relay/src/handlers/event.rs
@@ -705,16 +705,49 @@ pub async fn handle_event(event: Event, conn: Arc<ConnectionState>, state: Arc<A
             ));
             return;
         }
-        handle_ephemeral_event(
+        match buzz_deletion::store(&state.db)
+            .is_serving_active(conn.tenant.community())
+            .await
+        {
+            Ok(true) => {}
+            Ok(false) => {
+                reject("restricted");
+                conn.send(RelayMessage::ok(
+                    &event_id_hex,
+                    false,
+                    "restricted: community writes are fenced",
+                ));
+                return;
+            }
+            Err(error) => {
+                reject("error");
+                tracing::warn!(%error, event_id = %event_id_hex, "failed to check ephemeral-event community lifecycle");
+                conn.send(RelayMessage::ok(
+                    &event_id_hex,
+                    false,
+                    "error: internal server error",
+                ));
+                return;
+            }
+        }
+        match handle_ephemeral_event(
             event,
             conn_id,
-            &event_id_hex,
             pubkey_bytes,
             auth_pubkey,
-            conn,
+            Arc::clone(&conn),
             state,
         )
-        .await;
+        .await
+        {
+            Ok(()) => {
+                conn.send(RelayMessage::ok(&event_id_hex, true, ""));
+            }
+            Err(message) => {
+                reject("invalid");
+                conn.send(RelayMessage::ok(&event_id_hex, false, &message));
+            }
+        }
         return;
     }
 
@@ -762,33 +795,19 @@ pub async fn handle_event(event: Event, conn: Arc<ConnectionState>, state: Arc<A
 async fn handle_ephemeral_event(
     event: Event,
     conn_id: uuid::Uuid,
-    event_id_hex: &str,
     pubkey_bytes: Vec<u8>,
     auth_pubkey: nostr::PublicKey,
     conn: Arc<ConnectionState>,
     state: Arc<AppState>,
-) {
+) -> Result<(), String> {
     let event_clone = event.clone();
+    let event_id = event.id.to_hex();
     let verify_result = tokio::task::spawn_blocking(move || verify_event(&event_clone)).await;
 
     match verify_result {
         Ok(Ok(())) => {}
-        Ok(Err(e)) => {
-            conn.send(RelayMessage::ok(
-                event_id_hex,
-                false,
-                &format!("invalid: {e}"),
-            ));
-            return;
-        }
-        Err(_) => {
-            conn.send(RelayMessage::ok(
-                event_id_hex,
-                false,
-                "error: internal error",
-            ));
-            return;
-        }
+        Ok(Err(e)) => return Err(format!("invalid: {e}")),
+        Err(_) => return Err("error: internal error".to_string()),
     }
 
     // Special handling for presence events (kind:20001).
@@ -829,18 +848,8 @@ async fn handle_ephemeral_event(
 
     // Check channel membership before publishing other ephemeral events.
     if let Some(ch_id) = super::ingest::extract_channel_id(&event) {
-        if let Err(msg) = super::ingest::check_channel_membership(
-            &conn.tenant,
-            &state,
-            ch_id,
-            &pubkey_bytes,
-            None,
-        )
-        .await
-        {
-            conn.send(RelayMessage::ok(event_id_hex, false, &msg));
-            return;
-        }
+        super::ingest::check_channel_membership(&conn.tenant, &state, ch_id, &pubkey_bytes, None)
+            .await?;
 
         // Mark as local before Redis publish to prevent double-delivery when
         // the event comes back through the Redis subscriber loop.
@@ -854,7 +863,7 @@ async fn handle_ephemeral_event(
             state
                 .local_event_ids
                 .invalidate(&(conn.tenant.community(), event.id.to_bytes()));
-            warn!(conn_id = %conn_id, event_id = %event_id_hex, "Ephemeral publish failed: {e}");
+            warn!(conn_id = %conn_id, event_id = %event_id, "Ephemeral publish failed: {e}");
         }
 
         // Direct fan-out to local WS subscribers, through the guarded send path
@@ -882,7 +891,7 @@ async fn handle_ephemeral_event(
             state
                 .local_event_ids
                 .invalidate(&(conn.tenant.community(), event.id.to_bytes()));
-            warn!(conn_id = %conn_id, event_id = %event_id_hex, "Ephemeral global publish failed: {e}");
+            warn!(conn_id = %conn_id, event_id = %event_id, "Ephemeral global publish failed: {e}");
         }
 
         // Direct fan-out to local WS subscribers through the guarded send path.
@@ -893,7 +902,7 @@ async fn handle_ephemeral_event(
         fan_out_event_to_local_subscribers(&state, conn.tenant.community(), &stored_event).await;
     }
 
-    conn.send(RelayMessage::ok(event_id_hex, true, ""));
+    Ok(())
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
diff --git a/crates/buzz-relay/src/handlers/ingest.rs b/crates/buzz-relay/src/handlers/ingest.rs
index a8651f5c02c..981e6d4ee3d 100644
--- a/crates/buzz-relay/src/handlers/ingest.rs
+++ b/crates/buzz-relay/src/handlers/ingest.rs
@@ -300,6 +300,24 @@ pub enum IngestError {
     Internal(String),
 }
 
+/// Map the durable community write-fence lookup onto the ingest error taxonomy.
+///
+/// An inactive community is an authorization decision and keeps the exact
+/// `restricted:` wire text the ephemeral path uses. A lookup outage is a
+/// server fault and fails closed as `error:`/500 — a Postgres blip can
+/// neither admit a write past the fence nor read as a client mistake.
+fn map_serving_fence_state(active: Result<bool, buzz_db::DbError>) -> Result<(), IngestError> {
+    match active {
+        Ok(true) => Ok(()),
+        Ok(false) => Err(IngestError::Rejected(
+            "restricted: community writes are fenced".into(),
+        )),
+        Err(error) => Err(IngestError::Internal(format!(
+            "error: checking community write fence: {error}"
+        ))),
+    }
+}
+
 fn map_relay_admin_error(error: super::relay_admin::RelayAdminError) -> IngestError {
     use super::relay_admin::RelayAdminError;
     match error {
@@ -1945,6 +1963,17 @@ async fn ingest_event_inner(
     let kind_u32 = event_kind_u32(&event);
     debug!(event_id = %event_id_hex, kind = kind_u32, "ingest_event");
 
+    // Durable community write fence: persistent ingest is a DB write the
+    // deletion engine cannot exclude via serving-write leases (those cover
+    // external side effects only), so the shared WS/HTTP seam must refuse
+    // writes once the community leaves the active lifecycle state. Row churn
+    // inside the remaining race window is swept by the destructive DB stage.
+    map_serving_fence_state(
+        buzz_deletion::store(&state.db)
+            .is_serving_active(tenant.community())
+            .await,
+    )?;
+
     if kind_u32 == KIND_AUTH {
         return Err(IngestError::Rejected(
             "invalid: AUTH events cannot be submitted".into(),
@@ -3185,6 +3214,123 @@ mod tests {
         }
     }
 
+    /// An active community passes the durable write fence untouched.
+    #[test]
+    fn serving_fence_active_community_admits_write() {
+        assert!(map_serving_fence_state(Ok(true)).is_ok());
+    }
+
+    /// A fenced/tombstoned/archived community is an authorization decision:
+    /// `restricted:` and (via `bridge.rs`) HTTP 400 — with the exact wire text
+    /// the ephemeral WS path uses, so clients see one refusal vocabulary.
+    #[test]
+    fn serving_fence_inactive_community_maps_to_restricted() {
+        match map_serving_fence_state(Ok(false)) {
+            Err(IngestError::Rejected(msg)) => {
+                assert_eq!(msg, "restricted: community writes are fenced");
+            }
+            other => panic!("fenced community must map to Rejected, got {other:?}"),
+        }
+    }
+
+    /// A fence-lookup outage is a server fault and must fail closed as
+    /// `error:`/500 — a Postgres blip can neither admit a write past the
+    /// fence nor be reported to an innocent client as a bad request.
+    #[test]
+    fn serving_fence_lookup_outage_fails_closed_as_internal() {
+        let outage = buzz_db::DbError::Sqlx(sqlx::Error::PoolTimedOut);
+        match map_serving_fence_state(Err(outage)) {
+            Err(IngestError::Internal(msg)) => {
+                assert!(
+                    msg.starts_with("error: "),
+                    "fence outages need the `error:` NIP-01 prefix, got {msg:?}"
+                );
+            }
+            other => panic!("fence lookup failure must map to Internal, got {other:?}"),
+        }
+    }
+
+    /// Production-path regression: the exact predicate `ingest_event_inner`
+    /// consults must admit writes while a community is active and refuse them
+    /// once the community deletion lifecycle fences it.
+    #[tokio::test]
+    #[ignore = "requires Postgres"]
+    async fn ingest_write_fence_follows_community_deletion_lifecycle() {
+        use buzz_db::deletion::{
+            FrozenInventory, KeyStreamDigest, PrefixManifest, StorageManifest,
+            DEFAULT_LEASE_DURATION,
+        };
+
+        let url = std::env::var("BUZZ_TEST_DATABASE_URL")
+            .or_else(|_| std::env::var("DATABASE_URL"))
+            .unwrap_or_else(|_| "postgres://buzz:buzz_dev@localhost:5432/buzz".to_string()); // sadscan:disable np.postgres.1
+        let pool = sqlx::PgPool::connect(&url).await.expect("connect test DB");
+        let db = buzz_db::Db::from_pool(pool);
+        db.migrate().await.expect("migrate test DB");
+        let store = buzz_deletion::store(&db);
+
+        let host = format!("lane3-fence-{}.example", Uuid::new_v4().simple());
+        let community = db
+            .ensure_configured_community(&host)
+            .await
+            .expect("community")
+            .id;
+
+        assert!(
+            map_serving_fence_state(store.is_serving_active(community).await).is_ok(),
+            "active community must admit persistent ingest"
+        );
+
+        let submitted = store
+            .submit(
+                &host,
+                "test-operator",
+                Some("lane3 ingest fence regression"),
+            )
+            .await
+            .expect("submit");
+        let inventory = FrozenInventory {
+            schema: store
+                .inventory_schema(community)
+                .await
+                .expect("schema inventory"),
+            storage: StorageManifest {
+                version: 4,
+                prefixes: buzz_media::tenant_prefixes(*community.as_uuid())
+                    .into_iter()
+                    .map(|prefix| PrefixManifest {
+                        prefix,
+                        object_count: 0,
+                        total_bytes: 0,
+                        keys_digest: KeyStreamDigest::new().finish().0,
+                    })
+                    .collect(),
+            },
+        };
+        let request = store
+            .freeze_inventory(submitted.id, &inventory)
+            .await
+            .expect("freeze inventory");
+        store
+            .approve(request.id, "approver", None)
+            .await
+            .expect("approve");
+        let claim = store
+            .claim_specific(request.id, "executor", DEFAULT_LEASE_DURATION)
+            .await
+            .expect("claim")
+            .expect("won claim");
+        store.begin_quiescing(&claim.lease).await.expect("quiesce");
+        store.fence(&claim.lease).await.expect("fence");
+
+        match map_serving_fence_state(store.is_serving_active(community).await) {
+            Err(IngestError::Rejected(msg)) => {
+                assert_eq!(msg, "restricted: community writes are fenced");
+            }
+            other => panic!("fenced community must refuse persistent ingest, got {other:?}"),
+        }
+    }
+
     #[derive(Debug, Default)]
     struct VecTracer {
         steps: Mutex<Vec<TraceStep>>,
diff --git a/crates/buzz-relay/src/main.rs b/crates/buzz-relay/src/main.rs
index 34dc2dfcf80..3584e1849d1 100644
--- a/crates/buzz-relay/src/main.rs
+++ b/crates/buzz-relay/src/main.rs
@@ -201,6 +201,12 @@ async fn main() -> anyhow::Result<()> {
         error!("Failed to ensure partitions: {e}");
     }
 
+    db.validate_deletion_serving_catalog().await.map_err(|e| {
+        error!("Community deletion serving-fence validation failed: {e}");
+        anyhow::anyhow!("Community deletion serving fence is unsafe: {e}")
+    })?;
+    info!("Community deletion serving fences verified");
+
     // Freshness fence probe: cursor pages route to the replica only for
     // history the probe has verified as fully replayed. Deliberately AFTER
     // the migration decision: spawn_fence_probe first verifies the
@@ -469,6 +475,7 @@ async fn main() -> anyhow::Result<()> {
     if let Some(handle) = buzz_relay::mesh_boot::boot_mesh(
         &state.config,
         state.redis_pool.clone(),
+        state.db.clone(),
         &state.relay_keypair,
         Arc::clone(&state.shutting_down),
     )
@@ -1018,6 +1025,24 @@ async fn main() -> anyhow::Result<()> {
                 metrics::gauge!("buzz_redis_pool_size").set(rs.size as f64);
                 metrics::gauge!("buzz_redis_pool_max").set(rs.max_size as f64);
                 metrics::gauge!("buzz_redis_pool_waiting").set(rs.waiting as f64);
+
+                let deletion_store = pool_state.db.deletion_store();
+                match deletion_store.reap_expired_serving_write_leases(1000).await {
+                    Ok(reaped) => metrics::counter!("buzz_deletion_serving_leases_reaped_total")
+                        .increment(reaped),
+                    Err(error) => tracing::warn!(%error, "serving-lease reaper failed"),
+                }
+                match deletion_store.serving_lease_stats().await {
+                    Ok(stats) => {
+                        metrics::gauge!("buzz_deletion_serving_leases_active")
+                            .set(stats.active as f64);
+                        metrics::gauge!("buzz_deletion_serving_leases_expired")
+                            .set(stats.expired as f64);
+                        metrics::gauge!("buzz_deletion_serving_leases_dead_tuples")
+                            .set(stats.dead_tuples as f64);
+                    }
+                    Err(error) => tracing::warn!(%error, "serving-lease metrics failed"),
+                }
             }
         });
     }
diff --git a/crates/buzz-relay/src/mesh_boot.rs b/crates/buzz-relay/src/mesh_boot.rs
index 20e550aa08a..cd7c427c72e 100644
--- a/crates/buzz-relay/src/mesh_boot.rs
+++ b/crates/buzz-relay/src/mesh_boot.rs
@@ -411,6 +411,7 @@ fn advertise_addrs(endpoint: &MeshEndpoint) -> Vec<String> {
 pub async fn boot_mesh(
     config: &Config,
     redis_pool: deadpool_redis::Pool,
+    db: buzz_db::Db,
     relay_keypair: &nostr::Keys,
     shutting_down: Arc<AtomicBool>,
 ) -> anyhow::Result<Option<MeshHandle>> {
@@ -508,7 +509,7 @@ pub async fn boot_mesh(
     transport.set_inbound(Box::new(dispatcher.clone()));
 
     Ok(Some(MeshHandle {
-        directory: SessionDirectory::new(redis_pool),
+        directory: SessionDirectory::with_db(redis_pool, db),
         transport,
         membership: membership_arc,
         local_runtime_id: runtime_id,
@@ -535,7 +536,13 @@ mod tests {
             .create_pool(Some(deadpool_redis::Runtime::Tokio1))
             .unwrap();
         let keys = nostr::Keys::generate();
-        let handle = boot_mesh(&config, pool, &keys, Arc::new(AtomicBool::new(false)))
+        let db = buzz_db::Db::from_pool(
+            sqlx::postgres::PgPoolOptions::new()
+                .max_connections(1)
+                .connect_lazy("postgres://unused:unused@127.0.0.1:1/unused")
+                .expect("lazy database pool"),
+        );
+        let handle = boot_mesh(&config, pool, db, &keys, Arc::new(AtomicBool::new(false)))
             .await
             .expect("off path is never an error");
         assert!(handle.is_none());
diff --git a/crates/buzz-relay/src/push_runtime.rs b/crates/buzz-relay/src/push_runtime.rs
index 49845067eac..4946b248c65 100644
--- a/crates/buzz-relay/src/push_runtime.rs
+++ b/crates/buzz-relay/src/push_runtime.rs
@@ -418,6 +418,23 @@ async fn deliver_one(
             return;
         }
     };
+    let serving_write = match buzz_deletion::acquire_serving_write(
+        &state.db,
+        outcome.community,
+        "push_delivery",
+    )
+    .await
+    {
+        Ok(guard) => guard,
+        Err(error) => {
+            warn!(wake=%outcome.id, %error, "push delivery suppressed by community deletion fence");
+            let _ = state
+                .db
+                .fail_push_wake(outcome.community, outcome.id, outcome.claim_id)
+                .await;
+            return;
+        }
+    };
     let Some(url) = state.config.push_gateway_delivery_url.as_ref() else {
         return;
     };
@@ -429,7 +446,20 @@ async fn deliver_one(
             return;
         }
     };
-    let response = send_gateway_request(http, url, body, auth).await;
+    if let Err(error) = serving_write.verify().await {
+        warn!(wake=%outcome.id, %error, "push serving lease lost before delivery");
+        return;
+    }
+    let response = match serving_write
+        .protect(send_gateway_request(http, url, body, auth))
+        .await
+    {
+        Ok(response) => response,
+        Err(error) => {
+            warn!(wake=%outcome.id, %error, "push serving lease lost during delivery");
+            return;
+        }
+    };
     match response {
         Ok(r) if r.status().is_success() => match r.json::<DeliveryResponse>().await {
             Ok(DeliveryResponse::Accepted) => {
@@ -502,6 +532,9 @@ async fn deliver_one(
                 .await;
         }
     }
+    if let Err(error) = serving_write.finish().await {
+        warn!(wake=%outcome.id, %error, "failed to release community serving lease after push delivery");
+    }
 }
 
 fn delivery_body(endpoint_grant: &str, request_id: uuid::Uuid, expires_at: i64) -> Vec<u8> {
diff --git a/crates/buzz-relay/src/router.rs b/crates/buzz-relay/src/router.rs
index 400ed1dfe34..82ad9938a2f 100644
--- a/crates/buzz-relay/src/router.rs
+++ b/crates/buzz-relay/src/router.rs
@@ -376,22 +376,30 @@ async fn readiness_handler(State(state): State<Arc<AppState>>) -> impl IntoRespo
     }
 
     let check = async {
-        let (pg_ok, redis_ok) = tokio::join!(state.db.ping(), async {
-            state.redis_pool.get().await.is_ok()
-        },);
-        (pg_ok, redis_ok)
+        let (pg_ok, redis_ok, deletion_catalog_ok) = tokio::join!(
+            state.db.ping(),
+            async { state.redis_pool.get().await.is_ok() },
+            async { state.db.validate_deletion_serving_catalog().await.is_ok() },
+        );
+        (pg_ok, redis_ok, deletion_catalog_ok)
     };
 
-    let (pg_ok, redis_ok) = tokio::time::timeout(Duration::from_secs(2), check)
-        .await
-        .unwrap_or((false, false));
+    let (pg_ok, redis_ok, deletion_catalog_ok) =
+        tokio::time::timeout(Duration::from_secs(2), check)
+            .await
+            .unwrap_or((false, false, false));
 
-    if pg_ok && redis_ok {
+    if pg_ok && redis_ok && deletion_catalog_ok {
         (StatusCode::OK, Json(json!({"status": "ready"}))).into_response()
     } else {
         (
             StatusCode::SERVICE_UNAVAILABLE,
-            Json(json!({"status": "not_ready", "postgres": pg_ok, "redis": redis_ok})),
+            Json(json!({
+                "status": "not_ready",
+                "postgres": pg_ok,
+                "redis": redis_ok,
+                "deletion_catalog": deletion_catalog_ok
+            })),
         )
             .into_response()
     }
diff --git a/crates/buzz-relay/src/state.rs b/crates/buzz-relay/src/state.rs
index 84c8911e477..a7c97be94a4 100644
--- a/crates/buzz-relay/src/state.rs
+++ b/crates/buzz-relay/src/state.rs
@@ -10,8 +10,7 @@ use axum::body::Bytes;
 use axum::extract::ws::{Message as WsMessage, Utf8Bytes as WsUtf8Bytes};
 use dashmap::DashMap;
 use futures_util::future::join_all;
-use tokio::sync::mpsc;
-use tokio::sync::Semaphore;
+use tokio::sync::{mpsc, watch, Semaphore};
 use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
 use uuid::Uuid;
@@ -37,6 +36,55 @@ use crate::subscription::SubscriptionRegistry;
 
 pub(crate) type ScopedPubkeyKey = (CommunityId, [u8; 32]);
 
+/// Why a community-bound socket is being asked to stop.
+///
+/// Only deletion is externally attributed today. Ordinary lifecycle exits keep
+/// using cancellation alone and therefore retain the existing bare-close
+/// behavior.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum CommunityDisconnectReason {
+    CommunityDeleted,
+}
+
+impl CommunityDisconnectReason {
+    pub(crate) fn close_message(self) -> WsMessage {
+        match self {
+            Self::CommunityDeleted => WsMessage::Close(Some(axum::extract::ws::CloseFrame {
+                code: axum::extract::ws::close_code::POLICY,
+                reason: WsUtf8Bytes::from_static("community deleted"),
+            })),
+        }
+    }
+}
+
+/// Per-socket lifecycle controls shared by the registry and the writer.
+#[derive(Clone)]
+pub(crate) struct CommunityConnectionControl {
+    cancel: CancellationToken,
+    reason_tx: watch::Sender<Option<CommunityDisconnectReason>>,
+}
+
+impl CommunityConnectionControl {
+    pub(crate) fn new(cancel: CancellationToken) -> Self {
+        let (reason_tx, _reason_rx) = watch::channel(None);
+        Self { cancel, reason_tx }
+    }
+
+    pub(crate) fn cancellation_token(&self) -> CancellationToken {
+        self.cancel.clone()
+    }
+
+    pub(crate) fn disconnect_reason(&self) -> watch::Receiver<Option<CommunityDisconnectReason>> {
+        self.reason_tx.subscribe()
+    }
+
+    fn disconnect_community(&self) {
+        self.reason_tx
+            .send_replace(Some(CommunityDisconnectReason::CommunityDeleted));
+        self.cancel.cancel();
+    }
+}
+
 /// Leaves headroom under the process-wide drain deadline for a stalled writer.
 const RESTART_CLOSE_ACK_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
 type SlidingWindowCounter = (u32, Instant);
@@ -68,7 +116,7 @@ struct ConnEntry {
 /// registration cancels the token; archival before registration is observed by
 /// the revalidation. The returned guard removes the entry on every exit path.
 pub struct CommunityConnectionRegistry {
-    connections: Arc<DashMap<Uuid, (CommunityId, CancellationToken)>>,
+    connections: Arc<DashMap<Uuid, (CommunityId, CommunityConnectionControl)>>,
 }
 
 impl Default for CommunityConnectionRegistry {
@@ -86,26 +134,27 @@ impl CommunityConnectionRegistry {
     }
 
     /// Registers one socket and returns a guard that deregisters it on drop.
-    pub fn register(
+    pub(crate) fn register(
         &self,
         connection_id: Uuid,
         community_id: CommunityId,
-        cancel: CancellationToken,
+        control: CommunityConnectionControl,
     ) -> CommunityConnectionGuard {
         self.connections
-            .insert(connection_id, (community_id, cancel));
+            .insert(connection_id, (community_id, control));
         CommunityConnectionGuard {
             connection_id,
             connections: Arc::clone(&self.connections),
         }
     }
 
-    /// Cancels every socket type currently bound to `community_id`.
+    /// Disconnects every socket type currently bound to `community_id` and
+    /// attributes the close to community deletion.
     pub fn disconnect_community(&self, community_id: CommunityId) -> usize {
         let mut closed = 0;
         for entry in self.connections.iter() {
             if entry.value().0 == community_id {
-                entry.value().1.cancel();
+                entry.value().1.disconnect_community();
                 closed += 1;
             }
         }
@@ -124,7 +173,7 @@ impl CommunityConnectionRegistry {
 /// Removes a socket lifecycle registration on every handler exit path.
 pub struct CommunityConnectionGuard {
     connection_id: Uuid,
-    connections: Arc<DashMap<Uuid, (CommunityId, CancellationToken)>>,
+    connections: Arc<DashMap<Uuid, (CommunityId, CommunityConnectionControl)>>,
 }
 
 impl Drop for CommunityConnectionGuard {
@@ -137,20 +186,21 @@ impl Drop for CommunityConnectionGuard {
 ///
 /// The ordering is the archival admission invariant: archive-before-query is
 /// observed by the query, while archive-after-registration sees the token.
-pub async fn run_registered_community_connection<Check, CheckFuture, Run, RunFuture>(
+pub(crate) async fn run_registered_community_connection<Check, CheckFuture, Run, RunFuture>(
     registry: &CommunityConnectionRegistry,
     connection_id: Uuid,
     community_id: CommunityId,
-    cancel: CancellationToken,
+    control: CommunityConnectionControl,
     check_active: Check,
     run: Run,
 ) where
     Check: FnOnce() -> CheckFuture,
     CheckFuture: Future<Output = Result<bool, buzz_db::DbError>>,
-    Run: FnOnce() -> RunFuture,
+    Run: FnOnce(CommunityConnectionControl) -> RunFuture,
     RunFuture: Future<Output = ()>,
 {
-    let _guard = registry.register(connection_id, community_id, cancel.clone());
+    let cancel = control.cancel.clone();
+    let _guard = registry.register(connection_id, community_id, control.clone());
     if !matches!(check_active().await, Ok(true)) {
         cancel.cancel();
         return;
@@ -158,7 +208,7 @@ pub async fn run_registered_community_connection<Check, CheckFuture, Run, RunFut
     if cancel.is_cancelled() {
         return;
     }
-    run().await;
+    run(control).await;
     cancel.cancel();
 }
 
@@ -1675,14 +1725,29 @@ mod tests {
         let ordinary_a = CancellationToken::new();
         let audio_a = CancellationToken::new();
         let ordinary_b = CancellationToken::new();
-        let _ordinary_a_guard = registry.register(Uuid::new_v4(), community_a, ordinary_a.clone());
-        let _audio_a_guard = registry.register(Uuid::new_v4(), community_a, audio_a.clone());
-        let _ordinary_b_guard = registry.register(Uuid::new_v4(), community_b, ordinary_b.clone());
+        let ordinary_a_control = CommunityConnectionControl::new(ordinary_a.clone());
+        let audio_a_control = CommunityConnectionControl::new(audio_a.clone());
+        let ordinary_b_control = CommunityConnectionControl::new(ordinary_b.clone());
+        let ordinary_a_reason = ordinary_a_control.disconnect_reason();
+        let audio_a_reason = audio_a_control.disconnect_reason();
+        let ordinary_b_reason = ordinary_b_control.disconnect_reason();
+        let _ordinary_a_guard = registry.register(Uuid::new_v4(), community_a, ordinary_a_control);
+        let _audio_a_guard = registry.register(Uuid::new_v4(), community_a, audio_a_control);
+        let _ordinary_b_guard = registry.register(Uuid::new_v4(), community_b, ordinary_b_control);
 
         assert_eq!(registry.disconnect_community(community_a), 2);
         assert!(ordinary_a.is_cancelled());
         assert!(audio_a.is_cancelled());
         assert!(!ordinary_b.is_cancelled());
+        assert_eq!(
+            *ordinary_a_reason.borrow(),
+            Some(CommunityDisconnectReason::CommunityDeleted)
+        );
+        assert_eq!(
+            *audio_a_reason.borrow(),
+            Some(CommunityDisconnectReason::CommunityDeleted)
+        );
+        assert_eq!(*ordinary_b_reason.borrow(), None);
     }
 
     #[tokio::test]
@@ -1699,9 +1764,9 @@ mod tests {
             &registry,
             Uuid::new_v4(),
             community,
-            cancel_before.clone(),
+            CommunityConnectionControl::new(cancel_before.clone()),
             || async { Ok(false) },
-            move || async move { started_before_run.store(true, Ordering::SeqCst) },
+            move |_| async move { started_before_run.store(true, Ordering::SeqCst) },
         )
         .await;
         assert!(cancel_before.is_cancelled());
@@ -1721,13 +1786,13 @@ mod tests {
             &registry,
             Uuid::new_v4(),
             community,
-            cancel_during.clone(),
+            CommunityConnectionControl::new(cancel_during.clone()),
             move || async move {
                 registered_check.notify_one();
                 resume_check.notified().await;
                 Ok(true)
             },
-            move || async move { started_during_run.store(true, Ordering::SeqCst) },
+            move |_| async move { started_during_run.store(true, Ordering::SeqCst) },
         );
         tokio::pin!(future);
         tokio::select! {
@@ -1750,9 +1815,21 @@ mod tests {
         let cancel_a = CancellationToken::new();
         let cancel_failed = CancellationToken::new();
         let cancel_c = CancellationToken::new();
-        let _guard_a = registry.register(Uuid::new_v4(), archived_a, cancel_a.clone());
-        let _guard_failed = registry.register(Uuid::new_v4(), failed, cancel_failed.clone());
-        let _guard_c = registry.register(Uuid::new_v4(), archived_c, cancel_c.clone());
+        let _guard_a = registry.register(
+            Uuid::new_v4(),
+            archived_a,
+            CommunityConnectionControl::new(cancel_a.clone()),
+        );
+        let _guard_failed = registry.register(
+            Uuid::new_v4(),
+            failed,
+            CommunityConnectionControl::new(cancel_failed.clone()),
+        );
+        let _guard_c = registry.register(
+            Uuid::new_v4(),
+            archived_c,
+            CommunityConnectionControl::new(cancel_c.clone()),
+        );
 
         let (closed, failures) =
             revalidate_registered_communities(&registry, |community| async move {
@@ -1783,7 +1860,11 @@ mod tests {
         let registry = CommunityConnectionRegistry::new();
         let community = CommunityId::from_uuid(Uuid::from_u128(0xa));
         let cancel = CancellationToken::new();
-        let guard = registry.register(Uuid::new_v4(), community, cancel.clone());
+        let guard = registry.register(
+            Uuid::new_v4(),
+            community,
+            CommunityConnectionControl::new(cancel.clone()),
+        );
         assert_eq!(registry.bound_communities(), HashSet::from([community]));
 
         drop(guard);
diff --git a/crates/buzz-relay/src/tunnel/directory.rs b/crates/buzz-relay/src/tunnel/directory.rs
index 7cd6e22a2d1..42b121e4310 100644
--- a/crates/buzz-relay/src/tunnel/directory.rs
+++ b/crates/buzz-relay/src/tunnel/directory.rs
@@ -87,6 +87,7 @@ return {current, known_generation}
 pub struct SessionDirectory {
     pool: deadpool_redis::Pool,
     lease_ttl: Duration,
+    db: Option<buzz_db::Db>,
 }
 
 /// Active session ownership lease read from Redis.
@@ -179,6 +180,9 @@ pub enum DirectoryError {
     /// Lease TTL cannot be represented in Redis milliseconds.
     #[error("lease ttl must be at least 1ms and fit in i64 milliseconds")]
     InvalidLeaseTtl,
+    /// Durable community deletion fence rejected a Redis mutation.
+    #[error("community write fenced: {0}")]
+    CommunityWriteFenced(String),
 }
 
 impl SessionDirectory {
@@ -187,9 +191,36 @@ impl SessionDirectory {
         Self::with_lease_ttl(pool, DEFAULT_LEASE_TTL)
     }
 
+    /// Create a serving directory whose Redis mutations use durable,
+    /// heartbeat-backed community write leases.
+    pub fn with_db(pool: deadpool_redis::Pool, db: buzz_db::Db) -> Self {
+        Self {
+            pool,
+            lease_ttl: DEFAULT_LEASE_TTL,
+            db: Some(db),
+        }
+    }
+
     /// Create a directory backed by `pool` with an explicit lease TTL.
     pub fn with_lease_ttl(pool: deadpool_redis::Pool, lease_ttl: Duration) -> Self {
-        Self { pool, lease_ttl }
+        Self {
+            pool,
+            lease_ttl,
+            db: None,
+        }
+    }
+
+    async fn begin_serving_write(
+        &self,
+        community_id: CommunityId,
+    ) -> Result<Option<buzz_deletion::ServingWriteGuard>, DirectoryError> {
+        match &self.db {
+            Some(db) => buzz_deletion::acquire_serving_write(db, community_id, "session_directory")
+                .await
+                .map(Some)
+                .map_err(|error| DirectoryError::CommunityWriteFenced(error.to_string())),
+            None => Ok(None),
+        }
     }
 
     /// Attempt to create/take over the session lease.
@@ -204,10 +235,11 @@ impl SessionDirectory {
         owner_runtime_id: RuntimeId,
         profile: Profile,
     ) -> Result<AcquireResult, DirectoryError> {
+        let serving_write = self.begin_serving_write(community_id).await?;
         let keys = SessionKeys::new(community_id, session_id);
         let ttl_ms = ttl_ms(self.lease_ttl)?;
         let mut conn = self.pool.get().await?;
-        let (status, value, _known_generation): (String, String, String) =
+        let mutation = async {
             Script::new(ACQUIRE_SCRIPT)
                 .key(&keys.lease)
                 .key(&keys.generation)
@@ -215,8 +247,22 @@ impl SessionDirectory {
                 .arg(profile.as_wire_str())
                 .arg(ttl_ms)
                 .invoke_async(&mut *conn)
-                .await?;
+                .await
+        };
+        let (status, value, _known_generation): (String, String, String) = match &serving_write {
+            Some(guard) => guard
+                .protect(mutation)
+                .await
+                .map_err(|error| DirectoryError::CommunityWriteFenced(error.to_string()))??,
+            None => mutation.await?,
+        };
         let lease = parse_lease(community_id, session_id, &value)?;
+        if let Some(guard) = serving_write {
+            guard
+                .finish()
+                .await
+                .map_err(|error| DirectoryError::CommunityWriteFenced(error.to_string()))?;
+        }
         match status.as_str() {
             "acquired" => Ok(AcquireResult::Acquired(lease)),
             "exists" => Ok(AcquireResult::Exists(lease)),
@@ -244,18 +290,34 @@ impl SessionDirectory {
     /// Renew a lease only if the current Redis value exactly matches the
     /// caller's owner runtime and generation.
     pub async fn renew(&self, lease: &SessionLease) -> Result<RenewResult, DirectoryError> {
+        let serving_write = self.begin_serving_write(lease.community_id).await?;
         let keys = SessionKeys::new(lease.community_id, lease.session_id);
         let ttl_ms = ttl_ms(self.lease_ttl)?;
         let mut conn = self.pool.get().await?;
-        let (status, value, known_generation): (String, String, String) = Script::new(RENEW_SCRIPT)
-            .key(&keys.lease)
-            .key(&keys.generation)
-            .arg(lease.owner_runtime_id.to_hex())
-            .arg(lease.generation)
-            .arg(ttl_ms)
-            .invoke_async(&mut *conn)
-            .await?;
+        let mutation = async {
+            Script::new(RENEW_SCRIPT)
+                .key(&keys.lease)
+                .key(&keys.generation)
+                .arg(lease.owner_runtime_id.to_hex())
+                .arg(lease.generation)
+                .arg(ttl_ms)
+                .invoke_async(&mut *conn)
+                .await
+        };
+        let (status, value, known_generation): (String, String, String) = match &serving_write {
+            Some(guard) => guard
+                .protect(mutation)
+                .await
+                .map_err(|error| DirectoryError::CommunityWriteFenced(error.to_string()))??,
+            None => mutation.await?,
+        };
         let current = parse_optional_lease(lease.community_id, lease.session_id, &value)?;
+        if let Some(guard) = serving_write {
+            guard
+                .finish()
+                .await
+                .map_err(|error| DirectoryError::CommunityWriteFenced(error.to_string()))?;
+        }
         match status.as_str() {
             "renewed" => Ok(RenewResult::Renewed(
                 current.expect("renewed returns lease"),
@@ -275,17 +337,32 @@ impl SessionDirectory {
     /// Release a lease only if the current Redis value exactly matches the
     /// caller's owner runtime and generation.
     pub async fn release(&self, lease: &SessionLease) -> Result<ReleaseResult, DirectoryError> {
+        let serving_write = self.begin_serving_write(lease.community_id).await?;
         let keys = SessionKeys::new(lease.community_id, lease.session_id);
         let mut conn = self.pool.get().await?;
-        let (status, value, known_generation): (String, String, String) =
+        let mutation = async {
             Script::new(RELEASE_SCRIPT)
                 .key(&keys.lease)
                 .key(&keys.generation)
                 .arg(lease.owner_runtime_id.to_hex())
                 .arg(lease.generation)
                 .invoke_async(&mut *conn)
-                .await?;
+                .await
+        };
+        let (status, value, known_generation): (String, String, String) = match &serving_write {
+            Some(guard) => guard
+                .protect(mutation)
+                .await
+                .map_err(|error| DirectoryError::CommunityWriteFenced(error.to_string()))??,
+            None => mutation.await?,
+        };
         let current = parse_optional_lease(lease.community_id, lease.session_id, &value)?;
+        if let Some(guard) = serving_write {
+            guard
+                .finish()
+                .await
+                .map_err(|error| DirectoryError::CommunityWriteFenced(error.to_string()))?;
+        }
         match status.as_str() {
             "released" => Ok(ReleaseResult::Released(
                 current.expect("released returns lease"),
diff --git a/crates/buzz-test-client/tests/e2e_relay.rs b/crates/buzz-test-client/tests/e2e_relay.rs
index 2013875d9ab..5d5ad8916c3 100644
--- a/crates/buzz-test-client/tests/e2e_relay.rs
+++ b/crates/buzz-test-client/tests/e2e_relay.rs
@@ -120,7 +120,12 @@ async fn seed_relay_member(host: &str, keys: &Keys, role: &str) {
 }
 
 async fn seed_relay_owner(keys: &Keys) {
-    seed_relay_member("localhost:3000", keys, "owner").await;
+    seed_relay_member(&relay_authority(), keys, "owner").await;
+}
+
+fn relay_authority() -> String {
+    let url = url::Url::parse(&relay_http_url()).expect("relay HTTP URL");
+    url[url::Position::BeforeHost..url::Position::AfterPort].to_string()
 }
 
 fn http_origin_for_host(host: &str) -> String {
@@ -315,7 +320,7 @@ async fn test_invite_claim_rejects_invalid_code() {
 #[ignore]
 async fn test_invite_mint_requires_owner_or_admin() {
     let member = Keys::generate();
-    seed_relay_member("localhost:3000", &member, "member").await;
+    seed_relay_member(&relay_authority(), &member, "member").await;
 
     let response = invite_post(&member, "/api/invites", "{}").await;
     assert_eq!(response.status(), reqwest::StatusCode::FORBIDDEN);
@@ -791,10 +796,10 @@ async fn test_auth_event_kind_rejected() {
 
 /// NIP-11 max_subscriptions must be enforced; (limit+1)th REQ gets CLOSED.
 ///
-/// The relay's MAX_SUBSCRIPTIONS is 1024. Opening 1024 subs in a test is slow,
-/// so we open a smaller batch and verify the NIP-11 advertised limit matches
-/// the actual enforcement constant. The full-limit test is covered by the
-/// NIP-11 assertion below (which verifies the advertised value is 1024).
+/// This is a protocol-cap test, not an admission-throughput test. Open one REQ
+/// at a time and wait out any shared fixed-window quota before retrying a REQ
+/// rejected specifically as `rate-limited`, so production admission remains
+/// enabled while the test deterministically reaches the independent 1024 cap.
 #[tokio::test]
 #[ignore]
 async fn test_subscription_limit_enforced() {
@@ -802,60 +807,75 @@ async fn test_subscription_limit_enforced() {
     let keys = Keys::generate();
     let mut client = BuzzTestClient::connect(&url, &keys).await.expect("connect");
 
-    // Open 1024 subscriptions (the relay's MAX_SUBSCRIPTIONS).
     for i in 0..1024 {
         let sid = format!("limit-sub-{i}");
-        let filter = Filter::new().kind(Kind::Custom(9));
-        client
-            .subscribe(&sid, vec![filter])
-            .await
-            .expect("subscribe");
-        // Drain EOSE to avoid buffer buildup.
-        client
-            .collect_until_eose(&sid, Duration::from_secs(5))
-            .await
-            .expect("EOSE");
+        let filter = Filter::new().kind(Kind::Custom(49_999));
+        subscribe_until_eose(&mut client, &sid, filter).await;
     }
 
     let overflow_sid = sub_id("overflow");
-    // Use a kind that no other test writes, so we don't receive stale events.
-    let filter = Filter::new().kind(Kind::Custom(49999));
-    client
-        .subscribe(&overflow_sid, vec![filter])
-        .await
-        .expect("send REQ");
-
-    // Drain EOSE and stale events from the 100 earlier subscriptions
-    // until we receive the CLOSED for the overflow subscription.
-    let msg = loop {
-        let m = client
-            .recv_event(Duration::from_secs(5))
+    let filter = Filter::new().kind(Kind::Custom(49_999));
+    loop {
+        client
+            .subscribe(&overflow_sid, vec![filter.clone()])
             .await
-            .expect("recv CLOSED (or timeout)");
-        match &m {
-            RelayMessage::Eose { .. } => continue,
-            RelayMessage::Event { .. } => continue, // stale event from earlier subs
-            _ => break m,
-        }
-    };
+            .expect("send overflow REQ");
 
-    match msg {
-        RelayMessage::Closed {
-            subscription_id,
-            message,
-        } => {
-            assert_eq!(subscription_id, overflow_sid);
-            assert!(
-                message.to_lowercase().contains("too many"),
-                "Expected 'too many' in CLOSED message, got: {message}"
-            );
+        match client
+            .recv_event(Duration::from_secs(6))
+            .await
+            .expect("recv overflow CLOSED")
+        {
+            RelayMessage::Closed {
+                subscription_id,
+                message,
+            } if subscription_id == overflow_sid && message.starts_with("rate-limited:") => {
+                tokio::time::sleep(Duration::from_secs(5)).await;
+            }
+            RelayMessage::Closed {
+                subscription_id,
+                message,
+            } => {
+                assert_eq!(subscription_id, overflow_sid);
+                assert!(
+                    message.to_lowercase().contains("too many"),
+                    "Expected 'too many' in CLOSED message, got: {message}"
+                );
+                break;
+            }
+            other => panic!("Expected CLOSED for overflow subscription, got {other:?}"),
         }
-        other => panic!("Expected CLOSED for overflow subscription, got {other:?}"),
     }
 
     client.disconnect().await.expect("disconnect");
 }
 
+async fn subscribe_until_eose(client: &mut BuzzTestClient, sid: &str, filter: Filter) {
+    loop {
+        client
+            .subscribe(sid, vec![filter.clone()])
+            .await
+            .expect("subscribe");
+        match client
+            .recv_event(Duration::from_secs(6))
+            .await
+            .expect("EOSE or rate-limit CLOSED")
+        {
+            RelayMessage::Eose { subscription_id } => {
+                assert_eq!(subscription_id, sid);
+                return;
+            }
+            RelayMessage::Closed {
+                subscription_id,
+                message,
+            } if subscription_id == sid && message.starts_with("rate-limited:") => {
+                tokio::time::sleep(Duration::from_secs(5)).await;
+            }
+            other => panic!("unexpected response while opening {sid}: {other:?}"),
+        }
+    }
+}
+
 #[tokio::test]
 #[ignore]
 async fn test_nip11_relay_info() {
diff --git a/crates/buzz-workflow/Cargo.toml b/crates/buzz-workflow/Cargo.toml
index d4813e56d42..7d361b1477a 100644
--- a/crates/buzz-workflow/Cargo.toml
+++ b/crates/buzz-workflow/Cargo.toml
@@ -10,6 +10,7 @@ description = "YAML-as-code workflow engine for Buzz"
 [dependencies]
 buzz-core = { workspace = true }
 buzz-db   = { workspace = true }
+buzz-deletion = { workspace = true }
 hex         = { workspace = true }
 serde       = { workspace = true }
 serde_json  = { workspace = true }
diff --git a/crates/buzz-workflow/src/executor.rs b/crates/buzz-workflow/src/executor.rs
index e30541377e4..dffa4927168 100644
--- a/crates/buzz-workflow/src/executor.rs
+++ b/crates/buzz-workflow/src/executor.rs
@@ -526,165 +526,202 @@ pub async fn dispatch_action(
 ) -> Result<StepResult, WorkflowError> {
     use ActionDef::*;
 
-    match action {
-        SendMessage { text, channel } => {
-            // Look up workflow metadata for destination validation and
-            // attribution, scoped to the run's community — the same run/workflow
-            // UUID may exist in another community, so a bare-id lookup could
-            // load the wrong row and drive a side effect under it.
-            let wf_run = engine
-                .db
-                .get_workflow_run(community_id, run_id)
-                .await
-                .map_err(|e| {
-                    WorkflowError::WebhookError(format!(
-                        "SendMessage: failed to load workflow run {run_id}: {e}"
-                    ))
-                })?;
-            let workflow = engine
-                .db
-                .get_workflow(community_id, wf_run.workflow_id)
-                .await
-                .map_err(|e| {
-                    WorkflowError::WebhookError(format!(
-                        "SendMessage: failed to load workflow {}: {e}",
-                        wf_run.workflow_id
-                    ))
-                })?;
-            let channel_id = resolve_send_message_channel(
-                channel.as_deref(),
-                &trigger_ctx.channel_id,
-                workflow.channel_id,
-            )?;
-            let owner_pubkey_hex = hex::encode(&workflow.owner_pubkey);
-
-            info!(
-                run_id = %run_id,
-                step = step_id,
-                channel = %channel_id,
-                "SendMessage → {channel_id}: {text}"
-            );
-
-            let event_id = engine
-                .action_sink()?
-                .send_message(community_id, &channel_id, text, &owner_pubkey_hex)
-                .await
-                .map_err(WorkflowError::from)?;
-
-            Ok(StepResult::Completed(serde_json::json!({
-                "sent": true,
-                "event_id": event_id,
-            })))
-        }
-
-        SendDm { to, text: _ } => {
-            warn!(run_id = %run_id, step = step_id, "SendDm not yet implemented (to={to})");
-            // TODO (WF-07): emit DM event.
-            Err(WorkflowError::NotImplemented("SendDm".into()))
-        }
-
-        SetChannelTopic { topic: _ } => {
-            warn!(run_id = %run_id, step = step_id, "SetChannelTopic not yet implemented");
-            // TODO (WF-07): update channel topic via DB.
-            Err(WorkflowError::NotImplemented("SetChannelTopic".into()))
-        }
-
-        AddReaction { emoji } => {
-            info!(run_id = %run_id, step = step_id, "AddReaction → :{emoji}:");
-            if trigger_ctx.message_id.is_empty() {
-                return Err(WorkflowError::InvalidDefinition(
-                    "AddReaction: no trigger.message_id available".into(),
-                ));
-            }
-
-            #[cfg(feature = "reqwest")]
-            {
-                let result = add_reaction_impl(&trigger_ctx.message_id, emoji).await?;
-                Ok(StepResult::Completed(result))
-            }
-
-            #[cfg(not(feature = "reqwest"))]
-            {
-                warn!(
-                    run_id = %run_id,
-                    step = step_id,
-                    "AddReaction: reqwest feature not enabled, skipping HTTP call"
-                );
-                Ok(StepResult::Completed(
-                    serde_json::json!({ "added": false, "skipped": true }),
+    // The workflow engine can outlive the serving request that spawned it.
+    // Revalidate the durable community fence immediately before every external
+    // side effect (message publish, webhook, delay/resume). A storage failure is
+    // a denial, never permission to continue.
+    let serving_write =
+        buzz_deletion::acquire_serving_write(&engine.db, community_id, "workflow_action")
+            .await
+            .map_err(|error| {
+                WorkflowError::WebhookError(format!(
+                    "community write fence rejected workflow side effect: {error}"
                 ))
-            }
-        }
+            })?;
 
-        CallWebhook {
-            url,
-            method,
-            headers,
-            body,
-        } => {
-            let method_str = method.as_deref().unwrap_or("POST");
-            info!(run_id = %run_id, step = step_id, "CallWebhook → {method_str} {url}");
+    serving_write.verify().await.map_err(|error| {
+        WorkflowError::WebhookError(format!("community write lease lost: {error}"))
+    })?;
 
-            #[cfg(feature = "reqwest")]
-            {
-                let result = call_webhook_impl(url, method_str, headers, body).await?;
-                Ok(StepResult::Completed(result))
-            }
+    let result = serving_write
+        .protect(async {
+            match action {
+                SendMessage { text, channel } => {
+                    // Look up workflow metadata for destination validation and
+                    // attribution, scoped to the run's community — the same run/workflow
+                    // UUID may exist in another community, so a bare-id lookup could
+                    // load the wrong row and drive a side effect under it.
+                    let wf_run = engine
+                        .db
+                        .get_workflow_run(community_id, run_id)
+                        .await
+                        .map_err(|e| {
+                            WorkflowError::WebhookError(format!(
+                                "SendMessage: failed to load workflow run {run_id}: {e}"
+                            ))
+                        })?;
+                    let workflow = engine
+                        .db
+                        .get_workflow(community_id, wf_run.workflow_id)
+                        .await
+                        .map_err(|e| {
+                            WorkflowError::WebhookError(format!(
+                                "SendMessage: failed to load workflow {}: {e}",
+                                wf_run.workflow_id
+                            ))
+                        })?;
+                    let channel_id = resolve_send_message_channel(
+                        channel.as_deref(),
+                        &trigger_ctx.channel_id,
+                        workflow.channel_id,
+                    )?;
+                    let owner_pubkey_hex = hex::encode(&workflow.owner_pubkey);
+
+                    info!(
+                        run_id = %run_id,
+                        step = step_id,
+                        channel = %channel_id,
+                        "SendMessage → {channel_id}: {text}"
+                    );
+
+                    let event_id = engine
+                        .action_sink()?
+                        .send_message(community_id, &channel_id, text, &owner_pubkey_hex)
+                        .await
+                        .map_err(WorkflowError::from)?;
+
+                    Ok(StepResult::Completed(serde_json::json!({
+                        "sent": true,
+                        "event_id": event_id,
+                    })))
+                }
 
-            #[cfg(not(feature = "reqwest"))]
-            {
-                // reqwest not enabled — log and return placeholder.
-                warn!(
-                    run_id = %run_id, step = step_id,
-                    "CallWebhook: reqwest feature not enabled, skipping HTTP call"
-                );
-                let _ = (headers, body); // suppress unused warnings
-                Ok(StepResult::Completed(serde_json::json!({
-                    "status": 0,
-                    "body": null,
-                    "skipped": true
-                })))
-            }
-        }
+                SendDm { to, text: _ } => {
+                    warn!(run_id = %run_id, step = step_id, "SendDm not yet implemented (to={to})");
+                    // TODO (WF-07): emit DM event.
+                    Err(WorkflowError::NotImplemented("SendDm".into()))
+                }
 
-        RequestApproval {
-            from,
-            message,
-            timeout,
-        } => {
-            let timeout_str = timeout.as_deref().unwrap_or("24h");
-            info!(
-                run_id = %run_id, step = step_id,
-                "RequestApproval from={from} timeout={timeout_str}: {message}"
-            );
+                SetChannelTopic { topic: _ } => {
+                    warn!(run_id = %run_id, step = step_id, "SetChannelTopic not yet implemented");
+                    // TODO (WF-07): update channel topic via DB.
+                    Err(WorkflowError::NotImplemented("SetChannelTopic".into()))
+                }
+
+                AddReaction { emoji } => {
+                    info!(run_id = %run_id, step = step_id, "AddReaction → :{emoji}:");
+                    if trigger_ctx.message_id.is_empty() {
+                        Err(WorkflowError::InvalidDefinition(
+                            "AddReaction: no trigger.message_id available".into(),
+                        ))
+                    } else {
+                        #[cfg(feature = "reqwest")]
+                        {
+                            let result = add_reaction_impl(&trigger_ctx.message_id, emoji).await?;
+                            Ok(StepResult::Completed(result))
+                        }
+
+                        #[cfg(not(feature = "reqwest"))]
+                        {
+                            warn!(
+                                run_id = %run_id,
+                                step = step_id,
+                                "AddReaction: reqwest feature not enabled, skipping HTTP call"
+                            );
+                            Ok(StepResult::Completed(
+                                serde_json::json!({ "added": false, "skipped": true }),
+                            ))
+                        }
+                    }
+                }
 
-            let token = generate_approval_token(run_id, step_id);
+                CallWebhook {
+                    url,
+                    method,
+                    headers,
+                    body,
+                } => {
+                    let method_str = method.as_deref().unwrap_or("POST");
+                    info!(run_id = %run_id, step = step_id, "CallWebhook → {method_str} {url}");
+
+                    #[cfg(feature = "reqwest")]
+                    {
+                        let result = call_webhook_impl(url, method_str, headers, body).await?;
+                        Ok(StepResult::Completed(result))
+                    }
 
-            // TODO (WF-08): create approval record in DB, emit kind:46010.
-            // For now, return Suspended with the token so the caller can persist state.
+                    #[cfg(not(feature = "reqwest"))]
+                    {
+                        // reqwest not enabled — log and return placeholder.
+                        warn!(
+                            run_id = %run_id, step = step_id,
+                            "CallWebhook: reqwest feature not enabled, skipping HTTP call"
+                        );
+                        let _ = (headers, body); // suppress unused warnings
+                        Ok(StepResult::Completed(serde_json::json!({
+                            "status": 0,
+                            "body": null,
+                            "skipped": true
+                        })))
+                    }
+                }
 
-            Ok(StepResult::Suspended {
-                approval_token: token,
-            })
-        }
+                RequestApproval {
+                    from,
+                    message,
+                    timeout,
+                } => {
+                    let timeout_str = timeout.as_deref().unwrap_or("24h");
+                    info!(
+                        run_id = %run_id, step = step_id,
+                        "RequestApproval from={from} timeout={timeout_str}: {message}"
+                    );
+
+                    let token = generate_approval_token(run_id, step_id);
+
+                    // TODO (WF-08): create approval record in DB, emit kind:46010.
+                    // For now, return Suspended with the token so the caller can persist state.
+
+                    Ok(StepResult::Suspended {
+                        approval_token: token,
+                    })
+                }
 
-        Delay { duration } => {
-            let secs = parse_duration_secs(duration)?;
-            // Cap delay at 270 seconds (4.5 minutes) — must be less than default_timeout_secs (300s)
-            // to avoid non-deterministic StepTimeout. Long delays (hours/days)
-            // should use the scheduled resume pattern (future work: WF-09).
-            const MAX_DELAY_SECS: u64 = 270;
-            if secs > MAX_DELAY_SECS {
-                return Err(WorkflowError::InvalidDefinition(format!(
-                    "delay exceeds maximum of {MAX_DELAY_SECS} seconds (got {secs}s); \
+                Delay { duration } => {
+                    let secs = parse_duration_secs(duration)?;
+                    // Cap delay at 270 seconds (4.5 minutes) — must be less than default_timeout_secs (300s)
+                    // to avoid non-deterministic StepTimeout. Long delays (hours/days)
+                    // should use the scheduled resume pattern (future work: WF-09).
+                    const MAX_DELAY_SECS: u64 = 270;
+                    if secs > MAX_DELAY_SECS {
+                        return Err(WorkflowError::InvalidDefinition(format!(
+                            "delay exceeds maximum of {MAX_DELAY_SECS} seconds (got {secs}s); \
                      use the scheduled resume pattern for long delays"
-                )));
+                        )));
+                    }
+                    info!(run_id = %run_id, step = step_id, "Delay {duration} ({secs}s)");
+                    tokio::time::sleep(std::time::Duration::from_secs(secs)).await;
+                    Ok(StepResult::Completed(
+                        serde_json::json!({ "slept_secs": secs }),
+                    ))
+                }
             }
-            info!(run_id = %run_id, step = step_id, "Delay {duration} ({secs}s)");
-            tokio::time::sleep(std::time::Duration::from_secs(secs)).await;
-            Ok(StepResult::Completed(
-                serde_json::json!({ "slept_secs": secs }),
-            ))
+        })
+        .await
+        .map_err(|error| {
+            WorkflowError::WebhookError(format!("community write lease lost: {error}"))
+        })?;
+    let release = serving_write.finish().await.map_err(|error| {
+        WorkflowError::WebhookError(format!("community write lease release failed: {error}"))
+    });
+    match result {
+        Ok(value) => {
+            release?;
+            Ok(value)
+        }
+        Err(error) => {
+            let _ = release;
+            Err(error)
         }
     }
 }
diff --git a/deploy/charts/buzz/README.md b/deploy/charts/buzz/README.md
index b2778df28b5..86989676604 100644
--- a/deploy/charts/buzz/README.md
+++ b/deploy/charts/buzz/README.md
@@ -62,9 +62,15 @@ Buzz uses one URL style for both media and Git/CAS object-store requests:
 | `virtual` | `https://bucket.endpoint/key` | AWS-style providers and new Railway Storage Buckets |
 
 The chart always renders `s3.addressingStyle` as
-`BUZZ_S3_ADDRESSING_STYLE`. It renders `s3.region` as `BUZZ_S3_REGION` only
-when explicitly set, preserving the relay's existing `AWS_REGION` fallback for
-upgrades. Only `path` and `virtual` addressing styles are accepted; invalid
+`BUZZ_S3_ADDRESSING_STYLE` and `s3.region` as `BUZZ_S3_REGION`. The region
+defaults to `us-east-1`, keeping bundled MinIO and the in-pod
+`buzz-admin deletions` workflow operable without an ambient `AWS_REGION`.
+Production providers must set their credential region explicitly when it
+differs. Existing releases that previously omitted `s3.region` will begin
+rendering `BUZZ_S3_REGION=us-east-1` after upgrade, even if an image or
+`relay.extraEnv` entry supplied `AWS_REGION`; set `s3.region` to the provider's
+actual credential region before upgrading. Only `path` and `virtual` addressing
+styles are accepted; invalid
 values fail chart rendering and relay startup. The bundled MinIO quickstart
 deliberately keeps `path` because its Service DNS resolves one endpoint
 hostname, not arbitrary `<bucket>.<service>` names.
diff --git a/deploy/charts/buzz/templates/deployment.yaml b/deploy/charts/buzz/templates/deployment.yaml
index 0ad41ac4611..451ebb1cded 100644
--- a/deploy/charts/buzz/templates/deployment.yaml
+++ b/deploy/charts/buzz/templates/deployment.yaml
@@ -170,9 +170,7 @@ spec:
             - { name: BUZZ_S3_ENDPOINT, value: {{ $s3Endpoint | quote }} }
             {{- end }}
             - { name: BUZZ_S3_BUCKET, value: {{ .Values.s3.bucket | quote }} }
-            {{- if .Values.s3.region }}
             - { name: BUZZ_S3_REGION, value: {{ .Values.s3.region | quote }} }
-            {{- end }}
             - { name: BUZZ_S3_ADDRESSING_STYLE, value: {{ .Values.s3.addressingStyle | quote }} }
 
             # ── Secrets (from chart-managed or existing) ─────────────
diff --git a/deploy/charts/buzz/tests/render_test.yaml b/deploy/charts/buzz/tests/render_test.yaml
index 196a4a53032..10a1a34d1fd 100644
--- a/deploy/charts/buzz/tests/render_test.yaml
+++ b/deploy/charts/buzz/tests/render_test.yaml
@@ -30,11 +30,11 @@ tests:
           path: kind
           value: Service
         template: templates/service.yaml
-      - notContains:
+      - contains:
           path: spec.template.spec.containers[0].env
           content:
             name: BUZZ_S3_REGION
-          any: true
+            value: "us-east-1"
         template: templates/deployment.yaml
       - contains:
           path: spec.template.spec.containers[0].env
diff --git a/deploy/charts/buzz/values.schema.json b/deploy/charts/buzz/values.schema.json
index d3670595b5b..94d369c8903 100644
--- a/deploy/charts/buzz/values.schema.json
+++ b/deploy/charts/buzz/values.schema.json
@@ -200,7 +200,8 @@
         "bucket": { "type": "string", "minLength": 1 },
         "region": {
           "type": "string",
-          "description": "Optional S3 region used for SigV4 signing. When empty, BUZZ_S3_REGION is omitted so the relay can use AWS_REGION or its own default."
+          "minLength": 1,
+          "description": "S3 region used for SigV4 signing by the relay and deletion operator. Defaults to us-east-1 for bundled MinIO/local deployments; set the provider region explicitly when it differs."
         },
         "addressingStyle": {
           "type": "string",
diff --git a/deploy/charts/buzz/values.yaml b/deploy/charts/buzz/values.yaml
index 8131aef4321..ca3403a633f 100644
--- a/deploy/charts/buzz/values.yaml
+++ b/deploy/charts/buzz/values.yaml
@@ -342,9 +342,10 @@ externalRedis:
 s3:
   endpoint: ""
   bucket: "buzz-media"
-  # Optional SigV4 signing region. Leave empty to preserve the relay's
-  # AWS_REGION fallback; set the provider's credential value when needed.
-  region: ""
+  # SigV4 signing region shared by the relay and `buzz-admin deletions`.
+  # Keep the MinIO/local default operable; production providers should set
+  # their credential region explicitly when it differs.
+  region: "us-east-1"
   # path: https://endpoint/bucket/key (bundled MinIO-compatible default)
   # virtual: https://bucket.endpoint/key (standard S3; required by new Railway buckets)
   addressingStyle: path
diff --git a/desktop/package.json b/desktop/package.json
index 0c1fb137339..3601f25185e 100644
--- a/desktop/package.json
+++ b/desktop/package.json
@@ -1,7 +1,7 @@
 {
   "name": "buzz",
   "private": true,
-  "version": "0.5.10",
+  "version": "0.5.11",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/desktop/playwright.config.ts b/desktop/playwright.config.ts
index a9ec17a249f..e930f0ef612 100644
--- a/desktop/playwright.config.ts
+++ b/desktop/playwright.config.ts
@@ -77,6 +77,7 @@ export default defineConfig({
         "**/relay-connectivity.spec.ts",
         "**/unread-pill.spec.ts",
         "**/sidebar-more-unread-overlap.spec.ts",
+        "**/sidebar-snapshot.spec.ts",
         "**/home-collapsed-top-chrome.spec.ts",
         "**/top-chrome-zoom-clearance.spec.ts",
         "**/thread-unread.spec.ts",
diff --git a/desktop/src-tauri/Cargo.lock b/desktop/src-tauri/Cargo.lock
index 9833847ece5..6c206264679 100644
--- a/desktop/src-tauri/Cargo.lock
+++ b/desktop/src-tauri/Cargo.lock
@@ -210,7 +210,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -221,7 +221,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1084,7 +1084,7 @@ dependencies = [
 
 [[package]]
 name = "buzz-desktop"
-version = "0.5.10"
+version = "0.5.11"
 dependencies = [
  "anyhow",
  "arboard",
@@ -1627,7 +1627,7 @@ version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2305,7 +2305,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccc2776f0c61eca1ca32528f85548abd1a4be8fb53d1b21c013e4f18da1e7090"
 dependencies = [
  "data-encoding",
- "syn 2.0.118",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -2483,7 +2483,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2764,7 +2764,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3282,7 +3282,7 @@ dependencies = [
  "libc",
  "log",
  "rustversion",
- "windows-link 0.2.1",
+ "windows-link 0.1.3",
  "windows-result 0.4.1",
 ]
 
@@ -5777,7 +5777,7 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "536bfad37a309d62069485248eeaba1e8d9853aaf951caaeaed0585a95346f08"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -5936,7 +5936,7 @@ dependencies = [
  "png 0.18.1",
  "serde",
  "thiserror 2.0.18",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -6449,7 +6449,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -7153,7 +7153,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
@@ -8179,7 +8179,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -8920,7 +8920,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -8990,7 +8990,7 @@ dependencies = [
  "security-framework 3.7.0",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -9257,7 +9257,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b55fb86dfd3a2f5f76ea78310a88f96c4ea21a3031f8d212443d56123fd0521"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -9897,7 +9897,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -10991,10 +10991,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom 0.4.3",
+ "getrandom 0.3.4",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -11016,7 +11016,7 @@ dependencies = [
  "parking_lot",
  "rustix 1.1.4",
  "signal-hook 0.3.18",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -11758,7 +11758,7 @@ dependencies = [
  "png 0.18.1",
  "serde",
  "thiserror 2.0.18",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -11859,7 +11859,7 @@ checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
 dependencies = [
  "memoffset",
  "tempfile",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -12470,15 +12470,15 @@ dependencies = [
 
 [[package]]
 name = "webbrowser"
-version = "1.2.1"
+version = "1.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fc95580916af1e68ff6a7be07446fc5db73ebf71cf092de939bbf5f7e189f72"
+checksum = "62c35be770821a214dbc362fc26908c853e776c0004294d0b10b8a6bad582f94"
 dependencies = [
- "core-foundation 0.10.1",
  "jni 0.22.4",
  "log",
  "ndk-context",
  "objc2",
+ "objc2-app-kit",
  "objc2-foundation",
  "url",
  "web-sys",
@@ -12710,7 +12710,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
diff --git a/desktop/src-tauri/Cargo.toml b/desktop/src-tauri/Cargo.toml
index 31092de99a9..54676458737 100644
--- a/desktop/src-tauri/Cargo.toml
+++ b/desktop/src-tauri/Cargo.toml
@@ -7,7 +7,7 @@ members = ["crates/buzz-terminal"]
 
 [package]
 name = "buzz-desktop"
-version = "0.5.10"
+version = "0.5.11"
 description = "Buzz desktop app"
 authors = ["you"]
 edition = "2021"
diff --git a/desktop/src-tauri/src/commands/agent_models_databricks.rs b/desktop/src-tauri/src/commands/agent_models_databricks.rs
index 63b4564e61d..4b6e512c059 100644
--- a/desktop/src-tauri/src/commands/agent_models_databricks.rs
+++ b/desktop/src-tauri/src/commands/agent_models_databricks.rs
@@ -1,7 +1,8 @@
 //! Databricks v1/v2 model discovery and interactive reauthentication.
 
-use std::collections::BTreeMap;
-use std::sync::LazyLock;
+use std::collections::{BTreeMap, HashMap};
+use std::sync::{LazyLock, Mutex, MutexGuard};
+use std::time::{Duration, Instant};
 
 use crate::commands::agent_models_env::{
     env_or_process_value, redaction_env_with_value, DiscoveryProvider,
@@ -13,6 +14,77 @@ use crate::managed_agents::AgentModelsResponse;
 // callback listener/browser flow for the process-wide OAuth cache.
 static AUTH_GATE: LazyLock<tokio::sync::Mutex<()>> = LazyLock::new(|| tokio::sync::Mutex::new(()));
 
+// Hard cap on the interactive browser flow launched from a discovery surface.
+// An abandoned SSO tab must fail discovery cleanly rather than wedge the
+// dropdown forever. (`authenticate_databricks` has its own 60s callback wait;
+// this outer bound also covers endpoint discovery and token exchange.)
+const AUTH_FLOW_TIMEOUT: Duration = Duration::from_secs(150);
+
+// How long a failed/cancelled interactive sign-in suppresses re-launching the
+// browser from passive surfaces.
+pub(super) const AUTH_COOLDOWN: Duration = Duration::from_secs(5 * 60);
+
+/// Per-host record of a recently failed, cancelled, or timed-out interactive
+/// sign-in.
+///
+/// Passive discovery surfaces fire on every form-state change, so without this
+/// a cancelled SSO page would re-pop the browser on the very next keystroke.
+/// Entries expire so a genuine later retry still launches; the saved-model
+/// picker bypasses the cooldown and a success clears it.
+#[derive(Default)]
+pub(super) struct AuthCooldown {
+    until: Mutex<HashMap<String, Instant>>,
+}
+
+impl AuthCooldown {
+    fn map(&self) -> MutexGuard<'_, HashMap<String, Instant>> {
+        // The critical sections below are panic-free map ops, so recover from a
+        // poisoned lock rather than wedge every future sign-in on one panic.
+        self.until
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+    }
+
+    pub(super) fn is_active(&self, host: &str, now: Instant) -> bool {
+        let mut map = self.map();
+        match map.get(host) {
+            Some(&expiry) if now < expiry => true,
+            Some(_) => {
+                map.remove(host);
+                false
+            }
+            None => false,
+        }
+    }
+
+    pub(super) fn record(&self, host: &str, now: Instant) {
+        self.map().insert(host.to_string(), now + AUTH_COOLDOWN);
+    }
+
+    pub(super) fn clear(&self, host: &str) {
+        self.map().remove(host);
+    }
+
+    /// Whether the interactive browser flow may launch now under `auth_intent`.
+    /// Passive surfaces are suppressed while a per-host cooldown is active; the
+    /// explicit picker path always launches and clears any stale suppression.
+    pub(super) fn permits_launch(
+        &self,
+        auth_intent: DatabricksAuthIntent,
+        host: &str,
+        now: Instant,
+    ) -> bool {
+        if auth_intent.respects_cooldown() {
+            !self.is_active(host, now)
+        } else {
+            self.clear(host);
+            true
+        }
+    }
+}
+
+static AUTH_COOLDOWNS: LazyLock<AuthCooldown> = LazyLock::new(AuthCooldown::default);
+
 pub(super) fn is_databricks_provider(provider: Option<&str>) -> bool {
     matches!(
         provider
@@ -50,8 +122,14 @@ pub(super) enum DatabricksAuthIntent {
 }
 
 impl DatabricksAuthIntent {
-    fn allows_interactive_auth(self) -> bool {
-        matches!(self, Self::InteractiveModelPicker)
+    /// Passive draft discovery honors (and, on failure, writes) the per-host
+    /// cooldown so a cancelled SSO page does not re-pop on the next form
+    /// keystroke. The saved-model picker is an explicit user action, so it
+    /// bypasses the cooldown and clears it before launching. Both surfaces
+    /// launch the browser flow (Phase 2 goose-parity); this predicate is the
+    /// only behavioral difference between them.
+    fn respects_cooldown(self) -> bool {
+        matches!(self, Self::PassiveDraftDiscovery)
     }
 }
 
@@ -60,11 +138,16 @@ pub(super) fn databricks_sign_in_required_error() -> String {
         .to_string()
 }
 
-pub(super) fn should_start_interactive_auth(
-    api_key: &str,
-    auth_intent: DatabricksAuthIntent,
-) -> bool {
-    api_key.is_empty() && auth_intent.allows_interactive_auth()
+pub(super) fn databricks_sign_in_timed_out_error() -> String {
+    "Databricks sign-in timed out; open the model picker to retry, or run `buzz-agent auth databricks`"
+        .to_string()
+}
+
+pub(super) fn should_start_interactive_auth(api_key: &str) -> bool {
+    // Phase 2: both discovery surfaces launch the browser flow when no static
+    // token is configured. Which surface is allowed to actually pop the browser
+    // (vs. respect a cooldown) is decided via `AuthCooldown::permits_launch`.
+    api_key.is_empty()
 }
 
 pub(super) async fn discover_databricks_models(
@@ -93,22 +176,26 @@ pub(super) async fn discover_databricks_models(
 
     let entries = match buzz_agent_pkg::discover_databricks_models(&config).await {
         Ok(entries) => entries,
-        Err(buzz_agent_pkg::AgentError::LlmAuth(_))
-            if should_start_interactive_auth(&api_key, auth_intent) =>
-        {
+        Err(buzz_agent_pkg::AgentError::LlmAuth(_)) if should_start_interactive_auth(&api_key) => {
             let _auth = AUTH_GATE.lock().await;
             match buzz_agent_pkg::discover_databricks_models(&config).await {
+                // A peer sign-in under the gate already succeeded.
                 Ok(entries) => entries,
                 Err(buzz_agent_pkg::AgentError::LlmAuth(_)) => {
-                    buzz_agent_pkg::authenticate_databricks(&host)
-                        .await
-                        .map_err(|error| {
-                            format_redacted_error(
-                                "Databricks sign-in failed",
-                                &error,
-                                &redaction_env,
-                            )
-                        })?;
+                    // Passive surfaces suppress the browser while a recent
+                    // failure/cancel is cooling down; the explicit picker path
+                    // always launches (and clears any stale cooldown).
+                    if !AUTH_COOLDOWNS.permits_launch(auth_intent, &host, Instant::now()) {
+                        return Err(databricks_sign_in_required_error());
+                    }
+                    run_interactive_databricks_auth(
+                        buzz_agent_pkg::authenticate_databricks(&host),
+                        AUTH_FLOW_TIMEOUT,
+                        &AUTH_COOLDOWNS,
+                        &host,
+                        &redaction_env,
+                    )
+                    .await?;
                     buzz_agent_pkg::discover_databricks_models(&config)
                         .await
                         .map_err(|error| {
@@ -172,3 +259,43 @@ fn format_redacted_error(
     let message = crate::managed_agents::redact_env_values_in(&error.to_string(), redaction_env);
     format!("{context}: {message}")
 }
+
+/// Run the interactive browser OAuth flow under a hard timeout and maintain the
+/// per-host cooldown. Success clears the cooldown; a failure, cancel, or
+/// timeout records it so passive surfaces stop re-launching the browser on the
+/// next form keystroke. `timeout` is injected (production passes
+/// [`AUTH_FLOW_TIMEOUT`]) so the timeout/cooldown policy is unit-testable
+/// without a live browser.
+pub(super) async fn run_interactive_databricks_auth<Fut>(
+    auth: Fut,
+    timeout: Duration,
+    cooldowns: &AuthCooldown,
+    host: &str,
+    redaction_env: &BTreeMap<String, String>,
+) -> Result<(), String>
+where
+    Fut: std::future::Future<Output = Result<(), buzz_agent_pkg::AgentError>>,
+{
+    match tokio::time::timeout(timeout, auth).await {
+        Ok(Ok(())) => {
+            cooldowns.clear(host);
+            Ok(())
+        }
+        Ok(Err(error)) => {
+            cooldowns.record(host, Instant::now());
+            Err(format_redacted_error(
+                "Databricks sign-in failed",
+                &error,
+                redaction_env,
+            ))
+        }
+        Err(_elapsed) => {
+            cooldowns.record(host, Instant::now());
+            Err(databricks_sign_in_timed_out_error())
+        }
+    }
+}
+
+#[cfg(test)]
+#[path = "agent_models_databricks_tests.rs"]
+mod tests;
diff --git a/desktop/src-tauri/src/commands/agent_models_databricks_tests.rs b/desktop/src-tauri/src/commands/agent_models_databricks_tests.rs
new file mode 100644
index 00000000000..cb530ec59bd
--- /dev/null
+++ b/desktop/src-tauri/src/commands/agent_models_databricks_tests.rs
@@ -0,0 +1,109 @@
+//! Cooldown and interactive-auth policy tests for Databricks discovery.
+//!
+//! Housed as a child of `agent_models_databricks` (not the shared
+//! `agent_models_tests`) so the async timeout/cooldown cases sit next to the
+//! code they exercise and reach its `pub(super)` items directly via
+//! `use super::*` — and so the shared test file stays under its size ratchet.
+
+use super::*;
+
+#[test]
+fn databricks_cooldown_suppresses_passive_relaunch_but_never_the_picker() {
+    let cooldowns = AuthCooldown::default();
+    let host = "https://example.cloud.databricks.com";
+    let now = Instant::now();
+
+    // A fresh host permits either surface to launch.
+    assert!(cooldowns.permits_launch(DatabricksAuthIntent::PassiveDraftDiscovery, host, now));
+    assert!(cooldowns.permits_launch(DatabricksAuthIntent::InteractiveModelPicker, host, now));
+
+    // After a failed/cancelled attempt, passive discovery must NOT re-pop the
+    // browser while the window is active...
+    cooldowns.record(host, now);
+    assert!(!cooldowns.permits_launch(DatabricksAuthIntent::PassiveDraftDiscovery, host, now));
+
+    // ...but an explicit picker click always launches, and clears the window so
+    // a later passive read is unblocked too.
+    assert!(cooldowns.permits_launch(DatabricksAuthIntent::InteractiveModelPicker, host, now));
+    assert!(cooldowns.permits_launch(DatabricksAuthIntent::PassiveDraftDiscovery, host, now));
+}
+
+#[test]
+fn databricks_cooldown_expires_after_its_window_and_is_host_scoped() {
+    let cooldowns = AuthCooldown::default();
+    let host = "https://a.cloud.databricks.com";
+    let other = "https://b.cloud.databricks.com";
+    let now = Instant::now();
+
+    cooldowns.record(host, now);
+    // A cooldown on one host never suppresses another.
+    assert!(!cooldowns.is_active(other, now));
+    assert!(cooldowns.is_active(host, now));
+
+    // The window is closed the instant it elapses, so a genuine later retry
+    // launches again.
+    let after = now + AUTH_COOLDOWN;
+    assert!(!cooldowns.is_active(host, after));
+}
+
+#[tokio::test]
+async fn databricks_interactive_auth_success_clears_a_prior_cooldown() {
+    let cooldowns = AuthCooldown::default();
+    let host = "https://example.cloud.databricks.com";
+    let redaction = BTreeMap::new();
+    cooldowns.record(host, Instant::now());
+
+    let result = run_interactive_databricks_auth(
+        async { Ok(()) },
+        Duration::from_secs(150),
+        &cooldowns,
+        host,
+        &redaction,
+    )
+    .await;
+
+    assert!(result.is_ok());
+    assert!(!cooldowns.is_active(host, Instant::now()));
+}
+
+#[tokio::test]
+async fn databricks_interactive_auth_failure_records_a_cooldown() {
+    let cooldowns = AuthCooldown::default();
+    let host = "https://example.cloud.databricks.com";
+    let redaction = BTreeMap::new();
+
+    let result = run_interactive_databricks_auth(
+        async { Err(buzz_agent_pkg::AgentError::LlmAuth("closed the tab".into())) },
+        Duration::from_secs(150),
+        &cooldowns,
+        host,
+        &redaction,
+    )
+    .await;
+
+    let error = result.expect_err("a failed sign-in must surface an error");
+    assert!(error.contains("Databricks sign-in failed"));
+    assert!(cooldowns.is_active(host, Instant::now()));
+}
+
+#[tokio::test(start_paused = true)]
+async fn databricks_interactive_auth_timeout_records_cooldown_and_returns_timeout_copy() {
+    let cooldowns = AuthCooldown::default();
+    let host = "https://example.cloud.databricks.com";
+    let redaction = BTreeMap::new();
+
+    // An abandoned SSO tab: the flow never resolves. Under the paused clock the
+    // injected timeout fires deterministically without real waiting.
+    let result = run_interactive_databricks_auth(
+        std::future::pending::<Result<(), buzz_agent_pkg::AgentError>>(),
+        Duration::from_secs(150),
+        &cooldowns,
+        host,
+        &redaction,
+    )
+    .await;
+
+    let error = result.expect_err("a timed-out sign-in must surface an error");
+    assert_eq!(error, databricks_sign_in_timed_out_error());
+    assert!(cooldowns.is_active(host, Instant::now()));
+}
diff --git a/desktop/src-tauri/src/commands/agent_models_tests.rs b/desktop/src-tauri/src/commands/agent_models_tests.rs
index e7d0e70fd0b..6226acfd964 100644
--- a/desktop/src-tauri/src/commands/agent_models_tests.rs
+++ b/desktop/src-tauri/src/commands/agent_models_tests.rs
@@ -577,19 +577,12 @@ fn is_databricks_provider_matches_both_variants() {
 }
 
 #[test]
-fn databricks_interactive_auth_requires_explicit_intent_and_no_static_token() {
-    assert!(should_start_interactive_auth(
-        "",
-        DatabricksAuthIntent::InteractiveModelPicker
-    ));
-    assert!(!should_start_interactive_auth(
-        "",
-        DatabricksAuthIntent::PassiveDraftDiscovery
-    ));
-    assert!(!should_start_interactive_auth(
-        "static-token",
-        DatabricksAuthIntent::InteractiveModelPicker
-    ));
+fn databricks_interactive_auth_launches_only_without_a_static_token() {
+    // Phase 2: both surfaces launch the browser flow when the token is empty;
+    // the surface distinction is now cooldown-only (asserted separately). A
+    // configured static token still short-circuits interactive auth entirely.
+    assert!(should_start_interactive_auth(""));
+    assert!(!should_start_interactive_auth("static-token"));
 }
 
 #[test]
diff --git a/desktop/src-tauri/src/managed_agents/agent_env.rs b/desktop/src-tauri/src/managed_agents/agent_env.rs
index 05979e76cbf..59b300d9d17 100644
--- a/desktop/src-tauri/src/managed_agents/agent_env.rs
+++ b/desktop/src-tauri/src/managed_agents/agent_env.rs
@@ -8,6 +8,25 @@ use std::collections::BTreeMap;
 
 use base64::Engine as _;
 
+/// Seconds a woken lazy harness stays warm before it releases its worker
+/// subprocesses back to the empty-slot state (via `BUZZ_ACP_IDLE_POOL_SLEEP`).
+/// The next accepted event re-wakes it through the same lazy path. Matches the
+/// harness's own 15-minute per-turn idle window so a warm pool survives a
+/// normal back-and-forth but a truly quiet harness stops paying for workers.
+const IDLE_POOL_SLEEP_SECS: &str = "900";
+
+/// Value for `BUZZ_ACP_IDLE_POOL_SLEEP`. Idle re-sleep is only meaningful for
+/// lazy harnesses (the harness ignores it otherwise); gate to `lazy` here so
+/// the env reads inert (`"0"` = disabled) for eager harnesses. This is a
+/// desktop-owned lifetime policy (reserved key), not user-tunable.
+pub(super) fn idle_pool_sleep_env(lazy: bool) -> &'static str {
+    if lazy {
+        IDLE_POOL_SLEEP_SECS
+    } else {
+        "0"
+    }
+}
+
 /// Return the baked-in build-time env pairs as a map.
 ///
 /// Internal builds (buzz-releases) bake provider/model defaults and arbitrary
diff --git a/desktop/src-tauri/src/managed_agents/env_vars/tests.rs b/desktop/src-tauri/src/managed_agents/env_vars/tests.rs
index 34cdfede2c2..f3de11ad242 100644
--- a/desktop/src-tauri/src/managed_agents/env_vars/tests.rs
+++ b/desktop/src-tauri/src/managed_agents/env_vars/tests.rs
@@ -164,7 +164,11 @@ fn reserved_keys_include_respond_to_gate() {
 
 #[test]
 fn reserved_keys_include_remote_lifetime_policy() {
-    for key in ["BUZZ_ACP_EXIT_AFTER_INACTIVITY", "BUZZ_ACP_NO_PRESENCE"] {
+    for key in [
+        "BUZZ_ACP_EXIT_AFTER_INACTIVITY",
+        "BUZZ_ACP_IDLE_POOL_SLEEP",
+        "BUZZ_ACP_NO_PRESENCE",
+    ] {
         assert!(is_reserved_env_key(key), "{key} should be reserved");
         let agent = map(&[(key, "0")]);
         assert!(merged_user_env(&BTreeMap::new(), &agent).is_empty());
diff --git a/desktop/src-tauri/src/managed_agents/reserved_env_keys.rs b/desktop/src-tauri/src/managed_agents/reserved_env_keys.rs
index 8698d3a51d1..afaaa2b4eb3 100644
--- a/desktop/src-tauri/src/managed_agents/reserved_env_keys.rs
+++ b/desktop/src-tauri/src/managed_agents/reserved_env_keys.rs
@@ -59,6 +59,9 @@ pub(crate) const RESERVED_ENV_KEYS: &[&str] = &[
     // Remote lifetime/presence policy: user env must not disable the
     // desktop/provider-owned bounds while the saved record still promises them.
     "BUZZ_ACP_EXIT_AFTER_INACTIVITY",
+    // Desktop-owned pool lifetime policy: user env must not disable or reset
+    // the idle worker-reclamation window while the desktop launcher sets it.
+    "BUZZ_ACP_IDLE_POOL_SLEEP",
     "BUZZ_ACP_NO_PRESENCE",
     // Readiness handoff: desktop is the ONLY readiness source. A saved or
     // ambient env var must not be able to forge setup mode (NotReady) on a
diff --git a/desktop/src-tauri/src/managed_agents/runtime.rs b/desktop/src-tauri/src/managed_agents/runtime.rs
index d95c5954177..b1c342e9955 100644
--- a/desktop/src-tauri/src/managed_agents/runtime.rs
+++ b/desktop/src-tauri/src/managed_agents/runtime.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use tauri::AppHandle;
 
-use super::agent_env::build_buzz_agent_provider_defaults;
+use super::agent_env::{build_buzz_agent_provider_defaults, idle_pool_sleep_env};
 
 use crate::{
     managed_agents::{
@@ -531,6 +531,7 @@ pub fn spawn_agent_child(
     command.env("BUZZ_PRIVATE_KEY", &record.private_key_nsec);
     command.env("BUZZ_RELAY_URL", &effective_relay_url);
     command.env("BUZZ_ACP_LAZY_POOL", if lazy { "true" } else { "false" });
+    command.env("BUZZ_ACP_IDLE_POOL_SLEEP", idle_pool_sleep_env(lazy));
     command.env("BUZZ_ACP_AGENT_COMMAND", &resolved_agent_command);
     command.env("BUZZ_ACP_AGENT_ARGS", agent_args.join(","));
     match &resolved_mcp_command {
diff --git a/desktop/src-tauri/tauri.conf.json b/desktop/src-tauri/tauri.conf.json
index 856a2dbde73..643c69c2dd3 100644
--- a/desktop/src-tauri/tauri.conf.json
+++ b/desktop/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "BitcoinMarkets",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "identifier": "app.bitcoinmarkets.desktop",
   "build": {
     "beforeDevCommand": {
diff --git a/desktop/src/app/AppShell.tsx b/desktop/src/app/AppShell.tsx
index 73e40e8cd89..db10c12dc95 100644
--- a/desktop/src/app/AppShell.tsx
+++ b/desktop/src/app/AppShell.tsx
@@ -939,6 +939,7 @@ export function AppShell() {
                   onSelectChannel={(channelId) => {
                     void goChannel(channelId);
                   }}
+                  relayUrl={communitiesHook.activeCommunity?.relayUrl}
                 />
                 <SendFeedbackController
                   onOpenChange={setIsSendFeedbackOpen}
diff --git a/desktop/src/app/AppShellOverlays.tsx b/desktop/src/app/AppShellOverlays.tsx
index 9a856ba6b07..35edc84f788 100644
--- a/desktop/src/app/AppShellOverlays.tsx
+++ b/desktop/src/app/AppShellOverlays.tsx
@@ -15,6 +15,11 @@ const ChannelManagementSheet = React.lazy(async () => {
   return { default: module.ChannelManagementSheet };
 });
 
+const MembersSidebar = React.lazy(async () => {
+  const module = await import("@/features/channels/ui/MembersSidebar");
+  return { default: module.MembersSidebar };
+});
+
 export type BrowseDialogType = "stream" | "forum" | null;
 
 type AppShellOverlaysProps = {
@@ -30,6 +35,7 @@ type AppShellOverlaysProps = {
   onChannelManagementOpenChange: (open: boolean) => void;
   onDeleteActiveChannel: () => void;
   onSelectChannel: (channelId: string) => void;
+  relayUrl?: string;
 };
 
 export function AppShellOverlays({
@@ -45,7 +51,11 @@ export function AppShellOverlays({
   onChannelManagementOpenChange,
   onDeleteActiveChannel,
   onSelectChannel,
+  relayUrl,
 }: AppShellOverlaysProps) {
+  const [membersChannel, setMembersChannel] = React.useState<Channel | null>(
+    null,
+  );
   const [visibleBrowseDialogType, setVisibleBrowseDialogType] =
     React.useState<BrowseDialogType>(null);
   const { cancelDeferredModalOpen, openNextFrame: openModalNextFrame } =
@@ -89,11 +99,28 @@ export function AppShellOverlays({
             channel={activeChannel}
             currentPubkey={currentPubkey}
             onDeleted={onDeleteActiveChannel}
+            onOpenMembers={() => setMembersChannel(activeChannel)}
             onOpenChange={onChannelManagementOpenChange}
             open={true}
           />
         </React.Suspense>
       ) : null}
+
+      {membersChannel ? (
+        <React.Suspense fallback={null}>
+          <MembersSidebar
+            channel={membersChannel}
+            currentPubkey={currentPubkey}
+            onOpenChange={(nextOpen) => {
+              if (!nextOpen) {
+                setMembersChannel(null);
+              }
+            }}
+            open={true}
+            relayUrl={relayUrl}
+          />
+        </React.Suspense>
+      ) : null}
     </>
   );
 }
diff --git a/desktop/src/app/useAppShellLifecycleEffects.ts b/desktop/src/app/useAppShellLifecycleEffects.ts
index 2d56d24cb37..ae62ae3e224 100644
--- a/desktop/src/app/useAppShellLifecycleEffects.ts
+++ b/desktop/src/app/useAppShellLifecycleEffects.ts
@@ -1,6 +1,7 @@
 import * as React from "react";
 
 import { setDesktopAppBadge } from "@/features/notifications/lib/desktop";
+import { useForegroundQueryRefresh } from "@/features/workflows/hooks";
 import { relayClient } from "@/shared/api/relayClient";
 import { useRelayResumeTriggers } from "@/shared/api/useRelayResumeTriggers";
 
@@ -20,6 +21,7 @@ export function useAppShellLifecycleEffects({
   // Event-driven reconnect: network online / focus / visibility short-circuit
   // the backoff timer when the relay session is degraded (CMD+R gap G1).
   useRelayResumeTriggers();
+  useForegroundQueryRefresh();
 
   // Prevent webview file:/// navigation on file drop outside the composer.
   // Scoped to file drags only (text drag-and-drop into inputs still works).
diff --git a/desktop/src/features/agent-memory/ui/MemorySection.tsx b/desktop/src/features/agent-memory/ui/MemorySection.tsx
index cfc5ed7bd92..d63ceeb3cd9 100644
--- a/desktop/src/features/agent-memory/ui/MemorySection.tsx
+++ b/desktop/src/features/agent-memory/ui/MemorySection.tsx
@@ -10,6 +10,7 @@ import { Skeleton } from "@/shared/ui/skeleton";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 
 const MEMORY_LIST_PREVIEW_LIMIT = 3;
+type MemorySectionVariant = "cards" | "grouped";
 
 const MEMORY_TRUNCATED_TOOLTIP =
   "This list may be incomplete — the relay returned the maximum number of memories.";
@@ -41,15 +42,17 @@ const MEMORY_DANGLING_REF_TOOLTIP =
  */
 export function MemorySection({
   agentPubkey,
+  variant = "cards",
   viewerIsOwner,
 }: {
   agentPubkey: string;
+  variant?: MemorySectionVariant;
   viewerIsOwner: boolean;
 }): React.ReactElement | null {
   // Hide entirely for non-owners.
   if (!viewerIsOwner) return null;
 
-  return <MemorySectionForOwner agentPubkey={agentPubkey} />;
+  return <MemorySectionForOwner agentPubkey={agentPubkey} variant={variant} />;
 }
 
 export function MemoryRefreshButton({
@@ -92,7 +95,13 @@ export function MemoryRefreshButton({
   );
 }
 
-function MemorySectionForOwner({ agentPubkey }: { agentPubkey: string }) {
+function MemorySectionForOwner({
+  agentPubkey,
+  variant,
+}: {
+  agentPubkey: string;
+  variant: MemorySectionVariant;
+}) {
   const { query, graph } = useAgentMemoryGraph(agentPubkey);
 
   // Order matters here. We want:
@@ -107,13 +116,14 @@ function MemorySectionForOwner({ agentPubkey }: { agentPubkey: string }) {
 
   return (
     <section data-testid="agent-memory-section">
-      {showInitialSkeleton ? <MemorySkeleton /> : null}
+      {showInitialSkeleton ? <MemorySkeleton variant={variant} /> : null}
 
       {showInitialError ? (
         <MemoryErrorState
           error={query.error}
           onRetry={() => query.refetch()}
           retrying={query.isFetching}
+          variant={variant}
         />
       ) : null}
 
@@ -123,10 +133,17 @@ function MemorySectionForOwner({ agentPubkey }: { agentPubkey: string }) {
               still have prior data on screen. Distinct from the initial
               error state above. */}
           {query.isError && !query.isFetching ? (
-            <MemoryStaleErrorBanner onRetry={() => query.refetch()} />
+            <MemoryStaleErrorBanner
+              onRetry={() => query.refetch()}
+              variant={variant}
+            />
           ) : null}
 
-          <MemoryGraphView graph={graph} truncated={query.data.truncated} />
+          <MemoryGraphView
+            graph={graph}
+            truncated={query.data.truncated}
+            variant={variant}
+          />
         </>
       ) : null}
     </section>
@@ -135,11 +152,11 @@ function MemorySectionForOwner({ agentPubkey }: { agentPubkey: string }) {
 
 // ── Subviews ────────────────────────────────────────────────────────────────
 
-function MemorySkeleton() {
+function MemorySkeleton({ variant }: { variant: MemorySectionVariant }) {
   return (
     <div
       aria-label="Loading memory"
-      className="space-y-2"
+      className={cn("space-y-2", variant === "grouped" && "p-4")}
       data-testid="agent-memory-skeleton"
       role="status"
     >
@@ -154,16 +171,21 @@ function MemoryErrorState({
   error,
   onRetry,
   retrying,
+  variant,
 }: {
   error: unknown;
   onRetry: () => void;
   retrying: boolean;
+  variant: MemorySectionVariant;
 }) {
   const message =
     error instanceof Error ? error.message : String(error ?? "unknown error");
   return (
     <div
-      className="flex flex-col gap-2 rounded-md border border-destructive/30 bg-destructive/5 p-3 text-xs"
+      className={cn(
+        "flex flex-col gap-2 rounded-md border border-destructive/30 bg-destructive/5 p-3 text-xs",
+        variant === "grouped" && "m-3",
+      )}
       data-testid="agent-memory-error"
       role="alert"
     >
@@ -189,10 +211,19 @@ function MemoryErrorState({
   );
 }
 
-function MemoryStaleErrorBanner({ onRetry }: { onRetry: () => void }) {
+function MemoryStaleErrorBanner({
+  onRetry,
+  variant,
+}: {
+  onRetry: () => void;
+  variant: MemorySectionVariant;
+}) {
   return (
     <div
-      className="mb-2 flex items-center gap-2 rounded-md border border-warning/30 bg-warning/5 px-2 py-1.5 text-xs"
+      className={cn(
+        "mb-2 flex items-center gap-2 rounded-md border border-warning/30 bg-warning/5 px-2 py-1.5 text-xs",
+        variant === "grouped" && "mx-3 mt-3",
+      )}
       data-testid="agent-memory-stale-error"
     >
       <AlertTriangle className="h-4 w-4 shrink-0 text-warning" />
@@ -211,9 +242,11 @@ function MemoryStaleErrorBanner({ onRetry }: { onRetry: () => void }) {
 function MemoryGraphView({
   graph,
   truncated,
+  variant,
 }: {
   graph: NonNullable<ReturnType<typeof useAgentMemoryGraph>["graph"]>;
   truncated: boolean;
+  variant: MemorySectionVariant;
 }) {
   const { rootedTree, orphans, dangling } = graph;
   const [showAllEntries, setShowAllEntries] = React.useState(false);
@@ -250,10 +283,13 @@ function MemoryGraphView({
     : entries.slice(0, MEMORY_LIST_PREVIEW_LIMIT);
 
   return (
-    <div className="space-y-3">
+    <div className={variant === "grouped" ? undefined : "space-y-3"}>
       {!core && memories.length > 0 ? (
         <p
-          className="text-xs italic text-muted-foreground"
+          className={cn(
+            "text-xs italic text-muted-foreground",
+            variant === "grouped" && "px-4 py-3",
+          )}
           data-testid="agent-memory-no-core"
         >
           No <code className="font-mono text-2xs">core</code> memory yet — agent
@@ -261,12 +297,18 @@ function MemoryGraphView({
         </p>
       ) : null}
 
-      <div className="space-y-2" data-testid="agent-memory-list">
+      <div
+        className={cn(
+          variant === "grouped" ? "divide-y divide-border/55" : "space-y-2",
+        )}
+        data-testid="agent-memory-list"
+      >
         {visibleEntries.map((entry) => (
           <MemoryEntryAccordion
             danglingSlugs={danglingSlugs}
             entry={entry}
             key={entry.eventId}
+            variant={variant}
           />
         ))}
       </div>
@@ -276,14 +318,22 @@ function MemoryGraphView({
           count={entries.length}
           onClick={() => setShowAllEntries(true)}
           truncated={truncated}
+          variant={variant}
         />
       ) : null}
 
-      {truncated && !hasMoreEntries ? <MemoryTruncatedHint /> : null}
+      {truncated && !hasMoreEntries ? (
+        <MemoryTruncatedHint variant={variant} />
+      ) : null}
 
       {hasMoreEntries && showAllEntries ? (
         <button
-          className="flex w-full justify-center rounded-2xl bg-muted/40 px-4 py-3 text-sm font-medium text-foreground transition-colors hover:bg-muted/50"
+          className={cn(
+            "flex w-full justify-center px-4 py-3 text-sm font-medium text-foreground transition-colors hover:bg-muted/50",
+            variant === "grouped"
+              ? "border-t border-border/55"
+              : "rounded-2xl bg-muted/40",
+          )}
           data-testid="agent-memory-show-less"
           onClick={() => setShowAllEntries(false)}
           type="button"
@@ -299,14 +349,21 @@ function MemoryShowMoreButton({
   count,
   onClick,
   truncated,
+  variant,
 }: {
   count: number;
   onClick: () => void;
   truncated: boolean;
+  variant: MemorySectionVariant;
 }) {
   const button = (
     <button
-      className="flex w-full items-center justify-center gap-2 rounded-2xl bg-muted/40 px-4 py-3 text-sm font-medium text-foreground transition-colors hover:bg-muted/50"
+      className={cn(
+        "flex w-full items-center justify-center gap-2 px-4 py-3 text-sm font-medium text-foreground transition-colors hover:bg-muted/50",
+        variant === "grouped"
+          ? "border-t border-border/55"
+          : "rounded-2xl bg-muted/40",
+      )}
       data-testid={
         truncated ? "agent-memory-truncated" : "agent-memory-show-more"
       }
@@ -329,12 +386,15 @@ function MemoryShowMoreButton({
   );
 }
 
-function MemoryTruncatedHint() {
+function MemoryTruncatedHint({ variant }: { variant: MemorySectionVariant }) {
   return (
     <Tooltip>
       <TooltipTrigger asChild>
         <div
-          className="flex justify-center rounded-2xl border border-warning/30 bg-warning/5 px-4 py-2"
+          className={cn(
+            "flex justify-center border-warning/30 bg-warning/5 px-4 py-2",
+            variant === "grouped" ? "border-t" : "rounded-2xl border",
+          )}
           data-testid="agent-memory-truncated"
         >
           <AlertTriangle className="h-4 w-4 text-warning" />
@@ -466,9 +526,11 @@ function elementExceedsLines(element: HTMLElement, lines: number): boolean {
 function MemoryEntryAccordion({
   danglingSlugs,
   entry,
+  variant,
 }: {
   danglingSlugs: ReadonlySet<string>;
   entry: EngramEntry;
+  variant: MemorySectionVariant;
 }) {
   const [open, setOpen] = React.useState(false);
   const [showCaret, setShowCaret] = React.useState(false);
@@ -545,7 +607,10 @@ function MemoryEntryAccordion({
 
   return (
     <article
-      className="overflow-hidden rounded-2xl bg-muted/40"
+      className={cn(
+        "overflow-hidden",
+        variant === "cards" && "rounded-2xl bg-muted/40",
+      )}
       ref={articleRef}
     >
       {canExpand ? (
diff --git a/desktop/src/features/agents/activeAgentTurnsStore.test.mjs b/desktop/src/features/agents/activeAgentTurnsStore.test.mjs
index e3e3b3e756f..44e43525b6d 100644
--- a/desktop/src/features/agents/activeAgentTurnsStore.test.mjs
+++ b/desktop/src/features/agents/activeAgentTurnsStore.test.mjs
@@ -16,7 +16,11 @@ import {
 import {
   injectObserverEventsForE2E,
   getAgentObserverSnapshot,
+  getAgentTranscript,
+  subscribeAgentObserverStore,
+  subscribeAgentManagementRequests,
   resetAgentObserverStore,
+  _testProcessLiveObserverEvents,
 } from "./observerRelayStore.ts";
 import { formatElapsed } from "./ui/agentSessionUtils.ts";
 
@@ -1621,6 +1625,115 @@ describe("observer → active-turns bridge sync", () => {
     );
   });
 
+  it("publishes one observer update for a batch while preserving outcomes", () => {
+    let observerNotifications = 0;
+    const unsubscribeObserver = subscribeAgentObserverStore(() => {
+      observerNotifications += 1;
+    });
+    const events = [
+      makeEvent({ seq: 1, kind: "turn_started" }),
+      ...Array.from({ length: 98 }, (_, index) =>
+        makeEvent({
+          seq: index + 2,
+          kind: "acp_write",
+          timestamp: new Date(
+            Date.parse("2024-01-01T00:00:00Z") + (index + 1) * 1_000,
+          ).toISOString(),
+        }),
+      ),
+      makeEvent({
+        seq: 100,
+        kind: "turn_completed",
+        timestamp: "2024-01-01T00:02:00Z",
+      }),
+    ];
+
+    injectObserverEventsForE2E(AGENT, events);
+    unsubscribeObserver();
+
+    assert.equal(
+      observerNotifications,
+      1,
+      "one harness envelope must produce one external-store publication",
+    );
+    assert.equal(getAgentObserverSnapshot(AGENT, true).events.length, 100);
+    assert.ok(
+      getAgentTranscript(AGENT, true).length > 0,
+      "the batched events must still build transcript state",
+    );
+    syncActiveAgentTurnsFromObserver(bridgeAgents);
+    assert.equal(
+      getActiveTurnsForAgent(AGENT).length,
+      0,
+      "the terminal event must still clear derived liveness",
+    );
+  });
+
+  it("makes the triggering frame visible before management callbacks", () => {
+    const managementFrame = makeEvent({
+      seq: 2,
+      kind: "acp_message",
+      timestamp: "2024-01-01T00:00:01Z",
+      payload: {
+        type: "agent_management_request",
+        action: "create",
+        requestId: "request-1",
+        request: {
+          channelId: "chan-1",
+          displayName: "Fleet Observer",
+          systemPrompt: "Observe the fleet.",
+        },
+      },
+    });
+    let visibleSeqs = [];
+    let observerNotifications = 0;
+    const unsubscribeObserver = subscribeAgentObserverStore(() => {
+      observerNotifications += 1;
+    });
+    const unsubscribeManagement = subscribeAgentManagementRequests(
+      (agentPubkey) => {
+        assert.equal(agentPubkey, AGENT);
+        visibleSeqs = getAgentObserverSnapshot(AGENT, true).events.map(
+          (event) => event.seq,
+        );
+        assert.equal(
+          observerNotifications,
+          0,
+          "the global publication must remain deferred until callbacks finish",
+        );
+      },
+    );
+
+    _testProcessLiveObserverEvents(AGENT, [
+      makeEvent({ seq: 1, kind: "turn_started" }),
+      managementFrame,
+    ]);
+    unsubscribeManagement();
+    unsubscribeObserver();
+
+    assert.deepEqual(
+      visibleSeqs,
+      [1, 2],
+      "management callback must observe its triggering frame and prior envelope frames",
+    );
+    assert.equal(observerNotifications, 1);
+  });
+
+  it("does not publish when a replay batch is entirely duplicate", () => {
+    const events = [makeEvent({ seq: 1, kind: "turn_started" })];
+    injectObserverEventsForE2E(AGENT, events);
+
+    let observerNotifications = 0;
+    const unsubscribeObserver = subscribeAgentObserverStore(() => {
+      observerNotifications += 1;
+    });
+    injectObserverEventsForE2E(AGENT, events);
+    unsubscribeObserver();
+
+    assert.equal(observerNotifications, 0);
+    assert.equal(getAgentObserverSnapshot(AGENT, true).events.length, 1);
+  });
+
   it("skips agents that are neither running nor deployed", () => {
     injectObserverEventsForE2E(AGENT, [
       makeEvent({ seq: 1, kind: "turn_started" }),
diff --git a/desktop/src/features/agents/focusRefetchPolicy.test.mjs b/desktop/src/features/agents/focusRefetchPolicy.test.mjs
index ee16a468678..9b394dad035 100644
--- a/desktop/src/features/agents/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/agents/focusRefetchPolicy.test.mjs
@@ -57,13 +57,13 @@ test("agents: skips fresh focus refetch", async () => {
   );
 });
 
-test("agents: refetches genuinely stale data on focus", async () => {
+test("agents: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: agentsFocusRefetchPolicy.staleTime + 1,
       policy: agentsFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
 
@@ -77,12 +77,12 @@ test("managed-agent-log: skips focus refetch when data is fresher than one poll
   );
 });
 
-test("managed-agent-log: refetches on focus when data is older than one poll tick", async () => {
+test("managed-agent-log: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: managedAgentLogFocusRefetchPolicy.staleTime + 1,
       policy: managedAgentLogFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
diff --git a/desktop/src/features/agents/hooks.ts b/desktop/src/features/agents/hooks.ts
index eb038ee06f1..de3d2b9e83b 100644
--- a/desktop/src/features/agents/hooks.ts
+++ b/desktop/src/features/agents/hooks.ts
@@ -111,13 +111,13 @@ export const MANAGED_AGENT_LOG_FOCUS_STALE_TIME_MS = 30_000;
 /** Focus-refetch policy for relay-agent and managed-agent queries; consumed by focusRefetchPolicy.test.mjs. */
 export const agentsFocusRefetchPolicy = {
   staleTime: AGENTS_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 /** Focus-refetch policy for the managed-agent-log query; consumed by focusRefetchPolicy.test.mjs. */
 export const managedAgentLogFocusRefetchPolicy = {
   staleTime: MANAGED_AGENT_LOG_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 export const relayAgentsQueryKey = ["relay-agents"] as const;
diff --git a/desktop/src/features/agents/lib/focusRefetchPolicy.test.mjs b/desktop/src/features/agents/lib/focusRefetchPolicy.test.mjs
index 7f274203099..66ec2c7a44a 100644
--- a/desktop/src/features/agents/lib/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/agents/lib/focusRefetchPolicy.test.mjs
@@ -54,12 +54,12 @@ test("persona-catalog: skips fresh focus refetch", async () => {
   );
 });
 
-test("persona-catalog: refetches genuinely stale data on focus", async () => {
+test("persona-catalog: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: personaCatalogFocusRefetchPolicy.staleTime + 1,
       policy: personaCatalogFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
diff --git a/desktop/src/features/agents/lib/managedAgentControlActions.ts b/desktop/src/features/agents/lib/managedAgentControlActions.ts
index 50a92e4f170..8a4a6898cce 100644
--- a/desktop/src/features/agents/lib/managedAgentControlActions.ts
+++ b/desktop/src/features/agents/lib/managedAgentControlActions.ts
@@ -44,7 +44,7 @@ export function getManagedAgentPrimaryActionLabel(agent: ManagedAgent) {
     return "Stop";
   }
 
-  return agent.status === "stopped" ? "Restart Agent" : "Start Agent";
+  return "Start agent";
 }
 
 export function resolveManagedAgentChannelId(
diff --git a/desktop/src/features/agents/lib/usePersonaCatalogRelay.ts b/desktop/src/features/agents/lib/usePersonaCatalogRelay.ts
index 2b0f0fdb296..898848ec5f4 100644
--- a/desktop/src/features/agents/lib/usePersonaCatalogRelay.ts
+++ b/desktop/src/features/agents/lib/usePersonaCatalogRelay.ts
@@ -24,7 +24,7 @@ export const PERSONA_CATALOG_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy for the persona catalog query; consumed by focusRefetchPolicy.test.mjs. */
 export const personaCatalogFocusRefetchPolicy = {
   staleTime: PERSONA_CATALOG_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 export function personaCatalogQueryKey(communityId: string | null) {
diff --git a/desktop/src/features/agents/observerRelayStore.ts b/desktop/src/features/agents/observerRelayStore.ts
index 611fdd489d4..4a8313a1e1c 100644
--- a/desktop/src/features/agents/observerRelayStore.ts
+++ b/desktop/src/features/agents/observerRelayStore.ts
@@ -193,44 +193,63 @@ function observerTag(event: RelayEvent, tagName: string) {
   return event.tags.find((tag) => tag[0] === tagName)?.[1] ?? null;
 }
 
-function appendAgentEvent(agentPubkey: string, event: ObserverEvent) {
+function appendAgentEvents(
+  agentPubkey: string,
+  events: readonly ObserverEvent[],
+): boolean {
+  if (events.length === 0) return false;
+
   const key = normalizePubkey(agentPubkey);
   const current = eventsByAgent.get(key) ?? [];
-  if (
-    current.some(
-      (existing) =>
-        existing.seq === event.seq && existing.timestamp === event.timestamp,
-    )
-  ) {
-    return;
+  const seen = new Set(
+    current.map(
+      (event) => `${event.timestamp.length}:${event.timestamp}:${event.seq}`,
+    ),
+  );
+  const added: ObserverEvent[] = [];
+  for (const event of events) {
+    const eventKey = `${event.timestamp.length}:${event.timestamp}:${event.seq}`;
+    if (seen.has(eventKey)) continue;
+    seen.add(eventKey);
+    added.push(event);
   }
+  if (added.length === 0) return false;
 
-  const sorted = [...current, event].sort(compareObserverEvents);
+  const sortedAdded = added.sort(compareObserverEvents);
+  const sorted = [...current, ...sortedAdded].sort(compareObserverEvents);
   const trimmed = sorted.length > MAX_OBSERVER_EVENTS;
   const final = trimmed
     ? sorted.slice(sorted.length - MAX_OBSERVER_EVENTS)
     : sorted;
   eventsByAgent.set(key, final);
 
-  // Determine whether the new event landed at the end of the sorted array.
-  // If it did (common case), we can incrementally process just this event.
-  // If not (out-of-order arrival) or if we trimmed, fall back to full rebuild.
-  const eventAtEnd = sorted[sorted.length - 1] === event;
-
-  if (eventAtEnd && !trimmed) {
-    // Fast path: incremental update
-    const transcriptState =
+  // The common live path appends a sorted batch after the retained window. Fold
+  // that batch through the transcript state once without rebuilding history.
+  // Out-of-order arrivals and cap eviction rebuild from the final window so
+  // stateful tool/permission relationships remain correct.
+  const currentLast = current.at(-1);
+  const allAtEnd =
+    !currentLast ||
+    sortedAdded.every((event) => compareObserverEvents(event, currentLast) > 0);
+  if (allAtEnd && !trimmed) {
+    let transcriptState =
       transcriptByAgent.get(key) ?? createEmptyTranscriptState();
-    const updatedTranscript = processTranscriptEvent(transcriptState, event);
-    transcriptByAgent.set(key, updatedTranscript);
+    for (const event of sortedAdded) {
+      transcriptState = processTranscriptEvent(transcriptState, event);
+    }
+    transcriptByAgent.set(key, transcriptState);
   } else {
-    // Slow path: full rebuild (out-of-order insertion or trim fired)
     transcriptByAgent.set(key, buildTranscriptState(final));
   }
 
   invalidateSnapshot(key);
+  return true;
+}
 
-  notifyListeners();
+function appendAgentEvent(agentPubkey: string, event: ObserverEvent) {
+  if (appendAgentEvents(agentPubkey, [event])) {
+    notifyListeners();
+  }
 }
 
 /**
@@ -362,44 +381,60 @@ function unwrapObserverBatch(parsed: ObserverEvent): ObserverEvent[] {
 
 // Per-event processing shared by every event a live frame carries (one for a
 // plain frame, many for a batch envelope).
-function processLiveObserverEvent(agentPubkey: string, parsed: ObserverEvent) {
-  // Track the latest-live-session-id per (agent, channel) on the live path.
-  // Only set when the parsed event carries both a sessionId and channelId,
-  // so we never attribute a session to the wrong channel.
-  if (parsed.sessionId && parsed.channelId) {
-    const key = liveSessionKey(agentPubkey, parsed.channelId);
-    const stored = latestLiveSessionByAgentChannel.get(key);
-    // Advance only when this event sorts strictly AFTER the stored one via
-    // isObserverEventAfter (timestamp then seq — same ordering as
-    // compareObserverEvents). This prevents late-arriving live frames from
-    // older sessions from regressing the latest-live id, while also
-    // correctly advancing on a same-timestamp frame with a higher seq.
-    if (!stored || isObserverEventAfter(parsed, stored)) {
-      latestLiveSessionByAgentChannel.set(key, {
-        sessionId: parsed.sessionId,
-        timestamp: parsed.timestamp,
-        seq: parsed.seq,
-      });
+function processLiveObserverEvents(
+  agentPubkey: string,
+  events: readonly ObserverEvent[],
+) {
+  // Commit the full envelope before dispatching synchronous specialized
+  // callbacks. Those callbacks historically observed their triggering frame
+  // in the raw/transcript stores; batching must preserve that visibility while
+  // deferring only the global external-store publication.
+  const observerChanged = appendAgentEvents(agentPubkey, events);
+
+  for (const parsed of events) {
+    // Track the latest-live-session-id per (agent, channel) on the live path.
+    // Only set when the parsed event carries both a sessionId and channelId,
+    // so we never attribute a session to the wrong channel.
+    if (parsed.sessionId && parsed.channelId) {
+      const key = liveSessionKey(agentPubkey, parsed.channelId);
+      const stored = latestLiveSessionByAgentChannel.get(key);
+      // Advance only when this event sorts strictly AFTER the stored one via
+      // isObserverEventAfter (timestamp then seq — same ordering as
+      // compareObserverEvents). This prevents late-arriving live frames from
+      // older sessions from regressing the latest-live id, while also
+      // correctly advancing on a same-timestamp frame with a higher seq.
+      if (!stored || isObserverEventAfter(parsed, stored)) {
+        latestLiveSessionByAgentChannel.set(key, {
+          sessionId: parsed.sessionId,
+          timestamp: parsed.timestamp,
+          seq: parsed.seq,
+        });
+      }
     }
-  }
-  appendAgentEvent(agentPubkey, parsed);
-  const managementRequest = parseAgentManagementRequest(parsed.payload);
-  if (managementRequest) {
-    for (const listener of agentManagementListeners) {
-      listener(agentPubkey, managementRequest);
+    const managementRequest = parseAgentManagementRequest(parsed.payload);
+    if (managementRequest) {
+      for (const listener of agentManagementListeners) {
+        listener(agentPubkey, managementRequest);
+      }
+    }
+    if (parsed.kind === "session_config_captured") {
+      void putAgentSessionConfig(agentPubkey, parsed.payload);
+      onSessionConfigCaptured?.(agentPubkey);
+    } else if (parsed.kind === "control_result") {
+      dispatchControlResult(agentPubkey, parsed.payload);
+    } else if (parsed.kind === "managed_agent_runtime_lifecycle") {
+      void putManagedAgentRuntimeLifecycle(agentPubkey, parsed.payload).catch(
+        (error) => {
+          console.debug("Late/untracked lifecycle frame dropped:", error);
+        },
+      );
     }
   }
-  if (parsed.kind === "session_config_captured") {
-    void putAgentSessionConfig(agentPubkey, parsed.payload);
-    onSessionConfigCaptured?.(agentPubkey);
-  } else if (parsed.kind === "control_result") {
-    dispatchControlResult(agentPubkey, parsed.payload);
-  } else if (parsed.kind === "managed_agent_runtime_lifecycle") {
-    void putManagedAgentRuntimeLifecycle(agentPubkey, parsed.payload).catch(
-      (error) => {
-        console.debug("Late/untracked lifecycle frame dropped:", error);
-      },
-    );
+
+  // Preserve the harness's envelope backpressure: retained state was committed
+  // before specialized callbacks, but external-store subscribers publish once.
+  if (observerChanged) {
+    notifyListeners();
   }
 }
 
@@ -437,9 +472,7 @@ async function handleRelayObserverEvent(
     if (activeGeneration !== generation) {
       return;
     }
-    for (const inner of unwrapObserverBatch(parsed)) {
-      processLiveObserverEvent(agentPubkey, inner);
-    }
+    processLiveObserverEvents(agentPubkey, unwrapObserverBatch(parsed));
   } catch (error) {
     if (activeGeneration !== generation) {
       return;
@@ -748,10 +781,9 @@ export function injectObserverEventsForE2E(
   agentPubkey: string,
   events: ObserverEvent[],
 ) {
-  for (const event of events) {
-    appendAgentEvent(agentPubkey, event);
+  if (appendAgentEvents(agentPubkey, events)) {
+    notifyListeners();
   }
-  notifyListeners();
 }
 
 /**
@@ -762,8 +794,8 @@ export function syncAgentObserverEvents(
   agentPubkey: string,
   events: ObserverEvent[],
 ) {
-  for (const event of events) {
-    appendAgentEvent(agentPubkey, event);
+  if (appendAgentEvents(agentPubkey, events)) {
+    notifyListeners();
   }
 }
 
@@ -801,6 +833,14 @@ export function _testRegisterKnownAgents(
   registerKnownAgents(subscriptionId, pubkeys);
 }
 
+/** Test-only: exercise live envelope ordering without relay/decryption setup. */
+export function _testProcessLiveObserverEvents(
+  agentPubkey: string,
+  events: readonly ObserverEvent[],
+): void {
+  processLiveObserverEvents(agentPubkey, events);
+}
+
 /**
  * Test-only: read the raw archived observer events for a (agent, channel) pair.
  * Production callers should use `getArchivedChannelEvents`.
diff --git a/desktop/src/features/agents/ui/AgentConfigPanel.tsx b/desktop/src/features/agents/ui/AgentConfigPanel.tsx
index 67c544257ce..c6081f96885 100644
--- a/desktop/src/features/agents/ui/AgentConfigPanel.tsx
+++ b/desktop/src/features/agents/ui/AgentConfigPanel.tsx
@@ -5,31 +5,53 @@ import {
   Brain,
   ChevronDown,
   ChevronRight,
-  Copy,
   Cpu,
   Hash,
   Layers,
   MessageSquare,
+  Pencil,
   PenOff,
   Server,
 } from "lucide-react";
 import { useAgentConfigSurface } from "../hooks";
 import { cn } from "@/shared/lib/cn";
-import { copyTextToClipboard } from "@/shared/lib/clipboard";
 import { Spinner } from "@/shared/ui/spinner";
-import { McpServersSection } from "./McpServersSection";
+import { PanelSectionGroup } from "@/shared/ui/PanelSectionGroup";
+import {
+  HoverCopyIndicator,
+  useCopyFeedback,
+} from "@/shared/ui/HoverCopyIndicator";
+import { McpServersSection, shouldRenderMcpServers } from "./McpServersSection";
 import type {
   ConfigField,
   ConfigOrigin,
   ConfigWriteMechanism,
   NormalizedConfig,
   NormalizedField,
+  RuntimeConfigSurface,
 } from "@/shared/api/types";
 import { providerDisplayLabel } from "./agentConfigOptions";
 
+export type AgentConfigPanelSection = "model" | "mcp" | "advanced";
+
+const ALL_AGENT_CONFIG_SECTIONS: readonly AgentConfigPanelSection[] = [
+  "model",
+  "mcp",
+  "advanced",
+];
+
 type Props = {
   pubkey: string;
   advancedMode?: "collapsed" | "flat";
+  onEdit?: () => void;
+  sections?: readonly AgentConfigPanelSection[];
+};
+
+type AgentConfigSurfaceRowsProps = {
+  advancedMode?: "collapsed" | "flat";
+  data: RuntimeConfigSurface;
+  onEdit?: () => void;
+  sections?: readonly AgentConfigPanelSection[];
 };
 
 function isReadOnlyField({
@@ -44,7 +66,7 @@ function isReadOnlyField({
 
 function ConfigFieldLabel({ label }: { label: string }) {
   return (
-    <span className="inline-flex min-w-0 items-center gap-1.5 text-xs font-medium text-foreground">
+    <span className="inline-flex min-w-0 items-center gap-1.5 text-sm font-medium text-foreground">
       <span className="truncate">{label}</span>
     </span>
   );
@@ -53,13 +75,15 @@ function ConfigFieldLabel({ label }: { label: string }) {
 function ProvenanceHint({
   locked,
   provenance,
+  showLockIcon = true,
 }: {
   locked: boolean;
   provenance: string;
+  showLockIcon?: boolean;
 }) {
   return (
     <span className="mt-0.5 flex items-center gap-1 text-2xs text-muted-foreground/70">
-      {locked ? (
+      {locked && showLockIcon ? (
         <PenOff aria-label="Read-only" className="h-3 w-3 shrink-0" />
       ) : null}
       <span className="min-w-0 truncate">{provenance}</span>
@@ -112,12 +136,12 @@ function provenanceSentence(
   origin: ConfigOrigin,
   writeVia: ConfigWriteMechanism,
   configFilePath: string | null,
-): string {
+): string | null {
   switch (origin) {
     case "buzzExplicit":
       return "Set in Buzz";
     case "personaDefault":
-      return "Inherited from template";
+      return null;
     case "runtimeOverride":
       return "Live override (this session only)";
     case "harnessConstraint":
@@ -148,10 +172,10 @@ const NORMALIZED_LABELS: Record<keyof NormalizedConfig, string> = {
   model: "Model",
   provider: "Provider",
   mode: "Mode",
-  thinkingEffort: "Thinking / Effort",
-  maxOutputTokens: "Max Output Tokens",
-  contextLimit: "Context Limit",
-  systemPrompt: "System Prompt",
+  thinkingEffort: "Thinking effort",
+  maxOutputTokens: "Max output tokens",
+  contextLimit: "Context limit",
+  systemPrompt: "System prompt",
 };
 
 const NORMALIZED_ICONS: Record<keyof NormalizedConfig, LucideIcon> = {
@@ -170,6 +194,7 @@ function NormalizedRow({
   field,
   isPreSpawn,
   configFilePath,
+  onEdit,
   variant = "compact",
 }: {
   fieldKey: keyof NormalizedConfig;
@@ -177,6 +202,7 @@ function NormalizedRow({
   field: NormalizedField;
   isPreSpawn: boolean;
   configFilePath: string | null;
+  onEdit?: () => void;
   variant?: RowVariant;
 }) {
   const Icon = NORMALIZED_ICONS[fieldKey];
@@ -195,19 +221,13 @@ function NormalizedRow({
     ? provenanceSentence(field.origin, field.writeVia, configFilePath)
     : null;
   const locked = isReadOnlyField(field);
-  const isCopyable =
-    variant === "profile" &&
-    shouldOfferCopy({
-      fieldKey,
-      origin: field.origin,
-      value: field.value,
-    });
+  const isEditable = variant === "profile" && onEdit !== undefined;
 
   const content = (
     <>
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <Icon className="h-4 w-4 text-muted-foreground" />
-      </span>
+      {variant === "compact" ? (
+        <Icon className="h-4 w-4 shrink-0 text-muted-foreground" />
+      ) : null}
       <span className="min-w-0 flex-1 text-left">
         {variant === "profile" ? (
           <ConfigFieldLabel label={label} />
@@ -234,24 +254,29 @@ function NormalizedRow({
           ) : null}
         </span>
         {provenance ? (
-          <ProvenanceHint locked={locked} provenance={provenance} />
+          <ProvenanceHint
+            locked={locked}
+            provenance={provenance}
+            showLockIcon={variant === "compact"}
+          />
         ) : null}
       </span>
-      {isCopyable ? (
-        <Copy className="h-4 w-4 shrink-0 text-muted-foreground" />
+      {isEditable ? (
+        <Pencil
+          className="h-4 w-4 shrink-0 text-muted-foreground opacity-0 transition-opacity group-hover:opacity-100 group-focus-visible:opacity-100"
+          data-testid={`agent-config-${fieldKey}-edit-indicator`}
+        />
       ) : null}
     </>
   );
 
-  if (isCopyable && field.value) {
+  if (isEditable) {
     return (
       <button
-        aria-label={`Copy ${label}`}
-        className="flex w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40"
-        onClick={() =>
-          copyTextToClipboard(field.value ?? "", `Copied ${label}`)
-        }
-        title={`Copy ${label}`}
+        aria-label={`Edit ${label}`}
+        className="group flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
+        onClick={onEdit}
+        title={`Edit ${label}`}
         type="button"
       >
         {content}
@@ -259,7 +284,16 @@ function NormalizedRow({
     );
   }
 
-  return <div className="flex items-center gap-3 px-4 py-3">{content}</div>;
+  return (
+    <div
+      className={cn(
+        "flex items-center gap-3 px-4 py-3",
+        variant === "profile" && "min-h-16",
+      )}
+    >
+      {content}
+    </div>
+  );
 }
 
 // ── Advanced row ──────────────────────────────────────────────────────────────
@@ -277,6 +311,10 @@ function AdvancedRow({
     ? provenanceSentence(field.origin, field.writeVia, configFilePath)
     : null;
   const locked = isReadOnlyField(field);
+  const { copied, copy } = useCopyFeedback({
+    label: field.label,
+    value: field.value ?? "",
+  });
 
   if (variant === "compact") {
     return (
@@ -305,9 +343,6 @@ function AdvancedRow({
   });
   const content = (
     <>
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <Hash className="h-4 w-4 text-muted-foreground" />
-      </span>
       <span className="min-w-0 flex-1 text-left">
         <ConfigFieldLabel label={field.label} />
         <span
@@ -317,11 +352,18 @@ function AdvancedRow({
           {field.value ?? "—"}
         </span>
         {provenance ? (
-          <ProvenanceHint locked={locked} provenance={provenance} />
+          <ProvenanceHint
+            locked={locked}
+            provenance={provenance}
+            showLockIcon={false}
+          />
         ) : null}
       </span>
       {isCopyable ? (
-        <Copy className="h-4 w-4 shrink-0 text-muted-foreground" />
+        <HoverCopyIndicator
+          copied={copied}
+          testId={`agent-config-advanced-${field.key}-copy-status`}
+        />
       ) : null}
     </>
   );
@@ -330,10 +372,8 @@ function AdvancedRow({
     return (
       <button
         aria-label={`Copy ${field.label}`}
-        className="flex w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40"
-        onClick={() =>
-          copyTextToClipboard(field.value ?? "", `Copied ${field.label}`)
-        }
+        className="group flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
+        onClick={() => void copy()}
         title={`Copy ${field.label}`}
         type="button"
       >
@@ -342,37 +382,95 @@ function AdvancedRow({
     );
   }
 
-  return <div className="flex items-center gap-3 px-4 py-3">{content}</div>;
+  return (
+    <div className="flex min-h-16 items-center gap-3 px-4 py-3">{content}</div>
+  );
 }
 
 // ── Main component ────────────────────────────────────────────────────────────
 
+function ProfileConfigSection({
+  children,
+  testId,
+  title,
+}: {
+  children: React.ReactNode;
+  testId?: string;
+  title: string;
+}) {
+  return (
+    <PanelSectionGroup testId={testId} title={title}>
+      {children}
+    </PanelSectionGroup>
+  );
+}
+
 export function AgentConfigPanel({
   advancedMode = "collapsed",
+  onEdit,
   pubkey,
+  sections = ALL_AGENT_CONFIG_SECTIONS,
 }: Props) {
-  const [advancedOpen, setAdvancedOpen] = React.useState(false);
   const { data, isLoading, error } = useAgentConfigSurface(pubkey);
+  const flatStateTitle = sections.includes("model")
+    ? "Model settings"
+    : sections.includes("mcp")
+      ? "MCP servers"
+      : "Advanced";
 
   if (isLoading) {
-    return (
-      <div className="flex items-center gap-2 py-4 text-sm text-muted-foreground">
+    const loading = (
+      <div className="flex items-center gap-2 px-4 py-4 text-sm text-muted-foreground">
         <Spinner className="h-3.5 w-3.5" />
-        Loading config…
+        Loading configuration…
       </div>
     );
+    if (advancedMode === "flat") {
+      return (
+        <ProfileConfigSection title={flatStateTitle}>
+          {loading}
+        </ProfileConfigSection>
+      );
+    }
+    return loading;
   }
 
   if (error || !data) {
-    return (
-      <p className="py-3 text-sm text-destructive">
+    const errorMessage = (
+      <p className="px-4 py-3 text-sm text-destructive">
         {error instanceof Error
           ? error.message
-          : "Failed to load agent config."}
+          : "Couldn't load agent configuration."}
       </p>
     );
+    if (advancedMode === "flat") {
+      return (
+        <ProfileConfigSection title={flatStateTitle}>
+          {errorMessage}
+        </ProfileConfigSection>
+      );
+    }
+    return errorMessage;
   }
 
+  return (
+    <AgentConfigSurfaceRows
+      advancedMode={advancedMode}
+      data={data}
+      onEdit={onEdit}
+      sections={sections}
+    />
+  );
+}
+
+export function AgentConfigSurfaceRows({
+  advancedMode = "collapsed",
+  data,
+  onEdit,
+  sections = ALL_AGENT_CONFIG_SECTIONS,
+}: AgentConfigSurfaceRowsProps) {
+  const [advancedOpen, setAdvancedOpen] = React.useState(false);
+
   const { normalized, advanced, extensions, runtimeId, sources, isPreSpawn } =
     data;
   const configFilePath = sources.configFilePath;
@@ -399,6 +497,72 @@ export function AgentConfigPanel({
     }
     return true;
   }) as [keyof NormalizedConfig, NormalizedField][];
+  const showMcpServers = shouldRenderMcpServers(runtimeId, extensions);
+  const showModelSection = sections.includes("model");
+  const showMcpSection = sections.includes("mcp");
+  const showAdvancedSection = sections.includes("advanced");
+
+  if (advancedMode === "flat") {
+    return (
+      <div className="space-y-4">
+        {showModelSection && normalizedEntries.length > 0 ? (
+          <ProfileConfigSection
+            testId="user-profile-model-settings-section"
+            title="Model settings"
+          >
+            <div
+              className={cn(
+                "divide-y divide-border/55",
+                isPreSpawn && "opacity-60",
+              )}
+            >
+              {normalizedEntries.map(([key, field]) => (
+                <NormalizedRow
+                  configFilePath={configFilePath}
+                  field={field}
+                  fieldKey={key}
+                  isPreSpawn={isPreSpawn}
+                  key={key}
+                  label={NORMALIZED_LABELS[key]}
+                  onEdit={onEdit}
+                  variant="profile"
+                />
+              ))}
+            </div>
+          </ProfileConfigSection>
+        ) : null}
+
+        {showMcpSection && showMcpServers ? (
+          <ProfileConfigSection
+            testId="user-profile-mcp-servers-section"
+            title="MCP servers"
+          >
+            <McpServersSection
+              extensions={extensions}
+              runtimeId={runtimeId}
+              variant="profile"
+            />
+          </ProfileConfigSection>
+        ) : null}
+
+        {showAdvancedSection && advanced.length > 0 ? (
+          <ProfileConfigSection
+            testId="user-profile-advanced-section"
+            title="Advanced"
+          >
+            {advanced.map((field) => (
+              <AdvancedRow
+                configFilePath={configFilePath}
+                field={field}
+                key={field.key}
+                variant="profile"
+              />
+            ))}
+          </ProfileConfigSection>
+        ) : null}
+      </div>
+    );
+  }
 
   return (
     <div className="space-y-0.5">
@@ -419,7 +583,7 @@ export function AgentConfigPanel({
               field={field}
               isPreSpawn={isPreSpawn}
               configFilePath={configFilePath}
-              variant={advancedMode === "flat" ? "profile" : "compact"}
+              variant="compact"
             />
           ))
         )}
@@ -428,26 +592,10 @@ export function AgentConfigPanel({
       <McpServersSection
         extensions={extensions}
         runtimeId={runtimeId}
-        variant={advancedMode === "flat" ? "profile" : "compact"}
+        variant="compact"
       />
 
-      {advanced.length > 0 && advancedMode === "flat" ? (
-        <div className="divide-y divide-border/50 border-t border-border/50">
-          <p className="px-4 py-3 text-xs font-medium text-foreground">
-            Advanced
-          </p>
-          {advanced.map((field) => (
-            <AdvancedRow
-              key={field.key}
-              field={field}
-              configFilePath={configFilePath}
-              variant="profile"
-            />
-          ))}
-        </div>
-      ) : null}
-
-      {advanced.length > 0 && advancedMode === "collapsed" ? (
+      {advanced.length > 0 ? (
         <div className="mt-3 border-t border-border/50 pt-2">
           <button
             className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground"
diff --git a/desktop/src/features/agents/ui/AgentStatusBadge.tsx b/desktop/src/features/agents/ui/AgentStatusBadge.tsx
index 15858b9ebd4..7a94b0b87c1 100644
--- a/desktop/src/features/agents/ui/AgentStatusBadge.tsx
+++ b/desktop/src/features/agents/ui/AgentStatusBadge.tsx
@@ -2,19 +2,24 @@ import * as React from "react";
 
 import { Badge } from "@/shared/ui/badge";
 import type { ManagedAgent, PresenceStatus } from "@/shared/api/types";
+import { cn } from "@/shared/lib/cn";
 
 /** Grace period after mount before treating "running + no presence" as "Starting…" */
 const PRESENCE_GRACE_MS = 15_000;
 
 export function AgentStatusBadge({
+  className,
   isWorking,
   presenceLoaded,
   presenceStatus,
+  sentenceCase = false,
   status,
 }: {
+  className?: string;
   isWorking?: boolean;
   presenceLoaded: boolean;
   presenceStatus: PresenceStatus | undefined;
+  sentenceCase?: boolean;
   status: ManagedAgent["status"];
 }) {
   const [inGracePeriod, setInGracePeriod] = React.useState(true);
@@ -39,15 +44,18 @@ export function AgentStatusBadge({
         ? "default"
         : "secondary";
 
-  const label = isWorking
+  const rawLabel = isWorking
     ? "Working"
     : isStarting
       ? "Starting\u2026"
       : status.replace(/_/g, " ");
+  const label = sentenceCase
+    ? `${rawLabel.charAt(0).toUpperCase()}${rawLabel.slice(1)}`
+    : rawLabel;
 
   return (
     <Badge
-      className={isWorking ? "motion-safe:animate-pulse" : undefined}
+      className={cn(className, isWorking && "motion-safe:animate-pulse")}
       variant={variant}
     >
       {label}
diff --git a/desktop/src/features/agents/ui/McpServersSection.tsx b/desktop/src/features/agents/ui/McpServersSection.tsx
index 3e6c93ca5dd..f92f77a3923 100644
--- a/desktop/src/features/agents/ui/McpServersSection.tsx
+++ b/desktop/src/features/agents/ui/McpServersSection.tsx
@@ -1,5 +1,4 @@
 import type * as React from "react";
-import { CheckCircle2, CircleSlash } from "lucide-react";
 import type { ExtensionEntry } from "@/shared/api/types";
 import { cn } from "@/shared/lib/cn";
 
@@ -10,6 +9,16 @@ type McpServersSectionProps = {
   buzzAgentSlot?: React.ReactNode;
 };
 
+export function shouldRenderMcpServers(
+  runtimeId: string | null,
+  extensions: ExtensionEntry[],
+): boolean {
+  // buzz-agent always surfaces its built-in MCP servers even with no
+  // user-configured extensions; every other runtime shows the section only
+  // once it has extensions parsed from its config file.
+  return runtimeId === "buzz-agent" || extensions.length > 0;
+}
+
 export function McpServersSection({
   buzzAgentSlot,
   extensions,
@@ -18,30 +27,26 @@ export function McpServersSection({
 }: McpServersSectionProps) {
   const isBuzzAgent = runtimeId === "buzz-agent";
 
-  if (!isBuzzAgent && extensions.length === 0) {
+  if (!shouldRenderMcpServers(runtimeId, extensions)) {
     return null;
   }
 
   return (
     <div
       className={cn(
-        "border-t border-border/50",
-        variant === "compact" ? "mt-3 pt-2" : "divide-y divide-border/50",
+        variant === "compact"
+          ? "mt-3 border-t border-border/50 pt-2"
+          : "divide-y divide-border/55",
       )}
     >
-      <p
-        className={cn(
-          "text-xs font-medium text-foreground",
-          variant === "compact" ? "py-2" : "px-4 py-3",
-        )}
-      >
-        MCP Servers
-      </p>
+      {variant === "compact" ? (
+        <p className="py-2 text-xs font-medium text-foreground">MCP servers</p>
+      ) : null}
 
       {isBuzzAgent && buzzAgentSlot ? buzzAgentSlot : null}
 
       {extensions.length > 0 ? (
-        <div className="divide-y divide-border/50">
+        <div className="divide-y divide-border/55">
           {extensions.map((extension) => (
             <McpServerRow
               extension={extension}
@@ -54,10 +59,12 @@ export function McpServersSection({
         <p
           className={cn(
             "text-sm text-muted-foreground",
-            variant === "compact" ? "py-2" : "px-4 py-3",
+            variant === "compact"
+              ? "py-2"
+              : "flex min-h-16 items-center px-4 py-3",
           )}
         >
-          No custom servers configured
+          No custom servers configured.
         </p>
       )}
     </div>
@@ -71,32 +78,24 @@ function McpServerRow({
   extension: ExtensionEntry;
   variant: "compact" | "profile";
 }) {
-  const StatusIcon = extension.enabled ? CheckCircle2 : CircleSlash;
-
   return (
     <div
       className={cn(
         "flex min-w-0 items-center gap-3",
-        variant === "compact" ? "py-2" : "px-4 py-3",
+        variant === "compact" ? "py-2" : "min-h-16 px-4 py-3",
       )}
     >
-      <span className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-muted/50">
-        <StatusIcon
-          className={cn(
-            "h-4 w-4",
-            extension.enabled ? "text-emerald-600" : "text-muted-foreground",
-          )}
-        />
-      </span>
       <span className="min-w-0 flex-1">
         <span className="block truncate text-sm font-medium text-foreground">
           {extension.name}
         </span>
-        <span className="mt-0.5 block truncate text-2xs text-muted-foreground/70">
+        <span className="mt-0.5 block truncate text-sm text-muted-foreground/70">
           {extension.kind}
-          {extension.enabled ? " enabled" : " disabled"}
         </span>
       </span>
+      <span className="shrink-0 text-sm text-muted-foreground">
+        {extension.enabled ? "Enabled" : "Disabled"}
+      </span>
     </div>
   );
 }
diff --git a/desktop/src/features/agents/ui/personaModelDiscoveryStatus.test.mjs b/desktop/src/features/agents/ui/personaModelDiscoveryStatus.test.mjs
index 548c9ccc0a2..dfa086738fb 100644
--- a/desktop/src/features/agents/ui/personaModelDiscoveryStatus.test.mjs
+++ b/desktop/src/features/agents/ui/personaModelDiscoveryStatus.test.mjs
@@ -69,6 +69,53 @@ test("model discovery status stays quiet for missing Databricks defaults", () =>
   assert.equal(status, null);
 });
 
+test("Databricks sign-in-required is a muted note pointing at the picker and CLI", () => {
+  const status = formatModelDiscoveryErrorStatus(
+    new Error(
+      "Databricks sign-in is required; save this agent, then open its model picker to sign in, or run `buzz-agent auth databricks`",
+    ),
+    "databricks_v2",
+  );
+
+  assert.equal(status?.tone, "muted");
+  assert.match(status?.message ?? "", /model picker/);
+  assert.match(status?.message ?? "", /buzz-agent auth databricks/);
+});
+
+test("Databricks sign-in failure warns and points at the explicit retry", () => {
+  const status = formatModelDiscoveryErrorStatus(
+    new Error("Databricks sign-in failed: oauth callback: access_denied"),
+    "databricks_v2",
+  );
+
+  assert.equal(status?.tone, "warning");
+  assert.match(status?.message ?? "", /didn't complete/);
+  assert.match(status?.message ?? "", /model picker/);
+});
+
+test("Databricks sign-in timeout warns and points at the explicit retry", () => {
+  const status = formatModelDiscoveryErrorStatus(
+    new Error(
+      "Databricks sign-in timed out; open the model picker to retry, or run `buzz-agent auth databricks`",
+    ),
+    "databricks_v2",
+  );
+
+  assert.equal(status?.tone, "warning");
+  assert.match(status?.message ?? "", /didn't complete/);
+  assert.match(status?.message ?? "", /buzz-agent auth databricks/);
+});
+
+test("other Databricks discovery failures fall through to the generic notice", () => {
+  const status = formatModelDiscoveryErrorStatus(
+    new Error("Databricks model discovery failed: relay offline"),
+    "databricks_v2",
+  );
+
+  assert.equal(status?.tone, "warning");
+  assert.match(status?.message ?? "", /Using built-in model options/);
+});
+
 test("auth-required errors name the agent and ask for sign-in", () => {
   // Real shape from run_agent_models_command wrapping buzz-acp stderr when
   // cursor-agent is signed out (spec ErrorCode::AuthRequired text).
diff --git a/desktop/src/features/agents/ui/personaModelDiscoveryStatus.ts b/desktop/src/features/agents/ui/personaModelDiscoveryStatus.ts
index b943f6455cd..0d895264253 100644
--- a/desktop/src/features/agents/ui/personaModelDiscoveryStatus.ts
+++ b/desktop/src/features/agents/ui/personaModelDiscoveryStatus.ts
@@ -124,6 +124,16 @@ export function formatModelDiscoveryErrorStatus(
     return null;
   }
 
+  // Databricks transparent auth (agent_models_databricks.rs). The backend
+  // launches the browser OAuth flow itself from every discovery surface, so
+  // these are terminal outcomes the user should see, not raw error text.
+  // Matched on the stable error strings the backend emits (string matching is
+  // this file's convention until typed error codes arrive).
+  const databricksStatus = formatDatabricksAuthStatus(message);
+  if (databricksStatus !== null) {
+    return databricksStatus;
+  }
+
   return {
     message: `Using built-in model options. Could not load live models for ${providerObjectLabel(
       provider,
@@ -131,3 +141,35 @@ export function formatModelDiscoveryErrorStatus(
     tone: "warning",
   };
 }
+
+/**
+ * Maps the terminal Databricks sign-in states to user-facing guidance, or null
+ * when the error is not a Databricks sign-in outcome. "Sign-in required" is a
+ * quiet muted note (a passive surface hit its cooldown, or an unsaved draft
+ * can't launch the browser); a failed, cancelled, or timed-out sign-in is a
+ * warning that points the user at the explicit retry path.
+ */
+function formatDatabricksAuthStatus(
+  message: string,
+): PersonaModelDiscoveryStatus | null {
+  if (message.includes("Databricks sign-in is required")) {
+    return {
+      message:
+        "Databricks sign-in is required. Open the model picker to sign in, or run `buzz-agent auth databricks` in a terminal.",
+      tone: "muted",
+    };
+  }
+
+  if (
+    message.includes("Databricks sign-in failed") ||
+    message.includes("Databricks sign-in timed out")
+  ) {
+    return {
+      message:
+        "Databricks sign-in didn't complete. Open the model picker to retry, or run `buzz-agent auth databricks` in a terminal.",
+      tone: "warning",
+    };
+  }
+
+  return null;
+}
diff --git a/desktop/src/features/channel-templates/focusRefetchPolicy.test.mjs b/desktop/src/features/channel-templates/focusRefetchPolicy.test.mjs
index 8edc822c868..d8a8d979075 100644
--- a/desktop/src/features/channel-templates/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/channel-templates/focusRefetchPolicy.test.mjs
@@ -54,12 +54,12 @@ test("channel-templates: skips fresh focus refetch", async () => {
   );
 });
 
-test("channel-templates: refetches genuinely stale data on focus", async () => {
+test("channel-templates: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: channelTemplatesFocusRefetchPolicy.staleTime + 1,
       policy: channelTemplatesFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
diff --git a/desktop/src/features/channel-templates/hooks.ts b/desktop/src/features/channel-templates/hooks.ts
index d0f2e73d02f..be62b101b76 100644
--- a/desktop/src/features/channel-templates/hooks.ts
+++ b/desktop/src/features/channel-templates/hooks.ts
@@ -24,7 +24,7 @@ export const CHANNEL_TEMPLATES_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy for the channel templates query; consumed by focusRefetchPolicy.test.mjs. */
 export const channelTemplatesFocusRefetchPolicy = {
   staleTime: CHANNEL_TEMPLATES_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 export const channelTemplatesQueryKey = ["channel-templates"] as const;
diff --git a/desktop/src/features/channels/channelSnapshot.test.mjs b/desktop/src/features/channels/channelSnapshot.test.mjs
index 5355bfe6f17..221f144d0b5 100644
--- a/desktop/src/features/channels/channelSnapshot.test.mjs
+++ b/desktop/src/features/channels/channelSnapshot.test.mjs
@@ -3,6 +3,7 @@ import test from "node:test";
 
 import {
   channelSnapshotKey,
+  inspectChannelSnapshot,
   readChannelSnapshot,
   removeChannelSnapshotForRelay,
   writeChannelSnapshot,
@@ -12,6 +13,10 @@ if (typeof globalThis.window === "undefined") {
   const storage = new Map();
   globalThis.window = {
     localStorage: {
+      get length() {
+        return storage.size;
+      },
+      key: (index) => [...storage.keys()][index] ?? null,
       getItem: (key) => storage.get(key) ?? null,
       setItem: (key, value) => storage.set(key, value),
       removeItem: (key) => storage.delete(key),
@@ -42,49 +47,214 @@ function makeChannel(overrides = {}) {
 }
 
 const RELAY = "wss://relay.example.com";
+const OWNER = "ABCDEF";
+const HASH = "channels-hash-v2";
+
+test.beforeEach(() => {
+  removeChannelSnapshotForRelay(RELAY);
+  removeChannelSnapshotForRelay("wss://other.example.com");
+});
 
 test("channelSnapshotKey: normalizes trailing slash and case", () => {
   assert.equal(
-    channelSnapshotKey("WSS://Relay.Example.com/"),
-    channelSnapshotKey("wss://relay.example.com"),
+    channelSnapshotKey("WSS://Relay.Example.com/", OWNER),
+    channelSnapshotKey("wss://relay.example.com", OWNER.toLowerCase()),
   );
 });
 
-test("read after write returns the persisted channels", () => {
-  const channels = [makeChannel(), makeChannel({ id: "chan-2", name: "Dev" })];
-  writeChannelSnapshot(RELAY, channels);
-  assert.deepEqual(readChannelSnapshot(RELAY), channels);
+test("read after write returns the complete list and matching hash", () => {
+  const channels = Array.from({ length: 14 }, (_, index) =>
+    makeChannel({ id: `chan-${index}`, name: `Channel ${index}` }),
+  );
+
+  writeChannelSnapshot(RELAY, OWNER, channels, HASH);
+
+  const snapshot = readChannelSnapshot(RELAY, OWNER.toLowerCase());
+  assert.deepEqual(snapshot, { channels, hash: HASH });
+  assert.equal(snapshot.channels.length, channels.length);
+
+  const { diagnostics } = inspectChannelSnapshot(RELAY, OWNER);
+  assert.equal(diagnostics.presence, "present");
+  assert.equal(diagnostics.channelCount, channels.length);
+  assert.ok(diagnostics.serializedBytes > 0);
+  assert.ok(diagnostics.ageMs >= 0);
+});
+
+test("inspection distinguishes absent from invalid snapshots", () => {
+  assert.deepEqual(inspectChannelSnapshot(RELAY, OWNER), {
+    diagnostics: {
+      ageMs: 0,
+      channelCount: 0,
+      presence: "absent",
+      serializedBytes: 0,
+    },
+    snapshot: null,
+  });
+
+  window.localStorage.setItem(channelSnapshotKey(RELAY, OWNER), "not-json{{{");
+  const invalid = inspectChannelSnapshot(RELAY, OWNER);
+  assert.equal(invalid.snapshot, null);
+  assert.equal(invalid.diagnostics.presence, "invalid");
+  assert.ok(invalid.diagnostics.serializedBytes > 0);
+});
+
+test("inspection memoizes parsing for repeated reads of the same document", () => {
+  writeChannelSnapshot(RELAY, OWNER, [makeChannel()], "memo-hash");
+  const originalParse = JSON.parse;
+  let parses = 0;
+  JSON.parse = (...args) => {
+    parses += 1;
+    return originalParse(...args);
+  };
+  try {
+    assert.notEqual(inspectChannelSnapshot(RELAY, OWNER).snapshot, null);
+    assert.notEqual(inspectChannelSnapshot(RELAY, OWNER).snapshot, null);
+    assert.equal(parses, 1);
+  } finally {
+    JSON.parse = originalParse;
+  }
+});
+
+test("inspection tolerates denied storage without retrying the read", () => {
+  const original = window.localStorage;
+  let reads = 0;
+  window.localStorage = {
+    get length() {
+      return 0;
+    },
+    key: () => null,
+    getItem: () => {
+      reads += 1;
+      throw new DOMException("storage denied", "SecurityError");
+    },
+    setItem: () => {},
+    removeItem: () => {},
+  };
+  try {
+    assert.deepEqual(inspectChannelSnapshot(RELAY, OWNER), {
+      diagnostics: {
+        ageMs: 0,
+        channelCount: 0,
+        presence: "absent",
+        serializedBytes: 0,
+      },
+      snapshot: null,
+    });
+    assert.equal(reads, 1);
+  } finally {
+    window.localStorage = original;
+  }
+});
+
+test("write replaces list and hash in lockstep", () => {
+  writeChannelSnapshot(RELAY, OWNER, [makeChannel()], "old-hash");
+  const channels = [
+    makeChannel({ id: "chan-2", name: "Dev" }),
+    makeChannel({ id: "chan-3", name: "Design" }),
+  ];
+
+  writeChannelSnapshot(RELAY, OWNER, channels, "new-hash");
+
+  assert.deepEqual(readChannelSnapshot(RELAY, OWNER), {
+    channels,
+    hash: "new-hash",
+  });
 });
 
 test("read for an unknown relay returns null", () => {
-  assert.equal(readChannelSnapshot("wss://never-written.example.com"), null);
+  assert.equal(
+    readChannelSnapshot("wss://never-written.example.com", OWNER),
+    null,
+  );
 });
 
-test("read returns null for malformed JSON", () => {
-  window.localStorage.setItem(channelSnapshotKey(RELAY), "not-json{{{");
-  assert.equal(readChannelSnapshot(RELAY), null);
+test("read rejects malformed JSON", () => {
+  window.localStorage.setItem(channelSnapshotKey(RELAY, OWNER), "not-json{{{");
+  assert.equal(readChannelSnapshot(RELAY, OWNER), null);
 });
 
-test("read returns null for a wrong-version payload", () => {
+test("read rejects a legacy channel-only snapshot", () => {
   window.localStorage.setItem(
-    channelSnapshotKey(RELAY),
-    JSON.stringify({ version: 2, channels: [makeChannel()] }),
+    channelSnapshotKey(RELAY, OWNER),
+    JSON.stringify({ version: 1, channels: [makeChannel()] }),
   );
-  assert.equal(readChannelSnapshot(RELAY), null);
+  assert.equal(readChannelSnapshot(RELAY, OWNER), null);
 });
 
-test("read returns null when channels is not an array", () => {
+test("read rejects a snapshot whose hash and list were partially changed", () => {
+  writeChannelSnapshot(RELAY, OWNER, [makeChannel()], "old-hash");
+  const key = channelSnapshotKey(RELAY, OWNER);
+  const stored = JSON.parse(window.localStorage.getItem(key));
   window.localStorage.setItem(
-    channelSnapshotKey(RELAY),
-    JSON.stringify({ version: 1, channels: "nope" }),
+    key,
+    JSON.stringify({ ...stored, hash: "newer-partial-hash" }),
+  );
+
+  assert.equal(readChannelSnapshot(RELAY, OWNER), null);
+  assert.equal(
+    inspectChannelSnapshot(RELAY, OWNER).diagnostics.presence,
+    "invalid",
   );
-  assert.equal(readChannelSnapshot(RELAY), null);
 });
 
-test("remove clears the snapshot for that relay", () => {
-  writeChannelSnapshot(RELAY, [makeChannel()]);
+test("read rejects a v2 snapshot with a missing hash", () => {
+  window.localStorage.setItem(
+    channelSnapshotKey(RELAY, OWNER),
+    JSON.stringify({
+      version: 2,
+      updatedAt: Date.now(),
+      ownerPubkey: OWNER,
+      channels: [makeChannel()],
+    }),
+  );
+  assert.equal(readChannelSnapshot(RELAY, OWNER), null);
+});
+
+test("read rejects a snapshot owned by another identity", () => {
+  writeChannelSnapshot(RELAY, OWNER, [makeChannel()], HASH);
+  assert.equal(readChannelSnapshot(RELAY, "different-owner"), null);
+});
+
+test("same-relay identities retain independent snapshots", () => {
+  const ownerAChannels = [makeChannel({ id: "owner-a", name: "Owner A" })];
+  const ownerBChannels = [makeChannel({ id: "owner-b", name: "Owner B" })];
+
+  writeChannelSnapshot(RELAY, OWNER, ownerAChannels, "owner-a-hash");
+  writeChannelSnapshot(
+    RELAY,
+    "different-owner",
+    ownerBChannels,
+    "owner-b-hash",
+  );
+
+  assert.deepEqual(readChannelSnapshot(RELAY, OWNER), {
+    channels: ownerAChannels,
+    hash: "owner-a-hash",
+  });
+  assert.deepEqual(readChannelSnapshot(RELAY, "different-owner"), {
+    channels: ownerBChannels,
+    hash: "owner-b-hash",
+  });
+});
+
+test("remove clears every identity snapshot for that relay", () => {
+  writeChannelSnapshot(RELAY, OWNER, [makeChannel()], HASH);
+  writeChannelSnapshot(
+    RELAY,
+    "different-owner",
+    [makeChannel({ id: "owner-b" })],
+    "owner-b-hash",
+  );
+  writeChannelSnapshot(
+    "wss://other.example.com",
+    OWNER,
+    [makeChannel({ id: "other-relay" })],
+    "other-relay-hash",
+  );
   removeChannelSnapshotForRelay(RELAY);
-  assert.equal(readChannelSnapshot(RELAY), null);
+  assert.equal(readChannelSnapshot(RELAY, OWNER), null);
+  assert.equal(readChannelSnapshot(RELAY, "different-owner"), null);
+  assert.notEqual(readChannelSnapshot("wss://other.example.com", OWNER), null);
 });
 
 test("cache write evicts disposable entries and retries at quota", () => {
@@ -108,8 +278,11 @@ test("cache write evicts disposable entries and retries at quota", () => {
     removeItem: (key) => storage.delete(key),
   };
   try {
-    writeChannelSnapshot(RELAY, [makeChannel()]);
-    assert.deepEqual(readChannelSnapshot(RELAY), [makeChannel()]);
+    writeChannelSnapshot(RELAY, OWNER, [makeChannel()], HASH);
+    assert.deepEqual(readChannelSnapshot(RELAY, OWNER), {
+      channels: [makeChannel()],
+      hash: HASH,
+    });
     assert.equal(storage.has("buzz-channel-messages.v1:relay:old"), false);
     assert.equal(storage.has("buzz-timeline-skeleton-shape.v1:old"), false);
   } finally {
@@ -123,7 +296,9 @@ test("write is tolerant of storage failures", () => {
     throw new Error("quota exceeded");
   };
   try {
-    assert.doesNotThrow(() => writeChannelSnapshot(RELAY, [makeChannel()]));
+    assert.doesNotThrow(() =>
+      writeChannelSnapshot(RELAY, OWNER, [makeChannel()], HASH),
+    );
   } finally {
     window.localStorage.setItem = original;
   }
diff --git a/desktop/src/features/channels/channelSnapshot.ts b/desktop/src/features/channels/channelSnapshot.ts
index 265b675790e..0e3cfc048db 100644
--- a/desktop/src/features/channels/channelSnapshot.ts
+++ b/desktop/src/features/channels/channelSnapshot.ts
@@ -7,8 +7,9 @@
  * channel list per relay so the sidebar can paint instantly from the snapshot
  * while the live fetch revalidates in the background.
  *
- * Keyed per relay URL (not community id) so equivalent URL formatting maps to
- * one slot and one relay's list never bleeds into another.
+ * Keyed per normalized relay URL and authoritative identity so identities that
+ * share a relay retain independent snapshots without exposing either list to
+ * the other.
  */
 
 import type { Channel } from "@/shared/api/types";
@@ -17,57 +18,239 @@ import { setLocalStorageItemWithRecovery } from "@/shared/lib/localStorageQuota"
 
 const STORAGE_KEY_PREFIX = "buzz-channels.v1";
 
-export function channelSnapshotKey(relayUrl: string): string {
-  return `${STORAGE_KEY_PREFIX}:${normalizeRelayUrl(relayUrl)}`;
+export type ChannelSnapshot = {
+  channels: Channel[];
+  hash: string;
+};
+
+export type ChannelSnapshotDiagnostics = {
+  ageMs: number;
+  channelCount: number;
+  presence: "absent" | "invalid" | "present";
+  serializedBytes: number;
+};
+
+export type ChannelSnapshotReadResult = {
+  diagnostics: ChannelSnapshotDiagnostics;
+  snapshot: ChannelSnapshot | null;
+};
+
+type StoredChannelSnapshot = ChannelSnapshot & {
+  version: 2;
+  updatedAt: number;
+  ownerPubkey: string;
+  integrity: string;
+};
+
+function channelSnapshotRelayPrefix(relayUrl: string): string {
+  return `${STORAGE_KEY_PREFIX}:${normalizeRelayUrl(relayUrl)}:`;
+}
+
+export function channelSnapshotKey(
+  relayUrl: string,
+  ownerPubkey: string,
+): string {
+  return `${channelSnapshotRelayPrefix(relayUrl)}${ownerPubkey.toLowerCase()}`;
 }
 
-function parseChannelSnapshot(json: unknown): Channel[] | null {
+function snapshotIntegrity(
+  ownerPubkey: string,
+  hash: string,
+  channels: Channel[],
+): string {
+  const value = JSON.stringify([ownerPubkey.toLowerCase(), hash, channels]);
+  let result = 0x811c9dc5;
+  for (let index = 0; index < value.length; index += 1) {
+    result ^= value.charCodeAt(index);
+    result = Math.imul(result, 0x01000193);
+  }
+  return (result >>> 0).toString(16).padStart(8, "0");
+}
+
+function parseChannelSnapshot(
+  json: unknown,
+  ownerPubkey: string,
+): ChannelSnapshot | null {
   if (typeof json !== "object" || json === null) return null;
   const obj = json as Record<string, unknown>;
-  if (obj.version !== 1 || !Array.isArray(obj.channels)) return null;
-  return obj.channels as Channel[];
+
+  // Version 1 did not record either the list hash or the owning identity. It
+  // cannot safely seed version 2: painting it could expose another identity's
+  // channels, and pairing it with any hash could suppress the corrective read.
+  if (
+    obj.version !== 2 ||
+    !Array.isArray(obj.channels) ||
+    typeof obj.hash !== "string" ||
+    obj.hash.length === 0 ||
+    typeof obj.updatedAt !== "number" ||
+    !Number.isFinite(obj.updatedAt) ||
+    typeof obj.ownerPubkey !== "string" ||
+    obj.ownerPubkey.toLowerCase() !== ownerPubkey.toLowerCase()
+  ) {
+    return null;
+  }
+
+  const channels = obj.channels as Channel[];
+  if (
+    typeof obj.integrity !== "string" ||
+    obj.integrity !== snapshotIntegrity(ownerPubkey, obj.hash, channels)
+  ) {
+    return null;
+  }
+
+  return { channels, hash: obj.hash };
+}
+
+function serializedBytes(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+type ParsedChannelSnapshotCacheEntry = {
+  presence: "invalid" | "present";
+  raw: string;
+  serializedBytes: number;
+  snapshot: ChannelSnapshot | null;
+  updatedAt: number | null;
+};
+
+const parsedSnapshotCache = new Map<string, ParsedChannelSnapshotCacheEntry>();
+
+function snapshotResultFromRaw(
+  key: string,
+  raw: string,
+  ownerPubkey: string,
+): ChannelSnapshotReadResult {
+  let cached = parsedSnapshotCache.get(key);
+  if (!cached || cached.raw !== raw) {
+    let parsedJson: Record<string, unknown> | null = null;
+    try {
+      parsedJson = JSON.parse(raw) as Record<string, unknown>;
+    } catch {
+      // Malformed snapshots are invalid cache entries, never fatal reads.
+    }
+    const snapshot = parsedJson
+      ? parseChannelSnapshot(parsedJson, ownerPubkey)
+      : null;
+    const updatedAt =
+      parsedJson &&
+      typeof parsedJson.updatedAt === "number" &&
+      Number.isFinite(parsedJson.updatedAt)
+        ? parsedJson.updatedAt
+        : null;
+    cached = {
+      presence: snapshot ? "present" : "invalid",
+      raw,
+      serializedBytes: serializedBytes(raw),
+      snapshot,
+      updatedAt,
+    };
+    parsedSnapshotCache.set(key, cached);
+  }
+
+  return {
+    diagnostics: {
+      ageMs:
+        cached.updatedAt === null
+          ? 0
+          : Math.max(0, Date.now() - cached.updatedAt),
+      channelCount: cached.snapshot?.channels.length ?? 0,
+      presence: cached.presence,
+      serializedBytes: cached.serializedBytes,
+    },
+    snapshot: cached.snapshot,
+  };
 }
 
 /**
- * Reads the cached channel list for a relay, or null when absent or malformed.
+ * Reads the atomic snapshot and reports why it can or cannot seed the sidebar.
+ * Invalid includes malformed, legacy, hashless, partial, and wrong-owner data.
+ * Parsing and integrity validation are memoized by storage key and raw value so
+ * repeated hook consumers do not rescan the same multi-megabyte document.
  */
-export function readChannelSnapshot(relayUrl: string): Channel[] | null {
+export function inspectChannelSnapshot(
+  relayUrl: string,
+  ownerPubkey: string,
+): ChannelSnapshotReadResult {
+  const absent: ChannelSnapshotDiagnostics = {
+    ageMs: 0,
+    channelCount: 0,
+    presence: "absent",
+    serializedBytes: 0,
+  };
+  const key = channelSnapshotKey(relayUrl, ownerPubkey);
+  let raw: string | null = null;
+
   try {
-    const raw = window.localStorage.getItem(channelSnapshotKey(relayUrl));
-    if (!raw) return null;
-    return parseChannelSnapshot(JSON.parse(raw));
+    raw = window.localStorage.getItem(key);
+    if (!raw) return { diagnostics: absent, snapshot: null };
+    return snapshotResultFromRaw(key, raw, ownerPubkey);
   } catch {
-    return null;
+    // `getItem` itself can throw when WebKit denies storage access. Never retry
+    // that read from the catch path: snapshot hydration is optional and must
+    // degrade to a live fetch rather than escaping into the render tree.
+    return {
+      diagnostics: {
+        ...absent,
+        presence: raw === null ? "absent" : "invalid",
+        serializedBytes: raw === null ? 0 : serializedBytes(raw),
+      },
+      snapshot: null,
+    };
   }
 }
 
 /**
- * Persists the channel list for a relay. Skips the write when unchanged so the
- * 60s background refetch does not re-serialize an identical list. Non-fatal on
+ * Reads the atomic channel-list/hash snapshot for an identity and relay, or
+ * null when absent, malformed, legacy, or owned by another identity.
+ */
+export function readChannelSnapshot(
+  relayUrl: string,
+  ownerPubkey: string,
+): ChannelSnapshot | null {
+  return inspectChannelSnapshot(relayUrl, ownerPubkey).snapshot;
+}
+
+/**
+ * Persists the complete last successfully fetched channel list and the hash
+ * that describes it as one document. Atomic replacement prevents a stale hash
+ * from ever being paired with a newer list (or vice versa). Non-fatal on
  * storage failure (e.g. quota exceeded).
  */
 export function writeChannelSnapshot(
   relayUrl: string,
+  ownerPubkey: string,
   channels: Channel[],
+  hash: string,
 ): void {
   try {
-    const key = channelSnapshotKey(relayUrl);
+    if (!ownerPubkey || !hash) return;
+
+    const key = channelSnapshotKey(relayUrl, ownerPubkey);
     const previous = window.localStorage.getItem(key);
     if (previous) {
       try {
-        const parsed = parseChannelSnapshot(JSON.parse(previous));
-        if (parsed && JSON.stringify(parsed) === JSON.stringify(channels))
+        const parsed = parseChannelSnapshot(JSON.parse(previous), ownerPubkey);
+        if (
+          parsed &&
+          parsed.hash === hash &&
+          JSON.stringify(parsed.channels) === JSON.stringify(channels)
+        ) {
           return;
+        }
       } catch {
         // Malformed snapshots are replaced below.
       }
     }
-    const serialized = JSON.stringify({
-      version: 1,
+
+    const snapshot: StoredChannelSnapshot = {
+      version: 2,
       updatedAt: Date.now(),
+      ownerPubkey: ownerPubkey.toLowerCase(),
+      hash,
       channels,
-    });
-    setLocalStorageItemWithRecovery(key, serialized);
+      integrity: snapshotIntegrity(ownerPubkey, hash, channels),
+    };
+    setLocalStorageItemWithRecovery(key, JSON.stringify(snapshot));
   } catch {
     // Storage access failures are non-fatal.
   }
@@ -78,7 +261,15 @@ export function writeChannelSnapshot(
  */
 export function removeChannelSnapshotForRelay(relayUrl: string): void {
   try {
-    window.localStorage.removeItem(channelSnapshotKey(relayUrl));
+    const prefix = channelSnapshotRelayPrefix(relayUrl);
+    const keys: string[] = [];
+    for (let index = 0; index < window.localStorage.length; index += 1) {
+      const key = window.localStorage.key(index);
+      if (key?.startsWith(prefix)) keys.push(key);
+    }
+    for (const key of keys) window.localStorage.removeItem(key);
+    // Also clear the superseded relay-only v1/v2 slot.
+    window.localStorage.removeItem(prefix.slice(0, -1));
   } catch {
     // Storage access failures are non-fatal.
   }
diff --git a/desktop/src/features/channels/hooks.test.mjs b/desktop/src/features/channels/hooks.test.mjs
index f802fe87b64..7dee24392f0 100644
--- a/desktop/src/features/channels/hooks.test.mjs
+++ b/desktop/src/features/channels/hooks.test.mjs
@@ -3,7 +3,9 @@ import test from "node:test";
 
 import {
   applyLastMessages,
+  canFetchChannelsForIdentity,
   reconcileRefreshedCachedChannel,
+  requireFullChannelList,
   upsertCachedChannel,
   upsertCachedChannelMember,
 } from "./hooks.ts";
@@ -110,6 +112,21 @@ test("reconcileRefreshedCachedChannel_restoresOpenedDmAfterStaleRefresh", () =>
   assert.deepEqual(reconciled[0], openedDm);
 });
 
+test("identity failure enables a hashless live channel fetch", () => {
+  assert.equal(canFetchChannelsForIdentity(null, false), false);
+  assert.equal(canFetchChannelsForIdentity("owner-pubkey", false), true);
+  assert.equal(canFetchChannelsForIdentity(null, true), true);
+});
+
+test("hashless retry rejects null channels before persistence", () => {
+  const channels = [makeChannel("general", "General")];
+  assert.strictEqual(requireFullChannelList(channels), channels);
+  assert.throws(
+    () => requireFullChannelList(null),
+    /no list for a hashless request/,
+  );
+});
+
 // ── applyLastMessages ─────────────────────────────────────────────────────────
 
 test("applyLastMessages_preservesReferenceWhenTimestampUnchanged", () => {
diff --git a/desktop/src/features/channels/hooks.ts b/desktop/src/features/channels/hooks.ts
index 9c1a91ea410..2d3dd22f05a 100644
--- a/desktop/src/features/channels/hooks.ts
+++ b/desktop/src/features/channels/hooks.ts
@@ -37,7 +37,8 @@ import { useFocusedRefetchInterval } from "@/shared/lib/useDocumentVisible";
 import { useCommunities } from "@/features/communities/useCommunities";
 import { canAddChannelMembers } from "@/features/channels/lib/channelMemberAdmission";
 import {
-  readChannelSnapshot,
+  inspectChannelSnapshot,
+  type ChannelSnapshot,
   writeChannelSnapshot,
 } from "@/features/channels/channelSnapshot";
 
@@ -50,15 +51,13 @@ export const CHANNELS_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy for the channels query; consumed by focusRefetchPolicy.test.mjs. */
 export const channelsFocusRefetchPolicy = {
   staleTime: CHANNELS_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 /**
- * Query-cache key for the channels payload hash. Stored alongside the channel
- * list so its lifecycle is tied to the channel cache — a community switch that
- * evicts the channel cache implicitly invalidates the stored hash, preventing a
- * stale hash from short-circuiting into an empty list.
+ * Authoritative server list/hash pair. Presentation mutations may patch
+ * `channelsQueryKey`, but may never change or be persisted with this hash.
  */
-const channelsHashKey = ["channels", "_hash"] as const;
+const channelsSnapshotPairKey = ["channels", "_snapshot-pair"] as const;
 const channelDetailQueryKey = (channelId: string) =>
   ["channels", channelId, "detail"] as const;
 const channelMembersQueryKey = (channelId: string) =>
@@ -88,6 +87,73 @@ function sortChannels(channels: Channel[]) {
   });
 }
 
+export const CHANNELS_SNAPSHOT_DIAGNOSTIC_MARK =
+  "buzz:sidebar:snapshot-diagnostic";
+export const CHANNELS_FULL_SIDEBAR_PAINT_MARK =
+  "buzz:sidebar:full-list-painted";
+export const CHANNELS_BOOT_TO_FULL_SIDEBAR_MEASURE =
+  "buzz:sidebar:boot-to-full-list-painted";
+
+const markedSnapshotKeys = new Set<string>();
+const measuredSidebarKeys = new Set<string>();
+const scheduledSidebarKeys = new Set<string>();
+
+function sidebarMeasurementKey(relayUrl: string, ownerPubkey: string): string {
+  return `${relayUrl}\u0000${ownerPubkey.toLowerCase()}`;
+}
+
+function markSnapshotDiagnostic(
+  relayUrl: string,
+  ownerPubkey: string,
+  diagnostics: ReturnType<typeof inspectChannelSnapshot>["diagnostics"],
+): void {
+  if (typeof performance === "undefined") return;
+  const key = sidebarMeasurementKey(relayUrl, ownerPubkey);
+  if (markedSnapshotKeys.has(key)) return;
+  markedSnapshotKeys.add(key);
+  performance.mark(CHANNELS_SNAPSHOT_DIAGNOSTIC_MARK, {
+    detail: { ...diagnostics, relayUrl },
+  });
+  console.info("[sidebar-perf] snapshot", { ...diagnostics, relayUrl });
+}
+
+function measureFullSidebarPaint(
+  relayUrl: string,
+  ownerPubkey: string,
+  channelCount: number,
+): void {
+  if (typeof performance === "undefined") return;
+  const key = sidebarMeasurementKey(relayUrl, ownerPubkey);
+  if (measuredSidebarKeys.has(key) || scheduledSidebarKeys.has(key)) return;
+  scheduledSidebarKeys.add(key);
+
+  // The channels have committed to the shared query cache; two animation frames
+  // put the mark after React's sidebar DOM commit and the browser's next paint.
+  window.requestAnimationFrame(() => {
+    window.requestAnimationFrame(() => {
+      scheduledSidebarKeys.delete(key);
+      if (measuredSidebarKeys.has(key)) return;
+      measuredSidebarKeys.add(key);
+      performance.mark(CHANNELS_FULL_SIDEBAR_PAINT_MARK, {
+        detail: { channelCount, relayUrl },
+      });
+      performance.measure(CHANNELS_BOOT_TO_FULL_SIDEBAR_MEASURE, {
+        detail: { channelCount, relayUrl },
+        duration: performance.now(),
+        start: 0,
+      });
+      const measure = performance
+        .getEntriesByName(CHANNELS_BOOT_TO_FULL_SIDEBAR_MEASURE)
+        .at(-1);
+      console.info("[sidebar-perf] full list painted", {
+        channelCount,
+        durationMs: measure?.duration,
+        relayUrl,
+      });
+    });
+  });
+}
+
 export type CachedChannelMember = {
   membershipAdded: boolean;
   name: string;
@@ -227,69 +293,162 @@ export function applyLastMessages(
   });
 }
 
+/**
+ * A failed identity read must disable persisted snapshots, not the live channel
+ * request. The backend still resolves its authoritative current identity.
+ */
+export function canFetchChannelsForIdentity(
+  ownerPubkey: string | null,
+  identityReadFailed: boolean,
+): boolean {
+  return ownerPubkey !== null || identityReadFailed;
+}
+
+/** A hashless retry must return a full list before it can become authoritative. */
+export function requireFullChannelList(channels: Channel[] | null): Channel[] {
+  if (channels === null) {
+    throw new Error("get_channels returned no list for a hashless request");
+  }
+  return channels;
+}
+
 export function useChannelsQuery(options?: { enabled?: boolean }) {
   const { activeCommunity } = useCommunities();
   const relayUrl = activeCommunity?.relayUrl ?? null;
+  // CommunityQueryProvider remounts its QueryClient for every community. Only
+  // the active identity may authorize a persisted snapshot: Community.pubkey
+  // is creation-time display metadata and can be stale after identity changes.
+  const identityQuery = useIdentityQuery();
+  const ownerPubkey = identityQuery.data?.pubkey ?? null;
+  const queryClient = useQueryClient();
+  const snapshotRead = React.useMemo(
+    () =>
+      relayUrl && ownerPubkey
+        ? inspectChannelSnapshot(relayUrl, ownerPubkey)
+        : null,
+    [ownerPubkey, relayUrl],
+  );
+  const snapshot = snapshotRead?.snapshot ?? null;
+  const initialSnapshotPair = React.useMemo(
+    () =>
+      snapshot
+        ? { channels: sortChannels(snapshot.channels), hash: snapshot.hash }
+        : null,
+    [snapshot],
+  );
+  React.useEffect(() => {
+    if (relayUrl && ownerPubkey && snapshotRead && options?.enabled !== false) {
+      markSnapshotDiagnostic(relayUrl, ownerPubkey, snapshotRead.diagnostics);
+    }
+  }, [options?.enabled, ownerPubkey, relayUrl, snapshotRead]);
   const refetchInterval = useFocusedRefetchInterval(
     CHANNELS_REFETCH_INTERVAL_MS,
   );
-  const queryClient = useQueryClient();
 
-  return useQuery({
-    enabled: options?.enabled ?? true,
+  const query = useQuery({
+    enabled:
+      (options?.enabled ?? true) &&
+      relayUrl !== null &&
+      canFetchChannelsForIdentity(ownerPubkey, identityQuery.isError),
     queryKey: channelsQueryKey,
     queryFn: async () => {
-      // Supply the stored hash only when the channel list is still in cache.
-      // If cache is absent (community switch, eviction) we send null so the
-      // Rust side never short-circuits into an empty list.
-      const cachedChannels =
-        queryClient.getQueryData<Channel[]>(channelsQueryKey);
-      const knownHash = cachedChannels
-        ? (queryClient.getQueryData<string>(channelsHashKey) ?? null)
-        : null;
+      // Revalidation uses only an authoritative list/hash pair. The displayed
+      // channels cache is intentionally ignored because successful mutations
+      // patch it before the relay's list/hash has necessarily caught up.
+      const cachedPair =
+        queryClient.getQueryData<ChannelSnapshot>(channelsSnapshotPairKey) ??
+        initialSnapshotPair;
+      const knownHash = cachedPair?.hash ?? null;
 
       const payload = await getChannels(knownHash);
 
-      // Pin the hash alongside the channel cache so it is implicitly
-      // invalidated whenever the channel list is evicted.
-      queryClient.setQueryData(channelsHashKey, payload.hash);
-
-      // Determine the base channel list: full payload on a normal response,
-      // or the still-valid cached list on a not-modified (channels === null) response.
-      const base = payload.channels ?? cachedChannels;
-
-      if (!base) {
-        // hash-match but cache somehow empty — shouldn't happen given the
-        // null-hash guard above, but handle defensively by re-fetching without
-        // the stale hash so we always have a channel list to return.
+      // A not-modified response is usable only when it echoes the exact hash
+      // that described the available list. Any other hash/list pairing fails
+      // slow-never-wrong by retrying without a hash.
+      const hasMatchingNotModifiedResponse =
+        payload.channels === null &&
+        knownHash !== null &&
+        payload.hash === knownHash;
+      const pairChannels =
+        payload.channels ??
+        (hasMatchingNotModifiedResponse ? cachedPair?.channels : undefined);
+
+      if (!pairChannels) {
+        // Missing cache or a mismatched not-modified response: discard the hash
+        // and fetch a complete authoritative list before updating persistence.
         const full = await getChannels(null);
-        queryClient.setQueryData(channelsHashKey, full.hash);
         const sorted = sortChannels(
-          applyLastMessages(full.channels ?? [], full.lastMessages),
+          applyLastMessages(
+            requireFullChannelList(full.channels),
+            full.lastMessages,
+          ),
         );
-        if (relayUrl) writeChannelSnapshot(relayUrl, sorted);
+        const pair = { channels: sorted, hash: full.hash };
+        queryClient.setQueryData(channelsSnapshotPairKey, pair);
+        if (relayUrl && ownerPubkey) {
+          writeChannelSnapshot(relayUrl, ownerPubkey, pair.channels, pair.hash);
+        }
         return sorted;
       }
 
-      const sorted = sortChannels(
-        applyLastMessages(base, payload.lastMessages),
+      const authoritativeChannels = sortChannels(
+        applyLastMessages(pairChannels, payload.lastMessages),
       );
-      if (relayUrl) writeChannelSnapshot(relayUrl, sorted);
+      const pair = {
+        channels: authoritativeChannels,
+        hash: payload.hash,
+      };
+      queryClient.setQueryData(channelsSnapshotPairKey, pair);
+      // A matching not-modified result must merge timestamps into whatever is
+      // displayed at completion time. Reading through setQueryData avoids
+      // clobbering an optimistic mutation that landed while the request ran.
+      const sorted =
+        payload.channels === null
+          ? (queryClient.setQueryData<Channel[]>(
+              channelsQueryKey,
+              (displayedChannels) =>
+                sortChannels(
+                  applyLastMessages(
+                    displayedChannels ?? authoritativeChannels,
+                    payload.lastMessages,
+                  ),
+                ),
+            ) ?? authoritativeChannels)
+          : authoritativeChannels;
+      if (relayUrl && ownerPubkey) {
+        writeChannelSnapshot(relayUrl, ownerPubkey, pair.channels, pair.hash);
+      }
       return sorted;
     },
-    // Paint the sidebar instantly from the last-known list for this relay, then
-    // revalidate. initialDataUpdatedAt:0 marks the seed as already-stale so the
-    // background refetch still fires immediately.
-    initialData: relayUrl
-      ? () => {
-          const snapshot = readChannelSnapshot(relayUrl);
-          return snapshot ? sortChannels(snapshot) : undefined;
-        }
-      : undefined,
+    // Paint the complete persisted list immediately. `initialDataUpdatedAt: 0`
+    // deliberately keeps it stale so every boot still validates against the
+    // relay; queryFn reads the matching hash from the same atomic document.
+    initialData: initialSnapshotPair?.channels,
     initialDataUpdatedAt: 0,
     refetchInterval,
     ...channelsFocusRefetchPolicy,
   });
+
+  React.useEffect(() => {
+    if (
+      relayUrl &&
+      ownerPubkey &&
+      query.isSuccess &&
+      query.fetchStatus === "idle" &&
+      query.dataUpdatedAt > 0
+    ) {
+      measureFullSidebarPaint(relayUrl, ownerPubkey, query.data.length);
+    }
+  }, [
+    query.data,
+    query.dataUpdatedAt,
+    query.fetchStatus,
+    query.isSuccess,
+    ownerPubkey,
+    relayUrl,
+  ]);
+
+  return query;
 }
 
 export function useCreateChannelMutation() {
diff --git a/desktop/src/features/channels/threadActivityStorage.ts b/desktop/src/features/channels/threadActivityStorage.ts
index 4e7c65a872a..eca3f97b5dd 100644
--- a/desktop/src/features/channels/threadActivityStorage.ts
+++ b/desktop/src/features/channels/threadActivityStorage.ts
@@ -118,3 +118,91 @@ export function addThreadActivityItems(
 
   return { didAdd: true, items: capped };
 }
+
+/**
+ * One-time removal of the orphaned pre-relay-scoping key
+ * `buzz-thread-activity.v1:<pubkey>`. The legacy pubkey-only writer was dropped
+ * when the key became relay-scoped, but the old ~400 KB blob is never read and
+ * is absent from the quota-sweep whitelist, so it lingers as dead weight.
+ * removeItem on an absent key is a no-op, so running this on every identity
+ * load is idempotent and self-terminating.
+ */
+export function removeLegacyThreadActivityKey(pubkey: string): void {
+  try {
+    window.localStorage.removeItem(`${ACTIVITY_STORAGE_PREFIX}:${pubkey}`);
+  } catch {
+    // Ignore storage errors.
+  }
+}
+
+// ─── Coalesced persistence writer (first-writer-wins + flush) ─────────────────
+//
+// The full item list is one ~600 KB JSON.stringify+setItem. Writing it on every
+// incoming reply drives the renderer stall this coalescing exists to fix, so the
+// scheduler collapses a burst of writes into one setItem ~1 s later. The live
+// buffer (itemsRef) stays the source of truth between flushes; the timer reads
+// it at fire time, so the persisted blob is always the burst's final state.
+
+const WRITE_DEBOUNCE_MS = 1_000;
+
+export type ThreadActivityRefs = {
+  itemsRef: { current: ThreadActivityItem[] };
+  scopeLoadedRef: { current: string };
+  timerRef: { current: ReturnType<typeof setTimeout> | null };
+};
+
+/**
+ * Inverse of activityScopeKey: split "pubkey:normalizedRelayUrl" back into its
+ * parts. The pubkey is colon-free, so the first colon is the boundary. Returns
+ * null for an empty or malformed scope.
+ */
+function decomposeScope(
+  scope: string,
+): { pubkey: string; relayUrl: string } | null {
+  if (!scope) return null;
+  const colonIdx = scope.indexOf(":");
+  if (colonIdx === -1) return null;
+  const pubkey = scope.slice(0, colonIdx);
+  const relayUrl = scope.slice(colonIdx + 1);
+  return pubkey && relayUrl ? { pubkey, relayUrl } : null;
+}
+
+/**
+ * Arm a trailing-edge write for `scope`, first-writer-wins: a pending timer is
+ * NOT reset, so a burst of N writes still fires once. The timer reads itemsRef
+ * at fire time and re-checks the loaded scope, so a write that outlives a scope
+ * switch can neither land under the new key nor persist the wrong buffer.
+ */
+export function scheduleThreadActivityWrite(
+  scope: string,
+  refs: ThreadActivityRefs,
+): void {
+  if (!scope || refs.scopeLoadedRef.current !== scope) return;
+  if (refs.timerRef.current !== null) return;
+
+  const parts = decomposeScope(scope);
+  if (!parts) return;
+  const { pubkey, relayUrl } = parts;
+
+  refs.timerRef.current = setTimeout(() => {
+    refs.timerRef.current = null;
+    if (refs.scopeLoadedRef.current !== scope) return;
+    writeActivityToStorage(pubkey, relayUrl, refs.itemsRef.current);
+  }, WRITE_DEBOUNCE_MS);
+}
+
+/**
+ * Synchronously persist a pending write and cancel the timer. A no-op when no
+ * write is pending (the buffer is already durable), so flushing on hidden or
+ * pagehide costs a setItem only when there is unsaved state. Callers MUST flush
+ * before reseeding on a scope switch so the old scope's buffer lands under the
+ * old key.
+ */
+export function flushThreadActivityWrite(refs: ThreadActivityRefs): void {
+  if (refs.timerRef.current === null) return;
+  clearTimeout(refs.timerRef.current);
+  refs.timerRef.current = null;
+  const parts = decomposeScope(refs.scopeLoadedRef.current);
+  if (!parts) return;
+  writeActivityToStorage(parts.pubkey, parts.relayUrl, refs.itemsRef.current);
+}
diff --git a/desktop/src/features/channels/threadActivityWriteScheduler.test.mjs b/desktop/src/features/channels/threadActivityWriteScheduler.test.mjs
new file mode 100644
index 00000000000..e28582610d3
--- /dev/null
+++ b/desktop/src/features/channels/threadActivityWriteScheduler.test.mjs
@@ -0,0 +1,198 @@
+/**
+ * Unit tests for the coalesced thread-activity write scheduler.
+ *
+ * These exercise scheduleThreadActivityWrite / flushThreadActivityWrite /
+ * removeLegacyThreadActivityKey directly against a ref bag, using node:test
+ * fake timers to drive the 1s debounce deterministically. Hook lifecycle
+ * (pagehide/visibility flush, scope-switch hydration) is covered separately in
+ * useThreadActivityPersistence.test.mjs.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, mock, test } from "node:test";
+
+import {
+  activityScopeKey,
+  activityStorageKey,
+  flushThreadActivityWrite,
+  readActivityFromStorage,
+  removeLegacyThreadActivityKey,
+  scheduleThreadActivityWrite,
+} from "./threadActivityStorage.ts";
+
+const originalWindow = globalThis.window;
+
+afterEach(() => {
+  mock.timers.reset();
+  if (originalWindow === undefined) delete globalThis.window;
+  else globalThis.window = originalWindow;
+});
+
+// Install an isolated in-memory localStorage with a setItem counter so a burst
+// can be asserted to collapse to exactly one write.
+function installStore() {
+  const store = new Map();
+  let setItemCalls = 0;
+  globalThis.window = {
+    localStorage: {
+      getItem: (key) => store.get(key) ?? null,
+      setItem: (key, value) => {
+        setItemCalls += 1;
+        store.set(key, value);
+      },
+      removeItem: (key) => store.delete(key),
+    },
+  };
+  return { store, setItemCalls: () => setItemCalls };
+}
+
+function makeRefs(scope, items = []) {
+  return {
+    itemsRef: { current: items },
+    scopeLoadedRef: { current: scope },
+    timerRef: { current: null },
+  };
+}
+
+const RELAY = "wss://relay.example.com";
+
+// ── scheduleThreadActivityWrite ──────────────────────────────────────────────
+
+test("scheduleThreadActivityWrite coalesces a burst of schedules into one setItem", () => {
+  mock.timers.enable({ apis: ["setTimeout"] });
+  const { setItemCalls } = installStore();
+
+  const scope = activityScopeKey("pk1", RELAY);
+  const refs = makeRefs(scope, [{ id: "r1" }]);
+
+  for (let i = 0; i < 5; i += 1) scheduleThreadActivityWrite(scope, refs);
+  assert.equal(setItemCalls(), 0, "no write before the debounce elapses");
+
+  mock.timers.tick(1_000);
+  assert.equal(
+    setItemCalls(),
+    1,
+    "a burst of 5 schedules fires exactly one write",
+  );
+});
+
+test("scheduleThreadActivityWrite persists the live buffer at fire time, not at schedule time", () => {
+  mock.timers.enable({ apis: ["setTimeout"] });
+  installStore();
+
+  const scope = activityScopeKey("pk1", RELAY);
+  const refs = makeRefs(scope, [{ id: "early" }]);
+
+  scheduleThreadActivityWrite(scope, refs);
+  // A second reply lands before the timer fires — the buffer grows in place.
+  refs.itemsRef.current = [{ id: "early" }, { id: "late" }];
+
+  mock.timers.tick(1_000);
+  assert.deepEqual(
+    readActivityFromStorage("pk1", RELAY).map((item) => item.id),
+    ["early", "late"],
+    "the persisted blob reflects the buffer's final state",
+  );
+});
+
+test("scheduleThreadActivityWrite ignores a scope that does not match the loaded scope", () => {
+  mock.timers.enable({ apis: ["setTimeout"] });
+  const { setItemCalls } = installStore();
+
+  const refs = makeRefs(activityScopeKey("pkA", "wss://relay-a.example.com"), [
+    { id: "a1" },
+  ]);
+  scheduleThreadActivityWrite(
+    activityScopeKey("pkB", "wss://relay-b.example.com"),
+    refs,
+  );
+
+  assert.equal(
+    refs.timerRef.current,
+    null,
+    "no timer armed for a mismatched scope",
+  );
+  mock.timers.tick(1_000);
+  assert.equal(setItemCalls(), 0, "a mismatched scope never writes");
+});
+
+test("scheduleThreadActivityWrite timer aborts when the loaded scope changed before it fired", () => {
+  mock.timers.enable({ apis: ["setTimeout"] });
+  const { setItemCalls } = installStore();
+
+  const pkA = "pkA";
+  const relayA = "wss://relay-a.example.com";
+  const scopeA = activityScopeKey(pkA, relayA);
+  const refs = makeRefs(scopeA, [{ id: "a1" }]);
+
+  scheduleThreadActivityWrite(scopeA, refs);
+  // Scope switches out from under the pending timer without cancelling it.
+  refs.scopeLoadedRef.current = activityScopeKey(
+    "pkB",
+    "wss://relay-b.example.com",
+  );
+
+  mock.timers.tick(1_000);
+  assert.equal(setItemCalls(), 0, "a stale-scope timer must not write");
+  assert.equal(
+    readActivityFromStorage(pkA, relayA).length,
+    0,
+    "A's key must stay empty when the timer aborts",
+  );
+});
+
+// ── flushThreadActivityWrite ─────────────────────────────────────────────────
+
+test("flushThreadActivityWrite persists synchronously and cancels the pending timer", () => {
+  mock.timers.enable({ apis: ["setTimeout"] });
+  const { setItemCalls } = installStore();
+
+  const scope = activityScopeKey("pk1", RELAY);
+  const refs = makeRefs(scope, [{ id: "f1" }]);
+
+  scheduleThreadActivityWrite(scope, refs);
+  flushThreadActivityWrite(refs);
+
+  assert.equal(setItemCalls(), 1, "flush writes immediately");
+  assert.equal(refs.timerRef.current, null, "flush cancels the timer");
+  assert.deepEqual(
+    readActivityFromStorage("pk1", RELAY).map((item) => item.id),
+    ["f1"],
+  );
+
+  mock.timers.tick(1_000);
+  assert.equal(
+    setItemCalls(),
+    1,
+    "the cancelled timer never fires a second write",
+  );
+});
+
+test("flushThreadActivityWrite is a no-op when no write is pending", () => {
+  const { setItemCalls } = installStore();
+
+  const refs = makeRefs(activityScopeKey("pk1", RELAY), [{ id: "x" }]);
+  flushThreadActivityWrite(refs);
+
+  assert.equal(setItemCalls(), 0, "no pending timer means no write");
+});
+
+// ── removeLegacyThreadActivityKey ────────────────────────────────────────────
+
+test("removeLegacyThreadActivityKey removes the orphaned pubkey-only key and preserves the scoped key", () => {
+  const { store } = installStore();
+
+  const pubkey = "pk1";
+  const legacyKey = `buzz-thread-activity.v1:${pubkey}`;
+  const scopedKey = activityStorageKey(pubkey, RELAY);
+  store.set(legacyKey, JSON.stringify([{ id: "legacy" }]));
+  store.set(scopedKey, JSON.stringify([{ id: "scoped" }]));
+
+  removeLegacyThreadActivityKey(pubkey);
+  assert.equal(store.has(legacyKey), false, "legacy pubkey-only key removed");
+  assert.equal(store.has(scopedKey), true, "relay-scoped key preserved");
+
+  // Idempotent: a second call on the absent key is a no-op that never throws.
+  removeLegacyThreadActivityKey(pubkey);
+  assert.equal(store.has(legacyKey), false);
+});
diff --git a/desktop/src/features/channels/ui/ChannelManagementAuxiliaryPanel.tsx b/desktop/src/features/channels/ui/ChannelManagementAuxiliaryPanel.tsx
index ccbabbac239..adcb955ede4 100644
--- a/desktop/src/features/channels/ui/ChannelManagementAuxiliaryPanel.tsx
+++ b/desktop/src/features/channels/ui/ChannelManagementAuxiliaryPanel.tsx
@@ -11,6 +11,7 @@ type ChannelManagementAuxiliaryPanelProps = {
   isSinglePanelView: boolean;
   onChannelManagementDeleted?: () => void;
   onCloseChannelManagement?: () => void;
+  onOpenMembers?: () => void;
   onResetThreadPanelWidth: () => void;
   onThreadPanelResizeStart: (
     event: React.PointerEvent<HTMLButtonElement>,
@@ -27,6 +28,7 @@ export function ChannelManagementAuxiliaryPanel({
   isSinglePanelView,
   onChannelManagementDeleted,
   onCloseChannelManagement,
+  onOpenMembers,
   onResetThreadPanelWidth,
   onThreadPanelResizeStart,
   threadPanelWidthPx,
@@ -40,6 +42,7 @@ export function ChannelManagementAuxiliaryPanel({
       currentPubkey={currentPubkey}
       layout={useSplitAuxiliaryPane || isSinglePanelView ? "split" : "overlay"}
       onDeleted={onChannelManagementDeleted}
+      onOpenMembers={onOpenMembers}
       onOpenChange={(nextOpen) => {
         if (!nextOpen) {
           onCloseChannelManagement?.();
diff --git a/desktop/src/features/channels/ui/ChannelManagementSheet.tsx b/desktop/src/features/channels/ui/ChannelManagementSheet.tsx
index ee963ad01dd..566cfa3fabe 100644
--- a/desktop/src/features/channels/ui/ChannelManagementSheet.tsx
+++ b/desktop/src/features/channels/ui/ChannelManagementSheet.tsx
@@ -1,23 +1,13 @@
 import {
   Archive,
+  ArchiveRestore,
   BookOpenText,
-  Copy,
   DoorClosed,
   DoorOpen,
-  FileText,
-  Fingerprint,
-  Eye,
-  Lock,
-  MessageSquare,
-  Pencil,
-  Radio,
-  Type,
-  Users,
-  Zap,
+  Trash2,
 } from "lucide-react";
 import * as React from "react";
 import * as DialogPrimitive from "@radix-ui/react-dialog";
-import { toast } from "sonner";
 
 import {
   useArchiveChannelMutation,
@@ -35,7 +25,7 @@ import {
   DEFAULT_EPHEMERAL_TTL_SECONDS,
   formatTtlDuration,
 } from "@/features/channels/lib/ephemeralChannel";
-import type { Channel } from "@/shared/api/types";
+import type { Channel, ChannelMember } from "@/shared/api/types";
 import { cn } from "@/shared/lib/cn";
 import { useTheme } from "@/shared/theme/ThemeProvider";
 import { Button } from "@/shared/ui/button";
@@ -57,6 +47,7 @@ import {
   getAuxiliaryPanelMode,
 } from "@/shared/layout/AuxiliaryPanel";
 import { useScrollBoundaryLock } from "@/shared/hooks/useScrollBoundaryLock";
+import { useDeferredModalOpen } from "@/shared/ui/deferredModalOpen";
 import {
   OverlayPanelBackdrop,
   PANEL_BASE_CLASS,
@@ -71,21 +62,20 @@ import {
 import { ChannelTypeSettings } from "./ChannelTypeSettings";
 import { ChannelPermissionsSettings } from "./ChannelPermissionsSettings";
 import {
+  ActionFieldRow,
   ChannelHero,
-  ChannelQuickAction,
   CopyFieldRow,
+  EditableInfoFieldRow,
   FieldGroup,
   getMarkdownPreviewText,
   InfoFieldRow,
   IngressRow,
-  NarrativeField,
-  NarrativeGroup,
 } from "./ChannelManagementSheetRows";
 import {
-  ChannelManagementModerationActions,
+  ChannelDeleteConfirmationDialog,
   useChannelModerationCapabilities,
 } from "./ChannelManagementModerationActions";
-import { writeTextToClipboard } from "@/shared/lib/clipboard";
+import { ChannelMemberAvatarStack } from "./ChannelMemberAvatarStack";
 
 type ChannelManagementSheetProps = {
   channel: Channel | null;
@@ -93,6 +83,7 @@ type ChannelManagementSheetProps = {
   currentPubkey?: string;
   layout?: "overlay" | "split";
   onDeleted?: () => void;
+  onOpenMembers?: () => void;
   onOpenChange: (open: boolean) => void;
   open: boolean;
   transparentChrome?: boolean;
@@ -104,6 +95,7 @@ export function ChannelManagementSheet({
   currentPubkey,
   layout = "overlay",
   onDeleted,
+  onOpenMembers,
   onOpenChange,
   open,
   transparentChrome = false,
@@ -138,6 +130,7 @@ export function ChannelManagementSheet({
 
   const { canDeleteChannel, canManageChannel } =
     useChannelModerationCapabilities(membersQuery.data, currentPubkey, open);
+  const canEditChannel = canManageChannel && detail?.channelType !== "dm";
   const canEditNarrative =
     canManageChannel && selfMember !== null && detail?.channelType !== "dm";
   const isArchived =
@@ -170,6 +163,19 @@ export function ChannelManagementSheet({
   const [activeView, setActiveView] = React.useState<"summary" | "canvas">(
     "summary",
   );
+  const { cancelDeferredModalOpen, openNextFrame: openModalNextFrame } =
+    useDeferredModalOpen();
+
+  const openEditDialog = React.useCallback(() => {
+    setIsEditDialogOpen(false);
+    openModalNextFrame(() => setIsEditDialogOpen(true));
+  }, [openModalNextFrame]);
+
+  const openMembersDialog = React.useCallback(() => {
+    if (!onOpenMembers) return;
+
+    openModalNextFrame(onOpenMembers);
+  }, [onOpenMembers, openModalNextFrame]);
 
   // Sync drafts from server only when the sheet opens or the channel changes -
   // not on every background refetch, which would clobber in-flight edits.
@@ -177,6 +183,7 @@ export function ChannelManagementSheet({
   React.useEffect(() => {
     if (!open) {
       // Reset on close so the next open re-syncs from server.
+      cancelDeferredModalOpen();
       syncedForRef.current = null;
       setIsDeleteDialogOpen(false);
       setIsEditDialogOpen(false);
@@ -200,7 +207,7 @@ export function ChannelManagementSheet({
     setTtlSecondsDraft(detail.ttlSeconds ?? DEFAULT_EPHEMERAL_TTL_SECONDS);
     setHasUserEditedChannelDraft(false);
     setActiveView("summary");
-  }, [detail, open]);
+  }, [cancelDeferredModalOpen, detail, open]);
 
   if (!channel) {
     return null;
@@ -261,16 +268,20 @@ export function ChannelManagementSheet({
   const canOpenCanvas = hasCanvas || canEditNarrative;
 
   function handleEditDialogOpenChange(next: boolean) {
-    if (!next) {
-      setNameDraft(resolvedChannel.name);
-      setDescriptionDraft(resolvedChannel.description);
-      setIsPrivateDraft(currentVisibility === "private");
-      setIsEphemeralDraft(currentTtlSeconds !== null);
-      setTtlSecondsDraft(currentTtlSeconds ?? DEFAULT_EPHEMERAL_TTL_SECONDS);
-      setHasUserEditedChannelDraft(false);
+    if (next) {
+      openEditDialog();
+      return;
     }
 
-    setIsEditDialogOpen(next);
+    cancelDeferredModalOpen();
+    setNameDraft(resolvedChannel.name);
+    setDescriptionDraft(resolvedChannel.description);
+    setIsPrivateDraft(currentVisibility === "private");
+    setIsEphemeralDraft(currentTtlSeconds !== null);
+    setTtlSecondsDraft(currentTtlSeconds ?? DEFAULT_EPHEMERAL_TTL_SECONDS);
+    setHasUserEditedChannelDraft(false);
+
+    setIsEditDialogOpen(false);
   }
 
   async function handleSaveChannelEdits() {
@@ -330,19 +341,19 @@ export function ChannelManagementSheet({
             activeView={activeView}
             archiveChannelMutation={archiveChannelMutation}
             canEditNarrative={canEditNarrative}
+            canEditChannel={canEditChannel}
             canJoin={canJoin}
             canLeave={canLeave}
-            canManageChannel={canManageChannel}
             canOpenCanvas={canOpenCanvas}
             canvasPreview={canvasPreview}
             canvasQuery={canvasQuery}
             channelId={channelId}
+            currentPubkey={currentPubkey}
             deleteChannelMutation={deleteChannelMutation}
             detailsError={detailsQuery.error}
             handleDeleteChannel={handleDeleteChannel}
             handleDeleteDialogOpenChange={handleDeleteDialogOpenChange}
             isArchived={isArchived}
-            isDark={isDark}
             isDeleteDialogOpen={isDeleteDialogOpen}
             canDeleteChannel={canDeleteChannel}
             mode={auxiliaryPanelMode}
@@ -350,11 +361,13 @@ export function ChannelManagementSheet({
             joinChannelMutation={joinChannelMutation}
             leaveChannelMutation={leaveChannelMutation}
             memberCount={memberCount}
+            members={members}
             membersError={membersQuery.error}
+            onOpenEdit={openEditDialog}
+            onOpenMembers={onOpenMembers ? openMembersDialog : undefined}
             onOpenChange={handlePanelOpenChange}
             resolvedChannel={resolvedChannel}
             setActiveView={setActiveView}
-            setIsEditDialogOpen={setIsEditDialogOpen}
             unarchiveChannelMutation={unarchiveChannelMutation}
           />
         </DialogPrimitive.Content>
@@ -376,19 +389,19 @@ export function ChannelManagementSheet({
               activeView={activeView}
               archiveChannelMutation={archiveChannelMutation}
               canEditNarrative={canEditNarrative}
+              canEditChannel={canEditChannel}
               canJoin={canJoin}
               canLeave={canLeave}
-              canManageChannel={canManageChannel}
               canOpenCanvas={canOpenCanvas}
               canvasPreview={canvasPreview}
               canvasQuery={canvasQuery}
               channelId={channelId}
+              currentPubkey={currentPubkey}
               deleteChannelMutation={deleteChannelMutation}
               detailsError={detailsQuery.error}
               handleDeleteChannel={handleDeleteChannel}
               handleDeleteDialogOpenChange={handleDeleteDialogOpenChange}
               isArchived={isArchived}
-              isDark={isDark}
               isDeleteDialogOpen={isDeleteDialogOpen}
               canDeleteChannel={canDeleteChannel}
               mode={auxiliaryPanelMode}
@@ -396,18 +409,20 @@ export function ChannelManagementSheet({
               joinChannelMutation={joinChannelMutation}
               leaveChannelMutation={leaveChannelMutation}
               memberCount={memberCount}
+              members={members}
               membersError={membersQuery.error}
+              onOpenEdit={openEditDialog}
+              onOpenMembers={onOpenMembers ? openMembersDialog : undefined}
               onOpenChange={handlePanelOpenChange}
               resolvedChannel={resolvedChannel}
               setActiveView={setActiveView}
-              setIsEditDialogOpen={setIsEditDialogOpen}
               unarchiveChannelMutation={unarchiveChannelMutation}
             />
           </DialogPrimitive.Content>
         </DialogPrimitive.Portal>
       )}
 
-      {canManageChannel ? (
+      {canEditChannel ? (
         <Dialog
           onOpenChange={handleEditDialogOpenChange}
           open={isEditDialogOpen}
@@ -556,20 +571,20 @@ type ChannelMutation<TArgs = void> = {
 type ChannelManagementPanelContentProps = {
   activeView: "summary" | "canvas";
   archiveChannelMutation: ChannelMutation;
+  canEditChannel: boolean;
   canEditNarrative: boolean;
   canJoin: boolean;
   canLeave: boolean;
-  canManageChannel: boolean;
   canOpenCanvas: boolean;
   canvasPreview?: string;
   canvasQuery: { isLoading: boolean };
   channelId: string | null;
+  currentPubkey?: string;
   deleteChannelMutation: ChannelMutation;
   detailsError: unknown;
   handleDeleteChannel: () => Promise<void>;
   handleDeleteDialogOpenChange: (open: boolean) => void;
   isArchived: boolean;
-  isDark: boolean;
   isDeleteDialogOpen: boolean;
   canDeleteChannel: boolean; // true when caller may delete the channel
   mode: AuxiliaryPanelMode;
@@ -577,31 +592,33 @@ type ChannelManagementPanelContentProps = {
   joinChannelMutation: ChannelMutation;
   leaveChannelMutation: ChannelMutation;
   memberCount: number;
+  members: ChannelMember[];
   membersError: unknown;
+  onOpenEdit: () => void;
+  onOpenMembers?: () => void;
   onOpenChange: (open: boolean) => void;
   resolvedChannel: Channel;
   setActiveView: React.Dispatch<React.SetStateAction<"summary" | "canvas">>;
-  setIsEditDialogOpen: React.Dispatch<React.SetStateAction<boolean>>;
   unarchiveChannelMutation: ChannelMutation;
 };
 
 function ChannelManagementPanelContent({
   activeView,
   archiveChannelMutation,
+  canEditChannel,
   canEditNarrative,
   canJoin,
   canLeave,
-  canManageChannel,
   canOpenCanvas,
   canvasPreview,
   canvasQuery,
   channelId,
+  currentPubkey,
   deleteChannelMutation,
   detailsError,
   handleDeleteChannel,
   handleDeleteDialogOpenChange,
   isArchived,
-  isDark,
   isDeleteDialogOpen,
   canDeleteChannel,
   mode,
@@ -609,20 +626,18 @@ function ChannelManagementPanelContent({
   joinChannelMutation,
   leaveChannelMutation,
   memberCount,
+  members,
   membersError,
+  onOpenEdit,
+  onOpenMembers,
   onOpenChange,
   resolvedChannel,
   setActiveView,
-  setIsEditDialogOpen,
   unarchiveChannelMutation,
 }: ChannelManagementPanelContentProps) {
   const scrollRef = React.useRef<HTMLDivElement>(null);
   useScrollBoundaryLock(scrollRef);
 
-  const showModerationActions =
-    activeView === "summary" &&
-    canManageChannel &&
-    resolvedChannel.channelType !== "dm";
   return (
     <AuxiliaryPanelContext.Provider
       value={{
@@ -653,7 +668,7 @@ function ChannelManagementPanelContent({
         >
           <DialogPrimitive.Title asChild>
             <AuxiliaryPanelTitle>
-              {activeView === "canvas" ? "Canvas" : "Channel"}
+              {activeView === "canvas" ? "Canvas" : "Channel Settings"}
             </AuxiliaryPanelTitle>
           </DialogPrimitive.Title>
         </AuxiliaryPanelHeaderGroup>
@@ -663,17 +678,17 @@ function ChannelManagementPanelContent({
       </AuxiliaryPanelHeader>
 
       <AuxiliaryPanelBody
-        className={cn(
-          "overflow-y-auto overflow-x-hidden overscroll-contain bg-background px-4 [overflow-anchor:none]",
-          showModerationActions ? "pb-20" : "pb-8",
-        )}
+        className="overflow-y-auto overflow-x-hidden overscroll-contain bg-background px-4 pb-8 [overflow-anchor:none]"
         mode={mode}
         panelPadding
         ref={scrollRef}
       >
         {activeView === "summary" ? (
           <div className="space-y-6 pt-3">
-            <ChannelHero channel={resolvedChannel} />
+            <ChannelHero
+              channel={resolvedChannel}
+              onEdit={canEditChannel ? onOpenEdit : undefined}
+            />
 
             {detailsError instanceof Error ? (
               <p className="rounded-xl border border-destructive/30 bg-destructive/10 px-3 py-2 text-sm text-destructive">
@@ -687,99 +702,56 @@ function ChannelManagementPanelContent({
               </p>
             ) : null}
 
-            <div className="flex flex-wrap items-start justify-center gap-6">
-              <ChannelQuickAction
-                icon={Copy}
-                label="Copy ID"
-                onClick={() => {
-                  void writeTextToClipboard(resolvedChannel.id).then(() =>
-                    toast.success("Copied channel ID"),
-                  );
-                }}
-                testId="channel-management-copy-id-action"
-              />
-              {canJoin ? (
-                <ChannelQuickAction
-                  active
-                  disabled={joinChannelMutation.isPending}
-                  icon={DoorOpen}
-                  label={joinChannelMutation.isPending ? "Joining..." : "Join"}
-                  onClick={() => {
-                    void joinChannelMutation.mutateAsync();
-                  }}
-                  testId="channel-management-join"
-                />
-              ) : null}
-              {canLeave ? (
-                <ChannelQuickAction
-                  disabled={leaveChannelMutation.isPending}
-                  icon={DoorClosed}
-                  label={
-                    leaveChannelMutation.isPending ? "Leaving..." : "Leave"
-                  }
-                  onClick={() => {
-                    void leaveChannelMutation.mutateAsync().then(() => {
-                      onOpenChange(false);
-                    });
-                  }}
-                  testId="channel-management-leave"
-                />
-              ) : null}
-              {canManageChannel ? (
-                <ChannelQuickAction
-                  icon={Pencil}
-                  label="Edit"
-                  onClick={() => setIsEditDialogOpen(true)}
-                  testId="channel-management-edit"
-                />
-              ) : null}
-            </div>
-
-            {joinChannelMutation.error instanceof Error ? (
-              <p className="text-center text-sm text-destructive">
-                {joinChannelMutation.error.message}
-              </p>
-            ) : null}
-            {leaveChannelMutation.error instanceof Error ? (
-              <p className="text-center text-sm text-destructive">
-                {leaveChannelMutation.error.message}
-              </p>
-            ) : null}
-
-            {resolvedChannel.description.trim() ||
-            resolvedChannel.topic?.trim() ||
-            resolvedChannel.purpose?.trim() ? (
-              <NarrativeGroup>
-                {resolvedChannel.description.trim() ? (
-                  <NarrativeField
-                    icon={FileText}
-                    label="Description"
-                    testId="channel-management-description"
-                    value={resolvedChannel.description.trim()}
+            <FieldGroup testId="channel-management-details" title="Details">
+              {resolvedChannel.channelType !== "dm" ? (
+                <>
+                  <EditableInfoFieldRow
+                    editTestId="channel-management-edit-channel-type"
+                    label="Channel type"
+                    onEdit={canEditChannel ? onOpenEdit : undefined}
+                    testId="channel-management-type"
+                    value={
+                      resolvedChannel.ttlSeconds === null
+                        ? "Ongoing"
+                        : `Temporary · ${formatTtlDuration(resolvedChannel.ttlSeconds)}`
+                    }
                   />
-                ) : null}
-                {resolvedChannel.topic?.trim() ? (
-                  <NarrativeField
-                    icon={MessageSquare}
-                    label="Topic"
-                    testId="channel-management-topic"
-                    value={resolvedChannel.topic.trim()}
+                  <EditableInfoFieldRow
+                    editTestId="channel-management-edit-visibility"
+                    label="Visibility"
+                    onEdit={canEditChannel ? onOpenEdit : undefined}
+                    testId="channel-management-visibility"
+                    value={
+                      resolvedChannel.visibility === "private"
+                        ? "Private"
+                        : "Public"
+                    }
                   />
-                ) : null}
-                {resolvedChannel.purpose?.trim() ? (
-                  <NarrativeField
-                    icon={Zap}
-                    label="Purpose"
-                    testId="channel-management-purpose"
-                    value={resolvedChannel.purpose.trim()}
+                </>
+              ) : null}
+              <InfoFieldRow
+                label="Members"
+                onClick={onOpenMembers}
+                testId="channel-management-member-count"
+                trailing={
+                  <ChannelMemberAvatarStack
+                    currentPubkey={currentPubkey}
+                    members={members}
                   />
-                ) : null}
-              </NarrativeGroup>
-            ) : null}
+                }
+                value={`${memberCount} member${memberCount === 1 ? "" : "s"}`}
+              />
+              <CopyFieldRow
+                label="Channel ID"
+                testId="channel-management-channel-id"
+                value={resolvedChannel.id}
+              />
+            </FieldGroup>
 
             {canOpenCanvas ? (
               <IngressRow
                 description={canvasPreview}
+                helpText="Use the canvas as a shared space for notes, plans, and other channel information."
                 icon={BookOpenText}
                 label="Canvas"
                 onClick={() => setActiveView("canvas")}
@@ -788,55 +760,106 @@ function ChannelManagementPanelContent({
               />
             ) : null}
 
-            <FieldGroup>
-              <CopyFieldRow
-                icon={Fingerprint}
-                label="Channel ID"
-                testId="channel-management-channel-id"
-                value={resolvedChannel.id}
-              />
-              <InfoFieldRow
-                icon={Type}
-                label="Name"
-                testId="channel-management-name-row"
-                value={resolvedChannel.name}
-              />
-              <InfoFieldRow
-                icon={Radio}
-                label="Type"
-                testId="channel-management-type"
-                value={resolvedChannel.channelType}
-              />
-              <InfoFieldRow
-                icon={resolvedChannel.visibility === "private" ? Lock : Eye}
-                label="Visibility"
-                testId="channel-management-visibility"
-                value={resolvedChannel.visibility}
-              />
-              <InfoFieldRow
-                icon={Users}
-                label="Members"
-                testId="channel-management-member-count"
-                value={`${memberCount}`}
-              />
-              {isArchived ? (
-                <InfoFieldRow
-                  icon={Archive}
-                  label="Status"
-                  testId="channel-management-archived"
-                  value="Archived"
-                />
-              ) : null}
-              {resolvedChannel.ttlSeconds !== null ? (
-                <InfoFieldRow
-                  icon={Archive}
-                  label="Ephemeral"
-                  testId="channel-management-ephemeral-row"
-                  value={formatTtlDuration(resolvedChannel.ttlSeconds)}
-                />
-              ) : null}
-            </FieldGroup>
+            {canJoin || canLeave || canEditChannel ? (
+              <FieldGroup testId="channel-management-actions">
+                {canJoin ? (
+                  <ActionFieldRow
+                    description="Add this channel to your sidebar"
+                    disabled={joinChannelMutation.isPending}
+                    icon={DoorOpen}
+                    label={
+                      joinChannelMutation.isPending
+                        ? "Joining channel..."
+                        : "Join channel"
+                    }
+                    onClick={() => {
+                      void joinChannelMutation.mutateAsync();
+                    }}
+                    testId="channel-management-join"
+                  />
+                ) : null}
+                {canLeave ? (
+                  <ActionFieldRow
+                    disabled={leaveChannelMutation.isPending}
+                    icon={DoorClosed}
+                    label={
+                      leaveChannelMutation.isPending
+                        ? "Leaving channel..."
+                        : "Leave channel"
+                    }
+                    onClick={() => {
+                      void leaveChannelMutation.mutateAsync().then(() => {
+                        onOpenChange(false);
+                      });
+                    }}
+                    testId="channel-management-leave"
+                  />
+                ) : null}
+                {canEditChannel ? (
+                  isArchived ? (
+                    <ActionFieldRow
+                      disabled={unarchiveChannelMutation.isPending}
+                      icon={ArchiveRestore}
+                      label={
+                        unarchiveChannelMutation.isPending
+                          ? "Restoring channel..."
+                          : "Unarchive channel"
+                      }
+                      onClick={() => {
+                        void unarchiveChannelMutation.mutateAsync();
+                      }}
+                      testId="channel-management-unarchive"
+                    />
+                  ) : (
+                    <ActionFieldRow
+                      disabled={archiveChannelMutation.isPending}
+                      icon={Archive}
+                      label={
+                        archiveChannelMutation.isPending
+                          ? "Archiving channel..."
+                          : "Archive channel"
+                      }
+                      onClick={() => {
+                        void archiveChannelMutation.mutateAsync();
+                      }}
+                      testId="channel-management-archive"
+                    />
+                  )
+                ) : null}
+                {canEditChannel && canDeleteChannel ? (
+                  <ChannelDeleteConfirmationDialog
+                    channelName={resolvedChannel.name}
+                    error={deleteChannelMutation.error}
+                    isPending={deleteChannelMutation.isPending}
+                    onConfirm={() => {
+                      void handleDeleteChannel();
+                    }}
+                    onOpenChange={handleDeleteDialogOpenChange}
+                    open={isDeleteDialogOpen}
+                    trigger={
+                      <ActionFieldRow
+                        destructive
+                        disabled={deleteChannelMutation.isPending}
+                        icon={Trash2}
+                        label="Delete channel"
+                        testId="channel-management-delete"
+                      />
+                    }
+                  />
+                ) : null}
+              </FieldGroup>
+            ) : null}
 
+            {joinChannelMutation.error instanceof Error ? (
+              <p className="text-sm text-destructive">
+                {joinChannelMutation.error.message}
+              </p>
+            ) : null}
+            {leaveChannelMutation.error instanceof Error ? (
+              <p className="text-sm text-destructive">
+                {leaveChannelMutation.error.message}
+              </p>
+            ) : null}
             {archiveChannelMutation.error instanceof Error ? (
               <p className="text-sm text-destructive">
                 {archiveChannelMutation.error.message}
@@ -858,22 +881,6 @@ function ChannelManagementPanelContent({
           </div>
         )}
       </AuxiliaryPanelBody>
-
-      {showModerationActions ? (
-        <ChannelManagementModerationActions
-          archiveChannelMutation={archiveChannelMutation}
-          canManageChannel={canManageChannel}
-          deleteChannelMutation={deleteChannelMutation}
-          handleDeleteChannel={handleDeleteChannel}
-          handleDeleteDialogOpenChange={handleDeleteDialogOpenChange}
-          isArchived={isArchived}
-          isDark={isDark}
-          isDeleteDialogOpen={isDeleteDialogOpen}
-          canDeleteChannel={canDeleteChannel}
-          resolvedChannelName={resolvedChannel.name}
-          unarchiveChannelMutation={unarchiveChannelMutation}
-        />
-      ) : null}
     </AuxiliaryPanelContext.Provider>
   );
 }
diff --git a/desktop/src/features/channels/ui/ChannelManagementSheetRows.tsx b/desktop/src/features/channels/ui/ChannelManagementSheetRows.tsx
index 51a3fee7825..851a55edd79 100644
--- a/desktop/src/features/channels/ui/ChannelManagementSheetRows.tsx
+++ b/desktop/src/features/channels/ui/ChannelManagementSheetRows.tsx
@@ -1,93 +1,116 @@
 import {
+  Check,
   ChevronRight,
   Copy,
   FileText,
   Hash,
+  Info,
   MessageSquare,
+  Pencil,
   type LucideIcon,
 } from "lucide-react";
-import type * as React from "react";
+import * as React from "react";
 import { toast } from "sonner";
 
 import type { Channel } from "@/shared/api/types";
 import { cn } from "@/shared/lib/cn";
 import { writeTextToClipboard } from "@/shared/lib/clipboard";
+import { PanelSectionGroup } from "@/shared/ui/PanelSectionGroup";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 
 function getChannelIcon(channelType: Channel["channelType"]): LucideIcon {
-  if (channelType === "forum") {
-    return FileText;
-  }
-  if (channelType === "dm") {
-    return MessageSquare;
-  }
+  if (channelType === "forum") return FileText;
+  if (channelType === "dm") return MessageSquare;
   return Hash;
 }
 
-export function ChannelHero({ channel }: { channel: Channel }) {
+export function ChannelHero({
+  channel,
+  onEdit,
+}: {
+  channel: Channel;
+  onEdit?: () => void;
+}) {
   const Icon = getChannelIcon(channel.channelType);
+  const channelDescription = channel.description.trim();
+  const description =
+    channelDescription || (onEdit ? "Add a description" : null);
 
   return (
-    <div className="flex flex-col items-center gap-3 text-center">
+    <div
+      className="flex flex-col items-center gap-3 py-3 text-center"
+      data-testid="channel-management-hero"
+    >
       <div className="flex h-20 w-20 items-center justify-center rounded-full bg-primary text-primary-foreground">
         <Icon className="h-8 w-8" />
       </div>
-      <div className="flex max-w-full flex-col items-center">
-        <h3 className="max-w-full truncate text-xl font-semibold tracking-tight">
-          {channel.name}
-        </h3>
-      </div>
+      {channel.channelType !== "dm" && onEdit ? (
+        <button
+          aria-label="Edit channel"
+          className="group flex max-w-full flex-col items-center rounded-lg px-8 py-1 text-center focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring"
+          data-testid="channel-management-edit"
+          onClick={onEdit}
+          type="button"
+        >
+          <span
+            className="relative max-w-full"
+            data-testid="channel-management-name-row"
+          >
+            <span className="block max-w-full truncate text-xl font-semibold tracking-tight">
+              {channel.name}
+            </span>
+            <span
+              aria-hidden="true"
+              className="pointer-events-none absolute top-1/2 left-full ml-1 -translate-y-1/2 text-muted-foreground opacity-0 transition-[color,opacity] duration-150 ease-out group-hover:text-foreground group-hover:opacity-100 group-focus-visible:opacity-100"
+              data-testid="channel-management-edit-icon"
+            >
+              <Pencil className="h-4 w-4" />
+            </span>
+          </span>
+          <span
+            className="mt-1 line-clamp-2 max-w-full text-sm leading-5 text-muted-foreground/70"
+            data-testid="channel-management-description"
+          >
+            {description}
+          </span>
+        </button>
+      ) : channel.channelType !== "dm" ? (
+        <div className="flex max-w-full flex-col items-center">
+          <h3
+            className="max-w-full truncate text-xl font-semibold tracking-tight"
+            data-testid="channel-management-name-row"
+          >
+            {channel.name}
+          </h3>
+          {description ? (
+            <p
+              className="mt-1 line-clamp-2 max-w-full text-sm leading-5 text-muted-foreground/70"
+              data-testid="channel-management-description"
+            >
+              {description}
+            </p>
+          ) : null}
+        </div>
+      ) : null}
     </div>
   );
 }
 
-export function ChannelQuickAction({
-  active,
-  disabled,
-  icon: Icon,
-  label,
-  onClick,
+export function FieldGroup({
+  children,
+  description,
   testId,
+  title,
 }: {
-  active?: boolean;
-  disabled?: boolean;
-  icon: LucideIcon;
-  label: string;
-  onClick: () => void;
+  children: React.ReactNode;
+  description?: React.ReactNode;
   testId?: string;
+  title?: React.ReactNode;
 }) {
   return (
-    <button
-      className="flex w-16 flex-col items-center gap-2 disabled:cursor-not-allowed disabled:opacity-50"
-      data-testid={testId}
-      disabled={disabled}
-      onClick={onClick}
-      type="button"
-    >
-      <span
-        className={cn(
-          "flex h-14 w-14 items-center justify-center rounded-full transition-colors",
-          active
-            ? "bg-foreground text-background hover:bg-foreground/90"
-            : "bg-muted/60 text-foreground hover:bg-muted/80",
-        )}
-      >
-        <Icon className="h-5 w-5" />
-      </span>
-      <span
-        className={cn(
-          "max-w-full truncate text-xs",
-          active ? "text-foreground" : "text-muted-foreground",
-        )}
-      >
-        {label}
-      </span>
-    </button>
-  );
-}
-
-export function FieldGroup({ children }: { children: React.ReactNode }) {
-  return (
-    <div className="overflow-hidden rounded-2xl bg-muted/20">{children}</div>
+    <PanelSectionGroup description={description} testId={testId} title={title}>
+      {children}
+    </PanelSectionGroup>
   );
 }
 
@@ -114,26 +137,51 @@ export function getMarkdownPreviewText(content: string) {
     .join(" ");
 }
 
+function truncateIdentifier(value: string) {
+  if (value.length <= 12) return value;
+  return `${value.slice(0, 8)}…${value.slice(-4)}`;
+}
+
 export function CopyFieldRow({
   icon: Icon,
   label,
   value,
   testId,
 }: {
-  icon: LucideIcon;
+  icon?: LucideIcon;
   label: string;
   value: string;
   testId?: string;
 }) {
+  const [copied, setCopied] = React.useState(false);
+  const resetTimerRef = React.useRef<number | null>(null);
+
+  React.useEffect(
+    () => () => {
+      if (resetTimerRef.current !== null) {
+        window.clearTimeout(resetTimerRef.current);
+      }
+    },
+    [],
+  );
+
   async function handleCopy() {
     await writeTextToClipboard(value);
+    setCopied(true);
+    if (resetTimerRef.current !== null) {
+      window.clearTimeout(resetTimerRef.current);
+    }
+    resetTimerRef.current = window.setTimeout(() => {
+      setCopied(false);
+      resetTimerRef.current = null;
+    }, 1_500);
     toast.success(`Copied ${label.toLowerCase()}`);
   }
 
   return (
     <button
-      aria-label={`Copy ${label}`}
-      className="flex w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40"
+      aria-label={copied ? `${label} copied` : `Copy ${label}`}
+      className="group flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40"
       data-testid={testId}
       onClick={() => {
         void handleCopy();
@@ -141,18 +189,45 @@ export function CopyFieldRow({
       title={`Copy ${label}`}
       type="button"
     >
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <Icon className="h-4 w-4 text-muted-foreground" />
-      </span>
+      {Icon ? (
+        <Icon
+          className="h-4 w-4 shrink-0 text-muted-foreground"
+          data-slot="field-row-icon"
+        />
+      ) : null}
       <span className="min-w-0 flex-1">
-        <span className="block text-xs font-medium text-foreground">
+        <span className="block text-sm font-medium text-foreground">
           {label}
         </span>
-        <span className="mt-0.5 block truncate font-mono text-sm text-muted-foreground">
-          {value}
+        <span
+          className="mt-0.5 block truncate font-mono text-sm text-muted-foreground/70"
+          title={value}
+        >
+          {truncateIdentifier(value)}
         </span>
       </span>
-      <Copy className="h-4 w-4 shrink-0 text-muted-foreground" />
+      <span
+        aria-hidden="true"
+        className={cn(
+          "relative h-4 w-4 shrink-0 transition-opacity duration-150 ease-out motion-reduce:transition-none group-hover:opacity-100 group-focus-within:opacity-100",
+          copied ? "opacity-100" : "opacity-0",
+        )}
+        data-copied={copied}
+        data-testid={testId ? `${testId}-copy-status` : undefined}
+      >
+        <Copy
+          className={cn(
+            "absolute inset-0 h-4 w-4 transition-[opacity,transform] duration-150 ease-[cubic-bezier(0.23,1,0.32,1)] motion-reduce:transition-none",
+            copied ? "scale-95 opacity-0" : "scale-100 opacity-100",
+          )}
+        />
+        <Check
+          className={cn(
+            "absolute inset-0 h-4 w-4 text-primary transition-[opacity,transform] duration-150 ease-[cubic-bezier(0.23,1,0.32,1)] motion-reduce:transition-none",
+            copied ? "scale-100 opacity-100" : "scale-95 opacity-0",
+          )}
+        />
+      </span>
     </button>
   );
 }
@@ -160,73 +235,203 @@ export function CopyFieldRow({
 export function InfoFieldRow({
   icon: Icon,
   label,
+  multiline = false,
+  onClick,
+  trailing,
   value,
   testId,
 }: {
-  icon: LucideIcon;
+  icon?: LucideIcon;
   label: string;
+  multiline?: boolean;
+  onClick?: () => void;
+  trailing?: React.ReactNode;
   value: string;
   testId?: string;
 }) {
-  return (
-    <div
-      className="flex w-full items-center gap-3 px-4 py-3"
-      data-testid={testId}
-    >
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <Icon className="h-4 w-4 text-muted-foreground" />
-      </span>
+  const content = (
+    <>
+      {Icon ? (
+        <Icon
+          className="h-4 w-4 shrink-0 text-muted-foreground"
+          data-slot="field-row-icon"
+        />
+      ) : null}
       <span className="min-w-0 flex-1 text-left">
-        <span className="block text-xs font-medium text-foreground">
+        <span className="block text-sm font-medium text-foreground">
           {label}
         </span>
-        <span className="mt-0.5 block truncate text-sm text-muted-foreground">
+        <span
+          className={cn(
+            "mt-0.5 block text-sm font-normal text-muted-foreground/70",
+            multiline ? "line-clamp-2 whitespace-normal leading-5" : "truncate",
+          )}
+        >
           {value}
         </span>
       </span>
-    </div>
+      {trailing}
+    </>
   );
-}
 
-export function NarrativeGroup({ children }: { children: React.ReactNode }) {
+  if (onClick) {
+    return (
+      <button
+        className="flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
+        data-testid={testId}
+        onClick={onClick}
+        type="button"
+      >
+        {content}
+      </button>
+    );
+  }
+
   return (
-    <div className="overflow-hidden rounded-2xl bg-muted/20">{children}</div>
+    <div
+      className="flex min-h-16 w-full items-center gap-3 px-4 py-3"
+      data-testid={testId}
+    >
+      {content}
+    </div>
   );
 }
 
-export function NarrativeField({
+export function EditableInfoFieldRow({
+  editTestId,
   icon: Icon,
   label,
+  multiline = false,
+  onEdit,
   value,
   testId,
 }: {
-  icon: LucideIcon;
+  editTestId?: string;
+  icon?: LucideIcon;
   label: string;
+  multiline?: boolean;
+  onEdit?: () => void;
   value: string;
   testId: string;
 }) {
-  return (
-    <div
-      className="flex w-full items-start gap-3 px-4 py-3"
-      data-testid={testId}
-    >
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <Icon className="h-4 w-4 text-muted-foreground" />
-      </span>
-      <span className="min-w-0 flex-1">
-        <span className="block text-xs font-medium text-foreground">
+  const content = (
+    <>
+      {Icon ? (
+        <Icon
+          className="h-4 w-4 shrink-0 text-muted-foreground"
+          data-slot="field-row-icon"
+        />
+      ) : null}
+      <span className="min-w-0 flex-1 text-left">
+        <span className="block text-sm font-medium text-foreground">
           {label}
         </span>
-        <span className="mt-1 block whitespace-pre-wrap text-sm leading-6 text-muted-foreground">
+        <span
+          className={cn(
+            "mt-0.5 block text-sm font-normal text-muted-foreground/70",
+            multiline ? "line-clamp-2 whitespace-normal leading-5" : "truncate",
+          )}
+        >
           {value}
         </span>
       </span>
+      {onEdit ? (
+        <span
+          aria-hidden="true"
+          className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full text-muted-foreground opacity-0 transition-opacity group-hover:opacity-100 group-focus-within:opacity-100"
+          data-testid={editTestId}
+        >
+          <Pencil className="h-4 w-4" />
+        </span>
+      ) : null}
+    </>
+  );
+
+  if (onEdit) {
+    return (
+      <button
+        aria-label={`Edit ${label.toLowerCase()}`}
+        className="group flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
+        data-testid={testId}
+        onClick={onEdit}
+        type="button"
+      >
+        {content}
+      </button>
+    );
+  }
+
+  return (
+    <div
+      className="group flex min-h-16 w-full items-center gap-3 px-4 py-3"
+      data-testid={testId}
+    >
+      {content}
     </div>
   );
 }
 
+type ActionFieldRowProps = {
+  destructive?: boolean;
+  description?: string;
+  disabled?: boolean;
+  icon: LucideIcon;
+  label: string;
+  onClick?: () => void;
+  testId: string;
+};
+
+export const ActionFieldRow = React.forwardRef<
+  HTMLButtonElement,
+  ActionFieldRowProps
+>(function ActionFieldRow(
+  {
+    destructive = false,
+    description,
+    disabled,
+    icon: Icon,
+    label,
+    onClick,
+    testId,
+    ...triggerProps
+  },
+  ref,
+) {
+  return (
+    <button
+      className={cn(
+        "flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 disabled:cursor-not-allowed disabled:opacity-50",
+        destructive && "text-destructive",
+      )}
+      data-testid={testId}
+      disabled={disabled}
+      onClick={onClick}
+      ref={ref}
+      type="button"
+      {...triggerProps}
+    >
+      <Icon
+        className={cn(
+          "h-4 w-4 shrink-0 text-muted-foreground",
+          destructive && "text-destructive",
+        )}
+        data-slot="field-row-icon"
+      />
+      <span className="min-w-0 flex-1">
+        <span className="block text-sm font-medium">{label}</span>
+        {description ? (
+          <span className="mt-0.5 block truncate text-sm font-normal text-muted-foreground/70">
+            {description}
+          </span>
+        ) : null}
+      </span>
+    </button>
+  );
+});
+
 export function IngressRow({
   description,
+  helpText,
   icon: Icon,
   label,
   onClick,
@@ -234,6 +439,7 @@ export function IngressRow({
   trailing,
 }: {
   description?: string;
+  helpText?: string;
   icon: LucideIcon;
   label: string;
   onClick: () => void;
@@ -241,29 +447,51 @@ export function IngressRow({
   trailing?: string;
 }) {
   return (
-    <button
-      className="flex w-full items-center gap-3 rounded-2xl bg-muted/20 px-4 py-2 text-left transition-colors hover:bg-muted/40"
-      data-testid={testId}
-      onClick={onClick}
-      type="button"
-    >
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <Icon className="h-4 w-4 text-muted-foreground" />
-      </span>
-      <span className="min-w-0 flex-1">
-        <span className="block text-sm font-medium text-foreground">
-          {label}
+    <PanelSectionGroup testId={`${testId}-section`}>
+      <div className="relative flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left">
+        <button
+          aria-label={`Open ${label.toLowerCase()}`}
+          className="absolute inset-0 z-10 transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
+          data-testid={testId}
+          onClick={onClick}
+          type="button"
+        />
+        <Icon className="pointer-events-none relative z-20 h-4 w-4 shrink-0 text-muted-foreground" />
+        <span className="pointer-events-none relative z-20 min-w-0 flex-1">
+          <span className="flex items-center gap-1.5 text-sm font-medium text-foreground">
+            <span>{label}</span>
+            {helpText ? (
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    aria-label={`About ${label.toLowerCase()}`}
+                    className="pointer-events-auto flex h-5 w-5 shrink-0 items-center justify-center rounded-full text-muted-foreground transition-colors hover:bg-muted/70 hover:text-foreground focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring"
+                    data-testid={`${testId}-info`}
+                    onClick={(event) => event.stopPropagation()}
+                    type="button"
+                  >
+                    <Info className="h-3.5 w-3.5" />
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent className="max-w-64 text-left" side="top">
+                  {helpText}
+                </TooltipContent>
+              </Tooltip>
+            ) : null}
+          </span>
+          {description ? (
+            <span className="mt-0.5 block truncate text-sm font-normal text-muted-foreground/70">
+              {description}
+            </span>
+          ) : null}
         </span>
-        {description ? (
-          <span className="mt-0.5 block truncate text-xs text-muted-foreground">
-            {description}
+        {trailing ? (
+          <span className="pointer-events-none relative z-20 text-sm text-muted-foreground/70">
+            {trailing}
           </span>
         ) : null}
-      </span>
-      {trailing ? (
-        <span className="text-sm text-muted-foreground">{trailing}</span>
-      ) : null}
-      <ChevronRight className="h-4 w-4 shrink-0 text-muted-foreground" />
-    </button>
+        <ChevronRight className="pointer-events-none relative z-20 h-4 w-4 shrink-0 text-muted-foreground" />
+      </div>
+    </PanelSectionGroup>
   );
 }
diff --git a/desktop/src/features/channels/ui/ChannelMemberAvatarStack.tsx b/desktop/src/features/channels/ui/ChannelMemberAvatarStack.tsx
new file mode 100644
index 00000000000..a9662bbf047
--- /dev/null
+++ b/desktop/src/features/channels/ui/ChannelMemberAvatarStack.tsx
@@ -0,0 +1,75 @@
+import * as React from "react";
+
+import { useUsersBatchQuery } from "@/features/profile/hooks";
+import { resolveUserLabel } from "@/features/profile/lib/identity";
+import type { ChannelMember } from "@/shared/api/types";
+import { normalizePubkey } from "@/shared/lib/pubkey";
+import { UserAvatar } from "@/shared/ui/UserAvatar";
+
+const MAX_VISIBLE_AVATARS = 3;
+
+export function ChannelMemberAvatarStack({
+  currentPubkey,
+  members,
+}: {
+  currentPubkey?: string;
+  members: ChannelMember[];
+}) {
+  const visibleMembers = members.slice(0, MAX_VISIBLE_AVATARS);
+  const visiblePubkeys = React.useMemo(
+    () => members.slice(0, MAX_VISIBLE_AVATARS).map((member) => member.pubkey),
+    [members],
+  );
+  const profilesQuery = useUsersBatchQuery(visiblePubkeys);
+  const profiles = profilesQuery.data?.profiles;
+  const overflowCount = members.length - visibleMembers.length;
+  const stackItemCount = visibleMembers.length + (overflowCount > 0 ? 1 : 0);
+
+  if (members.length === 0) {
+    return null;
+  }
+
+  return (
+    <div
+      className="flex shrink-0 items-center pl-3"
+      data-testid="channel-management-member-avatar-stack"
+    >
+      {visibleMembers.map((member, index) => {
+        const normalizedPubkey = normalizePubkey(member.pubkey);
+        const profile = profiles?.[normalizedPubkey];
+        const label = resolveUserLabel({
+          currentPubkey,
+          fallbackName: member.displayName,
+          profiles,
+          pubkey: member.pubkey,
+        });
+
+        return (
+          <span
+            className={index > 0 ? "-ml-2" : ""}
+            data-testid="channel-management-member-avatar"
+            key={normalizedPubkey}
+            style={{ zIndex: index + 1 }}
+          >
+            <UserAvatar
+              avatarUrl={profile?.avatarUrl ?? null}
+              className="!h-8 !w-8 border-2 border-background text-2xs"
+              displayName={label}
+              fallbackDelayMs={0}
+            />
+          </span>
+        );
+      })}
+      {overflowCount > 0 ? (
+        <span
+          className="-ml-2 flex h-8 w-8 items-center justify-center rounded-full border-2 border-background bg-muted text-2xs font-semibold text-muted-foreground"
+          data-testid="channel-management-member-avatar-overflow"
+          style={{ zIndex: stackItemCount }}
+          title={`${overflowCount} more members`}
+        >
+          +{overflowCount}
+        </span>
+      ) : null}
+    </div>
+  );
+}
diff --git a/desktop/src/features/channels/ui/ChannelPane.tsx b/desktop/src/features/channels/ui/ChannelPane.tsx
index 28f3f8aae7a..8fc7cfaf51a 100644
--- a/desktop/src/features/channels/ui/ChannelPane.tsx
+++ b/desktop/src/features/channels/ui/ChannelPane.tsx
@@ -762,6 +762,7 @@ export const ChannelPane = React.memo(function ChannelPane({
             key="channel-management-panel"
             onChannelManagementDeleted={onChannelManagementDeleted}
             onCloseChannelManagement={onCloseChannelManagement}
+            onOpenMembers={onOpenMembers}
             onResetThreadPanelWidth={onResetThreadPanelWidth}
             onThreadPanelResizeStart={onThreadPanelResizeStart}
             threadPanelWidthPx={threadPanelWidthPx}
diff --git a/desktop/src/features/channels/ui/channelFormStyles.ts b/desktop/src/features/channels/ui/channelFormStyles.ts
index 60e4053901a..df07001293c 100644
--- a/desktop/src/features/channels/ui/channelFormStyles.ts
+++ b/desktop/src/features/channels/ui/channelFormStyles.ts
@@ -2,4 +2,4 @@ export const CHANNEL_FORM_FIELD_SHELL_CLASS =
   "rounded-xl border border-input bg-muted/40 transition-colors duration-150 ease-out hover:border-muted-foreground/40 focus-within:border-muted-foreground/50";
 
 export const CHANNEL_FORM_FIELD_CONTROL_CLASS =
-  "border-0 bg-transparent text-muted-foreground/55 shadow-none outline-none ring-0 transition-colors duration-150 ease-out placeholder:text-muted-foreground/55 focus:bg-transparent focus:text-foreground focus:outline-hidden focus-visible:ring-0";
+  "border-0 bg-transparent text-foreground shadow-none outline-none ring-0 transition-colors duration-150 ease-out placeholder:text-muted-foreground/55 focus:bg-transparent focus:text-foreground focus:outline-hidden focus-visible:ring-0";
diff --git a/desktop/src/features/channels/useThreadActivityPersistence.test.mjs b/desktop/src/features/channels/useThreadActivityPersistence.test.mjs
new file mode 100644
index 00000000000..686a08fcc42
--- /dev/null
+++ b/desktop/src/features/channels/useThreadActivityPersistence.test.mjs
@@ -0,0 +1,276 @@
+/**
+ * Integration tests for useThreadActivityPersistence.
+ *
+ * These mount the REAL production hook via createRoot + act to exercise the
+ * actual lifecycle: pagehide flush, visibilitychange→hidden flush, unmount
+ * cleanup, scope-switch hydration (flush-before-reseed), legacy-key cleanup,
+ * and the read-live-buffer-at-flush-time contract that distinguishes this
+ * scheduler from a snapshot-at-schedule one. Debounce timing is covered by
+ * fake timers in threadActivityWriteScheduler.test.mjs.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  installDOMShim,
+  installFreshStorage,
+} from "./observedUnreadTestHarness.mjs";
+
+installDOMShim();
+installFreshStorage();
+
+import React from "react";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+
+import {
+  activityStorageKey,
+  readActivityFromStorage,
+  writeActivityToStorage,
+} from "./threadActivityStorage.ts";
+import { useThreadActivityPersistence } from "./useThreadActivityPersistence.ts";
+
+const RELAY = "wss://relay.example.com";
+
+// Mount the hook with a caller-owned buffer ref (mirrors useUnreadChannels,
+// which owns threadActivityRef and passes it in).
+async function mountHook(itemsRef, props) {
+  const apiRef = { current: null };
+
+  function Harness({ pubkey, relay }) {
+    apiRef.current = useThreadActivityPersistence(pubkey, relay, itemsRef);
+    return null;
+  }
+
+  const root = createRoot(document.createElement("div"));
+  const render = async (p) => {
+    await act(async () => {
+      root.render(React.createElement(Harness, p));
+    });
+  };
+  await render(props);
+
+  return {
+    get api() {
+      return apiRef.current;
+    },
+    render,
+    unmount: async () => {
+      await act(async () => root.unmount());
+    },
+  };
+}
+
+// ── flush contract: read the live buffer at flush time ───────────────────────
+
+test("pagehide flush persists the live buffer's final state, not a schedule-time snapshot", async () => {
+  installFreshStorage();
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey: "pk1", relay: RELAY });
+
+  // A reply lands, the writer buffers it in place and arms a coalesced write.
+  itemsRef.current = [{ id: "early" }];
+  harness.api.schedule(harness.api.currentScope);
+  // A second reply lands within the debounce window — buffer grows in place.
+  itemsRef.current = [{ id: "early" }, { id: "late" }];
+
+  await act(async () => {
+    globalThis.dispatchEvent({ type: "pagehide" });
+  });
+
+  assert.deepEqual(
+    readActivityFromStorage("pk1", RELAY).map((item) => item.id),
+    ["early", "late"],
+    "flush must persist the buffer's final state including the late reply",
+  );
+
+  await harness.unmount();
+});
+
+test("visibilitychange to hidden flushes a pending write", async () => {
+  installFreshStorage();
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey: "pk1", relay: RELAY });
+
+  itemsRef.current = [{ id: "hidden-flush" }];
+  harness.api.schedule(harness.api.currentScope);
+
+  await act(async () => {
+    globalThis.document.visibilityState = "hidden";
+    globalThis.document.dispatchEvent({ type: "visibilitychange" });
+  });
+
+  assert.deepEqual(
+    readActivityFromStorage("pk1", RELAY).map((item) => item.id),
+    ["hidden-flush"],
+    "backgrounding the webview must persist the pending buffer",
+  );
+
+  await harness.unmount();
+});
+
+test("visibilitychange to visible does not write", async () => {
+  installFreshStorage();
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey: "pk1", relay: RELAY });
+
+  itemsRef.current = [{ id: "still-buffered" }];
+  harness.api.schedule(harness.api.currentScope);
+
+  await act(async () => {
+    globalThis.document.visibilityState = "visible";
+    globalThis.document.dispatchEvent({ type: "visibilitychange" });
+  });
+
+  assert.deepEqual(
+    readActivityFromStorage("pk1", RELAY),
+    [],
+    "a visible transition must not flush",
+  );
+
+  await harness.unmount();
+});
+
+test("unmount with a pending write flushes before teardown", async () => {
+  installFreshStorage();
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey: "pk1", relay: RELAY });
+
+  itemsRef.current = [{ id: "unmount-flush" }];
+  harness.api.schedule(harness.api.currentScope);
+
+  await harness.unmount();
+
+  assert.deepEqual(
+    readActivityFromStorage("pk1", RELAY).map((item) => item.id),
+    ["unmount-flush"],
+    "unmount cleanup must flush the pending write",
+  );
+});
+
+// ── scope switch: flush-before-reseed under the OLD key ──────────────────────
+
+test("scope switch flushes A synchronously under A's key and does not leak A into B", async () => {
+  installFreshStorage();
+
+  const pkA = "pkA";
+  const relayA = "wss://relay-a.example.com";
+  const pkB = "pkB";
+  const relayB = "wss://relay-b.example.com";
+
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey: pkA, relay: relayA });
+
+  // A accumulates a buffered reply with a pending coalesced write.
+  itemsRef.current = [{ id: "a-only" }];
+  harness.api.schedule(harness.api.currentScope);
+
+  // Switch identity to B: the hydration effect must flush A first.
+  await harness.render({ pubkey: pkB, relay: relayB });
+
+  assert.deepEqual(
+    readActivityFromStorage(pkA, relayA).map((item) => item.id),
+    ["a-only"],
+    "A's pending write must land under A's key on scope switch",
+  );
+  assert.deepEqual(
+    readActivityFromStorage(pkB, relayB),
+    [],
+    "B's bucket must not contain A's rows",
+  );
+  assert.ok(
+    harness.api.currentScope.includes(pkB),
+    "currentScope must reflect B after the switch",
+  );
+
+  await harness.unmount();
+});
+
+test("scope switch hydrates B's buffer from B's persisted bucket", async () => {
+  installFreshStorage();
+
+  const pkA = "pkA";
+  const relayA = "wss://relay-a.example.com";
+  const pkB = "pkB";
+  const relayB = "wss://relay-b.example.com";
+  writeActivityToStorage(pkB, relayB, [{ id: "b-persisted" }]);
+
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey: pkA, relay: relayA });
+
+  itemsRef.current = [{ id: "a-only" }];
+  await harness.render({ pubkey: pkB, relay: relayB });
+
+  assert.deepEqual(
+    itemsRef.current.map((item) => item.id),
+    ["b-persisted"],
+    "the buffer must be reseeded from B's bucket, dropping A's rows",
+  );
+
+  await harness.unmount();
+});
+
+// ── legacy key cleanup ───────────────────────────────────────────────────────
+
+test("mounting removes the orphaned legacy pubkey-only key", async () => {
+  const ls = installFreshStorage();
+  const pubkey = "pk-legacy";
+  const legacyKey = `buzz-thread-activity.v1:${pubkey}`;
+  ls.setItem(legacyKey, JSON.stringify([{ id: "stale" }]));
+
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey, relay: RELAY });
+
+  assert.equal(
+    ls.getItem(legacyKey),
+    null,
+    "hydration must drop the orphaned legacy key",
+  );
+
+  await harness.unmount();
+});
+
+// ── scope fence: never write before a valid scope is loaded ──────────────────
+
+test("isScopeLoaded is false without an identity and true after hydration", async () => {
+  installFreshStorage();
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey: null, relay: RELAY });
+
+  assert.equal(
+    harness.api.isScopeLoaded(),
+    false,
+    "an absent pubkey must never pass the scope fence",
+  );
+
+  await harness.render({ pubkey: "pk1", relay: RELAY });
+  assert.equal(
+    harness.api.isScopeLoaded(),
+    true,
+    "a valid scope must pass once its hydration effect commits",
+  );
+
+  await harness.unmount();
+});
+
+test("schedule under an empty scope never writes", async () => {
+  const ls = installFreshStorage();
+  const itemsRef = { current: [] };
+  const harness = await mountHook(itemsRef, { pubkey: null, relay: RELAY });
+
+  itemsRef.current = [{ id: "orphan" }];
+  harness.api.schedule(harness.api.currentScope);
+
+  await act(async () => {
+    globalThis.dispatchEvent({ type: "pagehide" });
+  });
+
+  assert.equal(
+    ls.getItem(activityStorageKey("", RELAY)),
+    null,
+    "no write may land when identity is unknown",
+  );
+
+  await harness.unmount();
+});
diff --git a/desktop/src/features/channels/useThreadActivityPersistence.ts b/desktop/src/features/channels/useThreadActivityPersistence.ts
new file mode 100644
index 00000000000..025a82467e5
--- /dev/null
+++ b/desktop/src/features/channels/useThreadActivityPersistence.ts
@@ -0,0 +1,113 @@
+import * as React from "react";
+import {
+  activityScopeKey,
+  flushThreadActivityWrite,
+  readActivityFromStorage,
+  removeLegacyThreadActivityKey,
+  scheduleThreadActivityWrite,
+  type ThreadActivityItem,
+  type ThreadActivityRefs,
+} from "@/features/channels/threadActivityStorage";
+
+export type ThreadActivityPersistence = {
+  /** Scope key loaded into the buffer ("" until identity is known). */
+  scopeLoadedRef: React.MutableRefObject<string>;
+  /** Current scope derived from normalized pubkey + relay. */
+  currentScope: string;
+  /**
+   * True only when the hydration effect has committed for the current scope
+   * AND that scope is non-empty. Reads the ref at call time so it is never a
+   * stale snapshot. Use as the write/merge guard: an empty scope must never
+   * pass, or a writer could fire before the first valid scope is seeded.
+   */
+  isScopeLoaded: () => boolean;
+  /** Arm a coalesced write after mutating the buffer for `scope`. */
+  schedule: (scope: string) => void;
+};
+
+/**
+ * Manages the thread-activity localStorage persistence layer for
+ * useUnreadChannels: owns the loaded-scope ref, the coalescing timer, the
+ * pagehide/visibility flush, and hydration on identity/relay change. The buffer
+ * itself (`itemsRef`) is owned by the parent and merged in place by its writers;
+ * this hook only decides when the buffer is durably persisted.
+ *
+ * Sibling of useObservedUnreadPersistence — same scope-fence and flush shape,
+ * minus marker-prune/removeChannel/clearAll, which thread activity has no
+ * analog for.
+ */
+export function useThreadActivityPersistence(
+  normalizedPubkey: string | null,
+  normalizedRelayUrl: string,
+  itemsRef: React.MutableRefObject<ThreadActivityItem[]>,
+): ThreadActivityPersistence {
+  const currentScope = activityScopeKey(normalizedPubkey, normalizedRelayUrl);
+
+  const scopeLoadedRef = React.useRef<string>("");
+  const timerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const persistRefs = React.useRef<ThreadActivityRefs>({
+    itemsRef,
+    scopeLoadedRef,
+    timerRef,
+  });
+  persistRefs.current.itemsRef = itemsRef;
+
+  // pagehide + visibilitychange→hidden: synchronously persist any pending write
+  // before the webview unloads or is backgrounded. Cmd+R and #5588's idle
+  // reload both tear the webview down within the coalescing window; without
+  // these flushes the last burst of replies would be lost.
+  React.useEffect(() => {
+    const refs = persistRefs.current;
+    const flush = () => flushThreadActivityWrite(refs);
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") flush();
+    };
+    window.addEventListener("pagehide", flush);
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      window.removeEventListener("pagehide", flush);
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }, []);
+
+  // Hydrate the buffer whenever identity/relay changes. Flush the OLD scope
+  // first so an in-flight coalesced write lands under the old key before the
+  // buffer is clobbered, then drop the orphaned legacy key for this pubkey.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: normalizedRelayUrl is an intentional reset signal alongside normalizedPubkey
+  React.useEffect(() => {
+    flushThreadActivityWrite(persistRefs.current);
+
+    if (normalizedPubkey && normalizedRelayUrl) {
+      removeLegacyThreadActivityKey(normalizedPubkey);
+      itemsRef.current = readActivityFromStorage(
+        normalizedPubkey,
+        normalizedRelayUrl,
+      );
+    } else {
+      itemsRef.current = [];
+    }
+    scopeLoadedRef.current = currentScope;
+
+    // Flush the current scope on unmount / before the next run so a pending
+    // write is never dropped when refs are clobbered.
+    return () => {
+      flushThreadActivityWrite(persistRefs.current);
+    };
+  }, [normalizedPubkey, normalizedRelayUrl]);
+
+  const schedule = React.useCallback(
+    (scope: string) => scheduleThreadActivityWrite(scope, persistRefs.current),
+    [],
+  );
+
+  const isScopeLoaded = React.useCallback(
+    () => currentScope !== "" && scopeLoadedRef.current === currentScope,
+    [currentScope],
+  );
+
+  return React.useMemo(
+    () => ({ scopeLoadedRef, currentScope, isScopeLoaded, schedule }),
+    [currentScope, isScopeLoaded, schedule],
+  );
+}
diff --git a/desktop/src/features/channels/useUnreadChannels.ts b/desktop/src/features/channels/useUnreadChannels.ts
index d46cc71cdbe..0464a00fe0b 100644
--- a/desktop/src/features/channels/useUnreadChannels.ts
+++ b/desktop/src/features/channels/useUnreadChannels.ts
@@ -38,11 +38,8 @@ import { useStableMap, useStableSet } from "@/shared/hooks/useStableReference";
 import { normalizeRelayUrl } from "@/features/profile/lib/selfProfileStorage";
 import { DM_NOTIFIABLE_EVENT_KINDS } from "./isDmNotifiableKind";
 import {
-  activityScopeKey,
   addThreadActivityItems,
   projectActivityForScope,
-  readActivityFromStorage,
-  writeActivityToStorage,
   type ThreadActivityItem,
 } from "@/features/channels/threadActivityStorage";
 export type { ThreadActivityItem } from "@/features/channels/threadActivityStorage";
@@ -55,6 +52,7 @@ export {
   writeActivityToStorage,
 } from "@/features/channels/threadActivityStorage";
 import { useObservedUnreadPersistence } from "@/features/channels/useObservedUnreadPersistence";
+import { useThreadActivityPersistence } from "@/features/channels/useThreadActivityPersistence";
 
 type UseUnreadChannelsOptions = UseLiveChannelUpdatesOptions & {
   pubkey?: string;
@@ -147,14 +145,6 @@ export function useUnreadChannels(
   const normalizedRelayUrl = relayUrlOption
     ? normalizeRelayUrl(relayUrlOption)
     : "";
-  // Single identity for the in-memory thread-activity buffer — computed once
-  // per render and used at reset, both writers, and the return fence. The
-  // helper returns "" when either value is absent, which never matches a valid
-  // loaded scope, so the fence returns [] until the buffer is seeded.
-  const currentActivityScope = activityScopeKey(
-    normalizedPubkey,
-    normalizedRelayUrl,
-  );
 
   const {
     getEffectiveTimestamp,
@@ -227,12 +217,10 @@ export function useUnreadChannels(
   mutedChannelIdsRef.current = mutedChannelIdsOption ?? new Set();
 
   // Thread reply events that triggered notifications — surfaced in the Home
-  // activity feed as synthetic FeedItems.
+  // activity feed as synthetic FeedItems. The buffer is the source of truth
+  // between coalesced writes; useThreadActivityPersistence owns the loaded
+  // scope, the write timer, flush, and hydration.
   const threadActivityRef = React.useRef<ThreadActivityItem[]>([]);
-  // Tracks the (pubkey:relayUrl) scope currently loaded into threadActivityRef.
-  // Writers guard against this before merging so in-flight writes from a prior
-  // scope cannot corrupt the new one; renders return [] until it matches.
-  const threadActivityScopeRef = React.useRef<string>("");
 
   // Tracks which channels we've already issued a catch-up REQ for this
   // session. Prevents re-fetching on every channels-list refetch, while still
@@ -266,6 +254,15 @@ export function useUnreadChannels(
     { onPruned: bumpLatestVersion },
   );
 
+  // Thread-activity persistence: coalesced writes, pagehide/visibility flush,
+  // hydration + legacy-key cleanup. Owns the loaded scope for the buffer above.
+  const activityPersistence = useThreadActivityPersistence(
+    normalizedPubkey,
+    normalizedRelayUrl,
+    threadActivityRef,
+  );
+  const currentActivityScope = activityPersistence.currentScope;
+
   // Reset all in-session state when the identity or relay changes. In-memory
   // caches are cleared; persisted stores are loaded for the new pubkey (so
   // forced-unread, participation, etc. are correct for the new identity).
@@ -285,11 +282,6 @@ export function useUnreadChannels(
       ? mentionedStore.read(pubkey)
       : new Set();
     mutedRootIdsRef.current = pubkey ? mutedStore.read(pubkey) : new Set();
-    threadActivityRef.current =
-      normalizedPubkey && normalizedRelayUrl
-        ? readActivityFromStorage(normalizedPubkey, normalizedRelayUrl)
-        : [];
-    threadActivityScopeRef.current = currentActivityScope;
     bumpLatestVersion();
     bumpMembershipVersion();
   }, [pubkey, relayClient, normalizedRelayUrl]);
@@ -490,15 +482,10 @@ export function useUnreadChannels(
 
   const handleThreadReplyNotification = React.useCallback(
     (channelId: string, event: RelayEvent) => {
-      // Guard: don't merge into a ref whose scope has drifted from the current
-      // identity. Also reject an empty scope — activityScopeKey() returns ""
-      // when pubkey or relay is absent, and "" !== "" is false, so without this
-      // guard a writer could fire before the first valid scope is established.
-      if (
-        !currentActivityScope ||
-        threadActivityScopeRef.current !== currentActivityScope
-      )
-        return;
+      // Guard: don't merge into a buffer whose scope has drifted from the
+      // current identity. isScopeLoaded() also rejects an empty scope, so a
+      // writer can never fire before the first valid scope is seeded.
+      if (!activityPersistence.isScopeLoaded()) return;
 
       const channelName =
         channels.find((ch) => ch.id === channelId)?.name ?? "";
@@ -516,25 +503,13 @@ export function useUnreadChannels(
       if (!added.didAdd) return;
       const didRecordMentionedRoot = recordMentionedRoot(event);
       threadActivityRef.current = added.items;
-      if (normalizedPubkey !== null && normalizedRelayUrl) {
-        writeActivityToStorage(
-          normalizedPubkey,
-          normalizedRelayUrl,
-          added.items,
-        );
-      }
+      activityPersistence.schedule(currentActivityScope);
       if (didRecordMentionedRoot) {
         bumpMembershipVersion();
       }
       bumpLatestVersion();
     },
-    [
-      channels,
-      currentActivityScope,
-      normalizedPubkey,
-      normalizedRelayUrl,
-      recordMentionedRoot,
-    ],
+    [channels, currentActivityScope, activityPersistence, recordMentionedRoot],
   );
 
   const muteThread = React.useCallback(
@@ -785,13 +760,7 @@ export function useUnreadChannels(
         );
         if (added.didAdd) {
           threadActivityRef.current = added.items;
-          if (normalizedPubkey && normalizedRelayUrl) {
-            writeActivityToStorage(
-              normalizedPubkey,
-              normalizedRelayUrl,
-              added.items,
-            );
-          }
+          activityPersistence.schedule(currentActivityScope);
           didAdvance = true;
         }
       }
@@ -1009,7 +978,7 @@ export function useUnreadChannels(
     mentionedRootIds,
     recordThreadInteraction,
     threadActivityItems: projectActivityForScope(
-      threadActivityScopeRef.current,
+      activityPersistence.scopeLoadedRef.current,
       currentActivityScope,
       threadActivityRef.current,
     ),
diff --git a/desktop/src/features/custom-emoji/focusRefetchPolicy.test.mjs b/desktop/src/features/custom-emoji/focusRefetchPolicy.test.mjs
index 95aa6311d6f..73f8df42cc9 100644
--- a/desktop/src/features/custom-emoji/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/custom-emoji/focusRefetchPolicy.test.mjs
@@ -54,12 +54,12 @@ test("custom-emoji: skips fresh focus refetch", async () => {
   );
 });
 
-test("custom-emoji: refetches genuinely stale data on focus", async () => {
+test("custom-emoji: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: customEmojiFocusRefetchPolicy.staleTime + 1,
       policy: customEmojiFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
diff --git a/desktop/src/features/custom-emoji/hooks.ts b/desktop/src/features/custom-emoji/hooks.ts
index e730e950fb6..22016496f2f 100644
--- a/desktop/src/features/custom-emoji/hooks.ts
+++ b/desktop/src/features/custom-emoji/hooks.ts
@@ -32,7 +32,7 @@ export const CUSTOM_EMOJI_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy for the custom emoji query; consumed by focusRefetchPolicy.test.mjs. */
 export const customEmojiFocusRefetchPolicy = {
   staleTime: CUSTOM_EMOJI_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 export const customEmojiQueryKey = ["custom-emoji"] as const;
diff --git a/desktop/src/features/forum/focusRefetchPolicy.test.mjs b/desktop/src/features/forum/focusRefetchPolicy.test.mjs
index 9a87e1fe392..50e1dd21e11 100644
--- a/desktop/src/features/forum/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/forum/focusRefetchPolicy.test.mjs
@@ -54,12 +54,12 @@ test("forum: skips fresh focus refetch", async () => {
   );
 });
 
-test("forum: refetches genuinely stale data on focus", async () => {
+test("forum: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: forumFocusRefetchPolicy.staleTime + 1,
       policy: forumFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
diff --git a/desktop/src/features/forum/hooks.ts b/desktop/src/features/forum/hooks.ts
index e773dd07a64..2918a694fd0 100644
--- a/desktop/src/features/forum/hooks.ts
+++ b/desktop/src/features/forum/hooks.ts
@@ -22,7 +22,7 @@ export const FORUM_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy shared by forum-posts and forum-thread queries; consumed by focusRefetchPolicy.test.mjs. */
 export const forumFocusRefetchPolicy = {
   staleTime: FORUM_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 export function forumPostsQueryKey(channelId: string) {
diff --git a/desktop/src/features/home/focusRefetchPolicy.test.mjs b/desktop/src/features/home/focusRefetchPolicy.test.mjs
index 41250dfe8ea..1b9da3922a4 100644
--- a/desktop/src/features/home/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/home/focusRefetchPolicy.test.mjs
@@ -77,13 +77,13 @@ for (const entry of [
     );
   });
 
-  test(`${entry.name} refetches genuinely stale data on focus`, async () => {
+  test(`${entry.name} does not refetch stale data on focus`, async () => {
     assert.equal(
       await focusRefetchCount({
         ageMs: entry.focusPolicy.staleTime + 1,
         policy: entry.focusPolicy,
       }),
-      1,
+      0,
     );
   });
 }
diff --git a/desktop/src/features/home/hooks.ts b/desktop/src/features/home/hooks.ts
index 3b64f49069d..ce4a0a3056a 100644
--- a/desktop/src/features/home/hooks.ts
+++ b/desktop/src/features/home/hooks.ts
@@ -12,7 +12,7 @@ export const HOME_FEED_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy for the home feed query; consumed by focusRefetchPolicy.test.mjs. */
 export const homeFeedFocusRefetchPolicy = {
   staleTime: HOME_FEED_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 export function useHomeFeedQuery() {
diff --git a/desktop/src/features/home/ui/HomeMembersSidebarOverlay.tsx b/desktop/src/features/home/ui/HomeMembersSidebarOverlay.tsx
new file mode 100644
index 00000000000..88df346af43
--- /dev/null
+++ b/desktop/src/features/home/ui/HomeMembersSidebarOverlay.tsx
@@ -0,0 +1,37 @@
+import * as React from "react";
+
+import { useCommunities } from "@/features/communities/useCommunities";
+import type { Channel } from "@/shared/api/types";
+
+const MembersSidebar = React.lazy(async () => {
+  const module = await import("@/features/channels/ui/MembersSidebar");
+  return { default: module.MembersSidebar };
+});
+
+export function HomeMembersSidebarOverlay({
+  channel,
+  currentPubkey,
+  onClose,
+}: {
+  channel: Channel | null;
+  currentPubkey?: string;
+  onClose: () => void;
+}) {
+  const { activeCommunity } = useCommunities();
+
+  if (!channel) return null;
+
+  return (
+    <React.Suspense fallback={null}>
+      <MembersSidebar
+        channel={channel}
+        currentPubkey={currentPubkey}
+        onOpenChange={(nextOpen) => {
+          if (!nextOpen) onClose();
+        }}
+        open={true}
+        relayUrl={activeCommunity?.relayUrl}
+      />
+    </React.Suspense>
+  );
+}
diff --git a/desktop/src/features/home/ui/HomeView.tsx b/desktop/src/features/home/ui/HomeView.tsx
index 4ffbbaddc53..3b7bff44ea0 100644
--- a/desktop/src/features/home/ui/HomeView.tsx
+++ b/desktop/src/features/home/ui/HomeView.tsx
@@ -61,7 +61,7 @@ import { useRelaySelfQuery } from "@/features/moderation/hooks";
 import { resolveUserLabel } from "@/features/profile/lib/identity";
 import { useRemindLater } from "@/features/reminders/ui/RemindMeLaterProvider";
 import { deleteMessage, sendChannelMessage } from "@/shared/api/tauri";
-import type { HomeFeedResponse } from "@/shared/api/types";
+import type { Channel, HomeFeedResponse } from "@/shared/api/types";
 import { KIND_REACTION } from "@/shared/constants/kinds";
 import { topChromeInset } from "@/shared/layout/chromeLayout";
 import { cn } from "@/shared/lib/cn";
@@ -72,6 +72,7 @@ import { AUXILIARY_PANEL_SINGLE_COLUMN_BREAKPOINT_PX } from "@/shared/layout/Aux
 import { useHistorySearchState } from "@/shared/hooks/useHistorySearchState";
 import { ProfilePanelProvider } from "@/shared/context/ProfilePanelContext";
 import { Button } from "@/shared/ui/button";
+import { HomeMembersSidebarOverlay } from "./HomeMembersSidebarOverlay";
 
 const INBOX_SEARCH_KEYS = [
   "item",
@@ -167,6 +168,9 @@ export function HomeView({
   const [managedChannelId, setManagedChannelId] = React.useState<string | null>(
     null,
   );
+  const [membersChannel, setMembersChannel] = React.useState<Channel | null>(
+    null,
+  );
   const { goChannel } = useAppNavigation();
   const openDmMutation = useOpenDmMutation();
   const openDm = openDmMutation.mutateAsync;
@@ -972,6 +976,7 @@ export function HomeView({
                 channel={managedChannel}
                 currentPubkey={currentPubkey}
                 layout="split"
+                onOpenMembers={() => setMembersChannel(managedChannel)}
                 onOpenChange={(nextOpen) => {
                   if (!nextOpen) {
                     setManagedChannelId(null);
@@ -983,6 +988,11 @@ export function HomeView({
           ) : null}
         </div>
       </div>
+      <HomeMembersSidebarOverlay
+        channel={membersChannel}
+        currentPubkey={currentPubkey}
+        onClose={() => setMembersChannel(null)}
+      />
     </ProfilePanelProvider>
   );
 }
diff --git a/desktop/src/features/messages/hooks.ts b/desktop/src/features/messages/hooks.ts
index 9091121d0bf..e59cd72a919 100644
--- a/desktop/src/features/messages/hooks.ts
+++ b/desktop/src/features/messages/hooks.ts
@@ -1,5 +1,10 @@
 import { useEffect, useEffectEvent } from "react";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  type QueryClient,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
 import { toast } from "sonner";
 
 import {
@@ -17,7 +22,6 @@ import {
 import {
   projectChannelWindowMessages,
   refreshChannelWindowMessages,
-  shouldRefreshChannelWindowAfterSubscribe,
 } from "@/features/messages/lib/projectChannelWindow";
 import { reconcileChannelWindowMessages } from "@/features/messages/lib/channelWindowReconciliation";
 import {
@@ -235,26 +239,46 @@ export function useChannelWindowQuery(channel: Channel | null) {
   });
 }
 
+export function reconcileFetchedChannelWindow(
+  queryClient: QueryClient,
+  channelId: string,
+  events: Awaited<ReturnType<typeof getChannelWindowEvents>>,
+  previousMessages: RelayEvent[],
+  signal: AbortSignal,
+): RelayEvent[] {
+  // Tauri invokes cannot be canceled after dispatch. A replacement refetch can
+  // therefore win while this older request is still in flight. Never let that
+  // canceled request commit its stale page into the authoritative window.
+  signal.throwIfAborted();
+  const windowKey = channelWindowKey(channelId);
+  const page = parseChannelWindowResponse(events, channelId, null);
+  const current =
+    queryClient.getQueryData<ChannelWindowStore>(windowKey) ??
+    emptyChannelWindowStore();
+  const next = replaceNewestChannelWindow(current, page);
+  queryClient.setQueryData(windowKey, next);
+  return reconcileChannelWindowMessages(next, previousMessages);
+}
+
 export function useChannelMessagesQuery(channel: Channel | null) {
   const queryClient = useQueryClient();
   const queryKey = channelMessagesKey(channel?.id ?? "none");
-  const windowKey = channelWindowKey(channel?.id ?? "none");
 
   return useQuery({
     enabled: channel !== null && channel.channelType !== "forum",
     queryKey,
-    queryFn: async () => {
+    queryFn: async ({ signal }) => {
       if (!channel) throw new Error("No channel selected.");
       const previousMessages =
         queryClient.getQueryData<RelayEvent[]>(queryKey) ?? [];
       const events = await getChannelWindowEvents(channel.id);
-      const page = parseChannelWindowResponse(events, channel.id, null);
-      const current =
-        queryClient.getQueryData<ChannelWindowStore>(windowKey) ??
-        emptyChannelWindowStore();
-      const next = replaceNewestChannelWindow(current, page);
-      queryClient.setQueryData(windowKey, next);
-      return reconcileChannelWindowMessages(next, previousMessages);
+      return reconcileFetchedChannelWindow(
+        queryClient,
+        channel.id,
+        events,
+        previousMessages,
+        signal,
+      );
     },
     staleTime: 5 * 60 * 1_000,
     gcTime: 60 * 60 * 1_000,
@@ -382,9 +406,10 @@ export function useChannelSubscription(channel: Channel | null) {
         }
 
         cleanup = dispose;
-        if (!shouldRefreshChannelWindowAfterSubscribe(queryClient, channelId)) {
-          return;
-        }
+        // The live subscription starts at "now", so it cannot close the gap
+        // between the last page snapshot and subscription establishment. Always
+        // refresh after the subscription is active; freshness alone is not a
+        // proof that no relay events landed in that interval.
         void refreshNewestWindow().catch((error) => {
           if (!isDisposed) {
             console.error(
@@ -406,7 +431,7 @@ export function useChannelSubscription(channel: Channel | null) {
         void cleanup();
       }
     };
-  }, [channelId, channelType, queryClient]);
+  }, [channelId, channelType]);
 }
 
 export function useSendMessageMutation(
diff --git a/desktop/src/features/messages/lib/channelWindowReconciliation.ts b/desktop/src/features/messages/lib/channelWindowReconciliation.ts
index cc2c0f034c8..f6a7e4df21f 100644
--- a/desktop/src/features/messages/lib/channelWindowReconciliation.ts
+++ b/desktop/src/features/messages/lib/channelWindowReconciliation.ts
@@ -28,6 +28,18 @@ export function reconcileChannelWindowMessages(
   messages: RelayEvent[],
 ) {
   const windowEvents = flattenChannelWindowEvents(window);
+  if (window.pages.length === 0) {
+    // A pageless window is unresolved, not authoritative. This state can exist
+    // briefly when the companion window query mounts beside an already-cached
+    // rendered timeline. Preserve that cache while admitting live events;
+    // otherwise the first live event projects a one-row overlay over the
+    // entire conversation until reload refetches page zero.
+    let merged = messages;
+    for (const event of windowEvents) {
+      merged = reconcileIncomingMessage(merged, event);
+    }
+    return [...merged].sort((left, right) => compareRelayOrder(right, left));
+  }
   const authoritativeIds = new Set(windowEvents.map((event) => event.id));
   const retained = retainRefetchReconciliationEvents(messages).filter(
     (event) => !authoritativeIds.has(event.id),
diff --git a/desktop/src/features/messages/lib/projectChannelWindow.test.mjs b/desktop/src/features/messages/lib/projectChannelWindow.test.mjs
index 2ca2354271e..14ec110addf 100644
--- a/desktop/src/features/messages/lib/projectChannelWindow.test.mjs
+++ b/desktop/src/features/messages/lib/projectChannelWindow.test.mjs
@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { QueryClient, QueryObserver } from "@tanstack/react-query";
 
+import { reconcileFetchedChannelWindow } from "../hooks.ts";
 import { channelMessagesKey, channelWindowKey } from "./messageQueryKeys.ts";
 import {
   appendOlderChannelWindow,
@@ -11,10 +12,8 @@ import {
   replaceNewestChannelWindow,
 } from "./channelWindowStore.ts";
 import {
-  CHANNEL_WINDOW_FRESH_MS,
   projectChannelWindowMessages,
   refreshChannelWindowMessages,
-  shouldRefreshChannelWindowAfterSubscribe,
 } from "./projectChannelWindow.ts";
 import { reconcileChannelWindowMessages } from "./channelWindowReconciliation.ts";
 
@@ -30,6 +29,18 @@ function event(id, createdAt) {
   };
 }
 
+function wirePage(rows) {
+  return [
+    ...rows,
+    {
+      ...event("bounds", 0),
+      kind: 39006,
+      tags: [["d", "channel:head"]],
+      content: JSON.stringify({ has_more: false, next_cursor: null }),
+    },
+  ];
+}
+
 function newestPage(rows) {
   return {
     startCursor: null,
@@ -276,92 +287,79 @@ test("test_live_projection_retains_pending_send_and_non_broadcast_thread_reply",
   ]);
 });
 
-test("test_subscribe_refresh_skips_fresh_populated_window", () => {
+test("test_canceled_stale_fetch_cannot_overwrite_catch_up_window", async () => {
   const harness = createHarness();
-  const updatedAt = harness.client.getQueryState(
-    harness.windowKey,
-  ).dataUpdatedAt;
-
-  assert.equal(
-    shouldRefreshChannelWindowAfterSubscribe(
-      harness.client,
-      harness.channelId,
-      updatedAt + CHANNEL_WINDOW_FRESH_MS - 1,
-    ),
-    false,
-  );
-});
-
-test("test_subscribe_refresh_runs_for_stale_window", () => {
-  const harness = createHarness();
-  const updatedAt = harness.client.getQueryState(
-    harness.windowKey,
-  ).dataUpdatedAt;
+  const requests = [];
+  let resolveRequestStarted;
+  let requestStarted = new Promise((resolve) => {
+    resolveRequestStarted = resolve;
+  });
+  const observer = new QueryObserver(harness.client, {
+    queryKey: harness.messagesKey,
+    queryFn: async ({ signal }) => {
+      const previousMessages = harness.client.getQueryData(harness.messagesKey);
+      let resolveFetch;
+      const fetch = new Promise((resolve) => {
+        resolveFetch = resolve;
+      });
+      requests.push({ resolveFetch, signal });
+      resolveRequestStarted();
+      const events = await fetch;
+      return reconcileFetchedChannelWindow(
+        harness.client,
+        harness.channelId,
+        events,
+        previousMessages,
+        signal,
+      );
+    },
+  });
+  const unsubscribe = observer.subscribe(() => {});
 
-  assert.equal(
-    shouldRefreshChannelWindowAfterSubscribe(
-      harness.client,
-      harness.channelId,
-      updatedAt + CHANNEL_WINDOW_FRESH_MS,
-    ),
-    true,
+  await requestStarted;
+  requestStarted = new Promise((resolve) => {
+    resolveRequestStarted = resolve;
+  });
+  const catchUp = refreshChannelWindowMessages(
+    harness.client,
+    harness.channelId,
   );
-});
+  await requestStarted;
 
-test("test_live_cache_merge_does_not_extend_window_freshness", () => {
-  const harness = createHarness();
-  const windowUpdatedAt = harness.client.getQueryState(
-    harness.windowKey,
-  ).dataUpdatedAt;
-
-  harness.client.setQueryData(harness.messagesKey, (messages) => [
-    ...messages,
-    event("live-cache-only", 110),
-  ]);
-
-  assert.equal(
-    shouldRefreshChannelWindowAfterSubscribe(
-      harness.client,
-      harness.channelId,
-      windowUpdatedAt + CHANNEL_WINDOW_FRESH_MS,
-    ),
-    true,
+  assert.equal(requests[0].signal.aborted, true);
+  requests[1].resolveFetch(
+    wirePage([event("gap", 110), event("initial", 100)]),
   );
-});
+  await catchUp;
+  assert.deepEqual(contents(harness), ["initial", "gap"]);
 
-test("test_subscribe_refresh_runs_without_a_message_query", () => {
-  const client = new QueryClient({
-    defaultOptions: { queries: { retry: false } },
-  });
+  requests[0].resolveFetch(wirePage([event("initial", 100)]));
+  await new Promise((resolve) => setImmediate(resolve));
+  appendLiveEvent(harness, event("live", 120));
 
-  assert.equal(
-    shouldRefreshChannelWindowAfterSubscribe(client, "missing-channel"),
-    true,
+  assert.deepEqual(contents(harness), ["initial", "gap", "live"]);
+  assert.deepEqual(
+    flattenChannelWindowEvents(
+      harness.client.getQueryData(harness.windowKey),
+    ).map((item) => item.content),
+    ["initial", "gap", "live"],
   );
+  unsubscribe();
 });
 
-test("test_subscribe_refresh_does_not_duplicate_inflight_initial_fetch", async () => {
-  const client = new QueryClient({
-    defaultOptions: { queries: { retry: false } },
-  });
-  const channelId = "pending-channel";
-  const queryKey = channelMessagesKey(channelId);
-  let resolveFetch;
-  const observer = new QueryObserver(client, {
-    queryKey,
-    queryFn: () =>
-      new Promise((resolve) => {
-        resolveFetch = resolve;
-      }),
-  });
-  const unsubscribe = observer.subscribe(() => {});
+test("test_pageless_live_projection_preserves_cached_timeline", () => {
+  const harness = createHarness();
+  const cached = harness.client.getQueryData(harness.messagesKey);
+  const pageless = emptyChannelWindowStore();
+  harness.client.setQueryData(harness.windowKey, pageless);
 
-  assert.equal(
-    shouldRefreshChannelWindowAfterSubscribe(client, channelId),
-    false,
+  const next = mergeLiveChannelWindowEvent(
+    harness.client.getQueryData(harness.windowKey),
+    event("live", 110),
   );
+  harness.client.setQueryData(harness.windowKey, next);
+  projectChannelWindowMessages(harness.client, harness.channelId);
 
-  resolveFetch([]);
-  await client.getQueryCache().find({ queryKey })?.promise;
-  unsubscribe();
+  assert.deepEqual(contents(harness), ["initial", "live"]);
+  assert.equal(harness.client.getQueryData(harness.messagesKey)[0], cached[0]);
 });
diff --git a/desktop/src/features/messages/lib/projectChannelWindow.ts b/desktop/src/features/messages/lib/projectChannelWindow.ts
index 2d56c096b6c..81ef3de42d0 100644
--- a/desktop/src/features/messages/lib/projectChannelWindow.ts
+++ b/desktop/src/features/messages/lib/projectChannelWindow.ts
@@ -8,34 +8,6 @@ import {
 } from "./channelWindowStore";
 import { reconcileChannelWindowMessages } from "./channelWindowReconciliation";
 
-export const CHANNEL_WINDOW_FRESH_MS = 5 * 60_000;
-
-/**
- * Subscription setup closes the gap between the initial page and live events,
- * but revisiting a channel with a fresh page has no gap to close. Reconnects
- * still refresh unconditionally at their call site.
- */
-export function shouldRefreshChannelWindowAfterSubscribe(
-  queryClient: QueryClient,
-  channelId: string,
-  now = Date.now(),
-): boolean {
-  const messagesState = queryClient.getQueryState(
-    channelMessagesKey(channelId),
-  );
-  if (!messagesState) return true;
-  if (messagesState.fetchStatus === "fetching") return false;
-  const windowState = queryClient.getQueryState(channelWindowKey(channelId));
-  if (
-    messagesState.status !== "success" ||
-    windowState?.status !== "success" ||
-    windowState.dataUpdatedAt === 0
-  ) {
-    return true;
-  }
-  return now - windowState.dataUpdatedAt >= CHANNEL_WINDOW_FRESH_MS;
-}
-
 /** Keep the rendered timeline cache aligned with its authoritative window. */
 export function projectChannelWindowMessages(
   queryClient: QueryClient,
diff --git a/desktop/src/features/messages/lib/useRichTextEditor.ts b/desktop/src/features/messages/lib/useRichTextEditor.ts
index e800787ca7a..aeb7198b4c5 100644
--- a/desktop/src/features/messages/lib/useRichTextEditor.ts
+++ b/desktop/src/features/messages/lib/useRichTextEditor.ts
@@ -742,17 +742,26 @@ export function useRichTextEditor({
     [editor],
   );
 
-  const setContentAndFocusEnd = React.useCallback(
-    (markdown: string) => {
+  /**
+   * Replace the editor document with literal plain text and focus its end.
+   *
+   * Unlike markdown `setContent`, this preserves trailing whitespace. The
+   * transaction is marked as programmatic so authored-update observers do not
+   * reconcile against the intermediate post-send restoration.
+   */
+  const restorePlainTextAndFocusEnd = React.useCallback(
+    (text: string) => {
       if (!editor) return;
-      // The caller already synchronizes composer state. Keep this programmatic
-      // restoration out of user-edit observers (autocomplete/reconciliation),
-      // then move selection in the same command chain.
-      editor
-        .chain()
-        .setContent(markdown, { emitUpdate: false })
-        .focus("end")
-        .run();
+      const paragraph = editor.schema.nodes.paragraph.create(
+        null,
+        text ? editor.schema.text(text) : undefined,
+      );
+      const tr = editor.state.tr
+        .replaceWith(0, editor.state.doc.content.size, paragraph)
+        .setMeta("preventUpdate", true);
+      tr.setSelection(TextSelection.atEnd(tr.doc));
+      editor.view.dispatch(tr);
+      editor.view.focus();
     },
     [editor],
   );
@@ -950,7 +959,7 @@ export function useRichTextEditor({
     isEmpty,
     clearContent,
     setContent,
-    setContentAndFocusEnd,
+    restorePlainTextAndFocusEnd,
     focus,
     focusEnd,
     focusPreserve,
diff --git a/desktop/src/features/messages/ui/useMentionSendFlow.ts b/desktop/src/features/messages/ui/useMentionSendFlow.ts
index cc51c733453..4a721dcfed9 100644
--- a/desktop/src/features/messages/ui/useMentionSendFlow.ts
+++ b/desktop/src/features/messages/ui/useMentionSendFlow.ts
@@ -73,7 +73,7 @@ type UseMentionSendFlowOptions = {
   >;
   richText: Pick<
     UseRichTextEditorResult,
-    "clearContent" | "setContent" | "setContentAndFocusEnd"
+    "clearContent" | "setContent" | "restorePlainTextAndFocusEnd"
   >;
   setContent: (content: string) => void;
   setIsEmojiPickerOpen: React.Dispatch<React.SetStateAction<boolean>>;
@@ -334,7 +334,7 @@ export function useMentionSendFlow({
       setContent(postSendContent);
       contentRef.current = postSendContent;
       if (postSendContent) {
-        richText.setContentAndFocusEnd(postSendContent);
+        richText.restorePlainTextAndFocusEnd(postSendContent);
         mentions.cancelMentionAutocomplete();
       } else richText.clearContent();
       setPendingImeta([]);
@@ -352,7 +352,7 @@ export function useMentionSendFlow({
       mentions.cancelMentionAutocomplete,
       mentions.clearMentions,
       richText.clearContent,
-      richText.setContentAndFocusEnd,
+      richText.restorePlainTextAndFocusEnd,
       setContent,
       setIsEmojiPickerOpen,
       setPendingImeta,
diff --git a/desktop/src/features/notifications/hooks.ts b/desktop/src/features/notifications/hooks.ts
index d70ac60b220..1a2cb4a9a53 100644
--- a/desktop/src/features/notifications/hooks.ts
+++ b/desktop/src/features/notifications/hooks.ts
@@ -4,6 +4,7 @@ import { useHomeFeedQuery } from "@/features/home/hooks";
 import { useUsersBatchQuery } from "@/features/profile/hooks";
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import type { Channel, FeedItem, HomeFeedResponse } from "@/shared/api/types";
+import { scheduleAfterForegroundReady } from "@/shared/lib/foregroundReady";
 import {
   getDesktopNotificationPermissionState,
   requestDesktopNotificationAccess,
@@ -210,14 +211,23 @@ export function useNotificationSettings(pubkey?: string) {
   }, [normalizedPubkey]);
 
   React.useEffect(() => {
+    let cancelPendingRefresh: (() => void) | null = null;
     const refreshWhenVisible = () => {
-      if (document.visibilityState === "visible") {
-        void refreshPermission();
+      if (document.visibilityState !== "visible") {
+        cancelPendingRefresh?.();
+        cancelPendingRefresh = null;
+        return;
       }
+      if (cancelPendingRefresh) return;
+      cancelPendingRefresh = scheduleAfterForegroundReady(() => {
+        cancelPendingRefresh = null;
+        if (document.visibilityState === "visible") void refreshPermission();
+      });
     };
     document.addEventListener("visibilitychange", refreshWhenVisible);
     window.addEventListener("focus", refreshWhenVisible);
     return () => {
+      cancelPendingRefresh?.();
       document.removeEventListener("visibilitychange", refreshWhenVisible);
       window.removeEventListener("focus", refreshWhenVisible);
     };
diff --git a/desktop/src/features/presence/focusRefetchPolicy.test.mjs b/desktop/src/features/presence/focusRefetchPolicy.test.mjs
index f83a61d64bb..122ef43cc1b 100644
--- a/desktop/src/features/presence/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/presence/focusRefetchPolicy.test.mjs
@@ -54,12 +54,12 @@ test("presence: skips fresh focus refetch", async () => {
   );
 });
 
-test("presence: refetches genuinely stale data on focus", async () => {
+test("presence: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: presenceFocusRefetchPolicy.staleTime + 1,
       policy: presenceFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
diff --git a/desktop/src/features/presence/hooks.ts b/desktop/src/features/presence/hooks.ts
index 6da0a6215a4..b1acacafbc5 100644
--- a/desktop/src/features/presence/hooks.ts
+++ b/desktop/src/features/presence/hooks.ts
@@ -29,7 +29,7 @@ export const PRESENCE_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy for the presence query; consumed by focusRefetchPolicy.test.mjs. */
 export const presenceFocusRefetchPolicy = {
   staleTime: PRESENCE_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 const PRESENCE_ACTIVITY_THROTTLE_MS = 1_000;
 const PRESENCE_PREFERENCE_STORAGE_KEY = "buzz-presence-preference";
diff --git a/desktop/src/features/profile/ui/ProfileTabContentTransition.tsx b/desktop/src/features/profile/ui/ProfileTabContentTransition.tsx
new file mode 100644
index 00000000000..b5174251dc2
--- /dev/null
+++ b/desktop/src/features/profile/ui/ProfileTabContentTransition.tsx
@@ -0,0 +1,116 @@
+import * as React from "react";
+import {
+  AnimatePresence,
+  motion,
+  type Variants,
+  useReducedMotion,
+} from "motion/react";
+
+import type { ProfilePanelTab } from "@/features/profile/ui/UserProfilePanelUtils";
+import { cn } from "@/shared/lib/cn";
+
+type TabTransitionDirection = -1 | 0 | 1;
+
+type TabTransitionContext = {
+  direction: TabTransitionDirection;
+  reduceMotion: boolean;
+};
+
+const TAB_CONTENT_OFFSET_PX = 28;
+
+const tabContentVariants: Variants = {
+  enter: ({ direction, reduceMotion }: TabTransitionContext) => ({
+    opacity: reduceMotion ? 1 : 0.72,
+    pointerEvents: "auto",
+    transform: reduceMotion
+      ? "translateX(0px)"
+      : `translateX(${direction * TAB_CONTENT_OFFSET_PX}px)`,
+  }),
+  center: {
+    opacity: 1,
+    pointerEvents: "auto",
+    transform: "translateX(0px)",
+  },
+  exit: ({ direction, reduceMotion }: TabTransitionContext) => ({
+    opacity: reduceMotion ? 1 : 0,
+    pointerEvents: "none",
+    transform: reduceMotion
+      ? "translateX(0px)"
+      : `translateX(${-direction * TAB_CONTENT_OFFSET_PX}px)`,
+  }),
+};
+
+export function ProfileTabContentTransition({
+  activeTab,
+  children,
+  className,
+  tabs,
+}: {
+  activeTab: ProfilePanelTab;
+  children: React.ReactNode;
+  className?: string;
+  tabs: ProfilePanelTab[];
+}) {
+  const reduceMotion = useReducedMotion() ?? false;
+  const [lastTransition, setLastTransition] = React.useState<{
+    direction: TabTransitionDirection;
+    tab: ProfilePanelTab;
+  }>({ direction: 0, tab: activeTab });
+  const previousIndex = tabs.indexOf(lastTransition.tab);
+  const activeIndex = tabs.indexOf(activeTab);
+  const direction: TabTransitionDirection =
+    lastTransition.tab === activeTab
+      ? lastTransition.direction
+      : previousIndex < 0 || activeIndex < 0 || previousIndex === activeIndex
+        ? 0
+        : activeIndex > previousIndex
+          ? 1
+          : -1;
+  const transitionContext: TabTransitionContext = {
+    direction,
+    reduceMotion,
+  };
+
+  React.useLayoutEffect(() => {
+    if (lastTransition.tab !== activeTab) {
+      setLastTransition({ direction, tab: activeTab });
+    }
+  }, [activeTab, direction, lastTransition.tab]);
+
+  return (
+    <div
+      className={cn("relative overflow-x-clip", className)}
+      data-active-tab={activeTab}
+      data-testid="user-profile-tab-content-transition"
+      data-transition-direction={
+        direction === 0 ? "none" : direction > 0 ? "forward" : "backward"
+      }
+    >
+      <AnimatePresence
+        custom={transitionContext}
+        initial={false}
+        mode="popLayout"
+      >
+        <motion.div
+          animate="center"
+          className="w-full min-w-0"
+          custom={transitionContext}
+          exit="exit"
+          initial="enter"
+          key={activeTab}
+          transition={
+            reduceMotion
+              ? { duration: 0 }
+              : {
+                  duration: 0.22,
+                  ease: [0.23, 1, 0.32, 1],
+                }
+          }
+          variants={tabContentVariants}
+        >
+          {children}
+        </motion.div>
+      </AnimatePresence>
+    </div>
+  );
+}
diff --git a/desktop/src/features/profile/ui/UserProfileAgentActions.tsx b/desktop/src/features/profile/ui/UserProfileAgentActions.tsx
index 81db3405b21..5919a16e29b 100644
--- a/desktop/src/features/profile/ui/UserProfileAgentActions.tsx
+++ b/desktop/src/features/profile/ui/UserProfileAgentActions.tsx
@@ -6,23 +6,12 @@ import {
   Download,
   Power,
   Settings,
-  Trash2,
 } from "lucide-react";
 
 import type { IdentityArchiveActions } from "@/features/identity-archive/hooks";
 import { ArchiveConfirmDialog } from "@/features/profile/ui/ArchiveConfirmDialog";
 import type { ManagedAgent } from "@/shared/api/types";
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from "@/shared/ui/alert-dialog";
-import { Button, buttonVariants } from "@/shared/ui/button";
+import { Button } from "@/shared/ui/button";
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -37,7 +26,6 @@ export function UserProfileAgentSettingsMenu({
   isPending,
   isBot = false,
   managedAgent,
-  onDelete,
   onDuplicatePersona,
   onExportPersona,
   onToggleAutoStart,
@@ -47,14 +35,12 @@ export function UserProfileAgentSettingsMenu({
   isPending: boolean;
   isBot?: boolean;
   managedAgent?: ManagedAgent;
-  onDelete?: () => void;
   onDuplicatePersona?: () => void;
   onExportPersona?: () => void;
   onToggleAutoStart?: () => void;
   personaActionKey?: string;
 }) {
   const [archiveConfirmOpen, setArchiveConfirmOpen] = React.useState(false);
-  const [deleteConfirmOpen, setDeleteConfirmOpen] = React.useState(false);
   const actionKey = managedAgent?.pubkey ?? "persona-draft";
   const personaKey = personaActionKey ?? actionKey;
   const canToggleAutoStart =
@@ -66,11 +52,8 @@ export function UserProfileAgentSettingsMenu({
   const hasArchiveAction =
     archiveActions?.canArchive === true &&
     archiveActions.isArchived !== undefined;
-  const shouldConfirmAgentDelete =
-    managedAgent !== undefined && onDelete !== undefined;
-  const hasManageActions = hasArchiveAction || Boolean(onDelete);
   const hasActions =
-    canToggleAutoStart || hasPrimaryActions || hasManageActions;
+    canToggleAutoStart || hasPrimaryActions || hasArchiveAction;
 
   if (!hasActions) {
     return null;
@@ -142,7 +125,7 @@ export function UserProfileAgentSettingsMenu({
               Export
             </DropdownMenuItem>
           ) : null}
-          {hasManageActions && (canToggleAutoStart || hasPrimaryActions) ? (
+          {hasArchiveAction && (canToggleAutoStart || hasPrimaryActions) ? (
             <DropdownMenuSeparator />
           ) : null}
           {hasArchiveAction && archiveActions ? (
@@ -166,24 +149,6 @@ export function UserProfileAgentSettingsMenu({
               </DropdownMenuItem>
             )
           ) : null}
-          {onDelete && hasArchiveAction ? <DropdownMenuSeparator /> : null}
-          {onDelete ? (
-            <DropdownMenuItem
-              className="text-destructive focus:text-destructive"
-              data-testid={`user-profile-agent-delete-${actionKey}`}
-              disabled={isPending}
-              onSelect={() => {
-                if (shouldConfirmAgentDelete) {
-                  setDeleteConfirmOpen(true);
-                  return;
-                }
-                onDelete();
-              }}
-            >
-              <Trash2 className="h-4 w-4" />
-              Delete agent
-            </DropdownMenuItem>
-          ) : null}
         </DropdownMenuContent>
       </DropdownMenu>
       {hasArchiveAction && archiveActions ? (
@@ -198,32 +163,17 @@ export function UserProfileAgentSettingsMenu({
           open={archiveConfirmOpen}
         />
       ) : null}
-      {shouldConfirmAgentDelete ? (
-        <AgentDeleteConfirmDialog
-          agent={managedAgent}
-          isPending={isPending}
-          onConfirm={() => {
-            setDeleteConfirmOpen(false);
-            onDelete();
-          }}
-          onOpenChange={setDeleteConfirmOpen}
-          open={deleteConfirmOpen}
-        />
-      ) : null}
     </>
   );
 }
 
 export function UserProfileAgentSettingsMenuSlot({
   archiveActions,
-  canDeletePersona,
   canInstantiateAgent,
   canManagePersona,
   isAgentActionPending,
   isBot,
   managedAgent,
-  onDeleteAgent,
-  onDeletePersona,
   onDuplicatePersona,
   onExportPersona,
   onToggleAutoStart,
@@ -231,14 +181,11 @@ export function UserProfileAgentSettingsMenuSlot({
   viewerIsOwner,
 }: {
   archiveActions: IdentityArchiveActions;
-  canDeletePersona: boolean;
   canInstantiateAgent: boolean;
   canManagePersona: boolean;
   isAgentActionPending: boolean;
   isBot: boolean;
   managedAgent?: ManagedAgent;
-  onDeleteAgent: () => void;
-  onDeletePersona: () => void;
   onDuplicatePersona: () => void;
   onExportPersona: () => void;
   onToggleAutoStart: () => void;
@@ -250,11 +197,12 @@ export function UserProfileAgentSettingsMenuSlot({
   const settingsActionPending =
     isAgentActionPending || archiveActions.isPending;
   const sharedProps = {
-    archiveActions: canShowArchiveAction ? archiveActions : undefined,
+    archiveActions: !isBot && canShowArchiveAction ? archiveActions : undefined,
     isBot,
     isPending: settingsActionPending,
-    onDuplicatePersona: canManagePersona ? onDuplicatePersona : undefined,
-    onExportPersona: canManagePersona ? onExportPersona : undefined,
+    onDuplicatePersona:
+      !isBot && canManagePersona ? onDuplicatePersona : undefined,
+    onExportPersona: !isBot && canManagePersona ? onExportPersona : undefined,
     personaActionKey,
   };
 
@@ -263,22 +211,16 @@ export function UserProfileAgentSettingsMenuSlot({
       <UserProfileAgentSettingsMenu
         {...sharedProps}
         managedAgent={managedAgent}
-        onDelete={onDeleteAgent}
         onToggleAutoStart={onToggleAutoStart}
       />
     );
   }
 
   if (canInstantiateAgent) {
-    return (
-      <UserProfileAgentSettingsMenu
-        {...sharedProps}
-        onDelete={canDeletePersona ? onDeletePersona : undefined}
-      />
-    );
+    return <UserProfileAgentSettingsMenu {...sharedProps} />;
   }
 
-  if (canShowArchiveAction) {
+  if (canShowArchiveAction && !isBot) {
     return (
       <UserProfileAgentSettingsMenu
         archiveActions={archiveActions}
@@ -290,64 +232,3 @@ export function UserProfileAgentSettingsMenuSlot({
 
   return null;
 }
-
-function AgentDeleteConfirmDialog({
-  agent,
-  isPending,
-  onConfirm,
-  onOpenChange,
-  open,
-}: {
-  agent: ManagedAgent;
-  isPending: boolean;
-  onConfirm: () => void;
-  onOpenChange: (open: boolean) => void;
-  open: boolean;
-}) {
-  const isProviderAgent = agent.backend.type === "provider";
-
-  return (
-    <AlertDialog onOpenChange={onOpenChange} open={open}>
-      <AlertDialogContent data-testid="agent-delete-confirm-dialog">
-        <AlertDialogHeader>
-          <AlertDialogTitle>Delete this agent?</AlertDialogTitle>
-          <AlertDialogDescription>
-            Deleting this agent stops and removes the agent from this community.
-          </AlertDialogDescription>
-        </AlertDialogHeader>
-        <ul className="list-disc space-y-1.5 pl-5 text-sm text-muted-foreground">
-          <li>Removes the local management record and saved agent key</li>
-          <li>Removes the agent from every channel it belongs to</li>
-          <li>
-            Archives the agent&apos;s identity on the relay so it no longer
-            appears in member lists or mention suggestions
-          </li>
-          <li>
-            {isProviderAgent
-              ? "Requests remote deletion; if it is online, Buzz first sends a shutdown command when possible. If the deployment cannot be reached through a channel, the remote process may keep running without local management."
-              : "Stops any local agent process before deleting the record"}
-          </li>
-        </ul>
-        <p className="text-sm text-muted-foreground">
-          You can also archive this agent from the profile settings menu if you
-          want to hide the agent instead of removing it.
-        </p>
-        <AlertDialogFooter>
-          <AlertDialogCancel asChild>
-            <Button type="button" variant="outline">
-              Cancel
-            </Button>
-          </AlertDialogCancel>
-          <AlertDialogAction
-            className={buttonVariants({ variant: "destructive" })}
-            data-testid="agent-delete-confirm-action"
-            disabled={isPending}
-            onClick={onConfirm}
-          >
-            {isPending ? "Deleting..." : "Delete agent"}
-          </AlertDialogAction>
-        </AlertDialogFooter>
-      </AlertDialogContent>
-    </AlertDialog>
-  );
-}
diff --git a/desktop/src/features/profile/ui/UserProfileAgentManagementRows.tsx b/desktop/src/features/profile/ui/UserProfileAgentManagementRows.tsx
new file mode 100644
index 00000000000..8c6b4138cd7
--- /dev/null
+++ b/desktop/src/features/profile/ui/UserProfileAgentManagementRows.tsx
@@ -0,0 +1,283 @@
+import * as React from "react";
+import {
+  Archive,
+  ArchiveRestore,
+  CopyPlus,
+  Download,
+  Trash2,
+  type LucideIcon,
+} from "lucide-react";
+
+import type { IdentityArchiveActions } from "@/features/identity-archive/hooks";
+import { ArchiveConfirmDialog } from "@/features/profile/ui/ArchiveConfirmDialog";
+import type { ManagedAgent } from "@/shared/api/types";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/shared/ui/alert-dialog";
+import { Button, buttonVariants } from "@/shared/ui/button";
+import { PanelSectionGroup } from "@/shared/ui/PanelSectionGroup";
+
+export function UserProfileAgentManagementRows({
+  archiveActions,
+  canArchiveAgent,
+  canDeleteAgent,
+  isDeletePending,
+  managedAgent,
+  onDeleteAgent,
+  onDuplicateAgent,
+  onExportAgent,
+}: {
+  archiveActions: IdentityArchiveActions;
+  canArchiveAgent: boolean;
+  canDeleteAgent: boolean;
+  isDeletePending: boolean;
+  managedAgent?: ManagedAgent;
+  onDeleteAgent: () => void;
+  onDuplicateAgent?: () => void;
+  onExportAgent?: () => void;
+}) {
+  if (
+    !onDuplicateAgent &&
+    !onExportAgent &&
+    !canArchiveAgent &&
+    !canDeleteAgent
+  ) {
+    return null;
+  }
+
+  return (
+    <PanelSectionGroup testId="user-profile-agent-management-section">
+      {onDuplicateAgent ? (
+        <ProfileAgentActionRow
+          disabled={isDeletePending}
+          icon={CopyPlus}
+          label="Duplicate agent"
+          onClick={onDuplicateAgent}
+          testId="user-profile-duplicate-agent-row"
+        />
+      ) : null}
+      {onExportAgent ? (
+        <ProfileAgentActionRow
+          disabled={isDeletePending}
+          icon={Download}
+          label="Export agent"
+          onClick={onExportAgent}
+          testId="user-profile-export-agent-row"
+        />
+      ) : null}
+      {canArchiveAgent ? (
+        <ProfileArchiveAgentRow archiveActions={archiveActions} />
+      ) : null}
+      {canDeleteAgent ? (
+        <ProfileDeleteAgentRow
+          isPending={isDeletePending}
+          managedAgent={managedAgent}
+          onDelete={onDeleteAgent}
+        />
+      ) : null}
+    </PanelSectionGroup>
+  );
+}
+
+function ProfileAgentActionRow({
+  destructive = false,
+  disabled = false,
+  icon: Icon,
+  label,
+  onClick,
+  testId,
+}: {
+  destructive?: boolean;
+  disabled?: boolean;
+  icon: LucideIcon;
+  label: string;
+  onClick: () => void;
+  testId: string;
+}) {
+  return (
+    <button
+      className="flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 disabled:cursor-not-allowed disabled:opacity-50 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
+      data-testid={testId}
+      disabled={disabled}
+      onClick={onClick}
+      type="button"
+    >
+      <Icon
+        className={
+          destructive
+            ? "h-4 w-4 shrink-0 text-destructive"
+            : "h-4 w-4 shrink-0 text-muted-foreground"
+        }
+        data-slot="profile-action-icon"
+      />
+      <span
+        className={
+          destructive
+            ? "min-w-0 flex-1 text-sm font-medium text-destructive"
+            : "min-w-0 flex-1 text-sm font-medium"
+        }
+      >
+        {label}
+      </span>
+    </button>
+  );
+}
+
+function ProfileArchiveAgentRow({
+  archiveActions,
+}: {
+  archiveActions: IdentityArchiveActions;
+}) {
+  const [confirmOpen, setConfirmOpen] = React.useState(false);
+  const isArchived = archiveActions.isArchived === true;
+  const Icon = isArchived ? ArchiveRestore : Archive;
+  const label = archiveActions.isPending
+    ? isArchived
+      ? "Unarchiving…"
+      : "Archiving…"
+    : isArchived
+      ? "Unarchive agent"
+      : "Archive agent";
+
+  return (
+    <>
+      <ProfileAgentActionRow
+        disabled={archiveActions.isPending}
+        icon={Icon}
+        label={label}
+        onClick={() => {
+          if (isArchived) {
+            archiveActions.unarchive();
+            return;
+          }
+          setConfirmOpen(true);
+        }}
+        testId={
+          isArchived
+            ? "user-profile-unarchive-agent-row"
+            : "user-profile-archive-agent-row"
+        }
+      />
+      <ArchiveConfirmDialog
+        isBot
+        isPending={archiveActions.isPending}
+        onConfirm={() => {
+          archiveActions.archive();
+          setConfirmOpen(false);
+        }}
+        onOpenChange={setConfirmOpen}
+        open={confirmOpen}
+      />
+    </>
+  );
+}
+
+function ProfileDeleteAgentRow({
+  isPending,
+  managedAgent,
+  onDelete,
+}: {
+  isPending: boolean;
+  managedAgent?: ManagedAgent;
+  onDelete: () => void;
+}) {
+  const [confirmOpen, setConfirmOpen] = React.useState(false);
+
+  return (
+    <>
+      <ProfileAgentActionRow
+        destructive
+        disabled={isPending}
+        icon={Trash2}
+        label="Delete agent"
+        onClick={() => {
+          if (managedAgent) {
+            setConfirmOpen(true);
+            return;
+          }
+          onDelete();
+        }}
+        testId="user-profile-delete-agent-row"
+      />
+      {managedAgent ? (
+        <AgentDeleteConfirmDialog
+          agent={managedAgent}
+          isPending={isPending}
+          onConfirm={() => {
+            setConfirmOpen(false);
+            onDelete();
+          }}
+          onOpenChange={setConfirmOpen}
+          open={confirmOpen}
+        />
+      ) : null}
+    </>
+  );
+}
+
+function AgentDeleteConfirmDialog({
+  agent,
+  isPending,
+  onConfirm,
+  onOpenChange,
+  open,
+}: {
+  agent: ManagedAgent;
+  isPending: boolean;
+  onConfirm: () => void;
+  onOpenChange: (open: boolean) => void;
+  open: boolean;
+}) {
+  const isProviderAgent = agent.backend.type === "provider";
+
+  return (
+    <AlertDialog onOpenChange={onOpenChange} open={open}>
+      <AlertDialogContent data-testid="agent-delete-confirm-dialog">
+        <AlertDialogHeader>
+          <AlertDialogTitle>Delete this agent?</AlertDialogTitle>
+          <AlertDialogDescription>
+            Deleting this agent stops and removes the agent from this community.
+          </AlertDialogDescription>
+        </AlertDialogHeader>
+        <ul className="list-disc space-y-1.5 pl-5 text-sm text-muted-foreground">
+          <li>Removes the local management record and saved agent key</li>
+          <li>Removes the agent from every channel it belongs to</li>
+          <li>
+            Archives the agent&apos;s identity on the relay so it no longer
+            appears in member lists or mention suggestions
+          </li>
+          <li>
+            {isProviderAgent
+              ? "Requests remote deletion; if it is online, Buzz first sends a shutdown command when possible. If the deployment cannot be reached through a channel, the remote process may keep running without local management."
+              : "Stops any local agent process before deleting the record"}
+          </li>
+        </ul>
+        <p className="text-sm text-muted-foreground">
+          Archive this agent if you want to hide it instead of removing it.
+        </p>
+        <AlertDialogFooter>
+          <AlertDialogCancel asChild>
+            <Button type="button" variant="outline">
+              Cancel
+            </Button>
+          </AlertDialogCancel>
+          <AlertDialogAction
+            className={buttonVariants({ variant: "destructive" })}
+            data-testid="agent-delete-confirm-action"
+            disabled={isPending}
+            onClick={onConfirm}
+          >
+            {isPending ? "Deleting…" : "Delete agent"}
+          </AlertDialogAction>
+        </AlertDialogFooter>
+      </AlertDialogContent>
+    </AlertDialog>
+  );
+}
diff --git a/desktop/src/features/profile/ui/UserProfileEditAgentDialog.tsx b/desktop/src/features/profile/ui/UserProfileEditAgentDialog.tsx
new file mode 100644
index 00000000000..b1f4f54eedf
--- /dev/null
+++ b/desktop/src/features/profile/ui/UserProfileEditAgentDialog.tsx
@@ -0,0 +1,34 @@
+import { AgentDialog } from "@/features/agents/ui/AgentDialog";
+import type { EditAgentFocusTarget } from "@/features/agents/openEditAgentEvent";
+import type { ManagedAgent } from "@/shared/api/types";
+
+export function UserProfileEditAgentDialog({
+  agent,
+  canEdit,
+  initialFocus,
+  onEditLinkedPersona,
+  onOpenChange,
+  open,
+}: {
+  agent: ManagedAgent | undefined;
+  canEdit: boolean;
+  initialFocus: EditAgentFocusTarget | undefined;
+  onEditLinkedPersona: (() => void) | undefined;
+  onOpenChange: (open: boolean) => void;
+  open: boolean;
+}) {
+  if (!canEdit || !agent) {
+    return null;
+  }
+
+  return (
+    <AgentDialog
+      agent={agent}
+      initialFocus={initialFocus}
+      mode="instance-edit"
+      onEditLinkedPersona={onEditLinkedPersona}
+      onOpenChange={onOpenChange}
+      open={open}
+    />
+  );
+}
diff --git a/desktop/src/features/profile/ui/UserProfilePanel.tsx b/desktop/src/features/profile/ui/UserProfilePanel.tsx
index cb188dd0089..91040a28e24 100644
--- a/desktop/src/features/profile/ui/UserProfilePanel.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanel.tsx
@@ -2,10 +2,7 @@ import * as React from "react";
 import { toast } from "sonner";
 
 import { useAppNavigation } from "@/app/navigation/useAppNavigation";
-import {
-  useAgentMemoryQuery,
-  useIsManagedAgent,
-} from "@/features/agent-memory/hooks";
+import { useIsManagedAgent } from "@/features/agent-memory/hooks";
 import {
   type AttachManagedAgentToChannelResult,
   useAcpRuntimesQuery,
@@ -33,13 +30,7 @@ import {
   resolveStartRuntimeForDefinition,
 } from "@/features/agents/lib/instanceInputForDefinition";
 import { describeLogFile } from "@/features/agents/ui/agentUi";
-import { AgentDialog } from "@/features/agents/ui/AgentDialog";
 import { useAgentLifecycleActions } from "@/features/profile/ui/useAgentLifecycleActions";
-import {
-  consumePendingOpenEditAgent,
-  type EditAgentFocusTarget,
-  subscribeOpenEditAgent,
-} from "@/features/agents/openEditAgentEvent";
 import {
   duplicatePersonaDialogState,
   editPersonaDialogState,
@@ -59,13 +50,15 @@ import {
 import { ownsAuthorAgent } from "@/features/profile/lib/identity";
 import { resolveProfileActivityAgent } from "@/features/profile/lib/profileActivityAgent";
 import {
-  AgentInfoFocusedView,
   AgentInstructionsFocusedView,
+  ProfileSummaryView,
+} from "@/features/profile/ui/UserProfilePanelSections";
+import {
+  AgentInfoFocusedView,
   ChannelsFocusedView,
   DiagnosticsFocusedView,
   MemoryFocusedView,
-  ProfileSummaryView,
-} from "@/features/profile/ui/UserProfilePanelSections";
+} from "@/features/profile/ui/UserProfilePanelFocusedViews";
 import { AgentConfigurationFocusedView } from "@/features/profile/ui/UserProfilePanelAgentDetails";
 import { UserProfileAgentSettingsMenuSlot } from "@/features/profile/ui/UserProfileAgentActions";
 import { useProfileAgentDeletion } from "@/features/profile/ui/UserProfilePanelDeletion";
@@ -86,7 +79,7 @@ import {
   type UserProfilePanelProps,
   useRetainedPersona,
 } from "@/features/profile/ui/UserProfilePanelUtils";
-import { useProfileDmAction } from "@/features/profile/ui/useProfileDmAction";
+import { useProfileInteractionActions } from "@/features/profile/ui/useProfileInteractionActions";
 import { useUserStatusQuery } from "@/features/user-status/hooks";
 import { useOpenAgentActivity } from "@/features/agents/useOpenAgentActivity";
 import { useEscapeKey } from "@/shared/hooks/useEscapeKey";
@@ -101,6 +94,8 @@ import type {
 } from "@/shared/api/types";
 import { UserProfilePanelFrame } from "@/features/profile/ui/UserProfilePanelFrame";
 import { getUserProfilePanelHeaderContent } from "@/features/profile/ui/UserProfilePanelHeaderContent";
+import { UserProfileEditAgentDialog } from "@/features/profile/ui/UserProfileEditAgentDialog";
+import { useProfileEditAgentRequest } from "@/features/profile/ui/useProfileEditAgentRequest";
 export type { ProfilePanelTab, ProfilePanelView };
 
 export function UserProfilePanel({
@@ -154,28 +149,27 @@ export function UserProfilePanel({
     },
     [onTabChange],
   );
-  const [editAgentOpen, setEditAgentOpen] = React.useState(false);
-  const [editAgentFocus, setEditAgentFocus] = React.useState<
-    EditAgentFocusTarget | undefined
-  >(undefined);
-
-  // Open the Edit Agent dialog when `requestOpenEditAgent(pubkey)` fires from
-  // a card or other non-panel surface (e.g. `ConfigNudgeCard`). Mirrors the
-  // `subscribeOpenCreateAgent` pattern in AgentsView.
-  React.useEffect(() => {
-    if (!pubkey) return;
-    // Consume any pending request that arrived before this panel mounted.
-    const pending = consumePendingOpenEditAgent(pubkey);
-    if (pending !== false) {
-      setEditAgentFocus(pending === true ? undefined : pending);
-      setEditAgentOpen(true);
-    }
-    // Subscribe for events that arrive while the panel is mounted.
-    return subscribeOpenEditAgent(pubkey, (focus) => {
-      setEditAgentFocus(focus);
-      setEditAgentOpen(true);
-    });
-  }, [pubkey]);
+  const [stickyChrome, setStickyChrome] = React.useState({
+    active: false,
+    height: 0,
+  });
+  const handleStickyChromeChange = React.useCallback(
+    (nextState: { active: boolean; height: number }) => {
+      setStickyChrome((currentState) =>
+        currentState.active === nextState.active &&
+        currentState.height === nextState.height
+          ? currentState
+          : nextState,
+      );
+    },
+    [],
+  );
+  const {
+    focus: editAgentFocus,
+    open: editAgentOpen,
+    setFocus: setEditAgentFocus,
+    setOpen: setEditAgentOpen,
+  } = useProfileEditAgentRequest(pubkey);
   const [addToChannelOpen, setAddToChannelOpen] = React.useState(false);
   const [personaDialogState, setPersonaDialogState] =
     React.useState<PersonaDialogState | null>(null);
@@ -325,15 +319,8 @@ export function UserProfilePanel({
       }),
     [effectivePubkey, isBot, managedAgent, profile, relayAgent, viewerIsOwner],
   );
-  // Observer ingestion (frame decryption + derived active-turn liveness) is
-  // owner-global — mounted once in AppShell via useAgentObserverIngestion —
-  // covering both locally managed agents and declared-owned relay agents.
-  const canEditAgent =
-    isOwner === true &&
-    (managedAgent !== undefined || resolvedPersona !== undefined);
-  const memoryQuery = useAgentMemoryQuery(effectivePubkey, {
-    enabled: viewerIsOwner && Boolean(effectivePubkey),
-  });
+  // Observer ingestion is owner-global across local and declared-owned agents.
+  const canEditAgent = Boolean(isOwner && (managedAgent ?? resolvedPersona));
   const isSelf =
     currentPubkey !== undefined &&
     pubkeyLower.length > 0 &&
@@ -395,10 +382,22 @@ export function UserProfilePanel({
     setView("summary", { replace: true });
     setTab("info", { replace: true });
   }, [setTab, setView, targetKey]);
-  const { handleMessage, isOpeningDm } = useProfileDmAction({
+  const {
+    canHuddle,
+    canMessage,
+    canWave,
+    handleHuddle,
+    handleMessage,
+    handleWave,
+    isStartingHuddle,
+    pendingAction,
+  } = useProfileInteractionActions({
     effectivePubkey,
+    enabled: onOpenDm !== undefined,
+    isBot,
+    isSelf,
     onClose,
-    onOpenDm,
+    viewerIsOwner,
   });
 
   const handleEditAgent = React.useCallback(() => {
@@ -407,7 +406,7 @@ export function UserProfilePanel({
       return;
     }
     setEditAgentOpen(true);
-  }, [resolvedPersona]);
+  }, [resolvedPersona, setEditAgentOpen]);
 
   const { deleteManagedAgentRecord, deleteManagedAgentsForPersona } =
     useProfileAgentDeletion({
@@ -707,31 +706,27 @@ export function UserProfilePanel({
     : null;
   const ownerProfilePubkey =
     ownerPubkey ?? (isOwner === true ? (currentPubkey ?? null) : null);
-  const ownerAvatarProfile = ownerPubkey
-    ? ownerProfileQuery.data
-    : currentProfileQuery.data;
-  const memoryCount =
-    memoryQuery.data &&
-    (memoryQuery.data.core ? 1 : 0) + memoryQuery.data.memories.length;
   const agentInstruction = resolveAgentInstruction(
     managedAgent,
     resolvedPersona,
   );
   const canManagePersona = isOwner === true && resolvedPersona !== undefined;
-  const canEditPersona = canManagePersona;
   const canDeletePersona = canManagePersona && !resolvedPersona?.sourceTeam;
+  const canDeleteProfileAgent =
+    isBot &&
+    ((viewerIsOwner && managedAgent !== undefined) ||
+      (canInstantiateAgent && canDeletePersona));
+  const handleDeleteProfileAgent =
+    viewerIsOwner && managedAgent ? handleDeleteAgent : handleDeletePersona;
   const archiveActions = useIdentityArchive(effectivePubkey);
-  const agentSettingsMenu = (
+  const agentSettingsMenu = isBot ? null : (
     <UserProfileAgentSettingsMenuSlot
       archiveActions={archiveActions}
-      canDeletePersona={canDeletePersona}
       canInstantiateAgent={canInstantiateAgent}
       canManagePersona={canManagePersona}
       isAgentActionPending={isAgentActionPending}
       isBot={isBot}
       managedAgent={managedAgent}
-      onDeleteAgent={handleDeleteAgent}
-      onDeletePersona={handleDeletePersona}
       onDuplicatePersona={handleDuplicatePersona}
       onExportPersona={handleExportPersona}
       onToggleAutoStart={handleToggleAgentAutoStart}
@@ -745,7 +740,6 @@ export function UserProfilePanel({
       isOwner: viewerIsOwner,
       managedAgent,
       onOpenProfile,
-      ownerAvatarUrl: ownerAvatarProfile?.avatarUrl ?? null,
       ownerDisplayName,
       ownerHandle,
       ownerProfilePubkey,
@@ -770,6 +764,7 @@ export function UserProfilePanel({
       logCopyValue: isDiagnosticsLikeView ? managedAgentLogContent : null,
       logSubtitle: logHeaderSubtitle,
       onBack: () => setView("summary"),
+      onEditAgent: canEditAgent ? handleEditAgent : undefined,
       view,
       viewerIsOwner,
     },
@@ -783,10 +778,12 @@ export function UserProfilePanel({
           ? "flex flex-col overflow-hidden"
           : "overflow-y-auto",
       )}
+      data-testid="user-profile-scroll-body"
     >
       {view === "summary" ? (
         <ProfileSummaryView
           canAddToChannel={managedAgent !== undefined && isOwner === true}
+          canDeleteAgent={canDeleteProfileAgent}
           canEditAgent={canEditAgent}
           canInstantiateAgent={canInstantiateAgent}
           canOpenAgentLogs={canOpenAgentLogs}
@@ -802,11 +799,16 @@ export function UserProfilePanel({
           handleAgentPrimaryAction={handleAgentPrimaryAction}
           handleAgentRestart={handleAgentRestart}
           handleEditAgent={handleEditAgent}
-          handleEditPersona={canEditPersona ? handleEditPersona : undefined}
+          handleToggleAgentAutoStart={handleToggleAgentAutoStart}
+          handleEditPersona={canManagePersona ? handleEditPersona : undefined}
+          handleHuddle={canHuddle ? handleHuddle : undefined}
           handleInstantiateAgent={handleInstantiateAgent}
-          handleMessage={handleMessage}
+          handleMessage={canMessage ? handleMessage : undefined}
+          handleWave={canWave ? handleWave : undefined}
           isArchived={archiveActions.isArchived === true}
-          isMessagePending={isOpeningDm}
+          isHuddlePending={pendingAction === "huddle" || isStartingHuddle}
+          isMessagePending={pendingAction === "message"}
+          isWavePending={pendingAction === "wave"}
           isBot={isBot}
           isAgentActionPending={isAgentActionPending}
           isFollowing={isFollowing}
@@ -815,32 +817,24 @@ export function UserProfilePanel({
           instances={personaInstances}
           activityAgent={activityAgent}
           managedAgent={managedAgent}
-          memoriesLoading={memoryQuery.isLoading}
-          memoryCount={memoryCount}
           agentInfoFields={agentInfoFields}
+          archiveActions={archiveActions}
           agentSettingsFields={agentSettingsFields}
           diagnosticsFields={diagnosticsFields}
           onAddToChannel={() => setAddToChannelOpen(true)}
+          onDeleteAgent={handleDeleteProfileAgent}
+          onDuplicateAgent={
+            isBot && canManagePersona ? handleDuplicatePersona : undefined
+          }
+          onExportAgent={
+            isBot && canManagePersona ? handleExportPersona : undefined
+          }
           onOpenInstance={(instancePubkey) => onOpenProfile?.(instancePubkey)}
           onOpenActivity={handleOpenActivity}
           onOpenChannel={handleOpenChannel}
           onOpenDiagnostics={() => setView("diagnostics")}
-          onOpenInstructions={() => setView("instructions")}
+          onStickyChromeChange={handleStickyChromeChange}
           onTabChange={setTab}
-          onOpenDm={onOpenDm}
-          onCreateCard={
-            canManagePersona && resolvedPersona
-              ? () =>
-                  setCardMintTarget({
-                    // Prefer the live instance pubkey; fall back to the
-                    // persona/definition id (same resolution as export).
-                    id: managedAgent?.pubkey ?? resolvedPersona.id,
-                    name: resolvedPersona.displayName,
-                    // Locking needs an instance keypair to encrypt to.
-                    canLock: Boolean(managedAgent?.pubkey),
-                  })
-              : undefined
-          }
           presenceStatus={presenceStatus}
           profile={profile}
           pubkey={effectivePubkey}
@@ -905,28 +899,27 @@ export function UserProfilePanel({
       ) : null}
     </AuxiliaryPanelBody>
   );
-  const editAgentDialog =
-    canEditAgent && managedAgent ? (
-      <AgentDialog
-        agent={managedAgent}
-        mode="instance-edit"
-        initialFocus={editAgentFocus}
-        onEditLinkedPersona={
-          resolvedPersona && !resolvedPersona.isBuiltIn
-            ? () => {
-                setEditAgentOpen(false);
-                setEditAgentFocus(undefined);
-                setPersonaDialogState(editPersonaDialogState(resolvedPersona));
-              }
-            : undefined
-        }
-        onOpenChange={(next) => {
-          setEditAgentOpen(next);
-          if (!next) setEditAgentFocus(undefined);
-        }}
-        open={editAgentOpen}
-      />
-    ) : null;
+  const editAgentDialog = (
+    <UserProfileEditAgentDialog
+      agent={managedAgent}
+      canEdit={canEditAgent}
+      initialFocus={editAgentFocus}
+      onEditLinkedPersona={
+        resolvedPersona && !resolvedPersona.isBuiltIn
+          ? () => {
+              setEditAgentOpen(false);
+              setEditAgentFocus(undefined);
+              setPersonaDialogState(editPersonaDialogState(resolvedPersona));
+            }
+          : undefined
+      }
+      onOpenChange={(next) => {
+        setEditAgentOpen(next);
+        if (!next) setEditAgentFocus(undefined);
+      }}
+      open={editAgentOpen}
+    />
+  );
   const addAgentToChannelDialog = managedAgent ? (
     <AddAgentToChannelDialog
       agent={managedAgent ?? null}
@@ -992,6 +985,9 @@ export function UserProfilePanel({
       personaDialogs={personaDialogs}
       profileBody={profileBody}
       splitPaneClamp={splitPaneClamp}
+      stickyChromeActive={view === "summary" && stickyChrome.active}
+      stickyChromeEnabled={view === "summary" && isBot}
+      stickyChromeHeight={stickyChrome.height}
       widthPx={widthPx}
       transparentChrome={transparentChrome}
     />
diff --git a/desktop/src/features/profile/ui/UserProfilePanelAgentDetails.tsx b/desktop/src/features/profile/ui/UserProfilePanelAgentDetails.tsx
index 844de528e23..1da2e597dd8 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelAgentDetails.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanelAgentDetails.tsx
@@ -116,11 +116,11 @@ export function AgentInstructionRow({
     trimmedInstruction.length > 0 && onOpenInstructions !== undefined;
   const rowContent = (
     <>
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <MessageSquare className="h-4 w-4 text-muted-foreground" />
-      </span>
+      <MessageSquare className="h-4 w-4 shrink-0 text-muted-foreground" />
       <div className="min-w-0 flex-1 text-left">
-        <div className="text-xs font-medium text-foreground">Instructions</div>
+        <div className="text-xs font-medium text-foreground">
+          Agent instructions
+        </div>
         {trimmedInstruction ? (
           canOpenInstructions ? (
             <span
diff --git a/desktop/src/features/profile/ui/UserProfilePanelFields.tsx b/desktop/src/features/profile/ui/UserProfilePanelFields.tsx
index cf88919ce62..06b3d16a965 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelFields.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanelFields.tsx
@@ -2,10 +2,8 @@ import type { LucideIcon } from "lucide-react";
 import {
   Activity,
   ArrowUpRight,
-  Copy,
   Cpu,
   Ear,
-  Fingerprint,
   Server,
   Terminal,
   UserRound,
@@ -13,9 +11,12 @@ import {
 import * as React from "react";
 import { AgentStatusBadge } from "@/features/agents/ui/AgentStatusBadge";
 import { truncatePubkey } from "@/shared/lib/pubkey";
-import { copyTextToClipboard } from "@/shared/lib/clipboard";
+import {
+  HoverCopyIndicator,
+  useCopyFeedback,
+} from "@/shared/ui/HoverCopyIndicator";
 import { PubKey } from "@/shared/ui/PubKey";
-import { UserAvatar } from "@/shared/ui/UserAvatar";
+import { PanelSectionGroup } from "@/shared/ui/PanelSectionGroup";
 import type {
   AgentPersona,
   ManagedAgent,
@@ -38,7 +39,7 @@ export type ProfileField = {
   copyValue?: string;
   displayValue: string;
   displayNode?: React.ReactNode;
-  icon: LucideIcon;
+  icon?: LucideIcon;
   label: string;
   onClick?: () => void;
   testId?: string;
@@ -82,7 +83,6 @@ export function useProfileFieldBuckets({
   isOwner,
   managedAgent,
   onOpenProfile,
-  ownerAvatarUrl,
   ownerDisplayName,
   ownerHandle,
   ownerProfilePubkey,
@@ -98,7 +98,6 @@ export function useProfileFieldBuckets({
   isOwner: boolean | undefined;
   managedAgent: ManagedAgent | undefined;
   onOpenProfile?: (pubkey: string) => void;
-  ownerAvatarUrl: string | null;
   ownerDisplayName: string | null;
   ownerHandle: string | null;
   ownerProfilePubkey: string | null;
@@ -118,7 +117,6 @@ export function useProfileFieldBuckets({
             includeOperationalFields: isOwner === true,
             managedAgent,
             onOpenProfile,
-            ownerAvatarUrl,
             ownerDisplayName,
             ownerHandle,
             ownerProfilePubkey,
@@ -136,7 +134,6 @@ export function useProfileFieldBuckets({
     isOwner,
     managedAgent,
     onOpenProfile,
-    ownerAvatarUrl,
     ownerDisplayName,
     ownerHandle,
     ownerProfilePubkey,
@@ -167,10 +164,17 @@ export function buildPublicFields({
 
   if (pubkey) {
     fields.push({
+      copyValue: pubkey,
       displayValue: truncatePubkey(pubkey),
-      displayNode: <PubKey pubkey={pubkey} testId="user-profile-copy-pubkey" />,
-      icon: Fingerprint,
+      displayNode: (
+        <PubKey
+          interactive={false}
+          pubkey={pubkey}
+          testId="user-profile-copy-pubkey"
+        />
+      ),
       label: "Public key",
+      testId: "user-profile-public-key",
     });
   }
 
@@ -220,7 +224,6 @@ export function buildOwnerFields({
   includeOperationalFields,
   managedAgent,
   onOpenProfile,
-  ownerAvatarUrl,
   ownerDisplayName,
   ownerHandle,
   ownerProfilePubkey,
@@ -233,7 +236,6 @@ export function buildOwnerFields({
   includeOperationalFields: boolean;
   managedAgent: ManagedAgent | undefined;
   onOpenProfile?: (pubkey: string) => void;
-  ownerAvatarUrl: string | null;
   ownerDisplayName: string | null;
   ownerHandle: string | null;
   ownerProfilePubkey: string | null;
@@ -256,18 +258,6 @@ export function buildOwnerFields({
     : null;
 
   const ownerClickable = Boolean(onOpenProfile && ownerProfilePubkey);
-  const ownerContent = (
-    <>
-      <UserAvatar
-        avatarUrl={ownerAvatarUrl}
-        className="shrink-0"
-        displayName={ownerHandle ?? ownerDisplayName ?? ""}
-        size="xs"
-        testId="user-profile-owner-avatar"
-      />
-      <span className="truncate">{ownerDisplayName}</span>
-    </>
-  );
 
   if (ownerDisplayName) {
     fields.push({
@@ -275,12 +265,7 @@ export function buildOwnerFields({
         ? undefined
         : (ownerProfilePubkey ?? ownerPubkey ?? ownerHandle ?? undefined),
       displayValue: ownerDisplayName,
-      displayNode: (
-        <span className="inline-flex max-w-full items-center gap-2">
-          {ownerContent}
-        </span>
-      ),
-      icon: UserRound,
+      displayNode: <span className="truncate">{ownerDisplayName}</span>,
       label: "Managed by",
       onClick:
         ownerClickable && ownerProfilePubkey
@@ -335,8 +320,10 @@ export function buildOwnerFields({
         .replace(/\b\w/g, (char: string) => char.toUpperCase()),
       displayNode: (
         <AgentStatusBadge
+          className="normal-case tracking-normal"
           presenceLoaded={presenceLoaded}
           presenceStatus={presenceStatus}
+          sentenceCase
           status={managedAgent.status}
         />
       ),
@@ -439,52 +426,114 @@ function orderProfileFields(fields: ProfileField[]) {
   ];
 }
 
-export function ProfileFieldRows({ fields }: { fields: ProfileField[] }) {
+export function ProfileFieldRows({
+  fields,
+  variant = "default",
+}: {
+  fields: ProfileField[];
+  variant?: "default" | "runtime";
+}) {
   return (
     <>
       {orderProfileFields(fields).map((field) => (
-        <ProfileFieldRow field={field} key={field.testId ?? field.label} />
+        <ProfileFieldRow
+          field={field}
+          key={field.testId ?? field.label}
+          variant={variant}
+        />
       ))}
     </>
   );
 }
 
-export function ProfileFieldGroup({ fields }: { fields: ProfileField[] }) {
+export function ProfileSectionGroup({
+  children,
+  headerAction,
+  testId,
+  title,
+}: {
+  children: React.ReactNode;
+  headerAction?: React.ReactNode;
+  testId?: string;
+  title?: string;
+}) {
+  return (
+    <PanelSectionGroup
+      headerAction={headerAction}
+      testId={testId}
+      title={title}
+    >
+      <div className="divide-y divide-border/55">{children}</div>
+    </PanelSectionGroup>
+  );
+}
+
+export function ProfileFieldGroup({
+  fields,
+  title,
+}: {
+  fields: ProfileField[];
+  title?: string;
+}) {
   return (
-    <section>
-      <div className="overflow-hidden rounded-2xl bg-muted/20">
-        <ProfileFieldRows fields={fields} />
-      </div>
-    </section>
+    <ProfileSectionGroup title={title}>
+      <ProfileFieldRows fields={fields} />
+    </ProfileSectionGroup>
   );
 }
 
-function ProfileFieldRow({ field }: { field: ProfileField }) {
+function ProfileFieldRow({
+  field,
+  variant,
+}: {
+  field: ProfileField;
+  variant: "default" | "runtime";
+}) {
   const Icon = field.icon;
   const isCopyable = Boolean(field.copyValue);
   const isActionable = Boolean(field.onClick);
+  const isTrailingDisplay =
+    variant === "runtime" && field.label === "Status" && field.displayNode;
+  const { copied, copy } = useCopyFeedback({
+    label: field.label,
+    value: field.copyValue ?? "",
+  });
 
   const content = (
     <>
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <Icon className="h-4 w-4 text-muted-foreground" />
-      </span>
+      {variant === "default" && Icon ? (
+        <Icon
+          className="h-4 w-4 shrink-0 text-muted-foreground"
+          data-slot="profile-field-icon"
+        />
+      ) : null}
       <span className="min-w-0 flex-1 text-left">
-        <span className="block text-xs font-medium text-foreground">
+        <span className="block text-sm font-medium text-foreground">
           {field.label}
         </span>
-        <span
-          className="mt-0.5 block truncate text-sm text-muted-foreground"
-          title={field.displayValue}
-        >
-          {field.displayNode ?? field.displayValue}
-        </span>
+        {!isTrailingDisplay ? (
+          <span
+            className="mt-0.5 block truncate text-sm text-muted-foreground/70"
+            title={field.displayValue}
+          >
+            {field.displayNode ?? field.displayValue}
+          </span>
+        ) : null}
       </span>
+      {isTrailingDisplay ? field.displayNode : null}
       {field.trailingNode}
       {isActionable ? (
-        <ArrowUpRight className="h-4 w-4 shrink-0 text-muted-foreground" />
+        <ArrowUpRight
+          className="h-4 w-4 shrink-0 text-muted-foreground opacity-0 transition-opacity group-hover:opacity-100 group-focus-visible:opacity-100"
+          data-testid={
+            field.testId ? `${field.testId}-action-indicator` : undefined
+          }
+        />
       ) : isCopyable ? (
-        <Copy className="h-4 w-4 shrink-0 text-muted-foreground" />
+        <HoverCopyIndicator
+          copied={copied}
+          testId={field.testId ? `${field.testId}-copy-status` : undefined}
+        />
       ) : null}
     </>
   );
@@ -493,7 +542,7 @@ function ProfileFieldRow({ field }: { field: ProfileField }) {
     return (
       <button
         aria-label={`Open ${field.label}`}
-        className="flex w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40"
+        className="group flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
         data-testid={field.testId}
         onClick={field.onClick}
         title={`Open ${field.label}`}
@@ -508,11 +557,9 @@ function ProfileFieldRow({ field }: { field: ProfileField }) {
     return (
       <button
         aria-label={`Copy ${field.label}`}
-        className="flex w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40"
+        className="group flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
         data-testid={field.testId}
-        onClick={() =>
-          copyTextToClipboard(field.copyValue ?? "", `Copied ${field.label}`)
-        }
+        onClick={() => void copy()}
         title={`Copy ${field.label}`}
         type="button"
       >
@@ -523,7 +570,7 @@ function ProfileFieldRow({ field }: { field: ProfileField }) {
 
   return (
     <div
-      className="flex items-center gap-3 px-4 py-3"
+      className="flex min-h-16 items-center gap-3 px-4 py-3"
       data-testid={field.testId}
     >
       {content}
diff --git a/desktop/src/features/profile/ui/UserProfilePanelFocusedViews.tsx b/desktop/src/features/profile/ui/UserProfilePanelFocusedViews.tsx
new file mode 100644
index 00000000000..945feca7d99
--- /dev/null
+++ b/desktop/src/features/profile/ui/UserProfilePanelFocusedViews.tsx
@@ -0,0 +1,203 @@
+import { ArrowUpRight, CircleAlert, UserPlus } from "lucide-react";
+
+import { MemorySection } from "@/features/agent-memory/ui/MemorySection";
+import { ManagedAgentLogPanel } from "@/features/agents/ui/ManagedAgentLogPanel";
+import {
+  type ProfileField,
+  ProfileFieldGroup,
+  ProfileSectionGroup,
+} from "@/features/profile/ui/UserProfilePanelFields";
+import { ProfileIngressRow } from "@/features/profile/ui/UserProfilePanelTabs";
+import type { ProfileChannelLink } from "@/features/profile/ui/UserProfilePanelUtils";
+import type { ManagedAgent } from "@/shared/api/types";
+import { cn } from "@/shared/lib/cn";
+import { Alert, AlertDescription, AlertTitle } from "@/shared/ui/alert";
+
+export function MemoryFocusedView({
+  agentPubkey,
+  variant = "focused",
+  viewerIsOwner,
+}: {
+  agentPubkey: string;
+  variant?: "embedded" | "focused";
+  viewerIsOwner: boolean | undefined;
+}) {
+  if (viewerIsOwner !== true) {
+    return null;
+  }
+
+  return (
+    <div className={variant === "focused" ? "pt-4" : undefined}>
+      <ProfileSectionGroup testId="user-profile-memories-section">
+        <MemorySection
+          agentPubkey={agentPubkey}
+          variant="grouped"
+          viewerIsOwner={viewerIsOwner}
+        />
+      </ProfileSectionGroup>
+    </div>
+  );
+}
+
+export function ChannelsFocusedView({
+  canAddToChannel,
+  channels,
+  isActionPending,
+  isLoading,
+  onAddToChannel,
+  onOpenChannel,
+  variant = "focused",
+}: {
+  canAddToChannel: boolean;
+  channels: ProfileChannelLink[];
+  isActionPending: boolean;
+  isLoading: boolean;
+  onAddToChannel: () => void;
+  onOpenChannel: (channelId: string) => void;
+  variant?: "embedded" | "focused";
+}) {
+  return (
+    <div className={variant === "focused" ? "pt-4" : undefined}>
+      <ProfileSectionGroup testId="user-profile-channels-section">
+        {canAddToChannel ? (
+          <ProfileIngressRow
+            disabled={isActionPending}
+            grouped
+            icon={UserPlus}
+            label="Add to channel"
+            onClick={onAddToChannel}
+            testId="user-profile-agent-add-channel"
+            trailing={isActionPending ? "Working…" : undefined}
+          />
+        ) : null}
+        {isLoading ? (
+          <p className="px-4 py-3 text-sm leading-6 text-muted-foreground">
+            Loading channels…
+          </p>
+        ) : channels.length === 0 ? (
+          <div
+            className={cn(
+              "flex flex-col items-center justify-center px-6 text-center",
+              canAddToChannel ? "min-h-20 py-4" : "min-h-56 py-10",
+            )}
+            data-testid="user-profile-channels-empty"
+          >
+            <UserPlus className="mx-auto h-4 w-4 text-muted-foreground" />
+            <p className="mt-3 text-sm font-medium">
+              {canAddToChannel
+                ? "Add this agent to a channel"
+                : "Channels appear here"}
+            </p>
+            <p className="mt-1 text-sm text-muted-foreground">
+              {canAddToChannel
+                ? "Choose a channel above so it can join the conversation."
+                : "Visible memberships appear as this agent joins channels."}
+            </p>
+          </div>
+        ) : (
+          <ul
+            className="divide-y divide-border/55"
+            data-testid="user-profile-channels-list"
+          >
+            {channels.map((channel) => (
+              <li key={channel.id}>
+                <button
+                  aria-label={`Open #${channel.name}`}
+                  className="group flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left text-sm font-medium text-foreground transition-colors hover:bg-muted/40"
+                  data-testid={`user-profile-channel-link-${channel.name}`}
+                  onClick={() => onOpenChannel(channel.id)}
+                  type="button"
+                >
+                  <span className="min-w-0 flex-1 truncate">
+                    #{channel.name}
+                  </span>
+                  <ArrowUpRight
+                    aria-hidden="true"
+                    className="h-4 w-4 shrink-0 text-muted-foreground transition-colors group-hover:text-foreground"
+                  />
+                </button>
+              </li>
+            ))}
+          </ul>
+        )}
+      </ProfileSectionGroup>
+    </div>
+  );
+}
+
+export function AgentInfoFocusedView({
+  metadataFields,
+}: {
+  metadataFields: ProfileField[];
+}) {
+  if (metadataFields.length === 0) {
+    return null;
+  }
+
+  return (
+    <div className="pt-4">
+      <ProfileFieldGroup fields={metadataFields} title="Info" />
+    </div>
+  );
+}
+
+export function DiagnosticsFocusedView({
+  canOpenAgentLogs,
+  fields,
+  logContent,
+  logError,
+  logLoading,
+  managedAgent,
+}: {
+  canOpenAgentLogs: boolean;
+  fields: ProfileField[];
+  logContent: string | null;
+  logError: Error | null;
+  logLoading: boolean;
+  managedAgent: ManagedAgent | undefined;
+}) {
+  const hasLog = canOpenAgentLogs && managedAgent !== undefined;
+  const lastErrorField = fields.find((field) => field.label === "Last error");
+  const detailFields = fields.filter(
+    (field) => field.label !== "Last error" && field.label !== "Status",
+  );
+
+  if (!lastErrorField && detailFields.length === 0 && !hasLog) {
+    return null;
+  }
+
+  return (
+    <div className="flex min-h-0 flex-1 flex-col gap-3 pt-4">
+      {lastErrorField ? (
+        <Alert
+          className="flex gap-3"
+          data-testid={lastErrorField.testId}
+          variant="destructive"
+        >
+          <CircleAlert className="mt-0.5 h-4 w-4 shrink-0 text-destructive" />
+          <div className="min-w-0">
+            <AlertTitle>Last error</AlertTitle>
+            <AlertDescription className="wrap-break-word">
+              {lastErrorField.displayValue}
+            </AlertDescription>
+          </div>
+        </Alert>
+      ) : null}
+      {detailFields.length > 0 ? (
+        <ProfileFieldGroup fields={detailFields} />
+      ) : null}
+      {hasLog ? (
+        <div className="min-h-0 flex-1">
+          <ManagedAgentLogPanel
+            chrome="bare"
+            error={logError}
+            isLoading={logLoading}
+            logContent={logContent}
+            selectedAgent={managedAgent}
+            variant="inline"
+          />
+        </div>
+      ) : null}
+    </div>
+  );
+}
diff --git a/desktop/src/features/profile/ui/UserProfilePanelFrame.tsx b/desktop/src/features/profile/ui/UserProfilePanelFrame.tsx
index 81d1860448c..11a744ee8a4 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelFrame.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanelFrame.tsx
@@ -1,7 +1,11 @@
 import type * as React from "react";
 
-import { AuxiliaryPanel } from "@/shared/layout/AuxiliaryPanel";
-import { AuxiliaryPanelHeader } from "@/shared/layout/AuxiliaryPanel";
+import {
+  AUXILIARY_PANEL_DEFAULT_SURFACE_CLASS,
+  AuxiliaryPanel,
+  AuxiliaryPanelHeader,
+} from "@/shared/layout/AuxiliaryPanel";
+import { cn } from "@/shared/lib/cn";
 
 type UserProfilePanelFrameProps = {
   addAgentToChannelDialog: React.ReactNode;
@@ -18,6 +22,9 @@ type UserProfilePanelFrameProps = {
   personaDialogs: React.ReactNode;
   profileBody: React.ReactNode;
   splitPaneClamp: boolean;
+  stickyChromeActive: boolean;
+  stickyChromeEnabled: boolean;
+  stickyChromeHeight: number;
   widthPx: number;
   transparentChrome?: boolean;
 };
@@ -37,12 +44,16 @@ export function UserProfilePanelFrame({
   personaDialogs,
   profileBody,
   splitPaneClamp,
+  stickyChromeActive,
+  stickyChromeEnabled,
+  stickyChromeHeight,
   widthPx,
   transparentChrome = false,
 }: UserProfilePanelFrameProps) {
   return (
     <AuxiliaryPanel
       canResetWidth={canResetWidth}
+      className="relative"
       isSinglePanelView={isSinglePanelView}
       layout={isSplitLayout ? "split" : "standalone"}
       onClose={onClose}
@@ -62,15 +73,30 @@ export function UserProfilePanelFrame({
       transparentChrome={transparentChrome}
       widthPx={widthPx}
       header={
-        <AuxiliaryPanelHeader
-          backdrop={!isSplitLayout && !isOverlay}
-          inset={!isSplitLayout ? "wide" : "default"}
-          resizeBorder={!isSinglePanelView && !isOverlay && !isSplitLayout}
-          surface={isSinglePanelView ? "transparent" : "default"}
-        >
-          {headerLeftContent}
-          {headerActions}
-        </AuxiliaryPanelHeader>
+        <>
+          <div
+            aria-hidden="true"
+            className={cn(
+              "pointer-events-none absolute inset-x-0 top-0 z-30 opacity-0 transition-opacity duration-150 ease-out motion-reduce:transition-none",
+              AUXILIARY_PANEL_DEFAULT_SURFACE_CLASS,
+              stickyChromeActive && "opacity-100",
+            )}
+            data-active={stickyChromeActive ? "true" : "false"}
+            data-testid="user-profile-sticky-chrome-surface"
+            style={{ height: `${stickyChromeHeight}px` }}
+          />
+          <AuxiliaryPanelHeader
+            backdrop={false}
+            data-testid="user-profile-panel-header"
+            inset={!isSplitLayout ? "wide" : "default"}
+            resizeBorder={!isSinglePanelView && !isOverlay && !isSplitLayout}
+            surface={stickyChromeEnabled ? "transparent" : "default"}
+            transparent={stickyChromeEnabled}
+          >
+            {headerLeftContent}
+            {headerActions}
+          </AuxiliaryPanelHeader>
+        </>
       }
     >
       {profileBody}
diff --git a/desktop/src/features/profile/ui/UserProfilePanelHeaderContent.tsx b/desktop/src/features/profile/ui/UserProfilePanelHeaderContent.tsx
index 9e4150bd958..531222f0ba2 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelHeaderContent.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanelHeaderContent.tsx
@@ -11,6 +11,7 @@ import {
   AuxiliaryPanelHeaderGroup,
   AuxiliaryPanelHeaderTitleBlock,
 } from "@/shared/layout/AuxiliaryPanel";
+import { Button } from "@/shared/ui/button";
 
 export function getUserProfilePanelHeaderContent({
   agentSettingsMenu,
@@ -18,6 +19,7 @@ export function getUserProfilePanelHeaderContent({
   logCopyValue,
   logSubtitle,
   onBack,
+  onEditAgent,
   view,
   viewerIsOwner,
 }: {
@@ -26,6 +28,7 @@ export function getUserProfilePanelHeaderContent({
   logCopyValue?: string | null;
   logSubtitle?: string | null;
   onBack: () => void;
+  onEditAgent?: () => void;
   view: ProfilePanelView;
   viewerIsOwner: boolean;
 }) {
@@ -56,6 +59,19 @@ export function getUserProfilePanelHeaderContent({
         />
       ) : null}
       {view === "summary" ? agentSettingsMenu : null}
+      {view === "summary" && onEditAgent ? (
+        <Button
+          aria-label="Edit agent"
+          className="text-sm"
+          data-testid="user-profile-header-edit-agent"
+          onClick={onEditAgent}
+          size="sm"
+          type="button"
+          variant="ghost"
+        >
+          Edit
+        </Button>
+      ) : null}
       {shouldShowLogDetails ? (
         <CopyButton
           className="text-muted-foreground hover:text-foreground"
diff --git a/desktop/src/features/profile/ui/UserProfilePanelSections.tsx b/desktop/src/features/profile/ui/UserProfilePanelSections.tsx
index 22647eb286a..29a49102ea1 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelSections.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanelSections.tsx
@@ -1,18 +1,14 @@
 import * as React from "react";
-import {
-  ArrowUpRight,
-  ChevronDown,
-  ChevronUp,
-  CircleAlert,
-  UserPlus,
-} from "lucide-react";
-
-import { MemorySection } from "@/features/agent-memory/ui/MemorySection";
+import { ChevronDown, ChevronUp, Pencil } from "lucide-react";
+
 import { useAgentWorking } from "@/features/agents/agentWorkingSignal";
-import { getManagedAgentPrimaryActionLabel } from "@/features/agents/lib/managedAgentControlActions";
+import {
+  getManagedAgentPrimaryActionLabel,
+  isManagedAgentActive,
+} from "@/features/agents/lib/managedAgentControlActions";
 import { RestartDiffBadge } from "@/features/agents/ui/RestartDiffBadge";
-import { ManagedAgentLogPanel } from "@/features/agents/ui/ManagedAgentLogPanel";
 import { AgentConfigPanel } from "@/features/agents/ui/AgentConfigPanel";
+import type { IdentityArchiveActions } from "@/features/identity-archive/hooks";
 import { getPresenceLabel } from "@/features/presence/lib/presence";
 import { PresenceDot } from "@/features/presence/ui/PresenceBadge";
 import type { ProfileActivityAgent } from "@/features/profile/lib/profileActivityAgent";
@@ -21,14 +17,10 @@ import type {
   useUnfollowMutation,
   useUserProfileQuery,
 } from "@/features/profile/hooks";
-import {
-  type ProfileField,
-  ProfileFieldGroup,
-} from "@/features/profile/ui/UserProfilePanelFields";
+import type { ProfileField } from "@/features/profile/ui/UserProfilePanelFields";
 import { AGENT_DETAILS_FIELD_LABELS } from "@/features/profile/ui/UserProfilePanelAgentDetails";
 import {
   ProfileInfoTabContent,
-  ProfileIngressRow,
   ProfileRuntimeTabContent,
   ProfileTabBar,
 } from "@/features/profile/ui/UserProfilePanelTabs";
@@ -36,11 +28,22 @@ import {
   MaskedAvatarBadgeFrame,
   STATUS_DOT_MASK_CURVE,
 } from "@/features/profile/ui/MaskedAvatarBadgeFrame";
+import { ProfileTabContentTransition } from "@/features/profile/ui/ProfileTabContentTransition";
+import {
+  ChannelsFocusedView,
+  MemoryFocusedView,
+} from "@/features/profile/ui/UserProfilePanelFocusedViews";
 import { ProfileAvatar } from "@/features/profile/ui/ProfileAvatar";
 import {
   ProfilePersonaPrimaryActions,
   ProfilePrimaryActions,
 } from "@/features/profile/ui/UserProfilePrimaryActions";
+import {
+  fillRuntimePreviewDiagnostics,
+  fillRuntimePreviewFields,
+  UserProfileConfigPreview,
+  UserProfileRuntimePreviewNotice,
+} from "@/features/profile/ui/UserProfileRuntimePreview";
 import { StatusEmoji } from "@/features/user-status/ui/StatusEmoji";
 import { BotIdenticon } from "@/features/messages/ui/BotIdenticon";
 import type { ManagedAgent, RelayAgent } from "@/shared/api/types";
@@ -49,7 +52,8 @@ import type {
   ProfilePanelTab,
 } from "@/features/profile/ui/UserProfilePanelUtils";
 import { cn } from "@/shared/lib/cn";
-import { Alert, AlertDescription, AlertTitle } from "@/shared/ui/alert";
+import { observeElementBlockSize } from "@/shared/layout/observeElementBlockSize";
+import { useMeasuredCssVariable } from "@/shared/layout/useMeasuredCssVariable";
 import { Badge } from "@/shared/ui/badge";
 
 export { AgentInstructionsFocusedView } from "@/features/profile/ui/UserProfilePanelAgentDetails";
@@ -60,6 +64,7 @@ export type ProfileSummaryViewProps = {
   activityAgent: ProfileActivityAgent | null;
   callerChannelId: string | null;
   canAddToChannel: boolean;
+  canDeleteAgent: boolean;
   canEditAgent: boolean;
   canOpenAgentLogs: boolean;
   canViewActivity: boolean;
@@ -74,11 +79,16 @@ export type ProfileSummaryViewProps = {
   handleAgentPrimaryAction: () => void;
   handleAgentRestart: () => void;
   handleEditAgent: () => void;
+  handleToggleAgentAutoStart: () => void;
   handleEditPersona?: () => void;
+  handleHuddle?: () => void;
   handleInstantiateAgent: () => void;
-  handleMessage: () => void;
+  handleMessage?: () => void;
+  handleWave?: () => void;
   isArchived: boolean;
+  isHuddlePending: boolean;
   isMessagePending: boolean;
+  isWavePending: boolean;
   isBot: boolean;
   isAgentActionPending: boolean;
   isFollowing: boolean;
@@ -86,21 +96,20 @@ export type ProfileSummaryViewProps = {
   isSelf: boolean;
   instances: ManagedAgent[];
   managedAgent: ManagedAgent | undefined;
-  memoriesLoading: boolean;
-  memoryCount: number | undefined;
   agentInfoFields: ProfileField[];
+  archiveActions: IdentityArchiveActions;
   agentSettingsFields: ProfileField[];
   diagnosticsFields: ProfileField[];
   onAddToChannel: () => void;
+  onDeleteAgent: () => void;
+  onDuplicateAgent?: () => void;
+  onExportAgent?: () => void;
   onOpenInstance: (pubkey: string) => void;
   onOpenActivity: (channelId?: string | null) => void;
   onOpenChannel: (channelId: string) => void;
   onOpenDiagnostics: () => void;
-  onOpenInstructions: () => void;
+  onStickyChromeChange: (state: { active: boolean; height: number }) => void;
   onTabChange: (tab: ProfilePanelTab, options?: { replace?: boolean }) => void;
-  onOpenDm?: (pubkeys: string[]) => Promise<void> | void;
-  /** Mint an agent trading card. Present only for owner-managed personas. */
-  onCreateCard?: () => void;
   presenceStatus: "online" | "away" | "offline" | undefined;
   profile: ReturnType<typeof useUserProfileQuery>["data"];
   pubkey: string | null;
@@ -110,12 +119,11 @@ export type ProfileSummaryViewProps = {
   userStatus: { text: string; emoji: string } | null | undefined;
 };
 
-type RuntimeTabStatus = "running" | "stopped" | "error";
-
 const PROFILE_HERO_SPACING = {
   "0": 0,
   "6": 24,
 } as const;
+const PROFILE_ACTIONS_SCROLL_DISTANCE_PX = 96;
 
 const PROFILE_HERO_PRESENCE_BADGE = {
   cutout: { cx: 68, cy: 68, r: 15 },
@@ -127,54 +135,11 @@ const PROFILE_HERO_PRESENCE_BADGE = {
   },
 } as const;
 
-function resolveRuntimeTabStatus({
-  diagnosticsError,
-  managedAgent,
-}: {
-  diagnosticsError: boolean;
-  managedAgent: ManagedAgent | undefined;
-}): RuntimeTabStatus | undefined {
-  if (diagnosticsError || managedAgent?.lastError) {
-    return "error";
-  }
-
-  if (!managedAgent) {
-    return undefined;
-  }
-
-  if (managedAgent.status === "running" || managedAgent.status === "deployed") {
-    return "running";
-  }
-
-  return "stopped";
-}
-
-function RuntimeTabStatusDot({ status }: { status: RuntimeTabStatus }) {
-  const label =
-    status === "error" ? "Error" : status === "running" ? "Running" : "Stopped";
-
-  return (
-    <span
-      aria-hidden="true"
-      className={cn(
-        "block h-1.5 w-1.5 rounded-full ring-1 ring-background",
-        status === "error"
-          ? "bg-destructive"
-          : status === "running"
-            ? "bg-emerald-500"
-            : "bg-muted-foreground/50",
-      )}
-      data-status={status}
-      data-testid="user-profile-runtime-status"
-      title={label}
-    />
-  );
-}
-
 export function ProfileSummaryView({
   activityAgent,
   callerChannelId,
   canAddToChannel,
+  canDeleteAgent,
   canEditAgent,
   canOpenAgentLogs,
   canViewActivity,
@@ -189,11 +154,16 @@ export function ProfileSummaryView({
   handleAgentPrimaryAction,
   handleAgentRestart,
   handleEditAgent,
+  handleToggleAgentAutoStart,
   handleEditPersona,
+  handleHuddle,
   handleInstantiateAgent,
   handleMessage,
+  handleWave,
   isArchived,
+  isHuddlePending,
   isMessagePending,
+  isWavePending,
   isBot,
   isAgentActionPending,
   isFollowing,
@@ -201,20 +171,20 @@ export function ProfileSummaryView({
   isSelf,
   instances,
   managedAgent,
-  memoriesLoading,
-  memoryCount,
   agentInfoFields,
+  archiveActions,
   agentSettingsFields,
   diagnosticsFields,
   onAddToChannel,
+  onDeleteAgent,
+  onDuplicateAgent,
+  onExportAgent,
   onOpenInstance,
   onOpenActivity,
   onOpenChannel,
   onOpenDiagnostics,
-  onOpenInstructions,
+  onStickyChromeChange,
   onTabChange,
-  onOpenDm,
-  onCreateCard,
   presenceStatus,
   profile,
   pubkey,
@@ -224,6 +194,27 @@ export function ProfileSummaryView({
   userStatus,
 }: ProfileSummaryViewProps) {
   const activeTurns = useAgentWorking(isBot ? pubkey : null).channels;
+  const avatarStatus = isBot
+    ? managedAgent
+      ? isManagedAgentActive(managedAgent)
+        ? "online"
+        : "offline"
+      : (presenceStatus ?? "offline")
+    : presenceStatus;
+  const stickyLayoutRef = React.useRef<HTMLDivElement>(null);
+  const [primaryActionsConcealed, setPrimaryActionsConcealed] =
+    React.useState(false);
+  const [primaryActionsElement, setPrimaryActionsElement] =
+    React.useState<HTMLDivElement | null>(null);
+  const [stickyTabsElement, setStickyTabsElement] =
+    React.useState<HTMLDivElement | null>(null);
+  const stickyHeroRef = useMeasuredCssVariable({
+    cssVariable: "--buzz-profile-sticky-hero-height",
+    enabled: isBot,
+    resetKey: displayName,
+    resetValue: "0px",
+    targetRef: stickyLayoutRef,
+  });
 
   const showMemoriesTab = isOwner === true && Boolean(pubkey);
   const showInstructionBlock =
@@ -237,24 +228,42 @@ export function ProfileSummaryView({
   const runtimeSettingsFields = agentSettingsFields.filter(
     (field) => !AGENT_DETAILS_FIELD_LABELS.has(field.label),
   );
+  const showRuntimePreview =
+    import.meta.env.DEV &&
+    isOwner === true &&
+    isBot &&
+    managedAgent === undefined;
   const showRuntimeTab =
     isOwner === true &&
     isBot &&
-    (runtimeConfigurationFields.length > 0 ||
+    (managedAgent !== undefined ||
+      runtimeConfigurationFields.length > 0 ||
       runtimeSettingsFields.length > 0 ||
-      managedAgent !== undefined ||
+      instances.length > 0 ||
       diagnosticsFields.length > 0 ||
       canOpenAgentLogs ||
-      showInstructionBlock);
+      showRuntimePreview);
+  const displayedRuntimeFields = showRuntimePreview
+    ? fillRuntimePreviewFields([
+        ...runtimeConfigurationFields,
+        ...runtimeSettingsFields,
+      ])
+    : [...runtimeConfigurationFields, ...runtimeSettingsFields];
+  const displayedDiagnosticsFields = showRuntimePreview
+    ? fillRuntimePreviewDiagnostics(diagnosticsFields)
+    : diagnosticsFields;
   const showDiagnosticsIngress =
     diagnosticsFields.some((field) => field.label !== "Status") ||
     canOpenAgentLogs;
   const showActivityIngress = canViewActivity;
   const showInfoTab =
     agentInfoFields.length > 0 ||
-    instances.length > 1 ||
+    displayedRuntimeFields.length > 0 ||
     isArchived ||
     showActivityIngress ||
+    showInstructionBlock ||
+    managedAgent !== undefined ||
+    showRuntimePreview ||
     !showRuntimeTab;
 
   const diagnosticsErrorField = diagnosticsFields.find(
@@ -262,17 +271,14 @@ export function ProfileSummaryView({
   );
   const diagnosticsTrailing =
     diagnosticsErrorField !== undefined ? (
-      <Badge title={diagnosticsErrorField.displayValue} variant="destructive">
+      <Badge
+        className="normal-case tracking-normal"
+        title={diagnosticsErrorField.displayValue}
+        variant="destructive"
+      >
         Error
       </Badge>
-    ) : (
-      "View"
-    );
-  const runtimeTabStatus = resolveRuntimeTabStatus({
-    diagnosticsError: diagnosticsErrorField !== undefined,
-    managedAgent,
-  });
-
+    ) : null;
   const tabs = React.useMemo(() => {
     const items: Array<{
       id: ProfilePanelTab;
@@ -283,79 +289,159 @@ export function ProfileSummaryView({
       items.push({ id: "info", label: "Info" });
     }
     if (showRuntimeTab) {
-      items.push({
-        id: "runtime",
-        label: "Runtime",
-        trailing: runtimeTabStatus ? (
-          <RuntimeTabStatusDot status={runtimeTabStatus} />
-        ) : undefined,
-      });
+      items.push({ id: "runtime", label: "Runtime" });
     }
     if (showChannelsTab) {
-      items.push({
-        id: "channels",
-        label: "Channels",
-        trailing: channelsLoading
-          ? "…"
-          : channelCount > 0
-            ? String(channelCount)
-            : undefined,
-      });
+      items.push({ id: "channels", label: "Channels" });
     }
     if (showMemoriesTab) {
       items.push({
         id: "memories",
         label: "Memories",
-        trailing: memoriesLoading
-          ? "…"
-          : memoryCount !== undefined
-            ? String(memoryCount)
-            : undefined,
       });
     }
     return items;
-  }, [
-    channelCount,
-    channelsLoading,
-    memoriesLoading,
-    memoryCount,
-    runtimeTabStatus,
-    showChannelsTab,
-    showInfoTab,
-    showMemoriesTab,
-    showRuntimeTab,
-  ]);
+  }, [showChannelsTab, showInfoTab, showMemoriesTab, showRuntimeTab]);
 
   const showTabSection = tabs.length > 0;
   const showTabBar = !(tabs.length === 1 && tabs[0]?.id === "info");
   const activeTab = tabs.some((item) => item.id === tab)
     ? tab
     : (tabs[0]?.id ?? "info");
+  const tabIds = React.useMemo(() => tabs.map((item) => item.id), [tabs]);
+
+  React.useLayoutEffect(() => {
+    const layout = stickyLayoutRef.current;
+    const scrollBody = layout?.closest<HTMLElement>(
+      '[data-testid="user-profile-scroll-body"]',
+    );
+    const panel = scrollBody?.parentElement;
+    const header = panel?.querySelector<HTMLElement>(
+      '[data-testid="user-profile-panel-header"]',
+    );
+    const hero = layout?.querySelector<HTMLElement>(
+      '[data-testid="user-profile-sticky-hero"]',
+    );
+
+    if (
+      !isBot ||
+      !showTabBar ||
+      !scrollBody ||
+      !header ||
+      !hero ||
+      !stickyTabsElement
+    ) {
+      if (primaryActionsElement) {
+        primaryActionsElement.style.opacity = "";
+      }
+      setPrimaryActionsConcealed(false);
+      onStickyChromeChange({ active: false, height: 0 });
+      return;
+    }
+
+    let animationFrame: number | null = null;
+    const updateScrollChrome = () => {
+      animationFrame = null;
+      const headerRect = header.getBoundingClientRect();
+      const heroRect = hero.getBoundingClientRect();
+      const tabsRect = stickyTabsElement.getBoundingClientRect();
+
+      if (primaryActionsElement) {
+        const actionsProgress = Math.min(
+          Math.max(
+            scrollBody.scrollTop / PROFILE_ACTIONS_SCROLL_DISTANCE_PX,
+            0,
+          ),
+          1,
+        );
+        primaryActionsElement.style.opacity = String(1 - actionsProgress);
+        setPrimaryActionsConcealed(actionsProgress >= 1);
+      }
+      onStickyChromeChange({
+        active: scrollBody.scrollTop > 0 && tabsRect.top <= heroRect.bottom + 1,
+        height: Math.max(0, Math.ceil(tabsRect.bottom - headerRect.top)),
+      });
+    };
+    const scheduleStickyChromeUpdate = () => {
+      if (animationFrame === null) {
+        animationFrame = window.requestAnimationFrame(updateScrollChrome);
+      }
+    };
+
+    const disconnectObservers = [header, hero, stickyTabsElement].map(
+      (element) => observeElementBlockSize(element, scheduleStickyChromeUpdate),
+    );
+    scrollBody.addEventListener("scroll", scheduleStickyChromeUpdate, {
+      passive: true,
+    });
+    window.addEventListener("resize", scheduleStickyChromeUpdate);
+    scheduleStickyChromeUpdate();
+
+    return () => {
+      if (animationFrame !== null) {
+        window.cancelAnimationFrame(animationFrame);
+      }
+      for (const disconnect of disconnectObservers) {
+        disconnect();
+      }
+      scrollBody.removeEventListener("scroll", scheduleStickyChromeUpdate);
+      window.removeEventListener("resize", scheduleStickyChromeUpdate);
+      if (primaryActionsElement) {
+        primaryActionsElement.style.opacity = "";
+      }
+      setPrimaryActionsConcealed(false);
+      onStickyChromeChange({ active: false, height: 0 });
+    };
+  }, [
+    isBot,
+    onStickyChromeChange,
+    primaryActionsElement,
+    showTabBar,
+    stickyTabsElement,
+  ]);
+
+  const primaryActionsMotionClassName = isBot
+    ? cn(
+        "will-change-[opacity]",
+        primaryActionsConcealed && "pointer-events-none",
+      )
+    : undefined;
 
   return (
-    <div className="flex flex-col gap-6 pt-4">
-      <ProfileHero
-        displayName={displayName}
-        isBot={isBot}
-        presenceStatus={presenceStatus}
-        profile={profile}
-        userStatus={userStatus}
-      />
+    <div
+      className="flex flex-col gap-6 pt-4"
+      data-testid="user-profile-summary-scroll-layout"
+      ref={stickyLayoutRef}
+    >
+      <div
+        className={cn(isBot && "sticky top-0 z-40 -mx-4 px-4")}
+        data-testid={isBot ? "user-profile-sticky-hero" : undefined}
+        ref={stickyHeroRef}
+      >
+        <ProfileHero
+          displayName={displayName}
+          isBot={isBot}
+          onEditAgent={canEditAgent ? handleEditAgent : undefined}
+          presenceStatus={avatarStatus}
+          profile={profile}
+          userStatus={userStatus}
+        />
+      </div>
 
       {canInstantiateAgent ? (
         <ProfilePersonaPrimaryActions
-          canEditAgent={canEditAgent}
+          actionGroupRef={setPrimaryActionsElement}
+          className={primaryActionsMotionClassName}
+          concealed={primaryActionsConcealed}
           disabled={isAgentActionPending}
-          onCreateCard={onCreateCard}
-          onEditAgent={handleEditAgent}
           onStartAgent={handleInstantiateAgent}
         />
       ) : !isSelf && pubkey ? (
         <ProfilePrimaryActions
-          canEditAgent={canEditAgent}
+          actionGroupRef={setPrimaryActionsElement}
+          className={primaryActionsMotionClassName}
+          concealed={primaryActionsConcealed}
           followMutation={followMutation}
-          onCreateCard={onCreateCard}
-          onEditAgent={handleEditAgent}
           agentActionDisabled={isAgentActionPending}
           agentActionLabel={
             isOwner === true && managedAgent
@@ -380,10 +466,14 @@ export function ProfileSummaryView({
               : undefined
           }
           isFollowing={isFollowing}
+          huddlePending={isBot ? undefined : isHuddlePending}
           messagePending={isMessagePending}
-          onMessage={onOpenDm ? handleMessage : undefined}
+          onHuddle={isBot ? undefined : handleHuddle}
+          onMessage={handleMessage}
+          onWave={handleWave}
           pubkey={pubkey}
           unfollowMutation={unfollowMutation}
+          wavePending={isWavePending}
         />
       ) : null}
 
@@ -400,75 +490,134 @@ export function ProfileSummaryView({
       ) : null}
 
       {showTabSection ? (
-        <section className="space-y-3">
+        <section className={cn(isBot ? "space-y-0" : "space-y-3")}>
           {showTabBar ? (
-            <ProfileTabBar
-              activeTab={activeTab}
-              onTabChange={onTabChange}
-              tabs={tabs}
-            />
-          ) : null}
-          {activeTab === "info" ? (
-            <ProfileInfoTabContent
-              activeTurns={activeTurns}
-              activityAgent={activityAgent}
-              agentInfoFields={agentInfoFields}
-              callerChannelId={callerChannelId}
-              channelIdToName={channelIdToName}
-              instances={instances}
-              isArchived={isArchived}
-              onOpenActivity={onOpenActivity}
-              onOpenInstance={onOpenInstance}
-              pubkey={pubkey}
-              showActivityIngress={showActivityIngress}
-            />
+            <div
+              className={cn(
+                isBot &&
+                  "sticky z-40 -mx-4 px-4 pb-3 pt-2 motion-reduce:transition-none",
+              )}
+              data-testid={isBot ? "user-profile-sticky-tabs" : undefined}
+              ref={setStickyTabsElement}
+              style={
+                isBot
+                  ? {
+                      top: "var(--buzz-profile-sticky-hero-height, 0px)",
+                    }
+                  : undefined
+              }
+            >
+              <ProfileTabBar
+                activeTab={activeTab}
+                onTabChange={onTabChange}
+                tabs={tabs}
+              />
+            </div>
           ) : null}
-          {activeTab === "runtime" ? (
-            <>
-              <ProfileRuntimeTabContent
-                agentInstruction={agentInstruction}
-                autoRestartEnabled={
-                  managedAgent?.autoRestartOnConfigChange ?? false
-                }
-                diagnosticsFields={diagnosticsFields}
-                diagnosticsSummary={diagnosticsTrailing}
-                needsRestart={managedAgent?.needsRestart ?? false}
-                restartDiff={managedAgent?.restartDiff ?? []}
-                onOpenDiagnostics={onOpenDiagnostics}
-                onOpenInstructions={onOpenInstructions}
-                runtimeConfigurationFields={runtimeConfigurationFields}
-                runtimeSettingsFields={runtimeSettingsFields}
-                showDiagnosticsIngress={showDiagnosticsIngress}
+          <ProfileTabContentTransition
+            activeTab={activeTab}
+            className={cn(showTabBar && "pt-2")}
+            tabs={tabIds}
+          >
+            {activeTab === "info" ? (
+              <ProfileInfoTabContent
+                activeTurns={activeTurns}
+                activityAgent={activityAgent}
+                agentInfoFields={agentInfoFields}
+                archiveActions={archiveActions}
+                canArchiveAgent={isBot && archiveActions.canArchive}
+                canDeleteAgent={canDeleteAgent}
+                callerChannelId={callerChannelId}
+                channelIdToName={channelIdToName}
+                isArchived={isArchived}
+                isDeleteAgentPending={isAgentActionPending}
+                managedAgent={managedAgent}
+                onEditAgent={handleEditAgent}
+                onDeleteAgent={onDeleteAgent}
+                onDuplicateAgent={onDuplicateAgent}
+                onExportAgent={onExportAgent}
+                onOpenActivity={onOpenActivity}
+                pubkey={pubkey}
+                showActivityIngress={showActivityIngress}
                 showInstructionBlock={showInstructionBlock}
               />
-              {isOwner === true && managedAgent !== undefined ? (
-                <div className="overflow-hidden rounded-2xl bg-muted/20">
+            ) : null}
+            {activeTab === "runtime" ? (
+              <div className="space-y-4">
+                {showRuntimePreview ? (
+                  <UserProfileRuntimePreviewNotice />
+                ) : null}
+                <ProfileRuntimeTabContent
+                  autoRestartEnabled={
+                    managedAgent?.autoRestartOnConfigChange ?? false
+                  }
+                  currentPubkey={pubkey}
+                  diagnosticsFields={displayedDiagnosticsFields}
+                  diagnosticsSummary={diagnosticsTrailing}
+                  configurationFields={displayedRuntimeFields}
+                  instances={instances}
+                  modelSettings={
+                    isOwner === true && managedAgent !== undefined ? (
+                      <AgentConfigPanel
+                        advancedMode="flat"
+                        onEdit={canEditAgent ? handleEditAgent : undefined}
+                        pubkey={managedAgent.pubkey}
+                        sections={["model"]}
+                      />
+                    ) : showRuntimePreview ? (
+                      <UserProfileConfigPreview
+                        onEdit={canEditAgent ? handleEditAgent : undefined}
+                        sections={["model"]}
+                      />
+                    ) : undefined
+                  }
+                  needsRestart={managedAgent?.needsRestart ?? false}
+                  onToggleStartOnLaunch={
+                    managedAgent?.backend.type === "local"
+                      ? handleToggleAgentAutoStart
+                      : undefined
+                  }
+                  restartDiff={managedAgent?.restartDiff ?? []}
+                  startOnLaunchEnabled={managedAgent?.startOnAppLaunch}
+                  startOnLaunchPending={isAgentActionPending}
+                  onOpenDiagnostics={onOpenDiagnostics}
+                  onOpenInstance={onOpenInstance}
+                  showDiagnosticsIngress={showDiagnosticsIngress}
+                  showPreviewHarnessLog={
+                    showRuntimePreview && !showDiagnosticsIngress
+                  }
+                />
+                {isOwner === true && managedAgent !== undefined ? (
                   <AgentConfigPanel
                     advancedMode="flat"
                     pubkey={managedAgent.pubkey}
+                    sections={["mcp", "advanced"]}
                   />
-                </div>
-              ) : null}
-            </>
-          ) : null}
-          {activeTab === "channels" ? (
-            <ChannelsFocusedView
-              canAddToChannel={canAddToChannel}
-              channels={channels}
-              isActionPending={isAgentActionPending}
-              isLoading={channelsLoading}
-              onAddToChannel={onAddToChannel}
-              onOpenChannel={onOpenChannel}
-              variant="embedded"
-            />
-          ) : null}
-          {activeTab === "memories" && pubkey ? (
-            <MemoryFocusedView
-              agentPubkey={pubkey}
-              variant="embedded"
-              viewerIsOwner={isOwner}
-            />
-          ) : null}
+                ) : null}
+                {showRuntimePreview ? (
+                  <UserProfileConfigPreview sections={["mcp", "advanced"]} />
+                ) : null}
+              </div>
+            ) : null}
+            {activeTab === "channels" ? (
+              <ChannelsFocusedView
+                canAddToChannel={canAddToChannel}
+                channels={channels}
+                isActionPending={isAgentActionPending}
+                isLoading={channelsLoading}
+                onAddToChannel={onAddToChannel}
+                onOpenChannel={onOpenChannel}
+                variant="embedded"
+              />
+            ) : null}
+            {activeTab === "memories" && pubkey ? (
+              <MemoryFocusedView
+                agentPubkey={pubkey}
+                variant="embedded"
+                viewerIsOwner={isOwner}
+              />
+            ) : null}
+          </ProfileTabContentTransition>
         </section>
       ) : null}
     </div>
@@ -480,17 +629,27 @@ export function ProfileSummaryView({
 function ProfileHero({
   displayName,
   isBot,
+  onEditAgent,
   presenceStatus,
   profile,
   userStatus,
 }: {
   displayName: string;
   isBot: boolean;
+  onEditAgent?: () => void;
   presenceStatus: "online" | "away" | "offline" | undefined;
   profile: ProfileSummaryViewProps["profile"];
   userStatus: ProfileSummaryViewProps["userStatus"];
 }) {
   const presenceDotClassName = isBot ? "h-4.5 w-4.5" : "h-3.5 w-3.5";
+  const botIndicator = isBot ? (
+    <BotIdenticon
+      className="shrink-0 rounded"
+      data-testid="profile-bot-indicator"
+      size={20}
+      value={displayName}
+    />
+  ) : null;
 
   return (
     <div className="flex flex-col items-center gap-3 text-center">
@@ -527,19 +686,37 @@ function ProfileHero({
       </MaskedAvatarBadgeFrame>
 
       <div className="flex flex-col items-center gap-1">
-        <div className="flex items-center justify-center gap-2">
-          <h3 className="text-xl font-semibold tracking-tight">
-            {displayName}
+        {onEditAgent ? (
+          <h3 className="max-w-full" data-testid="user-profile-name-row">
+            <button
+              aria-label={`Edit ${displayName}`}
+              className="group relative flex max-w-full items-center justify-center gap-2 rounded-lg px-1 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring"
+              data-testid="user-profile-edit-agent"
+              onClick={onEditAgent}
+              type="button"
+            >
+              <span className="truncate text-xl font-semibold tracking-tight">
+                {displayName}
+              </span>
+              {botIndicator}
+              <span
+                aria-hidden="true"
+                className="pointer-events-none absolute top-1/2 left-full ml-1 -translate-y-1/2 text-muted-foreground opacity-0 transition-[color,opacity] duration-150 ease-out group-hover:text-foreground group-hover:opacity-100 group-focus-visible:opacity-100"
+                data-testid="user-profile-edit-agent-icon"
+              >
+                <Pencil className="h-4 w-4" />
+              </span>
+            </button>
           </h3>
-          {isBot ? (
-            <BotIdenticon
-              className="shrink-0 rounded"
-              data-testid="profile-bot-indicator"
-              size={20}
-              value={displayName}
-            />
-          ) : null}
-        </div>
+        ) : (
+          <h3
+            className="flex max-w-full items-center justify-center gap-2 text-xl font-semibold tracking-tight"
+            data-testid="user-profile-name-row"
+          >
+            <span className="truncate">{displayName}</span>
+            {botIndicator}
+          </h3>
+        )}
 
         {profile?.about?.trim() ? (
           <ProfileHeroDescription
@@ -640,183 +817,3 @@ function ProfileHeroDescription({ about }: { about: string }) {
     </div>
   );
 }
-
-// ── Focused views ────────────────────────────────────────────────────────────
-
-export function MemoryFocusedView({
-  agentPubkey,
-  variant = "focused",
-  viewerIsOwner,
-}: {
-  agentPubkey: string;
-  variant?: "embedded" | "focused";
-  viewerIsOwner: boolean | undefined;
-}) {
-  if (viewerIsOwner !== true) {
-    return null;
-  }
-
-  return (
-    <div className={variant === "focused" ? "pt-4" : undefined}>
-      <MemorySection agentPubkey={agentPubkey} viewerIsOwner={viewerIsOwner} />
-    </div>
-  );
-}
-
-export function ChannelsFocusedView({
-  canAddToChannel,
-  channels,
-  isActionPending,
-  isLoading,
-  onAddToChannel,
-  onOpenChannel,
-  variant = "focused",
-}: {
-  canAddToChannel: boolean;
-  channels: ProfileChannelLink[];
-  isActionPending: boolean;
-  isLoading: boolean;
-  onAddToChannel: () => void;
-  onOpenChannel: (channelId: string) => void;
-  variant?: "embedded" | "focused";
-}) {
-  return (
-    <div className={cn("space-y-3", variant === "focused" && "pt-4")}>
-      {canAddToChannel ? (
-        <ProfileIngressRow
-          disabled={isActionPending}
-          icon={UserPlus}
-          label="Add to channel"
-          onClick={onAddToChannel}
-          testId="user-profile-agent-add-channel"
-          trailing={isActionPending ? "Working…" : undefined}
-        />
-      ) : null}
-      {isLoading ? (
-        <p className="text-base leading-7 text-muted-foreground">
-          Loading channels…
-        </p>
-      ) : channels.length === 0 ? (
-        <div
-          className={cn(
-            "flex flex-col items-center justify-center px-6 text-center",
-            canAddToChannel ? "min-h-20 py-4" : "min-h-56 py-10",
-          )}
-          data-testid="user-profile-channels-empty"
-        >
-          <UserPlus className="mx-auto h-4 w-4 text-muted-foreground" />
-          <p className="mt-3 text-sm font-medium">
-            {canAddToChannel
-              ? "Add this agent to a channel"
-              : "Channels appear here"}
-          </p>
-          <p className="mt-1 text-sm text-muted-foreground">
-            {canAddToChannel
-              ? "Choose a channel above so it can join the conversation."
-              : "Visible memberships appear as this agent joins channels."}
-          </p>
-        </div>
-      ) : (
-        <ul
-          className="overflow-hidden rounded-2xl bg-muted/20"
-          data-testid="user-profile-channels-list"
-        >
-          {channels.map((channel) => (
-            <li key={channel.id}>
-              <button
-                aria-label={`Open #${channel.name}`}
-                className="group flex w-full items-center gap-3 px-4 py-3 text-left text-base leading-7 text-foreground transition-colors hover:bg-muted/40"
-                data-testid={`user-profile-channel-link-${channel.name}`}
-                onClick={() => onOpenChannel(channel.id)}
-                type="button"
-              >
-                <span className="min-w-0 flex-1 truncate">#{channel.name}</span>
-                <ArrowUpRight
-                  aria-hidden="true"
-                  className="h-4 w-4 shrink-0 text-muted-foreground transition-colors group-hover:text-foreground"
-                />
-              </button>
-            </li>
-          ))}
-        </ul>
-      )}
-    </div>
-  );
-}
-
-export function AgentInfoFocusedView({
-  metadataFields,
-}: {
-  metadataFields: ProfileField[];
-}) {
-  if (metadataFields.length === 0) {
-    return null;
-  }
-
-  return (
-    <div className="pt-4">
-      <ProfileFieldGroup fields={metadataFields} />
-    </div>
-  );
-}
-
-export function DiagnosticsFocusedView({
-  canOpenAgentLogs,
-  fields,
-  logContent,
-  logError,
-  logLoading,
-  managedAgent,
-}: {
-  canOpenAgentLogs: boolean;
-  fields: ProfileField[];
-  logContent: string | null;
-  logError: Error | null;
-  logLoading: boolean;
-  managedAgent: ManagedAgent | undefined;
-}) {
-  const hasLog = canOpenAgentLogs && managedAgent !== undefined;
-  const lastErrorField = fields.find((field) => field.label === "Last error");
-  const detailFields = fields.filter(
-    (field) => field.label !== "Last error" && field.label !== "Status",
-  );
-
-  if (!lastErrorField && detailFields.length === 0 && !hasLog) {
-    return null;
-  }
-
-  return (
-    <div className="flex min-h-0 flex-1 flex-col gap-3 pt-4">
-      {lastErrorField ? (
-        <Alert
-          className="flex gap-3"
-          data-testid={lastErrorField.testId}
-          variant="destructive"
-        >
-          <CircleAlert className="mt-0.5 h-4 w-4 shrink-0 text-destructive" />
-          <div className="min-w-0">
-            <AlertTitle>Last error</AlertTitle>
-            <AlertDescription className="wrap-break-word">
-              {lastErrorField.displayValue}
-            </AlertDescription>
-          </div>
-        </Alert>
-      ) : null}
-      {detailFields.length > 0 ? (
-        <ProfileFieldGroup fields={detailFields} />
-      ) : null}
-      {hasLog ? (
-        <div className="min-h-0 flex-1">
-          <ManagedAgentLogPanel
-            chrome="bare"
-            error={logError}
-            isLoading={logLoading}
-            logContent={logContent}
-            selectedAgent={managedAgent}
-            variant="inline"
-          />
-        </div>
-      ) : null}
-    </div>
-  );
-}
diff --git a/desktop/src/features/profile/ui/UserProfilePanelTabs.tsx b/desktop/src/features/profile/ui/UserProfilePanelTabs.tsx
index be6d5add431..0ab9d8067c9 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelTabs.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePanelTabs.tsx
@@ -1,14 +1,8 @@
 import * as React from "react";
 import type { LucideIcon } from "lucide-react";
-import {
-  Activity,
-  Archive,
-  ChevronRight,
-  Info,
-  RefreshCw,
-  Wrench,
-} from "lucide-react";
+import { Archive, ChevronRight, Info, RefreshCw, Wrench } from "lucide-react";
 
+import type { IdentityArchiveActions } from "@/features/identity-archive/hooks";
 import type { ManagedAgent, RestartDiffEntry } from "@/shared/api/types";
 import {
   AUTO_RESTART_OFF_BLURB,
@@ -17,20 +11,17 @@ import {
 } from "@/features/agents/ui/RestartDiffBadge";
 import type { ActiveTurnSummary } from "@/features/agents/activeAgentTurnsStore";
 import { ManagedAgentSessionPanel } from "@/features/agents/ui/ManagedAgentSessionPanel";
-import {
-  AgentDetailsRows,
-  AgentInstructionRow,
-} from "@/features/profile/ui/UserProfilePanelAgentDetails";
 import type { ProfileActivityAgent } from "@/features/profile/lib/profileActivityAgent";
 import { resolveActivityChannelId } from "@/features/profile/lib/profileActivityCarousel";
 import {
   type ProfileActivityFeedScope,
   useProfileActivityFeedScope,
 } from "@/features/profile/lib/profileActivityFeedScope";
+import { UserProfileAgentManagementRows } from "@/features/profile/ui/UserProfileAgentManagementRows";
 import {
   type ProfileField,
-  ProfileFieldGroup,
   ProfileFieldRows,
+  ProfileSectionGroup,
 } from "@/features/profile/ui/UserProfilePanelFields";
 import type { ProfilePanelTab } from "@/features/profile/ui/UserProfilePanelUtils";
 import { cn } from "@/shared/lib/cn";
@@ -42,10 +33,15 @@ import {
   CarouselContent,
   CarouselItem,
 } from "@/shared/ui/carousel";
+import { Tabs, TabsList, TabsTrigger } from "@/shared/ui/tabs";
+import { PanelSectionGroup } from "@/shared/ui/PanelSectionGroup";
+import { Switch } from "@/shared/ui/switch";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 
 export function ProfileIngressRow({
   disabled,
+  disclosureIcon: DisclosureIcon = ChevronRight,
+  grouped = false,
   icon: Icon,
   label,
   onClick,
@@ -53,25 +49,21 @@ export function ProfileIngressRow({
   trailing,
 }: {
   disabled?: boolean;
-  icon: LucideIcon;
+  disclosureIcon?: LucideIcon;
+  grouped?: boolean;
+  icon?: LucideIcon;
   label: string;
-  onClick: () => void;
+  onClick?: () => void;
   testId: string;
   trailing?: React.ReactNode;
 }) {
   const trailingTitle = typeof trailing === "string" ? trailing : undefined;
 
-  return (
-    <button
-      className="flex w-full items-center gap-3 rounded-2xl bg-muted/20 px-4 py-2 text-left transition-colors hover:bg-muted/40 disabled:cursor-not-allowed disabled:opacity-50"
-      data-testid={testId}
-      disabled={disabled}
-      onClick={onClick}
-      type="button"
-    >
-      <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-muted/60">
-        <Icon className="h-4 w-4 text-muted-foreground" />
-      </span>
+  const content = (
+    <>
+      {Icon ? (
+        <Icon className="h-4 w-4 shrink-0 text-muted-foreground" />
+      ) : null}
       <span className="min-w-0 flex-1 text-sm font-medium text-foreground">
         {label}
       </span>
@@ -83,136 +75,46 @@ export function ProfileIngressRow({
           {trailing}
         </span>
       ) : null}
-      <ChevronRight className="h-4 w-4 shrink-0 text-muted-foreground" />
-    </button>
+      {onClick ? (
+        <DisclosureIcon className="h-4 w-4 shrink-0 text-muted-foreground" />
+      ) : null}
+    </>
+  );
+  const className = cn(
+    "flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left",
+    onClick &&
+      "transition-colors hover:bg-muted/40 disabled:cursor-not-allowed disabled:opacity-50",
   );
-}
-
-function useHorizontalDragScroll() {
-  const scrollRef = React.useRef<HTMLDivElement>(null);
-  const didDragRef = React.useRef(false);
-  const momentumFrameRef = React.useRef<number | null>(null);
-  const activeListenersRef = React.useRef<{
-    move: (event: PointerEvent) => void;
-    up: (event: PointerEvent) => void;
-  } | null>(null);
-
-  const stopMomentum = React.useCallback(() => {
-    if (momentumFrameRef.current !== null) {
-      cancelAnimationFrame(momentumFrameRef.current);
-      momentumFrameRef.current = null;
-    }
-  }, []);
-
-  const cleanupListeners = React.useCallback(() => {
-    const active = activeListenersRef.current;
-    if (!active) {
-      return;
-    }
-
-    window.removeEventListener("pointermove", active.move);
-    window.removeEventListener("pointerup", active.up);
-    window.removeEventListener("pointercancel", active.up);
-    activeListenersRef.current = null;
-  }, []);
-
-  React.useEffect(() => {
-    return () => {
-      cleanupListeners();
-      stopMomentum();
-    };
-  }, [cleanupListeners, stopMomentum]);
-
-  const handlePointerDown = React.useCallback(
-    (event: React.PointerEvent<HTMLDivElement>) => {
-      const element = scrollRef.current;
-      if (!element || event.button !== 0) {
-        return;
-      }
 
-      cleanupListeners();
-      stopMomentum();
-
-      const startX = event.clientX;
-      const startScrollLeft = element.scrollLeft;
-      let lastX = event.clientX;
-      let lastTime = performance.now();
-      let velocity = 0;
-      didDragRef.current = false;
-
-      const handleMove = (moveEvent: PointerEvent) => {
-        const now = performance.now();
-        const deltaX = moveEvent.clientX - startX;
-        if (!didDragRef.current && Math.abs(deltaX) > 4) {
-          didDragRef.current = true;
-        }
-
-        if (didDragRef.current) {
-          moveEvent.preventDefault();
-          element.scrollLeft = startScrollLeft - deltaX;
-
-          const dt = now - lastTime;
-          if (dt > 0) {
-            velocity = -(moveEvent.clientX - lastX) / dt;
-          }
-          lastX = moveEvent.clientX;
-          lastTime = now;
-        }
-      };
-
-      const handleUp = () => {
-        cleanupListeners();
-        window.setTimeout(() => {
-          didDragRef.current = false;
-        }, 0);
-
-        const minVelocity = 0.02;
-        if (!didDragRef.current || Math.abs(velocity) < minVelocity) {
-          return;
-        }
-
-        let frameTime = performance.now();
-        const frictionPerMs = 0.004;
-
-        const step = (now: number) => {
-          const dt = now - frameTime;
-          frameTime = now;
-
-          const maxScroll = element.scrollWidth - element.clientWidth;
-          element.scrollLeft = Math.max(
-            0,
-            Math.min(maxScroll, element.scrollLeft + velocity * dt),
-          );
+  let row: React.ReactNode;
+  if (!onClick) {
+    row = (
+      <div className={className} data-testid={testId}>
+        {content}
+      </div>
+    );
+  } else {
+    row = (
+      <button
+        className={cn(
+          className,
+          "focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring",
+        )}
+        data-testid={testId}
+        disabled={disabled}
+        onClick={onClick}
+        type="button"
+      >
+        {content}
+      </button>
+    );
+  }
 
-          if (element.scrollLeft <= 0 || element.scrollLeft >= maxScroll) {
-            momentumFrameRef.current = null;
-            return;
-          }
-
-          velocity *= Math.exp(-frictionPerMs * dt);
-          if (Math.abs(velocity) >= minVelocity) {
-            momentumFrameRef.current = requestAnimationFrame(step);
-          } else {
-            momentumFrameRef.current = null;
-          }
-        };
-
-        momentumFrameRef.current = requestAnimationFrame(step);
-      };
-
-      activeListenersRef.current = { move: handleMove, up: handleUp };
-      window.addEventListener("pointermove", handleMove);
-      window.addEventListener("pointerup", handleUp);
-      window.addEventListener("pointercancel", handleUp);
-    },
-    [cleanupListeners, stopMomentum],
+  return grouped ? (
+    row
+  ) : (
+    <PanelSectionGroup testId={`${testId}-section`}>{row}</PanelSectionGroup>
   );
-
-  return {
-    didDragRef,
-    onPointerDown: handlePointerDown,
-    scrollRef,
-  };
 }
 
 export function ProfileTabBar({
@@ -228,57 +130,57 @@ export function ProfileTabBar({
     trailing?: React.ReactNode;
   }>;
 }) {
-  const { didDragRef, onPointerDown, scrollRef } = useHorizontalDragScroll();
+  if (tabs.length === 0) {
+    return null;
+  }
+
+  const activeIndex = Math.max(
+    0,
+    tabs.findIndex((tab) => tab.id === activeTab),
+  );
 
   return (
-    <div
-      className="-mx-4 cursor-grab select-none overflow-x-auto px-4 scrollbar-none active:cursor-grabbing [&::-webkit-scrollbar]:hidden"
-      onPointerDown={onPointerDown}
-      ref={scrollRef}
+    <Tabs
+      className="w-full"
+      onValueChange={(value) => onTabChange(value as ProfilePanelTab)}
+      value={activeTab}
     >
-      <div
+      <TabsList
         aria-label="Profile sections"
-        className="flex w-max min-w-full justify-center gap-1.5"
-        role="tablist"
+        className="relative isolate grid h-9 w-full overflow-hidden rounded-lg bg-muted p-0.5"
+        data-testid="user-profile-tab-list"
+        style={{
+          gridTemplateColumns: `repeat(${tabs.length}, minmax(0, 1fr))`,
+        }}
       >
+        <div
+          aria-hidden="true"
+          className="absolute bottom-0.5 left-0.5 top-0.5 z-0 rounded-md bg-background shadow-sm transition-transform duration-[220ms] ease-[cubic-bezier(0.23,1,0.32,1)] motion-reduce:transition-none"
+          data-testid="user-profile-tab-indicator"
+          style={{
+            transform: `translateX(${activeIndex * 100}%)`,
+            width: `calc((100% - 4px) / ${tabs.length})`,
+          }}
+        />
         {tabs.map((tab) => {
-          const isActive = activeTab === tab.id;
-
           return (
-            <Button
-              aria-selected={isActive}
-              className="shrink-0 rounded-full"
+            <TabsTrigger
+              className="group relative z-10 h-full min-w-0 gap-1 rounded-md bg-transparent px-2 text-xs font-medium shadow-none transition-colors data-[state=active]:bg-transparent data-[state=active]:shadow-none"
               data-testid={`user-profile-tab-${tab.id}`}
               key={tab.id}
-              onClick={() => {
-                if (didDragRef.current) {
-                  return;
-                }
-                onTabChange(tab.id);
-              }}
-              role="tab"
-              size="sm"
-              type="button"
-              variant={isActive ? "secondary" : "ghost"}
+              value={tab.id}
             >
-              {tab.label}
+              <span className="truncate">{tab.label}</span>
               {tab.trailing ? (
-                <span
-                  className={cn(
-                    "inline-flex items-center leading-none text-2xs",
-                    isActive
-                      ? "text-secondary-foreground/80"
-                      : "text-muted-foreground",
-                  )}
-                >
+                <span className="inline-flex shrink-0 items-center leading-none text-2xs text-muted-foreground group-data-[state=active]:text-foreground/70">
                   {tab.trailing}
                 </span>
               ) : null}
-            </Button>
+            </TabsTrigger>
           );
         })}
-      </div>
-    </div>
+      </TabsList>
+    </Tabs>
   );
 }
 
@@ -286,26 +188,42 @@ export function ProfileInfoTabContent({
   activeTurns,
   activityAgent,
   agentInfoFields,
+  archiveActions,
+  canArchiveAgent,
+  canDeleteAgent,
   callerChannelId,
   channelIdToName,
-  instances,
   isArchived,
+  isDeleteAgentPending,
+  managedAgent,
+  onDeleteAgent,
+  onDuplicateAgent,
+  onExportAgent,
   onOpenActivity,
-  onOpenInstance,
+  onEditAgent,
   pubkey,
   showActivityIngress,
+  showInstructionBlock,
 }: {
   activeTurns: ActiveTurnSummary[];
   activityAgent: ProfileActivityAgent | null;
   agentInfoFields: ProfileField[];
+  archiveActions: IdentityArchiveActions;
+  canArchiveAgent: boolean;
+  canDeleteAgent: boolean;
   callerChannelId: string | null;
   channelIdToName: Record<string, string>;
-  instances: ManagedAgent[];
   isArchived: boolean;
+  isDeleteAgentPending: boolean;
+  managedAgent?: ManagedAgent;
+  onDeleteAgent: () => void;
+  onDuplicateAgent?: () => void;
+  onExportAgent?: () => void;
+  onEditAgent: () => void;
   onOpenActivity: (channelId?: string | null) => void;
-  onOpenInstance: (pubkey: string) => void;
   pubkey: string | null;
   showActivityIngress: boolean;
+  showInstructionBlock: boolean;
 }) {
   const infoFields: ProfileField[] = isArchived
     ? [
@@ -320,17 +238,26 @@ export function ProfileInfoTabContent({
       ]
     : agentInfoFields;
   const hasInfoFields = infoFields.length > 0;
-  const hasInstances = instances.length > 1;
+  const showArchiveAction =
+    canArchiveAgent && archiveActions.isArchived !== undefined;
   const feedScope = useProfileActivityFeedScope(activityAgent, activeTurns);
   const showLiveActivityEmbed =
     showActivityIngress && (feedScope.isLive || feedScope.hasFeedContent);
 
-  if (!hasInfoFields && !showActivityIngress && !hasInstances) {
+  if (
+    !hasInfoFields &&
+    !showArchiveAction &&
+    !canDeleteAgent &&
+    !onDuplicateAgent &&
+    !onExportAgent &&
+    !showActivityIngress &&
+    !showInstructionBlock
+  ) {
     return null;
   }
 
   return (
-    <div className="space-y-2">
+    <div className="space-y-4" data-testid="user-profile-info-sections">
       {showActivityIngress ? (
         showLiveActivityEmbed && activityAgent ? (
           <ProfileLiveActivityEmbed
@@ -351,14 +278,29 @@ export function ProfileInfoTabContent({
           />
         )
       ) : null}
-      {hasInfoFields ? <ProfileFieldGroup fields={infoFields} /> : null}
-      {hasInstances ? (
-        <ProfileInstancesSection
-          currentPubkey={pubkey}
-          instances={instances}
-          onOpenInstance={onOpenInstance}
-        />
+      {hasInfoFields || showInstructionBlock ? (
+        <ProfileSectionGroup testId="user-profile-info-section" title="Info">
+          {showInstructionBlock ? (
+            <ProfileIngressRow
+              grouped
+              label="Agent instructions"
+              onClick={onEditAgent}
+              testId="user-profile-agent-instruction-row"
+            />
+          ) : null}
+          <ProfileFieldRows fields={infoFields} />
+        </ProfileSectionGroup>
       ) : null}
+      <UserProfileAgentManagementRows
+        archiveActions={archiveActions}
+        canArchiveAgent={showArchiveAction}
+        canDeleteAgent={canDeleteAgent}
+        isDeletePending={isDeleteAgentPending}
+        managedAgent={managedAgent}
+        onDeleteAgent={onDeleteAgent}
+        onDuplicateAgent={onDuplicateAgent}
+        onExportAgent={onExportAgent}
+      />
     </div>
   );
 }
@@ -373,19 +315,22 @@ function ProfileInstancesSection({
   onOpenInstance: (pubkey: string) => void;
 }) {
   const [expanded, setExpanded] = React.useState(false);
+  const instanceCountLabel = `${instances.length} instance${instances.length === 1 ? "" : "s"}`;
 
   return (
-    <div className="overflow-hidden rounded-2xl bg-muted/20">
+    <ProfileSectionGroup
+      testId="user-profile-instances-section"
+      title="Instances"
+    >
       <button
         aria-expanded={expanded}
-        className="flex w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40"
+        className="flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
         data-testid="user-profile-instances"
         onClick={() => setExpanded((value) => !value)}
         type="button"
       >
-        <span className="min-w-0 flex-1 text-sm font-medium">Instances</span>
-        <span className="text-sm text-muted-foreground">
-          {instances.length}
+        <span className="min-w-0 flex-1 text-sm font-medium">
+          {instanceCountLabel}
         </span>
         <ChevronRight
           className={cn(
@@ -394,13 +339,12 @@ function ProfileInstancesSection({
           )}
         />
       </button>
-      {expanded ? (
-        <div className="border-t border-border/60 px-2 py-2">
-          {instances.map((instance) => {
+      {expanded
+        ? instances.map((instance) => {
             const isCurrent = instance.pubkey === currentPubkey;
             return (
               <button
-                className="flex w-full items-center gap-3 rounded-xl px-3 py-2 text-left transition-colors hover:bg-muted/40"
+                className="flex min-h-16 w-full items-center gap-3 px-4 py-3 text-left transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
                 data-testid={`user-profile-instance-${instance.pubkey}`}
                 key={instance.pubkey}
                 onClick={() => onOpenInstance(instance.pubkey)}
@@ -415,10 +359,9 @@ function ProfileInstancesSection({
                 <ChevronRight className="h-4 w-4 shrink-0 text-muted-foreground" />
               </button>
             );
-          })}
-        </div>
-      ) : null}
-    </div>
+          })
+        : null}
+    </ProfileSectionGroup>
   );
 }
 
@@ -809,57 +752,94 @@ function ArchiveStatusTooltip() {
 }
 
 export function ProfileRuntimeTabContent({
-  agentInstruction,
   autoRestartEnabled = false,
+  currentPubkey,
   diagnosticsFields,
   diagnosticsSummary,
+  configurationFields,
+  instances,
+  modelSettings,
   needsRestart = false,
   restartDiff = [],
+  startOnLaunchEnabled,
+  startOnLaunchPending = false,
   onOpenDiagnostics,
-  onOpenInstructions,
-  runtimeConfigurationFields,
-  runtimeSettingsFields,
+  onOpenInstance,
+  onToggleStartOnLaunch,
   showDiagnosticsIngress,
-  showInstructionBlock,
+  showPreviewHarnessLog = false,
 }: {
-  agentInstruction: string | null;
   /** Whether the per-agent auto-restart toggle is ON. */
   autoRestartEnabled?: boolean;
+  currentPubkey: string | null;
   diagnosticsFields: ProfileField[];
   diagnosticsSummary: React.ReactNode;
+  configurationFields: ProfileField[];
+  instances: ManagedAgent[];
+  modelSettings?: React.ReactNode;
   /** True when the running agent's config has drifted from what it was spawned with. */
   needsRestart?: boolean;
   /** The full itemised diff — shown uncapped in the Runtime banner. */
   restartDiff?: RestartDiffEntry[];
+  startOnLaunchEnabled?: boolean;
+  startOnLaunchPending?: boolean;
   onOpenDiagnostics: () => void;
-  onOpenInstructions: () => void;
-  runtimeConfigurationFields: ProfileField[];
-  runtimeSettingsFields: ProfileField[];
+  onOpenInstance: (pubkey: string) => void;
+  onToggleStartOnLaunch?: () => void;
   showDiagnosticsIngress: boolean;
-  showInstructionBlock: boolean;
+  showPreviewHarnessLog?: boolean;
 }) {
+  const startOnLaunchFieldIndex = configurationFields.findIndex(
+    (field) => field.label === "Start on launch",
+  );
+  const startOnLaunchField = configurationFields[startOnLaunchFieldIndex];
+  const configurationFieldsBeforeStartOnLaunch =
+    startOnLaunchFieldIndex >= 0
+      ? configurationFields.slice(0, startOnLaunchFieldIndex)
+      : configurationFields;
+  const configurationFieldsAfterStartOnLaunch =
+    startOnLaunchFieldIndex >= 0
+      ? configurationFields.slice(startOnLaunchFieldIndex + 1)
+      : [];
+  const [previewStartOnLaunchEnabled, setPreviewStartOnLaunchEnabled] =
+    React.useState(startOnLaunchField?.displayValue === "Yes");
+  const isRuntimePreview =
+    startOnLaunchField !== undefined && startOnLaunchEnabled === undefined;
+  const resolvedStartOnLaunchEnabled =
+    startOnLaunchEnabled ?? previewStartOnLaunchEnabled;
+  const canToggleStartOnLaunch =
+    isRuntimePreview || onToggleStartOnLaunch !== undefined;
+  const handleStartOnLaunchToggle = React.useCallback(() => {
+    if (startOnLaunchPending) return;
+    if (isRuntimePreview) {
+      setPreviewStartOnLaunchEnabled((enabled) => !enabled);
+      return;
+    }
+    onToggleStartOnLaunch?.();
+  }, [isRuntimePreview, onToggleStartOnLaunch, startOnLaunchPending]);
   const statusDiagnosticsFields = diagnosticsFields.filter(
     (field) => field.label === "Status",
   );
-  const detailDiagnosticsFields = diagnosticsFields.filter(
-    (field) => field.label !== "Last error" && field.label !== "Status",
-  );
-  const hasRuntimeRows =
-    runtimeConfigurationFields.length > 0 || runtimeSettingsFields.length > 0;
+  const hasActivityRows =
+    statusDiagnosticsFields.length > 0 ||
+    showDiagnosticsIngress ||
+    showPreviewHarnessLog;
+  const hasConfigurationRows = configurationFields.length > 0;
+  const hasInstances = instances.length > 0;
 
   if (
-    !hasRuntimeRows &&
     statusDiagnosticsFields.length === 0 &&
-    detailDiagnosticsFields.length === 0 &&
-    !showDiagnosticsIngress &&
-    !showInstructionBlock &&
+    !hasActivityRows &&
+    !hasConfigurationRows &&
+    !modelSettings &&
+    !hasInstances &&
     !needsRestart
   ) {
     return null;
   }
 
   return (
-    <div className="space-y-2">
+    <div className="space-y-4" data-testid="user-profile-runtime-sections">
       {needsRestart ? (
         <div
           className="flex items-start gap-3 rounded-2xl bg-amber-500/10 px-4 py-3"
@@ -881,36 +861,90 @@ export function ProfileRuntimeTabContent({
           </div>
         </div>
       ) : null}
-      {showInstructionBlock ? (
-        <div className="overflow-hidden rounded-2xl bg-muted/20">
-          <AgentInstructionRow
-            instruction={agentInstruction}
-            onOpenInstructions={onOpenInstructions}
-          />
-        </div>
-      ) : null}
-      {statusDiagnosticsFields.length > 0 ? (
-        <ProfileFieldGroup fields={statusDiagnosticsFields} />
-      ) : null}
-      {showDiagnosticsIngress ? (
-        <ProfileIngressRow
-          icon={Activity}
-          label="Harness Log"
-          onClick={onOpenDiagnostics}
-          testId="user-profile-diagnostics-ingress"
-          trailing={diagnosticsSummary}
-        />
+      {hasActivityRows ? (
+        <ProfileSectionGroup
+          testId="user-profile-runtime-activity-section"
+          title="Activity"
+        >
+          {statusDiagnosticsFields.length > 0 ? (
+            <ProfileFieldRows
+              fields={statusDiagnosticsFields}
+              variant="runtime"
+            />
+          ) : null}
+          {showDiagnosticsIngress ? (
+            <ProfileIngressRow
+              grouped
+              label="Harness log"
+              onClick={onOpenDiagnostics}
+              testId="user-profile-diagnostics-ingress"
+              trailing={diagnosticsSummary}
+            />
+          ) : showPreviewHarnessLog ? (
+            <ProfileIngressRow
+              grouped
+              label="Harness log"
+              testId="user-profile-diagnostics-ingress-preview"
+            />
+          ) : null}
+        </ProfileSectionGroup>
       ) : null}
-      {hasRuntimeRows ? (
-        <div className="overflow-hidden rounded-2xl bg-muted/20">
-          <AgentDetailsRows fields={runtimeConfigurationFields} />
-          {runtimeSettingsFields.length > 0 ? (
-            <ProfileFieldRows fields={runtimeSettingsFields} />
+      {hasConfigurationRows ? (
+        <ProfileSectionGroup
+          testId="user-profile-agent-configuration-section"
+          title="Agent configuration"
+        >
+          <ProfileFieldRows
+            fields={configurationFieldsBeforeStartOnLaunch}
+            variant="runtime"
+          />
+          {startOnLaunchField ? (
+            <div
+              aria-checked={resolvedStartOnLaunchEnabled}
+              aria-disabled={!canToggleStartOnLaunch || startOnLaunchPending}
+              aria-label={startOnLaunchField.label}
+              className={cn(
+                "flex min-h-16 items-center gap-3 px-4 py-3",
+                canToggleStartOnLaunch &&
+                  "cursor-pointer transition-colors hover:bg-muted/40 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring",
+              )}
+              data-testid={startOnLaunchField.testId}
+              onKeyDown={(event) => {
+                if (event.key !== "Enter" && event.key !== " ") return;
+                event.preventDefault();
+                handleStartOnLaunchToggle();
+              }}
+              onClick={
+                canToggleStartOnLaunch ? handleStartOnLaunchToggle : undefined
+              }
+              role="switch"
+              tabIndex={canToggleStartOnLaunch ? 0 : -1}
+            >
+              <span className="min-w-0 flex-1 text-sm font-medium text-foreground">
+                {startOnLaunchField.label}
+              </span>
+              <Switch
+                aria-hidden="true"
+                checked={resolvedStartOnLaunchEnabled}
+                data-testid={`${startOnLaunchField.testId}-toggle`}
+                disabled={!canToggleStartOnLaunch || startOnLaunchPending}
+                tabIndex={-1}
+              />
+            </div>
           ) : null}
-        </div>
+          <ProfileFieldRows
+            fields={configurationFieldsAfterStartOnLaunch}
+            variant="runtime"
+          />
+        </ProfileSectionGroup>
       ) : null}
-      {detailDiagnosticsFields.length > 0 ? (
-        <ProfileFieldGroup fields={detailDiagnosticsFields} />
+      {modelSettings}
+      {hasInstances ? (
+        <ProfileInstancesSection
+          currentPubkey={currentPubkey}
+          instances={instances}
+          onOpenInstance={onOpenInstance}
+        />
       ) : null}
     </div>
   );
diff --git a/desktop/src/features/profile/ui/UserProfilePanelUtils.ts b/desktop/src/features/profile/ui/UserProfilePanelUtils.ts
index 07f57803b4a..df09726fecb 100644
--- a/desktop/src/features/profile/ui/UserProfilePanelUtils.ts
+++ b/desktop/src/features/profile/ui/UserProfilePanelUtils.ts
@@ -31,13 +31,13 @@ export type ProfilePanelTab = "info" | "runtime" | "channels" | "memories";
 
 export const PROFILE_PANEL_VIEW_TITLES: Record<ProfilePanelView, string> = {
   summary: "Profile",
-  instructions: "Instructions",
+  instructions: "Agent instructions",
   info: "Agent info",
   configuration: "Runtime",
-  diagnostics: "Harness Log",
+  diagnostics: "Harness log",
   memories: "Memories",
   channels: "Channels",
-  logs: "Harness Log",
+  logs: "Harness log",
 };
 
 const PROFILE_PANEL_VIEWS = new Set<ProfilePanelView>(
diff --git a/desktop/src/features/profile/ui/UserProfilePopover.tsx b/desktop/src/features/profile/ui/UserProfilePopover.tsx
index 06295cc615c..a402285732d 100644
--- a/desktop/src/features/profile/ui/UserProfilePopover.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePopover.tsx
@@ -1,22 +1,11 @@
 import * as React from "react";
-import { useQueryClient } from "@tanstack/react-query";
 import { Activity, Headphones, MessageSquare } from "lucide-react";
-import { toast } from "sonner";
 
-import { useAppNavigation } from "@/app/navigation/useAppNavigation";
-import { useHuddle } from "@/features/huddle";
-import { formatHuddleActionError } from "@/features/huddle/lib/huddleError";
+import { useChannelsQuery } from "@/features/channels/hooks";
 import {
-  channelsQueryKey,
-  useChannelsQuery,
-  useOpenDmMutation,
-} from "@/features/channels/hooks";
-import {
-  useProfileQuery,
   useUserProfileQuery,
   useUsersBatchQuery,
 } from "@/features/profile/hooks";
-import { channelMessagesKey } from "@/features/messages/lib/messageQueryKeys";
 import {
   useRelayAgentsQuery,
   useManagedAgentsQuery,
@@ -33,18 +22,11 @@ import { usePresenceQuery } from "@/features/presence/hooks";
 import { useUserStatusQuery } from "@/features/user-status/hooks";
 import { StatusEmoji } from "@/features/user-status/ui/StatusEmoji";
 import { ProfileAvatarWithStatus } from "@/features/profile/ui/ProfileAvatarWithStatus";
-import {
-  createOptimisticMessage,
-  mergeTimelineCacheMessages,
-} from "@/features/messages/hooks";
-import { buildWaveMessageContent } from "@/features/messages/lib/waveMessage";
 import { useOpenAgentActivity } from "@/features/agents/useOpenAgentActivity";
 import { useProfilePanel } from "@/shared/context/ProfilePanelContext";
-import { sendChannelMessage } from "@/shared/api/tauri";
-import type { Channel, RelayEvent } from "@/shared/api/types";
-import { KIND_STREAM_MESSAGE } from "@/shared/constants/kinds";
 import { cn } from "@/shared/lib/cn";
 import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { useProfileInteractionActions } from "@/features/profile/ui/useProfileInteractionActions";
 
 import { Popover, PopoverAnchor, PopoverContent } from "@/shared/ui/popover";
 import { BotIdenticon } from "@/features/messages/ui/BotIdenticon";
@@ -90,43 +72,6 @@ function InfoBadge({ children }: { children: React.ReactNode }) {
   );
 }
 
-function findCachedOneToOneDm(
-  channels: Channel[] | undefined,
-  targetPubkey: string,
-  currentPubkey: string | undefined,
-) {
-  const normalizedTargetPubkey = normalizePubkey(targetPubkey);
-  const normalizedCurrentPubkey = currentPubkey
-    ? normalizePubkey(currentPubkey)
-    : null;
-
-  return (
-    channels?.find((channel) => {
-      if (channel.channelType !== "dm") {
-        return false;
-      }
-
-      const participantPubkeys =
-        channel.participantPubkeys.map(normalizePubkey);
-      if (!participantPubkeys.includes(normalizedTargetPubkey)) {
-        return false;
-      }
-
-      const otherParticipantPubkeys = normalizedCurrentPubkey
-        ? participantPubkeys.filter(
-            (participantPubkey) =>
-              participantPubkey !== normalizedCurrentPubkey,
-          )
-        : participantPubkeys;
-
-      return (
-        otherParticipantPubkeys.length === 1 &&
-        otherParticipantPubkeys[0] === normalizedTargetPubkey
-      );
-    }) ?? null
-  );
-}
-
 const TEXT_SWAP_BASE_CLASS =
   "col-start-1 row-start-1 min-w-0 truncate transition-[opacity,filter] duration-[250ms] ease-in-out motion-reduce:transition-none";
 const TEXT_SWAP_VISIBLE_CLASS = "opacity-100 blur-0";
@@ -181,17 +126,9 @@ export function UserProfilePopover({
   botIdenticonValue,
 }: UserProfilePopoverProps) {
   const [open, setOpen] = React.useState(false);
-  const [pendingAction, setPendingAction] = React.useState<
-    "message" | "huddle" | "wave" | null
-  >(null);
-  const isMountedRef = React.useRef(false);
   const hoverTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(
     null,
   );
-  const queryClient = useQueryClient();
-  const { goChannel } = useAppNavigation();
-  const openDmMutation = useOpenDmMutation();
-  const { isStarting: isStartingHuddle, startHuddle } = useHuddle();
   const profileQuery = useUserProfileQuery(open ? pubkey : undefined);
   const usersBatchQuery = useUsersBatchQuery(open ? [pubkey] : [], {
     enabled: open,
@@ -260,7 +197,6 @@ export function UserProfilePopover({
   const showProfileActions = currentPubkey !== undefined && !isSelf;
   const showHumanProfileActions =
     showProfileActions && !isBotProfile && !isAgentClassificationPending;
-  const selfProfileQuery = useProfileQuery(open && showProfileActions);
   const isCurrentUserOwner = ownsAuthorAgent(profile, currentPubkey);
   const viewerIsOwner = isCurrentUserOwner || isOwner === true;
   const showHuddleAction =
@@ -334,186 +270,31 @@ export function UserProfilePopover({
     [canOpenProfilePanel, clearHoverTimer, openProfilePanel, pubkey],
   );
 
-  const handleMessage = React.useCallback(async () => {
-    if (!showMessageAction || pendingAction !== null) return;
-
-    clearHoverTimer();
-    setPendingAction("message");
-
-    try {
-      const dm = await openDmMutation.mutateAsync({ pubkeys: [pubkey] });
-      await goChannel(dm.id);
-      if (isMountedRef.current) {
-        setOpen(false);
-      }
-    } catch (error) {
-      toast.error(
-        error instanceof Error
-          ? error.message
-          : "Failed to open direct message.",
-      );
-    } finally {
-      if (isMountedRef.current) {
-        setPendingAction(null);
-      }
-    }
-  }, [
-    clearHoverTimer,
-    goChannel,
-    openDmMutation,
-    pendingAction,
-    pubkey,
-    showMessageAction,
-  ]);
-
-  const handleHuddle = React.useCallback(async () => {
-    if (
-      !showProfileActions ||
-      !showHuddleAction ||
-      pendingAction !== null ||
-      isStartingHuddle
-    ) {
-      return;
-    }
-
-    clearHoverTimer();
-    setPendingAction("huddle");
-
-    try {
-      const dm = await openDmMutation.mutateAsync({ pubkeys: [pubkey] });
-      await goChannel(dm.id);
-      await startHuddle(dm.id, isBotProfile ? [pubkey] : []);
-      await queryClient.invalidateQueries({ queryKey: channelsQueryKey });
-      if (isMountedRef.current) {
-        setOpen(false);
-      }
-    } catch (error) {
-      toast.error(formatHuddleActionError(error, "start"));
-    } finally {
-      if (isMountedRef.current) {
-        setPendingAction(null);
-      }
-    }
-  }, [
-    clearHoverTimer,
-    goChannel,
+  const closeProfileActions = React.useCallback(() => setOpen(false), []);
+  const {
+    handleHuddle,
+    handleMessage,
+    handleWave,
+    isOpeningDm,
     isStartingHuddle,
-    openDmMutation,
-    pendingAction,
-    pubkey,
-    queryClient,
-    isBotProfile,
-    showHuddleAction,
-    showProfileActions,
-    startHuddle,
-  ]);
-
-  const handleWave = React.useCallback(async () => {
-    if (
-      !showProfileActions ||
-      !showHumanProfileActions ||
-      pendingAction !== null
-    ) {
-      return;
-    }
-
-    clearHoverTimer();
-    setPendingAction("wave");
-
-    try {
-      const identity = identityQuery.data;
-      if (!identity) {
-        throw new Error("No identity available for sending messages.");
-      }
-
-      const dm =
-        findCachedOneToOneDm(channelsQuery.data, pubkey, currentPubkey) ??
-        (await openDmMutation.mutateAsync({ pubkeys: [pubkey] }));
-      const senderName =
-        selfProfileQuery.data?.displayName?.trim() ||
-        identity.displayName.trim() ||
-        truncatePubkey(identity.pubkey);
-      const content = buildWaveMessageContent(senderName);
-      const queryKey = channelMessagesKey(dm.id);
-
-      await queryClient.cancelQueries({ queryKey });
-      const previousMessages =
-        queryClient.getQueryData<RelayEvent[]>(queryKey) ?? [];
-      const optimisticMessage = createOptimisticMessage(
-        dm.id,
-        content,
-        identity,
-        previousMessages,
-      );
-
-      queryClient.setQueryData<RelayEvent[]>(
-        queryKey,
-        mergeTimelineCacheMessages(previousMessages, optimisticMessage),
-      );
-
-      try {
-        await goChannel(dm.id);
-        if (isMountedRef.current) {
-          setOpen(false);
-        }
-
-        const result = await sendChannelMessage(dm.id, content);
-        queryClient.setQueryData<RelayEvent[]>(queryKey, (current = []) =>
-          mergeTimelineCacheMessages(current, {
-            id: result.eventId,
-            localKey: optimisticMessage.id,
-            pubkey: identity.pubkey,
-            created_at: result.createdAt,
-            kind: KIND_STREAM_MESSAGE,
-            tags: [
-              ["h", dm.id],
-              ["p", identity.pubkey],
-            ],
-            content: content.trim(),
-            sig: "",
-          }),
-        );
-      } catch (error) {
-        queryClient.setQueryData<RelayEvent[]>(queryKey, (current = []) =>
-          current.filter(
-            (message) =>
-              message.id !== optimisticMessage.id &&
-              message.localKey !== optimisticMessage.localKey,
-          ),
-        );
-        throw error;
-      }
-    } catch (error) {
-      toast.error(
-        error instanceof Error ? error.message : "Failed to send wave.",
-      );
-    } finally {
-      if (isMountedRef.current) {
-        setPendingAction(null);
-      }
-    }
-  }, [
-    channelsQuery.data,
-    clearHoverTimer,
-    currentPubkey,
-    goChannel,
-    identityQuery.data,
-    openDmMutation,
     pendingAction,
-    pubkey,
-    queryClient,
-    selfProfileQuery.data?.displayName,
-    showHumanProfileActions,
-    showProfileActions,
-  ]);
+  } = useProfileInteractionActions({
+    availability: {
+      huddle: showHuddleAction,
+      message: showMessageAction,
+      wave: showHumanProfileActions,
+    },
+    effectivePubkey: pubkey,
+    enabled: open,
+    isBot: isBotProfile,
+    isSelf,
+    onBeforeAction: clearHoverTimer,
+    onClose: closeProfileActions,
+    viewerIsOwner,
+  });
 
   React.useEffect(() => {
-    isMountedRef.current = true;
-
-    return () => {
-      isMountedRef.current = false;
-      clearHoverTimer();
-    };
+    return clearHoverTimer;
   }, [clearHoverTimer]);
 
   const TriggerElement = triggerElement;
@@ -691,9 +472,7 @@ export function UserProfilePopover({
                       aria-label="Wave"
                       className="buzz-wave-hover-trigger shrink-0 px-3 transition-transform duration-100 ease-out motion-reduce:transition-none motion-safe:active:scale-[0.97]"
                       data-testid={`user-profile-popover-wave-${pubkey}`}
-                      disabled={
-                        pendingAction !== null || openDmMutation.isPending
-                      }
+                      disabled={pendingAction !== null || isOpeningDm}
                       onClick={() => {
                         void handleWave();
                       }}
@@ -720,9 +499,7 @@ export function UserProfilePopover({
                     <Button
                       className="min-w-0 flex-1"
                       data-testid={`user-profile-popover-message-${pubkey}`}
-                      disabled={
-                        pendingAction !== null || openDmMutation.isPending
-                      }
+                      disabled={pendingAction !== null || isOpeningDm}
                       onClick={() => {
                         void handleMessage();
                       }}
@@ -747,7 +524,7 @@ export function UserProfilePopover({
                       data-testid={`user-profile-popover-huddle-${pubkey}`}
                       disabled={
                         pendingAction !== null ||
-                        openDmMutation.isPending ||
+                        isOpeningDm ||
                         isStartingHuddle
                       }
                       onClick={() => {
diff --git a/desktop/src/features/profile/ui/UserProfilePrimaryActions.tsx b/desktop/src/features/profile/ui/UserProfilePrimaryActions.tsx
index 254b556e86f..3185de50ff0 100644
--- a/desktop/src/features/profile/ui/UserProfilePrimaryActions.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePrimaryActions.tsx
@@ -1,10 +1,11 @@
 import type { LucideIcon } from "lucide-react";
+import type { ReactNode, Ref } from "react";
 import {
+  Hand,
+  Headphones,
   MessageSquare,
-  Pencil,
   Play,
   RefreshCw,
-  Sparkles,
   Square,
   UserMinus,
   UserPlus,
@@ -18,40 +19,47 @@ import type {
 import { useFeatureEnabled } from "@/shared/features";
 import { cn } from "@/shared/lib/cn";
 import { Spinner } from "@/shared/ui/spinner";
-import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 
 // ── Primary actions ──────────────────────────────────────────────────────────
 
 export function ProfilePrimaryActions({
+  actionGroupRef,
   agentActionDisabled,
   agentActionLabel,
   agentActionLive,
-  canEditAgent,
+  className,
+  concealed = false,
   followMutation,
+  huddlePending,
   isFollowing,
   messagePending,
   onAgentPrimaryAction,
   onAgentRestart,
-  onCreateCard,
-  onEditAgent,
+  onHuddle,
   onMessage,
+  onWave,
   pubkey,
   unfollowMutation,
+  wavePending,
 }: {
+  actionGroupRef?: Ref<HTMLDivElement>;
   agentActionDisabled?: boolean;
   agentActionLabel?: string;
   agentActionLive?: boolean;
-  canEditAgent: boolean;
+  className?: string;
+  concealed?: boolean;
   followMutation: ReturnType<typeof useFollowMutation>;
+  huddlePending?: boolean;
   isFollowing: boolean;
   messagePending?: boolean;
   onAgentPrimaryAction?: () => void;
   onAgentRestart?: () => void;
-  onCreateCard?: () => void;
-  onEditAgent: () => void;
+  onHuddle?: () => void;
   onMessage?: () => void;
+  onWave?: () => void;
   pubkey: string;
   unfollowMutation: ReturnType<typeof useUnfollowMutation>;
+  wavePending?: boolean;
 }) {
   const showFollowAction = useFeatureEnabled("pulse");
   const followToggleMutation = isFollowing ? unfollowMutation : followMutation;
@@ -65,38 +73,27 @@ export function ProfilePrimaryActions({
     });
   };
 
+  const hasActions =
+    showFollowAction ||
+    onWave !== undefined ||
+    onMessage !== undefined ||
+    onHuddle !== undefined ||
+    (onAgentPrimaryAction !== undefined && agentActionLabel !== undefined) ||
+    onAgentRestart !== undefined;
+
+  if (!hasActions) {
+    return null;
+  }
+
   return (
-    <div className="flex items-center justify-center gap-8">
-      {showFollowAction ? (
-        <ProfileQuickAction
-          active={isFollowing}
-          disabled={followToggleMutation.isPending}
-          icon={isFollowing ? UserMinus : UserPlus}
-          label={isFollowing ? "Unfollow" : "Follow"}
-          onClick={handleFollowClick}
-        />
-      ) : null}
-      {onMessage ? (
-        <ProfileQuickAction
-          disabled={messagePending}
-          icon={MessageSquare}
-          isLoading={messagePending}
-          label="Message"
-          onClick={onMessage}
-          testId="user-profile-message"
-        />
-      ) : null}
-      {canEditAgent ? (
-        <ProfileQuickAction
-          icon={Pencil}
-          label="Edit"
-          onClick={onEditAgent}
-          testId="user-profile-edit-agent"
-        />
-      ) : null}
+    <ProfileActionGroup
+      className={className}
+      concealed={concealed}
+      ref={actionGroupRef}
+    >
       {onAgentPrimaryAction && agentActionLabel ? (
-        <ProfileQuickAction
-          active={agentActionLive}
+        <ProfileActionTile
+          active
           disabled={agentActionDisabled}
           icon={agentActionLive ? Square : Play}
           label={agentActionLabel}
@@ -105,71 +102,113 @@ export function ProfilePrimaryActions({
         />
       ) : null}
       {onAgentRestart ? (
-        <ProfileQuickAction
+        <ProfileActionTile
           disabled={agentActionDisabled}
           icon={RefreshCw}
-          label="Restart Agent"
+          label="Restart agent"
           onClick={onAgentRestart}
           testId="user-profile-agent-restart"
         />
       ) : null}
-      {onCreateCard ? (
-        <ProfileQuickAction
-          icon={Sparkles}
-          label="Create card"
-          onClick={onCreateCard}
-          testId="user-profile-create-card"
+      {onMessage ? (
+        <ProfileActionTile
+          disabled={messagePending}
+          icon={MessageSquare}
+          isLoading={messagePending}
+          label="Message"
+          onClick={onMessage}
+          testId="user-profile-message"
+        />
+      ) : null}
+      {onHuddle ? (
+        <ProfileActionTile
+          disabled={huddlePending}
+          icon={Headphones}
+          isLoading={huddlePending}
+          label="Huddle"
+          onClick={onHuddle}
+          testId="user-profile-huddle"
         />
       ) : null}
-    </div>
+      {onWave ? (
+        <ProfileActionTile
+          disabled={wavePending}
+          icon={Hand}
+          isLoading={wavePending}
+          label="Wave"
+          onClick={onWave}
+          testId="user-profile-wave"
+        />
+      ) : null}
+      {showFollowAction ? (
+        <ProfileActionTile
+          active={isFollowing}
+          disabled={followToggleMutation.isPending}
+          icon={isFollowing ? UserMinus : UserPlus}
+          label={isFollowing ? "Unfollow" : "Follow"}
+          onClick={handleFollowClick}
+        />
+      ) : null}
+    </ProfileActionGroup>
   );
 }
 
 export function ProfilePersonaPrimaryActions({
-  canEditAgent,
+  actionGroupRef,
+  className,
+  concealed = false,
   disabled,
-  onCreateCard,
-  onEditAgent,
   onStartAgent,
 }: {
-  canEditAgent: boolean;
+  actionGroupRef?: Ref<HTMLDivElement>;
+  className?: string;
+  concealed?: boolean;
   disabled: boolean;
-  onCreateCard?: () => void;
-  onEditAgent: () => void;
   onStartAgent: () => void;
 }) {
   return (
-    <div className="flex items-center justify-center gap-8">
-      <ProfileQuickAction
+    <ProfileActionGroup
+      className={className}
+      concealed={concealed}
+      ref={actionGroupRef}
+    >
+      <ProfileActionTile
+        active
         disabled={disabled}
         icon={Play}
-        label="Start Agent"
+        label="Start agent"
         onClick={onStartAgent}
         testId="user-profile-start-agent"
       />
-      {canEditAgent ? (
-        <ProfileQuickAction
-          disabled={disabled}
-          icon={Pencil}
-          label="Edit"
-          onClick={onEditAgent}
-          testId="user-profile-edit-agent"
-        />
-      ) : null}
-      {onCreateCard ? (
-        <ProfileQuickAction
-          disabled={disabled}
-          icon={Sparkles}
-          label="Create card"
-          onClick={onCreateCard}
-          testId="user-profile-create-card"
-        />
-      ) : null}
+    </ProfileActionGroup>
+  );
+}
+
+function ProfileActionGroup({
+  children,
+  className,
+  concealed,
+  ref,
+}: {
+  children: ReactNode;
+  className?: string;
+  concealed: boolean;
+  ref?: Ref<HTMLDivElement>;
+}) {
+  return (
+    <div
+      aria-hidden={concealed || undefined}
+      className={cn("grid grid-flow-col auto-cols-fr gap-2", className)}
+      data-testid="user-profile-primary-actions"
+      inert={concealed || undefined}
+      ref={ref}
+    >
+      {children}
     </div>
   );
 }
 
-function ProfileQuickAction({
+function ProfileActionTile({
   active,
   disabled,
   icon: Icon,
@@ -187,31 +226,26 @@ function ProfileQuickAction({
   testId?: string;
 }) {
   return (
-    <Tooltip>
-      <TooltipTrigger asChild>
-        <button
-          aria-label={label}
-          className={cn(
-            "flex h-12 w-12 items-center justify-center rounded-full transition-colors disabled:cursor-not-allowed disabled:opacity-50",
-            active
-              ? "bg-foreground text-background hover:bg-foreground/90"
-              : "bg-muted/60 text-foreground hover:bg-muted/80",
-          )}
-          data-testid={testId}
-          disabled={disabled}
-          onClick={onClick}
-          type="button"
-        >
-          {isLoading ? (
-            <Spinner aria-hidden="true" className="h-4 w-4 border-2" />
-          ) : (
-            <Icon className="h-4 w-4" />
-          )}
-        </button>
-      </TooltipTrigger>
-      <TooltipContent align="center" side="top">
-        {label}
-      </TooltipContent>
-    </Tooltip>
+    <button
+      aria-label={label}
+      aria-busy={isLoading || undefined}
+      className={cn(
+        "flex min-h-20 w-full flex-col items-center justify-center gap-1.5 rounded-xl bg-muted px-2 py-3 text-center transition-colors hover:bg-muted/80 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50",
+        active && "bg-foreground text-background hover:bg-foreground/90",
+      )}
+      data-testid={testId}
+      disabled={disabled}
+      onClick={onClick}
+      type="button"
+    >
+      {isLoading ? (
+        <Spinner aria-hidden="true" className="h-5 w-5 border-2" />
+      ) : (
+        <Icon
+          className={cn("h-5 w-5 text-foreground", active && "text-background")}
+        />
+      )}
+      <span className="min-w-0 text-xs font-medium leading-tight">{label}</span>
+    </button>
   );
 }
diff --git a/desktop/src/features/profile/ui/UserProfileRuntimePreview.tsx b/desktop/src/features/profile/ui/UserProfileRuntimePreview.tsx
new file mode 100644
index 00000000000..2c7f7840059
--- /dev/null
+++ b/desktop/src/features/profile/ui/UserProfileRuntimePreview.tsx
@@ -0,0 +1,154 @@
+import {
+  AgentConfigSurfaceRows,
+  type AgentConfigPanelSection,
+} from "@/features/agents/ui/AgentConfigPanel";
+import type { ProfileField } from "@/features/profile/ui/UserProfilePanelFields";
+import { Badge } from "@/shared/ui/badge";
+import type { NormalizedField, RuntimeConfigSurface } from "@/shared/api/types";
+
+function previewField(value: string): NormalizedField {
+  return {
+    isRequired: false,
+    origin: "harnessDefault",
+    overriddenOrigin: null,
+    overriddenValue: null,
+    value,
+    writeVia: { type: "readOnly" },
+  };
+}
+
+const PROFILE_RUNTIME_PREVIEW: RuntimeConfigSurface = {
+  advanced: [
+    {
+      key: "workingDirectory",
+      label: "Working directory",
+      origin: "buzzExplicit",
+      schemaType: { type: "string" },
+      value: "~/Development/buzz",
+      writeVia: { type: "readOnly" },
+    },
+  ],
+  extensions: [{ enabled: true, kind: "stdio", name: "Buzz developer tools" }],
+  isPreSpawn: false,
+  normalized: {
+    contextLimit: previewField("200,000"),
+    maxOutputTokens: previewField("8,192"),
+    mode: previewField("Auto"),
+    model: previewField("claude-sonnet-4-20250514"),
+    provider: previewField("anthropic"),
+    systemPrompt: null,
+    thinkingEffort: previewField("High"),
+  },
+  runtimeId: "goose",
+  runtimeLabel: "Goose",
+  sources: {
+    acpConfigOptions: "available",
+    acpNative: "available",
+    configFile: "available",
+    configFilePath: "~/.config/goose/config.yaml",
+    envVars: "notApplicable",
+    mcpConfigFilePath: null,
+  },
+};
+
+const PROFILE_RUNTIME_PREVIEW_FIELDS: ProfileField[] = [
+  {
+    copyValue: "goose",
+    displayValue: "Goose",
+    label: "Runtime",
+    testId: "user-profile-runtime",
+  },
+  {
+    copyValue: "goose acp",
+    displayValue: "goose acp",
+    label: "ACP command",
+    testId: "user-profile-acp",
+  },
+  {
+    copyValue: "goose mcp",
+    displayValue: "goose mcp",
+    label: "MCP command",
+    testId: "user-profile-mcp",
+  },
+  {
+    displayValue: "Yes",
+    label: "Start on launch",
+    testId: "user-profile-start-on-launch",
+  },
+  {
+    displayValue: "Only the owner",
+    label: "Who can send instructions",
+    testId: "user-profile-respond-to",
+  },
+];
+
+const PROFILE_RUNTIME_PREVIEW_DIAGNOSTICS: ProfileField[] = [
+  {
+    displayNode: (
+      <Badge className="normal-case tracking-normal" variant="success">
+        Running
+      </Badge>
+    ),
+    displayValue: "Running",
+    label: "Status",
+    testId: "user-profile-agent-status",
+  },
+];
+
+function appendMissingPreviewFields(
+  fields: ProfileField[],
+  previewFields: ProfileField[],
+) {
+  const existingLabels = new Set(fields.map((field) => field.label));
+  return [
+    ...fields,
+    ...previewFields.filter((field) => !existingLabels.has(field.label)),
+  ];
+}
+
+export function fillRuntimePreviewFields(fields: ProfileField[]) {
+  return appendMissingPreviewFields(fields, PROFILE_RUNTIME_PREVIEW_FIELDS);
+}
+
+export function fillRuntimePreviewDiagnostics(fields: ProfileField[]) {
+  return appendMissingPreviewFields(
+    fields,
+    PROFILE_RUNTIME_PREVIEW_DIAGNOSTICS,
+  );
+}
+
+export function UserProfileRuntimePreviewNotice() {
+  return (
+    <div
+      className="rounded-xl border border-dashed border-border/70 bg-muted/20 px-3 py-2.5"
+      data-testid="user-profile-runtime-preview-notice"
+    >
+      <p className="text-sm font-medium text-foreground">
+        Preview runtime data
+      </p>
+      <p className="mt-0.5 text-xs leading-5 text-muted-foreground">
+        Staging doesn’t include every production runtime detail. Missing values
+        below use examples.
+      </p>
+    </div>
+  );
+}
+
+export function UserProfileConfigPreview({
+  onEdit,
+  sections,
+}: {
+  onEdit?: () => void;
+  sections: readonly AgentConfigPanelSection[];
+}) {
+  return (
+    <div data-testid="user-profile-runtime-preview">
+      <AgentConfigSurfaceRows
+        advancedMode="flat"
+        data={PROFILE_RUNTIME_PREVIEW}
+        onEdit={onEdit}
+        sections={sections}
+      />
+    </div>
+  );
+}
diff --git a/desktop/src/features/profile/ui/useProfileDmAction.ts b/desktop/src/features/profile/ui/useProfileDmAction.ts
deleted file mode 100644
index 0d5811333a7..00000000000
--- a/desktop/src/features/profile/ui/useProfileDmAction.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import * as React from "react";
-import { toast } from "sonner";
-
-type UseProfileDmActionOptions = {
-  effectivePubkey: string | null;
-  onClose: () => void;
-  onOpenDm?: (pubkeys: string[]) => Promise<void> | void;
-};
-
-export function useProfileDmAction({
-  effectivePubkey,
-  onClose,
-  onOpenDm,
-}: UseProfileDmActionOptions) {
-  const isMountedRef = React.useRef(false);
-  const [isOpeningDm, setIsOpeningDm] = React.useState(false);
-
-  React.useEffect(() => {
-    isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-
-  const handleMessage = React.useCallback(async () => {
-    if (!effectivePubkey || !onOpenDm || isOpeningDm) return;
-
-    setIsOpeningDm(true);
-
-    try {
-      await onOpenDm([effectivePubkey]);
-    } catch (error) {
-      if (!isMountedRef.current) return;
-      toast.error(
-        error instanceof Error
-          ? error.message
-          : "Failed to open direct message.",
-      );
-      setIsOpeningDm(false);
-      return;
-    }
-
-    if (!isMountedRef.current) return;
-    setIsOpeningDm(false);
-    onClose();
-  }, [effectivePubkey, isOpeningDm, onClose, onOpenDm]);
-
-  return { handleMessage, isOpeningDm };
-}
diff --git a/desktop/src/features/profile/ui/useProfileEditAgentRequest.ts b/desktop/src/features/profile/ui/useProfileEditAgentRequest.ts
new file mode 100644
index 00000000000..2cfefca01ab
--- /dev/null
+++ b/desktop/src/features/profile/ui/useProfileEditAgentRequest.ts
@@ -0,0 +1,33 @@
+import * as React from "react";
+
+import {
+  consumePendingOpenEditAgent,
+  type EditAgentFocusTarget,
+  subscribeOpenEditAgent,
+} from "@/features/agents/openEditAgentEvent";
+
+export function useProfileEditAgentRequest(pubkey: string | null | undefined) {
+  const [open, setOpen] = React.useState(false);
+  const [focus, setFocus] = React.useState<EditAgentFocusTarget | undefined>(
+    undefined,
+  );
+
+  React.useEffect(() => {
+    if (!pubkey) {
+      return;
+    }
+
+    const pending = consumePendingOpenEditAgent(pubkey);
+    if (pending !== false) {
+      setFocus(pending === true ? undefined : pending);
+      setOpen(true);
+    }
+
+    return subscribeOpenEditAgent(pubkey, (nextFocus) => {
+      setFocus(nextFocus);
+      setOpen(true);
+    });
+  }, [pubkey]);
+
+  return { focus, open, setFocus, setOpen };
+}
diff --git a/desktop/src/features/profile/ui/useProfileInteractionActions.ts b/desktop/src/features/profile/ui/useProfileInteractionActions.ts
new file mode 100644
index 00000000000..f5ee47a7702
--- /dev/null
+++ b/desktop/src/features/profile/ui/useProfileInteractionActions.ts
@@ -0,0 +1,285 @@
+import { useQueryClient } from "@tanstack/react-query";
+import * as React from "react";
+import { toast } from "sonner";
+
+import { useAppNavigation } from "@/app/navigation/useAppNavigation";
+import {
+  channelsQueryKey,
+  useChannelsQuery,
+  useOpenDmMutation,
+} from "@/features/channels/hooks";
+import { useHuddle } from "@/features/huddle";
+import { formatHuddleActionError } from "@/features/huddle/lib/huddleError";
+import {
+  createOptimisticMessage,
+  mergeTimelineCacheMessages,
+} from "@/features/messages/hooks";
+import { channelMessagesKey } from "@/features/messages/lib/messageQueryKeys";
+import { buildWaveMessageContent } from "@/features/messages/lib/waveMessage";
+import { useProfileQuery } from "@/features/profile/hooks";
+import { useIdentityQuery } from "@/shared/api/hooks";
+import { sendChannelMessage } from "@/shared/api/tauri";
+import type { Channel, RelayEvent } from "@/shared/api/types";
+import { KIND_STREAM_MESSAGE } from "@/shared/constants/kinds";
+import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+
+export type ProfileInteractionAction = "huddle" | "message" | "wave";
+
+type ProfileInteractionAvailability = {
+  huddle: boolean;
+  message: boolean;
+  wave: boolean;
+};
+
+function findCachedOneToOneDm(
+  channels: Channel[] | undefined,
+  targetPubkey: string,
+  currentPubkey: string | undefined,
+) {
+  const normalizedTargetPubkey = normalizePubkey(targetPubkey);
+  const normalizedCurrentPubkey = currentPubkey
+    ? normalizePubkey(currentPubkey)
+    : null;
+
+  return (
+    channels?.find((channel) => {
+      if (channel.channelType !== "dm") {
+        return false;
+      }
+
+      const participantPubkeys =
+        channel.participantPubkeys.map(normalizePubkey);
+      if (!participantPubkeys.includes(normalizedTargetPubkey)) {
+        return false;
+      }
+
+      const otherParticipantPubkeys = normalizedCurrentPubkey
+        ? participantPubkeys.filter(
+            (participantPubkey) =>
+              participantPubkey !== normalizedCurrentPubkey,
+          )
+        : participantPubkeys;
+
+      return (
+        otherParticipantPubkeys.length === 1 &&
+        otherParticipantPubkeys[0] === normalizedTargetPubkey
+      );
+    }) ?? null
+  );
+}
+
+export function useProfileInteractionActions({
+  availability,
+  effectivePubkey,
+  enabled,
+  isBot,
+  isSelf,
+  onBeforeAction,
+  onClose,
+  viewerIsOwner,
+}: {
+  availability?: ProfileInteractionAvailability;
+  effectivePubkey: string | null;
+  enabled: boolean;
+  isBot: boolean;
+  isSelf: boolean;
+  onBeforeAction?: () => void;
+  onClose: () => void;
+  viewerIsOwner: boolean | undefined;
+}) {
+  const [pendingAction, setPendingAction] =
+    React.useState<ProfileInteractionAction | null>(null);
+  const isMountedRef = React.useRef(false);
+  const queryClient = useQueryClient();
+  const { goChannel } = useAppNavigation();
+  const openDmMutation = useOpenDmMutation();
+  const openDm = openDmMutation.mutateAsync;
+  const channelsQuery = useChannelsQuery();
+  const identityQuery = useIdentityQuery();
+  const { isStarting: isStartingHuddle, startHuddle } = useHuddle();
+
+  const canInteract = enabled && !isSelf && effectivePubkey !== null;
+  const canWave = canInteract && (availability?.wave ?? !isBot);
+  const canMessage =
+    canInteract &&
+    (availability?.message ?? (!isBot || viewerIsOwner === true));
+  const canHuddle = canInteract && (availability?.huddle ?? canMessage);
+  const selfProfileQuery = useProfileQuery(enabled && canWave);
+
+  React.useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+
+  const runAction = React.useCallback(
+    async (
+      action: ProfileInteractionAction,
+      operation: (targetPubkey: string) => Promise<void>,
+    ) => {
+      if (!effectivePubkey || pendingAction !== null) {
+        return;
+      }
+
+      onBeforeAction?.();
+      setPendingAction(action);
+      try {
+        await operation(effectivePubkey);
+      } catch (error) {
+        if (action === "huddle") {
+          toast.error(formatHuddleActionError(error, "start"));
+        } else {
+          toast.error(
+            error instanceof Error
+              ? error.message
+              : action === "wave"
+                ? "Couldn't send the wave."
+                : "Couldn't open the direct message.",
+          );
+        }
+      } finally {
+        if (isMountedRef.current) {
+          setPendingAction(null);
+        }
+      }
+    },
+    [effectivePubkey, onBeforeAction, pendingAction],
+  );
+
+  const handleMessage = React.useCallback(() => {
+    if (!canMessage) {
+      return;
+    }
+
+    void runAction("message", async (targetPubkey) => {
+      const dm = await openDm({ pubkeys: [targetPubkey] });
+      await goChannel(dm.id);
+      if (isMountedRef.current) {
+        onClose();
+      }
+    });
+  }, [canMessage, goChannel, onClose, openDm, runAction]);
+
+  const handleHuddle = React.useCallback(() => {
+    if (!canHuddle || isStartingHuddle) {
+      return;
+    }
+
+    void runAction("huddle", async (targetPubkey) => {
+      const dm = await openDm({ pubkeys: [targetPubkey] });
+      await goChannel(dm.id);
+      await startHuddle(dm.id, isBot ? [targetPubkey] : []);
+      await queryClient.invalidateQueries({ queryKey: channelsQueryKey });
+      if (isMountedRef.current) {
+        onClose();
+      }
+    });
+  }, [
+    canHuddle,
+    goChannel,
+    isBot,
+    isStartingHuddle,
+    onClose,
+    openDm,
+    queryClient,
+    runAction,
+    startHuddle,
+  ]);
+
+  const handleWave = React.useCallback(() => {
+    if (!canWave) {
+      return;
+    }
+
+    void runAction("wave", async (targetPubkey) => {
+      const identity = identityQuery.data;
+      if (!identity) {
+        throw new Error("No identity is available to send messages.");
+      }
+
+      const dm =
+        findCachedOneToOneDm(
+          channelsQuery.data,
+          targetPubkey,
+          identity.pubkey,
+        ) ?? (await openDm({ pubkeys: [targetPubkey] }));
+      const senderName =
+        selfProfileQuery.data?.displayName?.trim() ||
+        identity.displayName.trim() ||
+        truncatePubkey(identity.pubkey);
+      const content = buildWaveMessageContent(senderName);
+      const queryKey = channelMessagesKey(dm.id);
+
+      await queryClient.cancelQueries({ queryKey });
+      const previousMessages =
+        queryClient.getQueryData<RelayEvent[]>(queryKey) ?? [];
+      const optimisticMessage = createOptimisticMessage(
+        dm.id,
+        content,
+        identity,
+        previousMessages,
+      );
+
+      queryClient.setQueryData<RelayEvent[]>(
+        queryKey,
+        mergeTimelineCacheMessages(previousMessages, optimisticMessage),
+      );
+
+      try {
+        await goChannel(dm.id);
+        if (isMountedRef.current) {
+          onClose();
+        }
+
+        const result = await sendChannelMessage(dm.id, content);
+        queryClient.setQueryData<RelayEvent[]>(queryKey, (current = []) =>
+          mergeTimelineCacheMessages(current, {
+            id: result.eventId,
+            localKey: optimisticMessage.id,
+            pubkey: identity.pubkey,
+            created_at: result.createdAt,
+            kind: KIND_STREAM_MESSAGE,
+            tags: [
+              ["h", dm.id],
+              ["p", identity.pubkey],
+            ],
+            content: content.trim(),
+            sig: "",
+          }),
+        );
+      } catch (error) {
+        queryClient.setQueryData<RelayEvent[]>(queryKey, (current = []) =>
+          current.filter(
+            (message) =>
+              message.id !== optimisticMessage.id &&
+              message.localKey !== optimisticMessage.localKey,
+          ),
+        );
+        throw error;
+      }
+    });
+  }, [
+    canWave,
+    channelsQuery.data,
+    goChannel,
+    identityQuery.data,
+    onClose,
+    openDm,
+    queryClient,
+    runAction,
+    selfProfileQuery.data?.displayName,
+  ]);
+
+  return {
+    canHuddle,
+    canMessage,
+    canWave,
+    handleHuddle,
+    handleMessage,
+    handleWave,
+    isOpeningDm: openDmMutation.isPending,
+    isStartingHuddle,
+    pendingAction,
+  };
+}
diff --git a/desktop/src/features/projects/repoSyncHooks.ts b/desktop/src/features/projects/repoSyncHooks.ts
index 50ce5cbd92a..b52cd0e7545 100644
--- a/desktop/src/features/projects/repoSyncHooks.ts
+++ b/desktop/src/features/projects/repoSyncHooks.ts
@@ -51,7 +51,7 @@ export function useProjectRepoSyncStatusQuery(
     },
     staleTime: 10_000,
     refetchInterval,
-    refetchOnWindowFocus: true,
+    refetchOnWindowFocus: false,
     retry: 1,
   });
 }
diff --git a/desktop/src/features/pulse/focusRefetchPolicy.test.mjs b/desktop/src/features/pulse/focusRefetchPolicy.test.mjs
index b03487785b0..93fc851e95d 100644
--- a/desktop/src/features/pulse/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/pulse/focusRefetchPolicy.test.mjs
@@ -54,12 +54,12 @@ test("pulse: skips fresh focus refetch", async () => {
   );
 });
 
-test("pulse: refetches genuinely stale data on focus", async () => {
+test("pulse: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: pulseFocusRefetchPolicy.staleTime + 1,
       policy: pulseFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
diff --git a/desktop/src/features/pulse/hooks.ts b/desktop/src/features/pulse/hooks.ts
index 867deeac17e..6b061ae73fe 100644
--- a/desktop/src/features/pulse/hooks.ts
+++ b/desktop/src/features/pulse/hooks.ts
@@ -25,7 +25,7 @@ export const PULSE_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy shared by all pulse queries; consumed by focusRefetchPolicy.test.mjs. */
 export const pulseFocusRefetchPolicy = {
   staleTime: PULSE_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 // ── Query keys ──────────────────────────────────────────────────────────────
diff --git a/desktop/src/features/user-status/focusRefetchPolicy.test.mjs b/desktop/src/features/user-status/focusRefetchPolicy.test.mjs
index 05e503eb862..98c90bd942b 100644
--- a/desktop/src/features/user-status/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/user-status/focusRefetchPolicy.test.mjs
@@ -54,12 +54,12 @@ test("user-status: skips fresh focus refetch", async () => {
   );
 });
 
-test("user-status: refetches genuinely stale data on focus", async () => {
+test("user-status: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: userStatusFocusRefetchPolicy.staleTime + 1,
       policy: userStatusFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
diff --git a/desktop/src/features/user-status/hooks.ts b/desktop/src/features/user-status/hooks.ts
index c75adb1445b..96137ffaec5 100644
--- a/desktop/src/features/user-status/hooks.ts
+++ b/desktop/src/features/user-status/hooks.ts
@@ -47,7 +47,7 @@ export const USER_STATUS_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy for the user-status query; consumed by focusRefetchPolicy.test.mjs. */
 export const userStatusFocusRefetchPolicy = {
   staleTime: USER_STATUS_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 export function useUserStatusQuery(pubkeys: string[]) {
diff --git a/desktop/src/features/workflows/focusRefetchPolicy.test.mjs b/desktop/src/features/workflows/focusRefetchPolicy.test.mjs
index 60d816b7f37..b8ac89f4b80 100644
--- a/desktop/src/features/workflows/focusRefetchPolicy.test.mjs
+++ b/desktop/src/features/workflows/focusRefetchPolicy.test.mjs
@@ -58,13 +58,13 @@ test("workflow-list: skips focus refetch when data is fresh (< 10s)", async () =
   );
 });
 
-test("workflow-list: refetches on focus when data is stale (> 10s)", async () => {
+test("workflow-list: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: workflowListFocusRefetchPolicy.staleTime + 1,
       policy: workflowListFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
 
@@ -78,13 +78,13 @@ test("workflow-runs: skips focus refetch when data is fresh (< 10s)", async () =
   );
 });
 
-test("workflow-runs: refetches on focus when data is stale (> 10s)", async () => {
+test("workflow-runs: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: workflowRunsFocusRefetchPolicy.staleTime + 1,
       policy: workflowRunsFocusRefetchPolicy,
     }),
-    1,
+    0,
   );
 });
 
@@ -98,12 +98,107 @@ test("run-approvals: skips focus refetch when data is fresh (< 5 min)", async ()
   );
 });
 
-test("run-approvals: refetches on focus when data is stale (> 5 min)", async () => {
+test("run-approvals: does not refetch stale data on focus", async () => {
   assert.equal(
     await focusRefetchCount({
       ageMs: runApprovalsFocusRefetchPolicy.staleTime + 1,
       policy: runApprovalsFocusRefetchPolicy,
     }),
-    1,
+    0,
+  );
+});
+
+test("foreground refresh targets workflow gaps and repo sync", async () => {
+  const { shouldRefreshQueryOnForeground } = await import("./hooks.ts");
+  assert.equal(shouldRefreshQueryOnForeground(["workflows", "c"], []), true);
+  assert.equal(
+    shouldRefreshQueryOnForeground(["workflows-all", "c"], []),
+    true,
+  );
+  assert.equal(
+    shouldRefreshQueryOnForeground(["workflow-runs", "w"], []),
+    true,
+  );
+  assert.equal(
+    shouldRefreshQueryOnForeground(
+      ["workflow-runs", "w"],
+      [{ status: "completed" }],
+    ),
+    true,
+  );
+  assert.equal(
+    shouldRefreshQueryOnForeground(
+      ["workflow-runs", "w"],
+      [{ status: "running" }],
+    ),
+    false,
   );
+  assert.equal(
+    shouldRefreshQueryOnForeground(
+      ["project", "p", "repo-sync-status", "default"],
+      undefined,
+    ),
+    true,
+  );
+  assert.equal(
+    shouldRefreshQueryOnForeground(["project", "p", "issues"], []),
+    false,
+  );
+  assert.equal(shouldRefreshQueryOnForeground(["run-approvals"], []), false);
+});
+
+test("foreground refresh query contract includes only stale active targets", async () => {
+  const { shouldRefreshQueryOnForeground } = await import("./hooks.ts");
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  const fetches = [];
+  const subscribe = (queryKey, data, updatedAt) => {
+    queryClient.setQueryData(queryKey, data, { updatedAt });
+    const observer = new QueryObserver(queryClient, {
+      queryKey,
+      queryFn: async () => {
+        fetches.push(queryKey.join(":"));
+        return data;
+      },
+      refetchOnMount: false,
+      staleTime: 10_000,
+    });
+    return observer.subscribe(() => {});
+  };
+  const staleAt = Date.now() - 20_000;
+  const freshAt = Date.now();
+  const unsubscribers = [
+    subscribe(["workflows", "stale-active"], [], staleAt),
+    subscribe(["workflows", "fresh-active"], [], freshAt),
+    subscribe(
+      ["project", "p", "repo-sync-status", "default"],
+      { aheadCount: 1 },
+      staleAt,
+    ),
+    subscribe(
+      ["workflow-runs", "inactive"],
+      [{ status: "completed" }],
+      staleAt,
+    ),
+    subscribe(["workflow-runs", "active"], [{ status: "running" }], staleAt),
+  ];
+  queryClient.setQueryData(["workflows-all", "inactive-cache"], [], {
+    updatedAt: staleAt,
+  });
+
+  await queryClient.refetchQueries({
+    predicate: (query) =>
+      shouldRefreshQueryOnForeground(query.queryKey, query.state.data),
+    stale: true,
+    type: "active",
+  });
+
+  assert.deepEqual(fetches.sort(), [
+    "project:p:repo-sync-status:default",
+    "workflow-runs:inactive",
+    "workflows:stale-active",
+  ]);
+  for (const unsubscribe of unsubscribers) unsubscribe();
+  queryClient.clear();
 });
diff --git a/desktop/src/features/workflows/hooks.ts b/desktop/src/features/workflows/hooks.ts
index e10825ceae5..a8bb1d6f581 100644
--- a/desktop/src/features/workflows/hooks.ts
+++ b/desktop/src/features/workflows/hooks.ts
@@ -1,3 +1,4 @@
+import * as React from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 import type { WorkflowRun, WorkflowRunStatus } from "@/shared/api/types";
@@ -19,10 +20,8 @@ import {
 } from "@/shared/api/tauriWorkflows";
 
 /** Stale gate for workflow list queries (useChannelWorkflowsQuery, allWorkflowsQuery).
- * These queries have no poll and no relay push subscription; invalidateWorkflowListQueries
- * only fires for mutations performed by this renderer, so remote workflow creates/edits/deletes
- * surface only via refetch on focus return.  10 s suppresses rapid focus-flip burst refetches
- * while keeping remote changes visible on the next focus return. */
+ * These queries have no poll and no relay push subscription; foreground return
+ * explicitly refreshes them after the interaction-first activation boundary. */
 export const WORKFLOW_LIST_FOCUS_STALE_TIME_MS = 10_000;
 /** Keeps focused polling for run approvals at the established 10-second cadence. */
 export const RUN_APPROVALS_REFETCH_INTERVAL_MS = 10_000;
@@ -44,21 +43,51 @@ export const RUN_APPROVALS_FOCUS_STALE_TIME_MS = 5 * 60_000;
 /** Focus-refetch policy for workflow list queries; consumed by focusRefetchPolicy.test.mjs. */
 export const workflowListFocusRefetchPolicy = {
   staleTime: WORKFLOW_LIST_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 /** Focus-refetch policy for the workflow-runs query; consumed by focusRefetchPolicy.test.mjs. */
 export const workflowRunsFocusRefetchPolicy = {
   staleTime: WORKFLOW_RUNS_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
 /** Focus-refetch policy for the run-approvals query; consumed by focusRefetchPolicy.test.mjs. */
 export const runApprovalsFocusRefetchPolicy = {
   staleTime: RUN_APPROVALS_FOCUS_STALE_TIME_MS,
-  refetchOnWindowFocus: true,
+  refetchOnWindowFocus: false,
 } as const;
 
+export function shouldRefreshQueryOnForeground(
+  queryKey: readonly unknown[],
+  data: unknown,
+): boolean {
+  const family = queryKey[0];
+  if (family === "workflows" || family === "workflows-all") return true;
+  if (family === "project" && queryKey[2] === "repo-sync-status") return true;
+  if (family !== "workflow-runs") return false;
+  const runs = data as WorkflowRun[] | undefined;
+  return !runs?.some((run) => isActiveWorkflowRunStatus(run.status));
+}
+
+export function useForegroundQueryRefresh(): void {
+  const queryClient = useQueryClient();
+  const appFocused = useAppFocused();
+  const wasFocused = React.useRef(appFocused);
+  React.useEffect(() => {
+    const returnedToForeground = appFocused && !wasFocused.current;
+    wasFocused.current = appFocused;
+    if (!returnedToForeground) return;
+
+    void queryClient.refetchQueries({
+      predicate: (query) =>
+        shouldRefreshQueryOnForeground(query.queryKey, query.state.data),
+      stale: true,
+      type: "active",
+    });
+  }, [appFocused, queryClient]);
+}
+
 export const allWorkflowsQueryKey = (channelIdKey: string) =>
   ["workflows-all", channelIdKey] as const;
 export const workflowsQueryKey = (channelId: string) =>
diff --git a/desktop/src/shared/api/useRelayResumeTriggers.test.mjs b/desktop/src/shared/api/useRelayResumeTriggers.test.mjs
new file mode 100644
index 00000000000..4ed98c2924b
--- /dev/null
+++ b/desktop/src/shared/api/useRelayResumeTriggers.test.mjs
@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+
+import { installRelayResumeTriggers } from "./useRelayResumeTriggers.ts";
+
+const originalDocument = globalThis.document;
+const originalWindow = globalThis.window;
+
+afterEach(() => {
+  if (originalDocument === undefined) delete globalThis.document;
+  else globalThis.document = originalDocument;
+  if (originalWindow === undefined) delete globalThis.window;
+  else globalThis.window = originalWindow;
+});
+
+function installEventStub() {
+  let visibilityState = "visible";
+  const documentListeners = new Map();
+  const windowListeners = new Map();
+  const add = (listeners, type, listener) => {
+    const values = listeners.get(type) ?? new Set();
+    values.add(listener);
+    listeners.set(type, values);
+  };
+  const remove = (listeners, type, listener) => {
+    const values = listeners.get(type);
+    values?.delete(listener);
+    if (values?.size === 0) listeners.delete(type);
+  };
+  globalThis.document = {
+    get visibilityState() {
+      return visibilityState;
+    },
+    addEventListener: (type, listener) =>
+      add(documentListeners, type, listener),
+    removeEventListener: (type, listener) =>
+      remove(documentListeners, type, listener),
+  };
+  globalThis.window = {
+    addEventListener: (type, listener) => add(windowListeners, type, listener),
+    removeEventListener: (type, listener) =>
+      remove(windowListeners, type, listener),
+  };
+  return {
+    documentListeners,
+    windowListeners,
+    emitDocument(type) {
+      for (const listener of documentListeners.get(type) ?? []) listener();
+    },
+    emitWindow(type) {
+      for (const listener of windowListeners.get(type) ?? []) listener();
+    },
+    setVisibility(value) {
+      visibilityState = value;
+    },
+  };
+}
+
+describe("relay resume triggers", () => {
+  it("defers and coalesces foreground signals", () => {
+    const stub = installEventStub();
+    const scheduled = [];
+    let attempts = 0;
+    const dispose = installRelayResumeTriggers(
+      () => attempts++,
+      (callback) => {
+        const pending = { callback, cancelled: false };
+        scheduled.push(pending);
+        return () => {
+          pending.cancelled = true;
+        };
+      },
+    );
+
+    stub.emitWindow("focus");
+    stub.emitWindow("online");
+    stub.emitDocument("visibilitychange");
+    assert.equal(attempts, 0, "resume is not attempted in the event turn");
+    assert.equal(scheduled.length, 1, "foreground burst is coalesced");
+
+    scheduled[0].callback();
+    assert.equal(attempts, 1);
+    dispose();
+    assert.equal(stub.documentListeners.size, 0);
+    assert.equal(stub.windowListeners.size, 0);
+  });
+
+  it("cancels a pending resume when hidden", () => {
+    const stub = installEventStub();
+    let pending;
+    let attempts = 0;
+    installRelayResumeTriggers(
+      () => attempts++,
+      (callback) => {
+        pending = {
+          cancelled: false,
+          run() {
+            if (!this.cancelled) callback();
+          },
+        };
+        return () => {
+          pending.cancelled = true;
+        };
+      },
+    );
+
+    stub.emitWindow("focus");
+    stub.setVisibility("hidden");
+    stub.emitDocument("visibilitychange");
+    assert.equal(pending.cancelled, true);
+    pending.run();
+    assert.equal(attempts, 0, "hidden state suppresses pending resume");
+  });
+
+  it("cancels a pending resume on dispose", () => {
+    const stub = installEventStub();
+    let pending;
+    let attempts = 0;
+    const dispose = installRelayResumeTriggers(
+      () => attempts++,
+      (callback) => {
+        pending = {
+          cancelled: false,
+          run() {
+            if (!this.cancelled) callback();
+          },
+        };
+        return () => {
+          pending.cancelled = true;
+        };
+      },
+    );
+
+    stub.emitWindow("focus");
+    dispose();
+    pending.run();
+    assert.equal(attempts, 0);
+    assert.equal(stub.documentListeners.size, 0);
+    assert.equal(stub.windowListeners.size, 0);
+  });
+});
diff --git a/desktop/src/shared/api/useRelayResumeTriggers.ts b/desktop/src/shared/api/useRelayResumeTriggers.ts
index abb2e5d49ba..48c08545e5b 100644
--- a/desktop/src/shared/api/useRelayResumeTriggers.ts
+++ b/desktop/src/shared/api/useRelayResumeTriggers.ts
@@ -2,11 +2,46 @@ import * as React from "react";
 
 import { relayClient } from "@/shared/api/relayClient";
 import { shouldTriggerResumeReconnect } from "@/shared/api/relayResumeTriggerPolicy";
+import { scheduleAfterForegroundReady } from "@/shared/lib/foregroundReady";
+
+type ScheduleForegroundWork = (callback: () => void) => () => void;
+
+export function installRelayResumeTriggers(
+  attempt: () => void,
+  schedule: ScheduleForegroundWork = scheduleAfterForegroundReady,
+): () => void {
+  let cancelPendingResume: (() => void) | null = null;
+  const scheduleAttempt = () => {
+    if (cancelPendingResume) return;
+    cancelPendingResume = schedule(() => {
+      cancelPendingResume = null;
+      attempt();
+    });
+  };
+  const onVisibilityChange = () => {
+    if (document.visibilityState === "visible") scheduleAttempt();
+    else {
+      cancelPendingResume?.();
+      cancelPendingResume = null;
+    }
+  };
+
+  window.addEventListener("online", scheduleAttempt);
+  window.addEventListener("focus", scheduleAttempt);
+  document.addEventListener("visibilitychange", onVisibilityChange);
+
+  return () => {
+    cancelPendingResume?.();
+    window.removeEventListener("online", scheduleAttempt);
+    window.removeEventListener("focus", scheduleAttempt);
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+  };
+}
 
 /**
  * Event-driven reconnect triggers: network `online`, window `focus`, and
- * visibility→visible each attempt an immediate `resumeReconnect()` when the
- * relay session is degraded (reconnecting/stalled), rate-limited by
+ * visibility→visible coalesce a foreground-ready `resumeReconnect()` attempt
+ * when the relay session is degraded (reconnecting/stalled), rate-limited by
  * `RESUME_TRIGGER_MIN_INTERVAL_MS`.
  *
  * Rationale (CMD+R gap audit G1): without these, recovery rides solely on
@@ -43,18 +78,6 @@ export function useRelayResumeTriggers(): void {
       void relayClient.resumeReconnect().catch(() => {});
     };
 
-    const onVisibilityChange = () => {
-      if (document.visibilityState === "visible") attempt();
-    };
-
-    window.addEventListener("online", attempt);
-    window.addEventListener("focus", attempt);
-    document.addEventListener("visibilitychange", onVisibilityChange);
-
-    return () => {
-      window.removeEventListener("online", attempt);
-      window.removeEventListener("focus", attempt);
-      document.removeEventListener("visibilitychange", onVisibilityChange);
-    };
+    return installRelayResumeTriggers(attempt);
   }, []);
 }
diff --git a/desktop/src/shared/layout/AuxiliaryPanel/index.ts b/desktop/src/shared/layout/AuxiliaryPanel/index.ts
index 72724302d20..974a696999a 100644
--- a/desktop/src/shared/layout/AuxiliaryPanel/index.ts
+++ b/desktop/src/shared/layout/AuxiliaryPanel/index.ts
@@ -1,6 +1,7 @@
 export { AuxiliaryPanel } from "@/shared/layout/AuxiliaryPanelShell";
 export { AuxiliaryPanelBody } from "@/shared/layout/AuxiliaryPanelBody";
 export {
+  AUXILIARY_PANEL_DEFAULT_SURFACE_CLASS,
   AuxiliaryPanelHeader,
   AuxiliaryPanelHeaderActions,
   AuxiliaryPanelHeaderGroup,
diff --git a/desktop/src/shared/layout/AuxiliaryPanelHeader.tsx b/desktop/src/shared/layout/AuxiliaryPanelHeader.tsx
index 08c41f24d15..5140c4d8d52 100644
--- a/desktop/src/shared/layout/AuxiliaryPanelHeader.tsx
+++ b/desktop/src/shared/layout/AuxiliaryPanelHeader.tsx
@@ -55,6 +55,8 @@ type AuxiliaryPanelTitleContentProps = React.ComponentProps<"h2">;
 type AuxiliaryPanelSurface = "default" | "soft" | "transparent";
 
 const AUXILIARY_PANEL_HEADER_HEIGHT_CLASS = "pt-13";
+export const AUXILIARY_PANEL_DEFAULT_SURFACE_CLASS =
+  "bg-background/80 backdrop-blur-md supports-[backdrop-filter]:bg-background/70 dark:bg-background/70 dark:backdrop-blur-xl dark:supports-[backdrop-filter]:bg-background/55";
 const AUXILIARY_PANEL_CLOSE_LABEL = "Close panel";
 const AUXILIARY_PANEL_CLOSE_TEST_ID = "auxiliary-panel-close";
 const AUXILIARY_PANEL_RESIZE_BORDER_CLASS =
@@ -80,7 +82,7 @@ function getAuxiliaryPanelSurfaceClass(surface: AuxiliaryPanelSurface) {
     return "bg-background/75 backdrop-blur-md supports-[backdrop-filter]:bg-background/65 dark:bg-background/45 dark:backdrop-blur-xl dark:supports-[backdrop-filter]:bg-background/35";
   }
 
-  return "bg-background/80 backdrop-blur-md supports-[backdrop-filter]:bg-background/70 dark:bg-background/70 dark:backdrop-blur-xl dark:supports-[backdrop-filter]:bg-background/55";
+  return AUXILIARY_PANEL_DEFAULT_SURFACE_CLASS;
 }
 
 type AuxiliaryPanelHeaderBackdropProps = {
diff --git a/desktop/src/shared/lib/foregroundReady.test.mjs b/desktop/src/shared/lib/foregroundReady.test.mjs
new file mode 100644
index 00000000000..c5b01f4a8f2
--- /dev/null
+++ b/desktop/src/shared/lib/foregroundReady.test.mjs
@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+
+import { scheduleAfterForegroundReady } from "./foregroundReady.ts";
+
+const originalWindow = globalThis.window;
+
+afterEach(() => {
+  if (originalWindow === undefined) delete globalThis.window;
+  else globalThis.window = originalWindow;
+});
+
+function installSchedulerStub({ animationFrame = true } = {}) {
+  const tasks = new Map();
+  const frames = new Map();
+  let nextId = 0;
+  globalThis.window = {
+    setTimeout(callback) {
+      const id = ++nextId;
+      tasks.set(id, callback);
+      return id;
+    },
+    clearTimeout(id) {
+      tasks.delete(id);
+    },
+    ...(animationFrame
+      ? {
+          requestAnimationFrame(callback) {
+            const id = ++nextId;
+            frames.set(id, callback);
+            return id;
+          },
+          cancelAnimationFrame(id) {
+            frames.delete(id);
+          },
+        }
+      : {}),
+  };
+  const runFirst = (queue, argument) => {
+    const entry = queue.entries().next().value;
+    assert.ok(entry, "expected queued work");
+    const [id, callback] = entry;
+    queue.delete(id);
+    callback(argument);
+  };
+  return {
+    frames,
+    tasks,
+    runTask: () => runFirst(tasks),
+    runFrame: () => runFirst(frames, 0),
+  };
+}
+
+describe("scheduleAfterForegroundReady", () => {
+  it("runs after task, animation frame, and trailing task", () => {
+    const stub = installSchedulerStub();
+    let calls = 0;
+
+    scheduleAfterForegroundReady(() => calls++);
+    assert.equal(calls, 0);
+    stub.runTask();
+    assert.equal(calls, 0);
+    stub.runFrame();
+    assert.equal(calls, 0);
+    stub.runTask();
+    assert.equal(calls, 1);
+  });
+
+  it("falls back to two tasks when animation frames are unavailable", () => {
+    const stub = installSchedulerStub({ animationFrame: false });
+    let calls = 0;
+
+    scheduleAfterForegroundReady(() => calls++);
+    stub.runTask();
+    assert.equal(calls, 0);
+    stub.runTask();
+    assert.equal(calls, 1);
+  });
+
+  it("cancels work at every scheduling stage", () => {
+    for (const cancelAfter of ["schedule", "task", "frame"]) {
+      const stub = installSchedulerStub();
+      let calls = 0;
+      const cancel = scheduleAfterForegroundReady(() => calls++);
+      if (cancelAfter !== "schedule") stub.runTask();
+      if (cancelAfter === "frame") stub.runFrame();
+      cancel();
+
+      assert.equal(stub.tasks.size, 0, `${cancelAfter}: tasks cleared`);
+      assert.equal(stub.frames.size, 0, `${cancelAfter}: frames cleared`);
+      assert.equal(calls, 0, `${cancelAfter}: callback suppressed`);
+    }
+  });
+});
diff --git a/desktop/src/shared/lib/foregroundReady.ts b/desktop/src/shared/lib/foregroundReady.ts
new file mode 100644
index 00000000000..461d09943bf
--- /dev/null
+++ b/desktop/src/shared/lib/foregroundReady.ts
@@ -0,0 +1,45 @@
+/**
+ * Run foreground-resume work only after the activation event has returned,
+ * the browser has painted one frame, and a following task gets a turn.
+ *
+ * A single timeout is not enough: it can run before the activating click is
+ * delivered. The task -> frame -> task sequence gives WebKit an interaction
+ * boundary before query refresh, reconnect, and polling resume work begins.
+ */
+export function scheduleAfterForegroundReady(callback: () => void): () => void {
+  if (typeof window === "undefined") {
+    callback();
+    return () => {};
+  }
+
+  let cancelled = false;
+  let frameId: number | null = null;
+  let trailingTaskId: number | null = null;
+
+  const leadingTaskId = window.setTimeout(() => {
+    if (cancelled) return;
+    const afterFrame = () => {
+      if (cancelled) return;
+      trailingTaskId = window.setTimeout(() => {
+        if (!cancelled) callback();
+      }, 0);
+    };
+
+    if (typeof window.requestAnimationFrame === "function") {
+      frameId = window.requestAnimationFrame(afterFrame);
+    } else {
+      trailingTaskId = window.setTimeout(() => {
+        if (!cancelled) callback();
+      }, 0);
+    }
+  }, 0);
+
+  return () => {
+    cancelled = true;
+    window.clearTimeout(leadingTaskId);
+    if (frameId !== null && typeof window.cancelAnimationFrame === "function") {
+      window.cancelAnimationFrame(frameId);
+    }
+    if (trailingTaskId !== null) window.clearTimeout(trailingTaskId);
+  };
+}
diff --git a/desktop/src/shared/lib/useDocumentVisible.test.mjs b/desktop/src/shared/lib/useDocumentVisible.test.mjs
index 80f1799e0ce..ed7dc05de9e 100644
--- a/desktop/src/shared/lib/useDocumentVisible.test.mjs
+++ b/desktop/src/shared/lib/useDocumentVisible.test.mjs
@@ -38,6 +38,8 @@ function installVisibilityStub() {
   let focused = true;
   const documentListeners = new Map();
   const windowListeners = new Map();
+  const tasks = [];
+  const frames = [];
   globalThis.document = {
     get visibilityState() {
       return visibilityState;
@@ -65,10 +67,29 @@ function installVisibilityStub() {
       listeners?.delete(listener);
       if (listeners?.size === 0) windowListeners.delete(type);
     },
+    setTimeout(callback) {
+      tasks.push(callback);
+      return tasks.length;
+    },
+    clearTimeout() {},
+    requestAnimationFrame(callback) {
+      frames.push(callback);
+      return frames.length;
+    },
+    cancelAnimationFrame() {},
   };
   return {
     documentListeners,
     windowListeners,
+    flushLeadingTask() {
+      tasks.shift()?.();
+    },
+    flushFrame() {
+      frames.shift()?.(0);
+    },
+    flushTrailingTask() {
+      tasks.shift()?.();
+    },
     setFocused(value) {
       focused = value;
     },
@@ -105,6 +126,18 @@ describe("document visibility", () => {
 
     stub.setFocused(true);
     for (const listener of stub.windowListeners.get("focus")) listener();
+    assert.deepEqual(
+      focusedStates,
+      [false],
+      "focus resume must not notify inside the activation turn",
+    );
+    stub.flushLeadingTask();
+    assert.deepEqual(focusedStates, [false]);
+    stub.flushFrame();
+    assert.deepEqual(focusedStates, [false]);
+    stub.flushTrailingTask();
+    assert.deepEqual(focusedStates, [false, true]);
+
     stub.setVisibility("hidden");
     for (const listener of stub.documentListeners.get("visibilitychange"))
       listener();
@@ -164,7 +197,7 @@ describe("visibility-gated hooks", () => {
     dom.window.close();
   });
 
-  it("focused polling pauses on blur and refreshes immediately on focus", async () => {
+  it("focused polling pauses on blur and resumes after activation yields", async () => {
     const dom = new JSDOM(
       "<!doctype html><html><body><div id='root'></div></body></html>",
     );
@@ -199,6 +232,10 @@ describe("visibility-gated hooks", () => {
     assert.deepEqual(observed, [1_000, false]);
     focused = true;
     await act(async () => window.dispatchEvent(new window.Event("focus")));
+    assert.deepEqual(observed, [1_000, false]);
+    await act(
+      async () => new Promise((resolve) => window.setTimeout(resolve, 10)),
+    );
     assert.deepEqual(observed, [1_000, false, 1_000]);
 
     await act(async () => root.unmount());
diff --git a/desktop/src/shared/lib/useDocumentVisible.ts b/desktop/src/shared/lib/useDocumentVisible.ts
index 3368e5bde7b..3dc23861f09 100644
--- a/desktop/src/shared/lib/useDocumentVisible.ts
+++ b/desktop/src/shared/lib/useDocumentVisible.ts
@@ -1,5 +1,7 @@
 import * as React from "react";
 
+import { scheduleAfterForegroundReady } from "@/shared/lib/foregroundReady";
+
 export function isDocumentVisible(): boolean {
   if (typeof document === "undefined") return true;
   return document.visibilityState === "visible";
@@ -35,11 +37,25 @@ export function subscribeAppFocus(
     return () => {};
   }
 
-  const handleFocusChange = () => listener(isAppFocused());
+  let cancelPendingResume: (() => void) | null = null;
+  const handleFocusChange = () => {
+    cancelPendingResume?.();
+    cancelPendingResume = null;
+    const focused = isAppFocused();
+    if (!focused) {
+      listener(false);
+      return;
+    }
+    cancelPendingResume = scheduleAfterForegroundReady(() => {
+      cancelPendingResume = null;
+      if (isAppFocused()) listener(true);
+    });
+  };
   document.addEventListener("visibilitychange", handleFocusChange);
   window.addEventListener("focus", handleFocusChange);
   window.addEventListener("blur", handleFocusChange);
   return () => {
+    cancelPendingResume?.();
     document.removeEventListener("visibilitychange", handleFocusChange);
     window.removeEventListener("focus", handleFocusChange);
     window.removeEventListener("blur", handleFocusChange);
@@ -54,12 +70,36 @@ export function useDocumentVisible(): boolean {
   return visible;
 }
 
-export function useAppFocused(): boolean {
-  const [focused, setFocused] = React.useState(isAppFocused);
+const appFocusStoreListeners = new Set<() => void>();
+let appFocusStoreSnapshot = isAppFocused();
+let stopAppFocusStore: (() => void) | null = null;
+
+function subscribeAppFocusStore(listener: () => void): () => void {
+  appFocusStoreListeners.add(listener);
+  if (!stopAppFocusStore) {
+    appFocusStoreSnapshot = isAppFocused();
+    stopAppFocusStore = subscribeAppFocus((focused) => {
+      if (appFocusStoreSnapshot === focused) return;
+      appFocusStoreSnapshot = focused;
+      for (const storeListener of appFocusStoreListeners) storeListener();
+    });
+  }
 
-  React.useEffect(() => subscribeAppFocus(setFocused), []);
+  return () => {
+    appFocusStoreListeners.delete(listener);
+    if (appFocusStoreListeners.size === 0) {
+      stopAppFocusStore?.();
+      stopAppFocusStore = null;
+    }
+  };
+}
 
-  return focused;
+export function useAppFocused(): boolean {
+  return React.useSyncExternalStore(
+    subscribeAppFocusStore,
+    () => appFocusStoreSnapshot,
+    () => true,
+  );
 }
 
 export function useFocusedRefetchInterval(
diff --git a/desktop/src/shared/ui/HoverCopyIndicator.tsx b/desktop/src/shared/ui/HoverCopyIndicator.tsx
new file mode 100644
index 00000000000..1e279aec28b
--- /dev/null
+++ b/desktop/src/shared/ui/HoverCopyIndicator.tsx
@@ -0,0 +1,78 @@
+import { Check, Copy } from "lucide-react";
+import * as React from "react";
+import { toast } from "sonner";
+
+import { writeTextToClipboard } from "@/shared/lib/clipboard";
+import { cn } from "@/shared/lib/cn";
+
+export function useCopyFeedback({
+  label,
+  value,
+}: {
+  label: string;
+  value: string;
+}) {
+  const [copied, setCopied] = React.useState(false);
+  const resetTimerRef = React.useRef<number | null>(null);
+
+  React.useEffect(
+    () => () => {
+      if (resetTimerRef.current !== null) {
+        window.clearTimeout(resetTimerRef.current);
+      }
+    },
+    [],
+  );
+
+  const copy = React.useCallback(async () => {
+    try {
+      await writeTextToClipboard(value);
+      setCopied(true);
+      if (resetTimerRef.current !== null) {
+        window.clearTimeout(resetTimerRef.current);
+      }
+      resetTimerRef.current = window.setTimeout(() => {
+        setCopied(false);
+        resetTimerRef.current = null;
+      }, 1_500);
+      toast.success(`Copied ${label.toLowerCase()}`);
+    } catch {
+      toast.error(`Couldn't copy ${label.toLowerCase()}.`);
+    }
+  }, [label, value]);
+
+  return { copied, copy };
+}
+
+export function HoverCopyIndicator({
+  copied,
+  testId,
+}: {
+  copied: boolean;
+  testId?: string;
+}) {
+  return (
+    <span
+      aria-hidden="true"
+      className={cn(
+        "relative h-4 w-4 shrink-0 transition-opacity duration-150 ease-out motion-reduce:transition-none group-hover:opacity-100 group-focus-within:opacity-100",
+        copied ? "opacity-100" : "opacity-0",
+      )}
+      data-copied={copied}
+      data-testid={testId}
+    >
+      <Copy
+        className={cn(
+          "absolute inset-0 h-4 w-4 transition-[opacity,transform] duration-150 ease-[cubic-bezier(0.23,1,0.32,1)] motion-reduce:transition-none",
+          copied ? "scale-95 opacity-0" : "scale-100 opacity-100",
+        )}
+      />
+      <Check
+        className={cn(
+          "absolute inset-0 h-4 w-4 text-primary transition-[opacity,transform] duration-150 ease-[cubic-bezier(0.23,1,0.32,1)] motion-reduce:transition-none",
+          copied ? "scale-100 opacity-100" : "scale-95 opacity-0",
+        )}
+      />
+    </span>
+  );
+}
diff --git a/desktop/src/shared/ui/PanelSectionGroup.tsx b/desktop/src/shared/ui/PanelSectionGroup.tsx
new file mode 100644
index 00000000000..54a849a29ae
--- /dev/null
+++ b/desktop/src/shared/ui/PanelSectionGroup.tsx
@@ -0,0 +1,52 @@
+import type { ReactNode } from "react";
+
+import { cn } from "@/shared/lib/cn";
+
+export function PanelSectionGroup({
+  children,
+  className,
+  description,
+  headerAction,
+  testId,
+  title,
+}: {
+  children: ReactNode;
+  className?: string;
+  description?: ReactNode;
+  headerAction?: ReactNode;
+  testId?: string;
+  title?: ReactNode;
+}) {
+  const hasHeader = Boolean(title || description || headerAction);
+
+  return (
+    <section className={cn("space-y-1", className)} data-testid={testId}>
+      {hasHeader ? (
+        <div
+          className="flex min-h-7 items-center gap-3 px-4"
+          data-slot="panel-section-header"
+        >
+          <div className="min-w-0 flex-1">
+            {title ? (
+              <h2 className="text-xs font-semibold text-muted-foreground/70">
+                {title}
+              </h2>
+            ) : null}
+            {description ? (
+              <p className="mt-0.5 text-xs font-normal text-muted-foreground/70">
+                {description}
+              </p>
+            ) : null}
+          </div>
+          {headerAction ? <div className="shrink-0">{headerAction}</div> : null}
+        </div>
+      ) : null}
+      <div
+        className="divide-y divide-border/55 overflow-hidden rounded-xl border border-border/70 bg-background/70"
+        data-slot="panel-section-card"
+      >
+        {children}
+      </div>
+    </section>
+  );
+}
diff --git a/desktop/src/shared/ui/PubKey.tsx b/desktop/src/shared/ui/PubKey.tsx
index b6d79156744..153801787ba 100644
--- a/desktop/src/shared/ui/PubKey.tsx
+++ b/desktop/src/shared/ui/PubKey.tsx
@@ -25,6 +25,8 @@ type PubKeyProps = {
    * decisions must be made against the whole key.
    */
   variant?: "compact" | "full";
+  /** Render compact keys as text when a parent row owns the interaction. */
+  interactive?: boolean;
   className?: string;
   testId?: string;
 };
@@ -77,6 +79,7 @@ function PubKeyDetails({ pubkey }: { pubkey: string }) {
 export function PubKey({
   pubkey,
   variant = "compact",
+  interactive = true,
   className,
   testId,
 }: PubKeyProps) {
@@ -139,6 +142,14 @@ export function PubKey({
     );
   }
 
+  if (!interactive) {
+    return (
+      <span className={cn("font-mono", className)} data-testid={testId}>
+        {truncatePubkey(pubkey)}
+      </span>
+    );
+  }
+
   return (
     <Popover onOpenChange={setOpen} open={open}>
       <PopoverTrigger asChild>
diff --git a/desktop/src/shared/ui/link-preview-attachment.tsx b/desktop/src/shared/ui/link-preview-attachment.tsx
index 743d2471ef2..1fb449c9da3 100644
--- a/desktop/src/shared/ui/link-preview-attachment.tsx
+++ b/desktop/src/shared/ui/link-preview-attachment.tsx
@@ -1,5 +1,7 @@
 import type { ResolvedLinkPreview } from "@/shared/lib/useResolvedLinkPreviews";
 import { useLinkPreviewStyle } from "@/shared/lib/linkPreviewStylePreference";
+import { rewriteRelayUrl } from "@/shared/lib/mediaUrl";
+import { useMediaProxyPort } from "@/shared/lib/useMediaProxyPort";
 import { CompactLinkPreviewAttachment } from "@/shared/ui/compact-link-preview-attachment";
 import {
   type LinkPreviewImageLightboxComponent,
@@ -21,6 +23,16 @@ export function LinkPreviewAttachment({
   preview: ResolvedLinkPreview;
   showControls?: boolean;
 }) {
+  useMediaProxyPort();
+  const renderedPreview = {
+    ...preview,
+    faviconDataUrl: preview.faviconDataUrl
+      ? rewriteRelayUrl(preview.faviconDataUrl)
+      : null,
+    imageDataUrl: preview.imageDataUrl
+      ? rewriteRelayUrl(preview.imageDataUrl)
+      : null,
+  };
   const style = useLinkPreviewStyle();
   if (style === "rich") {
     return (
@@ -29,7 +41,7 @@ export function LinkPreviewAttachment({
         ImageLightbox={ImageLightbox}
         onOpen={onOpen}
         onRemove={onRemove}
-        preview={preview}
+        preview={renderedPreview}
         showControls={showControls}
       />
     );
@@ -40,7 +52,7 @@ export function LinkPreviewAttachment({
       className={className}
       onOpen={onOpen}
       onRemove={onRemove}
-      preview={preview}
+      preview={renderedPreview}
       showControls={showControls}
     />
   );
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index 46bda44ffb7..298b59249cb 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -61,6 +61,10 @@ import type {
   RawInstallRuntimeResult,
   RuntimeFileConfigSubset,
 } from "@/shared/api/tauri";
+import {
+  ensureRelayOriginFetch,
+  resetMediaCaches,
+} from "@/shared/lib/mediaUrl";
 import { normalizePubkey } from "@/shared/lib/pubkey";
 import {
   isValidLinkPreviewSnapshotCanonicalUrl,
@@ -309,6 +313,10 @@ type E2eConfig = {
     /** Reject successive mock `join_channel` calls, then resume. */
     joinChannelErrors?: string[];
     channelsReadDelayMs?: number;
+    /** Return not-modified for this many reads before resuming full payloads. */
+    channelsNotModifiedResponses?: number;
+    /** When true, a matching knownHash returns a not-modified channel payload. */
+    honorChannelsKnownHash?: boolean;
     /** Number of seeded rows in the deep-history fixture. Defaults to 600. */
     deepHistoryMessageCount?: number;
     feedReadError?: string;
@@ -318,6 +326,8 @@ type E2eConfig = {
     applyCommunityDelayMs?: number;
     openDmDelayMs?: number;
     sendMessageDelayMs?: number;
+    /** Hold the media proxy at port 0 until the E2E release seam is invoked. */
+    mediaProxyInitiallyUnavailable?: boolean;
     /** Hold mock send live echoes until the E2E release seam is invoked. */
     deferSendMessageLiveEcho?: boolean;
     /** Close the first channel-window live REQ; its retry is accepted. */
@@ -1101,6 +1111,8 @@ declare global {
       command: string;
       payload: unknown;
     }>;
+    /** Release a mock media proxy held at port 0 and return its ready port. */
+    __BUZZ_E2E_RELEASE_MEDIA_PROXY__?: () => number;
     /** Release mock send events that were stored but withheld from live subscribers. */
     __BUZZ_E2E_RELEASE_SEND_MESSAGE_LIVE_ECHO__?: () => number;
     __BUZZ_E2E_EMIT_MEDIA_UPLOAD_PHASE__?: (input: {
@@ -1340,6 +1352,7 @@ declare global {
     __BUZZ_E2E_MUTATE_CHANNEL__?: (opts: {
       channelId: string;
       channelType?: "stream" | "forum" | "dm";
+      description?: string;
       removeMemberPubkey?: string;
     }) => void;
     /**
@@ -1390,6 +1403,7 @@ const CHANNEL_WINDOW_AUX_DELETION_KINDS = new Set([
 // in e2e (instead of the `buzz-media://` fallback). The reaction guard
 // asserts against this exact port.
 const MOCK_MEDIA_PROXY_PORT = 54321;
+let mockMediaProxyPort = MOCK_MEDIA_PROXY_PORT;
 
 // A relay-hosted custom emoji used by the reaction guard. Its URL matches
 // `rewriteRelayUrl()`'s `/media/{64-hex}.{ext}` pattern on the relay origin, so
@@ -5699,7 +5713,10 @@ function buildLastMessages(
   return map;
 }
 
-async function handleGetChannels(config: E2eConfig | undefined) {
+async function handleGetChannels(
+  payload: unknown,
+  config: E2eConfig | undefined,
+) {
   const channelsReadDelayMs = config?.mock?.channelsReadDelayMs ?? 0;
   if (channelsReadDelayMs > 0) {
     await new Promise((resolve) =>
@@ -5716,15 +5733,25 @@ async function handleGetChannels(config: E2eConfig | undefined) {
 
   const identity = getIdentity(config);
   if (!identity) {
-    // The hash is constant ("mock-hash") and channels are always returned in
-    // full — the not-modified short-circuit is intentionally never exercised
-    // here: mock channel data mutates during tests (last_message_at updates on
-    // message emission) while the hash never changes, so honoring knownHash
-    // would wrongly short-circuit after mutations.
+    // The hash is constant ("mock-hash") and full lists remain the default:
+    // mock channel data mutates during tests while the hash does not. Focused
+    // snapshot specs can opt into the not-modified branch explicitly.
     const channels = listMockChannels(config);
+    const hash = "mock-hash";
+    const knownHash = (payload as { knownHash?: unknown } | null)?.knownHash;
+    const forcedNotModified =
+      (config?.mock?.channelsNotModifiedResponses ?? 0) > 0;
+    if (forcedNotModified && config?.mock) {
+      config.mock.channelsNotModifiedResponses =
+        (config.mock.channelsNotModifiedResponses ?? 1) - 1;
+    }
     return {
-      hash: "mock-hash",
-      channels,
+      hash,
+      channels:
+        forcedNotModified ||
+        (config?.mock?.honorChannelsKnownHash && knownHash === hash)
+          ? null
+          : channels,
       last_messages: buildLastMessages(channels),
     };
   }
@@ -10131,6 +10158,15 @@ export function maybeInstallE2eTauriMocks() {
   window.__BUZZ_E2E_COMMANDS__ = [];
   window.__BUZZ_E2E_COMMAND_PAYLOADS__ = [];
   window.__BUZZ_E2E_COMMAND_LOG__ = [];
+  mockMediaProxyPort = config.mock?.mediaProxyInitiallyUnavailable
+    ? 0
+    : MOCK_MEDIA_PROXY_PORT;
+  window.__BUZZ_E2E_RELEASE_MEDIA_PROXY__ = () => {
+    mockMediaProxyPort = MOCK_MEDIA_PROXY_PORT;
+    resetMediaCaches();
+    ensureRelayOriginFetch();
+    return mockMediaProxyPort;
+  };
   window.__BUZZ_E2E_EMIT_MOCK_HUDDLE_TTS_SPEAKER__ = (payload) =>
     emit("huddle-tts-speaker-level", payload);
   window.__BUZZ_E2E_SIGNED_EVENTS__ = [];
@@ -10260,6 +10296,7 @@ export function maybeInstallE2eTauriMocks() {
   window.__BUZZ_E2E_MUTATE_CHANNEL__ = ({
     channelId,
     channelType,
+    description,
     removeMemberPubkey,
   }) => {
     const channel = mockChannels.find((ch) => ch.id === channelId);
@@ -10267,6 +10304,9 @@ export function maybeInstallE2eTauriMocks() {
     if (channelType !== undefined) {
       channel.channel_type = channelType;
     }
+    if (description !== undefined) {
+      channel.description = description;
+    }
     if (removeMemberPubkey !== undefined) {
       channel.members = channel.members.filter(
         (m) => m.pubkey !== removeMemberPubkey,
@@ -11916,7 +11956,7 @@ export function maybeInstallE2eTauriMocks() {
         // invocation's completion. Later reads pass through and cannot join it.
         const deferred = deferNextChannelsRead;
         deferNextChannelsRead = false;
-        const channels = handleGetChannels(activeConfig);
+        const channels = handleGetChannels(payload, activeConfig);
         if (deferred) {
           await new Promise<void>((resolve) => {
             deferredChannelsReadResolve = resolve;
@@ -12691,7 +12731,7 @@ export function maybeInstallE2eTauriMocks() {
           activeConfig,
         );
       case "get_media_proxy_port":
-        return MOCK_MEDIA_PROXY_PORT;
+        return mockMediaProxyPort;
       case "pick_and_upload_media":
         return await resolveMockUploadDescriptors(activeConfig);
       case "pick_and_upload_image":
diff --git a/desktop/tests/e2e/agents.spec.ts b/desktop/tests/e2e/agents.spec.ts
index 66f9e4e707a..cc9c047e9dc 100644
--- a/desktop/tests/e2e/agents.spec.ts
+++ b/desktop/tests/e2e/agents.spec.ts
@@ -2580,12 +2580,20 @@ test("duplicate instances move from the agents gallery into the agent profile",
   ).toHaveCount(0);
 
   await page.getByTestId(`persona-agent-row-${personaId}`).click();
+  await page.getByTestId("user-profile-tab-runtime").click();
   await page.getByTestId("user-profile-instances").click();
   await page.getByTestId(`user-profile-instance-${additionalPubkey}`).click();
 
   await expect(page.getByTestId("user-profile-panel")).toBeVisible();
-  await page.getByTestId("user-profile-settings-menu-trigger").click();
+  await expect(page.getByTestId("user-profile-delete-agent-row")).toBeVisible();
   await expect(
-    page.getByTestId(`user-profile-agent-delete-${additionalPubkey}`),
+    page.getByTestId("user-profile-settings-menu-trigger"),
+  ).toHaveCount(0);
+  await expect(
+    page.getByTestId("user-profile-duplicate-agent-row"),
   ).toBeVisible();
+  await expect(page.getByTestId("user-profile-export-agent-row")).toBeVisible();
+  await expect(
+    page.getByTestId(`user-profile-agent-delete-${additionalPubkey}`),
+  ).toHaveCount(0);
 });
diff --git a/desktop/tests/e2e/channel-controls.spec.ts b/desktop/tests/e2e/channel-controls.spec.ts
index 0e671a70681..093b572353f 100644
--- a/desktop/tests/e2e/channel-controls.spec.ts
+++ b/desktop/tests/e2e/channel-controls.spec.ts
@@ -221,13 +221,13 @@ test.describe("channel controls", () => {
     ).toBeEnabled();
   });
 
-  test("05 — sticky footer pins lifecycle buttons", async ({ page }) => {
+  test("05 — owner actions live in the settings list", async ({ page }) => {
     await installMockBridge(page);
     await openManagementSheet(page);
 
-    const footer = page.getByTestId("channel-management-footer");
-    await expect(footer).toBeVisible();
+    await expect(page.getByTestId("channel-management-footer")).toHaveCount(0);
     await expect(page.getByTestId("channel-management-archive")).toBeVisible();
+    await expect(page.getByTestId("channel-management-delete")).toBeVisible();
     await settle(page);
   });
 
diff --git a/desktop/tests/e2e/channels.spec.ts b/desktop/tests/e2e/channels.spec.ts
index ab7eac41b06..4a55849920d 100644
--- a/desktop/tests/e2e/channels.spec.ts
+++ b/desktop/tests/e2e/channels.spec.ts
@@ -14,6 +14,7 @@ import {
 } from "../helpers/bridge";
 
 const GENERAL_CHANNEL_ID = "9a1657ac-f7aa-5db0-b632-d8bbeb6dfb50";
+const RANDOM_CHANNEL_ID = "9dae0116-799b-5071-a0a8-fdd30a91a35d";
 const AGENTS_CHANNEL_ID = "94a444a4-c0a3-5966-ab05-530c6ddc2301";
 const MOCK_IDENTITY_PUBKEY = "deadbeef".repeat(8);
 const CACHED_PROFILE_LABELS_TAG = "@cached-profile-labels";
@@ -1366,6 +1367,55 @@ test("create stream with name and description", async ({ page }) => {
   await expect(page.getByTestId("chat-title")).toHaveText(channelName);
 });
 
+test("channel name values stay primary after their inputs blur", async ({
+  page,
+}) => {
+  async function expectPrimaryValueAfterBlur(
+    input: import("@playwright/test").Locator,
+    blurTarget: import("@playwright/test").Locator,
+  ) {
+    const placeholder = await input.getAttribute("placeholder");
+    const placeholderColor = placeholder
+      ? await input.evaluate(
+          (element) => window.getComputedStyle(element, "::placeholder").color,
+        )
+      : null;
+
+    await input.fill("primary-channel-name");
+    const focusedColor = await input.evaluate(
+      (element) => window.getComputedStyle(element).color,
+    );
+    await blurTarget.click();
+    const valueColor = await input.evaluate(
+      (element) => window.getComputedStyle(element).color,
+    );
+
+    expect(valueColor).toBe(focusedColor);
+    if (placeholderColor) {
+      expect(valueColor).not.toBe(placeholderColor);
+    }
+  }
+
+  await page.goto("/");
+  await openCreateChannelDialog(page);
+  const createDialog = page.getByTestId("create-channel-dialog");
+  await expectPrimaryValueAfterBlur(
+    createDialog.getByTestId("create-channel-name"),
+    createDialog.getByTestId("create-channel-description"),
+  );
+  await createDialog.getByRole("button", { name: "Close" }).click();
+
+  await openChannelManagement(page, "general");
+  await openChannelEditDialog(page);
+  const editDialog = page.getByRole("dialog", {
+    name: /Edit (?:public|private) channel/,
+  });
+  await expectPrimaryValueAfterBlur(
+    editDialog.getByTestId("channel-management-name"),
+    editDialog.getByTestId("channel-management-description"),
+  );
+});
+
 test("create channel template selector matches the lifecycle controls", async ({
   page,
 }) => {
@@ -2493,6 +2543,240 @@ test("manage channel updates details", async ({ page }) => {
   ).toHaveCount(0);
 });
 
+test("manage channel shows member avatars and owner-only row controls", async ({
+  page,
+}) => {
+  await page.context().grantPermissions(["clipboard-read", "clipboard-write"]);
+  await page.goto("/");
+  await openChannelManagement(page, "general");
+
+  await expect(
+    page.getByTestId("channel-management-member-avatar-stack"),
+  ).toBeVisible();
+  await expect(
+    page.getByTestId("channel-management-member-avatar"),
+  ).toHaveCount(3);
+  await expect(
+    page.getByTestId("channel-management-member-avatar-overflow"),
+  ).toHaveText("+1");
+  await expect(page.getByTestId("channel-management-hero")).toBeVisible();
+  await expect(
+    page.getByTestId("channel-management-sheet").locator(".space-y-6").first(),
+  ).toBeVisible();
+  const detailsSection = page.getByTestId("channel-management-details");
+  const detailsTitle = detailsSection.getByRole("heading", {
+    exact: true,
+    level: 2,
+    name: "Details",
+  });
+  await expect(detailsTitle).toHaveClass(/text-xs/);
+  await expect(detailsTitle).toHaveClass(/text-muted-foreground\/70/);
+  await expect(
+    detailsSection.locator('[data-slot="panel-section-header"]'),
+  ).toHaveClass(/px-4/);
+  await expect(
+    detailsSection
+      .locator('[data-slot="panel-section-card"]')
+      .getByRole("heading", { exact: true, name: "Details" }),
+  ).toHaveCount(0);
+  const untitledChannelSections = [
+    page.getByTestId("channel-canvas-ingress-section"),
+    page.getByTestId("channel-management-actions"),
+  ];
+  for (const section of untitledChannelSections) {
+    await expect(
+      section.locator('[data-slot="panel-section-header"]'),
+    ).toHaveCount(0);
+  }
+  for (const rowTestId of [
+    "channel-management-type",
+    "channel-management-visibility",
+    "channel-management-member-count",
+    "channel-management-channel-id",
+  ]) {
+    await expect(
+      page
+        .getByTestId(rowTestId)
+        .locator(":scope > [data-slot='field-row-icon']"),
+    ).toHaveCount(0);
+  }
+  const leaveChannelRow = page.getByTestId("channel-management-leave");
+  await expect(
+    leaveChannelRow.locator(":scope > svg[data-slot='field-row-icon']"),
+  ).toHaveCount(1);
+  await expect(
+    leaveChannelRow.locator(":scope > span.rounded-full"),
+  ).toHaveCount(0);
+  const canvasInfo = page.getByTestId("channel-canvas-ingress-info");
+  await canvasInfo.hover();
+  await expect(page.getByRole("tooltip")).toHaveText(
+    "Use the canvas as a shared space for notes, plans, and other channel information.",
+  );
+  const nameEdit = page.getByTestId("channel-management-edit");
+  await expect(nameEdit).toBeVisible();
+  const nameEditIcon = page.getByTestId("channel-management-edit-icon");
+  await expect(nameEditIcon).toHaveCSS("opacity", "0");
+  await nameEdit.hover();
+  await expect(nameEditIcon).toHaveCSS("opacity", "1");
+  await expect(
+    page.getByTestId("channel-management-edit-description"),
+  ).toHaveCount(0);
+  await expect(
+    page.getByTestId("channel-management-edit-channel-type"),
+  ).toHaveCSS("opacity", "0");
+  await expect(
+    page.getByTestId("channel-management-edit-visibility"),
+  ).toHaveCSS("opacity", "0");
+  await expect(page.getByTestId("channel-management-archive")).toBeVisible();
+  await expect(page.getByTestId("channel-management-delete")).toBeVisible();
+  await expect(
+    page.getByTestId("channel-management-copy-id-action"),
+  ).toHaveCount(0);
+  const layoutOrder = await page
+    .getByTestId("channel-management-sheet")
+    .locator(
+      "[data-testid='channel-management-member-count'], [data-testid='channel-management-channel-id'], [data-testid='channel-canvas-ingress'], [data-testid='channel-management-leave']",
+    )
+    .evaluateAll((elements) =>
+      elements.map((element) => element.getAttribute("data-testid")),
+    );
+  expect(layoutOrder).toEqual([
+    "channel-management-member-count",
+    "channel-management-channel-id",
+    "channel-canvas-ingress",
+    "channel-management-leave",
+  ]);
+
+  const channelIdRow = page.getByTestId("channel-management-channel-id");
+  const channelIdCopyStatus = page.getByTestId(
+    "channel-management-channel-id-copy-status",
+  );
+  await expect(channelIdRow.getByTitle(GENERAL_CHANNEL_ID)).toHaveText(
+    "9a1657ac…fb50",
+  );
+  await expect(channelIdCopyStatus).toHaveCSS("opacity", "0");
+  await channelIdRow.hover();
+  await expect(channelIdCopyStatus).toHaveCSS("opacity", "1");
+  await channelIdRow.click();
+  await expect(channelIdRow).toHaveAttribute("aria-label", "Channel ID copied");
+  await expect(channelIdCopyStatus).toHaveAttribute("data-copied", "true");
+
+  for (const editTrigger of [
+    nameEdit,
+    page.getByTestId("channel-management-description"),
+    page.getByTestId("channel-management-type"),
+    page.getByTestId("channel-management-visibility"),
+  ]) {
+    await editTrigger.click();
+    const editDialog = page.getByRole("dialog", {
+      name: /Edit (?:public|private) channel/,
+    });
+    await expect(editDialog).toBeVisible();
+    await expect(editDialog).toHaveClass(/data-\[state=open\]:animate-in/);
+    await expect(editDialog).toHaveClass(/data-\[state=open\]:fade-in-0/);
+    await expect(editDialog).toHaveClass(/data-\[state=open\]:zoom-in-95/);
+    await editDialog.getByRole("button", { name: "Cancel" }).click();
+    await expect(editDialog).not.toBeVisible();
+  }
+
+  await page.getByTestId("channel-management-member-count").click();
+  await expect(page.getByTestId("channel-management-sheet")).toBeVisible();
+  const membersDialog = page.getByTestId("members-sidebar");
+  await expect(membersDialog).toBeVisible();
+  await expect(membersDialog).toHaveClass(/data-\[state=open\]:animate-in/);
+  await expect(membersDialog).toHaveClass(/data-\[state=open\]:fade-in-0/);
+  await expect(membersDialog).toHaveClass(/data-\[state=open\]:zoom-in-95/);
+  await membersDialog.getByRole("button", { name: "Close" }).click();
+  await expect(membersDialog).not.toBeVisible();
+  await expect(page.getByTestId("channel-management-sheet")).toBeVisible();
+
+  await page
+    .getByTestId("channel-management-sheet")
+    .getByTestId("auxiliary-panel-close")
+    .click();
+  await expect(page.getByTestId("channel-management-sheet")).not.toBeVisible();
+
+  await openChannelManagement(page, "random");
+
+  await expect(page.getByTestId("channel-management-edit")).toHaveCount(0);
+  await expect(
+    page.getByTestId("channel-management-edit-description"),
+  ).toHaveCount(0);
+  await expect(
+    page.getByTestId("channel-management-edit-channel-type"),
+  ).toHaveCount(0);
+  await expect(
+    page.getByTestId("channel-management-edit-visibility"),
+  ).toHaveCount(0);
+  await expect(page.getByTestId("channel-management-archive")).toHaveCount(0);
+  await expect(page.getByTestId("channel-management-delete")).toHaveCount(0);
+  await expect(page.getByTestId("channel-management-leave")).toBeVisible();
+});
+
+test("direct message settings omit the channel name and empty actions card", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await openChannelManagement(page, "alice-tyler");
+
+  await expect(page.getByTestId("channel-management-hero")).toBeVisible();
+  await expect(page.getByTestId("channel-management-name-row")).toHaveCount(0);
+  await expect(page.getByTestId("channel-management-description")).toHaveCount(
+    0,
+  );
+  await expect(page.getByTestId("channel-management-actions")).toHaveCount(0);
+  await expect(
+    page
+      .getByTestId("channel-management-details")
+      .locator('[data-slot="panel-section-card"]')
+      .getByRole("heading", { exact: true, name: "Details" }),
+  ).toHaveCount(0);
+});
+
+test("channel settings only prompt editors to add an empty description", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await page.evaluate(
+    async ({ generalChannelId, randomChannelId }) => {
+      const bridge = window as Window & {
+        __BUZZ_E2E_INVALIDATE_CHANNELS__?: () => Promise<void>;
+        __BUZZ_E2E_MUTATE_CHANNEL__?: (options: {
+          channelId: string;
+          description?: string;
+        }) => void;
+      };
+      bridge.__BUZZ_E2E_MUTATE_CHANNEL__?.({
+        channelId: generalChannelId,
+        description: "",
+      });
+      bridge.__BUZZ_E2E_MUTATE_CHANNEL__?.({
+        channelId: randomChannelId,
+        description: "",
+      });
+      await bridge.__BUZZ_E2E_INVALIDATE_CHANNELS__?.();
+    },
+    {
+      generalChannelId: GENERAL_CHANNEL_ID,
+      randomChannelId: RANDOM_CHANNEL_ID,
+    },
+  );
+
+  await openChannelManagement(page, "general");
+  await expect(page.getByTestId("channel-management-edit")).toBeVisible();
+  await expect(page.getByTestId("channel-management-description")).toHaveText(
+    "Add a description",
+  );
+  await closeChannelManagement(page);
+
+  await openChannelManagement(page, "random");
+
+  await expect(page.getByTestId("channel-management-edit")).toHaveCount(0);
+  await expect(page.getByTestId("channel-management-description")).toHaveCount(
+    0,
+  );
+});
+
 test("manage channel updates visibility and ephemeral lifecycle independently", async ({
   page,
 }) => {
@@ -2621,7 +2905,7 @@ test("manage channel updates visibility and ephemeral lifecycle independently",
   await expect(page.getByTestId("channel-management-ttl")).toHaveCount(0);
 });
 
-test("manage channel keeps canvas near the top of the sheet", async ({
+test("manage channel places canvas between channel info and actions", async ({
   page,
 }) => {
   await page.goto("/");
@@ -2631,12 +2915,15 @@ test("manage channel keeps canvas near the top of the sheet", async ({
   const sheetBox = await sheet.boundingBox();
   const timelineBox = await page.getByTestId("message-timeline").boundingBox();
 
-  // Canvas ingress should appear before the channel metadata rows in the DOM.
+  // Canvas ingress separates the channel information from channel actions.
   const canvasBox = await sheet
     .getByTestId("channel-canvas-ingress")
     .boundingBox();
-  const nameBox = await sheet
-    .getByTestId("channel-management-name-row")
+  const channelIdBox = await sheet
+    .getByTestId("channel-management-channel-id")
+    .boundingBox();
+  const leaveBox = await sheet
+    .getByTestId("channel-management-leave")
     .boundingBox();
 
   expect(sheetBox).not.toBeNull();
@@ -2659,16 +2946,21 @@ test("manage channel keeps canvas near the top of the sheet", async ({
   }
   expect(narrowSheetBox.width).toBeGreaterThan(500);
   expect(canvasBox).not.toBeNull();
-  expect(nameBox).not.toBeNull();
-  expect(canvasBox?.y).toBeLessThan(nameBox?.y);
+  expect(channelIdBox).not.toBeNull();
+  expect(leaveBox).not.toBeNull();
+  expect(channelIdBox?.y).toBeLessThan(canvasBox?.y);
+  expect(canvasBox?.y).toBeLessThan(leaveBox?.y);
 });
 
 async function seedHomeInboxMention(
   page: import("@playwright/test").Page,
   itemId: string,
   tags?: string[][],
+  { navigate = true }: { navigate?: boolean } = {},
 ) {
-  await page.goto("/");
+  if (navigate) {
+    await page.goto("/");
+  }
   await expect(page.getByTestId("home-inbox-list")).toBeVisible();
   await page.waitForFunction(
     () =>
@@ -3497,6 +3789,58 @@ test("home inbox manage affordance opens management without leaving home", async
   await expect(page).not.toHaveURL(/#\/channels\//);
 });
 
+test("home channel settings keeps agent lifecycle actions scoped to the active community", async ({
+  page,
+}) => {
+  await page.goto("/");
+  const agentPubkey = await addGenericAgent(
+    page,
+    "general",
+    `home-sidebar-agent-${Date.now()}`,
+  );
+  const baselineCommands = await readCommandLog(page);
+  const baselineRuntimeStopCount = commandCount(
+    baselineCommands,
+    "stop_managed_agent_runtime",
+  );
+  const baselineLegacyStopCount = commandCount(
+    baselineCommands,
+    "stop_managed_agent",
+  );
+
+  await page.getByRole("button", { exact: true, name: "Inbox" }).click();
+  await seedHomeInboxMention(
+    page,
+    "mock-feed-home-agent-lifecycle",
+    undefined,
+    { navigate: false },
+  );
+  await page
+    .getByTestId("home-inbox-detail")
+    .getByTestId("channel-management-trigger")
+    .click();
+  await page.getByTestId("channel-management-member-count").click();
+  await expect(page.getByTestId("members-sidebar")).toBeVisible();
+
+  const agentStatus = page.getByTestId(
+    `sidebar-managed-agent-status-${agentPubkey}`,
+  );
+  const agentAction = page.getByTestId(`sidebar-agent-action-${agentPubkey}`);
+  await expect(agentStatus).toContainText("Here");
+  await openMemberMenu(page, agentPubkey);
+  await expect(agentAction).toContainText("Stop");
+  await agentAction.click();
+  await expect(agentStatus).toContainText("Unavailable");
+
+  const commands = await readCommandLog(page);
+  expect(commandCount(commands, "stop_managed_agent_runtime")).toBe(
+    baselineRuntimeStopCount + 1,
+  );
+  expect(commandCount(commands, "stop_managed_agent")).toBe(
+    baselineLegacyStopCount,
+  );
+});
+
 test("members sidebar virtualizes large channel rosters", async ({ page }) => {
   await page.goto("/");
   const channelId = await page
diff --git a/desktop/tests/e2e/community-rail.spec.ts b/desktop/tests/e2e/community-rail.spec.ts
index 0a4c8830e12..51b4867bf46 100644
--- a/desktop/tests/e2e/community-rail.spec.ts
+++ b/desktop/tests/e2e/community-rail.spec.ts
@@ -4,6 +4,11 @@ import { installMockBridge } from "../helpers/bridge";
 import { FEATURE_OVERRIDES_STORAGE_KEY } from "../helpers/features";
 
 const RELAY_URL = "ws://localhost:3000";
+const OWNER_PUBKEY = "deadbeef".repeat(8);
+
+function snapshotKey(relayUrl: string) {
+  return `buzz-channels.v1:${relayUrl}:${OWNER_PUBKEY.toLowerCase()}`;
+}
 
 const COMMUNITY_A = {
   id: "ws-a",
@@ -412,33 +417,36 @@ test.describe("community rail", () => {
     await seedCommunities(page, [COMMUNITY_A, COMMUNITY_B], COMMUNITY_A.id);
     await page.goto("/");
     await expect(page.getByTestId("app-sidebar")).toBeVisible();
-    const rememberedChannelId = await page.evaluate((communityId) => {
-      const source = window.localStorage.getItem(
-        "buzz-channels.v1:ws://localhost:3000",
-      );
-      if (!source) throw new Error("missing source channel snapshot");
-      const snapshot = JSON.parse(source) as {
-        channels: Array<{ id: string; name: string }>;
-      };
-      const generalChannel = snapshot.channels.find(
-        (channel) => channel.name === "general",
-      );
-      if (!generalChannel) throw new Error("missing general channel snapshot");
-      window.localStorage.setItem(
-        "buzz-channels.v1:ws://localhost:3001",
-        source,
-      );
-      window.localStorage.setItem(
-        "buzz-community-destinations",
-        JSON.stringify({
-          [communityId]: {
-            kind: "channel",
-            channelId: generalChannel.id,
-          },
-        }),
-      );
-      return generalChannel.id;
-    }, COMMUNITY_B.id);
+    const rememberedChannelId = await page.evaluate(
+      ({ communityId, sourceSnapshotKey, targetSnapshotKey }) => {
+        const source = window.localStorage.getItem(sourceSnapshotKey);
+        if (!source) throw new Error("missing source channel snapshot");
+        const snapshot = JSON.parse(source) as {
+          channels: Array<{ id: string; name: string }>;
+        };
+        const generalChannel = snapshot.channels.find(
+          (channel) => channel.name === "general",
+        );
+        if (!generalChannel)
+          throw new Error("missing general channel snapshot");
+        window.localStorage.setItem(targetSnapshotKey, source);
+        window.localStorage.setItem(
+          "buzz-community-destinations",
+          JSON.stringify({
+            [communityId]: {
+              kind: "channel",
+              channelId: generalChannel.id,
+            },
+          }),
+        );
+        return generalChannel.id;
+      },
+      {
+        communityId: COMMUNITY_B.id,
+        sourceSnapshotKey: snapshotKey(COMMUNITY_A.relayUrl),
+        targetSnapshotKey: snapshotKey(COMMUNITY_B.relayUrl),
+      },
+    );
 
     await page.evaluate(() => {
       const testWindow = window as typeof window & {
@@ -478,28 +486,29 @@ test.describe("community rail", () => {
     }, COMMUNITY_B.id);
 
     await page.goto("/");
+    const sourceSnapshotKey = snapshotKey(COMMUNITY_A.relayUrl);
+    const targetSnapshotKey = snapshotKey(COMMUNITY_B.relayUrl);
     await expect
       .poll(() =>
-        page.evaluate(() =>
-          window.localStorage.getItem("buzz-channels.v1:ws://localhost:3000"),
+        page.evaluate(
+          (key) => window.localStorage.getItem(key),
+          sourceSnapshotKey,
         ),
       )
       .not.toBeNull();
-    await page.evaluate(() => {
-      const source = window.localStorage.getItem(
-        "buzz-channels.v1:ws://localhost:3000",
-      );
-      if (!source) throw new Error("missing source channel snapshot");
-      const snapshot = JSON.parse(source);
-      snapshot.channels = snapshot.channels.map(
-        (channel: Record<string, unknown>, index: number) =>
-          index === 0 ? { ...channel, id: "missing-channel" } : channel,
-      );
-      window.localStorage.setItem(
-        "buzz-channels.v1:ws://localhost:3001",
-        JSON.stringify(snapshot),
-      );
-    });
+    await page.evaluate(
+      ({ sourceKey, targetKey }) => {
+        const source = window.localStorage.getItem(sourceKey);
+        if (!source) throw new Error("missing source channel snapshot");
+        const snapshot = JSON.parse(source);
+        snapshot.channels = snapshot.channels.map(
+          (channel: Record<string, unknown>, index: number) =>
+            index === 0 ? { ...channel, id: "missing-channel" } : channel,
+        );
+        window.localStorage.setItem(targetKey, JSON.stringify(snapshot));
+      },
+      { sourceKey: sourceSnapshotKey, targetKey: targetSnapshotKey },
+    );
     await page.getByTestId(`community-rail-button-${COMMUNITY_B.id}`).click();
 
     await expect(page).not.toHaveURL(/#\/channels\//);
@@ -531,10 +540,12 @@ test.describe("community rail", () => {
     }, COMMUNITY_B.id);
     await page.goto("/");
     await expect(page.getByTestId("app-sidebar")).toBeVisible();
+    const sourceSnapshotKey = snapshotKey(COMMUNITY_A.relayUrl);
     await expect
       .poll(() =>
-        page.evaluate(() =>
-          window.localStorage.getItem("buzz-channels.v1:ws://localhost:3000"),
+        page.evaluate(
+          (key) => window.localStorage.getItem(key),
+          sourceSnapshotKey,
         ),
       )
       .not.toBeNull();
@@ -563,20 +574,21 @@ test.describe("community rail", () => {
         };
       }),
     ).toEqual({ released: 0, pending: 0 });
-    await page.evaluate(() => {
-      const source = window.localStorage.getItem(
-        "buzz-channels.v1:ws://localhost:3000",
-      );
-      if (!source) throw new Error("missing source channel snapshot");
-      const snapshot = JSON.parse(source);
-      snapshot.channels = snapshot.channels.filter(
-        (channel: { id: string }) => channel.id !== "general",
-      );
-      window.localStorage.setItem(
-        "buzz-channels.v1:ws://localhost:3001",
-        JSON.stringify(snapshot),
-      );
-    });
+    await page.evaluate(
+      ({ sourceKey, targetKey }) => {
+        const source = window.localStorage.getItem(sourceKey);
+        if (!source) throw new Error("missing source channel snapshot");
+        const snapshot = JSON.parse(source);
+        snapshot.channels = snapshot.channels.filter(
+          (channel: { id: string }) => channel.id !== "general",
+        );
+        window.localStorage.setItem(targetKey, JSON.stringify(snapshot));
+      },
+      {
+        sourceKey: sourceSnapshotKey,
+        targetKey: snapshotKey(COMMUNITY_B.relayUrl),
+      },
+    );
     await page.evaluate(() => {
       const config = (
         window as Window & {
diff --git a/desktop/tests/e2e/config-bridge-screenshots.spec.ts b/desktop/tests/e2e/config-bridge-screenshots.spec.ts
index 11d4a73fa37..453ffddee94 100644
--- a/desktop/tests/e2e/config-bridge-screenshots.spec.ts
+++ b/desktop/tests/e2e/config-bridge-screenshots.spec.ts
@@ -97,11 +97,15 @@ async function activatePersonas(page: import("@playwright/test").Page) {
 
 /**
  * Open the #agents channel and click an agent's avatar in the message list
- * to open the profile side panel, then navigate to the Runtime tab.
+ * to open the profile side panel, then navigate to the requested tab.
  */
 async function openAgentProfileFromChannel(
   page: import("@playwright/test").Page,
   agentName: string,
+  {
+    anchorText = "Model",
+    tab = "Info",
+  }: { anchorText?: string; tab?: "Info" | "Runtime" } = {},
 ) {
   await page.goto("/", { waitUntil: "domcontentloaded" });
   await waitForInvokeBridge(page);
@@ -121,13 +125,10 @@ async function openAgentProfileFromChannel(
   const panel = page.getByTestId("user-profile-panel");
   await expect(panel).toBeVisible({ timeout: 10_000 });
 
-  // Click the Runtime tab to reveal the Configuration section.
-  await panel.getByRole("tab", { name: "Runtime" }).click();
+  await panel.getByRole("tab", { name: tab }).click();
 
-  // Wait for the first normalized config field ("Model") to appear.
-  const configAnchor = panel.getByText("Model").first();
+  const configAnchor = panel.getByText(anchorText, { exact: true }).first();
   await expect(configAnchor).toBeVisible({ timeout: 10_000 });
-
   // Scroll the panel's internal scroll container to the bottom so the
   // config section content is fully visible.
   await configAnchor.scrollIntoViewIfNeeded();
@@ -175,7 +176,9 @@ test.describe("config bridge screenshots", () => {
   test("01 — folded config panel", async ({ page }) => {
     await installMockBridge(page, { managedAgents: MANAGED_AGENTS });
 
-    const panel = await openAgentProfileFromChannel(page, "Goose Agent");
+    const panel = await openAgentProfileFromChannel(page, "Goose Agent", {
+      tab: "Runtime",
+    });
 
     // The folded config panel: provenance sentences inline under each value.
     await expect(panel.getByText("Set in Buzz").first()).toBeVisible();
@@ -190,6 +193,7 @@ test.describe("config bridge screenshots", () => {
     const panel = await openAgentProfileFromChannel(
       page,
       "Runtime Override Agent",
+      { tab: "Runtime" },
     );
 
     // A runtimeOverride model shows the live model, the persona baseline as a
@@ -208,11 +212,17 @@ test.describe("config bridge screenshots", () => {
   test("03 — provenance sentences", async ({ page }) => {
     await installMockBridge(page, { managedAgents: MANAGED_AGENTS });
 
-    const panel = await openAgentProfileFromChannel(page, "Multi-Origin Agent");
+    const panel = await openAgentProfileFromChannel(
+      page,
+      "Multi-Origin Agent",
+      {
+        tab: "Runtime",
+      },
+    );
 
     // Multiple distinct provenance origins visible at once.
     await expect(panel.getByText("Set in Buzz").first()).toBeVisible();
-    await expect(panel.getByText("Inherited from template")).toBeVisible();
+    await expect(panel.getByText("Inherited from template")).toHaveCount(0);
     await expect(
       panel.getByText("From environment variable (GOOSE_MODE)"),
     ).toBeVisible();
@@ -229,7 +239,9 @@ test.describe("config bridge screenshots", () => {
   test("04 — pre-spawn state", async ({ page }) => {
     await installMockBridge(page, { managedAgents: MANAGED_AGENTS });
 
-    const panel = await openAgentProfileFromChannel(page, "Pre-Spawn Agent");
+    const panel = await openAgentProfileFromChannel(page, "Pre-Spawn Agent", {
+      tab: "Runtime",
+    });
 
     // ACP-only fields show "Available after agent starts" before spawn.
     await expect(
@@ -243,7 +255,10 @@ test.describe("config bridge screenshots", () => {
   test("05 — advanced flat list", async ({ page }) => {
     await installMockBridge(page, { managedAgents: MANAGED_AGENTS });
 
-    const panel = await openAgentProfileFromChannel(page, "Goose Agent");
+    const panel = await openAgentProfileFromChannel(page, "Goose Agent", {
+      anchorText: "MCP servers",
+      tab: "Runtime",
+    });
 
     // Advanced runtime fields render directly in the profile panel's flat list,
     // grouped under their own "Advanced" header.
@@ -251,7 +266,7 @@ test.describe("config bridge screenshots", () => {
     await expect(panel.getByText("Advanced", { exact: true })).toHaveCount(1);
     // MCP servers render once each under their group label.
     await expect(panel.getByText("developer", { exact: true })).toHaveCount(1);
-    await expect(panel.getByText("MCP Servers", { exact: true })).toHaveCount(
+    await expect(panel.getByText("MCP servers", { exact: true })).toHaveCount(
       1,
     );
     await settleAnimations(panel);
@@ -271,12 +286,15 @@ test.describe("config bridge screenshots", () => {
       ],
     });
 
-    const panel = await openAgentProfileFromChannel(page, "Buzz Agent");
+    const panel = await openAgentProfileFromChannel(page, "Buzz Agent", {
+      anchorText: "MCP servers",
+      tab: "Runtime",
+    });
 
     await expect(
-      panel.getByText("No custom servers configured", { exact: true }),
+      panel.getByText("No custom servers configured.", { exact: true }),
     ).toBeVisible();
-    await expect(panel.getByText("MCP Servers", { exact: true })).toHaveCount(
+    await expect(panel.getByText("MCP servers", { exact: true })).toHaveCount(
       1,
     );
   });
@@ -313,7 +331,7 @@ test.describe("config bridge screenshots", () => {
     const panel = page.getByTestId("user-profile-panel");
     await expect(panel).toBeVisible({ timeout: 10_000 });
 
-    // The Configuration section lives inside the Runtime tab — click it first.
+    // Editable configuration lives inside the Runtime tab.
     await panel.getByRole("tab", { name: "Runtime" }).click();
 
     // Wait for the config section to render and scroll it into view so
diff --git a/desktop/tests/e2e/identity-archive.spec.ts b/desktop/tests/e2e/identity-archive.spec.ts
index 633315e98f8..dfbe2ff2690 100644
--- a/desktop/tests/e2e/identity-archive.spec.ts
+++ b/desktop/tests/e2e/identity-archive.spec.ts
@@ -77,9 +77,8 @@ test.describe("NIP-IA archive button gate", () => {
       archivedIdentities: [],
     });
     await openAliceProfile(page);
-    await openProfileSettingsMenu(page);
     await expect(
-      page.getByTestId("user-profile-archive-identity"),
+      page.getByTestId("user-profile-archive-agent-row"),
     ).toBeVisible();
   });
 
@@ -92,9 +91,8 @@ test.describe("NIP-IA archive button gate", () => {
       archivedIdentities: [],
     });
     await openAliceProfile(page);
-    await openProfileSettingsMenu(page);
     await expect(
-      page.getByTestId("user-profile-archive-identity"),
+      page.getByTestId("user-profile-archive-agent-row"),
     ).toBeVisible();
   });
 
@@ -116,6 +114,9 @@ test.describe("NIP-IA archive button gate", () => {
     await expect(
       page.getByTestId("user-profile-unarchive-identity"),
     ).toHaveCount(0);
+    await expect(
+      page.getByTestId("user-profile-archive-agent-row"),
+    ).toHaveCount(0);
   });
 
   test("case 5 — Alice archived: flair + Unarchive button (under admin gate)", async ({
@@ -129,12 +130,11 @@ test.describe("NIP-IA archive button gate", () => {
     });
     await openAliceProfile(page);
     await expect(page.getByTestId("user-profile-archived-flair")).toBeVisible();
-    await openProfileSettingsMenu(page);
     await expect(
-      page.getByTestId("user-profile-unarchive-identity"),
+      page.getByTestId("user-profile-unarchive-agent-row"),
     ).toBeVisible();
-    await expect(page.getByTestId("user-profile-archive-identity")).toHaveCount(
-      0,
-    );
+    await expect(
+      page.getByTestId("user-profile-archive-agent-row"),
+    ).toHaveCount(0);
   });
 });
diff --git a/desktop/tests/e2e/messaging.spec.ts b/desktop/tests/e2e/messaging.spec.ts
index adacdb62952..39744136891 100644
--- a/desktop/tests/e2e/messaging.spec.ts
+++ b/desktop/tests/e2e/messaging.spec.ts
@@ -280,44 +280,63 @@ test.beforeEach(async ({ page }, testInfo) => {
                               "link-preview-image",
                             ],
                           }
-                        : testInfo.title.includes("link preview") ||
-                            testInfo.title.includes("supported Compact")
+                        : testInfo.title.includes(
+                              "sent link preview media uses",
+                            )
                           ? {
+                              mediaProxyInitiallyUnavailable: true,
                               linkPreviewMetadata: {
                                 title: "Buzz pull request",
                                 siteName: "GitHub",
                                 description:
                                   "A sender-authored preview snapshot.",
-                                imageDataUrl: null,
-                                imageDomain: null,
+                                imageDataUrl:
+                                  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
+                                imageDomain: "opengraph.githubassets.com",
+                                faviconDataUrl:
+                                  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
                               },
-                              linkPreviewMetadataDelayMs:
-                                testInfo.title.includes(
-                                  "loading card before cold resolver work",
-                                )
-                                  ? 10_000
-                                  : testInfo.title.includes(
-                                        "send does not wait",
-                                      )
-                                    ? 3_000
-                                    : testInfo.title.includes("draft auto-send")
-                                      ? 500
+                            }
+                          : testInfo.title.includes("link preview") ||
+                              testInfo.title.includes("supported Compact")
+                            ? {
+                                linkPreviewMetadata: {
+                                  title: "Buzz pull request",
+                                  siteName: "GitHub",
+                                  description:
+                                    "A sender-authored preview snapshot.",
+                                  imageDataUrl: null,
+                                  imageDomain: null,
+                                },
+                                linkPreviewMetadataDelayMs:
+                                  testInfo.title.includes(
+                                    "loading card before cold resolver work",
+                                  )
+                                    ? 10_000
+                                    : testInfo.title.includes(
+                                          "send does not wait",
+                                        )
+                                      ? 3_000
                                       : testInfo.title.includes(
-                                            "style defaults",
-                                          ) ||
-                                          testInfo.title.includes(
-                                            "attachment-sized",
+                                            "draft auto-send",
                                           )
-                                        ? 1_500
-                                        : undefined,
-                              linkPreviewMetadataStartBlockMs:
-                                testInfo.title.includes(
-                                  "loading card before cold resolver work",
-                                )
-                                  ? 150
-                                  : undefined,
-                            }
-                          : undefined;
+                                        ? 500
+                                        : testInfo.title.includes(
+                                              "style defaults",
+                                            ) ||
+                                            testInfo.title.includes(
+                                              "attachment-sized",
+                                            )
+                                          ? 1_500
+                                          : undefined,
+                                linkPreviewMetadataStartBlockMs:
+                                  testInfo.title.includes(
+                                    "loading card before cold resolver work",
+                                  )
+                                    ? 150
+                                    : undefined,
+                              }
+                            : undefined;
   const mock = testInfo.title.includes("unresolvable preview")
     ? { linkPreviewMetadata: null, linkPreviewMetadataDelayMs: 800 }
     : baseMock;
@@ -462,6 +481,69 @@ test("markdown tables overflow wide content and fill the message when narrow", a
     .toBeLessThanOrEqual(1);
 });
 
+test("sent link preview media uses the authenticated proxy in compact and rich cards", async ({
+  page,
+}) => {
+  const previewUrl = "https://github.com/block/buzz/pull/3246?proxy=1";
+  const fallbackMediaPattern =
+    /^buzz-media:\/\/localhost\/media\/[\da-f]{64}\.png$/;
+  const proxyMediaPattern =
+    /^http:\/\/127\.0\.0\.1:54321\/media\/[\da-f]{64}\.png$/;
+  await page.route("http://127.0.0.1:54321/media/**", (route) =>
+    route.fulfill({
+      body: '<svg xmlns="http://www.w3.org/2000/svg" width="40" height="20"><rect width="40" height="20" fill="#22c55e"/></svg>',
+      contentType: "image/svg+xml",
+    }),
+  );
+
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await page.getByTestId("message-input").fill(previewUrl);
+  await waitForReadyComposerSnapshots(page);
+  await page.getByTestId("send-message").click();
+
+  const row = page.getByTestId("message-row").last();
+  const compactPreview = row.locator(
+    '[data-link-preview="github-pull-request"]',
+  );
+  const compactThumbnail = compactPreview
+    .locator("[data-link-preview-thumbnail] img")
+    .first();
+  const compactFavicon = compactPreview.locator(
+    "img[data-link-preview-hostname-favicon]",
+  );
+  await expect(compactThumbnail).toHaveAttribute("src", fallbackMediaPattern);
+  await expect(compactFavicon).toHaveAttribute("src", fallbackMediaPattern);
+
+  const releasedPort = await page.evaluate(() =>
+    window.__BUZZ_E2E_RELEASE_MEDIA_PROXY__?.(),
+  );
+  expect(releasedPort).toBe(54321);
+  await expect(compactThumbnail).toHaveAttribute("src", proxyMediaPattern);
+  await expect(compactFavicon).toHaveAttribute("src", proxyMediaPattern);
+  await expect
+    .poll(() => compactThumbnail.evaluate((image) => image.naturalWidth))
+    .toBe(40);
+
+  await openSettings(page, "appearance");
+  await page.getByTestId("link-preview-style-trigger").click();
+  await page.getByTestId("link-preview-style-rich").click();
+  await page.getByTestId("settings-back-to-app").click();
+
+  const richPreview = row.locator(
+    '[data-link-preview="github-pull-request"][data-link-preview-inline]',
+  );
+  const richThumbnail = richPreview
+    .locator("[data-link-preview-thumbnail] img")
+    .first();
+  const richFavicon = richPreview.locator("img[data-link-preview-favicon]");
+  await expect(richThumbnail).toHaveAttribute("src", proxyMediaPattern);
+  await expect(richFavicon).toHaveAttribute("src", proxyMediaPattern);
+  await expect
+    .poll(() => richThumbnail.evaluate((image) => image.naturalWidth))
+    .toBe(40);
+});
+
 test("link preview style defaults to compact and Rich unfurls descriptions", async ({
   page,
 }) => {
diff --git a/desktop/tests/e2e/persistent-agent-audience.spec.ts b/desktop/tests/e2e/persistent-agent-audience.spec.ts
index ae424b4e5c8..9636f2c7505 100644
--- a/desktop/tests/e2e/persistent-agent-audience.spec.ts
+++ b/desktop/tests/e2e/persistent-agent-audience.spec.ts
@@ -179,11 +179,24 @@ test("persistent agents transition atomically before Enter-send resolves", async
         // to ProseMirror coordinates proves selection.from/to === doc.content.size.
         return {
           empty: selection.isCollapsed,
+          text: element.textContent,
+          endsWithSpace: element.textContent?.endsWith(" ") ?? false,
           atDocumentEnd: position + 1 === viewDesc.size - 2,
         };
       }),
     )
-    .toEqual({ empty: true, atDocumentEnd: true });
+    .toEqual({
+      empty: true,
+      text: "@Morgarita ",
+      endsWithSpace: true,
+      atDocumentEnd: true,
+    });
+
+  // Exercise the reported contract, not just its selection prerequisites:
+  // immediate typing after restoration must remain outside the mention chip.
+  await input.pressSequentially("testing");
+  await expect(input).toHaveText("@Morgarita testing");
+  await expect(input.locator(".agent-mention-highlight")).toHaveCount(1);
 });
 
 test("timeline agent send remains one-shot and returns to the placeholder", async ({
diff --git a/desktop/tests/e2e/profile.spec.ts b/desktop/tests/e2e/profile.spec.ts
index 26311354764..ff43f0f59d0 100644
--- a/desktop/tests/e2e/profile.spec.ts
+++ b/desktop/tests/e2e/profile.spec.ts
@@ -104,16 +104,27 @@ async function addGenericAgent(
           __BUZZ_E2E_INVOKE_MOCK_COMMAND__?: (
             command: string,
             payload?: Record<string, unknown>,
-          ) => Promise<{ agent?: { pubkey: string } }>;
+          ) => Promise<{ agent?: { pubkey: string }; id?: string }>;
         }
       ).__BUZZ_E2E_INVOKE_MOCK_COMMAND__;
       if (!invoke) {
         throw new Error("Mock bridge is not installed.");
       }
 
+      const persona = await invoke("create_persona", {
+        input: {
+          displayName: agentName,
+          systemPrompt,
+        },
+      });
+      if (!persona.id) {
+        throw new Error("Mock persona creation did not return an id.");
+      }
+
       const created = await invoke("create_managed_agent", {
         input: {
           name: agentName,
+          personaId: persona.id,
           spawnAfterCreate: true,
           systemPrompt,
         },
@@ -165,6 +176,72 @@ test.beforeEach(async ({ page }) => {
   await installMockBridge(page);
 });
 
+test("profile panel shows communication actions as quick action tiles", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+  await waitForMockLiveSubscription(page, "general");
+
+  await page.evaluate((bobPubkey) => {
+    const emit = (
+      window as Window & {
+        __BUZZ_E2E_EMIT_MOCK_MESSAGE__?: (input: {
+          channelName: string;
+          content: string;
+          pubkey: string;
+        }) => unknown;
+      }
+    ).__BUZZ_E2E_EMIT_MOCK_MESSAGE__;
+    if (!emit) {
+      throw new Error("Mock message emitter is unavailable.");
+    }
+    emit({
+      channelName: "general",
+      content: "Profile action tile check",
+      pubkey: bobPubkey,
+    });
+  }, TEST_IDENTITIES.bob.pubkey);
+
+  const messageRow = page
+    .getByTestId("message-row")
+    .filter({ hasText: "Profile action tile check" });
+  await expect(messageRow).toBeVisible();
+  await messageRow.locator("button").first().click();
+
+  const panel = page.getByTestId("user-profile-panel");
+  await expect(panel).toBeVisible();
+  await expect(panel.getByTestId("user-profile-header-edit-agent")).toHaveCount(
+    0,
+  );
+  const actionGroup = panel.getByTestId("user-profile-primary-actions");
+  await expect(actionGroup).toBeVisible();
+  await expect(actionGroup).toHaveClass(/grid-flow-col/);
+  await expect(actionGroup).toHaveClass(/auto-cols-fr/);
+  const waveAction = panel.getByTestId("user-profile-wave");
+  const messageAction = panel.getByTestId("user-profile-message");
+  const huddleAction = panel.getByTestId("user-profile-huddle");
+  await expect(waveAction).toHaveClass(/flex-col/);
+  await expect(messageAction).toHaveClass(/flex-col/);
+  await expect(huddleAction).toHaveClass(/flex-col/);
+  const communicationActionOrder = await actionGroup
+    .locator("button[data-testid]")
+    .evaluateAll((buttons) =>
+      buttons.map((button) => button.getAttribute("data-testid")),
+    );
+  expect(communicationActionOrder).toEqual([
+    "user-profile-message",
+    "user-profile-huddle",
+    "user-profile-wave",
+  ]);
+  await expect(panel.getByTestId("user-profile-copy-pubkey")).toBeVisible();
+
+  await waveAction.click();
+  await expect(page.getByTestId("chat-title")).toHaveText("bob-tyler");
+  await expect(page.getByTestId("message-wave-attachment")).toBeVisible();
+});
+
 test("keeps the saved profile description after a community round trip", async ({
   page,
 }) => {
@@ -860,7 +937,11 @@ test("renders agent profile ingress subviews from the Playwright mock bridge", a
 }) => {
   await installMockBridge(page, {
     agentMemory: createMockAgentMemoryListing(),
+    // The viewer is the agent's verified NIP-OA owner, so archiveActions
+    // grants the Archive row (canArchive gate; the relay re-verifies on submit).
+    oaOwnerIsMe: true,
   });
+  await page.context().grantPermissions(["clipboard-read", "clipboard-write"]);
   await page.goto("/");
 
   const longAgentInstruction = [
@@ -911,57 +992,538 @@ test("renders agent profile ingress subviews from the Playwright mock bridge", a
   await messageRow.locator("button").first().click();
 
   await expect(page.getByTestId("user-profile-panel")).toBeVisible();
+  await expect(page.getByTestId("user-profile-message")).toBeVisible();
+  await expect(page.getByTestId("user-profile-huddle")).toHaveCount(0);
+  await expect(page.getByTestId("user-profile-wave")).toHaveCount(0);
+  const agentPresenceBadge = page.getByTestId("user-profile-presence-badge");
+  await expect(agentPresenceBadge).toBeVisible();
+  await expect(agentPresenceBadge).toHaveAttribute("aria-label", "Online");
+  const headerEditAgent = page.getByTestId("user-profile-header-edit-agent");
+  await expect(headerEditAgent).toHaveText("Edit");
+  await expect(headerEditAgent.locator("svg")).toHaveCount(0);
+  await expect(
+    page.getByTestId("user-profile-settings-menu-trigger"),
+  ).toHaveCount(0);
+  const closePanelButton = page.getByTestId("auxiliary-panel-close");
+  const headerActionOrder = await headerEditAgent
+    .locator("xpath=..")
+    .locator("button")
+    .evaluateAll((buttons) =>
+      buttons.map((button) => button.getAttribute("data-testid")),
+    );
+  expect(headerActionOrder.at(-2)).toBe("user-profile-header-edit-agent");
+  expect(headerActionOrder.at(-1)).toBe("auxiliary-panel-close");
+  await headerEditAgent.click();
+  await expect(page.getByTestId("persona-dialog")).toBeVisible();
+  await page
+    .getByTestId("persona-dialog")
+    .getByRole("button", { name: "Cancel" })
+    .click();
+  await expect(closePanelButton).toBeVisible();
+  const agentEdit = page.getByTestId("user-profile-edit-agent");
+  const agentEditIcon = page.getByTestId("user-profile-edit-agent-icon");
+  await expect(agentEdit).toBeVisible();
+  await expect(agentEditIcon).toHaveCSS("opacity", "0");
+  await agentEdit.hover();
+  await expect(agentEditIcon).toHaveCSS("opacity", "1");
+  await expect(
+    page.getByTestId("user-profile-agent-primary-action"),
+  ).toHaveAttribute("aria-label", "Stop");
+  await expect(page.getByTestId("user-profile-agent-restart")).toBeVisible();
+  const runningAgentActionOrder = await page
+    .getByTestId("user-profile-primary-actions")
+    .locator("button[data-testid]")
+    .evaluateAll((buttons) =>
+      buttons.map((button) => button.getAttribute("data-testid")),
+    );
+  expect(runningAgentActionOrder).toEqual([
+    "user-profile-agent-primary-action",
+    "user-profile-agent-restart",
+    "user-profile-message",
+  ]);
+  const runningAgentActionWidths = await page
+    .getByTestId("user-profile-primary-actions")
+    .locator("button[data-testid]")
+    .evaluateAll((buttons) =>
+      buttons.map((button) => button.getBoundingClientRect().width),
+    );
+  expect(
+    runningAgentActionWidths.every(
+      (width) => Math.abs(width - runningAgentActionWidths[0]) <= 1,
+    ),
+  ).toBe(true);
+  const agentPrimaryAction = page.getByTestId(
+    "user-profile-agent-primary-action",
+  );
+  await expect(agentPrimaryAction).toHaveClass(/bg-foreground/);
+  await expect(agentPrimaryAction).toHaveClass(/text-background/);
+  await agentPrimaryAction.click();
+  await expect(agentPrimaryAction).toHaveAttribute("aria-label", "Start agent");
+  await expect(agentPresenceBadge).toHaveAttribute("aria-label", "Offline");
+  await expect(agentPrimaryAction).toHaveClass(/bg-foreground/);
+  await expect(agentPrimaryAction).toHaveClass(/text-background/);
+  await expect(page.getByTestId("user-profile-agent-restart")).toHaveCount(0);
+  const stoppedAgentActionOrder = await page
+    .getByTestId("user-profile-primary-actions")
+    .locator("button[data-testid]")
+    .evaluateAll((buttons) =>
+      buttons.map((button) => button.getAttribute("data-testid")),
+    );
+  expect(stoppedAgentActionOrder).toEqual([
+    "user-profile-agent-primary-action",
+    "user-profile-message",
+  ]);
+  await expect(agentPrimaryAction).toBeEnabled();
+  await agentPrimaryAction.click();
+  await expect(agentPrimaryAction).toHaveAttribute("aria-label", "Stop");
+  await expect(agentPresenceBadge).toHaveAttribute("aria-label", "Online");
+  await expect(page.getByTestId("user-profile-agent-restart")).toBeVisible();
   await expectHashSearchParam(page, "profileTab", null);
 
   await expect(page.getByTestId("user-profile-tab-info")).toBeVisible();
-  await expect(page.getByTestId("user-profile-runtime-status")).toHaveAttribute(
-    "data-status",
-    "running",
+  const profileScrollBody = page.getByTestId("user-profile-scroll-body");
+  const profileHeader = page.getByTestId("user-profile-panel-header");
+  const primaryActions = page.getByTestId("user-profile-primary-actions");
+  const stickyHero = page.getByTestId("user-profile-sticky-hero");
+  const stickyTabs = page.getByTestId("user-profile-sticky-tabs");
+  const stickyChromeSurface = page.getByTestId(
+    "user-profile-sticky-chrome-surface",
+  );
+  await expect(stickyHero).toHaveCSS("position", "sticky");
+  await expect(stickyTabs).toHaveCSS("position", "sticky");
+  await expect(stickyTabs).toHaveCSS("padding-top", "8px");
+  await expect(profileHeader).toHaveCSS("backdrop-filter", "none");
+  await expect(stickyHero).toHaveCSS("backdrop-filter", "none");
+  await expect(stickyTabs).toHaveCSS("backdrop-filter", "none");
+  await profileScrollBody.evaluate((element) => {
+    element.scrollTop = 0;
+  });
+  await expect(stickyChromeSurface).toHaveAttribute("data-active", "false");
+  await expect(stickyChromeSurface).toHaveCSS("opacity", "0");
+  await expect(primaryActions).toHaveCSS("opacity", "1");
+  await expect(primaryActions).toHaveCSS("transform", "none");
+  for (const removedFadeTestId of [
+    "user-profile-header-blur-fade",
+    "user-profile-hero-blur-fade",
+    "user-profile-sticky-blur-fade",
+  ]) {
+    await expect(page.getByTestId(removedFadeTestId)).toHaveCount(0);
+  }
+  await page.emulateMedia({ reducedMotion: "reduce" });
+  await profileScrollBody.evaluate((element) => {
+    element.scrollTop = 24;
+  });
+  await expect(primaryActions).not.toHaveAttribute("aria-hidden", "true");
+  await expect(primaryActions).toHaveCSS("opacity", "0.75");
+  await expect(primaryActions).toHaveCSS("transform", "none");
+  await profileScrollBody.evaluate((element) => {
+    element.scrollTop = 48;
+  });
+  await expect(primaryActions).not.toHaveAttribute("aria-hidden", "true");
+  await expect(primaryActions).toHaveCSS("opacity", "0.5");
+  await expect(primaryActions).toHaveCSS("transform", "none");
+  await profileScrollBody.evaluate((element) => {
+    element.scrollTop = 96;
+  });
+  await expect(primaryActions).toHaveAttribute("aria-hidden", "true");
+  await expect(primaryActions).toHaveCSS("opacity", "0");
+  await expect(primaryActions).toHaveCSS("transform", "none");
+  await profileScrollBody.evaluate((element) => {
+    element.scrollTop = 0;
+  });
+  await expect(primaryActions).not.toHaveAttribute("aria-hidden", "true");
+  await expect(primaryActions).toHaveCSS("opacity", "1");
+  await expect(primaryActions).toHaveCSS("transform", "none");
+  await page.emulateMedia({ reducedMotion: "no-preference" });
+  const stickyOffsets = await page
+    .getByTestId("user-profile-summary-scroll-layout")
+    .evaluate((layout) => {
+      const tabs = layout.querySelector<HTMLElement>(
+        '[data-testid="user-profile-sticky-tabs"]',
+      );
+      return {
+        heroHeight: Number.parseFloat(
+          getComputedStyle(layout).getPropertyValue(
+            "--buzz-profile-sticky-hero-height",
+          ),
+        ),
+        tabsTop: tabs ? Number.parseFloat(getComputedStyle(tabs).top) : 0,
+      };
+    });
+  expect(stickyOffsets.heroHeight).toBeGreaterThan(0);
+  expect(stickyOffsets.tabsTop).toBeCloseTo(stickyOffsets.heroHeight, 0);
+  await profileScrollBody.evaluate((element) => {
+    element.scrollTop = element.scrollHeight;
+  });
+  await expect(
+    page.getByTestId("user-profile-primary-actions"),
+  ).not.toBeInViewport();
+  await expect(primaryActions).toHaveCSS("opacity", "0");
+  await expect(stickyChromeSurface).toHaveAttribute("data-active", "true");
+  await expect(stickyChromeSurface).toHaveCSS("opacity", "1");
+  await expect(stickyChromeSurface).toHaveCSS("pointer-events", "none");
+  await expect(stickyChromeSurface).not.toHaveCSS("backdrop-filter", "none");
+  await expect(stickyHero).toBeInViewport();
+  await expect(stickyTabs).toBeInViewport();
+  const stickyChromeRects = await Promise.all(
+    [profileHeader, stickyHero, stickyTabs].map((element) =>
+      element.evaluate((node) => node.getBoundingClientRect().toJSON()),
+    ),
+  );
+  expect(stickyChromeRects[1]?.top).toBeCloseTo(
+    stickyChromeRects[0]?.bottom ?? 0,
+    0,
+  );
+  expect(
+    Math.abs(
+      (stickyChromeRects[2]?.top ?? 0) - (stickyChromeRects[1]?.bottom ?? 0),
+    ),
+  ).toBeLessThanOrEqual(1);
+  const stickySurfaceRect = await stickyChromeSurface.evaluate((node) =>
+    node.getBoundingClientRect().toJSON(),
+  );
+  expect(stickySurfaceRect.top).toBeCloseTo(stickyChromeRects[0]?.top ?? 0, 0);
+  expect(stickySurfaceRect.bottom).toBeCloseTo(
+    stickyChromeRects[2]?.bottom ?? 0,
+    0,
+  );
+  await profileScrollBody.evaluate((element) => {
+    element.scrollTop = 0;
+  });
+  await expect(stickyChromeSurface).toHaveAttribute("data-active", "false");
+  await expect(stickyChromeSurface).toHaveCSS("opacity", "0");
+  await expect(
+    page.getByTestId("user-profile-panel").getByRole("heading", {
+      exact: true,
+      level: 2,
+      name: "Info",
+    }),
+  ).toBeVisible();
+  await expect(page.getByTestId("user-profile-info-sections")).toHaveClass(
+    /space-y-4/,
+  );
+  await expect(
+    page.getByTestId("user-profile-tab-content-transition"),
+  ).toHaveClass(/pt-2/);
+  const infoSection = page.getByTestId("user-profile-info-section");
+  await expect(
+    infoSection.getByRole("heading", { exact: true, name: "Info" }),
+  ).toHaveClass(/text-xs/);
+  await expect(
+    infoSection.getByRole("heading", { exact: true, name: "Info" }),
+  ).toHaveClass(/text-muted-foreground\/70/);
+  await expect(
+    infoSection.locator('[data-slot="panel-section-header"]'),
+  ).toHaveClass(/px-4/);
+  await expect(
+    infoSection
+      .locator('[data-slot="panel-section-card"]')
+      .getByRole("heading", { exact: true, name: "Info" }),
+  ).toHaveCount(0);
+  await expect(
+    page
+      .getByTestId("user-profile-public-key")
+      .locator('[data-slot="profile-field-icon"]'),
+  ).toHaveCount(0);
+  await expect(
+    page
+      .getByTestId("user-profile-managed-by")
+      .locator('[data-slot="profile-field-icon"]'),
+  ).toHaveCount(0);
+  const managedByRow = page.getByTestId("user-profile-managed-by");
+  const managedByActionIndicator = page.getByTestId(
+    "user-profile-managed-by-action-indicator",
+  );
+  await expect(managedByActionIndicator).toHaveCSS("opacity", "0");
+  await managedByRow.hover();
+  await expect(managedByActionIndicator).toHaveCSS("opacity", "1");
+  await expect(page.getByTestId("user-profile-owner-avatar")).toHaveCount(0);
+  await expect(
+    page.getByTestId("user-profile-model-settings-section"),
+  ).toHaveCount(0);
+  await expect(
+    page
+      .getByTestId("user-profile-agent-management-section")
+      .locator('[data-slot="panel-section-header"]'),
+  ).toHaveCount(0);
+  const instructionRow = page.getByTestId("user-profile-agent-instruction-row");
+  await expect(instructionRow).toContainText("Agent instructions");
+  await expect(instructionRow).not.toContainText("View");
+  const publicKeyRow = page.getByTestId("user-profile-public-key");
+  const publicKeyCopy = page.getByTestId("user-profile-public-key-copy-status");
+  await expect(publicKeyCopy).toHaveCSS("opacity", "0");
+  await publicKeyRow.hover();
+  await expect(publicKeyCopy).toHaveCSS("opacity", "1");
+  await publicKeyRow.click();
+  await expect(publicKeyCopy).toHaveAttribute("data-copied", "true");
+  await expect
+    .poll(() => page.evaluate(() => navigator.clipboard.readText()))
+    .toBe(agentPubkey);
+  await expect(page.getByTestId("user-profile-agent-instruction")).toHaveCount(
+    0,
+  );
+  await expect(page.getByTestId("user-profile-edit-agent-row")).toHaveCount(0);
+  await instructionRow.click();
+  await expect(page.getByTestId("persona-dialog")).toBeVisible();
+  await page
+    .getByTestId("persona-dialog")
+    .getByRole("button", {
+      name: "Cancel",
+    })
+    .click();
+  const managementRowOrder = await page
+    .getByTestId("user-profile-agent-management-section")
+    .locator("button[data-testid]")
+    .evaluateAll((buttons) =>
+      buttons.map((button) => button.getAttribute("data-testid")),
+    );
+  expect(managementRowOrder).toEqual([
+    "user-profile-duplicate-agent-row",
+    "user-profile-export-agent-row",
+    "user-profile-archive-agent-row",
+    "user-profile-delete-agent-row",
+  ]);
+  for (const rowTestId of managementRowOrder) {
+    const actionRow = page.getByTestId(rowTestId ?? "");
+    await expect(
+      actionRow.locator(":scope > svg[data-slot='profile-action-icon']"),
+    ).toHaveCount(1);
+    await expect(actionRow.locator(":scope > span.rounded-full")).toHaveCount(
+      0,
+    );
+  }
+  await page.getByTestId("user-profile-duplicate-agent-row").click();
+  const duplicateDialog = page.getByTestId("persona-dialog");
+  await expect(duplicateDialog).toBeVisible();
+  await duplicateDialog.getByRole("button", { name: "Cancel" }).click();
+  await page.getByTestId("user-profile-export-agent-row").click();
+  const exportDialog = page.getByTestId("agent-snapshot-export-dialog");
+  await expect(exportDialog).toBeVisible();
+  await exportDialog.getByRole("button", { name: "Cancel" }).click();
+  const archiveAgentRow = page.getByTestId("user-profile-archive-agent-row");
+  await expect(archiveAgentRow).toHaveText(/Archive agent/);
+  await archiveAgentRow.click();
+  await expect(page.getByTestId("archive-confirm-dialog")).toBeVisible();
+  await page.getByRole("button", { name: "Cancel" }).click();
+  const deleteAgentRow = page.getByTestId("user-profile-delete-agent-row");
+  await expect(deleteAgentRow).toHaveText("Delete agent");
+  await deleteAgentRow.click();
+  await expect(page.getByTestId("agent-delete-confirm-dialog")).toBeVisible();
+  await page.getByRole("button", { name: "Cancel" }).click();
+  await expect(page.getByTestId("user-profile-tab-memories")).toHaveText(
+    "Memories",
+  );
+  await expect(page.getByTestId("user-profile-tab-runtime")).toHaveText(
+    "Runtime",
+  );
+  await expect(page.getByTestId("user-profile-tab-channels")).toHaveText(
+    "Channels",
+  );
+  await expect(page.getByTestId("user-profile-tab-list")).toHaveClass(
+    /bg-muted/,
+  );
+  const actionBackground = await page
+    .getByTestId("user-profile-agent-restart")
+    .evaluate((element) => getComputedStyle(element).backgroundColor);
+  const segmentBackground = await page
+    .getByTestId("user-profile-tab-list")
+    .evaluate((element) => getComputedStyle(element).backgroundColor);
+  expect(actionBackground).toBe(segmentBackground);
+  await expect(page.getByTestId("user-profile-tab-indicator")).toHaveCSS(
+    "transform",
+    "matrix(1, 0, 0, 1, 0, 0)",
+  );
+  await expect(page.getByTestId("user-profile-runtime-status")).toHaveCount(0);
+  await expect(page.getByTestId("user-profile-create-card")).toHaveCount(0);
+  await expect(
+    page.getByTestId("user-profile-model-settings-edit"),
+  ).toHaveCount(0);
+  await expect(page.getByTestId("agent-config-model-copy-status")).toHaveCount(
+    0,
+  );
+  const tabContentTransition = page.getByTestId(
+    "user-profile-tab-content-transition",
+  );
+  await expect(tabContentTransition).toHaveClass(/pt-2/);
+  const tabMotionSamplesPromise = tabContentTransition.evaluate(
+    (container) =>
+      new Promise<Array<{ activeTab: string | undefined; x: number[] }>>(
+        (resolve) => {
+          const samples: Array<{
+            activeTab: string | undefined;
+            x: number[];
+          }> = [];
+          const startedAt = performance.now();
+          const sample = () => {
+            samples.push({
+              activeTab: container.dataset.activeTab,
+              x: Array.from(container.children).map((child) => {
+                const transform = getComputedStyle(child).transform;
+                return transform === "none"
+                  ? 0
+                  : new DOMMatrixReadOnly(transform).m41;
+              }),
+            });
+            if (performance.now() - startedAt < 320) {
+              requestAnimationFrame(sample);
+            } else {
+              resolve(samples);
+            }
+          };
+          requestAnimationFrame(sample);
+        },
+      ),
   );
   await page.getByTestId("user-profile-tab-runtime").click();
-  await expectHashSearchParam(page, "profileTab", "runtime");
-  const instructionPane = page.getByTestId("user-profile-agent-instruction");
-  await expect(instructionPane).toContainText(
-    "Watch the channel and help when asked.",
+  await expect(tabContentTransition).toHaveAttribute(
+    "data-transition-direction",
+    "forward",
+  );
+  const tabMotionSamples = await tabMotionSamplesPromise;
+  expect(
+    tabMotionSamples.some(
+      (sample) => sample.activeTab === "runtime" && sample.x.some((x) => x > 1),
+    ),
+  ).toBe(true);
+  expect(
+    tabMotionSamples.some(
+      (sample) =>
+        sample.activeTab === "runtime" && sample.x.some((x) => x < -1),
+    ),
+  ).toBe(true);
+  await expect
+    .poll(() =>
+      tabContentTransition.evaluate((container) =>
+        Array.from(container.children).every((child) => {
+          const transform = getComputedStyle(child).transform;
+          const x =
+            transform === "none" ? 0 : new DOMMatrixReadOnly(transform).m41;
+          return Math.abs(x) < 1;
+        }),
+      ),
+    )
+    .toBe(true);
+  await expect(page.getByTestId("user-profile-tab-runtime")).toHaveAttribute(
+    "data-state",
+    "active",
   );
-  await expect(instructionPane).toHaveClass(/line-clamp-2/);
-  await page.getByTestId("user-profile-agent-instruction-row").click();
-  await expectHashSearchParam(page, "profileView", "instructions");
   await expect(
-    page.getByRole("heading", { level: 2, name: "Instructions" }),
+    page.getByTestId("user-profile-panel").getByRole("heading", {
+      exact: true,
+      level: 2,
+      name: "Activity",
+    }),
   ).toBeVisible();
   await expect(
-    page.getByTestId("user-profile-agent-instructions-view"),
-  ).toContainText("When uncertainty remains");
-  await page.getByTestId("user-profile-panel-back").click();
-  await expectHashSearchParam(page, "profileView", null);
-  await expectHashSearchParam(page, "profileTab", "runtime");
+    page.getByTestId("user-profile-model-settings-section"),
+  ).toBeVisible();
   await expect(
-    page.getByRole("heading", { level: 2, name: "Profile" }),
+    page.getByTestId("user-profile-panel").getByRole("heading", {
+      exact: true,
+      level: 2,
+      name: "Agent configuration",
+    }),
   ).toBeVisible();
-
-  await page.getByTestId("user-profile-tab-runtime").click();
+  await expect(
+    page.getByTestId("user-profile-agent-instruction-row"),
+  ).toHaveCount(0);
+  const modelEditRow = page.getByRole("button", { name: "Edit Model" });
+  const modelEditIndicator = page.getByTestId(
+    "agent-config-model-edit-indicator",
+  );
+  await expect(modelEditIndicator).toHaveCSS("opacity", "0");
+  await modelEditRow.hover();
+  await expect(modelEditIndicator).toHaveCSS("opacity", "1");
+  await modelEditRow.click();
+  await expect(page.getByTestId("persona-dialog")).toBeVisible();
+  await page
+    .getByTestId("persona-dialog")
+    .getByRole("button", { name: "Cancel" })
+    .click();
+  const acpRow = page.getByTestId("user-profile-acp");
+  const acpCopy = page.getByTestId("user-profile-acp-copy-status");
+  await expect(acpCopy).toHaveCSS("opacity", "0");
+  await acpRow.hover();
+  await expect(acpCopy).toHaveCSS("opacity", "1");
+  const startOnLaunchRow = page.getByTestId("user-profile-start-on-launch");
+  const startOnLaunchToggle = page.getByTestId(
+    "user-profile-start-on-launch-toggle",
+  );
+  await expect(startOnLaunchRow).not.toContainText("Yes");
+  await expect(startOnLaunchRow).toBeChecked();
+  await expect(startOnLaunchToggle).toHaveAttribute("data-state", "checked");
+  await startOnLaunchRow.click();
+  await expect(startOnLaunchRow).not.toBeChecked();
+  await expect(startOnLaunchToggle).toHaveAttribute("data-state", "unchecked");
   await expectHashSearchParam(page, "profileTab", "runtime");
-  // The dedicated Model row was consolidated into the runtime config panel;
-  // Model now renders as a normalized config row with real provenance.
+  const instancesSection = page.getByTestId("user-profile-instances-section");
   await expect(
-    page
-      .getByTestId("user-profile-panel")
-      .getByText("Model", { exact: true })
-      .first(),
-  ).toBeVisible();
-  await expect(page.getByTestId("user-profile-respond-to")).toBeVisible();
+    instancesSection.getByRole("heading", {
+      exact: true,
+      level: 2,
+      name: "Instances",
+    }),
+  ).toHaveClass(/text-xs/);
+  await expect(
+    instancesSection
+      .locator('[data-slot="panel-section-card"]')
+      .getByRole("heading", { exact: true, name: "Instances" }),
+  ).toHaveCount(0);
+  const runtimeSectionHeaderOffsets = await Promise.all(
+    [
+      page.getByTestId("user-profile-runtime-activity-section"),
+      page.getByTestId("user-profile-agent-configuration-section"),
+      page.getByTestId("user-profile-model-settings-section"),
+      instancesSection,
+    ].map((section) =>
+      section.evaluate((element) => {
+        const header = element.querySelector(
+          '[data-slot="panel-section-header"]',
+        );
+        const card = element.querySelector('[data-slot="panel-section-card"]');
+        if (
+          !(header instanceof HTMLElement) ||
+          !(card instanceof HTMLElement)
+        ) {
+          throw new Error("Expected panel section header and card");
+        }
+        return (
+          card.getBoundingClientRect().top - header.getBoundingClientRect().top
+        );
+      }),
+    ),
+  );
+  expect(
+    runtimeSectionHeaderOffsets.every(
+      (offset) => Math.abs(offset - runtimeSectionHeaderOffsets[0]) <= 1,
+    ),
+  ).toBe(true);
+  const instancesRow = page.getByTestId("user-profile-instances");
+  await expect(instancesRow).toContainText("1 instance");
+  await expect(instancesRow).toHaveClass(/min-h-16/);
+  await instancesRow.click();
+  await expect(
+    page.getByTestId(`user-profile-instance-${agentPubkey}`),
+  ).toContainText("Current");
 
-  await page.getByTestId("user-profile-settings-menu-trigger").click();
   await expect(
-    page.getByTestId(`user-profile-agent-auto-start-${agentPubkey}`),
-  ).toBeVisible();
-  await page.keyboard.press("Escape");
+    page.getByTestId("user-profile-settings-menu-trigger"),
+  ).toHaveCount(0);
 
-  await page.getByTestId("user-profile-diagnostics-ingress").click();
+  const diagnosticsIngress = page.getByTestId(
+    "user-profile-diagnostics-ingress",
+  );
+  await expect(diagnosticsIngress).not.toContainText("View");
+  await expect(
+    diagnosticsIngress.locator("svg.lucide-chevron-right"),
+  ).toBeVisible();
+  await expect(diagnosticsIngress.locator("svg.lucide-chevron-up")).toHaveCount(
+    0,
+  );
+  await diagnosticsIngress.click();
   await expectHashSearchParam(page, "profileView", "diagnostics");
   await expect(
-    page.getByRole("heading", { level: 2, name: "Harness Log" }),
+    page.getByRole("heading", { level: 2, name: "Harness log" }),
   ).toBeVisible();
   await expect(page.getByTestId("user-profile-agent-status")).toHaveCount(0);
   await expect(page.getByTestId("managed-agent-log-content")).toBeVisible();
@@ -973,6 +1535,9 @@ test("renders agent profile ingress subviews from the Playwright mock bridge", a
   ).toBeVisible();
 
   await page.getByTestId("user-profile-tab-info").click();
+  await expect(
+    page.getByTestId("user-profile-tab-content-transition"),
+  ).toHaveAttribute("data-transition-direction", "backward");
   await expectHashSearchParam(page, "profileTab", null);
   await page.getByTestId(`user-profile-view-activity-${agentPubkey}`).click();
   await expect(page.getByTestId("agent-session-thread-panel")).toBeVisible();
@@ -984,12 +1549,36 @@ test("renders agent profile ingress subviews from the Playwright mock bridge", a
 
   await page.getByTestId("user-profile-tab-channels").click();
   await expectHashSearchParam(page, "profileTab", "channels");
+  await expect(
+    page.getByTestId("user-profile-panel").getByRole("heading", {
+      exact: true,
+      level: 2,
+      name: "Channels",
+    }),
+  ).toHaveCount(0);
+  await expect(
+    page
+      .getByTestId("user-profile-channels-section")
+      .locator('[data-slot="panel-section-header"]'),
+  ).toHaveCount(0);
   await expect(page.getByTestId("user-profile-channels-list")).toContainText(
     "#general",
   );
 
   await page.getByTestId("user-profile-tab-memories").click();
   await expectHashSearchParam(page, "profileTab", "memories");
+  await expect(
+    page.getByTestId("user-profile-panel").getByRole("heading", {
+      exact: true,
+      level: 2,
+      name: "Memories",
+    }),
+  ).toHaveCount(0);
+  await expect(
+    page
+      .getByTestId("user-profile-memories-section")
+      .locator('[data-slot="panel-section-header"]'),
+  ).toHaveCount(0);
   await expect(page.getByTestId("agent-memory-section")).toBeVisible();
   await expect(page.getByTestId("agent-memory-list")).toContainText(
     "ui-density",
diff --git a/desktop/tests/e2e/pubkey-display-screenshots.spec.ts b/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
index 79f7ada8b26..77630467da1 100644
--- a/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
+++ b/desktop/tests/e2e/pubkey-display-screenshots.spec.ts
@@ -14,7 +14,7 @@ const AGENT_PUBKEY = "cafef00d".repeat(8);
 // Screenshot evidence for the pubkey-display work: the canonical profile
 // surfaces, plus the new-DM recipient identity-hover states retained by it.
 
-test("profile panel Public key row opens the PubKey popover on hover", async ({
+test("profile panel Public key row reveals its copy action on hover", async ({
   page,
 }) => {
   await installMockBridge(page);
@@ -28,18 +28,15 @@ test("profile panel Public key row opens the PubKey popover on hover", async ({
   await messageRow.locator("button").first().click();
   await expect(page.getByTestId("user-profile-panel")).toBeVisible();
 
-  const pubkeyTrigger = page.getByTestId("user-profile-copy-pubkey");
-  await expect(pubkeyTrigger).toBeVisible();
-  await pubkeyTrigger.hover();
-
-  // Hover-open fires after a 500ms intent delay.
-  await expect(page.getByText("hex", { exact: true })).toBeVisible({
-    timeout: 3_000,
-  });
-  await expect(page.getByText("npub", { exact: true })).toBeVisible();
+  const pubkeyRow = page.getByTestId("user-profile-public-key");
+  const copyIndicator = page.getByTestId("user-profile-public-key-copy-status");
+  await expect(page.getByTestId("user-profile-copy-pubkey")).toBeVisible();
+  await expect(copyIndicator).toHaveCSS("opacity", "0");
+  await pubkeyRow.hover();
+  await expect(copyIndicator).toHaveCSS("opacity", "1");
   await waitForAnimations(page);
   await page.screenshot({
-    path: `${SHOTS}/profile-panel-pubkey-hover-popover.png`,
+    path: `${SHOTS}/profile-panel-pubkey-hover-copy.png`,
   });
 });
 
diff --git a/desktop/tests/e2e/sidebar-snapshot.spec.ts b/desktop/tests/e2e/sidebar-snapshot.spec.ts
new file mode 100644
index 00000000000..eaf8797f11e
--- /dev/null
+++ b/desktop/tests/e2e/sidebar-snapshot.spec.ts
@@ -0,0 +1,599 @@
+import { expect, test, type Page } from "@playwright/test";
+
+import { installMockBridge } from "../helpers/bridge";
+
+const RELAY_URL = "ws://localhost:3000";
+const OTHER_RELAY_URL = "ws://localhost:3001";
+const OWNER_PUBKEY = "deadbeef".repeat(8);
+const STALE_COMMUNITY_PUBKEY = "cafebabe".repeat(8);
+const MATCHING_HASH = "mock-hash";
+const READ_DELAY_MS = 600;
+const SNAPSHOT_FRAME_DELAY_MS = 3_000;
+
+function snapshotKey(relayUrl: string, ownerPubkey = OWNER_PUBKEY) {
+  return `buzz-channels.v1:${relayUrl}:${ownerPubkey.toLowerCase()}`;
+}
+
+function makeSnapshotChannel(index: number, prefix = "snapshot") {
+  return {
+    id: `${prefix}-${index}`,
+    name: `${prefix}-${String(index).padStart(2, "0")}`,
+    channelType: "stream",
+    visibility: "open",
+    description: "",
+    topic: null,
+    purpose: null,
+    memberCount: 1,
+    memberPubkeys: [OWNER_PUBKEY],
+    lastMessageAt: null,
+    archivedAt: null,
+    participants: [],
+    participantPubkeys: [],
+    isMember: true,
+    ttlSeconds: null,
+    ttlDeadline: null,
+  };
+}
+
+const FULL_SNAPSHOT = Array.from({ length: 14 }, (_, index) =>
+  makeSnapshotChannel(index),
+);
+const SNAPSHOT_DIAGNOSTIC_MARK = "buzz:sidebar:snapshot-diagnostic";
+const FULL_SIDEBAR_PAINT_MARK = "buzz:sidebar:full-list-painted";
+const BOOT_TO_FULL_SIDEBAR_MEASURE = "buzz:sidebar:boot-to-full-list-painted";
+
+function snapshotIntegrity(
+  ownerPubkey: string,
+  hash: string,
+  channels: ReturnType<typeof makeSnapshotChannel>[],
+) {
+  const value = JSON.stringify([ownerPubkey.toLowerCase(), hash, channels]);
+  let result = 0x811c9dc5;
+  for (let index = 0; index < value.length; index += 1) {
+    result ^= value.charCodeAt(index);
+    result = Math.imul(result, 0x01000193);
+  }
+  return (result >>> 0).toString(16).padStart(8, "0");
+}
+
+type SnapshotDiagnostics = {
+  ageMs: number;
+  channelCount: number;
+  presence: "absent" | "invalid" | "present";
+  serializedBytes: number;
+};
+
+async function getSnapshotDiagnostic(page: Page) {
+  return page.evaluate((name) => {
+    const entry = performance.getEntriesByName(name).at(-1) as
+      | PerformanceMark
+      | undefined;
+    return entry?.detail as SnapshotDiagnostics | undefined;
+  }, SNAPSHOT_DIAGNOSTIC_MARK);
+}
+
+async function getFullSidebarMeasure(page: Page) {
+  return page.evaluate(
+    ({ markName, measureName }) => ({
+      markCount: performance.getEntriesByName(markName).length,
+      measure: performance.getEntriesByName(measureName).at(-1)?.duration,
+    }),
+    {
+      markName: FULL_SIDEBAR_PAINT_MARK,
+      measureName: BOOT_TO_FULL_SIDEBAR_MEASURE,
+    },
+  );
+}
+
+async function seedSnapshot(
+  page: Page,
+  options: {
+    channels?: ReturnType<typeof makeSnapshotChannel>[];
+    hash: string;
+    keyOwnerPubkey?: string;
+    ownerPubkey?: string;
+    relayUrl?: string;
+  },
+) {
+  const channels = options.channels ?? FULL_SNAPSHOT;
+  const ownerPubkey = options.ownerPubkey ?? OWNER_PUBKEY;
+  await page.addInitScript(
+    ({ channels, hash, integrity, key, ownerPubkey }) => {
+      window.localStorage.setItem(
+        key,
+        JSON.stringify({
+          version: 2,
+          updatedAt: Date.now(),
+          ownerPubkey,
+          hash,
+          channels,
+          integrity,
+        }),
+      );
+    },
+    {
+      channels,
+      hash: options.hash,
+      integrity: snapshotIntegrity(ownerPubkey, options.hash, channels),
+      key: snapshotKey(
+        options.relayUrl ?? RELAY_URL,
+        options.keyOwnerPubkey ?? ownerPubkey,
+      ),
+      ownerPubkey,
+    },
+  );
+}
+
+async function seedCommunities(page: Page, communityPubkey = OWNER_PUBKEY) {
+  await page.addInitScript(
+    ({ communityPubkey, relayA, relayB }) => {
+      const communities = [
+        {
+          id: "community-a",
+          name: "Alpha",
+          relayUrl: relayA,
+          pubkey: communityPubkey,
+          addedAt: "2026-01-01T00:00:00.000Z",
+        },
+        {
+          id: "community-b",
+          name: "Bravo",
+          relayUrl: relayB,
+          pubkey: communityPubkey,
+          addedAt: "2026-01-02T00:00:00.000Z",
+        },
+      ];
+      window.localStorage.setItem(
+        "buzz-communities",
+        JSON.stringify(communities),
+      );
+      window.localStorage.setItem(
+        "buzz-active-community-id",
+        communities[0].id,
+      );
+    },
+    { communityPubkey, relayA: RELAY_URL, relayB: OTHER_RELAY_URL },
+  );
+}
+
+async function getChannelsPayloads(page: Page) {
+  return page.evaluate(() =>
+    (window.__BUZZ_E2E_COMMAND_LOG__ ?? [])
+      .filter((entry) => entry.command === "get_channels")
+      .map((entry) => entry.payload as { knownHash?: unknown }),
+  );
+}
+
+async function mutateDisplayedChannels(page: Page, channelName: string) {
+  await page.evaluate((name) => {
+    const queryClient = window.__BUZZ_E2E_QUERY_CLIENT__ as
+      | {
+          setQueryData: (
+            queryKey: readonly string[],
+            updater: (
+              channels: ReturnType<typeof makeSnapshotChannel>[] | undefined,
+            ) => ReturnType<typeof makeSnapshotChannel>[],
+          ) => unknown;
+        }
+      | undefined;
+    if (!queryClient) {
+      throw new Error("E2E query client seam is not installed.");
+    }
+    queryClient.setQueryData(["channels"], (channels) => {
+      const template = channels?.[0];
+      if (!template) {
+        throw new Error("Displayed channel cache is empty.");
+      }
+      return [...channels, { ...template, id: "optimistic-channel", name }];
+    });
+  }, channelName);
+}
+
+async function readPersistedSnapshot(page: Page) {
+  return page.evaluate((key) => {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return null;
+    const snapshot = JSON.parse(raw) as {
+      channels: Array<{ name: string }>;
+      hash: string;
+    };
+    return {
+      channelNames: snapshot.channels.map((channel) => channel.name),
+      hash: snapshot.hash,
+    };
+  }, snapshotKey(RELAY_URL));
+}
+
+async function trackSnapshotRows(page: Page) {
+  await page.addInitScript(() => {
+    const testWindow = window as Window & {
+      __BUZZ_E2E_SNAPSHOT_ROWS_SEEN__?: string[];
+    };
+    const seen: string[] = [];
+    testWindow.__BUZZ_E2E_SNAPSHOT_ROWS_SEEN__ = seen;
+    const record = (node: Node) => {
+      if (!(node instanceof Element)) return;
+      const rows = node.matches('[data-channel-id^="snapshot-"]')
+        ? [node]
+        : Array.from(node.querySelectorAll('[data-channel-id^="snapshot-"]'));
+      for (const row of rows) {
+        const id = row.getAttribute("data-channel-id");
+        if (id && !seen.includes(id)) seen.push(id);
+      }
+    };
+    new MutationObserver((records) => {
+      for (const mutation of records) {
+        for (const node of mutation.addedNodes) record(node);
+      }
+    }).observe(document, { childList: true, subtree: true });
+  });
+}
+
+async function getTrackedSnapshotRows(page: Page) {
+  return page.evaluate(
+    () =>
+      (
+        window as Window & {
+          __BUZZ_E2E_SNAPSHOT_ROWS_SEEN__?: string[];
+        }
+      ).__BUZZ_E2E_SNAPSHOT_ROWS_SEEN__ ?? [],
+  );
+}
+
+test("cold boot paints the complete snapshot, sends its hash, and revalidates", async ({
+  page,
+}) => {
+  await seedSnapshot(page, { hash: MATCHING_HASH });
+  await installMockBridge(page, {
+    channelsReadDelayMs: SNAPSHOT_FRAME_DELAY_MS,
+    honorChannelsKnownHash: true,
+  });
+
+  const navigationStartedAt = performance.now();
+  await page.goto("/");
+  const rows = page.locator('[data-channel-id^="snapshot-"]');
+  await expect(rows).toHaveCount(FULL_SNAPSHOT.length, { timeout: 2_000 });
+  const snapshotPaintedAt = performance.now();
+  expect(snapshotPaintedAt - navigationStartedAt).toBeLessThan(
+    SNAPSHOT_FRAME_DELAY_MS,
+  );
+  await expect(page.getByTestId("sidebar-loading")).toHaveCount(0);
+  await expect
+    .poll(() => getChannelsPayloads(page))
+    .toEqual([{ knownHash: MATCHING_HASH }]);
+  await expect
+    .poll(() => getSnapshotDiagnostic(page))
+    .toMatchObject({
+      channelCount: FULL_SNAPSHOT.length,
+      presence: "present",
+    });
+  const diagnostics = await getSnapshotDiagnostic(page);
+  expect(diagnostics?.serializedBytes).toBeGreaterThan(0);
+  expect(diagnostics?.ageMs).toBeGreaterThanOrEqual(0);
+
+  // The persisted data is deliberately stale: it paints immediately but still
+  // validates. The delayed matching response leaves a deterministic snapshot
+  // frame, then not-modified must not shrink the list.
+  await expect(rows).toHaveCount(FULL_SNAPSHOT.length);
+  await expect
+    .poll(() => getFullSidebarMeasure(page))
+    .toEqual({
+      markCount: expect.any(Number),
+      measure: expect.any(Number),
+    });
+  expect((await getFullSidebarMeasure(page)).markCount).toBeGreaterThan(0);
+
+  const liveSettledAt = performance.now();
+  console.info(
+    `[sidebar-snapshot] firstPaint=${Math.round(snapshotPaintedAt - navigationStartedAt)}ms snapshotToLive=${Math.round(liveSettledAt - snapshotPaintedAt)}ms rows=${FULL_SNAPSHOT.length}`,
+  );
+});
+
+test("matching not-modified preserves display mutations without persisting them", async ({
+  page,
+}) => {
+  const optimisticName = "optimistic-local-channel";
+  await seedSnapshot(page, { hash: MATCHING_HASH });
+  await installMockBridge(page, {
+    channelsReadDelayMs: READ_DELAY_MS,
+    honorChannelsKnownHash: true,
+  });
+  await page.goto("/");
+
+  await expect(page.locator('[data-channel-id^="snapshot-"]')).toHaveCount(
+    FULL_SNAPSHOT.length,
+    { timeout: 500 },
+  );
+  await mutateDisplayedChannels(page, optimisticName);
+  await expect(
+    page.locator('[data-channel-id="optimistic-channel"]'),
+  ).toBeVisible();
+
+  await expect
+    .poll(() => getChannelsPayloads(page))
+    .toEqual([{ knownHash: MATCHING_HASH }]);
+  await expect
+    .poll(() => readPersistedSnapshot(page))
+    .toEqual({
+      channelNames: FULL_SNAPSHOT.map((channel) => channel.name),
+      hash: MATCHING_HASH,
+    });
+  await expect(
+    page.locator('[data-channel-id="optimistic-channel"]'),
+  ).toBeVisible();
+  expect((await readPersistedSnapshot(page))?.channelNames).not.toContain(
+    optimisticName,
+  );
+});
+
+test("first-ever boot without a snapshot sends null and shows loading", async ({
+  page,
+}) => {
+  await installMockBridge(page, { channelsReadDelayMs: READ_DELAY_MS });
+  await page.goto("/");
+
+  await expect(page.getByTestId("sidebar-loading")).toBeVisible({
+    timeout: 500,
+  });
+  await expect(page.locator('[data-channel-id^="snapshot-"]')).toHaveCount(0);
+  await expect
+    .poll(() => getChannelsPayloads(page))
+    .toEqual([{ knownHash: null }]);
+  await expect
+    .poll(() => getSnapshotDiagnostic(page))
+    .toMatchObject({
+      channelCount: 0,
+      presence: "absent",
+      serializedBytes: 0,
+    });
+  await expect(page.getByTestId("channel-general")).toBeVisible();
+  await expect
+    .poll(() => getFullSidebarMeasure(page))
+    .toEqual({
+      markCount: expect.any(Number),
+      measure: expect.any(Number),
+    });
+  expect((await getFullSidebarMeasure(page)).markCount).toBeGreaterThan(0);
+});
+
+test("a different identity's snapshot is ignored", async ({ page }) => {
+  await seedSnapshot(page, {
+    hash: "foreign-hash",
+    keyOwnerPubkey: OWNER_PUBKEY,
+    ownerPubkey: STALE_COMMUNITY_PUBKEY,
+  });
+  await installMockBridge(page, { channelsReadDelayMs: READ_DELAY_MS });
+  await page.goto("/");
+
+  await expect(page.getByTestId("sidebar-loading")).toBeVisible({
+    timeout: 500,
+  });
+  await expect(page.locator('[data-channel-id^="snapshot-"]')).toHaveCount(0);
+  await expect
+    .poll(() => getChannelsPayloads(page))
+    .toEqual([{ knownHash: null }]);
+  await expect
+    .poll(() => getSnapshotDiagnostic(page))
+    .toMatchObject({
+      channelCount: 0,
+      presence: "invalid",
+    });
+  await expect(page.getByTestId("channel-general")).toBeVisible();
+});
+
+test("display-only community pubkey cannot expose another identity's snapshot", async ({
+  page,
+}) => {
+  await seedSnapshot(page, {
+    hash: "stale-community-identity-hash",
+    ownerPubkey: STALE_COMMUNITY_PUBKEY,
+  });
+  await trackSnapshotRows(page);
+  await installMockBridge(
+    page,
+    { channelsReadDelayMs: READ_DELAY_MS },
+    { skipCommunitySeed: true },
+  );
+  await seedCommunities(page, STALE_COMMUNITY_PUBKEY);
+  await page.goto("/");
+
+  await expect(page.getByTestId("channel-general")).toBeVisible();
+  expect(await getTrackedSnapshotRows(page)).toEqual([]);
+  const payloads = await getChannelsPayloads(page);
+  expect(payloads).toEqual([{ knownHash: null }]);
+  expect(payloads).not.toContainEqual({
+    knownHash: "stale-community-identity-hash",
+  });
+});
+
+test("partial hash/list write fails toward a full fetch", async ({ page }) => {
+  await seedSnapshot(page, { hash: MATCHING_HASH });
+  await page.addInitScript((key) => {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return;
+    const snapshot = JSON.parse(raw) as { hash: string };
+    window.localStorage.setItem(
+      key,
+      JSON.stringify({ ...snapshot, hash: "newer-partial-hash" }),
+    );
+  }, snapshotKey(RELAY_URL));
+  await installMockBridge(page, {
+    channelsReadDelayMs: READ_DELAY_MS,
+    honorChannelsKnownHash: true,
+  });
+  await page.goto("/");
+
+  await expect(page.getByTestId("sidebar-loading")).toBeVisible({
+    timeout: 500,
+  });
+  await expect(page.locator('[data-channel-id^="snapshot-"]')).toHaveCount(0);
+  await expect
+    .poll(() => getChannelsPayloads(page))
+    .toEqual([{ knownHash: null }]);
+  await expect
+    .poll(() => getSnapshotDiagnostic(page))
+    .toMatchObject({
+      channelCount: 0,
+      presence: "invalid",
+    });
+  await expect(page.getByTestId("channel-general")).toBeVisible();
+  await expect(page.locator('[data-channel-id^="snapshot-"]')).toHaveCount(0);
+});
+
+test("unexpected not-modified response retries without a hash", async ({
+  page,
+}) => {
+  await installMockBridge(page, {
+    channelsNotModifiedResponses: 1,
+  });
+  await page.goto("/");
+
+  await expect(page.getByTestId("channel-general")).toBeVisible();
+  await expect
+    .poll(() => getChannelsPayloads(page))
+    .toEqual([{ knownHash: null }, { knownHash: null }]);
+});
+
+test("mismatched not-modified hash falls back to a full list", async ({
+  page,
+}) => {
+  await seedSnapshot(page, { hash: "persisted-stale-hash" });
+  await installMockBridge(page, {
+    channelsReadDelayMs: READ_DELAY_MS,
+    channelsNotModifiedResponses: 1,
+  });
+  await page.goto("/");
+
+  const snapshotRows = page.locator('[data-channel-id^="snapshot-"]');
+  await expect(snapshotRows).toHaveCount(FULL_SNAPSHOT.length, {
+    timeout: 500,
+  });
+  await expect
+    .poll(() => getChannelsPayloads(page))
+    .toEqual([{ knownHash: "persisted-stale-hash" }, { knownHash: null }]);
+
+  // The stale snapshot may provide the immediate boot frame, but an impossible
+  // not-modified hash/list pairing must never survive as the settled result.
+  await expect(page.getByTestId("channel-general")).toBeVisible();
+  await expect(snapshotRows).toHaveCount(0);
+  await expect
+    .poll(() =>
+      page.evaluate((key) => {
+        const raw = window.localStorage.getItem(key);
+        if (!raw) return null;
+        const snapshot = JSON.parse(raw) as {
+          channels: Array<{ name: string }>;
+          hash: string;
+        };
+        return {
+          hash: snapshot.hash,
+          hasGeneral: snapshot.channels.some(
+            (channel) => channel.name === "general",
+          ),
+          hasSnapshotRow: snapshot.channels.some((channel) =>
+            channel.name.startsWith("snapshot-"),
+          ),
+        };
+      }, snapshotKey(RELAY_URL)),
+    )
+    .toEqual({ hash: MATCHING_HASH, hasGeneral: true, hasSnapshotRow: false });
+});
+
+test("hash mismatch replaces the snapshot with the full live list", async ({
+  page,
+}) => {
+  await seedSnapshot(page, { hash: "stale-hash" });
+  await installMockBridge(page, {
+    channelsReadDelayMs: READ_DELAY_MS,
+    honorChannelsKnownHash: true,
+  });
+  await page.goto("/");
+
+  await expect(page.locator('[data-channel-id^="snapshot-"]')).toHaveCount(
+    FULL_SNAPSHOT.length,
+    { timeout: 500 },
+  );
+  await expect
+    .poll(() => getChannelsPayloads(page))
+    .toEqual([{ knownHash: "stale-hash" }]);
+  await expect(page.getByTestId("channel-general")).toBeVisible();
+  await expect(page.locator('[data-channel-id^="snapshot-"]')).toHaveCount(0);
+  await expect
+    .poll(() =>
+      page.evaluate((key) => {
+        const raw = window.localStorage.getItem(key);
+        if (!raw) return null;
+        const snapshot = JSON.parse(raw) as {
+          channels: Array<{ name: string }>;
+          hash: string;
+        };
+        return {
+          hash: snapshot.hash,
+          hasGeneral: snapshot.channels.some(
+            (channel) => channel.name === "general",
+          ),
+          hasSnapshotRow: snapshot.channels.some((channel) =>
+            channel.name.startsWith("snapshot-"),
+          ),
+        };
+      }, snapshotKey(RELAY_URL)),
+    )
+    .toEqual({ hash: MATCHING_HASH, hasGeneral: true, hasSnapshotRow: false });
+});
+
+test("community switch validates a stale relay snapshot and replaces it", async ({
+  page,
+}) => {
+  const switchedSnapshot = Array.from({ length: 6 }, (_, index) =>
+    makeSnapshotChannel(index, "switched"),
+  );
+  await seedSnapshot(page, {
+    channels: switchedSnapshot,
+    hash: "stale-community-hash",
+    relayUrl: OTHER_RELAY_URL,
+  });
+  await installMockBridge(
+    page,
+    {
+      channelsReadDelayMs: READ_DELAY_MS,
+      honorChannelsKnownHash: true,
+    },
+    { skipCommunitySeed: true },
+  );
+  await seedCommunities(page);
+  await page.goto("/");
+  await expect(page.getByTestId("app-sidebar")).toBeVisible();
+
+  const payloadCountBeforeSwitch = (await getChannelsPayloads(page)).length;
+  await page.getByTestId("community-rail-button-community-b").click();
+  const switchedRows = page.locator('[data-channel-id^="switched-"]');
+  await expect(switchedRows).toHaveCount(switchedSnapshot.length, {
+    timeout: 500,
+  });
+  await expect
+    .poll(async () =>
+      (await getChannelsPayloads(page)).slice(payloadCountBeforeSwitch).at(0),
+    )
+    .toEqual({ knownHash: "stale-community-hash" });
+
+  await expect(page.getByTestId("channel-general")).toBeVisible();
+  await expect(switchedRows).toHaveCount(0);
+  await expect
+    .poll(() =>
+      page.evaluate((key) => {
+        const raw = window.localStorage.getItem(key);
+        if (!raw) return null;
+        const snapshot = JSON.parse(raw) as {
+          channels: Array<{ name: string }>;
+          hash: string;
+        };
+        return {
+          hash: snapshot.hash,
+          hasGeneral: snapshot.channels.some(
+            (channel) => channel.name === "general",
+          ),
+        };
+      }, snapshotKey(OTHER_RELAY_URL)),
+    )
+    .toEqual({ hash: MATCHING_HASH, hasGeneral: true });
+});
diff --git a/desktop/tests/helpers/bridge.ts b/desktop/tests/helpers/bridge.ts
index 50f792447c0..31af66ab0ac 100644
--- a/desktop/tests/helpers/bridge.ts
+++ b/desktop/tests/helpers/bridge.ts
@@ -267,6 +267,11 @@ type MockBridgeOptions = {
   ensureStarterChannelsErrors?: string[];
   /** Reject successive mock `join_channel` calls, then resume. */
   joinChannelErrors?: string[];
+  channelsReadDelayMs?: number;
+  /** Return not-modified for this many reads before resuming full payloads. */
+  channelsNotModifiedResponses?: number;
+  /** When true, a matching knownHash returns a not-modified channel payload. */
+  honorChannelsKnownHash?: boolean;
   /** Number of seeded rows in the deep-history fixture. Defaults to 600. */
   deepHistoryMessageCount?: number;
   feedReadError?: string;
@@ -275,6 +280,8 @@ type MockBridgeOptions = {
   applyCommunityDelayMs?: number;
   openDmDelayMs?: number;
   sendMessageDelayMs?: number;
+  /** Hold the media proxy at port 0 until the E2E release seam is invoked. */
+  mediaProxyInitiallyUnavailable?: boolean;
   /** Hold mock send live echoes until the E2E release seam is invoked. */
   deferSendMessageLiveEcho?: boolean;
   /** Close the first channel-window live REQ; its retry is accepted. */
diff --git a/migrations/0031_community_deletion.sql b/migrations/0031_community_deletion.sql
new file mode 100644
index 00000000000..a140b356814
--- /dev/null
+++ b/migrations/0031_community_deletion.sql
@@ -0,0 +1,575 @@
+-- Durable, CLI-only whole-community deletion control plane.
+--
+-- The community row is never removed: it becomes the permanent name tombstone.
+-- All destructive progress is lease/fence/checkpoint guarded and every existing
+-- community-scoped table receives the same database-enforced write fence.
+-- This migration intentionally remains one atomic catalog change so a failed
+-- deployment cannot expose only a subset of the universal fences. CREATE
+-- TRIGGER takes SHARE ROW EXCLUSIVE on each target; fail quickly rather than
+-- queueing behind long transactions. See the chart deletion rollout runbook.
+SET LOCAL lock_timeout = '5s';
+
+ALTER TABLE communities
+    ADD COLUMN deletion_state TEXT NOT NULL DEFAULT 'active'
+        CHECK (deletion_state IN ('active', 'quiescing', 'fenced', 'tombstone')),
+    ADD COLUMN deletion_fence_generation BIGINT NOT NULL DEFAULT 0
+        CHECK (deletion_fence_generation >= 0),
+    ADD COLUMN deleted_at TIMESTAMPTZ;
+
+CREATE TABLE community_deletion_requests (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    community_id UUID NOT NULL UNIQUE REFERENCES communities(id),
+    community_host TEXT NOT NULL,
+    stage TEXT NOT NULL DEFAULT 'submitted' CHECK (stage IN (
+        'submitted', 'inventoried', 'approved', 'fenced', 'drained',
+        'bindings_removed', 'postgres_purged', 'cache_purged',
+        'logically_verified', 'retention_pending'
+    )),
+    requested_by TEXT NOT NULL,
+    reason TEXT,
+    schema_manifest JSONB,
+    storage_manifest JSONB,
+    destructive_storage_manifest JSONB,
+    destructive_storage_frozen_at TIMESTAMPTZ,
+    inventory_manifest JSONB,
+    inventory_digest BYTEA CHECK (inventory_digest IS NULL OR length(inventory_digest) = 32),
+    inventory_frozen_at TIMESTAMPTZ,
+    fence_generation BIGINT CHECK (fence_generation IS NULL OR fence_generation > 0),
+    lease_owner TEXT,
+    lease_generation BIGINT NOT NULL DEFAULT 0 CHECK (lease_generation >= 0),
+    lease_until TIMESTAMPTZ,
+    attempts INTEGER NOT NULL DEFAULT 0 CHECK (attempts >= 0),
+    retry_count INTEGER NOT NULL DEFAULT 0 CHECK (retry_count >= 0),
+    retry_stage TEXT CHECK (retry_stage IS NULL OR retry_stage IN (
+        'approved', 'fenced', 'drained', 'bindings_removed',
+        'postgres_purged', 'cache_purged', 'logically_verified'
+    )),
+    next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    last_error TEXT,
+    last_error_at TIMESTAMPTZ,
+    blocked_at TIMESTAMPTZ,
+    blocked_reason TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    completed_at TIMESTAMPTZ,
+    CHECK ((blocked_at IS NULL) = (blocked_reason IS NULL)),
+    CHECK ((inventory_frozen_at IS NULL) = (inventory_digest IS NULL)),
+    UNIQUE (id, community_id, inventory_digest)
+);
+CREATE INDEX community_deletion_requests_runnable
+    ON community_deletion_requests (next_attempt_at, created_at)
+    WHERE blocked_at IS NULL
+      AND stage IN ('approved', 'fenced', 'drained', 'bindings_removed',
+                    'postgres_purged', 'cache_purged', 'logically_verified');
+CREATE INDEX community_deletion_requests_lease
+    ON community_deletion_requests (lease_until)
+    WHERE lease_owner IS NOT NULL;
+
+CREATE TABLE community_deletion_approvals (
+    request_id UUID PRIMARY KEY,
+    community_id UUID NOT NULL,
+    inventory_digest BYTEA NOT NULL CHECK (length(inventory_digest) = 32),
+    approved_by TEXT NOT NULL,
+    note TEXT,
+    approved_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    FOREIGN KEY (request_id, community_id, inventory_digest)
+        REFERENCES community_deletion_requests(id, community_id, inventory_digest)
+        ON DELETE RESTRICT
+);
+
+-- The approval identity is only meaningful while its frozen target and
+-- inventory remain unchanged. Make those facts irreversible in the database,
+-- not merely conventions in the worker.
+CREATE FUNCTION prevent_community_deletion_request_retargeting()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    IF NEW.community_id IS DISTINCT FROM OLD.community_id
+        OR NEW.community_host IS DISTINCT FROM OLD.community_host
+    THEN
+        RAISE EXCEPTION 'community deletion target identity is immutable'
+            USING ERRCODE = 'integrity_constraint_violation';
+    END IF;
+    IF OLD.inventory_frozen_at IS NOT NULL AND (
+        NEW.schema_manifest IS DISTINCT FROM OLD.schema_manifest
+        OR NEW.storage_manifest IS DISTINCT FROM OLD.storage_manifest
+        OR NEW.inventory_manifest IS DISTINCT FROM OLD.inventory_manifest
+        OR NEW.inventory_digest IS DISTINCT FROM OLD.inventory_digest
+        OR NEW.inventory_frozen_at IS DISTINCT FROM OLD.inventory_frozen_at
+    ) THEN
+        RAISE EXCEPTION 'frozen community deletion inventory is immutable'
+            USING ERRCODE = 'integrity_constraint_violation';
+    END IF;
+    IF OLD.destructive_storage_frozen_at IS NOT NULL AND (
+        NEW.destructive_storage_manifest IS DISTINCT FROM OLD.destructive_storage_manifest
+        OR NEW.destructive_storage_frozen_at IS DISTINCT FROM OLD.destructive_storage_frozen_at
+    ) THEN
+        RAISE EXCEPTION 'frozen destructive storage manifest is immutable'
+            USING ERRCODE = 'integrity_constraint_violation';
+    END IF;
+    RETURN NEW;
+END;
+$$;
+
+CREATE TRIGGER community_deletion_request_retargeting_guard
+BEFORE UPDATE ON community_deletion_requests
+FOR EACH ROW
+EXECUTE FUNCTION prevent_community_deletion_request_retargeting();
+
+CREATE FUNCTION prevent_community_deletion_approval_removal()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    RAISE EXCEPTION 'community deletion approval evidence is immutable'
+        USING ERRCODE = 'integrity_constraint_violation';
+END;
+$$;
+
+CREATE TRIGGER community_deletion_approval_removal_guard
+BEFORE UPDATE OR DELETE ON community_deletion_approvals
+FOR EACH ROW
+EXECUTE FUNCTION prevent_community_deletion_approval_removal();
+
+CREATE TABLE community_deletion_checkpoints (
+    request_id UUID NOT NULL REFERENCES community_deletion_requests(id) ON DELETE RESTRICT,
+    sequence BIGINT GENERATED ALWAYS AS IDENTITY,
+    stage TEXT NOT NULL,
+    unit_key TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('started', 'completed', 'failed')),
+    lease_generation BIGINT NOT NULL CHECK (lease_generation > 0),
+    attempts INTEGER NOT NULL DEFAULT 1 CHECK (attempts > 0),
+    detail JSONB NOT NULL DEFAULT '{}'::jsonb,
+    error TEXT,
+    started_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    completed_at TIMESTAMPTZ,
+    PRIMARY KEY (request_id, sequence),
+    UNIQUE (request_id, stage, unit_key),
+    CHECK ((status = 'completed') = (completed_at IS NOT NULL)),
+    CHECK ((status = 'failed') = (error IS NOT NULL))
+);
+
+-- Frozen destructive key list, chunked out of the request row so a large
+-- tenant (100k-1M objects) never materializes as one multi-hundred-MB JSONB
+-- value. Rows are written once in the fenced stage, stamped `deleted_at` as
+-- the executor confirms each chunk removed, and dropped at logical
+-- verification. The request row keeps only per-prefix count/bytes/digest
+-- summaries; the chunk stream must hash to those frozen digests.
+CREATE TABLE community_deletion_manifest_keys (
+    request_id UUID NOT NULL REFERENCES community_deletion_requests(id) ON DELETE CASCADE,
+    chunk_no BIGINT NOT NULL CHECK (chunk_no >= 0),
+    prefix TEXT NOT NULL,
+    keys JSONB NOT NULL,
+    deleted_at TIMESTAMPTZ,
+    PRIMARY KEY (request_id, chunk_no)
+);
+
+-- Chunk content is immutable once written; the only permitted update is the
+-- one-way deleted_at stamp. New chunks are permitted only while the request is
+-- fenced and its destructive manifest remains unfrozen. Removal is permitted
+-- only while the destructive manifest has not yet frozen (a retried partial
+-- freeze rewrites its chunks) or once the request has passed logical
+-- verification (terminal cleanup).
+CREATE FUNCTION protect_community_deletion_manifest_keys()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    frozen_at TIMESTAMPTZ;
+    request_stage TEXT;
+BEGIN
+    IF TG_OP = 'UPDATE' THEN
+        IF NEW.request_id IS DISTINCT FROM OLD.request_id
+            OR NEW.chunk_no IS DISTINCT FROM OLD.chunk_no
+            OR NEW.prefix IS DISTINCT FROM OLD.prefix
+            OR NEW.keys IS DISTINCT FROM OLD.keys
+            OR OLD.deleted_at IS NOT NULL
+        THEN
+            RAISE EXCEPTION 'community deletion manifest key chunks are immutable'
+                USING ERRCODE = 'integrity_constraint_violation';
+        END IF;
+        RETURN NEW;
+    END IF;
+    SELECT destructive_storage_frozen_at, stage
+      INTO frozen_at, request_stage
+      FROM community_deletion_requests
+     WHERE id = CASE WHEN TG_OP = 'INSERT' THEN NEW.request_id ELSE OLD.request_id END
+     FOR UPDATE;
+    IF TG_OP = 'INSERT' THEN
+        IF FOUND AND frozen_at IS NULL AND request_stage = 'fenced' THEN
+            RETURN NEW;
+        END IF;
+        RAISE EXCEPTION 'community deletion manifest key chunks require an unfrozen fenced request'
+            USING ERRCODE = 'integrity_constraint_violation';
+    END IF;
+    IF NOT FOUND
+        OR frozen_at IS NULL
+        OR request_stage IN ('logically_verified', 'retention_pending')
+    THEN
+        RETURN OLD;
+    END IF;
+    RAISE EXCEPTION 'community deletion manifest key chunks cannot be removed mid-execution'
+        USING ERRCODE = 'integrity_constraint_violation';
+END;
+$$;
+
+CREATE TRIGGER community_deletion_manifest_keys_guard
+BEFORE INSERT OR UPDATE OR DELETE ON community_deletion_manifest_keys
+FOR EACH ROW
+EXECUTE FUNCTION protect_community_deletion_manifest_keys();
+
+-- Fleet-wide object-store taxonomy sweep evidence. This is an independent
+-- observability record: community deletion inventories only the target's owned
+-- prefixes and does not gate submission or execution on sweep state.
+CREATE TABLE storage_taxonomy_sweeps (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    started_at TIMESTAMPTZ NOT NULL,
+    completed_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    listed_objects BIGINT NOT NULL CHECK (listed_objects >= 0),
+    unknown_object_count BIGINT NOT NULL CHECK (unknown_object_count >= 0),
+    unknown_key_sample JSONB NOT NULL DEFAULT '[]'::jsonb,
+    object_cap BIGINT NOT NULL CHECK (object_cap > 0),
+    CHECK (completed_at >= started_at)
+);
+CREATE INDEX storage_taxonomy_sweeps_latest
+    ON storage_taxonomy_sweeps (completed_at DESC);
+
+CREATE TABLE community_serving_write_leases (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    community_id UUID NOT NULL REFERENCES communities(id),
+    operation TEXT NOT NULL,
+    owner TEXT NOT NULL,
+    generation BIGINT NOT NULL DEFAULT 1 CHECK (generation > 0),
+    -- Community fence generation observed when this lease was acquired.
+    fence_generation BIGINT NOT NULL CHECK (fence_generation >= 0),
+    lease_until TIMESTAMPTZ NOT NULL,
+    heartbeat_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX community_serving_write_leases_active
+    ON community_serving_write_leases (community_id, lease_until);
+
+CREATE TABLE community_deletion_executor_heartbeats (
+    executor_id TEXT PRIMARY KEY,
+    mode TEXT NOT NULL CHECK (mode IN ('run', 'drain', 'worker')),
+    request_id UUID REFERENCES community_deletion_requests(id) ON DELETE SET NULL,
+    started_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    heartbeat_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    draining BOOLEAN NOT NULL DEFAULT false,
+    stopped_at TIMESTAMPTZ
+);
+
+INSERT INTO _operator_global_tables (table_name, reason) VALUES
+    ('community_deletion_requests', 'deployment deletion lifecycle and frozen inventory'),
+    ('community_deletion_approvals', 'deployment operator destructive approvals'),
+    ('community_deletion_checkpoints', 'deployment deletion executor checkpoints and failures'),
+    ('community_deletion_manifest_keys', 'deployment deletion frozen destructive key chunks'),
+    ('storage_taxonomy_sweeps', 'deployment object-store taxonomy sweep evidence'),
+    ('community_serving_write_leases', 'deployment serving side-effect leases drained by deletion'),
+    ('community_deletion_executor_heartbeats', 'deployment deletion worker liveness');
+
+-- Shared lock key used by both the trigger and the deletion engine. Every
+-- ordinary tenant mutation takes the shared xact lock before checking state;
+-- the fence transition takes the exclusive xact lock, so an already-open write
+-- transaction cannot commit behind the fence and no new writer can slip ahead.
+CREATE FUNCTION community_deletion_lock_key(target UUID) RETURNS BIGINT
+LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$
+    SELECT hashtextextended('buzz-community-deletion:' || target::text, 0)
+$$;
+
+-- Keep the deletion control plane writable while its target tenant is fenced.
+-- This predicate is the single SQL source of truth used by attachment and live
+-- catalog validation.
+CREATE FUNCTION community_write_fence_excluded_table(target NAME) RETURNS BOOLEAN
+LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$
+    SELECT target::TEXT = ANY (ARRAY[
+        'community_deletion_requests',
+        'community_deletion_approvals',
+        'community_deletion_checkpoints',
+        'community_serving_write_leases',
+        'community_deletion_executor_heartbeats'
+    ]::TEXT[])
+$$;
+
+-- Fleet-wide writers must filter their candidate rows through this function
+-- inside the mutating statement. The shared lock and lifecycle read form one
+-- indivisible admission check, so a disallowed tenant is skipped before its
+-- row trigger can abort healthy tenants in the same statement.
+CREATE FUNCTION community_write_allowed(target UUID) RETURNS BOOLEAN
+LANGUAGE plpgsql VOLATILE AS $$
+DECLARE
+    lifecycle TEXT;
+BEGIN
+    IF current_setting('transaction_isolation') <> 'read committed' THEN
+        RAISE EXCEPTION 'community writes require READ COMMITTED isolation'
+            USING ERRCODE = 'invalid_transaction_state';
+    END IF;
+
+    IF target IS NULL THEN
+        RETURN true;
+    END IF;
+
+    PERFORM pg_advisory_xact_lock_shared(community_deletion_lock_key(target));
+    SELECT deletion_state
+      INTO lifecycle
+      FROM communities
+     WHERE id = target;
+    RETURN FOUND AND lifecycle = 'active';
+END
+$$;
+
+CREATE FUNCTION assert_community_write_allowed(target UUID) RETURNS VOID
+LANGUAGE plpgsql AS $$
+DECLARE
+    lifecycle TEXT;
+    generation BIGINT;
+    executor_community TEXT;
+    executor_generation TEXT;
+    serving_community TEXT;
+    serving_lease_id TEXT;
+    serving_owner TEXT;
+    serving_generation TEXT;
+    serving_fence_generation TEXT;
+    serving_lease_valid BOOLEAN := false;
+BEGIN
+    -- The fence proof depends on a fresh statement snapshot after the shared
+    -- advisory lock is granted. Pinned RR/Serializable snapshots can retain a
+    -- pre-fence lifecycle or executor generation and resurrect tenant data.
+    IF current_setting('transaction_isolation') <> 'read committed' THEN
+        RAISE EXCEPTION 'community writes require READ COMMITTED isolation'
+            USING ERRCODE = 'invalid_transaction_state';
+    END IF;
+
+    -- Nullable operator-attribution rows without a tenant are unrelated.
+    IF target IS NULL THEN
+        RETURN;
+    END IF;
+
+    PERFORM pg_advisory_xact_lock_shared(community_deletion_lock_key(target));
+    SELECT deletion_state, deletion_fence_generation
+      INTO lifecycle, generation
+      FROM communities
+     WHERE id = target;
+    IF NOT FOUND THEN
+        RAISE EXCEPTION 'community write rejected: community % is missing', target
+            USING ERRCODE = 'object_not_in_prerequisite_state';
+    END IF;
+
+    -- Authorization is evaluated independently for every community checked.
+    executor_community := current_setting('buzz.deletion_executor_community', true);
+    executor_generation := current_setting('buzz.deletion_fence_generation', true);
+    IF executor_community = target::TEXT
+       AND executor_generation ~ '^[0-9]+$'
+       AND executor_generation::BIGINT = generation THEN
+        RETURN;
+    END IF;
+
+    -- A serving mutation admitted before quiescing may finish only while its
+    -- exact durable lease remains current and bound to this fence generation.
+    serving_community := current_setting('buzz.serving_write_community', true);
+    serving_lease_id := current_setting('buzz.serving_write_lease_id', true);
+    serving_owner := current_setting('buzz.serving_write_owner', true);
+    serving_generation := current_setting('buzz.serving_write_generation', true);
+    serving_fence_generation := current_setting('buzz.serving_write_fence_generation', true);
+    IF lifecycle IN ('active', 'quiescing')
+       AND serving_community = target::TEXT
+       AND serving_lease_id ~ '^[0-9a-fA-F-]{36}$'
+       AND serving_generation ~ '^[0-9]+$'
+       AND serving_fence_generation ~ '^[0-9]+$'
+       AND serving_fence_generation::BIGINT = generation THEN
+        SELECT EXISTS(
+            SELECT 1 FROM community_serving_write_leases lease
+             WHERE lease.id = serving_lease_id::UUID
+               AND lease.community_id = target
+               AND lease.owner = serving_owner
+               AND lease.generation = serving_generation::BIGINT
+               AND lease.fence_generation = serving_fence_generation::BIGINT
+               AND lease.lease_until >= now()
+        ) INTO serving_lease_valid;
+        IF serving_lease_valid THEN
+            RETURN;
+        END IF;
+    END IF;
+
+    IF lifecycle <> 'active' THEN
+        RAISE EXCEPTION 'community write fenced: community % generation %', target, generation
+            USING ERRCODE = 'object_not_in_prerequisite_state';
+    END IF;
+END
+$$;
+
+CREATE FUNCTION enforce_community_write_fence() RETURNS TRIGGER
+LANGUAGE plpgsql AS $$
+BEGIN
+    IF TG_OP = 'INSERT' THEN
+        PERFORM assert_community_write_allowed(NEW.community_id);
+    ELSIF TG_OP = 'DELETE' THEN
+        PERFORM assert_community_write_allowed(OLD.community_id);
+    ELSIF OLD.community_id IS NOT DISTINCT FROM NEW.community_id THEN
+        PERFORM assert_community_write_allowed(OLD.community_id);
+    ELSIF OLD.community_id IS NULL THEN
+        PERFORM assert_community_write_allowed(NEW.community_id);
+    ELSIF NEW.community_id IS NULL THEN
+        PERFORM assert_community_write_allowed(OLD.community_id);
+    ELSIF OLD.community_id < NEW.community_id THEN
+        PERFORM assert_community_write_allowed(OLD.community_id);
+        PERFORM assert_community_write_allowed(NEW.community_id);
+    ELSE
+        PERFORM assert_community_write_allowed(NEW.community_id);
+        PERFORM assert_community_write_allowed(OLD.community_id);
+    END IF;
+
+    RETURN CASE WHEN TG_OP = 'DELETE' THEN OLD ELSE NEW END;
+END
+$$;
+
+-- Protect the tombstone row itself. Normal updates are permitted only while the
+-- row is active and do not change deletion metadata. Deletion executor updates
+-- must present the exact durable generation in session-local GUCs.
+CREATE FUNCTION enforce_community_tombstone() RETURNS TRIGGER
+LANGUAGE plpgsql AS $$
+DECLARE
+    executor_community TEXT := current_setting('buzz.deletion_executor_community', true);
+    executor_generation TEXT := current_setting('buzz.deletion_fence_generation', true);
+    expected_generation BIGINT;
+BEGIN
+    IF TG_OP = 'DELETE' THEN
+        IF OLD.deletion_state <> 'active' OR OLD.deleted_at IS NOT NULL THEN
+            RAISE EXCEPTION 'community tombstones are permanent'
+                USING ERRCODE = 'object_not_in_prerequisite_state';
+        END IF;
+        RETURN OLD;
+    END IF;
+
+    expected_generation := CASE
+        WHEN NEW.deletion_fence_generation > OLD.deletion_fence_generation
+            THEN NEW.deletion_fence_generation
+        ELSE OLD.deletion_fence_generation
+    END;
+    IF executor_community = OLD.id::text
+       AND executor_generation ~ '^[0-9]+$'
+       AND executor_generation::BIGINT = expected_generation THEN
+        RETURN NEW;
+    END IF;
+
+    IF OLD.deletion_state <> 'active'
+       OR NEW.deletion_state <> OLD.deletion_state
+       OR NEW.deletion_fence_generation <> OLD.deletion_fence_generation
+       OR NEW.deleted_at IS DISTINCT FROM OLD.deleted_at THEN
+        RAISE EXCEPTION 'community tombstone mutation rejected: community % generation %',
+            OLD.id, OLD.deletion_fence_generation
+            USING ERRCODE = 'object_not_in_prerequisite_state';
+    END IF;
+    RETURN NEW;
+END
+$$;
+
+CREATE TRIGGER communities_deletion_tombstone
+BEFORE UPDATE OR DELETE ON communities
+FOR EACH ROW EXECUTE FUNCTION enforce_community_tombstone();
+
+-- Attach the universal fence to one community-scoped relation. Future
+-- migrations must invoke this helper explicitly after CREATE/ALTER introduces
+-- community_id; the migration lint enforces that contract.
+CREATE FUNCTION attach_community_write_fence(target REGCLASS) RETURNS VOID
+LANGUAGE plpgsql AS $$
+DECLARE
+    relation_name NAME;
+BEGIN
+    SELECT c.relname
+      INTO relation_name
+      FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE c.oid = target
+       AND n.nspname = current_schema()
+       AND c.relkind IN ('r', 'p')
+       AND NOT c.relispartition;
+    IF NOT FOUND THEN
+        RAISE EXCEPTION 'community write fence target % is not a table in the current schema', target
+            USING ERRCODE = 'wrong_object_type';
+    END IF;
+    IF community_write_fence_excluded_table(relation_name) THEN
+        RETURN;
+    END IF;
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_attribute
+         WHERE attrelid = target AND attname = 'community_id' AND NOT attisdropped
+    ) THEN
+        RAISE EXCEPTION 'community write fence target % has no community_id', target
+            USING ERRCODE = 'undefined_column';
+    END IF;
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_trigger
+         WHERE tgrelid = target
+           AND tgname = 'community_write_fence_' || relation_name
+           AND NOT tgisinternal
+    ) THEN
+        EXECUTE format(
+            'CREATE TRIGGER %I BEFORE INSERT OR UPDATE OR DELETE ON %s '
+            'FOR EACH ROW EXECUTE FUNCTION enforce_community_write_fence()',
+            'community_write_fence_' || relation_name,
+            target
+        );
+    END IF;
+END
+$$;
+
+-- Attach the universal fence to every existing table carrying community_id,
+-- including deployment-private sidecars whose community_id is provenance.
+DO $$
+DECLARE
+    target REGCLASS;
+BEGIN
+    FOR target IN
+        SELECT c.oid::REGCLASS
+          FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_attribute a ON a.attrelid = c.oid
+         WHERE n.nspname = current_schema()
+           AND c.relkind IN ('r', 'p')
+           AND NOT c.relispartition
+           AND a.attname = 'community_id'
+           AND NOT a.attisdropped
+           AND NOT community_write_fence_excluded_table(c.relname)
+         ORDER BY c.oid::REGCLASS::TEXT
+    LOOP
+        PERFORM attach_community_write_fence(target);
+    END LOOP;
+END
+$$;
+
+-- Desired-state schema application does not replay migration history, so keep
+-- these explicit calls as first-class catalog declarations. They also make the
+-- fence contract visible to migration linting instead of hiding it only in the
+-- dynamic bootstrap loop above.
+SELECT attach_community_write_fence('api_tokens');
+SELECT attach_community_write_fence('archived_identities');
+SELECT attach_community_write_fence('audit_log');
+SELECT attach_community_write_fence('channel_members');
+SELECT attach_community_write_fence('channels');
+SELECT attach_community_write_fence('community_bans');
+SELECT attach_community_write_fence('delivery_log');
+SELECT attach_community_write_fence('event_mentions');
+SELECT attach_community_write_fence('events');
+SELECT attach_community_write_fence('git_repo_names');
+SELECT attach_community_write_fence('join_policy_acceptances');
+SELECT attach_community_write_fence('moderation_actions');
+SELECT attach_community_write_fence('moderation_reports');
+SELECT attach_community_write_fence('parameterized_event_watermarks');
+SELECT attach_community_write_fence('product_feedback');
+SELECT attach_community_write_fence('pubkey_allowlist');
+SELECT attach_community_write_fence('push_leases');
+SELECT attach_community_write_fence('push_match_queue');
+SELECT attach_community_write_fence('push_wake_outbox');
+SELECT attach_community_write_fence('rate_limit_violations');
+SELECT attach_community_write_fence('reactions');
+SELECT attach_community_write_fence('relay_invites');
+SELECT attach_community_write_fence('relay_members');
+SELECT attach_community_write_fence('scheduled_workflow_fires');
+SELECT attach_community_write_fence('subscriptions');
+SELECT attach_community_write_fence('thread_metadata');
+SELECT attach_community_write_fence('users');
+SELECT attach_community_write_fence('workflow_approvals');
+SELECT attach_community_write_fence('workflow_runs');
+SELECT attach_community_write_fence('workflows');
diff --git a/migrations/0032_community_deletion_recovery.sql b/migrations/0032_community_deletion_recovery.sql
new file mode 100644
index 00000000000..805dc5cb01b
--- /dev/null
+++ b/migrations/0032_community_deletion_recovery.sql
@@ -0,0 +1,48 @@
+-- Terminal recovery for deletion requests that have not begun irreversible
+-- object deletion, plus explicit operator-global provenance ownership.
+-- These ALTER TABLE statements require ACCESS EXCLUSIVE locks; fail quickly
+-- rather than queueing behind long-running production transactions.
+SET LOCAL lock_timeout = '5s';
+
+ALTER TABLE community_deletion_requests
+    DROP CONSTRAINT community_deletion_requests_community_id_key,
+    DROP CONSTRAINT community_deletion_requests_stage_check,
+    ADD CONSTRAINT community_deletion_requests_stage_check CHECK (stage IN (
+        'submitted', 'inventoried', 'approved', 'fenced', 'drained',
+        'bindings_removed', 'postgres_purged', 'cache_purged',
+        'logically_verified', 'retention_pending', 'aborted'
+    )),
+    ADD COLUMN pre_quiesce_archived_at TIMESTAMPTZ,
+    ADD COLUMN quiescing_started_at TIMESTAMPTZ,
+    ADD COLUMN aborted_by TEXT,
+    ADD COLUMN abort_reason TEXT,
+    ADD COLUMN aborted_at TIMESTAMPTZ,
+    ADD CHECK ((stage = 'aborted') = (aborted_at IS NOT NULL)),
+    ADD CHECK ((aborted_at IS NULL) = (aborted_by IS NULL)),
+    ADD CHECK ((aborted_at IS NULL) = (abort_reason IS NULL));
+
+-- Aborted requests remain immutable audit evidence, but must not permanently
+-- consume the community's one active deletion slot. Retention-pending remains
+-- active because its tombstoned community must never be re-armed.
+CREATE UNIQUE INDEX community_deletion_requests_active_community
+    ON community_deletion_requests (community_id)
+    WHERE stage <> 'aborted';
+
+ALTER TABLE product_feedback ALTER COLUMN community_id DROP NOT NULL;
+ALTER TABLE product_feedback DROP CONSTRAINT product_feedback_community_id_fkey;
+ALTER TABLE product_feedback ADD CONSTRAINT product_feedback_community_id_fkey
+    FOREIGN KEY (community_id) REFERENCES communities(id) ON DELETE SET NULL;
+
+-- These are deployment-global operator evidence. community_id is provenance,
+-- not ownership, so they are neither fenced nor purged with a tenant.
+DROP TRIGGER IF EXISTS community_write_fence_product_feedback ON product_feedback;
+DROP TRIGGER IF EXISTS community_write_fence_rate_limit_violations ON rate_limit_violations;
+CREATE OR REPLACE FUNCTION community_write_fence_excluded_table(target NAME) RETURNS BOOLEAN
+LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$
+    SELECT target::TEXT = ANY (ARRAY[
+        'community_deletion_requests', 'community_deletion_approvals',
+        'community_deletion_checkpoints', 'community_serving_write_leases',
+        'community_deletion_executor_heartbeats', 'product_feedback',
+        'rate_limit_violations'
+    ]::TEXT[])
+$$;
diff --git a/mobile/lib/features/channels/initial_thread_tail_settle.dart b/mobile/lib/features/channels/initial_thread_tail_settle.dart
new file mode 100644
index 00000000000..2e41d18e5b0
--- /dev/null
+++ b/mobile/lib/features/channels/initial_thread_tail_settle.dart
@@ -0,0 +1,88 @@
+import 'package:flutter/widgets.dart';
+import 'package:scrollable_positioned_list/scrollable_positioned_list.dart';
+
+/// Settles an ordinary thread open on the latest hydrated reply after layout.
+///
+/// Scheduling again before completion invalidates callbacks aimed at an older
+/// tail, allowing a rebuild with newly arrived replies to choose the target.
+class InitialThreadTailSettle {
+  var _generation = 0;
+  var _isComplete = false;
+
+  /// Whether no more settling is needed.
+  ///
+  /// Completion occurs when there is no tail target, the target is already
+  /// visible after hydration has settled, or the scheduled scroll finishes.
+  bool get isComplete => _isComplete;
+
+  /// Permanently abandons initial settling and invalidates queued callbacks.
+  ///
+  /// This is terminal: later scheduling remains disabled even if the user
+  /// returns to the tail and resumes ordinary follow behavior.
+  void abandon() {
+    _generation++;
+    _isComplete = true;
+  }
+
+  /// Schedules a settle after each hydrated thread layout until [isComplete].
+  ///
+  /// A later schedule replaces an earlier target while replies are still
+  /// arriving. The final target is left in place when already visible; otherwise
+  /// it scrolls into the viewport between the measured top and bottom overlays.
+  void schedule({
+    required BuildContext context,
+    required ItemScrollController controller,
+    required ItemPositionsListener positionsListener,
+    required int? targetIndex,
+    required double hiddenTopFraction,
+    required double hiddenBottomFraction,
+  }) {
+    if (_isComplete) return;
+
+    final generation = ++_generation;
+    if (targetIndex == null) {
+      _isComplete = true;
+      return;
+    }
+
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (!context.mounted || generation != _generation) return;
+
+      // Let events received during hydration rebuild the list before committing
+      // the target. That rebuild schedules a new generation at the current tail.
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        if (!context.mounted ||
+            !controller.isAttached ||
+            generation != _generation) {
+          return;
+        }
+        final targetIsFullyVisible = positionsListener.itemPositions.value.any(
+          (position) =>
+              position.index == targetIndex &&
+              position.itemLeadingEdge >= hiddenTopFraction &&
+              position.itemTrailingEdge <= 1 - hiddenBottomFraction,
+        );
+        // Short threads already expose their tail from the top anchor. Moving
+        // that fully visible target down would only add empty space above the
+        // head. A clipped tail still takes the measured correction path.
+        if (targetIsFullyVisible) {
+          _isComplete = true;
+          return;
+        }
+        controller
+            .scrollTo(
+              index: targetIndex,
+              alignment: hiddenTopFraction,
+              duration: const Duration(milliseconds: 1),
+            )
+            .whenComplete(() {
+              if (generation == _generation) _isComplete = true;
+            });
+      });
+      // A post-frame callback does not itself request the frame in which it
+      // runs. Slow hydration can otherwise leave this settle parked until an
+      // unrelated redraw.
+      WidgetsBinding.instance.scheduleFrame();
+    });
+  }
+}
diff --git a/mobile/lib/features/channels/laid_out_viewport.dart b/mobile/lib/features/channels/laid_out_viewport.dart
new file mode 100644
index 00000000000..12fa4a2f88e
--- /dev/null
+++ b/mobile/lib/features/channels/laid_out_viewport.dart
@@ -0,0 +1,70 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_hooks/flutter_hooks.dart';
+
+/// Tracks the height of a viewport after Flutter has laid it out.
+///
+/// Create one instance for a viewport, pass it to [LaidOutViewportReporter],
+/// listen to [height] for measurements, and call [dispose] when the owner is
+/// removed. Measurements are reported after the frame that performed layout.
+class LaidOutViewport {
+  /// Key used by [LaidOutViewportReporter] to locate the viewport render box.
+  final key = GlobalKey();
+
+  /// The latest laid-out viewport height, or zero before the first report.
+  final height = ValueNotifier(0.0);
+
+  /// Schedules a viewport measurement after the current frame is laid out.
+  ///
+  /// Reports only changes of at least half a logical pixel. If the viewport is
+  /// not mounted or has not been laid out, the scheduled report does nothing.
+  void reportAfterLayout() {
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      final renderObject = key.currentContext?.findRenderObject();
+      if (renderObject is! RenderBox || !renderObject.hasSize) return;
+      final nextHeight = renderObject.size.height;
+      if ((height.value - nextHeight).abs() < 0.5) return;
+      height.value = nextHeight;
+    });
+  }
+
+  /// Releases the [height] notifier owned by this viewport.
+  void dispose() => height.dispose();
+}
+
+/// Reports the laid-out height of [child] through [viewport].
+///
+/// Reports once after initial layout and again whenever the child's layout size
+/// changes. The owner must keep [viewport] stable across rebuilds and dispose it
+/// after this reporter is removed.
+class LaidOutViewportReporter extends HookWidget {
+  /// Receives the laid-out height measurements.
+  final LaidOutViewport viewport;
+
+  /// The widget whose viewport height is measured.
+  final Widget child;
+
+  /// Creates a reporter for [child] backed by [viewport].
+  const LaidOutViewportReporter({
+    super.key,
+    required this.viewport,
+    required this.child,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    useEffect(() {
+      viewport.reportAfterLayout();
+      return null;
+    }, [viewport]);
+
+    return NotificationListener<SizeChangedLayoutNotification>(
+      onNotification: (_) {
+        viewport.reportAfterLayout();
+        return true;
+      },
+      child: SizeChangedLayoutNotifier(
+        child: KeyedSubtree(key: viewport.key, child: child),
+      ),
+    );
+  }
+}
diff --git a/mobile/lib/features/channels/thread_detail_helpers.dart b/mobile/lib/features/channels/thread_detail_helpers.dart
new file mode 100644
index 00000000000..e4d0f76ff3d
--- /dev/null
+++ b/mobile/lib/features/channels/thread_detail_helpers.dart
@@ -0,0 +1,125 @@
+part of 'thread_detail_page.dart';
+
+int _threadTailIndex(int replyCount) => replyCount;
+
+double _threadTailTrailingBoundary({
+  required bool hasComposerDock,
+  required double viewportHeight,
+  required double dockHeight,
+}) {
+  if (!hasComposerDock) return 1.001;
+  if (!viewportHeight.isFinite ||
+      viewportHeight <= 0 ||
+      !dockHeight.isFinite ||
+      dockHeight <= 0) {
+    return double.negativeInfinity;
+  }
+  return 1 - (dockHeight / viewportHeight) + 0.001;
+}
+
+void _resumeThreadTailFollow({
+  required bool Function() isVisible,
+  required ObjectRef<bool> userOptedOut,
+  required ObjectRef<bool> followsTail,
+}) {
+  if (!isVisible()) return;
+  userOptedOut.value = false;
+  followsTail.value = true;
+}
+
+bool _isDeletedBy(Iterable<NostrEvent> events, String messageId) {
+  for (final event in events) {
+    if (event.kind != EventKind.deletion &&
+        event.kind != EventKind.nip29DeleteEvent) {
+      continue;
+    }
+    if (event.tags.any(
+      (tag) => tag.length >= 2 && tag[0] == 'e' && tag[1] == messageId,
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/// Build a lightweight summary for a nested thread (reply that has its own
+/// replies). Same logic as the top-level [ThreadSummary] but kept local to
+/// avoid coupling.
+ThreadSummary _buildNestedSummary(
+  String messageId,
+  List<TimelineMessage> children,
+) {
+  final seen = <String>{};
+  final participants = <String>[];
+  for (var i = children.length - 1; i >= 0 && participants.length < 3; i--) {
+    final pk = children[i].pubkey.toLowerCase();
+    if (seen.add(pk)) participants.add(pk);
+  }
+  return ThreadSummary(
+    threadHeadId: messageId,
+    replyCount: children.length,
+    participantPubkeys: participants.reversed.toList(),
+    lastReplyAt: children.last.createdAt,
+  );
+}
+
+class _ThreadTailMetricsObserver with WidgetsBindingObserver {
+  final VoidCallback onMetricsChanged;
+
+  _ThreadTailMetricsObserver({required this.onMetricsChanged});
+
+  @override
+  void didChangeMetrics() => onMetricsChanged();
+}
+
+/// Serializes deferred tail work behind the latest user scroll intent.
+class _ThreadTailIntent {
+  var _generation = 0;
+  var isDragging = false;
+
+  void detach() => _generation++;
+
+  void beginDrag() {
+    isDragging = true;
+    detach();
+  }
+
+  void endDrag() => isDragging = false;
+
+  void schedule({
+    required bool allowed,
+    required bool Function() revalidate,
+    required VoidCallback action,
+  }) {
+    if (!allowed) return;
+    final generation = ++_generation;
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        if (generation == _generation && revalidate()) action();
+      });
+      WidgetsBinding.instance.scheduleFrame();
+    });
+  }
+}
+
+/// Thread-scoped typing status with optional size animation.
+class _ThreadTypingIndicator extends StatelessWidget {
+  final List<TypingEntry> entries;
+  final bool animated;
+
+  const _ThreadTypingIndicator({required this.entries, this.animated = true});
+
+  @override
+  Widget build(BuildContext context) {
+    final child = entries.isEmpty
+        ? const SizedBox.shrink()
+        : ChannelTypingIndicator(entries: entries);
+    if (!animated || MediaQuery.disableAnimationsOf(context)) return child;
+    return AnimatedSize(
+      duration: const Duration(milliseconds: 180),
+      curve: Curves.easeOutCubic,
+      alignment: Alignment.bottomCenter,
+      child: child,
+    );
+  }
+}
diff --git a/mobile/lib/features/channels/thread_detail_page.dart b/mobile/lib/features/channels/thread_detail_page.dart
index 2ce862ea711..9de8dc861f6 100644
--- a/mobile/lib/features/channels/thread_detail_page.dart
+++ b/mobile/lib/features/channels/thread_detail_page.dart
@@ -24,6 +24,8 @@ import 'composer_dock_size_reporter.dart';
 import 'date_formatters.dart';
 import 'day_divider.dart';
 import '../profile/user_profile_sheet.dart';
+import 'initial_thread_tail_settle.dart';
+import 'laid_out_viewport.dart';
 import 'message_actions.dart';
 import 'message_long_press_region.dart';
 import 'message_content.dart';
@@ -34,6 +36,8 @@ import 'send_message_provider.dart';
 import 'small_avatar.dart';
 import 'timeline_message.dart';
 
+part 'thread_detail_helpers.dart';
+
 /// Full-screen thread detail page.
 ///
 /// Shows the thread head message, direct replies, typing indicators scoped to
@@ -62,20 +66,12 @@ class ThreadDetailPage extends HookConsumerWidget {
   Widget build(BuildContext context, WidgetRef ref) {
     final composerDockHeight = useState(0.0);
     final sendMessage = ref.read(sendMessageProvider);
-    // Relay thread queries are keyed by the outermost root, even when this
-    // page displays a nested branch. Query that root, then select this head's
-    // direct children from the returned subtree below.
     final queryRootId = threadHead.rootId ?? threadHead.id;
     final repliesState = ref.watch(
       threadRepliesWithLocalProvider(
         ThreadRepliesArgs(channelId: channelId, rootId: queryRootId),
       ),
     );
-    // The thread query is one-shot and asks only for content kinds, so a
-    // reaction, edit, or deletion that lands while the thread is open never
-    // reaches it — a new pill (and its burst) only showed up after leaving and
-    // re-entering, which refetched. The channel socket already receives those
-    // events, so union the two sources and format once.
     final liveChannelEvents =
         ref.watch(channelMessagesProvider(channelId)).value ??
         const <NostrEvent>[];
@@ -94,18 +90,12 @@ class ThreadDetailPage extends HookConsumerWidget {
     final allMsgs = fetchedReplies == null
         ? allMessages
         : [
-            // Only fall back to the pushed-route snapshot when neither source
-            // carries the head, and no live deletion has suppressed it. That
-            // keeps a temporarily unavailable head visible without restoring
-            // a head that was deleted while this page was open.
             if (!liveDeletionHidesHead &&
                 !fetchedReplies.any((message) => message.id == threadHead.id))
               threadHead,
             ...fetchedReplies,
           ];
 
-    // Index all messages by parentId so we can find direct children of any
-    // message and compute thread summaries for nested threads.
     final childrenByParent = <String, List<TimelineMessage>>{};
     for (final msg in allMsgs) {
       final pid = msg.parentId;
@@ -116,28 +106,35 @@ class ThreadDetailPage extends HookConsumerWidget {
     final replies = childrenByParent[threadHead.id] ?? const [];
     final itemScrollController = useMemoized(ItemScrollController.new);
     final itemPositionsListener = useMemoized(ItemPositionsListener.create);
+    final listViewport = useMemoized(LaidOutViewport.new);
+    useEffect(() => listViewport.dispose, [listViewport]);
     final didJumpToInitialMessage = useRef(false);
     final followsThreadTail = useRef(false);
+    final userOptedOutOfTailFollow = useRef(false);
+    final tailIntent = useMemoized(_ThreadTailIntent.new);
     final pendingTailAlignment = useRef<double?>(null);
-    final tailRealignmentQueued = useRef(false);
-
-    // Item 0 is the thread head; reply `i` lives at `i + 1`.
     const headIndex = 0;
     int indexForReply(int chronologicalIndex) => chronologicalIndex + 1;
 
     bool threadTailIsVisible() {
-      final lastIndex = replies.isEmpty
-          ? headIndex
-          : indexForReply(replies.length - 1);
+      final lastIndex = _threadTailIndex(replies.length);
+      final trailingBoundary = _threadTailTrailingBoundary(
+        hasComposerDock: isMember && !isArchived,
+        viewportHeight: listViewport.height.value,
+        dockHeight: composerDockHeight.value,
+      );
       return itemPositionsListener.itemPositions.value.any(
         (position) =>
-            position.index == lastIndex && position.itemTrailingEdge <= 1.001,
+            position.index == lastIndex &&
+            position.itemTrailingEdge <= trailingBoundary,
       );
     }
 
     useEffect(() {
       void onPositionsChanged() {
-        if (threadTailIsVisible()) followsThreadTail.value = true;
+        if (!userOptedOutOfTailFollow.value && threadTailIsVisible()) {
+          followsThreadTail.value = true;
+        }
       }
 
       itemPositionsListener.itemPositions.addListener(onPositionsChanged);
@@ -148,8 +145,6 @@ class ThreadDetailPage extends HookConsumerWidget {
 
     useEffect(() {
       final messageId = initialMessageId;
-      // Wait for the authoritative thread query before consuming the one-shot
-      // jump; the fallback main-timeline list can contain only the linked reply.
       if (messageId == null || fetchedReplies == null) return null;
       final chronologicalIndex = replies.indexWhere(
         (reply) => reply.id == messageId,
@@ -160,70 +155,138 @@ class ThreadDetailPage extends HookConsumerWidget {
           ? null
           : indexForReply(chronologicalIndex);
       if (targetIndex == null || didJumpToInitialMessage.value) return null;
-      WidgetsBinding.instance.addPostFrameCallback((_) {
-        if (!context.mounted || !itemScrollController.isAttached) return;
-        // The provisional route snapshot can make the linked reply look like
-        // the tail. This authoritative deep-link jump intentionally leaves
-        // the user at an older item, so it must opt out of follow-tail first.
-        followsThreadTail.value = false;
-        pendingTailAlignment.value = null;
-        itemScrollController.jumpTo(index: targetIndex, alignment: 0.35);
-        didJumpToInitialMessage.value = true;
-      });
+      didJumpToInitialMessage.value = true;
+      tailIntent.schedule(
+        allowed: true,
+        revalidate: () =>
+            context.mounted &&
+            itemScrollController.isAttached &&
+            !tailIntent.isDragging,
+        action: () {
+          tailIntent.detach();
+          followsThreadTail.value = false;
+          pendingTailAlignment.value = null;
+          itemScrollController.jumpTo(index: targetIndex, alignment: 0.35);
+        },
+      );
       return null;
     }, [initialMessageId, fetchedReplies, replies.length]);
 
-    // A top-anchored list doesn't stick to the newest item the way the old
-    // reversed one did, so follow the tail explicitly: when a reply arrives
-    // while the last item is on screen, scroll it into view. If the user has
-    // scrolled up to read, leave them where they are.
     final hasFetchedReplies = fetchedReplies != null;
-    final didEstablishInitialReplies = useRef(hasFetchedReplies);
+    final initialTailSettle = useMemoized(InitialThreadTailSettle.new);
     final previousReplyCount = useRef(replies.length);
+    final viewportHeight = useListenable(listViewport.height).value;
+    final previousViewportHeight = useRef(viewportHeight);
+    final topOverlayFraction = frostedAppBarHeight(context) / viewportHeight;
+    final settleGeometry = (composerDockHeight.value, viewportHeight);
+    bool currentIntentAllowsTailMutation({bool allowIdleDetached = false}) {
+      if (tailIntent.isDragging) return false;
+      if (allowIdleDetached) return true;
+      return !userOptedOutOfTailFollow.value &&
+          (followsThreadTail.value || threadTailIsVisible());
+    }
+
+    void queueTailRealignment({
+      bool allowIdleDetached = false,
+      bool restoreFollow = false,
+      bool animate = true,
+    }) {
+      if (!initialTailSettle.isComplete ||
+          viewportHeight <= 0 ||
+          !currentIntentAllowsTailMutation(
+            allowIdleDetached: allowIdleDetached,
+          )) {
+        return;
+      }
+      if (!allowIdleDetached) followsThreadTail.value = true;
+      tailIntent.schedule(
+        allowed: true,
+        revalidate: () =>
+            context.mounted &&
+            itemScrollController.isAttached &&
+            currentIntentAllowsTailMutation(
+              allowIdleDetached: allowIdleDetached,
+            ),
+        action: () {
+          final lastIndex = _threadTailIndex(replies.length);
+          if (restoreFollow) {
+            userOptedOutOfTailFollow.value = false;
+            followsThreadTail.value = true;
+          }
+          if (animate) {
+            itemScrollController.scrollTo(
+              index: lastIndex,
+              alignment: topOverlayFraction,
+              duration: const Duration(milliseconds: 220),
+              curve: Curves.easeOutCubic,
+            );
+          } else {
+            itemScrollController.jumpTo(
+              index: lastIndex,
+              alignment: topOverlayFraction,
+            );
+          }
+        },
+      );
+    }
+
     useEffect(() {
-      // The first authoritative query result is hydration, not a live arrival.
-      // Establish the baseline without moving the user away from the head.
-      if (!hasFetchedReplies) return null;
-      if (!didEstablishInitialReplies.value) {
-        didEstablishInitialReplies.value = true;
+      if (!hasFetchedReplies || viewportHeight <= 0) return null;
+      if (isMember && !isArchived && composerDockHeight.value <= 0) {
+        return null;
+      }
+      if (!initialTailSettle.isComplete) {
         previousReplyCount.value = replies.length;
+        previousViewportHeight.value = viewportHeight;
+        initialTailSettle.schedule(
+          context: context,
+          controller: itemScrollController,
+          positionsListener: itemPositionsListener,
+          targetIndex: initialMessageId == null && replies.isNotEmpty
+              ? indexForReply(replies.length - 1)
+              : null,
+          hiddenTopFraction: topOverlayFraction,
+          hiddenBottomFraction: composerDockHeight.value / viewportHeight,
+        );
         return null;
       }
-
       final previous = previousReplyCount.value;
       previousReplyCount.value = replies.length;
-      if (replies.length <= previous) return null;
+      final viewportChanged =
+          (viewportHeight - previousViewportHeight.value).abs() >= 0.5;
+      previousViewportHeight.value = viewportHeight;
+      if (replies.length <= previous) {
+        // Preserve a short thread's valid top anchor when resize leaves its
+        // tail inside the newly measured usable viewport. Long/clipped tails
+        // still follow through the shared intent-serialized correction path.
+        if (viewportChanged && !threadTailIsVisible()) {
+          queueTailRealignment(animate: false);
+        }
+        return null;
+      }
       final positions = itemPositionsListener.itemPositions.value;
-      final lastIndex = indexForReply(replies.length - 1);
-      // Positions still describe the list as it was *before* these replies, so
-      // compare against the old tail. Measuring against the new one only reads
-      // as "at the tail" when exactly one reply arrived.
       final previousLastIndex = previous == 0
           ? headIndex
           : indexForReply(previous - 1);
-      final wasAtTail =
-          positions.isEmpty ||
-          positions.any((position) => position.index >= previousLastIndex);
+      final wasAtTail = positions.any(
+        (position) => position.index == previousLastIndex,
+      );
       final localPubkey = currentPubkey?.toLowerCase();
       final hasNewLocalReply =
           localPubkey != null &&
           replies
               .skip(previous)
               .any((reply) => reply.pubkey.toLowerCase() == localPubkey);
-      // A reply the current user just sent must be visible even if they were
-      // reading at the head of a long thread. Remote arrivals still respect
-      // the user's scroll position.
-      if (!wasAtTail && !hasNewLocalReply) return null;
-      WidgetsBinding.instance.addPostFrameCallback((_) {
-        if (!context.mounted || !itemScrollController.isAttached) return;
-        itemScrollController.scrollTo(
-          index: lastIndex,
-          duration: const Duration(milliseconds: 220),
-          curve: Curves.easeOutCubic,
-        );
-      });
+      if (tailIntent.isDragging) return null;
+      if (!hasNewLocalReply && (userOptedOutOfTailFollow.value || !wasAtTail)) {
+        return null;
+      }
+      queueTailRealignment(
+        allowIdleDetached: hasNewLocalReply,
+        restoreFollow: hasNewLocalReply,
+      );
       return null;
-    }, [hasFetchedReplies, replies.length]);
+    }, [hasFetchedReplies, replies.length, settleGeometry]);
     final readState = ref.watch(readStateProvider);
     final visibleReplyReadKey = replies
         .map((reply) => '${reply.id}:${reply.createdAt}')
@@ -241,7 +304,6 @@ class ThreadDetailPage extends HookConsumerWidget {
       return null;
     }, [threadHead.id, readState.isReady, visibleReplyReadKey]);
 
-    // Thread-scoped typing indicators (exclude self).
     final allTyping = ref.watch(channelTypingProvider(channelId));
     final threadTyping = allTyping
         .where((e) => e.threadHeadId == threadHead.id)
@@ -252,72 +314,56 @@ class ThreadDetailPage extends HookConsumerWidget {
         )
         .toList();
 
-    // Resolve thread head from live data (reactions/edits may have changed).
     final liveHead =
         allMsgs.where((m) => m.id == threadHead.id).firstOrNull ?? threadHead;
 
-    // The root of the entire thread chain. If the current thread head is
-    // itself a root message its rootId is null, so fall back to its own id.
     final effectiveRootId = threadHead.rootId ?? threadHead.id;
 
     void updateComposerDockHeight(double height) {
+      listViewport.reportAfterLayout();
       final previousHeight = composerDockHeight.value;
       final heightDelta = height - previousHeight;
       if (heightDelta.abs() < 0.5) return;
 
-      final shouldFollowTail = followsThreadTail.value || threadTailIsVisible();
+      final shouldFollowTail =
+          !userOptedOutOfTailFollow.value &&
+          (followsThreadTail.value || threadTailIsVisible());
       if (shouldFollowTail) followsThreadTail.value = true;
       composerDockHeight.value = height;
-      if (heightDelta <= 0 || !shouldFollowTail) {
+      if (heightDelta <= 0 ||
+          !shouldFollowTail ||
+          !viewportHeight.isFinite ||
+          viewportHeight <= 0 ||
+          !initialTailSettle.isComplete) {
         pendingTailAlignment.value = null;
         return;
       }
-      final lastIndex = replies.isEmpty
-          ? headIndex
-          : indexForReply(replies.length - 1);
+      final lastIndex = _threadTailIndex(replies.length);
       final lastPosition = itemPositionsListener.itemPositions.value
           .where((position) => position.index == lastIndex)
           .firstOrNull;
       if (lastPosition == null) return;
       final targetAlignment =
           (pendingTailAlignment.value ?? lastPosition.itemLeadingEdge) -
-          (heightDelta / MediaQuery.sizeOf(context).height);
+          (heightDelta / viewportHeight);
       pendingTailAlignment.value = targetAlignment;
 
-      WidgetsBinding.instance.addPostFrameCallback((_) {
-        if (!context.mounted || !itemScrollController.isAttached) return;
-        itemScrollController.jumpTo(
+      tailIntent.schedule(
+        allowed: true,
+        revalidate: () =>
+            context.mounted &&
+            itemScrollController.isAttached &&
+            currentIntentAllowsTailMutation(),
+        action: () => itemScrollController.jumpTo(
           index: lastIndex,
           alignment: targetAlignment,
-        );
-      });
+        ),
+      );
     }
 
-    // Composer size changes and keyboard metrics changes are independent:
-    // the dock grows first, then the Scaffold's viewport shrinks once the
-    // keyboard appears. Re-align after that latter layout pass too, but only
-    // while the user was already following the thread tail.
     void realignThreadTailAfterMetricsChange() {
-      final shouldFollowTail = followsThreadTail.value || threadTailIsVisible();
-      if (!shouldFollowTail || tailRealignmentQueued.value) return;
-      followsThreadTail.value = true;
-      tailRealignmentQueued.value = true;
-      WidgetsBinding.instance.addPostFrameCallback((_) {
-        tailRealignmentQueued.value = false;
-        if (!context.mounted ||
-            !itemScrollController.isAttached ||
-            !followsThreadTail.value) {
-          return;
-        }
-        final lastIndex = replies.isEmpty
-            ? headIndex
-            : indexForReply(replies.length - 1);
-        itemScrollController.scrollTo(
-          index: lastIndex,
-          duration: const Duration(milliseconds: 220),
-          curve: Curves.easeOutCubic,
-        );
-      });
+      listViewport.reportAfterLayout();
+      queueTailRealignment();
     }
 
     useEffect(() {
@@ -328,7 +374,6 @@ class ThreadDetailPage extends HookConsumerWidget {
       return () => WidgetsBinding.instance.removeObserver(observer);
     }, [itemScrollController, replies.length]);
 
-    // Channel names for message content rendering.
     final channelsAsync = ref.watch(channelsProvider);
     final channelNamesMap = <String, String>{};
     channelsAsync.whenData((channels) {
@@ -348,162 +393,170 @@ class ThreadDetailPage extends HookConsumerWidget {
           Column(
             children: [
               Expanded(
-                child: KeyboardDismissOnDrag(
-                  onUserScrollStart: () {
-                    followsThreadTail.value = false;
-                    pendingTailAlignment.value = null;
-                  },
-                  child: ScrollablePositionedList.builder(
-                    key: const ValueKey('thread-message-list'),
-                    itemScrollController: itemScrollController,
-                    itemPositionsListener: itemPositionsListener,
-                    // Top-anchored, head first, replies flowing down — matching
-                    // desktop's thread panel. The old reversed list bottom-anchored
-                    // the content, which jammed the head against the composer
-                    // whenever a thread had only a handful of replies.
-                    padding: EdgeInsets.only(
-                      left: Grid.gutter,
-                      right: Grid.gutter,
-                      top: frostedAppBarHeight(context),
-                      bottom: Grid.xs + composerDockHeight.value,
-                    ),
-                    itemCount: replies.length + 1, // +1 for thread head
-                    itemBuilder: (context, index) {
-                      if (index == headIndex) {
-                        if (liveDeletionHidesHead) {
-                          return const Padding(
-                            key: ValueKey('thread-message-deleted'),
-                            padding: EdgeInsets.only(bottom: Grid.xs),
-                            child: Text('This message was deleted'),
+                child: LaidOutViewportReporter(
+                  viewport: listViewport,
+                  child: KeyboardDismissOnDrag(
+                    onUserScrollStart: () {
+                      initialTailSettle.abandon();
+                      tailIntent.beginDrag();
+                      userOptedOutOfTailFollow.value = true;
+                      followsThreadTail.value = false;
+                      pendingTailAlignment.value = null;
+                    },
+                    onUserScrollEnd: () {
+                      tailIntent.endDrag();
+                      tailIntent.schedule(
+                        allowed: userOptedOutOfTailFollow.value,
+                        revalidate: () =>
+                            context.mounted &&
+                            itemScrollController.isAttached &&
+                            !tailIntent.isDragging &&
+                            userOptedOutOfTailFollow.value,
+                        action: () => _resumeThreadTailFollow(
+                          isVisible: threadTailIsVisible,
+                          userOptedOut: userOptedOutOfTailFollow,
+                          followsTail: followsThreadTail,
+                        ),
+                      );
+                    },
+                    child: ScrollablePositionedList.builder(
+                      key: const ValueKey('thread-message-list'),
+                      itemScrollController: itemScrollController,
+                      itemPositionsListener: itemPositionsListener,
+                      padding: EdgeInsets.only(
+                        left: Grid.gutter,
+                        right: Grid.gutter,
+                        top: frostedAppBarHeight(context),
+                        bottom: Grid.xs + composerDockHeight.value,
+                      ),
+                      itemCount: replies.length + 1, // +1 for thread head
+                      itemBuilder: (context, index) {
+                        if (index == headIndex) {
+                          if (liveDeletionHidesHead) {
+                            return const Padding(
+                              key: ValueKey('thread-message-deleted'),
+                              padding: EdgeInsets.only(bottom: Grid.xs),
+                              child: Text('This message was deleted'),
+                            );
+                          }
+                          return Padding(
+                            key: ValueKey(
+                              'thread-message-group-${liveHead.id}',
+                            ),
+                            padding: const EdgeInsets.only(bottom: Grid.xs),
+                            child: Column(
+                              crossAxisAlignment: CrossAxisAlignment.start,
+                              children: [
+                                DayDivider(
+                                  label: formatDayHeading(liveHead.createdAt),
+                                ),
+                                _ThreadMessage(
+                                  message: liveHead,
+                                  channelNames: channelNamesMap,
+                                  channelId: channelId,
+                                  currentPubkey: currentPubkey,
+                                  showAuthor: true,
+                                  isHighlighted:
+                                      liveHead.id == initialMessageId,
+                                  allMessages: allMsgs,
+                                  isMember: isMember,
+                                  isArchived: isArchived,
+                                  isThreadHead: true,
+                                ),
+                                Padding(
+                                  padding: const EdgeInsets.symmetric(
+                                    vertical: Grid.xxs,
+                                  ),
+                                  child: Row(
+                                    children: [
+                                      Text(
+                                        '${replies.length} ${replies.length == 1 ? 'reply' : 'replies'}',
+                                        style: context.textTheme.labelMedium
+                                            ?.copyWith(
+                                              color: context
+                                                  .colors
+                                                  .onSurfaceVariant,
+                                              fontWeight: FontWeight.w600,
+                                            ),
+                                      ),
+                                      const SizedBox(width: Grid.xxs),
+                                      Expanded(
+                                        child: Divider(
+                                          color: context.colors.outlineVariant,
+                                        ),
+                                      ),
+                                    ],
+                                  ),
+                                ),
+                              ],
+                            ),
                           );
                         }
+
+                        final chronIdx = index - 1;
+                        final reply = replies[chronIdx];
+                        final prevReply = chronIdx > 0
+                            ? replies[chronIdx - 1]
+                            : null;
+                        final previousMessage = prevReply ?? liveHead;
+                        final showDayDivider = !isSameDay(
+                          previousMessage.createdAt,
+                          reply.createdAt,
+                        );
+                        final showAuthor =
+                            prevReply == null ||
+                            showDayDivider ||
+                            prevReply.pubkey.toLowerCase() !=
+                                reply.pubkey.toLowerCase() ||
+                            (reply.createdAt - prevReply.createdAt) > 300;
+
+                        final nestedChildren = childrenByParent[reply.id];
+                        final nestedSummary =
+                            nestedChildren != null && nestedChildren.isNotEmpty
+                            ? _buildNestedSummary(reply.id, nestedChildren)
+                            : null;
+
                         return Padding(
-                          key: ValueKey('thread-message-group-${liveHead.id}'),
-                          padding: const EdgeInsets.only(bottom: Grid.xs),
+                          key: ValueKey('thread-message-group-${reply.id}'),
+                          padding: EdgeInsets.zero,
                           child: Column(
                             crossAxisAlignment: CrossAxisAlignment.start,
                             children: [
-                              DayDivider(
-                                label: formatDayHeading(liveHead.createdAt),
-                              ),
+                              if (showDayDivider)
+                                DayDivider(
+                                  label: formatDayHeading(reply.createdAt),
+                                ),
                               _ThreadMessage(
-                                message: liveHead,
+                                message: reply,
                                 channelNames: channelNamesMap,
                                 channelId: channelId,
                                 currentPubkey: currentPubkey,
-                                showAuthor: true,
-                                isHighlighted: liveHead.id == initialMessageId,
+                                showAuthor: showAuthor,
+                                isHighlighted: reply.id == initialMessageId,
                                 allMessages: allMsgs,
                                 isMember: isMember,
                                 isArchived: isArchived,
-                                isThreadHead: true,
                               ),
-                              Padding(
-                                padding: const EdgeInsets.symmetric(
-                                  vertical: Grid.xxs,
-                                ),
-                                child: Row(
-                                  children: [
-                                    Text(
-                                      '${replies.length} ${replies.length == 1 ? 'reply' : 'replies'}',
-                                      style: context.textTheme.labelMedium
-                                          ?.copyWith(
-                                            color:
-                                                context.colors.onSurfaceVariant,
-                                            fontWeight: FontWeight.w600,
-                                          ),
-                                    ),
-                                    const SizedBox(width: Grid.xxs),
-                                    Expanded(
-                                      child: Divider(
-                                        color: context.colors.outlineVariant,
-                                      ),
-                                    ),
-                                  ],
+                              if (nestedSummary != null)
+                                _NestedThreadSummaryRow(
+                                  summary: nestedSummary,
+                                  replyMessage: reply,
+                                  allMessages: allMsgs,
+                                  channelId: channelId,
+                                  currentPubkey: currentPubkey,
+                                  isMember: isMember,
+                                  isArchived: isArchived,
                                 ),
-                              ),
                             ],
                           ),
                         );
-                      }
-
-                      // Chronological list: index 1 = oldest reply.
-                      final chronIdx = index - 1;
-                      final reply = replies[chronIdx];
-                      final prevReply = chronIdx > 0
-                          ? replies[chronIdx - 1]
-                          : null;
-                      final previousMessage = prevReply ?? liveHead;
-                      final showDayDivider = !isSameDay(
-                        previousMessage.createdAt,
-                        reply.createdAt,
-                      );
-                      final showAuthor =
-                          prevReply == null ||
-                          showDayDivider ||
-                          prevReply.pubkey.toLowerCase() !=
-                              reply.pubkey.toLowerCase() ||
-                          (reply.createdAt - prevReply.createdAt) > 300;
-
-                      // Check if this reply itself has children (nested thread).
-                      final nestedChildren = childrenByParent[reply.id];
-                      final nestedSummary =
-                          nestedChildren != null && nestedChildren.isNotEmpty
-                          ? _buildNestedSummary(reply.id, nestedChildren)
-                          : null;
-
-                      return Padding(
-                        key: ValueKey('thread-message-group-${reply.id}'),
-                        // Tail spacing comes from the list's own bottom padding now
-                        // that the list runs top-down; the reversed list used to
-                        // need it here because item 0 sat against the composer.
-                        padding: EdgeInsets.zero,
-                        child: Column(
-                          crossAxisAlignment: CrossAxisAlignment.start,
-                          children: [
-                            if (showDayDivider)
-                              DayDivider(
-                                label: formatDayHeading(reply.createdAt),
-                              ),
-                            _ThreadMessage(
-                              message: reply,
-                              channelNames: channelNamesMap,
-                              channelId: channelId,
-                              currentPubkey: currentPubkey,
-                              showAuthor: showAuthor,
-                              isHighlighted: reply.id == initialMessageId,
-                              allMessages: allMsgs,
-                              isMember: isMember,
-                              isArchived: isArchived,
-                            ),
-                            if (nestedSummary != null)
-                              _NestedThreadSummaryRow(
-                                summary: nestedSummary,
-                                replyMessage: reply,
-                                allMessages: allMsgs,
-                                channelId: channelId,
-                                currentPubkey: currentPubkey,
-                                isMember: isMember,
-                                isArchived: isArchived,
-                              ),
-                          ],
-                        ),
-                      );
-                    },
+                      },
+                    ),
                   ),
                 ),
               ),
               if (!isMember || isArchived)
-                AnimatedSize(
-                  duration: MediaQuery.disableAnimationsOf(context)
-                      ? Duration.zero
-                      : const Duration(milliseconds: 180),
-                  curve: Curves.easeOutCubic,
-                  alignment: Alignment.bottomCenter,
-                  child: threadTyping.isEmpty
-                      ? const SizedBox.shrink()
-                      : ChannelTypingIndicator(entries: threadTyping),
-                ),
+                _ThreadTypingIndicator(entries: threadTyping, animated: false),
             ],
           ),
           if (isMember && !isArchived)
@@ -515,16 +568,7 @@ class ThreadDetailPage extends HookConsumerWidget {
                 child: Column(
                   mainAxisSize: MainAxisSize.min,
                   children: [
-                    AnimatedSize(
-                      duration: MediaQuery.disableAnimationsOf(context)
-                          ? Duration.zero
-                          : const Duration(milliseconds: 180),
-                      curve: Curves.easeOutCubic,
-                      alignment: Alignment.bottomCenter,
-                      child: threadTyping.isEmpty
-                          ? const SizedBox.shrink()
-                          : ChannelTypingIndicator(entries: threadTyping),
-                    ),
+                    _ThreadTypingIndicator(entries: threadTyping),
                     ComposeBar(
                       channelId: channelId,
                       hintText: 'Reply in thread\u2026',
@@ -554,42 +598,6 @@ class ThreadDetailPage extends HookConsumerWidget {
   }
 }
 
-bool _isDeletedBy(Iterable<NostrEvent> events, String messageId) {
-  for (final event in events) {
-    if (event.kind != EventKind.deletion &&
-        event.kind != EventKind.nip29DeleteEvent) {
-      continue;
-    }
-    if (event.tags.any(
-      (tag) => tag.length >= 2 && tag[0] == 'e' && tag[1] == messageId,
-    )) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/// Build a lightweight summary for a nested thread (reply that has its own
-/// replies). Same logic as the top-level [ThreadSummary] but kept local to
-/// avoid coupling.
-ThreadSummary _buildNestedSummary(
-  String messageId,
-  List<TimelineMessage> children,
-) {
-  final seen = <String>{};
-  final participants = <String>[];
-  for (var i = children.length - 1; i >= 0 && participants.length < 3; i--) {
-    final pk = children[i].pubkey.toLowerCase();
-    if (seen.add(pk)) participants.add(pk);
-  }
-  return ThreadSummary(
-    threadHeadId: messageId,
-    replyCount: children.length,
-    participantPubkeys: participants.reversed.toList(),
-    lastReplyAt: children.last.createdAt,
-  );
-}
-
 /// Tappable summary row shown below a reply that itself has replies.
 /// Pushes a new [ThreadDetailPage] for the nested thread.
 class _NestedThreadSummaryRow extends ConsumerWidget {
@@ -702,15 +710,6 @@ class _NestedThreadSummaryRow extends ConsumerWidget {
   }
 }
 
-class _ThreadTailMetricsObserver with WidgetsBindingObserver {
-  final VoidCallback onMetricsChanged;
-
-  _ThreadTailMetricsObserver({required this.onMetricsChanged});
-
-  @override
-  void didChangeMetrics() => onMetricsChanged();
-}
-
 class _ThreadMessage extends ConsumerWidget {
   final TimelineMessage message;
   final Map<String, String> channelNames;
diff --git a/mobile/lib/shared/widgets/keyboard_dismiss_on_drag.dart b/mobile/lib/shared/widgets/keyboard_dismiss_on_drag.dart
index 93371bdd0bd..c38608c3cc6 100644
--- a/mobile/lib/shared/widgets/keyboard_dismiss_on_drag.dart
+++ b/mobile/lib/shared/widgets/keyboard_dismiss_on_drag.dart
@@ -29,9 +29,13 @@ class KeyboardDismissOnDrag extends HookWidget {
   final Widget child;
   final VoidCallback? onUserScrollStart;
 
+  /// Called after a drag-originated scroll ends, not after programmatic scrolls.
+  final VoidCallback? onUserScrollEnd;
+
   const KeyboardDismissOnDrag({
     super.key,
     this.onUserScrollStart,
+    this.onUserScrollEnd,
     required this.child,
   });
 
@@ -40,14 +44,24 @@ class KeyboardDismissOnDrag extends HookWidget {
     // A ref, not state: accumulating travel must never trigger a rebuild of
     // the message list this wraps.
     final downwardTravel = useRef(0.0);
+    final userScrollInProgress = useRef(false);
 
     bool handle(ScrollNotification notification) {
+      // This wrapper owns the directly wrapped message list. Notifications from
+      // scrollables inside a message (code blocks, media, reactions, and any
+      // future vertical descendants) bubble through here at a greater depth and
+      // must not affect the primary list's drag lifecycle or dismissal state.
+      if (notification.depth != 0) return false;
+
       if (notification is ScrollStartNotification) {
-        if (notification.dragDetails != null) onUserScrollStart?.call();
+        userScrollInProgress.value = notification.dragDetails != null;
+        if (userScrollInProgress.value) onUserScrollStart?.call();
         downwardTravel.value = 0;
         return false;
       }
       if (notification is ScrollEndNotification) {
+        if (userScrollInProgress.value) onUserScrollEnd?.call();
+        userScrollInProgress.value = false;
         downwardTravel.value = 0;
         return false;
       }
diff --git a/mobile/test/features/channels/channel_detail_page_test.dart b/mobile/test/features/channels/channel_detail_page_test.dart
index 15cf79a3133..fbb12f71771 100644
--- a/mobile/test/features/channels/channel_detail_page_test.dart
+++ b/mobile/test/features/channels/channel_detail_page_test.dart
@@ -14,6 +14,7 @@ import 'package:buzz/features/channels/channel_detail_page.dart';
 import 'package:buzz/features/channels/channel_management_provider.dart';
 import 'package:buzz/features/channels/channel_messages_provider.dart';
 import 'package:buzz/features/channels/channel_typing_provider.dart';
+import 'package:buzz/features/channels/composer_dock_size_reporter.dart';
 import 'package:buzz/features/channels/date_formatters.dart';
 import 'package:buzz/features/channels/day_divider.dart';
 import 'package:buzz/features/channels/emoji_picker.dart';
@@ -33,6 +34,7 @@ import 'package:buzz/shared/mentions/agent_identity_provider.dart';
 import 'package:buzz/shared/relay/relay.dart';
 import 'package:buzz/shared/theme/theme.dart';
 import 'package:buzz/shared/widgets/frosted_app_bar.dart';
+import 'package:buzz/shared/widgets/keyboard_dismiss_on_drag.dart';
 import 'package:buzz/shared/widgets/skeleton.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
@@ -176,6 +178,7 @@ Widget _buildTestable({
   ChannelActions Function(Ref ref)? createChannelActions,
   ReadStateNotifier? readStateNotifier,
   _FakeMessagesNotifier? messagesNotifier,
+  _FakeTypingNotifier? typingNotifier,
   String? canvasContent,
   String? initialMessageId,
   String? initialThreadRootId,
@@ -197,7 +200,7 @@ Widget _buildTestable({
       ).overrideWith(() => fakeMessagesNotifier),
       channelTypingProvider(
         _channelId,
-      ).overrideWith(() => _FakeTypingNotifier(typing)),
+      ).overrideWith(() => typingNotifier ?? _FakeTypingNotifier(typing)),
       userCacheProvider.overrideWith(
         () => userCacheNotifier ?? _FakeUserCacheNotifier(users),
       ),
@@ -4085,9 +4088,1558 @@ void main() {
       );
     });
 
+    for (final replyCount in [0, 1]) {
+      testWidgets(
+        'cached writable $replyCount-reply thread defers dock correction until measured',
+        (tester) async {
+          tester.view.physicalSize = const Size(400, 800);
+          tester.view.devicePixelRatio = 1;
+          addTearDown(tester.view.reset);
+          final rootEvent = _textMsg(
+            id: 'thread-root',
+            pubkey: 'alice',
+            content: 'Short root',
+            createdAt: 1000,
+          );
+          final replies = [
+            if (replyCount == 1)
+              _textMsg(
+                id: 'reply-0',
+                pubkey: 'bob',
+                content: 'Short reply',
+                createdAt: 1100,
+                extraTags: const [
+                  ['e', 'thread-root', '', 'reply'],
+                ],
+              ),
+          ];
+          await tester.pumpWidget(
+            _buildTestable(
+              messages: [rootEvent],
+              threadReplies: {'thread-root': replies},
+              users: const {
+                'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+                'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+              },
+            ),
+          );
+          await tester.pumpAndSettle();
+          final routeMessages = formatTimeline([rootEvent, ...replies]);
+          Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+            MaterialPageRoute<void>(
+              builder: (_) => ThreadDetailPage(
+                threadHead: routeMessages.first,
+                allMessages: routeMessages,
+                channelId: _channelId,
+                currentPubkey: 'self',
+                isMember: true,
+                isArchived: false,
+              ),
+            ),
+          );
+
+          await tester.pump();
+          expect(tester.takeException(), isNull);
+          final earlyDock = tester.widget<ComposerDockSizeReporter>(
+            find.byType(ComposerDockSizeReporter).last,
+          );
+
+          await tester.pumpAndSettle();
+          expect(tester.takeException(), isNull);
+          earlyDock.onHeightChanged(200);
+          await tester.pumpAndSettle();
+          expect(tester.takeException(), isNull);
+          final composerSurface = find.byKey(
+            const ValueKey('composer-surface'),
+          );
+          final tail = find.byKey(
+            ValueKey(
+              replyCount == 0
+                  ? 'thread-message-group-thread-root'
+                  : 'thread-message-group-reply-0',
+            ),
+          );
+          expect(tail, findsOneWidget);
+          expect(
+            tester.getTopLeft(tail).dy,
+            greaterThanOrEqualTo(frostedAppBarHeight(tester.element(tail))),
+          );
+          expect(
+            tester.getBottomLeft(tail).dy,
+            lessThanOrEqualTo(tester.getTopLeft(composerSurface).dy),
+          );
+        },
+      );
+    }
+
+    testWidgets(
+      'cached initial thread settles between the app bar and measured composer',
+      (tester) async {
+        tester.view.physicalSize = const Size(400, 800);
+        tester.view.devicePixelRatio = 1;
+        addTearDown(tester.view.reset);
+
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Thread root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 30; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: i == 29
+                  ? List.filled(33, 'Tall latest reply').join('\n')
+                  : 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            threadReplies: {'thread-root': replies},
+            users: const {
+              'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+              'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+            },
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final threadHead = formatTimeline([rootEvent]).single;
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: threadHead,
+              allMessages: [threadHead],
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: true,
+              isArchived: false,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final latestReply = find.byKey(
+          const ValueKey('thread-message-group-reply-29'),
+        );
+        final latestRect = tester.getRect(latestReply);
+        final context = tester.element(latestReply);
+        final composerTop = tester
+            .getTopLeft(find.byKey(const ValueKey('composer-surface')))
+            .dy;
+        expect(
+          latestRect.top,
+          greaterThanOrEqualTo(frostedAppBarHeight(context)),
+        );
+        expect(latestRect.bottom, lessThanOrEqualTo(composerTop));
+      },
+    );
+
+    testWidgets('read-only cached thread still settles on its tail', (
+      tester,
+    ) async {
+      final rootEvent = _textMsg(
+        id: 'thread-root',
+        pubkey: 'alice',
+        content: 'Thread root',
+        createdAt: 1000,
+      );
+      final replies = [
+        for (var i = 0; i < 30; i++)
+          _textMsg(
+            id: 'reply-$i',
+            pubkey: 'bob',
+            content: 'Reply $i',
+            createdAt: 1100 + i,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+      ];
+
+      await tester.pumpWidget(
+        _buildTestable(
+          messages: [rootEvent],
+          threadReplies: {'thread-root': replies},
+          users: const {
+            'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+            'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+          },
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      final threadHead = formatTimeline([rootEvent]).single;
+      Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+        MaterialPageRoute<void>(
+          builder: (_) => ThreadDetailPage(
+            threadHead: threadHead,
+            allMessages: [threadHead],
+            channelId: _channelId,
+            currentPubkey: 'self',
+            isMember: false,
+            isArchived: false,
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      final latestReply = find.byKey(
+        const ValueKey('thread-message-group-reply-29'),
+      );
+      expect(latestReply, findsOneWidget);
+      expect(
+        tester.getTopLeft(latestReply).dy,
+        greaterThanOrEqualTo(frostedAppBarHeight(tester.element(latestReply))),
+      );
+    });
+
+    testWidgets(
+      'user drag abandons pending hydration settle until returning to tail',
+      (tester) async {
+        tester.view.physicalSize = const Size(400, 800);
+        tester.view.devicePixelRatio = 1;
+        addTearDown(tester.view.reset);
+
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Thread root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 35; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+        final completer = Completer<List<NostrEvent>>();
+
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            pendingThreadReplies: {'thread-root': completer.future},
+            users: const {
+              'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+              'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+            },
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final provisional = formatTimeline([rootEvent, ...replies.take(30)]);
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: provisional.first,
+              allMessages: provisional,
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: true,
+              isArchived: false,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final list = find.byKey(const ValueKey('thread-message-list'));
+        await tester.drag(list, const Offset(0, -100));
+        await tester.pumpAndSettle();
+        final anchor = find.byKey(
+          const ValueKey('thread-message-group-reply-10'),
+        );
+        final anchorTop = tester.getTopLeft(anchor).dy;
+
+        completer.complete(replies);
+        await tester.pumpAndSettle();
+
+        expect(anchor, findsOneWidget);
+        expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+        expect(
+          find.byKey(const ValueKey('thread-message-group-reply-34')),
+          findsNothing,
+        );
+
+        for (var i = 0; i < 12; i++) {
+          await tester.drag(list, const Offset(0, -100));
+          await tester.pumpAndSettle();
+        }
+        final latestReply = find.byKey(
+          const ValueKey('thread-message-group-reply-34'),
+        );
+        expect(latestReply, findsOneWidget);
+
+        tester.view.viewInsets = const FakeViewPadding(bottom: 300);
+        await tester.pumpAndSettle();
+
+        expect(
+          tester.getBottomLeft(latestReply).dy,
+          lessThanOrEqualTo(
+            tester
+                .getTopLeft(find.byKey(const ValueKey('composer-surface')))
+                .dy,
+          ),
+        );
+      },
+    );
+
+    testWidgets('active drag cancels a queued hydrated deep-link jump', (
+      tester,
+    ) async {
+      final rootEvent = _textMsg(
+        id: 'thread-root',
+        pubkey: 'alice',
+        content: 'Thread root',
+        createdAt: 1000,
+      );
+      final replies = [
+        for (var i = 0; i < 35; i++)
+          _textMsg(
+            id: 'reply-$i',
+            pubkey: 'bob',
+            content: 'Reply $i',
+            createdAt: 1100 + i,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+      ];
+      final completer = Completer<List<NostrEvent>>();
+
+      await tester.pumpWidget(
+        _buildTestable(
+          messages: [rootEvent],
+          pendingThreadReplies: {'thread-root': completer.future},
+          users: const {
+            'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+            'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+          },
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      final provisional = formatTimeline([rootEvent, ...replies.take(30)]);
+      Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+        MaterialPageRoute<void>(
+          builder: (_) => ThreadDetailPage(
+            threadHead: provisional.first,
+            allMessages: provisional,
+            channelId: _channelId,
+            currentPubkey: 'self',
+            isMember: true,
+            isArchived: false,
+            initialMessageId: 'reply-5',
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      final anchor = find.byKey(
+        const ValueKey('thread-message-group-thread-root'),
+      );
+      final anchorTop = tester.getTopLeft(anchor).dy;
+      completer.complete(replies);
+      await tester.pump();
+
+      // Authoritative hydration has queued the deep-link jump. A primary drag
+      // takes ownership before the shared deferred-intent boundary executes it.
+      tester
+          .widget<KeyboardDismissOnDrag>(find.byType(KeyboardDismissOnDrag))
+          .onUserScrollStart!();
+      await tester.pumpAndSettle();
+
+      expect(anchor, findsOneWidget);
+      expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+    });
+
+    testWidgets('user drag invalidates an already queued hydration settle', (
+      tester,
+    ) async {
+      final rootEvent = _textMsg(
+        id: 'thread-root',
+        pubkey: 'alice',
+        content: 'Thread root',
+        createdAt: 1000,
+      );
+      final replies = [
+        for (var i = 0; i < 35; i++)
+          _textMsg(
+            id: 'reply-$i',
+            pubkey: 'bob',
+            content: 'Reply $i',
+            createdAt: 1100 + i,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+      ];
+      final completer = Completer<List<NostrEvent>>();
+
+      await tester.pumpWidget(
+        _buildTestable(
+          messages: [rootEvent],
+          pendingThreadReplies: {'thread-root': completer.future},
+          users: const {
+            'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+            'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+          },
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      final provisional = formatTimeline([rootEvent, ...replies.take(30)]);
+      Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+        MaterialPageRoute<void>(
+          builder: (_) => ThreadDetailPage(
+            threadHead: provisional.first,
+            allMessages: provisional,
+            channelId: _channelId,
+            currentPubkey: 'self',
+            isMember: true,
+            isArchived: false,
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      final anchor = find.byKey(
+        const ValueKey('thread-message-group-thread-root'),
+      );
+      final anchorTop = tester.getTopLeft(anchor).dy;
+      completer.complete(replies);
+      await tester.pump();
+
+      // Hydration has scheduled the settle's second post-frame callback. A
+      // drag starts before another frame can run it.
+      tester
+          .widget<KeyboardDismissOnDrag>(find.byType(KeyboardDismissOnDrag))
+          .onUserScrollStart!();
+      await tester.pumpAndSettle();
+
+      expect(anchor, findsOneWidget);
+      expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+      expect(
+        find.byKey(const ValueKey('thread-message-group-reply-34')),
+        findsNothing,
+      );
+    });
+
+    testWidgets(
+      'keyboard-open initial hydration settles within the list viewport',
+      (tester) async {
+        tester.view.physicalSize = const Size(400, 800);
+        tester.view.devicePixelRatio = 1;
+        addTearDown(tester.view.reset);
+
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Thread root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 30; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: i == 29
+                  ? List.filled(15, 'Tall latest reply').join('\n')
+                  : 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+        final completer = Completer<List<NostrEvent>>();
+
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            pendingThreadReplies: {'thread-root': completer.future},
+            users: const {
+              'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+              'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+            },
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final threadHead = formatTimeline([rootEvent]).single;
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: threadHead,
+              allMessages: [threadHead],
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: true,
+              isArchived: false,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        await tester.tap(find.text('Reply in thread…').hitTestable());
+        await tester.pumpAndSettle();
+        tester.view.viewInsets = const FakeViewPadding(bottom: 300);
+        await tester.pumpAndSettle();
+
+        final list = find.byKey(const ValueKey('thread-message-list'));
+        final listHeight = tester.getSize(list).height;
+        final mediaQueryHeight = MediaQuery.sizeOf(tester.element(list)).height;
+        expect(listHeight, lessThan(mediaQueryHeight));
+
+        completer.complete(replies);
+        await tester.pumpAndSettle();
+
+        final latestReply = find.byKey(
+          const ValueKey('thread-message-group-reply-29'),
+        );
+        final latestRect = tester.getRect(latestReply);
+        final context = tester.element(latestReply);
+        final composerTop = tester
+            .getTopLeft(find.byKey(const ValueKey('composer-surface')))
+            .dy;
+        expect(
+          latestRect.top,
+          greaterThanOrEqualTo(frostedAppBarHeight(context)),
+        );
+        expect(latestRect.bottom, lessThanOrEqualTo(composerTop));
+      },
+    );
+
+    testWidgets('short initial thread hydration remains top-anchored', (
+      tester,
+    ) async {
+      final rootEvent = _textMsg(
+        id: 'thread-root',
+        pubkey: 'alice',
+        content: 'Thread root',
+        createdAt: 1000,
+      );
+      final replies = [
+        _textMsg(
+          id: 'reply-1',
+          pubkey: 'bob',
+          content: 'First reply',
+          createdAt: 1100,
+          extraTags: const [
+            ['e', 'thread-root', '', 'reply'],
+          ],
+        ),
+        _textMsg(
+          id: 'reply-2',
+          pubkey: 'bob',
+          content: 'Second reply',
+          createdAt: 1101,
+          extraTags: const [
+            ['e', 'thread-root', '', 'reply'],
+          ],
+        ),
+      ];
+      final completer = Completer<List<NostrEvent>>();
+
+      await tester.pumpWidget(
+        _buildTestable(
+          messages: [rootEvent],
+          pendingThreadReplies: {'thread-root': completer.future},
+          users: const {
+            'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+            'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+          },
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      final threadHead = formatTimeline([rootEvent]).single;
+      Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+        MaterialPageRoute<void>(
+          builder: (_) => ThreadDetailPage(
+            threadHead: threadHead,
+            allMessages: [threadHead],
+            channelId: _channelId,
+            currentPubkey: 'self',
+            isMember: true,
+            isArchived: false,
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      final headFinder = find.byKey(
+        const ValueKey('thread-message-group-thread-root'),
+      );
+      final initialHeadY = tester.getTopLeft(headFinder).dy;
+
+      completer.complete(replies);
+      await tester.pumpAndSettle();
+
+      expect(headFinder, findsOneWidget);
+      expect(
+        find.byKey(const ValueKey('thread-message-group-reply-2')),
+        findsOneWidget,
+      );
+      expect(tester.getTopLeft(headFinder).dy, closeTo(initialHeadY, 0.5));
+    });
+
+    testWidgets(
+      'slow initial hydration requests the frame that settles the latest reply',
+      (tester) async {
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Thread root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 30; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+        final completer = Completer<List<NostrEvent>>();
+
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            pendingThreadReplies: {'thread-root': completer.future},
+            users: const {
+              'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+              'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+            },
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final threadHead = formatTimeline([rootEvent]).single;
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: threadHead,
+              allMessages: [threadHead],
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: true,
+              isArchived: false,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        completer.complete(replies);
+        await tester.pump();
+        expect(tester.binding.hasScheduledFrame, isTrue);
+        await tester.pumpAndSettle();
+
+        expect(
+          find.byKey(const ValueKey('thread-message-group-thread-root')),
+          findsNothing,
+        );
+        expect(
+          find.byKey(const ValueKey('thread-message-group-reply-29')),
+          findsOneWidget,
+        );
+      },
+    );
+
+    testWidgets(
+      'initial thread hydration settles on the latest reply after pagination',
+      (tester) async {
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Thread root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 30; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+        final completer = Completer<List<NostrEvent>>();
+        final messagesNotifier = _FakeMessagesNotifier([rootEvent]);
+
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            messagesNotifier: messagesNotifier,
+            pendingThreadReplies: {'thread-root': completer.future},
+            users: const {
+              'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
+              'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
+            },
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final threadHead = formatTimeline([rootEvent]).single;
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: threadHead,
+              allMessages: [threadHead],
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: true,
+              isArchived: false,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+        expect(
+          find.byKey(const ValueKey('thread-message-group-thread-root')),
+          findsOneWidget,
+        );
+
+        completer.complete(replies);
+        await tester.pump();
+        final latestLiveReply = _textMsg(
+          id: 'reply-live',
+          pubkey: 'bob',
+          content: List.filled(10, 'Tall live reply').join('\n'),
+          createdAt: 1200,
+          extraTags: const [
+            ['e', 'thread-root', '', 'reply'],
+          ],
+        );
+        messagesNotifier.setMessages([rootEvent, latestLiveReply]);
+        await tester.pumpAndSettle();
+
+        expect(
+          find.byKey(const ValueKey('thread-message-group-thread-root')),
+          findsNothing,
+        );
+        expect(
+          find.byKey(const ValueKey('thread-message-group-reply-live')),
+          findsOneWidget,
+        );
+        final listRect = tester.getRect(
+          find.byKey(const ValueKey('thread-message-list')),
+        );
+        final latestReply = find.byKey(
+          const ValueKey('thread-message-group-reply-live'),
+        );
+        final latestRect = tester.getRect(latestReply);
+        final composerTop = tester
+            .getTopLeft(find.byKey(const ValueKey('composer-surface')))
+            .dy;
+        expect(latestRect.bottom, lessThanOrEqualTo(composerTop));
+        expect(latestRect.bottom, greaterThan(listRect.center.dy));
+      },
+    );
+
+    testWidgets(
+      'active primary drag rejects queued remote and local reply tail work',
+      (tester) async {
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 30; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+        final messagesNotifier = _FakeMessagesNotifier([rootEvent]);
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            messagesNotifier: messagesNotifier,
+            threadReplies: {'thread-root': replies},
+          ),
+        );
+        await tester.pumpAndSettle();
+        final threadHead = formatTimeline([rootEvent]).single;
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: threadHead,
+              allMessages: [threadHead],
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: true,
+              isArchived: false,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+        final lifecycle = tester.widget<KeyboardDismissOnDrag>(
+          find.byType(KeyboardDismissOnDrag),
+        );
+        lifecycle.onUserScrollStart!();
+        final anchor = find.byKey(
+          const ValueKey('thread-message-group-reply-20'),
+        );
+        final anchorTop = tester.getTopLeft(anchor).dy;
+        final remoteReply = _textMsg(
+          id: 'reply-remote',
+          pubkey: 'bob',
+          content: 'Remote',
+          createdAt: 1200,
+          extraTags: const [
+            ['e', 'thread-root', '', 'reply'],
+          ],
+        );
+        messagesNotifier.setMessages([rootEvent, remoteReply]);
+        await tester.pumpAndSettle();
+        expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+        final localReply = _textMsg(
+          id: 'reply-local',
+          pubkey: 'self',
+          content: 'Local',
+          createdAt: 1201,
+          extraTags: const [
+            ['e', 'thread-root', '', 'reply'],
+          ],
+        );
+        messagesNotifier.setMessages([rootEvent, remoteReply, localReply]);
+        await tester.pumpAndSettle();
+        expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+        lifecycle.onUserScrollEnd!();
+      },
+    );
+
+    testWidgets('idle detached local reply retains force-visible behavior', (
+      tester,
+    ) async {
+      final rootEvent = _textMsg(
+        id: 'thread-root',
+        pubkey: 'alice',
+        content: 'Root',
+        createdAt: 1000,
+      );
+      final replies = [
+        for (var i = 0; i < 30; i++)
+          _textMsg(
+            id: 'reply-$i',
+            pubkey: 'bob',
+            content: 'Reply $i',
+            createdAt: 1100 + i,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+      ];
+      final messagesNotifier = _FakeMessagesNotifier([rootEvent]);
+      await tester.pumpWidget(
+        _buildTestable(
+          messages: [rootEvent],
+          messagesNotifier: messagesNotifier,
+          threadReplies: {'thread-root': replies},
+        ),
+      );
+      await tester.pumpAndSettle();
+      final threadHead = formatTimeline([rootEvent]).single;
+      Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+        MaterialPageRoute<void>(
+          builder: (_) => ThreadDetailPage(
+            threadHead: threadHead,
+            allMessages: [threadHead],
+            channelId: _channelId,
+            currentPubkey: 'self',
+            isMember: true,
+            isArchived: false,
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+      final list = find.byKey(const ValueKey('thread-message-list'));
+      for (var i = 0; i < 4; i++) {
+        await tester.drag(list, const Offset(0, 100));
+        await tester.pumpAndSettle();
+      }
+      final localReply = _textMsg(
+        id: 'reply-local',
+        pubkey: 'self',
+        content: 'Local',
+        createdAt: 1200,
+        extraTags: const [
+          ['e', 'thread-root', '', 'reply'],
+        ],
+      );
+      messagesNotifier.setMessages([rootEvent, localReply]);
+      await tester.pumpAndSettle();
+      expect(
+        find.byKey(const ValueKey('thread-message-group-reply-local')),
+        findsOneWidget,
+      );
+
+      final laterRemoteReplies = [
+        for (var i = 0; i < 10; i++)
+          _textMsg(
+            id: 'reply-after-local-$i',
+            pubkey: 'bob',
+            content: List.filled(8, 'Tall remote reply $i').join('\n'),
+            createdAt: 1300 + i,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+      ];
+      messagesNotifier.setMessages([
+        rootEvent,
+        localReply,
+        ...laterRemoteReplies,
+      ]);
+      await tester.pumpAndSettle();
+      expect(
+        find.byKey(const ValueKey('thread-message-group-reply-after-local-9')),
+        findsOneWidget,
+      );
+    });
+
+    testWidgets(
+      'short followed thread stays top-anchored after viewport resize',
+      (tester) async {
+        tester.view.physicalSize = const Size(400, 800);
+        tester.view.devicePixelRatio = 1;
+        addTearDown(tester.view.reset);
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 3; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            threadReplies: {'thread-root': replies},
+          ),
+        );
+        await tester.pumpAndSettle();
+        final threadHead = formatTimeline([rootEvent]).single;
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: threadHead,
+              allMessages: [threadHead],
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: false,
+              isArchived: false,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final head = find.byKey(
+          const ValueKey('thread-message-group-thread-root'),
+        );
+        final latest = find.byKey(
+          const ValueKey('thread-message-group-reply-2'),
+        );
+        final initialHeadTop = tester.getTopLeft(head).dy;
+
+        tester.view.viewInsets = const FakeViewPadding(bottom: 100);
+        await tester.pumpAndSettle();
+
+        expect(latest, findsOneWidget);
+        expect(tester.getTopLeft(head).dy, closeTo(initialHeadTop, 0.5));
+      },
+    );
+
+    for (final layout in <({String name, bool isMember, bool isArchived})>[
+      (name: 'non-member', isMember: false, isArchived: false),
+      (name: 'archived', isMember: true, isArchived: true),
+      (name: 'writable member', isMember: true, isArchived: false),
+    ]) {
+      for (final tail in <({String name, bool isLong})>[
+        (name: 'short', isLong: false),
+        (name: 'long', isLong: true),
+      ]) {
+        testWidgets(
+          '${layout.name} typing transitions preserve a followed ${tail.name} tail',
+          (tester) async {
+            tester.view.physicalSize = const Size(400, 800);
+            tester.view.devicePixelRatio = 1;
+            addTearDown(tester.view.reset);
+            final rootEvent = _textMsg(
+              id: 'thread-root',
+              pubkey: 'alice',
+              content: 'Root',
+              createdAt: 1000,
+            );
+            final replyCount = tail.isLong ? 30 : 6;
+            final replies = [
+              for (var i = 0; i < replyCount; i++)
+                _textMsg(
+                  id: 'reply-$i',
+                  pubkey: 'bob',
+                  content: i == replyCount - 1 && tail.isLong
+                      ? List.filled(8, 'Tall latest reply').join('\n')
+                      : 'Reply $i',
+                  createdAt: 1100 + i,
+                  extraTags: const [
+                    ['e', 'thread-root', '', 'reply'],
+                  ],
+                ),
+            ];
+            final typingNotifier = _FakeTypingNotifier(const []);
+            await tester.pumpWidget(
+              _buildTestable(
+                messages: [rootEvent],
+                typingNotifier: typingNotifier,
+                threadReplies: {'thread-root': replies},
+                disableAnimations: true,
+              ),
+            );
+            await tester.pumpAndSettle();
+            final threadHead = formatTimeline([rootEvent]).single;
+            Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+              MaterialPageRoute<void>(
+                builder: (_) => ThreadDetailPage(
+                  threadHead: threadHead,
+                  allMessages: [threadHead],
+                  channelId: _channelId,
+                  currentPubkey: 'self',
+                  isMember: layout.isMember,
+                  isArchived: layout.isArchived,
+                ),
+              ),
+            );
+            await tester.pumpAndSettle();
+            final latest = find.byKey(
+              ValueKey('thread-message-group-reply-${replyCount - 1}'),
+            );
+            final head = find.byKey(
+              const ValueKey('thread-message-group-thread-root'),
+            );
+            final initialHeadTop = tail.isLong
+                ? null
+                : tester.getTopLeft(head).dy;
+            final list = find.byKey(const ValueKey('thread-message-list'));
+            final initialHeight = tester.getSize(list).height;
+            void expectTailWithinList() {
+              final latestRect = tester.getRect(latest);
+              final listRect = tester.getRect(list);
+              expect(
+                latestRect.top,
+                greaterThanOrEqualTo(
+                  frostedAppBarHeight(tester.element(latest)),
+                ),
+              );
+              if (tail.isLong) {
+                expect(latestRect.bottom, lessThanOrEqualTo(listRect.bottom));
+              }
+            }
+
+            expectTailWithinList();
+            typingNotifier.setEntries(const [
+              TypingEntry(
+                pubkey: 'bob',
+                threadHeadId: 'thread-root',
+                expiresAtMs: 9999999999999,
+              ),
+            ]);
+            await tester.pumpAndSettle();
+            expectTailWithinList();
+            if (initialHeadTop != null) {
+              expect(tester.getTopLeft(head).dy, closeTo(initialHeadTop, 0.5));
+            }
+            if (!layout.isMember || layout.isArchived) {
+              expect(tester.getSize(list).height, lessThan(initialHeight));
+            }
+            typingNotifier.setEntries(const []);
+            await tester.pumpAndSettle();
+            expectTailWithinList();
+            if (initialHeadTop != null) {
+              expect(tester.getTopLeft(head).dy, closeTo(initialHeadTop, 0.5));
+            }
+            expect(tester.getSize(list).height, closeTo(initialHeight, 0.5));
+          },
+        );
+      }
+
+      testWidgets(
+        '${layout.name} typing transitions preserve a detached anchor',
+        (tester) async {
+          tester.view.physicalSize = const Size(400, 800);
+          tester.view.devicePixelRatio = 1;
+          addTearDown(tester.view.reset);
+          final rootEvent = _textMsg(
+            id: 'thread-root',
+            pubkey: 'alice',
+            content: 'Root',
+            createdAt: 1000,
+          );
+          final replies = [
+            for (var i = 0; i < 30; i++)
+              _textMsg(
+                id: 'reply-$i',
+                pubkey: 'bob',
+                content: 'Reply $i',
+                createdAt: 1100 + i,
+                extraTags: const [
+                  ['e', 'thread-root', '', 'reply'],
+                ],
+              ),
+          ];
+          final typingNotifier = _FakeTypingNotifier(const []);
+          await tester.pumpWidget(
+            _buildTestable(
+              messages: [rootEvent],
+              typingNotifier: typingNotifier,
+              threadReplies: {'thread-root': replies},
+              disableAnimations: true,
+            ),
+          );
+          await tester.pumpAndSettle();
+          final threadHead = formatTimeline([rootEvent]).single;
+          Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+            MaterialPageRoute<void>(
+              builder: (_) => ThreadDetailPage(
+                threadHead: threadHead,
+                allMessages: [threadHead],
+                channelId: _channelId,
+                currentPubkey: 'self',
+                isMember: layout.isMember,
+                isArchived: layout.isArchived,
+              ),
+            ),
+          );
+          await tester.pumpAndSettle();
+          final list = find.byKey(const ValueKey('thread-message-list'));
+          for (var i = 0; i < 4; i++) {
+            await tester.drag(list, const Offset(0, 100));
+            await tester.pumpAndSettle();
+          }
+          final listRect = tester.getRect(list);
+          final anchor =
+              [
+                for (var i = 0; i < replies.length; i++)
+                  find.byKey(ValueKey('thread-message-group-reply-$i')),
+              ].firstWhere(
+                (candidate) =>
+                    candidate.evaluate().length == 1 &&
+                    listRect.overlaps(tester.getRect(candidate)),
+              );
+          final anchorTop = tester.getTopLeft(anchor).dy;
+          typingNotifier.setEntries(const [
+            TypingEntry(
+              pubkey: 'bob',
+              threadHeadId: 'thread-root',
+              expiresAtMs: 9999999999999,
+            ),
+          ]);
+          await tester.pumpAndSettle();
+          expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+          typingNotifier.setEntries(const []);
+          await tester.pumpAndSettle();
+          expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+        },
+      );
+    }
+
+    for (final layout in [
+      (name: 'non-member', isMember: false, isArchived: false),
+      (name: 'archived', isMember: true, isArchived: true),
+    ]) {
+      testWidgets('${layout.name} no-dock tail resumes full-viewport follow', (
+        tester,
+      ) async {
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Thread root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 30; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+        final messagesNotifier = _FakeMessagesNotifier([rootEvent]);
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            messagesNotifier: messagesNotifier,
+            threadReplies: {'thread-root': replies},
+          ),
+        );
+        await tester.pumpAndSettle();
+        final threadHead = formatTimeline([rootEvent]).single;
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: threadHead,
+              allMessages: [threadHead],
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: layout.isMember,
+              isArchived: layout.isArchived,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final lifecycle = tester.widget<KeyboardDismissOnDrag>(
+          find.byType(KeyboardDismissOnDrag),
+        );
+        lifecycle.onUserScrollStart!();
+        lifecycle.onUserScrollEnd!();
+        await tester.pumpAndSettle();
+        messagesNotifier.setMessages([
+          rootEvent,
+          _textMsg(
+            id: 'reply-remote',
+            pubkey: 'bob',
+            content: 'Remote tail',
+            createdAt: 9999,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+        ]);
+        await tester.pumpAndSettle();
+
+        expect(
+          find.byKey(const ValueKey('thread-message-group-reply-remote')),
+          findsOneWidget,
+        );
+      });
+    }
+
     testWidgets(
-      'initial thread hydration keeps the head visible instead of following the tail',
+      'composer-covered tail remains detached after drag-end settlement',
       (tester) async {
+        tester.view.physicalSize = const Size(400, 800);
+        tester.view.devicePixelRatio = 1;
+        addTearDown(tester.view.reset);
+
+        final rootEvent = _textMsg(
+          id: 'thread-root',
+          pubkey: 'alice',
+          content: 'Thread root',
+          createdAt: 1000,
+        );
+        final replies = [
+          for (var i = 0; i < 30; i++)
+            _textMsg(
+              id: 'reply-$i',
+              pubkey: 'bob',
+              content: 'Reply $i',
+              createdAt: 1100 + i,
+              extraTags: const [
+                ['e', 'thread-root', '', 'reply'],
+              ],
+            ),
+        ];
+        final messagesNotifier = _FakeMessagesNotifier([rootEvent]);
+        await tester.pumpWidget(
+          _buildTestable(
+            messages: [rootEvent],
+            messagesNotifier: messagesNotifier,
+            threadReplies: {'thread-root': replies},
+          ),
+        );
+        await tester.pumpAndSettle();
+        final threadHead = formatTimeline([rootEvent]).single;
+        Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+          MaterialPageRoute<void>(
+            builder: (_) => ThreadDetailPage(
+              threadHead: threadHead,
+              allMessages: [threadHead],
+              channelId: _channelId,
+              currentPubkey: 'self',
+              isMember: true,
+              isArchived: false,
+            ),
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        final list = find.byKey(const ValueKey('thread-message-list'));
+        final latest = find.byKey(
+          const ValueKey('thread-message-group-reply-29'),
+        );
+        final composer = find.byKey(const ValueKey('composer-surface'));
+        await tester.drag(list, const Offset(0, 24));
+        await tester.pumpAndSettle();
+        expect(
+          tester.getBottomLeft(latest).dy,
+          greaterThan(tester.getTopLeft(composer).dy),
+        );
+        expect(
+          tester.getBottomLeft(latest).dy,
+          lessThanOrEqualTo(tester.getBottomLeft(list).dy),
+        );
+        final visibleBeforeRemote = tester
+            .widgetList<Widget>(
+              find.byWidgetPredicate(
+                (widget) =>
+                    widget.key is ValueKey<String> &&
+                    (widget.key! as ValueKey<String>).value.startsWith(
+                      'thread-message-group-',
+                    ),
+              ),
+            )
+            .map((widget) => widget.key)
+            .toSet();
+        final anchorKey = visibleBeforeRemote.firstWhere(
+          (key) => key != latest.evaluate().single.widget.key,
+        );
+        final anchor = find.byKey(anchorKey!);
+        final detachedTop = tester.getTopLeft(anchor).dy;
+
+        messagesNotifier.setMessages([
+          rootEvent,
+          _textMsg(
+            id: 'reply-remote',
+            pubkey: 'bob',
+            content: 'Remote tail',
+            createdAt: 9999,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+        ]);
+        await tester.pumpAndSettle();
+        expect(
+          tester
+              .widgetList<Widget>(
+                find.byWidgetPredicate(
+                  (widget) => visibleBeforeRemote.contains(widget.key),
+                ),
+              )
+              .map((widget) => widget.key),
+          isNotEmpty,
+        );
+        expect(tester.getTopLeft(anchor).dy, closeTo(detachedTop, 0.5));
+
+        await tester.tap(find.text('Reply in thread…').hitTestable());
+        await tester.pumpAndSettle();
+        expect(tester.getTopLeft(anchor).dy, closeTo(detachedTop, 0.5));
+
+        tester.view.viewInsets = const FakeViewPadding(bottom: 300);
+        await tester.pumpAndSettle();
+        expect(tester.getTopLeft(anchor).dy, closeTo(detachedTop, 0.5));
+      },
+    );
+
+    testWidgets('invalid writable dock geometry cannot resume tail follow', (
+      tester,
+    ) async {
+      final rootEvent = _textMsg(
+        id: 'thread-root',
+        pubkey: 'alice',
+        content: 'Thread root',
+        createdAt: 1000,
+      );
+      final replies = [
+        for (var i = 0; i < 30; i++)
+          _textMsg(
+            id: 'reply-$i',
+            pubkey: 'bob',
+            content: 'Reply $i',
+            createdAt: 1100 + i,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+      ];
+      final messagesNotifier = _FakeMessagesNotifier([rootEvent]);
+      await tester.pumpWidget(
+        _buildTestable(
+          messages: [rootEvent],
+          messagesNotifier: messagesNotifier,
+          threadReplies: {'thread-root': replies},
+        ),
+      );
+      await tester.pumpAndSettle();
+      final threadHead = formatTimeline([rootEvent]).single;
+      Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+        MaterialPageRoute<void>(
+          builder: (_) => ThreadDetailPage(
+            threadHead: threadHead,
+            allMessages: [threadHead],
+            channelId: _channelId,
+            currentPubkey: 'self',
+            isMember: true,
+            isArchived: false,
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      tester
+          .widget<ComposerDockSizeReporter>(
+            find.byType(ComposerDockSizeReporter).last,
+          )
+          .onHeightChanged(0);
+      await tester.pumpAndSettle();
+      final lifecycle = tester.widget<KeyboardDismissOnDrag>(
+        find.byType(KeyboardDismissOnDrag),
+      );
+      lifecycle.onUserScrollStart!();
+      lifecycle.onUserScrollEnd!();
+      await tester.pumpAndSettle();
+      final anchor = find.byKey(
+        const ValueKey('thread-message-group-reply-29'),
+      );
+      final anchorTop = tester.getTopLeft(anchor).dy;
+
+      messagesNotifier.setMessages([
+        rootEvent,
+        _textMsg(
+          id: 'reply-remote',
+          pubkey: 'bob',
+          content: 'Remote tail',
+          createdAt: 9999,
+          extraTags: const [
+            ['e', 'thread-root', '', 'reply'],
+          ],
+        ),
+      ]);
+      await tester.pumpAndSettle();
+
+      expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+    });
+
+    testWidgets('new drag invalidates deferred drag-end resumption', (
+      tester,
+    ) async {
+      final rootEvent = _textMsg(
+        id: 'thread-root',
+        pubkey: 'alice',
+        content: 'Thread root',
+        createdAt: 1000,
+      );
+      final replies = [
+        for (var i = 0; i < 30; i++)
+          _textMsg(
+            id: 'reply-$i',
+            pubkey: 'bob',
+            content: 'Reply $i',
+            createdAt: 1100 + i,
+            extraTags: const [
+              ['e', 'thread-root', '', 'reply'],
+            ],
+          ),
+      ];
+      final messagesNotifier = _FakeMessagesNotifier([rootEvent]);
+      await tester.pumpWidget(
+        _buildTestable(
+          messages: [rootEvent],
+          messagesNotifier: messagesNotifier,
+          threadReplies: {'thread-root': replies},
+        ),
+      );
+      await tester.pumpAndSettle();
+      final threadHead = formatTimeline([rootEvent]).single;
+      Navigator.of(tester.element(find.byType(ChannelDetailPage))).push(
+        MaterialPageRoute<void>(
+          builder: (_) => ThreadDetailPage(
+            threadHead: threadHead,
+            allMessages: [threadHead],
+            channelId: _channelId,
+            currentPubkey: 'self',
+            isMember: true,
+            isArchived: false,
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      var lifecycle = tester.widget<KeyboardDismissOnDrag>(
+        find.byType(KeyboardDismissOnDrag),
+      );
+      lifecycle.onUserScrollStart!();
+      lifecycle.onUserScrollEnd!();
+      await tester.pump();
+      lifecycle = tester.widget<KeyboardDismissOnDrag>(
+        find.byType(KeyboardDismissOnDrag),
+      );
+      lifecycle.onUserScrollStart!();
+      await tester.pumpAndSettle();
+      final anchor = find.byKey(
+        const ValueKey('thread-message-group-reply-29'),
+      );
+      final anchorTop = tester.getTopLeft(anchor).dy;
+
+      messagesNotifier.setMessages([
+        rootEvent,
+        _textMsg(
+          id: 'reply-remote',
+          pubkey: 'bob',
+          content: 'Remote tail',
+          createdAt: 9999,
+          extraTags: const [
+            ['e', 'thread-root', '', 'reply'],
+          ],
+        ),
+      ]);
+      await tester.pumpAndSettle();
+
+      expect(tester.getTopLeft(anchor).dy, closeTo(anchorTop, 0.5));
+      tester
+          .widget<KeyboardDismissOnDrag>(find.byType(KeyboardDismissOnDrag))
+          .onUserScrollEnd!();
+    });
+
+    testWidgets(
+      'dragging away opts out, then returning to the tail resumes keyboard realignment',
+      (tester) async {
+        tester.view.physicalSize = const Size(400, 800);
+        tester.view.devicePixelRatio = 1;
+        addTearDown(tester.view.reset);
+
         final rootEvent = _textMsg(
           id: 'thread-root',
           pubkey: 'alice',
@@ -4106,12 +5658,11 @@ void main() {
               ],
             ),
         ];
-        final completer = Completer<List<NostrEvent>>();
 
         await tester.pumpWidget(
           _buildTestable(
             messages: [rootEvent],
-            pendingThreadReplies: {'thread-root': completer.future},
+            threadReplies: {'thread-root': replies},
             users: const {
               'alice': UserProfile(pubkey: 'alice', displayName: 'Alice'),
               'bob': UserProfile(pubkey: 'bob', displayName: 'Bob'),
@@ -4134,22 +5685,72 @@ void main() {
           ),
         );
         await tester.pumpAndSettle();
+
+        final list = find.byKey(const ValueKey('thread-message-list'));
+        for (var i = 0; i < 4; i++) {
+          await tester.drag(list, const Offset(0, 100));
+          await tester.pumpAndSettle();
+        }
         expect(
-          find.byKey(const ValueKey('thread-message-group-thread-root')),
-          findsOneWidget,
+          find.byKey(const ValueKey('thread-message-group-reply-29')),
+          findsNothing,
         );
+        final visibleBeforeResize = tester
+            .widgetList<Widget>(
+              find.byWidgetPredicate(
+                (widget) =>
+                    widget.key is ValueKey<String> &&
+                    (widget.key! as ValueKey<String>).value.startsWith(
+                      'thread-message-group-',
+                    ),
+              ),
+            )
+            .map((widget) => widget.key)
+            .toSet();
 
-        completer.complete(replies);
+        tester.view.viewInsets = const FakeViewPadding(bottom: 300);
         await tester.pumpAndSettle();
 
-        expect(
-          find.byKey(const ValueKey('thread-message-group-thread-root')),
-          findsOneWidget,
-        );
         expect(
           find.byKey(const ValueKey('thread-message-group-reply-29')),
           findsNothing,
         );
+        expect(
+          tester
+              .widgetList<Widget>(
+                find.byWidgetPredicate(
+                  (widget) => visibleBeforeResize.contains(widget.key),
+                ),
+              )
+              .map((widget) => widget.key),
+          isNotEmpty,
+        );
+
+        // Return the viewport to its original geometry while opt-out remains
+        // active. This must not itself pull the list back to the tail.
+        tester.view.viewInsets = FakeViewPadding.zero;
+        await tester.pumpAndSettle();
+
+        // Returning to the tail is a deliberate choice to resume following.
+        // Only the scroll-end callback may clear the opt-out state, so this
+        // reverse drag must complete before geometry changes re-align the tail.
+        for (var i = 0; i < 12; i++) {
+          await tester.drag(list, const Offset(0, -100));
+          await tester.pumpAndSettle();
+        }
+        final latestReply = find.byKey(
+          const ValueKey('thread-message-group-reply-29'),
+        );
+        expect(latestReply, findsOneWidget);
+
+        final composerSurface = find.byKey(const ValueKey('composer-surface'));
+        tester.view.viewInsets = const FakeViewPadding(bottom: 300);
+        await tester.pumpAndSettle();
+
+        expect(
+          tester.getBottomLeft(latestReply).dy,
+          lessThanOrEqualTo(tester.getTopLeft(composerSurface).dy),
+        );
       },
     );
 
@@ -4533,6 +6134,8 @@ class _FakeTypingNotifier extends ChannelTypingNotifier {
 
   @override
   List<TypingEntry> build() => _entries;
+
+  void setEntries(List<TypingEntry> entries) => state = entries;
 }
 
 class _SynchronousReadStateNotifier extends ReadStateNotifier {
diff --git a/mobile/test/shared/widgets/keyboard_dismiss_on_drag_test.dart b/mobile/test/shared/widgets/keyboard_dismiss_on_drag_test.dart
index 19424b7c82e..55f6281e50f 100644
--- a/mobile/test/shared/widgets/keyboard_dismiss_on_drag_test.dart
+++ b/mobile/test/shared/widgets/keyboard_dismiss_on_drag_test.dart
@@ -7,6 +7,8 @@ import 'package:flutter_test/flutter_test.dart';
 Widget _testable({
   required FocusNode focusNode,
   VoidCallback? onUserScrollStart,
+  VoidCallback? onUserScrollEnd,
+  Widget? scrollChild,
 }) {
   return MaterialApp(
     home: Scaffold(
@@ -16,12 +18,15 @@ Widget _testable({
           Expanded(
             child: KeyboardDismissOnDrag(
               onUserScrollStart: onUserScrollStart,
-              child: ListView(
-                children: [
-                  for (var i = 0; i < 40; i++)
-                    SizedBox(height: 60, child: Text('row $i')),
-                ],
-              ),
+              onUserScrollEnd: onUserScrollEnd,
+              child:
+                  scrollChild ??
+                  ListView(
+                    children: [
+                      for (var i = 0; i < 40; i++)
+                        SizedBox(height: 60, child: Text('row $i')),
+                    ],
+                  ),
             ),
           ),
         ],
@@ -62,7 +67,15 @@ void main() {
       final focusNode = FocusNode();
       addTearDown(focusNode.dispose);
       _raiseKeyboard(tester);
-      await tester.pumpWidget(_testable(focusNode: focusNode));
+      var starts = 0;
+      var ends = 0;
+      await tester.pumpWidget(
+        _testable(
+          focusNode: focusNode,
+          onUserScrollStart: () => starts += 1,
+          onUserScrollEnd: () => ends += 1,
+        ),
+      );
       focusNode.requestFocus();
       await tester.pump();
       expect(focusNode.hasFocus, isTrue);
@@ -74,6 +87,8 @@ void main() {
       // `ScrollUpdateNotification`, and the one a focused composer is usually
       // sitting in.
       expect(focusNode.hasFocus, isFalse);
+      expect(starts, 1);
+      expect(ends, 1);
     });
 
     testWidgets('an ordinary downward scroll dismisses too', (tester) async {
@@ -125,6 +140,147 @@ void main() {
       expect(userScrollStarts, 1);
     });
 
+    testWidgets('reports a user scroll ending', (tester) async {
+      final focusNode = FocusNode();
+      addTearDown(focusNode.dispose);
+      var userScrollEnds = 0;
+      await tester.pumpWidget(
+        _testable(
+          focusNode: focusNode,
+          onUserScrollEnd: () => userScrollEnds += 1,
+        ),
+      );
+
+      await tester.drag(find.text('row 3'), const Offset(0, -100));
+      await tester.pumpAndSettle();
+
+      expect(userScrollEnds, 1);
+    });
+
+    testWidgets('nested horizontal drag is outside the primary list boundary', (
+      tester,
+    ) async {
+      final focusNode = FocusNode();
+      addTearDown(focusNode.dispose);
+      _raiseKeyboard(tester);
+      var starts = 0;
+      var ends = 0;
+      await tester.pumpWidget(
+        _testable(
+          focusNode: focusNode,
+          onUserScrollStart: () => starts += 1,
+          onUserScrollEnd: () => ends += 1,
+          scrollChild: ListView(
+            children: [
+              SizedBox(
+                height: 80,
+                child: SingleChildScrollView(
+                  key: const ValueKey('nested-horizontal'),
+                  scrollDirection: Axis.horizontal,
+                  child: const SizedBox(
+                    width: 1600,
+                    child: Text('nested horizontal content'),
+                  ),
+                ),
+              ),
+              const SizedBox(height: 1200),
+            ],
+          ),
+        ),
+      );
+      focusNode.requestFocus();
+      await tester.pump();
+
+      await tester.drag(
+        find.byKey(const ValueKey('nested-horizontal')),
+        const Offset(-200, 60),
+      );
+      await tester.pumpAndSettle();
+
+      expect(starts, 0);
+      expect(ends, 0);
+      expect(focusNode.hasFocus, isTrue);
+    });
+
+    testWidgets('nested vertical drag is outside the primary list boundary', (
+      tester,
+    ) async {
+      final focusNode = FocusNode();
+      addTearDown(focusNode.dispose);
+      _raiseKeyboard(tester);
+      var starts = 0;
+      var ends = 0;
+      await tester.pumpWidget(
+        _testable(
+          focusNode: focusNode,
+          onUserScrollStart: () => starts += 1,
+          onUserScrollEnd: () => ends += 1,
+          scrollChild: ListView(
+            children: [
+              SizedBox(
+                height: 180,
+                child: ListView(
+                  key: const ValueKey('nested-vertical'),
+                  children: const [
+                    SizedBox(
+                      height: 900,
+                      child: Text('nested vertical content'),
+                    ),
+                  ],
+                ),
+              ),
+              const SizedBox(height: 1200),
+            ],
+          ),
+        ),
+      );
+      focusNode.requestFocus();
+      await tester.pump();
+
+      await tester.drag(
+        find.byKey(const ValueKey('nested-vertical')),
+        const Offset(0, -100),
+      );
+      await tester.pumpAndSettle();
+
+      expect(starts, 0);
+      expect(ends, 0);
+      expect(focusNode.hasFocus, isTrue);
+    });
+
+    testWidgets('programmatic scroll reports no user lifecycle callbacks', (
+      tester,
+    ) async {
+      final focusNode = FocusNode();
+      final controller = ScrollController();
+      addTearDown(focusNode.dispose);
+      addTearDown(controller.dispose);
+      var starts = 0;
+      var ends = 0;
+      await tester.pumpWidget(
+        _testable(
+          focusNode: focusNode,
+          onUserScrollStart: () => starts += 1,
+          onUserScrollEnd: () => ends += 1,
+          scrollChild: ListView(
+            controller: controller,
+            children: const [SizedBox(height: 2000)],
+          ),
+        ),
+      );
+
+      final animation = controller.animateTo(
+        300,
+        duration: const Duration(milliseconds: 100),
+        curve: Curves.linear,
+      );
+      await tester.pumpAndSettle();
+      await animation;
+
+      expect(starts, 0);
+      expect(ends, 0);
+    });
+
     testWidgets('an upward drag never dismisses, however far it goes', (
       tester,
     ) async {
diff --git a/schema/schema.sql b/schema/schema.sql
index 4dac29176d9..d08dbd9019a 100644
--- a/schema/schema.sql
+++ b/schema/schema.sql
@@ -59,6 +59,9 @@ CREATE TABLE communities (
     icon            TEXT,
     created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
     archived_at     TIMESTAMPTZ,
+    deletion_state  TEXT NOT NULL DEFAULT 'active' CHECK (deletion_state IN ('active', 'quiescing', 'fenced', 'tombstone')),
+    deletion_fence_generation BIGINT NOT NULL DEFAULT 0 CHECK (deletion_fence_generation >= 0),
+    deleted_at      TIMESTAMPTZ,
     CONSTRAINT chk_communities_id_not_nil CHECK (id <> '00000000-0000-0000-0000-000000000000'::uuid)
 );
 
@@ -791,6 +794,48 @@ INSERT INTO _operator_global_tables (table_name, reason) VALUES
     ('communities',           'the tenant registry itself; id IS the community key'),
     ('rate_limit_violations', 'deployment abuse/health; never tenant-observable; community_id is an attribution label only'),
     ('_operator_global_tables', 'the registry table itself');
+
+-- ── Additive tenant tables represented in migrations 0002/0007/0017 ──────────
+-- Keep desired-state schema parity with the embedded SQLx migration path.
+CREATE TABLE git_repo_names (
+    community_id  UUID NOT NULL REFERENCES communities(id),
+    repo_id       TEXT NOT NULL,
+    owner_pubkey  TEXT NOT NULL,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (community_id, repo_id)
+);
+CREATE INDEX idx_git_repo_names_owner ON git_repo_names (community_id, owner_pubkey);
+
+CREATE TABLE parameterized_event_watermarks (
+    community_id  UUID NOT NULL REFERENCES communities(id),
+    kind          INT NOT NULL,
+    pubkey        BYTEA NOT NULL,
+    d_tag         TEXT NOT NULL,
+    created_at    TIMESTAMPTZ NOT NULL,
+    event_id      BYTEA NOT NULL,
+    PRIMARY KEY (community_id, kind, pubkey, d_tag)
+);
+CREATE INDEX idx_event_mentions_community_event
+    ON event_mentions (community_id, event_id);
+
+CREATE TABLE product_feedback (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    community_id UUID REFERENCES communities(id) ON DELETE SET NULL,
+    event_id BYTEA NOT NULL CHECK (length(event_id) = 32),
+    submitter_pubkey BYTEA NOT NULL CHECK (length(submitter_pubkey) = 32),
+    category TEXT CHECK (category IN ('bug', 'praise', 'needs-work')),
+    body TEXT NOT NULL CHECK (length(btrim(body)) > 0),
+    tags JSONB NOT NULL DEFAULT '[]'::jsonb CHECK (jsonb_typeof(tags) = 'array'),
+    event_created_at TIMESTAMPTZ NOT NULL,
+    received_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (event_id)
+);
+CREATE INDEX idx_product_feedback_received
+    ON product_feedback (received_at DESC, id);
+CREATE INDEX idx_product_feedback_community_received
+    ON product_feedback (community_id, received_at DESC, id);
+INSERT INTO _operator_global_tables (table_name, reason) VALUES
+    ('product_feedback', 'deployment product inbox; community_id is provenance only');
 -- NIP-PL effective lease state and durable wake outbox. Every key is led by
 -- community_id: client-provided origin is confirmation only, never routing.
 CREATE TABLE push_leases (
@@ -1080,3 +1125,545 @@ INSERT INTO replica_heartbeat (id) VALUES (1);
 
 INSERT INTO _operator_global_tables (table_name, reason) VALUES
     ('replica_heartbeat', 'single-row replication freshness token; describes deployment topology, never tenant data');
+
+-- ── Whole-community deletion control plane (migration 0029) ─────────────────
+CREATE TABLE community_deletion_requests (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    community_id UUID NOT NULL REFERENCES communities(id),
+    community_host TEXT NOT NULL,
+    stage TEXT NOT NULL DEFAULT 'submitted' CHECK (stage IN (
+        'submitted', 'inventoried', 'approved', 'fenced', 'drained',
+        'bindings_removed', 'postgres_purged', 'cache_purged',
+        'logically_verified', 'retention_pending', 'aborted'
+    )),
+    requested_by TEXT NOT NULL,
+    reason TEXT,
+    schema_manifest JSONB,
+    storage_manifest JSONB,
+    destructive_storage_manifest JSONB,
+    destructive_storage_frozen_at TIMESTAMPTZ,
+    inventory_manifest JSONB,
+    inventory_digest BYTEA CHECK (inventory_digest IS NULL OR length(inventory_digest) = 32),
+    inventory_frozen_at TIMESTAMPTZ,
+    fence_generation BIGINT CHECK (fence_generation IS NULL OR fence_generation > 0),
+    lease_owner TEXT,
+    lease_generation BIGINT NOT NULL DEFAULT 0 CHECK (lease_generation >= 0),
+    lease_until TIMESTAMPTZ,
+    attempts INTEGER NOT NULL DEFAULT 0 CHECK (attempts >= 0),
+    retry_count INTEGER NOT NULL DEFAULT 0 CHECK (retry_count >= 0),
+    retry_stage TEXT CHECK (retry_stage IS NULL OR retry_stage IN (
+        'approved', 'fenced', 'drained', 'bindings_removed',
+        'postgres_purged', 'cache_purged', 'logically_verified'
+    )),
+    next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    last_error TEXT,
+    last_error_at TIMESTAMPTZ,
+    blocked_at TIMESTAMPTZ,
+    blocked_reason TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    pre_quiesce_archived_at TIMESTAMPTZ,
+    quiescing_started_at TIMESTAMPTZ,
+    aborted_by TEXT,
+    abort_reason TEXT,
+    aborted_at TIMESTAMPTZ,
+    completed_at TIMESTAMPTZ,
+    CHECK ((blocked_at IS NULL) = (blocked_reason IS NULL)),
+    CHECK ((stage = 'aborted') = (aborted_at IS NOT NULL)),
+    CHECK ((aborted_at IS NULL) = (aborted_by IS NULL)),
+    CHECK ((aborted_at IS NULL) = (abort_reason IS NULL)),
+    CHECK ((inventory_frozen_at IS NULL) = (inventory_digest IS NULL)),
+    UNIQUE (id, community_id, inventory_digest)
+);
+CREATE UNIQUE INDEX community_deletion_requests_active_community
+    ON community_deletion_requests (community_id)
+    WHERE stage <> 'aborted';
+CREATE INDEX community_deletion_requests_runnable
+    ON community_deletion_requests (next_attempt_at, created_at)
+    WHERE blocked_at IS NULL
+      AND stage IN ('approved', 'fenced', 'drained', 'bindings_removed',
+                    'postgres_purged', 'cache_purged', 'logically_verified');
+CREATE INDEX community_deletion_requests_lease
+    ON community_deletion_requests (lease_until) WHERE lease_owner IS NOT NULL;
+
+CREATE TABLE community_deletion_approvals (
+    request_id UUID PRIMARY KEY,
+    community_id UUID NOT NULL,
+    inventory_digest BYTEA NOT NULL CHECK (length(inventory_digest) = 32),
+    approved_by TEXT NOT NULL,
+    note TEXT,
+    approved_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    FOREIGN KEY (request_id, community_id, inventory_digest)
+        REFERENCES community_deletion_requests(id, community_id, inventory_digest)
+        ON DELETE RESTRICT
+);
+
+CREATE FUNCTION prevent_community_deletion_request_retargeting()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    IF NEW.community_id IS DISTINCT FROM OLD.community_id
+        OR NEW.community_host IS DISTINCT FROM OLD.community_host
+    THEN
+        RAISE EXCEPTION 'community deletion target identity is immutable'
+            USING ERRCODE = 'integrity_constraint_violation';
+    END IF;
+    IF OLD.inventory_frozen_at IS NOT NULL AND (
+        NEW.schema_manifest IS DISTINCT FROM OLD.schema_manifest
+        OR NEW.storage_manifest IS DISTINCT FROM OLD.storage_manifest
+        OR NEW.inventory_manifest IS DISTINCT FROM OLD.inventory_manifest
+        OR NEW.inventory_digest IS DISTINCT FROM OLD.inventory_digest
+        OR NEW.inventory_frozen_at IS DISTINCT FROM OLD.inventory_frozen_at
+    ) THEN
+        RAISE EXCEPTION 'frozen community deletion inventory is immutable'
+            USING ERRCODE = 'integrity_constraint_violation';
+    END IF;
+    IF OLD.destructive_storage_frozen_at IS NOT NULL AND (
+        NEW.destructive_storage_manifest IS DISTINCT FROM OLD.destructive_storage_manifest
+        OR NEW.destructive_storage_frozen_at IS DISTINCT FROM OLD.destructive_storage_frozen_at
+    ) THEN
+        RAISE EXCEPTION 'frozen destructive storage manifest is immutable'
+            USING ERRCODE = 'integrity_constraint_violation';
+    END IF;
+    RETURN NEW;
+END;
+$$;
+
+CREATE TRIGGER community_deletion_request_retargeting_guard
+BEFORE UPDATE ON community_deletion_requests
+FOR EACH ROW
+EXECUTE FUNCTION prevent_community_deletion_request_retargeting();
+
+CREATE FUNCTION prevent_community_deletion_approval_removal()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    RAISE EXCEPTION 'community deletion approval evidence is immutable'
+        USING ERRCODE = 'integrity_constraint_violation';
+END;
+$$;
+
+CREATE TRIGGER community_deletion_approval_removal_guard
+BEFORE UPDATE OR DELETE ON community_deletion_approvals
+FOR EACH ROW
+EXECUTE FUNCTION prevent_community_deletion_approval_removal();
+
+CREATE TABLE community_deletion_checkpoints (
+    request_id UUID NOT NULL REFERENCES community_deletion_requests(id) ON DELETE RESTRICT,
+    sequence BIGINT GENERATED ALWAYS AS IDENTITY,
+    stage TEXT NOT NULL,
+    unit_key TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('started', 'completed', 'failed')),
+    lease_generation BIGINT NOT NULL CHECK (lease_generation > 0),
+    attempts INTEGER NOT NULL DEFAULT 1 CHECK (attempts > 0),
+    detail JSONB NOT NULL DEFAULT '{}'::jsonb,
+    error TEXT,
+    started_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    completed_at TIMESTAMPTZ,
+    PRIMARY KEY (request_id, sequence),
+    UNIQUE (request_id, stage, unit_key),
+    CHECK ((status = 'completed') = (completed_at IS NOT NULL)),
+    CHECK ((status = 'failed') = (error IS NOT NULL))
+);
+
+-- Frozen destructive key list, chunked out of the request row so a large
+-- tenant (100k-1M objects) never materializes as one multi-hundred-MB JSONB
+-- value. Rows are written once in the fenced stage, stamped `deleted_at` as
+-- the executor confirms each chunk removed, and dropped at logical
+-- verification. The request row keeps only per-prefix count/bytes/digest
+-- summaries; the chunk stream must hash to those frozen digests.
+CREATE TABLE community_deletion_manifest_keys (
+    request_id UUID NOT NULL REFERENCES community_deletion_requests(id) ON DELETE CASCADE,
+    chunk_no BIGINT NOT NULL CHECK (chunk_no >= 0),
+    prefix TEXT NOT NULL,
+    keys JSONB NOT NULL,
+    deleted_at TIMESTAMPTZ,
+    PRIMARY KEY (request_id, chunk_no)
+);
+
+-- Chunk content is immutable once written; the only permitted update is the
+-- one-way deleted_at stamp. New chunks are permitted only while the request is
+-- fenced and its destructive manifest remains unfrozen. Removal is permitted
+-- only while the destructive manifest has not yet frozen (a retried partial
+-- freeze rewrites its chunks) or once the request has passed logical
+-- verification (terminal cleanup).
+CREATE FUNCTION protect_community_deletion_manifest_keys()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    frozen_at TIMESTAMPTZ;
+    request_stage TEXT;
+BEGIN
+    IF TG_OP = 'UPDATE' THEN
+        IF NEW.request_id IS DISTINCT FROM OLD.request_id
+            OR NEW.chunk_no IS DISTINCT FROM OLD.chunk_no
+            OR NEW.prefix IS DISTINCT FROM OLD.prefix
+            OR NEW.keys IS DISTINCT FROM OLD.keys
+            OR OLD.deleted_at IS NOT NULL
+        THEN
+            RAISE EXCEPTION 'community deletion manifest key chunks are immutable'
+                USING ERRCODE = 'integrity_constraint_violation';
+        END IF;
+        RETURN NEW;
+    END IF;
+    SELECT destructive_storage_frozen_at, stage
+      INTO frozen_at, request_stage
+      FROM community_deletion_requests
+     WHERE id = CASE WHEN TG_OP = 'INSERT' THEN NEW.request_id ELSE OLD.request_id END
+     FOR UPDATE;
+    IF TG_OP = 'INSERT' THEN
+        IF FOUND AND frozen_at IS NULL AND request_stage = 'fenced' THEN
+            RETURN NEW;
+        END IF;
+        RAISE EXCEPTION 'community deletion manifest key chunks require an unfrozen fenced request'
+            USING ERRCODE = 'integrity_constraint_violation';
+    END IF;
+    IF NOT FOUND
+        OR frozen_at IS NULL
+        OR request_stage IN ('logically_verified', 'retention_pending')
+    THEN
+        RETURN OLD;
+    END IF;
+    RAISE EXCEPTION 'community deletion manifest key chunks cannot be removed mid-execution'
+        USING ERRCODE = 'integrity_constraint_violation';
+END;
+$$;
+
+CREATE TRIGGER community_deletion_manifest_keys_guard
+BEFORE INSERT OR UPDATE OR DELETE ON community_deletion_manifest_keys
+FOR EACH ROW
+EXECUTE FUNCTION protect_community_deletion_manifest_keys();
+
+-- Fleet-wide object-store taxonomy sweep evidence. This is an independent
+-- observability record: community deletion inventories only the target's owned
+-- prefixes and does not gate submission or execution on sweep state.
+CREATE TABLE storage_taxonomy_sweeps (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    started_at TIMESTAMPTZ NOT NULL,
+    completed_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    listed_objects BIGINT NOT NULL CHECK (listed_objects >= 0),
+    unknown_object_count BIGINT NOT NULL CHECK (unknown_object_count >= 0),
+    unknown_key_sample JSONB NOT NULL DEFAULT '[]'::jsonb,
+    object_cap BIGINT NOT NULL CHECK (object_cap > 0),
+    CHECK (completed_at >= started_at)
+);
+CREATE INDEX storage_taxonomy_sweeps_latest
+    ON storage_taxonomy_sweeps (completed_at DESC);
+
+CREATE TABLE community_serving_write_leases (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    community_id UUID NOT NULL REFERENCES communities(id),
+    operation TEXT NOT NULL,
+    owner TEXT NOT NULL,
+    generation BIGINT NOT NULL DEFAULT 1 CHECK (generation > 0),
+    -- Community fence generation observed when this lease was acquired.
+    fence_generation BIGINT NOT NULL CHECK (fence_generation >= 0),
+    lease_until TIMESTAMPTZ NOT NULL,
+    heartbeat_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX community_serving_write_leases_active
+    ON community_serving_write_leases (community_id, lease_until);
+
+CREATE TABLE community_deletion_executor_heartbeats (
+    executor_id TEXT PRIMARY KEY,
+    mode TEXT NOT NULL CHECK (mode IN ('run', 'drain', 'worker')),
+    request_id UUID REFERENCES community_deletion_requests(id) ON DELETE SET NULL,
+    started_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    heartbeat_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    draining BOOLEAN NOT NULL DEFAULT false,
+    stopped_at TIMESTAMPTZ
+);
+INSERT INTO _operator_global_tables (table_name, reason) VALUES
+    ('community_deletion_requests', 'deployment deletion lifecycle and frozen inventory'),
+    ('community_deletion_approvals', 'deployment operator destructive approvals'),
+    ('community_deletion_checkpoints', 'deployment deletion executor checkpoints and failures'),
+    ('community_deletion_manifest_keys', 'deployment deletion frozen destructive key chunks'),
+    ('storage_taxonomy_sweeps', 'deployment object-store taxonomy sweep evidence'),
+    ('community_serving_write_leases', 'deployment serving side-effect leases drained by deletion'),
+    ('community_deletion_executor_heartbeats', 'deployment deletion worker liveness');
+
+CREATE FUNCTION community_deletion_lock_key(target UUID) RETURNS BIGINT
+LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$
+    SELECT hashtextextended('buzz-community-deletion:' || target::text, 0)
+$$;
+-- Keep the deletion control plane writable while its target tenant is fenced.
+-- This predicate is the single SQL source of truth used by attachment and live
+-- catalog validation.
+CREATE FUNCTION community_write_fence_excluded_table(target NAME) RETURNS BOOLEAN
+LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$
+    SELECT target::TEXT = ANY (ARRAY[
+        'community_deletion_requests',
+        'community_deletion_approvals',
+        'community_deletion_checkpoints',
+        'community_serving_write_leases',
+        'community_deletion_executor_heartbeats',
+        'product_feedback',
+        'rate_limit_violations'
+    ]::TEXT[])
+$$;
+
+-- Fleet-wide writers filter candidates through this VOLATILE predicate in
+-- the mutating statement so fenced tenants are skipped before row triggers run.
+CREATE FUNCTION community_write_allowed(target UUID) RETURNS BOOLEAN
+LANGUAGE plpgsql VOLATILE AS $$
+DECLARE
+    lifecycle TEXT;
+BEGIN
+    IF current_setting('transaction_isolation') <> 'read committed' THEN
+        RAISE EXCEPTION 'community writes require READ COMMITTED isolation'
+            USING ERRCODE = 'invalid_transaction_state';
+    END IF;
+
+    IF target IS NULL THEN
+        RETURN true;
+    END IF;
+
+    PERFORM pg_advisory_xact_lock_shared(community_deletion_lock_key(target));
+    SELECT deletion_state
+      INTO lifecycle
+      FROM communities
+     WHERE id = target;
+    RETURN FOUND AND lifecycle = 'active';
+END
+$$;
+
+CREATE FUNCTION assert_community_write_allowed(target UUID) RETURNS VOID
+LANGUAGE plpgsql AS $$
+DECLARE
+    lifecycle TEXT;
+    generation BIGINT;
+    executor_community TEXT;
+    executor_generation TEXT;
+    serving_community TEXT;
+    serving_lease_id TEXT;
+    serving_owner TEXT;
+    serving_generation TEXT;
+    serving_fence_generation TEXT;
+    serving_lease_valid BOOLEAN := false;
+BEGIN
+    -- The fence proof requires a fresh statement snapshot after lock grant;
+    -- pinned RR/Serializable snapshots can retain pre-fence authorization.
+    IF current_setting('transaction_isolation') <> 'read committed' THEN
+        RAISE EXCEPTION 'community writes require READ COMMITTED isolation'
+            USING ERRCODE = 'invalid_transaction_state';
+    END IF;
+
+    -- Nullable operator-attribution rows without a tenant are unrelated.
+    IF target IS NULL THEN
+        RETURN;
+    END IF;
+
+    PERFORM pg_advisory_xact_lock_shared(community_deletion_lock_key(target));
+    SELECT deletion_state, deletion_fence_generation
+      INTO lifecycle, generation
+      FROM communities
+     WHERE id = target;
+    IF NOT FOUND THEN
+        RAISE EXCEPTION 'community write rejected: community % is missing', target
+            USING ERRCODE = 'object_not_in_prerequisite_state';
+    END IF;
+
+    -- Authorization is evaluated independently for every community checked.
+    executor_community := current_setting('buzz.deletion_executor_community', true);
+    executor_generation := current_setting('buzz.deletion_fence_generation', true);
+    IF executor_community = target::TEXT
+       AND executor_generation ~ '^[0-9]+$'
+       AND executor_generation::BIGINT = generation THEN
+        RETURN;
+    END IF;
+
+    -- A serving mutation admitted before quiescing may finish only while its
+    -- exact durable lease remains current and bound to this fence generation.
+    serving_community := current_setting('buzz.serving_write_community', true);
+    serving_lease_id := current_setting('buzz.serving_write_lease_id', true);
+    serving_owner := current_setting('buzz.serving_write_owner', true);
+    serving_generation := current_setting('buzz.serving_write_generation', true);
+    serving_fence_generation := current_setting('buzz.serving_write_fence_generation', true);
+    IF lifecycle IN ('active', 'quiescing')
+       AND serving_community = target::TEXT
+       AND serving_lease_id ~ '^[0-9a-fA-F-]{36}$'
+       AND serving_generation ~ '^[0-9]+$'
+       AND serving_fence_generation ~ '^[0-9]+$'
+       AND serving_fence_generation::BIGINT = generation THEN
+        SELECT EXISTS(
+            SELECT 1 FROM community_serving_write_leases lease
+             WHERE lease.id = serving_lease_id::UUID
+               AND lease.community_id = target
+               AND lease.owner = serving_owner
+               AND lease.generation = serving_generation::BIGINT
+               AND lease.fence_generation = serving_fence_generation::BIGINT
+               AND lease.lease_until >= now()
+        ) INTO serving_lease_valid;
+        IF serving_lease_valid THEN
+            RETURN;
+        END IF;
+    END IF;
+
+    IF lifecycle <> 'active' THEN
+        RAISE EXCEPTION 'community write fenced: community % generation %', target, generation
+            USING ERRCODE = 'object_not_in_prerequisite_state';
+    END IF;
+END
+$$;
+
+CREATE FUNCTION enforce_community_write_fence() RETURNS TRIGGER
+LANGUAGE plpgsql AS $$
+BEGIN
+    IF TG_OP = 'INSERT' THEN
+        PERFORM assert_community_write_allowed(NEW.community_id);
+    ELSIF TG_OP = 'DELETE' THEN
+        PERFORM assert_community_write_allowed(OLD.community_id);
+    ELSIF OLD.community_id IS NOT DISTINCT FROM NEW.community_id THEN
+        PERFORM assert_community_write_allowed(OLD.community_id);
+    ELSIF OLD.community_id IS NULL THEN
+        PERFORM assert_community_write_allowed(NEW.community_id);
+    ELSIF NEW.community_id IS NULL THEN
+        PERFORM assert_community_write_allowed(OLD.community_id);
+    ELSIF OLD.community_id < NEW.community_id THEN
+        PERFORM assert_community_write_allowed(OLD.community_id);
+        PERFORM assert_community_write_allowed(NEW.community_id);
+    ELSE
+        PERFORM assert_community_write_allowed(NEW.community_id);
+        PERFORM assert_community_write_allowed(OLD.community_id);
+    END IF;
+
+    RETURN CASE WHEN TG_OP = 'DELETE' THEN OLD ELSE NEW END;
+END
+$$;
+
+CREATE FUNCTION enforce_community_tombstone() RETURNS TRIGGER
+LANGUAGE plpgsql AS $$
+DECLARE
+    executor_community TEXT := current_setting('buzz.deletion_executor_community', true);
+    executor_generation TEXT := current_setting('buzz.deletion_fence_generation', true);
+    expected_generation BIGINT;
+BEGIN
+    IF TG_OP = 'DELETE' THEN
+        IF OLD.deletion_state <> 'active' OR OLD.deleted_at IS NOT NULL THEN
+            RAISE EXCEPTION 'community tombstones are permanent'
+                USING ERRCODE = 'object_not_in_prerequisite_state';
+        END IF;
+        RETURN OLD;
+    END IF;
+    expected_generation := CASE WHEN NEW.deletion_fence_generation > OLD.deletion_fence_generation
+        THEN NEW.deletion_fence_generation ELSE OLD.deletion_fence_generation END;
+    IF executor_community = OLD.id::text AND executor_generation ~ '^[0-9]+$'
+       AND executor_generation::BIGINT = expected_generation THEN RETURN NEW; END IF;
+    IF OLD.deletion_state <> 'active' OR NEW.deletion_state <> OLD.deletion_state
+       OR NEW.deletion_fence_generation <> OLD.deletion_fence_generation
+       OR NEW.deleted_at IS DISTINCT FROM OLD.deleted_at THEN
+        RAISE EXCEPTION 'community tombstone mutation rejected: community % generation %',
+            OLD.id, OLD.deletion_fence_generation
+            USING ERRCODE = 'object_not_in_prerequisite_state';
+    END IF;
+    RETURN NEW;
+END
+$$;
+CREATE TRIGGER communities_deletion_tombstone BEFORE UPDATE OR DELETE ON communities
+FOR EACH ROW EXECUTE FUNCTION enforce_community_tombstone();
+-- Attach the universal fence to one community-scoped relation. Future
+-- migrations must invoke this helper explicitly after CREATE/ALTER introduces
+-- community_id; the migration lint enforces that contract.
+CREATE FUNCTION attach_community_write_fence(target REGCLASS) RETURNS VOID
+LANGUAGE plpgsql AS $$
+DECLARE
+    relation_name NAME;
+BEGIN
+    SELECT c.relname
+      INTO relation_name
+      FROM pg_class c
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+     WHERE c.oid = target
+       AND n.nspname = current_schema()
+       AND c.relkind IN ('r', 'p')
+       AND NOT c.relispartition;
+    IF NOT FOUND THEN
+        RAISE EXCEPTION 'community write fence target % is not a table in the current schema', target
+            USING ERRCODE = 'wrong_object_type';
+    END IF;
+    IF community_write_fence_excluded_table(relation_name) THEN
+        RETURN;
+    END IF;
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_attribute
+         WHERE attrelid = target AND attname = 'community_id' AND NOT attisdropped
+    ) THEN
+        RAISE EXCEPTION 'community write fence target % has no community_id', target
+            USING ERRCODE = 'undefined_column';
+    END IF;
+    IF NOT EXISTS (
+        SELECT 1 FROM pg_trigger
+         WHERE tgrelid = target
+           AND tgname = 'community_write_fence_' || relation_name
+           AND NOT tgisinternal
+    ) THEN
+        EXECUTE format(
+            'CREATE TRIGGER %I BEFORE INSERT OR UPDATE OR DELETE ON %s '
+            'FOR EACH ROW EXECUTE FUNCTION enforce_community_write_fence()',
+            'community_write_fence_' || relation_name,
+            target
+        );
+    END IF;
+END
+$$;
+
+-- Attach the universal fence to every existing table carrying community_id,
+-- including deployment-private sidecars whose community_id is provenance.
+DO $$
+DECLARE
+    target REGCLASS;
+BEGIN
+    FOR target IN
+        SELECT c.oid::REGCLASS
+          FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_attribute a ON a.attrelid = c.oid
+         WHERE n.nspname = current_schema()
+           AND c.relkind IN ('r', 'p')
+           AND NOT c.relispartition
+           AND a.attname = 'community_id'
+           AND NOT a.attisdropped
+           AND NOT community_write_fence_excluded_table(c.relname)
+         ORDER BY c.oid::REGCLASS::TEXT
+    LOOP
+        PERFORM attach_community_write_fence(target);
+    END LOOP;
+END
+$$;
+
+-- Desired-state schema application does not replay migration history, so keep
+-- these explicit calls as first-class catalog declarations. They also make the
+-- fence contract visible to migration linting instead of hiding it only in the
+-- dynamic bootstrap loop above.
+SELECT attach_community_write_fence('api_tokens');
+SELECT attach_community_write_fence('archived_identities');
+SELECT attach_community_write_fence('audit_log');
+SELECT attach_community_write_fence('channel_members');
+SELECT attach_community_write_fence('channels');
+SELECT attach_community_write_fence('community_bans');
+SELECT attach_community_write_fence('delivery_log');
+SELECT attach_community_write_fence('event_mentions');
+SELECT attach_community_write_fence('events');
+SELECT attach_community_write_fence('git_repo_names');
+SELECT attach_community_write_fence('join_policy_acceptances');
+SELECT attach_community_write_fence('moderation_actions');
+SELECT attach_community_write_fence('moderation_reports');
+SELECT attach_community_write_fence('parameterized_event_watermarks');
+SELECT attach_community_write_fence('pubkey_allowlist');
+SELECT attach_community_write_fence('push_leases');
+SELECT attach_community_write_fence('push_match_queue');
+SELECT attach_community_write_fence('push_wake_outbox');
+SELECT attach_community_write_fence('reactions');
+SELECT attach_community_write_fence('relay_invites');
+SELECT attach_community_write_fence('relay_members');
+SELECT attach_community_write_fence('scheduled_workflow_fires');
+SELECT attach_community_write_fence('subscriptions');
+SELECT attach_community_write_fence('thread_metadata');
+SELECT attach_community_write_fence('users');
+SELECT attach_community_write_fence('workflow_approvals');
+SELECT attach_community_write_fence('workflow_runs');
+SELECT attach_community_write_fence('workflows');
diff --git a/scripts/attach-schema-partitions.sql b/scripts/attach-schema-partitions.sql
index d02fc7c82a9..5837676f842 100644
--- a/scripts/attach-schema-partitions.sql
+++ b/scripts/attach-schema-partitions.sql
@@ -21,6 +21,7 @@ BEGIN
         DROP TRIGGER IF EXISTS events_enqueue_push_match ON events_p_past;
         DROP TRIGGER IF EXISTS events_refresh_channel_ttl ON events_p_past;
         DROP TRIGGER IF EXISTS events_created_at_floor ON events_p_past;
+        DROP TRIGGER IF EXISTS community_write_fence_events ON events_p_past;
         ALTER TABLE events ATTACH PARTITION events_p_past
             FOR VALUES FROM (MINVALUE) TO ('2026-01-01');
     END IF;
@@ -33,6 +34,7 @@ BEGIN
         DROP TRIGGER IF EXISTS events_enqueue_push_match ON events_p2026_01;
         DROP TRIGGER IF EXISTS events_refresh_channel_ttl ON events_p2026_01;
         DROP TRIGGER IF EXISTS events_created_at_floor ON events_p2026_01;
+        DROP TRIGGER IF EXISTS community_write_fence_events ON events_p2026_01;
         ALTER TABLE events ATTACH PARTITION events_p2026_01
             FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');
     END IF;
@@ -45,6 +47,7 @@ BEGIN
         DROP TRIGGER IF EXISTS events_enqueue_push_match ON events_p2026_02;
         DROP TRIGGER IF EXISTS events_refresh_channel_ttl ON events_p2026_02;
         DROP TRIGGER IF EXISTS events_created_at_floor ON events_p2026_02;
+        DROP TRIGGER IF EXISTS community_write_fence_events ON events_p2026_02;
         ALTER TABLE events ATTACH PARTITION events_p2026_02
             FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');
     END IF;
@@ -57,6 +60,7 @@ BEGIN
         DROP TRIGGER IF EXISTS events_enqueue_push_match ON events_p2026_03;
         DROP TRIGGER IF EXISTS events_refresh_channel_ttl ON events_p2026_03;
         DROP TRIGGER IF EXISTS events_created_at_floor ON events_p2026_03;
+        DROP TRIGGER IF EXISTS community_write_fence_events ON events_p2026_03;
         ALTER TABLE events ATTACH PARTITION events_p2026_03
             FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');
     END IF;
@@ -69,6 +73,7 @@ BEGIN
         DROP TRIGGER IF EXISTS events_enqueue_push_match ON events_p2026_04;
         DROP TRIGGER IF EXISTS events_refresh_channel_ttl ON events_p2026_04;
         DROP TRIGGER IF EXISTS events_created_at_floor ON events_p2026_04;
+        DROP TRIGGER IF EXISTS community_write_fence_events ON events_p2026_04;
         ALTER TABLE events ATTACH PARTITION events_p2026_04
             FOR VALUES FROM ('2026-04-01') TO ('2026-05-01');
     END IF;
@@ -81,6 +86,7 @@ BEGIN
         DROP TRIGGER IF EXISTS events_enqueue_push_match ON events_p2026_05;
         DROP TRIGGER IF EXISTS events_refresh_channel_ttl ON events_p2026_05;
         DROP TRIGGER IF EXISTS events_created_at_floor ON events_p2026_05;
+        DROP TRIGGER IF EXISTS community_write_fence_events ON events_p2026_05;
         ALTER TABLE events ATTACH PARTITION events_p2026_05
             FOR VALUES FROM ('2026-05-01') TO ('2026-06-01');
     END IF;
@@ -93,6 +99,7 @@ BEGIN
         DROP TRIGGER IF EXISTS events_enqueue_push_match ON events_p2026_06;
         DROP TRIGGER IF EXISTS events_refresh_channel_ttl ON events_p2026_06;
         DROP TRIGGER IF EXISTS events_created_at_floor ON events_p2026_06;
+        DROP TRIGGER IF EXISTS community_write_fence_events ON events_p2026_06;
         ALTER TABLE events ATTACH PARTITION events_p2026_06
             FOR VALUES FROM ('2026-06-01') TO ('2026-07-01');
     END IF;
@@ -105,6 +112,7 @@ BEGIN
         DROP TRIGGER IF EXISTS events_enqueue_push_match ON events_p_future;
         DROP TRIGGER IF EXISTS events_refresh_channel_ttl ON events_p_future;
         DROP TRIGGER IF EXISTS events_created_at_floor ON events_p_future;
+        DROP TRIGGER IF EXISTS community_write_fence_events ON events_p_future;
         ALTER TABLE events ATTACH PARTITION events_p_future
             FOR VALUES FROM ('2026-07-01') TO (MAXVALUE);
     END IF;
@@ -122,6 +130,7 @@ BEGIN
           AND inhrelid = 'delivery_log_p_past'::regclass
     ) THEN
         ALTER TABLE delivery_log_p_past ALTER COLUMN id DROP IDENTITY IF EXISTS;
+        DROP TRIGGER IF EXISTS community_write_fence_delivery_log ON delivery_log_p_past;
         ALTER TABLE delivery_log ATTACH PARTITION delivery_log_p_past
             FOR VALUES FROM (MINVALUE) TO ('2026-03-01');
     END IF;
@@ -132,6 +141,7 @@ BEGIN
           AND inhrelid = 'delivery_log_p2026_03'::regclass
     ) THEN
         ALTER TABLE delivery_log_p2026_03 ALTER COLUMN id DROP IDENTITY IF EXISTS;
+        DROP TRIGGER IF EXISTS community_write_fence_delivery_log ON delivery_log_p2026_03;
         ALTER TABLE delivery_log ATTACH PARTITION delivery_log_p2026_03
             FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');
     END IF;
@@ -142,6 +152,7 @@ BEGIN
           AND inhrelid = 'delivery_log_p2026_04'::regclass
     ) THEN
         ALTER TABLE delivery_log_p2026_04 ALTER COLUMN id DROP IDENTITY IF EXISTS;
+        DROP TRIGGER IF EXISTS community_write_fence_delivery_log ON delivery_log_p2026_04;
         ALTER TABLE delivery_log ATTACH PARTITION delivery_log_p2026_04
             FOR VALUES FROM ('2026-04-01') TO ('2026-05-01');
     END IF;
@@ -152,6 +163,7 @@ BEGIN
           AND inhrelid = 'delivery_log_p2026_05'::regclass
     ) THEN
         ALTER TABLE delivery_log_p2026_05 ALTER COLUMN id DROP IDENTITY IF EXISTS;
+        DROP TRIGGER IF EXISTS community_write_fence_delivery_log ON delivery_log_p2026_05;
         ALTER TABLE delivery_log ATTACH PARTITION delivery_log_p2026_05
             FOR VALUES FROM ('2026-05-01') TO ('2026-06-01');
     END IF;
@@ -162,6 +174,7 @@ BEGIN
           AND inhrelid = 'delivery_log_p2026_06'::regclass
     ) THEN
         ALTER TABLE delivery_log_p2026_06 ALTER COLUMN id DROP IDENTITY IF EXISTS;
+        DROP TRIGGER IF EXISTS community_write_fence_delivery_log ON delivery_log_p2026_06;
         ALTER TABLE delivery_log ATTACH PARTITION delivery_log_p2026_06
             FOR VALUES FROM ('2026-06-01') TO ('2026-07-01');
     END IF;
@@ -172,6 +185,7 @@ BEGIN
           AND inhrelid = 'delivery_log_p_future'::regclass
     ) THEN
         ALTER TABLE delivery_log_p_future ALTER COLUMN id DROP IDENTITY IF EXISTS;
+        DROP TRIGGER IF EXISTS community_write_fence_delivery_log ON delivery_log_p_future;
         ALTER TABLE delivery_log ATTACH PARTITION delivery_log_p_future
             FOR VALUES FROM ('2026-07-01') TO (MAXVALUE);
     END IF;