chore: release version 0.2.0-alpha

Reviewed-on: #25

.github/workflows/release.yml

@@ -159,7 +159,7 @@ jobs:
         id: create_release
         uses: akkuman/gitea-release-action@v1
         with:
-          server_url: "https://git.reya.su/"
+          server_url: "https://git.reya.info/"
           repository: "reya/signed"
           token: ${{ secrets.GITEA_TOKEN }}
           draft: true

.gitignore

@@ -6,7 +6,7 @@ dist/
 
 # Snap and Flatpak local build output
 /snap
-/su.reya.signed.json
+/info.reya.signed.json
 /linux-artifacts
 
 # Vendored dependencies + cargo config generated by script/prepare-flathub

.rules

@@ -1,174 +0,0 @@
-# Rust coding guidelines
-
-* Prioritize code correctness and clarity. Speed and efficiency are secondary priorities unless otherwise specified.
-* Do not write organizational or comments that summarize the code. Comments should only be written in order to explain "why" the code is written in some way in the case there is a reason that is tricky / non-obvious.
-* Prefer implementing functionality in existing files unless it is a new logical component. Avoid creating many small files.
-* Avoid using functions that panic like `unwrap()`, instead use mechanisms like `?` to propagate errors.
-* Be careful with operations like indexing which may panic if the indexes are out of bounds.
-* Never silently discard errors with `let _ =` on fallible operations. Always handle errors appropriately:
-  - Propagate errors with `?` when the calling function should handle them
-  - Use `.log_err()` or similar when you need to ignore errors but want visibility
-  - Use explicit error handling with `match` or `if let Err(...)` when you need custom logic
-  - Example: avoid `let _ = client.request(...).await?;` - use `client.request(...).await?;` instead
-* When implementing async operations that may fail, ensure errors propagate to the UI layer so users get meaningful feedback.
-* Avoid creative additions unless explicitly requested
-* Use full words for variable names (no abbreviations like "q" for "queue")
-* Use variable shadowing to scope clones in async contexts for clarity, minimizing the lifetime of borrowed references.
-  Example:
-  ```rust
-  executor.spawn({
-      let task_ran = task_ran.clone();
-      async move {
-          *task_ran.borrow_mut() = true;
-      }
-  });
-  ```
-
-# Timers in tests
-
-* In GPUI tests, prefer GPUI executor timers over `smol::Timer::after(...)` when you need timeouts, delays, or to drive `run_until_parked()`:
-  - Use `cx.background_executor().timer(duration).await` (or `cx.background_executor.timer(duration).await` in `TestAppContext`) so the work is scheduled on GPUI's dispatcher.
-  - Avoid `smol::Timer::after(...)` for test timeouts when you rely on `run_until_parked()`, because it may not be tracked by GPUI's scheduler and can lead to "nothing left to run" when pumping.
-
-# GPUI
-
-GPUI is a UI framework which also provides primitives for state and concurrency management.
-
-## Context
-
-Context types allow interaction with global state, windows, entities, and system services. They are typically passed to functions as the argument named `cx`. When a function takes callbacks they come after the `cx` parameter.
-
-* `App` is the root context type, providing access to global state and read and update of entities.
-* `Context<T>` is provided when updating an `Entity<T>`. This context dereferences into `App`, so functions which take `&App` can also take `&Context<T>`.
-* `AsyncApp` and `AsyncWindowContext` are provided by `cx.spawn` and `cx.spawn_in`. These can be held across await points.
-
-## `Window`
-
-`Window` provides access to the state of an application window. It is passed to functions as an argument named `window` and comes before `cx` when present. It is used for managing focus, dispatching actions, directly drawing, getting user input state, etc.
-
-## Entities
-
-An `Entity<T>` is a handle to state of type `T`. With `thing: Entity<T>`:
-
-* `thing.entity_id()` returns `EntityId`
-* `thing.downgrade()` returns `WeakEntity<T>`
-* `thing.read(cx: &App)` returns `&T`.
-* `thing.read_with(cx, |thing: &T, cx: &App| ...)` returns the closure's return value.
-* `thing.update(cx, |thing: &mut T, cx: &mut Context<T>| ...)` allows the closure to mutate the state, and provides a `Context<T>` for interacting with the entity. It returns the closure's return value.
-* `thing.update_in(cx, |thing: &mut T, window: &mut Window, cx: &mut Context<T>| ...)` takes a `AsyncWindowContext` or `VisualTestContext`. It's the same as `update` while also providing the `Window`.
-
-Within the closures, the inner `cx` provided to the closure must be used instead of the outer `cx` to avoid issues with multiple borrows.
-
-Trying to update an entity while it's already being updated must be avoided as this will cause a panic.
-
-`WeakEntity<T>` is a weak handle. It has `read_with`, `update`, and `update_in` methods that work the same, but always return an `anyhow::Result` so that they can fail if the entity no longer exists. This can be useful to avoid memory leaks - if entities have mutually recursive handles to each other they will never be dropped.
-
-## Concurrency
-
-All use of entities and UI rendering occurs on a single foreground thread.
-
-`cx.spawn(async move |cx| ...)` runs an async closure on the foreground thread. Within the closure, `cx` is `&mut AsyncApp`.
-
-When the outer cx is a `Context<T>`, the use of `spawn` instead looks like `cx.spawn(async move |this, cx| ...)`, where `this: WeakEntity<T>` and `cx: &mut AsyncApp`.
-
-To do work on other threads, `cx.background_spawn(async move { ... })` is used. Often this background task is awaited on by a foreground task which uses the results to update state.
-
-Both `cx.spawn` and `cx.background_spawn` return a `Task<R>`, which is a future that can be awaited upon. If this task is dropped, then its work is cancelled. To prevent this one of the following must be done:
-
-* Awaiting the task in some other async context.
-* Detaching the task via `task.detach()` or `task.detach_and_log_err(cx)`, allowing it to run indefinitely.
-* Storing the task in a field, if the work should be halted when the struct is dropped.
-
-A task which doesn't do anything but provide a value can be created with `Task::ready(value)`.
-
-## Elements
-
-The `Render` trait is used to render some state into an element tree that is laid out using flexbox layout. An `Entity<T>` where `T` implements `Render` is sometimes called a "view".
-
-Example:
-
-```
-struct TextWithBorder(SharedString);
-
-impl Render for TextWithBorder {
-    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().border_1().child(self.0.clone())
-    }
-}
-```
-
-Since `impl IntoElement for SharedString` exists, it can be used as an argument to `child`. `SharedString` is used to avoid copying strings, and is either an `&'static str` or `Arc<str>`.
-
-UI components that are constructed just to be turned into elements can instead implement the `RenderOnce` trait, which is similar to `Render`, but its `render` method takes ownership of `self` and receives `&mut App` instead of `&mut Context<Self>`. Types that implement this trait can use `#[derive(IntoElement)]` to use them directly as children.
-
-The style methods on elements are similar to those used by Tailwind CSS.
-
-If some attributes or children of an element tree are conditional, `.when(condition, |this| ...)` can be used to run the closure only when `condition` is true. Similarly, `.when_some(option, |this, value| ...)` runs the closure when the `Option` has a value.
-
-## Input events
-
-Input event handlers can be registered on an element via methods like `.on_click(|event, window, cx: &mut App| ...)`.
-
-Often event handlers will want to update the entity that's in the current `Context<T>`. The `cx.listener` method provides this - its use looks like `.on_click(cx.listener(|this: &mut T, event, window, cx: &mut Context<T>| ...)`.
-
-## Actions
-
-Actions are dispatched via user keyboard interaction or in code via `window.dispatch_action(SomeAction.boxed_clone(), cx)` or `focus_handle.dispatch_action(&SomeAction, window, cx)`.
-
-Actions with no data are defined with the `actions!(some_namespace, [SomeAction, AnotherAction])` macro call. Otherwise the `Action` derive macro is used. Doc comments on actions are displayed to the user.
-
-Action handlers can be registered on an element via the event handler `.on_action(|action, window, cx| ...)`. Like other event handlers, this is often used with `cx.listener`.
-
-## Notify
-
-When a view's state has changed in a way that may affect its rendering, it should call `cx.notify()`. This will cause the view to be rerendered. It will also cause any observe callbacks registered for the entity with `cx.observe` to be called.
-
-## Entity events
-
-While updating an entity (`cx: Context<T>`), it can emit an event using `cx.emit(event)`. Entities register which events they can emit by declaring `impl EventEmitter<EventType> for EntityType {}`.
-
-Other entities can then register a callback to handle these events by doing `cx.subscribe(other_entity, |this, other_entity, event, cx| ...)`. This will return a `Subscription` which deregisters the callback when dropped.  Typically `cx.subscribe` happens when creating a new entity and the subscriptions are stored in a `_subscriptions: Vec<Subscription>` field.
-
-# Pull request hygiene
-
-When an agent opens or updates a pull request, it must:
-
-- Use a clear, correctly capitalized, imperative PR title (for example, `Fix crash in project panel`).
-- Avoid conventional commit prefixes in PR titles (`fix:`, `feat:`, `docs:`, etc.).
-- Avoid trailing punctuation in PR titles.
-- Optionally prefix the title with a crate name when one crate is the clear scope (for example, `git_ui: Add history view`).
-- Include a `Release Notes:` section as the final section in the PR body.
-- Use one bullet under `Release Notes:`:
-  - `- Added ...`, `- Fixed ...`, or `- Improved ...` for user-facing changes, or
-  - `- N/A` for docs-only and other non-user-facing changes.
-- Format release notes exactly with a blank line after the heading, for example:
-
-```
-Release Notes:
-
-- N/A
-```
-
-# Rules Hygiene
-
-These `.rules` files are read by every agent session. Keep them high-signal.
-
-## After any agentic session
-If you discover a non-obvious pattern that would help future sessions, include a **"Suggested .rules additions"** heading in your PR description with the proposed text. Do **not** edit `.rules` inline during normal feature/fix work. Reviewers decide what gets merged.
-
-## High bar for new rules
-Editing or clarifying existing rules is always welcome. New rules must meet **all three** criteria:
-1. **Non-obvious** — someone familiar with the codebase would still get it wrong without the rule.
-2. **Repeatedly encountered** — it came up more than once (multiple hits in one session counts).
-3. **Specific enough to act on** — a concrete instruction, not a vague principle.
-
-Rules that apply to a single crate belong in that crate's own `.rules` file, not the repo root.
-
-## What NOT to put in `.rules`
-Avoid architectural descriptions of a crate (module layout, data flow, key types). These go stale fast and the agent can gather them by reading the code. Rules should be **traps to avoid**, not **maps to follow**.
-
-## No drive-by additions
-Rules emerge from validated patterns, not one-off observations. The workflow is:
-1. Agent notes a pattern during a session.
-2. Team validates the pattern in code review.
-3. A dedicated commit adds the rule with context on *why* it exists.

AGENTS.md

@@ -1 +1,152 @@
-.rules
+# Rust coding guidelines
+
+* Prioritize code correctness and clarity. Speed and efficiency are secondary priorities unless otherwise specified.
+* Do not write organizational or comments that summarize the code. Comments should only be written in order to explain "why" the code is written in some way in the case there is a reason that is tricky / non-obvious.
+* Prefer implementing functionality in existing files unless it is a new logical component. Avoid creating many small files.
+* Avoid using functions that panic like `unwrap()`, instead use mechanisms like `?` to propagate errors.
+* Be careful with operations like indexing which may panic if the indexes are out of bounds.
+* Never silently discard errors with `let _ =` on fallible operations. Always handle errors appropriately:
+  - Propagate errors with `?` when the calling function should handle them
+  - Use `.log_err()` or similar when you need to ignore errors but want visibility
+  - Use explicit error handling with `match` or `if let Err(...)` when you need custom logic
+  - Example: avoid `let _ = client.request(...).await?;` - use `client.request(...).await?;` instead
+* When implementing async operations that may fail, ensure errors propagate to the UI layer so users get meaningful feedback.
+* Avoid creative additions unless explicitly requested
+* Use full words for variable names (no abbreviations like "q" for "queue")
+* Use variable shadowing to scope clones in async contexts for clarity, minimizing the lifetime of borrowed references.
+  Example:
+  ```rust
+  executor.spawn({
+      let task_ran = task_ran.clone();
+      async move {
+          *task_ran.borrow_mut() = true;
+      }
+  });
+  ```
+
+# Timers in tests
+
+* In GPUI tests, prefer GPUI executor timers over `smol::Timer::after(...)` when you need timeouts, delays, or to drive `run_until_parked()`:
+  - Use `cx.background_executor().timer(duration).await` (or `cx.background_executor.timer(duration).await` in `TestAppContext`) so the work is scheduled on GPUI's dispatcher.
+  - Avoid `smol::Timer::after(...)` for test timeouts when you rely on `run_until_parked()`, because it may not be tracked by GPUI's scheduler and can lead to "nothing left to run" when pumping.
+
+# GPUI
+
+GPUI is a UI framework which also provides primitives for state and concurrency management.
+
+## Context
+
+Context types allow interaction with global state, windows, entities, and system services. They are typically passed to functions as the argument named `cx`. When a function takes callbacks they come after the `cx` parameter.
+
+* `App` is the root context type, providing access to global state and read and update of entities.
+* `Context<T>` is provided when updating an `Entity<T>`. This context dereferences into `App`, so functions which take `&App` can also take `&Context<T>`.
+* `AsyncApp` and `AsyncWindowContext` are provided by `cx.spawn` and `cx.spawn_in`. These can be held across await points.
+
+## `Window`
+
+`Window` provides access to the state of an application window. It is passed to functions as an argument named `window` and comes before `cx` when present. It is used for managing focus, dispatching actions, directly drawing, getting user input state, etc.
+
+## Entities
+
+An `Entity<T>` is a handle to state of type `T`. With `thing: Entity<T>`:
+
+* `thing.entity_id()` returns `EntityId`
+* `thing.downgrade()` returns `WeakEntity<T>`
+* `thing.read(cx: &App)` returns `&T`.
+* `thing.read_with(cx, |thing: &T, cx: &App| ...)` returns the closure's return value.
+* `thing.update(cx, |thing: &mut T, cx: &mut Context<T>| ...)` allows the closure to mutate the state, and provides a `Context<T>` for interacting with the entity. It returns the closure's return value.
+* `thing.update_in(cx, |thing: &mut T, window: &mut Window, cx: &mut Context<T>| ...)` takes a `AsyncWindowContext` or `VisualTestContext`. It's the same as `update` while also providing the `Window`.
+
+Within the closures, the inner `cx` provided to the closure must be used instead of the outer `cx` to avoid issues with multiple borrows.
+
+Trying to update an entity while it's already being updated must be avoided as this will cause a panic.
+
+`WeakEntity<T>` is a weak handle. It has `read_with`, `update`, and `update_in` methods that work the same, but always return an `anyhow::Result` so that they can fail if the entity no longer exists. This can be useful to avoid memory leaks - if entities have mutually recursive handles to each other they will never be dropped.
+
+## Concurrency
+
+All use of entities and UI rendering occurs on a single foreground thread.
+
+`cx.spawn(async move |cx| ...)` runs an async closure on the foreground thread. Within the closure, `cx` is `&mut AsyncApp`.
+
+When the outer cx is a `Context<T>`, the use of `spawn` instead looks like `cx.spawn(async move |this, cx| ...)`, where `this: WeakEntity<T>` and `cx: &mut AsyncApp`.
+
+To do work on other threads, `cx.background_spawn(async move { ... })` is used. Often this background task is awaited on by a foreground task which uses the results to update state.
+
+Both `cx.spawn` and `cx.background_spawn` return a `Task<R>`, which is a future that can be awaited upon. If this task is dropped, then its work is cancelled. To prevent this one of the following must be done:
+
+* Awaiting the task in some other async context.
+* Detaching the task via `task.detach()` or `task.detach_and_log_err(cx)`, allowing it to run indefinitely.
+* Storing the task in a field, if the work should be halted when the struct is dropped.
+
+A task which doesn't do anything but provide a value can be created with `Task::ready(value)`.
+
+Prefer keeping a task in a field over `.detach()` when the work belongs to a view or store. A detached task outlives the view that started it (for example, a repository panel the user has closed), while a task stored in a field is cancelled when that struct drops. A finished `Task` held in a container is not reaped by GPUI - it stays alive until its handle is dropped - so if the container can accumulate many runs, either drop the finished handles before pushing a new one, or hold a single `Option<Task<_>>` and replace it.
+
+## Elements
+
+The `Render` trait is used to render some state into an element tree that is laid out using flexbox layout. An `Entity<T>` where `T` implements `Render` is sometimes called a "view".
+
+Example:
+
+```
+struct TextWithBorder(SharedString);
+
+impl Render for TextWithBorder {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        div().border_1().child(self.0.clone())
+    }
+}
+```
+
+Since `impl IntoElement for SharedString` exists, it can be used as an argument to `child`. `SharedString` is used to avoid copying strings, and is either an `&'static str` or `Arc<str>`.
+
+UI components that are constructed just to be turned into elements can instead implement the `RenderOnce` trait, which is similar to `Render`, but its `render` method takes ownership of `self` and receives `&mut App` instead of `&mut Context<Self>`. Types that implement this trait can use `#[derive(IntoElement)]` to use them directly as children.
+
+The style methods on elements are similar to those used by Tailwind CSS.
+
+If some attributes or children of an element tree are conditional, `.when(condition, |this| ...)` can be used to run the closure only when `condition` is true. Similarly, `.when_some(option, |this, value| ...)` runs the closure when the `Option` has a value.
+
+## Input events
+
+Input event handlers can be registered on an element via methods like `.on_click(|event, window, cx: &mut App| ...)`.
+
+Often event handlers will want to update the entity that's in the current `Context<T>`. The `cx.listener` method provides this - its use looks like `.on_click(cx.listener(|this: &mut T, event, window, cx: &mut Context<T>| ...)`.
+
+## Actions
+
+Actions are dispatched via user keyboard interaction or in code via `window.dispatch_action(SomeAction.boxed_clone(), cx)` or `focus_handle.dispatch_action(&SomeAction, window, cx)`.
+
+Actions with no data are defined with the `actions!(some_namespace, [SomeAction, AnotherAction])` macro call. Otherwise the `Action` derive macro is used. Doc comments on actions are displayed to the user.
+
+Action handlers can be registered on an element via the event handler `.on_action(|action, window, cx| ...)`. Like other event handlers, this is often used with `cx.listener`.
+
+## Notify
+
+When a view's state has changed in a way that may affect its rendering, it should call `cx.notify()`. This will cause the view to be rerendered. It will also cause any observe callbacks registered for the entity with `cx.observe` to be called.
+
+## Entity events
+
+While updating an entity (`cx: Context<T>`), it can emit an event using `cx.emit(event)`. Entities register which events they can emit by declaring `impl EventEmitter<EventType> for EntityType {}`.
+
+Other entities can then register a callback to handle these events by doing `cx.subscribe(other_entity, |this, other_entity, event, cx| ...)`. This will return a `Subscription` which deregisters the callback when dropped.  Typically `cx.subscribe` happens when creating a new entity and the subscriptions are stored in a `_subscriptions: Vec<Subscription>` field.
+
+# Pull request hygiene
+
+When an agent opens or updates a pull request, it must:
+
+- Use a clear, correctly capitalized, imperative PR title (for example, `fix crash in project panel`).
+- Avoid conventional commit prefixes in PR titles (`fix:`, `feat:`, `docs:`, etc.).
+- Avoid trailing punctuation in PR titles.
+- Optionally prefix the title with a crate name when one crate is the clear scope (for example, `workspace: add history view`).
+- Include a `Release Notes:` section as the final section in the PR body.
+- Use one bullet under `Release Notes:`:
+  - `- Added ...`, `- Fixed ...`, or `- Improved ...` for user-facing changes, or
+  - `- N/A` for docs-only and other non-user-facing changes.
+- Format release notes exactly with a blank line after the heading, for example:
+
+```
+Release Notes:
+
+- N/A
+```

CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+## Unreleased
+
+### Breaking changes
+
+### Added
+
+- Show an avatar in each panel's tab, using the repository owner's profile picture when set and a pixel avatar otherwise
+- Add a Tab Bar setting to hide the previous/next tab buttons, hidden by default
+- Add an Event Fetching Strategy setting, fetching a repository's activity from its announced relays only (Curated) or from every maintainer's relays as well (Uncensored, the default)
+
+### Changed
+
+- Migrate the GPUI foundation to the published `gpui-pre` crates and GPUI Kit 0.6, off the zed and gpui-component git pins
+- Use the pixel avatar as the single fallback for a missing picture, sized and rounded to match the other avatars
+- Redesign the dock tab bar, using muted grey active tab, added close buttons, double-click to zoom, and removed panel toolbar
+- Connect to bootstrap relays on demand instead of at startup
+- Fetch profile metadata in batches of 100 authors, applying every requested profile in a single database query
+- Prefetch the 500 most recent profiles at startup instead of 200
+
+### Fixed
+
+- Render every avatar at one consistent size, where a surrounding border had shrunk pictures by two pixels and the pixel avatar ignored an explicit size
+- Date repositories from their repository state event, so the explore list and open repository views show the latest push instead of the announcement date
+- Fix background tasks outliving their view, so a closed repository panel or pull request view stops fetching and publishing on its own
+
+### Removed
+
+- Remove cover note support, the kind-1624 GitWorkshop and `ngit` extension outside the NIP-34
+
+### Deprecated
+
+## v0.1.0-alpha - 2026/09/14
+
+Initial alpha release.
+
+### Added
+
+- Create and unlock a passphrase-protected Nostr identity
+- Browse and search NIP-34 repositories with All, Popular and Recent filters
+- Scan local Git repositories and detect their NIP-34 and GRASP bindings
+- Create, publish, clone and open repositories
+- Repository view with files, commit history, branches and tags
+- Colour-coded commit diffs
+- Issues and pull requests with discussions
+- Send patches and push branches
+- Inbox for repository activity
+- Settings for appearance, theme, GRASP servers and repository scan paths
+- Release and packaging infrastructure

Cargo.toml

@@ -4,20 +4,18 @@ members = ["crates/*", "desktop"]
 default-members = ["desktop"]
 
 [workspace.package]
-version = "0.1.0-alpha"
+version = "0.2.0-alpha"
 edition = "2024"
 publish = false
 
 [workspace.dependencies]
-# GPUI
-gpui = { git = "https://github.com/zed-industries/zed" }
-gpui_platform = { git = "https://github.com/zed-industries/zed", features = ["font-kit", "x11", "wayland"] }
-gpui_tokio = { git = "https://github.com/zed-industries/zed" }
-reqwest_client = { git = "https://github.com/zed-industries/zed" }
+gpui = { package = "gpui-pre", version = "0.3.6" }
+gpui_platform = { package = "gpui-pre-platform", version = "0.3.6", features = ["font-kit", "x11", "wayland"] }
+reqwest_client = { package = "gpui-pre-reqwest-client", version = "0.3.6" }
 
 # GPUI Kit
-gpui-component = { git = "https://github.com/longbridge/gpui-component", rev = "39c2c86dbee7ad445591462f8675f74082e10828", features = ["tree-sitter-languages"], }
-gpui-base = { git = "https://github.com/longbridge/gpui-component", rev = "39c2c86dbee7ad445591462f8675f74082e10828" }
+gpui-component = { version = "0.6.6", features = ["tree-sitter-languages"] }
+gpui-base = "0.6.6"
 
 dock = { path = "crates/dock" }
 settings = { path = "crates/settings" }

crates/assets/assets/themes/signed.json

@@ -77,9 +77,9 @@
         "success.foreground": "#052E16",
         "switch.background": "#CECECE",
         "switch.thumb.background": "#FFFFFF",
-        "tab.background": "#00000000",
-        "tab.active.background": "#EBFFC1",
-        "tab.active.foreground": "#3F6212",
+        "tab.background": "#E8E8E8",
+        "tab.active.background": "#F5F5F5",
+        "tab.active.foreground": "#18181B",
         "tab.foreground": "#646464",
         "tab_bar.background": "#F0F0F0",
         "tab_bar.segmented.background": "#F0F0F0",
@@ -286,9 +286,9 @@
         "success.foreground": "#052E16",
         "switch.background": "#484848",
         "switch.thumb.background": "#0A0A0A",
-        "tab.background": "#00000000",
-        "tab.active.background": "#19200A",
-        "tab.active.foreground": "#C6FF4D",
+        "tab.background": "#2E2E2E",
+        "tab.active.background": "#2A2A2A",
+        "tab.active.foreground": "#FAFAFA",
         "tab.foreground": "#B4B4B4",
         "tab_bar.background": "#191919",
         "tab_bar.segmented.background": "#191919",

crates/dock/Cargo.toml

@@ -9,6 +9,7 @@ publish.workspace = true
 gpui.workspace = true
 gpui-component.workspace = true
 gpui-base.workspace = true
+settings = { path = "../settings" }
 signed_ui = { path = "../signed_ui" }
 
 [dev-dependencies]

crates/dock/src/dock_area.rs

@@ -11,22 +11,19 @@ use gpui::{
 };
 use gpui_base::dock::{
     DockArea, DockAreaRenderer, DockContext, DockEvent, DockPlacement, NodeId, PanelState,
-    PanelView, TabGroupRenderer, TilesRenderer,
+    PanelView, TabGroupRenderer,
 };
 use gpui_base::resize_handle;
-use gpui_component::scroll::ScrollbarMode;
 use gpui_component::{ActiveTheme as _, Side};
 
 use crate::invalid_panel::InvalidPanel;
+use crate::panel_handle;
 use crate::tab_panel::SignedTabGroupSkin;
-use crate::tiles::SignedTilesSkin;
-use crate::{TAB_BAR_HEIGHT, panel_handle};
 
 /// State the skin shares with its per-container renderers.
 pub(crate) struct SkinShared {
     area: WeakEntity<DockArea>,
     toggle_button_visible: Cell<bool>,
-    tiles_scrollbar_mode: Cell<Option<ScrollbarMode>>,
     /// The dock whose resize handle is being dragged, if any. Only one can be.
     resizing_dock: Cell<Option<DockPlacement>>,
 }
@@ -40,10 +37,6 @@ impl SkinShared {
         self.toggle_button_visible.get()
     }
 
-    pub(crate) fn tiles_scrollbar_mode(&self) -> Option<ScrollbarMode> {
-        self.tiles_scrollbar_mode.get()
-    }
-
     pub(crate) fn resizing_dock(&self) -> &Cell<Option<DockPlacement>> {
         &self.resizing_dock
     }
@@ -73,7 +66,6 @@ impl SignedDockSkin {
             shared: Rc::new(SkinShared {
                 area: cx.weak_entity(),
                 toggle_button_visible: Cell::new(true),
-                tiles_scrollbar_mode: Cell::new(None),
                 resizing_dock: Cell::new(None),
             }),
         })
@@ -92,16 +84,6 @@ impl SignedDockSkin {
         self.shared.toggle_button_visible.set(visible);
         self.shared.notify(cx);
     }
-
-    /// When a tiles canvas shows its scrollbar. `None` follows the theme.
-    pub fn tiles_scrollbar_mode(&self) -> Option<ScrollbarMode> {
-        self.shared.tiles_scrollbar_mode()
-    }
-
-    pub fn set_tiles_scrollbar_mode(&self, mode: Option<ScrollbarMode>, cx: &mut App) {
-        self.shared.tiles_scrollbar_mode.set(mode);
-        self.shared.notify(cx);
-    }
 }
 
 /// Payload a dock's resize handle drags.
@@ -154,16 +136,10 @@ impl DockAreaRenderer for SignedDockSkin {
         window: &mut Window,
         cx: &mut App,
     ) -> AnyElement {
-        let placement = dock.placement();
-
         div()
             .flex()
             .size_full()
             .relative()
-            // A closed bottom dock keeps a strip, and that strip is the tab bar.
-            .when(!dock.is_open() && placement.is_bottom(), |this| {
-                this.h(TAB_BAR_HEIGHT)
-            })
             .child(content)
             .child(self.render_resize_handle(dock, window, cx))
             .child(DockResizeTracker {
@@ -190,10 +166,6 @@ impl DockAreaRenderer for SignedDockSkin {
     fn tab_group_renderer(&self) -> Rc<dyn TabGroupRenderer> {
         Rc::new(SignedTabGroupSkin::new(self.shared().clone()))
     }
-
-    fn tiles_renderer(&self) -> Rc<dyn TilesRenderer> {
-        Rc::new(SignedTilesSkin::new(self.shared().clone()))
-    }
 }
 
 impl SignedDockSkin {

crates/dock/src/lib.rs

@@ -6,7 +6,6 @@ use gpui_base::dock::PanelView;
 mod dock_area;
 mod invalid_panel;
 mod tab_panel;
-mod tiles;
 mod window_controls;
 
 pub use dock_area::SignedDockSkin;

crates/dock/src/tab_panel.rs

@@ -5,9 +5,9 @@ use std::time::Duration;
 
 use gpui::prelude::FluentBuilder as _;
 use gpui::{
-    Anchor, Animation, AnimationExt as _, AnyElement, AnyView, App, AppContext as _, Bounds,
-    Context, Div, Empty, InteractiveElement as _, IntoElement, ParentElement as _, Pixels, Point,
-    Render, ScrollHandle, SharedString, Stateful, StatefulInteractiveElement as _, StyleRefinement,
+    Animation, AnimationExt as _, AnyElement, AnyView, App, AppContext as _, Bounds, Context, Div,
+    Empty, InteractiveElement as _, IntoElement, ParentElement as _, Pixels, Point, Render,
+    ScrollHandle, SharedString, Stateful, StatefulInteractiveElement as _, StyleRefinement,
     Styled as _, Window, div, px, size,
 };
 use gpui_base::dock::{
@@ -18,17 +18,24 @@ use gpui_base::{ElementExt, InteractiveElementExt, Tab, Tabs};
 use gpui_component::animation::{Lerp as _, ease_out_cubic};
 use gpui_component::button::{Button, ButtonVariants as _};
 use gpui_component::dock::{ClosePanel, PanelControl, PanelHandle, ToggleZoom};
-use gpui_component::menu::DropdownMenu as _;
-use gpui_component::{
-    ActiveTheme as _, Disableable as _, IconName, Selectable as _, Sizable as _, h_flex, v_flex,
-};
+use gpui_component::{ActiveTheme as _, Disableable as _, IconName, Sizable as _, h_flex, v_flex};
+use settings::{SettingsStore, TabBarSettings};
 use signed_ui::title_bar_drag_handlers;
 
 use crate::dock_area::SkinShared;
 use crate::{TAB_BAR_HEIGHT, t, window_controls};
 
-/// The drag preview's size, reported to base for the drop placeholder.
 const DRAG_PREVIEW_SIZE: gpui::Size<gpui::Pixels> = size(px(96.), px(30.));
+const COLLAPSED_TAB_BAR_SELECTOR: &str = "signed-dock-collapsed-tab-bar";
+const ACTIVE_TAB_SELECTOR: &str = "signed-dock-active-tab";
+const ACTIVE_TAB_CLOSE_SELECTOR: &str = "signed-dock-active-tab-close";
+const TAB_HOVER_GROUP: &str = "signed-dock-tab";
+const NAVIGATION_BUTTONS_TAB_THRESHOLD: usize = 10;
+
+/// Whether a group's prev/next buttons should be drawn.
+fn navigation_buttons_visible(hide_navigation_buttons: bool, panels_len: usize) -> bool {
+    !hide_navigation_buttons && panels_len > NAVIGATION_BUTTONS_TAB_THRESHOLD
+}
 
 /// A panel's title, or its registered name when the panel has no handle.
 pub(crate) fn panel_title(
@@ -43,24 +50,20 @@ pub(crate) fn panel_title(
 }
 
 /// The preview that follows the cursor while a panel is dragged.
-/// Base's `DragPanel` is the payload and draws nothing, this is the appearance half.
 struct DragPanelPreview {
     panel: Arc<dyn BasePanelView>,
 }
 
 impl Render for DragPanelPreview {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        div()
+        h_flex()
             .id("drag-panel")
             .cursor_grab()
-            .py_1()
-            .px_3()
-            .w_24()
-            .overflow_hidden()
+            .p_1()
             .whitespace_nowrap()
             .border_1()
             .border_color(cx.theme().border)
-            .rounded(cx.theme().radius)
+            .rounded(cx.theme().radius_lg)
             .text_color(cx.theme().tab_foreground)
             .bg(cx.theme().tokens.tab_active)
             .opacity(0.75)
@@ -69,9 +72,14 @@ impl Render for DragPanelPreview {
 }
 
 /// The zoom affordance for the group's displayed panel, if it offers one.
-/// The panel must offer a control and be zoomable, base refuses a zoom otherwise.
 fn zoom_control(group: &TabGroupContext, cx: &App) -> Option<PanelControl> {
-    let panel = group.active_panel()?;
+    panel_zoom_control(group.active_panel()?, cx)
+}
+
+/// The zoom affordance `panel` offers, if any.
+///
+/// The panel must offer a control and be zoomable, base refuses a zoom otherwise.
+fn panel_zoom_control(panel: &Arc<dyn BasePanelView>, cx: &App) -> Option<PanelControl> {
     panel
         .zoomable(cx)
         .then(|| PanelHandle::of(panel).and_then(|handle| handle.zoom_control(cx)))
@@ -79,16 +87,17 @@ fn zoom_control(group: &TabGroupContext, cx: &App) -> Option<PanelControl> {
 }
 
 /// The left-most, top-most tab group in a container.
+///
 /// A left dock's collapse button lives in this group.
 fn left_top_group(node: &PaneNode) -> Option<NodeId> {
     match node.kind() {
         PaneRef::Tabs { .. } => Some(node.id()),
         PaneRef::Split { children, .. } => children.first().and_then(left_top_group),
-        PaneRef::Tiles { .. } => None,
     }
 }
 
 /// The right-most, top-most tab group.
+///
 /// A vertical split picks its first child, a horizontal split picks its last.
 fn right_top_group(node: &PaneNode) -> Option<NodeId> {
     match node.kind() {
@@ -98,7 +107,53 @@ fn right_top_group(node: &PaneNode) -> Option<NodeId> {
             gpui::Axis::Horizontal => children.last(),
         }
         .and_then(right_top_group),
-        PaneRef::Tiles { .. } => None,
+    }
+}
+
+/// The bottom or right dock whose root tab group is this one, if any.
+///
+/// Base keeps a dock's last group, so the skin removes these docks as a whole.
+fn dock_root_group(
+    shared: &SkinShared,
+    group: &TabGroupContext,
+    cx: &App,
+) -> Option<DockPlacement> {
+    let area = shared.area().upgrade()?;
+    let area = area.read(cx);
+
+    [DockPlacement::Bottom, DockPlacement::Right]
+        .into_iter()
+        .find(|placement| {
+            area.layout(*placement)
+                .is_some_and(|tree| tree.root().id() == group.node())
+        })
+}
+
+/// Close `panel`, removing its dock instead when base would refuse an empty one.
+///
+/// A bottom or right dock's only panel is that case, so the whole dock goes.
+fn close_panel(
+    shared: &SkinShared,
+    group: &TabGroupContext,
+    panel: &Arc<dyn BasePanelView>,
+    window: &mut Window,
+    cx: &mut App,
+) {
+    if !panel.closable(cx) {
+        return;
+    }
+
+    let dock = (group.panels().len() <= 1)
+        .then(|| dock_root_group(shared, group, cx))
+        .flatten();
+
+    match dock {
+        Some(placement) => {
+            _ = shared.area().update(cx, |area, cx| {
+                area.remove_dock(placement, window, cx);
+            });
+        }
+        None => group.close(panel.panel_id(cx), window, cx),
     }
 }
 
@@ -144,26 +199,14 @@ impl SignedTabGroupSkin {
         left == group.node() && group.panels().len() == 1
     }
 
-    /// The bottom or right dock whose root tab group is this one, if any.
-    /// Base keeps a dock's last group, so the skin removes these docks as a whole.
-    fn is_dock_root_group(&self, group: &TabGroupContext, cx: &App) -> Option<DockPlacement> {
-        let area = self.shared.area().upgrade()?;
-        let area = area.read(cx);
-        [DockPlacement::Bottom, DockPlacement::Right]
-            .into_iter()
-            .find(|placement| {
-                area.layout(*placement)
-                    .is_some_and(|tree| tree.root().id() == group.node())
-            })
-    }
-
     /// The tab's drag payload, or `None` when the group must not be rearranged.
+    ///
     /// A locked group never is, a bottom or right dock root always is.
     fn tab_drag(&self, group: &TabGroupContext, ix: usize, cx: &App) -> Option<DragPanel> {
         if group.is_locked() {
             return None;
         }
-        if !group.is_draggable() && self.is_dock_root_group(group, cx).is_none() {
+        if !group.is_draggable() && dock_root_group(&self.shared, group, cx).is_none() {
             return None;
         }
         group.drag_panel(ix, cx)
@@ -233,15 +276,22 @@ impl SignedTabGroupSkin {
     }
 
     /// The previous and next tab buttons in the tab bar's leading prefix.
-    /// Always rendered, disabled at the strip ends or when collapsed.
-    fn render_prev_next_tab_buttons(
-        &self,
-        group: &TabGroupContext,
-        _cx: &mut App,
-    ) -> impl IntoElement {
+    ///
+    /// Hidden by default, and only offered for crowded strips where the active
+    /// tab may have scrolled out of view. Disabled at the strip ends or collapsed.
+    fn render_prev_next_tab_buttons(&self, group: &TabGroupContext, cx: &mut App) -> AnyElement {
         let collapsed = group.is_collapsed();
         let active_ix = group.active_ix();
         let panels_len = group.panels().len();
+
+        let hidden = SettingsStore::try_global(cx)
+            .map(|store| store.read(cx).settings().tab_bar.hide_navigation_buttons)
+            .unwrap_or_else(|| TabBarSettings::default().hide_navigation_buttons);
+
+        if !navigation_buttons_visible(hidden, panels_len) {
+            return Empty.into_any_element();
+        }
+
         let prev_enabled = !collapsed && active_ix > 0;
         let next_enabled = !collapsed && active_ix + 1 < panels_len;
 
@@ -273,100 +323,10 @@ impl SignedTabGroupSkin {
                         move |_, window, cx| group.select_tab(active_ix + 1, window, cx)
                     }),
             )
-    }
-
-    /// The trailing controls, the panel's own buttons, zoom and the ellipsis menu.
-    fn render_toolbar(
-        &self,
-        group: &TabGroupContext,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> impl IntoElement {
-        if group.is_collapsed() {
-            return div();
-        }
-
-        let zoomed = group.is_zoomed();
-        let handle = group.active_panel().and_then(PanelHandle::of);
-        let control = zoom_control(group, cx);
-        let toolbar_zoom = control.is_some_and(|control| control.toolbar_visible());
-        let menu_zoom = control.is_some_and(|control| control.menu_visible());
-        // A bottom or right dock's only panel cannot close through the group.
-        // The close item is offered, the skin removes the whole dock instead.
-        let closable = group.is_closable()
-            || (self.is_dock_root_group(group, cx).is_some()
-                && group.active_panel().is_some_and(|panel| panel.closable(cx)));
-        let buttons = handle.and_then(|handle| handle.toolbar_buttons(window, cx));
-        let panel = handle.map(|handle| handle.panel());
-
-        h_flex()
-            .gap_1()
-            .occlude()
-            .when_some(buttons, |this, buttons| {
-                this.children(
-                    buttons
-                        .into_iter()
-                        .map(|button| button.small().ghost().tab_stop(false)),
-                )
-            })
-            .map(|this| {
-                let value = if zoomed {
-                    Some(("zoom-out", IconName::Minimize, t("Dock.Zoom Out")))
-                } else if toolbar_zoom {
-                    Some(("zoom-in", IconName::Maximize, t("Dock.Zoom In")))
-                } else {
-                    None
-                };
-
-                if let Some((id, icon, tooltip)) = value {
-                    this.child(
-                        Button::new(id)
-                            .icon(icon)
-                            .small()
-                            .ghost()
-                            .tab_stop(false)
-                            .tooltip_with_action(tooltip, &ToggleZoom, None)
-                            .selected(zoomed)
-                            .on_click({
-                                let group = group.clone();
-                                move |_, window, cx| group.toggle_zoom(window, cx)
-                            }),
-                    )
-                } else {
-                    this
-                }
-            })
-            .child(
-                Button::new("menu")
-                    .icon(IconName::Ellipsis)
-                    .small()
-                    .ghost()
-                    .tab_stop(false)
-                    .dropdown_menu(move |menu, window, cx| {
-                        menu.when_some(panel.clone(), |menu, panel| {
-                            panel.dropdown_menu(menu, window, cx)
-                        })
-                        .separator()
-                        .menu_with_disabled(
-                            if zoomed {
-                                t("Dock.Zoom Out")
-                            } else {
-                                t("Dock.Zoom In")
-                            },
-                            Box::new(ToggleZoom),
-                            !menu_zoom,
-                        )
-                        .when(closable, |menu| {
-                            menu.separator().menu(t("Dock.Close"), Box::new(ClosePanel))
-                        })
-                    })
-                    .anchor(Anchor::TopRight),
-            )
+            .into_any_element()
     }
 
     /// One tab of the pill strip.
-    /// While collapsed, tabs lose the active style and all interactions.
-    /// The strip is also how a closed bottom dock is opened again.
     #[allow(clippy::too_many_arguments)]
     fn render_tab(
         &self,
@@ -382,25 +342,73 @@ impl SignedTabGroupSkin {
         let droppable = group.is_droppable();
         let drag = self.tab_drag(group, ix, cx);
         let handle = PanelHandle::of(&panel);
+        let id = SharedString::from(format!("close-tab:{}:{ix}", group.node().as_u64()));
+
+        let closable = !collapsed
+            && (group.is_closable()
+                || (dock_root_group(&self.shared, group, cx).is_some() && panel.closable(cx)));
+
+        // Whether a double-click zooms this tab in.
+        let can_zoom_in = panel_zoom_control(&panel, cx).is_some();
 
         Tab::new(ix)
-            .h_6()
-            .px_3()
-            .text_sm()
-            .whitespace_nowrap()
+            .group(TAB_HOVER_GROUP)
+            .when(active, |this| {
+                this.debug_selector(|| ACTIVE_TAB_SELECTOR.to_string())
+            })
             .flex()
             .items_center()
-            .justify_center()
-            .gap_1()
             .flex_shrink_0()
+            .h_7()
+            .min_w_40()
+            .gap_1()
+            .px_1p5()
+            .text_sm()
             .overflow_hidden()
             .rounded(cx.theme().radius)
-            .text_color(cx.theme().foreground)
-            .map(|this| match handle.and_then(|handle| handle.tab_name(cx)) {
-                Some(tab_name) => this.child(tab_name),
-                None => this.child(panel_title(&panel, window, cx)),
+            .text_color(cx.theme().tab_foreground)
+            .child(
+                h_flex()
+                    .flex_1()
+                    .h_6()
+                    .items_center()
+                    .overflow_hidden()
+                    .whitespace_nowrap()
+                    .map(|this| match handle.and_then(|handle| handle.tab_name(cx)) {
+                        Some(tab_name) => this.child(tab_name),
+                        None => this.child(panel_title(&panel, window, cx)),
+                    }),
+            )
+            .when(closable, |this| {
+                this.child(
+                    div()
+                        .flex_shrink_0()
+                        .when(active, |this| {
+                            this.debug_selector(|| ACTIVE_TAB_CLOSE_SELECTOR.to_string())
+                        })
+                        .when(!active, |this| {
+                            this.invisible()
+                                .group_hover(TAB_HOVER_GROUP, |this| this.visible())
+                        })
+                        .child(
+                            Button::new(id)
+                                .icon(IconName::Close)
+                                .tooltip(t("Dock.Close"))
+                                .ghost()
+                                .xsmall()
+                                .tab_stop(false)
+                                .on_click({
+                                    let group = group.clone();
+                                    let shared = self.shared.clone();
+                                    let panel = panel.clone();
+                                    move |_, window, cx| {
+                                        cx.stop_propagation();
+                                        close_panel(&shared, &group, &panel, window, cx);
+                                    }
+                                }),
+                        ),
+                )
             })
-            // Pill style, the selected tab is the filled pill, others show only on hover.
             .styles(|styles| {
                 styles.selected(|style| {
                     style
@@ -412,15 +420,15 @@ impl SignedTabGroupSkin {
                 if active {
                     this
                 } else {
-                    this.text_color(cx.theme().secondary_foreground)
-                        .bg(cx.theme().secondary_hover)
+                    this.text_color(cx.theme().tab_foreground)
+                        .bg(cx.theme().tab)
                 }
             })
             .selected(active)
             .on_click({
                 let group = group.clone();
                 let area = self.shared.area().clone();
-                move |_, window, cx| {
+                move |event, window, cx| {
                     group.select_tab(ix, window, cx);
 
                     // Clicking the strip of a collapsed bottom dock reopens it.
@@ -428,7 +436,15 @@ impl SignedTabGroupSkin {
                         _ = area.update(cx, |area, cx| {
                             area.toggle_dock(DockPlacement::Bottom, window, cx);
                         });
+                        return;
                     }
+
+                    // A double-click zooms the tab's panel
+                    if event.click_count() < 2 || (!group.is_zoomed() && !can_zoom_in) {
+                        return;
+                    }
+
+                    group.toggle_zoom(window, cx);
                 }
             })
             .when(!collapsed, |this| {
@@ -531,10 +547,6 @@ impl TabGroupRenderer for SignedTabGroupSkin {
         if group.panels().is_empty() {
             return div().id("tab-panel");
         }
-        // Base refuses an empty dock, so closing its only panel removes the dock.
-        let dock_to_remove = (group.panels().len() <= 1)
-            .then(|| self.is_dock_root_group(group, cx))
-            .flatten();
         let shared = self.shared.clone();
 
         // `v_flex`, a plain `div` ignores `flex_grow` and the content would collapse.
@@ -543,14 +555,10 @@ impl TabGroupRenderer for SignedTabGroupSkin {
             .size_full()
             .overflow_hidden()
             .bg(cx.theme().tokens.background)
-            // A collapsed group has no content, so these actions are not registered.
             .when(!group.is_collapsed(), |this| {
                 this.on_action({
                     let group = group.clone();
                     move |_: &ToggleZoom, window, cx| {
-                        // A panel with no zoom control is not zoomed in by the keybinding.
-                        // Zooming out is never refused.
-                        // Otherwise a zoomed panel that lost its control would strand the user.
                         if !group.is_zoomed() && control.is_none() {
                             return;
                         }
@@ -564,18 +572,7 @@ impl TabGroupRenderer for SignedTabGroupSkin {
                         let Some(panel) = group.active_panel() else {
                             return;
                         };
-                        if !panel.closable(cx) {
-                            return;
-                        }
-                        let panel = panel.panel_id(cx);
-                        match dock_to_remove {
-                            Some(placement) => {
-                                _ = shared.area().update(cx, |area, cx| {
-                                    area.remove_dock(placement, window, cx);
-                                });
-                            }
-                            None => group.close(panel, window, cx),
-                        }
+                        close_panel(&shared, &group, panel, window, cx);
                     }
                 })
             })
@@ -613,17 +610,23 @@ impl TabGroupRenderer for SignedTabGroupSkin {
         let right_dock_button = self.dock_toggle_button(DockPlacement::Right, group, cx);
         let is_bottom_dock = bottom_dock_button.is_some();
 
-        // On macOS the traffic lights overlay the window's top-left corner.
-        // Only the tab bar that sits under them reserves the space.
-        // That is the center's top-left group when the left dock is closed or absent.
+        // On macOS the traffic lights overlay the window's top-left corner, so the
+        // tab bar under them reserves the space. That is the center's top-left group
+        // when the left dock is closed or absent, and the zoomed group otherwise:
+        // a zoom fills the whole area, hiding the docks the frame would draw.
         let needs_traffic_light_padding = cfg!(target_os = "macos")
             && self.shared.area().upgrade().is_some_and(|area| {
                 let area = area.read(cx);
-                !area.is_dock_open(DockPlacement::Left)
-                    && area
-                        .layout(DockPlacement::Center)
-                        .and_then(|tree| left_top_group(tree.root()))
-                        == Some(group.node())
+                match area.zoomed_group() {
+                    Some(zoomed) => zoomed == group.node(),
+                    None => {
+                        !area.is_dock_open(DockPlacement::Left)
+                            && area
+                                .layout(DockPlacement::Center)
+                                .and_then(|tree| left_top_group(tree.root()))
+                                == Some(group.node())
+                    }
+                }
             });
 
         // Bring a newly displayed tab into view.
@@ -709,7 +712,16 @@ impl TabGroupRenderer for SignedTabGroupSkin {
                     .child(
                         Tabs::new("tab-bar")
                             .px(px(-1.))
-                            .h(TAB_BAR_HEIGHT)
+                            // A collapsed group stands in for a closed bottom dock,
+                            // which base gives only its reserved strip. The bar keeps
+                            // its own height there rather than the title-bar height,
+                            // so it fits instead of being clipped away.
+                            .when(!collapsed, |this| this.h(TAB_BAR_HEIGHT))
+                            // Only a collapsed (bottom) dock tags its bar, so the
+                            // selector is unique when a test measures it.
+                            .when(collapsed, |this| {
+                                this.debug_selector(|| COLLAPSED_TAB_BAR_SELECTOR.to_string())
+                            })
                             .flex()
                             .items_center()
                             .text_color(cx.theme().tab_foreground)
@@ -763,7 +775,6 @@ impl TabGroupRenderer for SignedTabGroupSkin {
                                                 .and_then(PanelHandle::of)
                                                 .and_then(|handle| handle.title_suffix(window, cx)),
                                         )
-                                        .child(self.render_toolbar(group, window, cx))
                                         .children(right_dock_button),
                                 )
                             }),
@@ -833,3 +844,123 @@ impl TabGroupRenderer for SignedTabGroupSkin {
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use gpui::{
+        App, AppContext as _, Context, Empty, EventEmitter, FocusHandle, Focusable, IntoElement,
+        Render, TestAppContext, Window, px,
+    };
+    use gpui_base::dock::{DockArea, DockLayout, DockPlacement, PanelEvent};
+
+    use super::{COLLAPSED_TAB_BAR_SELECTOR, navigation_buttons_visible};
+    use crate::{BasePanel, Panel, SignedDockSkin, panel_handle};
+
+    struct Probe {
+        focus_handle: FocusHandle,
+    }
+
+    impl Probe {
+        fn new(cx: &mut Context<Self>) -> Self {
+            Self {
+                focus_handle: cx.focus_handle(),
+            }
+        }
+    }
+
+    impl BasePanel for Probe {
+        fn panel_name(&self) -> &'static str {
+            "Probe"
+        }
+    }
+
+    impl Panel for Probe {
+        fn title(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+            "Probe"
+        }
+    }
+
+    impl EventEmitter<PanelEvent> for Probe {}
+
+    impl Focusable for Probe {
+        fn focus_handle(&self, _: &App) -> FocusHandle {
+            self.focus_handle.clone()
+        }
+    }
+
+    impl Render for Probe {
+        fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
+            Empty
+        }
+    }
+
+    /// Base reserves only `gpui_base::dock::CLOSED_BOTTOM_STRIP` for a closed
+    /// bottom dock, so the tab bar drawn in place of one has to shrink to that
+    /// height; at the full title-bar height its bottom was clipped away.
+    #[gpui::test]
+    fn a_collapsed_bottom_dock_bar_fits_the_reserved_strip(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            gpui_component::init(cx);
+        });
+        let (area, cx) = cx.add_window_view(|window, cx| {
+            let skin = SignedDockSkin::new(cx);
+            DockArea::new("test", None, window, cx).with_renderer(skin)
+        });
+
+        cx.update(|window, cx| {
+            let center = cx.new(Probe::new);
+            let bottom = cx.new(Probe::new);
+            area.update(cx, |area, cx| {
+                area.set_center(
+                    DockLayout::tabs().panel_view(panel_handle(center), cx),
+                    window,
+                    cx,
+                );
+                area.set_dock(
+                    DockPlacement::Bottom,
+                    DockLayout::tabs().panel_view(panel_handle(bottom), cx),
+                    window,
+                    cx,
+                );
+            });
+        });
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear(cx));
+
+        // Open, nothing is collapsed, so no bar carries the selector.
+        assert!(cx.debug_bounds(COLLAPSED_TAB_BAR_SELECTOR).is_none());
+
+        cx.update(|window, cx| {
+            area.update(cx, |area, cx| {
+                area.toggle_dock(DockPlacement::Bottom, window, cx);
+            });
+        });
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear(cx));
+
+        let bounds = cx
+            .debug_bounds(COLLAPSED_TAB_BAR_SELECTOR)
+            .expect("a collapsed bottom dock draws its stand-in tab bar");
+        // `gpui_base::dock::CLOSED_BOTTOM_STRIP`, which the engine does not
+        // re-export. The bar used to be `TAB_BAR_HEIGHT` here and its bottom was
+        // clipped away; it now has to fit inside what base reserves.
+        let reserved_strip = px(29.);
+        assert!(
+            bounds.size.height <= reserved_strip,
+            "the collapsed bar is {}px tall, more than the {}px strip base reserves",
+            bounds.size.height,
+            reserved_strip,
+        );
+    }
+
+    #[test]
+    fn navigation_buttons_follow_the_setting_and_tab_count() {
+        // Hidden by default, no matter how many tabs there are.
+        assert!(!navigation_buttons_visible(true, 1));
+        assert!(!navigation_buttons_visible(true, 20));
+
+        // When not hidden they still only appear for a crowded strip.
+        assert!(!navigation_buttons_visible(false, 10));
+        assert!(navigation_buttons_visible(false, 11));
+    }
+}

crates/dock/src/tiles.rs

@@ -1,388 +0,0 @@
-use std::rc::Rc;
-
-use gpui::prelude::FluentBuilder as _;
-use gpui::{
-    AnyElement, App, AppContext as _, Context, Div, DragMoveEvent, Empty, InteractiveElement as _,
-    IntoElement, MouseButton, MouseDownEvent, ParentElement as _, Pixels, Render, ScrollHandle,
-    Size, Stateful, StatefulInteractiveElement as _, Styled as _, Window, div, px,
-};
-use gpui_base::dock::{
-    DRAG_BAR_HEIGHT, HANDLE_SIZE, NodeId, ResizeSide, TileContext, TilesRenderer,
-};
-use gpui_component::button::{Button, ButtonVariants as _};
-use gpui_component::dock::PanelHandle;
-use gpui_component::menu::{DropdownMenu as _, PopupMenuItem};
-use gpui_component::scroll::Scrollbar;
-use gpui_component::{
-    ActiveTheme as _, Icon, IconName, Selectable as _, Sizable as _, h_flex, v_flex,
-};
-
-use crate::dock_area::SkinShared;
-use crate::t;
-use crate::tab_panel::panel_title;
-
-/// How far a resize handle sticks out past the tile's edge.
-const HANDLE_OFFSET: Pixels = px(-4.);
-
-/// The payload a tile drag carries, so one canvas ignores another's drags.
-#[derive(Clone)]
-struct DragMoving(NodeId);
-
-impl Render for DragMoving {
-    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
-        Empty
-    }
-}
-
-/// The payload a tile resize carries, for the same reason.
-#[derive(Clone)]
-struct DragResizing(NodeId);
-
-impl Render for DragResizing {
-    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
-        Empty
-    }
-}
-
-/// One tiles canvas's appearance.
-/// Built once per container, so its scroll position belongs to the canvas it scrolls.
-pub(crate) struct SignedTilesSkin {
-    shared: Rc<SkinShared>,
-    scroll_handle: ScrollHandle,
-}
-
-impl SignedTilesSkin {
-    pub(crate) fn new(shared: Rc<SkinShared>) -> Self {
-        Self {
-            shared,
-            scroll_handle: ScrollHandle::default(),
-        }
-    }
-
-    fn resize_handle(
-        &self,
-        tile: &TileContext,
-        id: &'static str,
-        side: ResizeSide,
-        build: impl FnOnce(Stateful<Div>) -> Stateful<Div>,
-    ) -> Stateful<Div> {
-        let node = tile.node();
-
-        build(div().id(id).absolute())
-            .on_mouse_down(MouseButton::Left, {
-                let tile = tile.clone();
-                move |event: &MouseDownEvent, window, cx| {
-                    tile.begin_resize(side, event.position, window, cx);
-                    cx.stop_propagation();
-                }
-            })
-            .on_drag(DragResizing(node), |drag, _, _, cx| {
-                cx.stop_propagation();
-                cx.new(|_| drag.clone())
-            })
-            .on_drag_move({
-                let tile = tile.clone();
-                move |event: &DragMoveEvent<DragResizing>, window, cx| {
-                    if event.drag(cx).0 != node {
-                        return;
-                    }
-                    tile.resize_to(event.event.position, window, cx);
-                }
-            })
-    }
-
-    /// The trailing controls of a tile's title bar, zoom, close and the ellipsis menu.
-    /// They use click handlers, the zoom and close actions target a focused tab group.
-    fn render_tile_controls(
-        &self,
-        tile: &TileContext,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> impl IntoElement {
-        let handle = PanelHandle::of(tile.panel());
-        let control = handle.and_then(|handle| handle.zoom_control(cx));
-        let zoomed = tile.is_zoomed();
-        let toolbar_zoom =
-            tile.is_zoomable() && control.is_some_and(|control| control.toolbar_visible());
-        let menu_zoom = tile.is_zoomable() && control.is_some_and(|control| control.menu_visible());
-        let closable = tile.is_closable();
-        let buttons = handle.and_then(|handle| handle.toolbar_buttons(window, cx));
-        let panel = handle.map(|handle| handle.panel());
-
-        h_flex()
-            .gap_1()
-            .flex_shrink_0()
-            .occlude()
-            .when_some(buttons, |this, buttons| {
-                this.children(
-                    buttons
-                        .into_iter()
-                        .map(|button| button.xsmall().ghost().tab_stop(false)),
-                )
-            })
-            .when_some(
-                match (zoomed, toolbar_zoom) {
-                    (true, _) => Some(("zoom-out", IconName::Minimize, t("Dock.Zoom Out"))),
-                    (false, true) => Some(("zoom-in", IconName::Maximize, t("Dock.Zoom In"))),
-                    (false, false) => None,
-                },
-                |this, (id, icon, tooltip)| {
-                    this.child(
-                        Button::new(id)
-                            .icon(icon)
-                            .xsmall()
-                            .ghost()
-                            .tab_stop(false)
-                            .tooltip(tooltip)
-                            .selected(zoomed)
-                            .on_click({
-                                let tile = tile.clone();
-                                move |_, window, cx| tile.toggle_zoom(window, cx)
-                            }),
-                    )
-                },
-            )
-            .child(
-                Button::new("menu")
-                    .icon(IconName::Ellipsis)
-                    .xsmall()
-                    .ghost()
-                    .tab_stop(false)
-                    .dropdown_menu({
-                        let tile = tile.clone();
-                        move |menu, window, cx| {
-                            menu.when_some(panel.clone(), |menu, panel| {
-                                panel.dropdown_menu(menu, window, cx)
-                            })
-                            .separator()
-                            .item(
-                                PopupMenuItem::new(match zoomed {
-                                    true => t("Dock.Zoom Out"),
-                                    false => t("Dock.Zoom In"),
-                                })
-                                .disabled(!menu_zoom && !zoomed)
-                                .on_click({
-                                    let tile = tile.clone();
-                                    move |_, window, cx| tile.toggle_zoom(window, cx)
-                                }),
-                            )
-                            .when(closable, |menu| {
-                                menu.separator()
-                                    .item(PopupMenuItem::new(t("Dock.Close")).on_click({
-                                        let tile = tile.clone();
-                                        move |_, window, cx| tile.close(window, cx)
-                                    }))
-                            })
-                        }
-                    })
-                    .anchor(gpui::Anchor::TopRight),
-            )
-    }
-}
-
-impl TilesRenderer for SignedTilesSkin {
-    fn frame(&self, _: &mut Window, cx: &mut App) -> Stateful<Div> {
-        div()
-            .id("tiles")
-            .relative()
-            .size_full()
-            .bg(cx.theme().tokens.tiles)
-            .track_scroll(&self.scroll_handle)
-            .overflow_scroll()
-    }
-
-    fn tile_frame(&self, tile: &TileContext, _: &mut Window, cx: &mut App) -> Stateful<Div> {
-        v_flex()
-            .id(("tile", tile.panel_id().as_u64()))
-            .occlude()
-            .overflow_hidden()
-            .bg(cx.theme().tokens.background)
-            .border_1()
-            .border_color(cx.theme().border)
-            .rounded(cx.theme().tile_radius)
-            // Room for the title bar, which overlays the top padding.
-            // Base draws the panel as a plain child, this keeps them apart.
-            .pt(DRAG_BAR_HEIGHT)
-            // Base stores no bounds on a zoomed tile, the skin decides how it fills the dock.
-            .when(tile.is_zoomed(), |this| this.size_full())
-            .on_mouse_down(MouseButton::Left, {
-                let tile = tile.clone();
-                move |_, window, cx| tile.bring_to_front(window, cx)
-            })
-            // A gesture can end anywhere, so both mouse-up hooks run.
-            // Each is a no-op unless this tile is the one that moved.
-            .on_mouse_up(MouseButton::Left, {
-                let tile = tile.clone();
-                move |_, window, cx| {
-                    tile.end_move(window, cx);
-                    tile.end_resize(window, cx);
-                }
-            })
-            .on_mouse_up_out(MouseButton::Left, {
-                let tile = tile.clone();
-                move |_, window, cx| {
-                    tile.end_move(window, cx);
-                    tile.end_resize(window, cx);
-                }
-            })
-    }
-
-    fn render_drag_bar(&self, tile: &TileContext, window: &mut Window, cx: &mut App) -> AnyElement {
-        let node = tile.node();
-        let handle = PanelHandle::of(tile.panel());
-        let title_style = handle.and_then(|handle| handle.title_style(cx));
-
-        h_flex()
-            .id("drag-bar")
-            .absolute()
-            .top_0()
-            .left_0()
-            .w_full()
-            .h(DRAG_BAR_HEIGHT)
-            .items_center()
-            .gap_1()
-            .pl_3()
-            .pr_2()
-            .when_some(title_style, |this, style| {
-                this.bg(style.background).text_color(style.foreground)
-            })
-            .child(
-                div()
-                    .flex_1()
-                    .min_w_16()
-                    .overflow_hidden()
-                    .text_ellipsis()
-                    .whitespace_nowrap()
-                    .child(panel_title(tile.panel(), window, cx)),
-            )
-            .children(handle.and_then(|handle| handle.title_suffix(window, cx)))
-            .child(self.render_tile_controls(tile, window, cx))
-            // A zoomed tile is not at its stored bounds, so moving it would mean nothing.
-            .when(!tile.is_zoomed(), |this| {
-                this.cursor_grab()
-                    .on_mouse_down(MouseButton::Left, {
-                        let tile = tile.clone();
-                        move |event: &MouseDownEvent, window, cx| {
-                            tile.begin_move(event.position, window, cx);
-                        }
-                    })
-                    .on_drag(DragMoving(node), |drag, _, _, cx| {
-                        cx.stop_propagation();
-                        cx.new(|_| drag.clone())
-                    })
-                    .on_drag_move({
-                        let tile = tile.clone();
-                        move |event: &DragMoveEvent<DragMoving>, window, cx| {
-                            if event.drag(cx).0 != node {
-                                return;
-                            }
-                            tile.move_to(event.event.position, window, cx);
-                        }
-                    })
-            })
-            .into_any_element()
-    }
-
-    fn render_resize_handles(
-        &self,
-        tile: &TileContext,
-        _: &mut Window,
-        cx: &mut App,
-    ) -> AnyElement {
-        let bounds = tile.bounds();
-
-        // A passive full-tile box, so handles sit against the tile, not its flow neighbours.
-        // It registers no interaction, so it does not shadow the panel underneath.
-        div()
-            .absolute()
-            .top_0()
-            .left_0()
-            .size_full()
-            .child(
-                self.resize_handle(tile, "left-resize-handle", ResizeSide::Left, |this| {
-                    this.cursor_ew_resize()
-                        .top_0()
-                        .left(HANDLE_OFFSET)
-                        .w(HANDLE_SIZE)
-                        .h(bounds.size.height)
-                }),
-            )
-            .child(
-                self.resize_handle(tile, "right-resize-handle", ResizeSide::Right, |this| {
-                    this.cursor_ew_resize()
-                        .top_0()
-                        .right(HANDLE_OFFSET)
-                        .w(HANDLE_SIZE)
-                        .h(bounds.size.height)
-                }),
-            )
-            .child(
-                self.resize_handle(tile, "top-resize-handle", ResizeSide::Top, |this| {
-                    this.cursor_ns_resize()
-                        .left_0()
-                        .top(HANDLE_OFFSET)
-                        .w(bounds.size.width)
-                        .h(HANDLE_SIZE)
-                }),
-            )
-            .child(
-                self.resize_handle(tile, "bottom-resize-handle", ResizeSide::Bottom, |this| {
-                    this.cursor_ns_resize()
-                        .left_0()
-                        .bottom(HANDLE_OFFSET)
-                        .w(bounds.size.width)
-                        .h(HANDLE_SIZE)
-                }),
-            )
-            .child(
-                Icon::new(IconName::ResizeCorner)
-                    .size_3()
-                    .absolute()
-                    .right(px(1.))
-                    .bottom(px(1.))
-                    .text_color(cx.theme().muted_foreground.opacity(0.5)),
-            )
-            .child(self.resize_handle(
-                tile,
-                "corner-resize-handle",
-                ResizeSide::BottomRight,
-                |this| {
-                    this.cursor_nwse_resize()
-                        .right(HANDLE_OFFSET)
-                        .bottom(HANDLE_OFFSET)
-                        .size_3()
-                },
-            ))
-            .into_any_element()
-    }
-
-    /// Gives the tile's panel `size_full`, base draws it as a plain child otherwise.
-    fn panel_frame(&self, tile: &TileContext, _: &mut Window, _: &mut App) -> Stateful<Div> {
-        h_flex()
-            .id(("tile-panel", tile.panel_id().as_u64()))
-            .overflow_hidden()
-            .size_full()
-    }
-
-    /// The canvas scrollbar, as an overlay.
-    /// Placed inside the frame it would end up underneath every tile.
-    fn render_overlay(
-        &self,
-        content: Size<Pixels>,
-        _: &mut Window,
-        _: &mut App,
-    ) -> Option<AnyElement> {
-        Some(
-            Scrollbar::new(&self.scroll_handle)
-                .scroll_size(content)
-                .when_some(self.shared.tiles_scrollbar_mode(), |this, mode| {
-                    this.mode(mode)
-                })
-                .into_any_element(),
-        )
-    }
-
-    fn grid_size(&self, cx: &App) -> Pixels {
-        cx.theme().tile_grid_size
-    }
-}

crates/settings/src/settings.rs

@@ -18,6 +18,16 @@ pub enum AppearanceMode {
     Dark,
 }
 
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum EventFetchingStrategy {
+    /// Only the relays declared in the repository announcement.
+    Curated,
+    /// Repository relays plus every maintainer's NIP-65 relays.
+    #[default]
+    Uncensored,
+}
+
 /// Fields mirror the gpui-component `Theme` surface customized at startup.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
@@ -54,6 +64,22 @@ impl Default for ThemeSettings {
     }
 }
 
+/// Tab bar chrome.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct TabBarSettings {
+    /// Hide the previous and next tab buttons.
+    pub hide_navigation_buttons: bool,
+}
+
+impl Default for TabBarSettings {
+    fn default() -> Self {
+        Self {
+            hide_navigation_buttons: true,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
 pub struct GraspServersSettings {
@@ -125,7 +151,9 @@ pub struct CreateRepositorySettings {
 #[serde(default)]
 pub struct Settings {
     pub appearance: AppearanceMode,
+    pub event_fetching: EventFetchingStrategy,
     pub theme: ThemeSettings,
+    pub tab_bar: TabBarSettings,
     pub grasp_servers: GraspServersSettings,
     pub local_repos: LocalReposSettings,
     pub checkouts: CheckoutsSettings,
@@ -140,6 +168,7 @@ mod tests {
     fn json_roundtrip_preserves_everything() {
         let settings = Settings {
             appearance: AppearanceMode::Dark,
+            event_fetching: EventFetchingStrategy::Curated,
             theme: ThemeSettings {
                 radius: 8.0,
                 ..Default::default()
@@ -161,9 +190,19 @@ mod tests {
             serde_json::from_str(r#"{"appearance": "dark", "theme": {"radius": 4.0}}"#).unwrap();
         assert_eq!(settings.appearance, AppearanceMode::Dark);
         assert_eq!(settings.theme.radius, 4.0);
+        // Unset fields fall back to their defaults, including the fetching strategy.
+        assert_eq!(settings.event_fetching, EventFetchingStrategy::Uncensored);
         // The rest of the theme and the other groups keep their defaults.
         assert_eq!(settings.theme.light_theme, "Signed Light");
         assert_eq!(settings.grasp_servers, GraspServersSettings::default());
         assert_eq!(settings.create_repository.default_folder, None);
     }
+
+    #[test]
+    fn event_fetching_uses_snake_case() {
+        let json = serde_json::to_string(&EventFetchingStrategy::Curated).unwrap();
+        assert_eq!(json, r#""curated""#);
+        let parsed: EventFetchingStrategy = serde_json::from_str(r#""uncensored""#).unwrap();
+        assert_eq!(parsed, EventFetchingStrategy::Uncensored);
+    }
 }

crates/settings/src/store.rs

@@ -24,6 +24,12 @@ impl SettingsStore {
         cx.global::<GlobalSettingsStore>().0.clone()
     }
 
+    /// Retrieve the global settings store if one has been installed.
+    pub fn try_global(cx: &App) -> Option<Entity<Self>> {
+        cx.try_global::<GlobalSettingsStore>()
+            .map(|store| store.0.clone())
+    }
+
     pub fn set_global(entity: Entity<Self>, cx: &mut App) {
         cx.set_global(GlobalSettingsStore(entity));
     }

crates/signed_core/src/annotations.rs

@@ -1,7 +0,0 @@
-use nostr::prelude::*;
-
-/// GitWorkshop and `ngit` cover-note extension, kind 1624.
-///
-/// A markdown note attached to an issue, patch or PR by its author or a maintainer,
-/// not part of the NIP-34 draft, read support for interop.
-pub const COVER_NOTE_KIND: Kind = Kind::Custom(1624);

crates/signed_core/src/filters.rs

@@ -2,7 +2,7 @@ use std::time::Duration;
 
 use nostr::prelude::*;
 
-use crate::{COVER_NOTE_KIND, RepoAddr};
+use crate::RepoAddr;
 
 /// Kinds that make up the activity of a repository.
 pub const ACTIVITY_KINDS: [Kind; 9] = [
@@ -18,19 +18,18 @@ pub const ACTIVITY_KINDS: [Kind; 9] = [
 ];
 
 /// Kinds that notify a user when they tag them via their `p` tag.
-pub const NOTIFICATION_KINDS: [Kind; 9] = [
+pub const NOTIFICATION_KINDS: [Kind; 8] = [
     Kind::GitIssue,
     Kind::GitPullRequest,
     Kind::GitPatch,
     Kind::GitPullRequestUpdate,
-    COVER_NOTE_KIND,
     Kind::GitStatusOpen,
     Kind::GitStatusApplied,
     Kind::GitStatusClosed,
     Kind::GitStatusDraft,
 ];
 
-/// Git root kinds that make a comment or cover note count as git activity.
+/// Git root kinds that make a comment count as git activity.
 const GIT_ROOT_KINDS: [Kind; 4] = [
     Kind::GitIssue,
     Kind::GitPatch,
@@ -38,6 +37,15 @@ const GIT_ROOT_KINDS: [Kind; 4] = [
     Kind::GitRepoAnnouncement,
 ];
 
+/// Kinds that carry repository data: announcements, states, activity and deletions.
+pub fn is_repo_kind(kind: Kind) -> bool {
+    kind == Kind::GitRepoAnnouncement
+        || kind == Kind::RepoState
+        || kind == Kind::EventDeletion
+        || kind == Kind::RequestToVanish
+        || ACTIVITY_KINDS.contains(&kind)
+}
+
 /// Value of the first tag named `name` on `event`.
 fn tag_value<'a>(event: &'a Event, name: &str) -> Option<&'a str> {
     event
@@ -140,13 +148,7 @@ pub fn notifications(me: PublicKey) -> Vec<Filter> {
 /// A comment on an unrelated kind is matched too, so results must be filtered
 /// through [`is_git_activity`] before display.
 pub fn authored_activity(me: PublicKey) -> Filter {
-    Filter::new()
-        .kinds(
-            ACTIVITY_KINDS
-                .into_iter()
-                .chain(std::iter::once(COVER_NOTE_KIND)),
-        )
-        .author(me)
+    Filter::new().kinds(ACTIVITY_KINDS).author(me)
 }
 
 /// Whether a kind-1111 comment targets a git root, checked via its `K` tag.
@@ -155,12 +157,6 @@ fn is_git_comment(event: &Event) -> bool {
         && tag_kind(event, "K").is_some_and(|kind| GIT_ROOT_KINDS.contains(&kind))
 }
 
-/// Whether a kind-1624 cover note targets a git root, checked via its `k` tag.
-fn is_git_cover_note(event: &Event) -> bool {
-    event.kind == COVER_NOTE_KIND
-        && tag_kind(event, "k").is_some_and(|kind| GIT_ROOT_KINDS.contains(&kind))
-}
-
 /// Whether a status event references a git root, checked via its `k` tag.
 fn is_git_status(event: &Event) -> bool {
     tag_kind(event, "k").is_some_and(|kind| GIT_ROOT_KINDS.contains(&kind))
@@ -175,7 +171,7 @@ pub fn is_git_activity(event: &Event) -> bool {
         | Kind::GitStatusApplied
         | Kind::GitStatusClosed
         | Kind::GitStatusDraft => is_git_status(event),
-        kind => kind == COVER_NOTE_KIND && is_git_cover_note(event),
+        _ => false,
     }
 }
 
@@ -184,6 +180,11 @@ pub fn all_announcements() -> Filter {
     Filter::new().kind(Kind::GitRepoAnnouncement)
 }
 
+/// All repository state events, carrying each repository's refs and last push time.
+pub fn all_states() -> Filter {
+    Filter::new().kind(Kind::RepoState)
+}
+
 /// How far back deletion requests are fetched and stored.
 const DELETIONS_LOOKBACK: Duration = Duration::from_secs(3 * 365 * 86_400);
 
@@ -262,17 +263,12 @@ mod tests {
     }
 
     #[test]
-    fn status_and_cover_note_activity_depend_on_the_lowercase_k_tag() {
+    fn status_activity_depends_on_the_lowercase_k_tag() {
         let status = signed(
             &keys(1),
             Kind::GitStatusClosed,
             vec![kind_tag("k", Kind::GitPullRequest)],
         );
-        let cover = signed(
-            &keys(1),
-            COVER_NOTE_KIND,
-            vec![kind_tag("k", Kind::GitPatch)],
-        );
         let unrelated = signed(
             &keys(1),
             Kind::GitStatusClosed,
@@ -280,7 +276,6 @@ mod tests {
         );
 
         assert!(is_git_activity(&status));
-        assert!(is_git_activity(&cover));
         assert!(!is_git_activity(&unrelated));
         assert!(!is_git_activity(&signed(
             &keys(1),

crates/signed_core/src/inbox.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 use nostr::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use crate::{COVER_NOTE_KIND, RepoAddr, activity_subject};
+use crate::{RepoAddr, activity_subject};
 
 /// Window before `now` that an advanced cutoff retreats to.
 const ADVANCE_WINDOW: Duration = Duration::from_secs(3 * 24 * 60 * 60);
@@ -121,14 +121,11 @@ impl InboxItem {
 /// - patch (1617): its `e` parent patch, else itself
 /// - NIP-22 comment (1111): uppercase `E` root pointer
 /// - PR update (1619): uppercase `E`
-/// - statuses (1630-1633) / cover note (1624): NIP-10 root `e`
+/// - statuses (1630-1633): NIP-10 root `e`
 pub fn notification_root<L>(event: &Event, lookup: &L) -> Option<EventId>
 where
     L: Fn(EventId) -> Option<Event>,
 {
-    if event.kind == COVER_NOTE_KIND {
-        return nip10_root_id(event).map(|root| resolve_thread_root(root, lookup));
-    }
     match event.kind {
         Kind::GitIssue | Kind::GitPullRequest => Some(event.id),
         Kind::GitPatch => Some(match first_e_id(event) {

crates/signed_core/src/lib.rs

@@ -1,5 +1,4 @@
 pub mod addr;
-pub mod annotations;
 pub mod deletions;
 pub mod filters;
 pub mod inbox;
@@ -8,7 +7,6 @@ pub mod state;
 pub mod status;
 
 pub use addr::{RepoAddr, identifier_from_name, repo_addr};
-pub use annotations::COVER_NOTE_KIND;
 pub use deletions::Deletions;
 pub use filters::{
     NOTIFICATION_KINDS, authored_activity, is_git_activity, notification_comments, notifications,

crates/signed_git/Cargo.toml

@@ -8,6 +8,8 @@ publish.workspace = true
 signed_core = { path = "../signed_core" }
 
 nostr.workspace = true
+serde.workspace = true
+serde_json.workspace = true
 gix = { workspace = true, features = ["revision", "blob-diff"] }
 gix-worktree = "0.56"
 gix-worktree-state = "0.34"

crates/signed_git/src/lib.rs

@@ -1,6 +1,7 @@
 mod cache;
 mod diff;
 mod history;
+mod nip34;
 mod patch;
 mod remote;
 mod repo;
@@ -19,6 +20,9 @@ pub use history::{
     CommitList, FileCommit, MAX_LISTED_COMMITS, all_commits, head_commit, worktree_all_commits,
     worktree_commit, worktree_commit_range_commits, worktree_last_commits,
 };
+pub use nip34::{
+    GraspSignals, Nip34Binding, Nip34Kind, detect_nip34, is_grasp_url, set_nostr_repo,
+};
 pub use patch::{
     apply_patch, format_patch_between, patch_commits, patch_diffs, split_patch_series,
 };
@@ -32,7 +36,7 @@ pub use repo::{
     repo_tags, root_commit, worktree_branches, worktree_current_branch, worktree_ref_exists,
     worktree_ref_state,
 };
-pub use scan::find_git_repos;
+pub use scan::{LocalRepo, find_git_repos};
 pub use worktree::{
     WorktreeSnapshot, find_readme, worktree_checkout_branch, worktree_checkout_tag,
     worktree_commits_ahead, worktree_dirty, worktree_entries, worktree_read, worktree_snapshot,

crates/signed_git/src/nip34.rs

@@ -0,0 +1,454 @@
+use std::path::Path;
+
+use anyhow::Result;
+use gix::bstr::ByteSlice;
+use nostr::prelude::*;
+
+/// The kind of NIP-34 relationship a local repository has on disk.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Nip34Kind {
+    /// Bound to a NIP-34 coordinate, by `nak`'s `nip34.json` or `ngit`'s `nostr.repo`.
+    Initialized,
+    /// Cloned from a `nostr://` remote but never initialized locally.
+    Cloned,
+    /// Nostr tooling touched the repository but no binding is recoverable.
+    ToolingOnly,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct GraspSignals {
+    pub nip34_json: bool,
+    pub nip34_excluded: bool,
+    pub nostr_repo_config: bool,
+    pub nostr_remote: bool,
+    pub grasp_remote: bool,
+    /// `nip34_grasp_remote` is the `nak`-specific `nip34/grasp/<host>` remote name.
+    pub nip34_grasp_remote: bool,
+    pub nip34_state_refs: bool,
+    pub nostr_cache: bool,
+    pub nostr_aux_config: bool,
+    pub maintainers_yaml: bool,
+}
+
+impl GraspSignals {
+    pub fn any(&self) -> bool {
+        *self != Self::default()
+    }
+}
+
+/// What a local repository's on-disk state says about its NIP-34 binding.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Nip34Binding {
+    pub kind: Nip34Kind,
+    pub signals: GraspSignals,
+    /// Coordinate owner and identifier, from `nip34.json` or `nostr.repo`.
+    pub owner: Option<PublicKey>,
+    pub identifier: Option<String>,
+    pub grasp_urls: Vec<String>,
+}
+
+#[derive(serde::Deserialize)]
+struct Nip34Json {
+    identifier: Option<String>,
+    owner: Option<String>,
+}
+
+pub fn detect_nip34(repo_path: &Path) -> Option<Nip34Binding> {
+    let repo = gix::open(repo_path).ok()?;
+    let common_dir = repo.common_dir().to_path_buf();
+    let workdir = repo.workdir().map(Path::to_path_buf);
+
+    let mut signals = GraspSignals::default();
+    let mut owner: Option<PublicKey> = None;
+    let mut identifier: Option<String> = None;
+    let mut grasp_urls: Vec<String> = Vec::new();
+
+    if let Some(workdir) = &workdir {
+        if let Ok(bytes) = std::fs::read(workdir.join("nip34.json"))
+            && let Ok(config) = serde_json::from_slice::<Nip34Json>(&bytes)
+        {
+            signals.nip34_json = true;
+            identifier = config.identifier.and_then(non_empty);
+            owner = config
+                .owner
+                .as_deref()
+                .and_then(|value| PublicKey::parse(value).ok());
+        }
+
+        if workdir.join("maintainers.yaml").is_file() {
+            signals.maintainers_yaml = true;
+        }
+    }
+
+    if let Ok(exclude) = std::fs::read_to_string(common_dir.join("info/exclude"))
+        && exclude.contains("nip34.json")
+    {
+        signals.nip34_excluded = true;
+    }
+
+    // `ngit` keeps its repository event cache in the Git common directory.
+    if common_dir.join("nostr-cache.lmdb").is_file() {
+        signals.nostr_cache = true;
+    }
+
+    // `ngit` reads and writes `nostr.repo` at repository-local scope only.
+    if let Ok(config) = gix::config::File::from_path_no_includes(
+        common_dir.join("config"),
+        gix::config::Source::Local,
+    ) {
+        if let Some(value) = config.string("nostr.repo")
+            && let Some((key, id)) = coordinate_from_naddr(&value.to_str_lossy())
+        {
+            signals.nostr_repo_config = true;
+            owner = Some(key);
+            identifier = Some(id);
+        }
+
+        for key in ["nostr.repo-relay-only", "nostr.nostate", "nostr.private"] {
+            if config.string(key).is_some() {
+                signals.nostr_aux_config = true;
+            }
+        }
+
+        if let Some(sections) = config.sections_by_name("remote") {
+            for section in sections {
+                let Some(name) = section.header().subsection_name() else {
+                    continue;
+                };
+                let nak_grasp_remote = name.to_str_lossy().starts_with("nip34/grasp/");
+
+                for url in section.values("url") {
+                    let url = url.to_str_lossy();
+
+                    if url.starts_with("nostr://") {
+                        signals.nostr_remote = true;
+                        // Strong markers win; only fill an empty binding.
+                        if owner.is_none()
+                            && identifier.is_none()
+                            && let Some((key, id)) = parse_nostr_url(&url)
+                        {
+                            owner = Some(key);
+                            identifier = Some(id);
+                        }
+                    }
+
+                    if is_grasp_url(&url) {
+                        signals.grasp_remote = true;
+                        signals.nip34_grasp_remote |= nak_grasp_remote;
+                        grasp_urls.push(url.to_string());
+
+                        if owner.is_none()
+                            && identifier.is_none()
+                            && let Some((key, id)) = grasp_parts(&url)
+                        {
+                            owner = Some(key);
+                            identifier = Some(id);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // `nak` materializes a kind-30618 state as `refs/heads/nip34/state/*`.
+    if let Ok(platform) = repo.references()
+        && let Ok(mut refs) = platform.prefixed(b"refs/heads/nip34/state/")
+        && refs.next().is_some()
+    {
+        signals.nip34_state_refs = true;
+    }
+
+    if !signals.any() {
+        return None;
+    }
+
+    let kind = if signals.nip34_json
+        || signals.nostr_repo_config
+        || signals.nip34_grasp_remote
+        || signals.nip34_state_refs
+    {
+        Nip34Kind::Initialized
+    } else if signals.nostr_remote {
+        Nip34Kind::Cloned
+    } else {
+        Nip34Kind::ToolingOnly
+    };
+
+    Some(Nip34Binding {
+        kind,
+        signals,
+        owner,
+        identifier,
+        grasp_urls,
+    })
+}
+
+/// Record a repository's NIP-34 coordinate in its local `nostr.repo` config.
+pub fn set_nostr_repo(repo_path: &Path, naddr: &str) -> Result<()> {
+    let repo = gix::open(repo_path)?;
+
+    crate::remote::edit_local_config(&repo, |config| {
+        config.set_raw_value("nostr.repo", naddr)?;
+        Ok(())
+    })
+}
+
+/// Mirrors `nak`'s `IsGraspURL`: two path segments, a path of at least 65 bytes,
+/// and a first segment that decodes as an `npub`.
+pub fn is_grasp_url(url: &str) -> bool {
+    let Ok(parsed) = Url::parse(url) else {
+        return false;
+    };
+
+    if !matches!(parsed.scheme(), "http" | "https" | "grasp") {
+        return false;
+    }
+
+    let path = parsed.path();
+    if path.matches('/').count() != 2 || path.len() < 65 {
+        return false;
+    }
+
+    grasp_parts(url).is_some()
+}
+
+fn grasp_parts(url: &str) -> Option<(PublicKey, String)> {
+    let parsed = Url::parse(url).ok()?;
+    let mut segments = parsed.path_segments()?.filter(|part| !part.is_empty());
+
+    let owner = PublicKey::parse(segments.next()?).ok()?;
+    let identifier = non_empty(segments.next()?.trim_end_matches(".git"))?;
+
+    Some((owner, identifier))
+}
+
+fn coordinate_from_naddr(value: &str) -> Option<(PublicKey, String)> {
+    let coordinate = Nip19Coordinate::from_bech32(value).ok()?;
+    if coordinate.kind != Kind::GitRepoAnnouncement {
+        return None;
+    }
+
+    let identifier = non_empty(coordinate.identifier.clone())?;
+    Some((coordinate.public_key, identifier))
+}
+
+/// Handles a bare `naddr`, an `npub`, and the optional `[ssh-key-file@]`,
+/// `[protocol/]` and `[relay/]` components. An `nip05` owner yields no binding.
+fn parse_nostr_url(url: &str) -> Option<(PublicKey, String)> {
+    let rest = url.strip_prefix("nostr://")?;
+
+    if rest.starts_with("naddr1") {
+        return coordinate_from_naddr(rest);
+    }
+
+    let rest = rest.rsplit_once('@').map_or(rest, |(_, after)| after);
+    let mut parts: Vec<&str> = rest.split('/').filter(|part| !part.is_empty()).collect();
+
+    if parts
+        .first()
+        .is_some_and(|first| matches!(*first, "ssh" | "https" | "http"))
+    {
+        parts.remove(0);
+    }
+
+    // `[owner, (relay), identifier]`.
+    if parts.len() < 2 {
+        return None;
+    }
+
+    let owner = PublicKey::parse(parts[0]).ok()?;
+    let identifier = non_empty(parts.last()?.trim_end_matches(".git"))?;
+
+    Some((owner, identifier))
+}
+
+fn non_empty(value: impl Into<String>) -> Option<String> {
+    let value = value.into();
+    (!value.is_empty()).then_some(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::process::Command;
+
+    use super::*;
+
+    fn init_repo() -> (tempfile::TempDir, std::path::PathBuf) {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let path = dir.path().join("repo");
+        std::fs::create_dir_all(&path).expect("mkdir");
+        git(&path, &["init", "-q"]);
+        (dir, path)
+    }
+
+    fn git(dir: &Path, args: &[&str]) {
+        let status = Command::new("git")
+            .current_dir(dir)
+            .env("GIT_AUTHOR_NAME", "Test Author")
+            .env("GIT_AUTHOR_EMAIL", "test@example.com")
+            .env("GIT_COMMITTER_NAME", "Test Author")
+            .env("GIT_COMMITTER_EMAIL", "test@example.com")
+            .env("GIT_EDITOR", "true")
+            .args(args)
+            .status()
+            .expect("spawn git");
+        assert!(status.success(), "git {args:?} failed");
+    }
+
+    fn key() -> PublicKey {
+        Keys::generate().public_key()
+    }
+
+    fn naddr(kind: Kind, owner: PublicKey, identifier: &str) -> String {
+        let coordinate = Coordinate::new(kind, owner).identifier(identifier);
+        Nip19Coordinate::new(coordinate, Vec::<RelayUrl>::new())
+            .to_bech32()
+            .expect("naddr")
+    }
+
+    #[test]
+    fn plain_repository_has_no_binding() {
+        let (_dir, path) = init_repo();
+        assert!(detect_nip34(&path).is_none());
+    }
+
+    #[test]
+    fn nip34_json_marks_a_repository_initialized() {
+        let (_dir, path) = init_repo();
+        let owner = key();
+        let npub = owner.to_bech32().expect("npub");
+        std::fs::write(
+            path.join("nip34.json"),
+            format!(r#"{{"identifier":"my-repo","owner":"{npub}"}}"#),
+        )
+        .expect("write");
+
+        let binding = detect_nip34(&path).expect("binding");
+        assert_eq!(binding.kind, Nip34Kind::Initialized);
+        assert!(binding.signals.nip34_json);
+        assert_eq!(binding.owner, Some(owner));
+        assert_eq!(binding.identifier.as_deref(), Some("my-repo"));
+    }
+
+    #[test]
+    fn malformed_nip34_json_is_ignored() {
+        let (_dir, path) = init_repo();
+        std::fs::write(path.join("nip34.json"), b"not json").expect("write");
+
+        assert!(detect_nip34(&path).is_none());
+    }
+
+    #[test]
+    fn nak_exclude_and_state_refs_are_detected() {
+        let (_dir, path) = init_repo();
+
+        std::fs::create_dir_all(path.join(".git/info")).expect("mkdir");
+        std::fs::write(path.join(".git/info/exclude"), "nip34.json\n").expect("write");
+
+        git(&path, &["commit", "-q", "--allow-empty", "-m", "initial"]);
+        git(
+            &path,
+            &["update-ref", "refs/heads/nip34/state/HEAD", "HEAD"],
+        );
+
+        let binding = detect_nip34(&path).expect("binding");
+        assert_eq!(binding.kind, Nip34Kind::Initialized);
+        assert!(binding.signals.nip34_excluded);
+        assert!(binding.signals.nip34_state_refs);
+    }
+
+    #[test]
+    fn nostr_repo_config_marks_a_repository_initialized() {
+        let (_dir, path) = init_repo();
+        let owner = key();
+        let naddr = naddr(Kind::GitRepoAnnouncement, owner, "my-repo");
+        git(&path, &["config", "nostr.repo", &naddr]);
+
+        let binding = detect_nip34(&path).expect("binding");
+        assert_eq!(binding.kind, Nip34Kind::Initialized);
+        assert!(binding.signals.nostr_repo_config);
+        assert_eq!(binding.owner, Some(owner));
+        assert_eq!(binding.identifier.as_deref(), Some("my-repo"));
+    }
+
+    #[test]
+    fn the_written_nostr_repo_marker_is_detected() {
+        let (_dir, path) = init_repo();
+        let owner = key();
+        let naddr = naddr(Kind::GitRepoAnnouncement, owner, "my-repo");
+
+        set_nostr_repo(&path, &naddr).expect("write marker");
+
+        let binding = detect_nip34(&path).expect("binding");
+        assert_eq!(binding.kind, Nip34Kind::Initialized);
+        assert!(binding.signals.nostr_repo_config);
+        assert_eq!(binding.owner, Some(owner));
+        assert_eq!(binding.identifier.as_deref(), Some("my-repo"));
+    }
+
+    #[test]
+    fn nostr_remote_is_a_nip34_clone() {
+        let (_dir, path) = init_repo();
+        let owner = key();
+        let npub = owner.to_bech32().expect("npub");
+        let url = format!("nostr://{npub}/relay.ngit.dev/my-repo");
+        git(&path, &["remote", "add", "origin", &url]);
+
+        let binding = detect_nip34(&path).expect("binding");
+        assert_eq!(binding.kind, Nip34Kind::Cloned);
+        assert!(binding.signals.nostr_remote);
+        assert_eq!(binding.owner, Some(owner));
+        assert_eq!(binding.identifier.as_deref(), Some("my-repo"));
+    }
+
+    #[test]
+    fn nak_grasp_remote_marks_a_repository_initialized() {
+        let (_dir, path) = init_repo();
+        let owner = key();
+        let npub = owner.to_bech32().expect("npub");
+        let url = format!("https://gitnostr.com/{npub}/my-repo.git");
+        git(
+            &path,
+            &["config", "remote.nip34/grasp/gitnostr.com.url", &url],
+        );
+
+        let binding = detect_nip34(&path).expect("binding");
+        assert_eq!(binding.kind, Nip34Kind::Initialized);
+        assert!(binding.signals.nip34_grasp_remote);
+        assert!(binding.signals.grasp_remote);
+        assert_eq!(binding.grasp_urls, vec![url]);
+        assert_eq!(binding.owner, Some(owner));
+        assert_eq!(binding.identifier.as_deref(), Some("my-repo"));
+    }
+
+    #[test]
+    fn nostr_cache_alone_is_tooling_only() {
+        let (_dir, path) = init_repo();
+        std::fs::write(path.join(".git/nostr-cache.lmdb"), b"cache").expect("write");
+
+        let binding = detect_nip34(&path).expect("binding");
+        assert_eq!(binding.kind, Nip34Kind::ToolingOnly);
+        assert!(binding.signals.nostr_cache);
+    }
+
+    #[test]
+    fn grasp_urls_are_recognised_by_shape() {
+        let owner = key();
+        let npub = owner.to_bech32().expect("npub");
+
+        assert!(is_grasp_url(&format!(
+            "https://gitnostr.com/{npub}/my-repo.git"
+        )));
+        assert!(is_grasp_url(&format!(
+            "grasp://gitnostr.com/{npub}/my-repo.git"
+        )));
+
+        assert!(!is_grasp_url("https://gitnostr.com/my-repo.git"));
+        assert!(!is_grasp_url(
+            "https://gitnostr.com/not-a-pubkey/my-repo.git"
+        ));
+        assert!(!is_grasp_url(&format!(
+            "ssh://gitnostr.com/{npub}/my-repo.git"
+        )));
+    }
+}

crates/signed_git/src/remote.rs

@@ -252,10 +252,7 @@ pub fn set_origin(repo_path: &Path, url: &str) -> Result<()> {
 }
 
 /// Apply `edit` to the repository-local configuration and persist it.
-///
-/// The config file is locked while it is read, edited and written back,
-/// like git would when running `git config` or `git remote`.
-fn edit_local_config(
+pub(crate) fn edit_local_config(
     repo: &gix::Repository,
     edit: impl FnOnce(&mut gix::config::File) -> Result<()>,
 ) -> Result<()> {

crates/signed_git/src/scan.rs

@@ -2,12 +2,21 @@ use std::path::{Path, PathBuf};
 
 use ignore::WalkBuilder;
 
+use crate::nip34::{Nip34Binding, detect_nip34};
+
 /// Caps nesting so pathological trees can't stall the scan.
 const SCAN_MAX_DEPTH: usize = 12;
 
-/// Walk `root` recursively and collect the paths of git repositories below it.
-/// `.gitignore` and `.ignore` files are honoured.
-pub fn find_git_repos(root: &Path) -> Vec<PathBuf> {
+/// A git repository discovered under a scan root.
+#[derive(Debug, Clone)]
+pub struct LocalRepo {
+    pub path: PathBuf,
+    /// `None` for a plain repository.
+    pub nip34: Option<Nip34Binding>,
+}
+
+/// Walk `root` recursively and collect the git repositories below it.
+pub fn find_git_repos(root: &Path) -> Vec<LocalRepo> {
     if !root.is_dir() {
         return Vec::new();
     }
@@ -38,4 +47,10 @@ pub fn find_git_repos(root: &Path) -> Vec<PathBuf> {
     }
 
     roots
+        .into_iter()
+        .map(|path| {
+            let nip34 = detect_nip34(&path);
+            LocalRepo { path, nip34 }
+        })
+        .collect()
 }

crates/signed_git/src/tests.rs

@@ -42,7 +42,10 @@ fn find_git_repos_discovers_repositories_recursively() {
     std::fs::create_dir_all(outer.join(".git")).unwrap();
     std::fs::create_dir_all(outer.join("sub/other/.git")).unwrap();
 
-    let mut found = find_git_repos(root);
+    let mut found: Vec<PathBuf> = find_git_repos(root)
+        .into_iter()
+        .map(|repo| repo.path)
+        .collect();
     found.sort();
 
     let mut expected = vec![

crates/signed_state/src/backend.rs

@@ -7,10 +7,11 @@ use anyhow::{Error, anyhow, bail};
 use bitcoin_hashes::sha1::Hash as Sha1Hash;
 use gpui::{App, AppContext, BackgroundExecutor, Context, Entity, EventEmitter, Global, Task};
 use nostr::event::IntoEventBuilder;
+use nostr::nips::nip19::Nip19Coordinate;
 use nostr_connect::prelude::*;
 use nostr_sdk::client::SyncSummary;
 use nostr_sdk::prelude::*;
-use signed_core::{Announcement, RepoAddr, build_state, filters, identifier_from_name};
+use signed_core::{Announcement, RepoAddr, build_state, filters, identifier_from_name, repo_addr};
 use signed_nostr::{SignedAuthUrlHandler, UniversalSigner, Update};
 
 use crate::git_store::repo_mirror_path;
@@ -20,15 +21,8 @@ use crate::repos::RepoListStore;
 pub const USER_KEYRING: &str = "Signed Safe Storage";
 /// Timeout for NIP-46 signer responses.
 pub const NOSTR_CONNECT_TIMEOUT: u64 = 60;
-
 /// Relays connected at startup, before any user-specific relay config is known.
-pub const BOOTSTRAP_RELAYS: [&str; 4] = [
-    "wss://relay.primal.net",
-    "wss://relay.ditto.pub",
-    "wss://index.ngit.dev",
-    "wss://profiles.nostr1.com",
-];
-
+pub const BOOTSTRAP_RELAYS: [&str; 2] = ["wss://relay.ditto.pub", "wss://index.ngit.dev"];
 /// Relays used to index the user's NIP-65 relay list.
 pub const INDEXER_RELAYS: [&str; 2] = ["wss://indexer.coracle.social", "wss://user.kindpag.es"];
 
@@ -41,20 +35,15 @@ pub enum BackendEvent {
     PassphraseRequired,
     /// The signer changed on login, logout or account switch.
     SignerChanged,
-    /// New events were received from a relay and stored in the database.
-    ///
-    /// Batched: [`Backend`]'s notification pump coalesces everything a
-    /// relay delivers within one debounce window into a single event,
-    /// instead of emitting per-event and making every subscriber debounce
-    /// the same burst independently.
-    NostrUpdate(Vec<Update>),
+    /// Kind-0 metadata arrived for these authors; re-read them from the store.
+    ProfileUpdates(Vec<PublicKey>),
+    /// Repository events arrived: announcements, states, activity and deletions.
+    RepoUpdates(Vec<Update>),
     Synced,
     SyncProgress {
         total: u64,
         current: u64,
     },
-    /// An event built locally was signed, broadcast and stored.
-    Published(Box<Event>),
     Error(String),
 }
 
@@ -99,14 +88,16 @@ impl Backend {
 
         let pump: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
             let mut notifications = pump_client.notifications();
-            let mut pending: Vec<Update> = Vec::new();
+            let mut pending_profiles: HashSet<PublicKey> = HashSet::new();
+            let mut pending_repos: Vec<Update> = Vec::new();
+            let mut seen: HashSet<EventId> = HashSet::new();
 
             'outer: loop {
-                match notifications.next().await {
-                    Some(ClientNotification::Event { event, .. }) => {
-                        pending.push(Update::from_event(&event));
+                match next_update(&mut notifications, &mut seen).await {
+                    Some(UpdateEvent::Profile(author)) => {
+                        pending_profiles.insert(author);
                     }
-                    Some(_) => continue,
+                    Some(UpdateEvent::Repo(update)) => pending_repos.push(update),
                     None => break,
                 }
 
@@ -122,28 +113,33 @@ impl Backend {
                     let timer = cx.background_executor().timer(deadline - now);
                     futures::pin_mut!(timer);
 
-                    let next = notifications.next();
+                    let next = next_update(&mut notifications, &mut seen);
                     futures::pin_mut!(next);
 
                     match futures::future::select(next, timer).await {
-                        futures::future::Either::Left((
-                            Some(ClientNotification::Event { event, .. }),
-                            _,
-                        )) => {
-                            pending.push(Update::from_event(&event));
+                        futures::future::Either::Left((Some(UpdateEvent::Profile(author)), _)) => {
+                            pending_profiles.insert(author);
+                        }
+                        futures::future::Either::Left((Some(UpdateEvent::Repo(update)), _)) => {
+                            pending_repos.push(update);
                         }
-                        futures::future::Either::Left((Some(_), _)) => continue,
                         futures::future::Either::Left((None, _)) => break 'outer,
                         futures::future::Either::Right(_) => break,
                     }
                 }
 
-                let batch = std::mem::take(&mut pending);
+                let profiles: Vec<PublicKey> = pending_profiles.drain().collect();
+                let repos = std::mem::take(&mut pending_repos);
 
-                if let Err(e) =
-                    this.update(cx, |_this, cx| cx.emit(BackendEvent::NostrUpdate(batch)))
-                {
-                    log::warn!("failed to emit nostr update: {e}");
+                if let Err(e) = this.update(cx, |_this, cx| {
+                    if !profiles.is_empty() {
+                        cx.emit(BackendEvent::ProfileUpdates(profiles));
+                    }
+                    if !repos.is_empty() {
+                        cx.emit(BackendEvent::RepoUpdates(repos));
+                    }
+                }) {
+                    log::warn!("failed to emit backend update: {e}");
                 }
             }
 
@@ -153,9 +149,10 @@ impl Backend {
         pump.detach();
 
         cx.defer(move |cx| {
-            if let Err(error) = weak.update(cx, |this, cx| this.bootstrap(cx)) {
-                log::warn!("backend dropped before bootstrap could run: {error}");
-            }
+            weak.update(cx, |this, cx| {
+                this.restore_session(cx);
+            })
+            .ok();
         });
 
         Self {
@@ -169,42 +166,6 @@ impl Backend {
         }
     }
 
-    fn bootstrap(&mut self, cx: &mut Context<Self>) {
-        let client = self.client.clone();
-
-        let task = cx.background_spawn(async move {
-            for url in BOOTSTRAP_RELAYS {
-                client.add_relay(url).await?;
-            }
-
-            for url in INDEXER_RELAYS {
-                client
-                    .add_relay(url)
-                    .capabilities(RelayCapabilities::DISCOVERY)
-                    .await?;
-            }
-
-            client.connect().await;
-
-            Ok::<(), Error>(())
-        });
-
-        let notify_task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
-            match task.await {
-                Ok(()) => {
-                    this.update(cx, |this, cx| {
-                        this.restore_session(cx);
-                    })?;
-                }
-                Err(e) => {
-                    this.update(cx, |_this, cx| cx.emit(BackendEvent::error(e.to_string())))?;
-                }
-            }
-            Ok::<(), Error>(())
-        });
-        notify_task.detach();
-    }
-
     /// Restore the saved session from the Keyring.
     ///
     /// - Emits [`BackendEvent::SignerRequired`] when no credential is stored.
@@ -229,7 +190,9 @@ impl Backend {
             let result = async {
                 if content.starts_with("nsec1") {
                     let keys = Keys::new(SecretKey::parse(&content)?);
-                    this.update(cx, |this, cx| this.set_signer(keys, cx))?;
+                    this.update(cx, |this, cx| {
+                        this.set_signer(keys, cx);
+                    })?;
                 } else if content.starts_with("bunker://") {
                     let (base, keys) = extract_master_key(&content);
                     let uri = NostrConnectUri::parse(base)?;
@@ -240,14 +203,19 @@ impl Backend {
                         None,
                     )?;
                     signer.auth_url_handler(SignedAuthUrlHandler);
-                    this.update(cx, |this, cx| this.set_signer(signer, cx))?;
+
+                    this.update(cx, |this, cx| {
+                        this.set_signer(signer, cx);
+                    })?;
                 } else if content.starts_with("ncryptsec1") {
                     this.update(cx, |this, cx| {
                         this.passphrase_required = true;
                         cx.emit(BackendEvent::PassphraseRequired);
                     })?;
                 } else {
-                    this.update(cx, |_this, cx| cx.emit(BackendEvent::SignerRequired))?;
+                    this.update(cx, |_this, cx| {
+                        cx.emit(BackendEvent::SignerRequired);
+                    })?;
                 }
 
                 Ok::<_, Error>(())
@@ -445,9 +413,6 @@ impl Backend {
         let client = self.client.clone();
 
         // Initialize directly at the user's chosen destination.
-        // No mirror is pre-populated: `GitCache::ensure_clone` lazily clones
-        // from the grasp server the first time the repo detail view needs it,
-        // exactly like every other repository.
         let destination = {
             let dir_name = signed_git::sanitize_path_component(&name);
             let dir_name = if dir_name.is_empty() {
@@ -512,9 +477,7 @@ impl Backend {
                 let builder = announcement.into_event_builder();
                 let event = builder.finalize_async(&signer).await?;
                 let output = client.send_event(&event).broadcast().await?;
-                let event = require_relay_accepted(output, event)?;
-                this.update(cx, |this, cx| this.announce_published(event.clone(), cx))?;
-                event
+                require_relay_accepted(output, event)?
             };
 
             // The state event is the push authorization. Stage it on each
@@ -569,14 +532,10 @@ impl Backend {
             // Fan the state out to the relays once a git server holds the objects.
             // Staging already stored the event locally, publishing makes it
             // visible to the other relays and clients.
-            if let Some(state_event) = &outcome.state_event {
-                if let Err(e) = client.send_event(state_event).broadcast().await {
-                    log::warn!("failed to broadcast repository state: {e}");
-                }
-                this.update(cx, |this, cx| {
-                    this.announce_published(state_event.clone(), cx)
-                })
-                .ok();
+            if let Some(state_event) = &outcome.state_event
+                && let Err(e) = client.send_event(state_event).broadcast().await
+            {
+                log::warn!("failed to broadcast repository state: {e}");
             }
 
             let announcement = Announcement::from_event(&event)
@@ -665,9 +624,7 @@ impl Backend {
                 let builder = announcement.into_event_builder();
                 let event = builder.finalize_async(&signer).await?;
                 let output = client.send_event(&event).broadcast().await?;
-                let event = require_relay_accepted(output, event)?;
-                this.update(cx, |this, cx| this.announce_published(event.clone(), cx))?;
-                event
+                require_relay_accepted(output, event)?
             };
 
             let refs = state.refs.clone();
@@ -724,12 +681,10 @@ impl Backend {
 
                 // Fan the state out to the relays once a git server holds the objects.
                 // Staging already stored the event locally, publishing makes it visible to the other relays and clients.
-                if let Some(state_event) = &outcome.state_event {
-                    if let Err(e) = client.send_event(state_event).broadcast().await {
-                        log::warn!("failed to broadcast repository state: {e}");
-                    }
-                    this.update(cx, |this, cx| this.announce_published(state_event.clone(), cx))
-                        .ok();
+                if let Some(state_event) = &outcome.state_event
+                    && let Err(e) = client.send_event(state_event).broadcast().await
+                {
+                    log::warn!("failed to broadcast repository state: {e}");
                 }
             }
 
@@ -743,6 +698,25 @@ impl Backend {
                 .await;
             }
 
+            // Record the ngit-compatible `nostr.repo` marker,
+            // so the next scan detects the repository instead of offering to publish it again.
+            let coordinate = repo_addr(event.pubkey, repo_id.clone());
+            match Nip19Coordinate::new(coordinate, servers.clone()).to_bech32() {
+                Ok(naddr) => {
+                    let path = path.clone();
+                    cx.background_spawn(async move {
+                        if let Err(error) = signed_git::set_nostr_repo(&path, &naddr) {
+                            log::warn!(
+                                "failed to record the NIP-34 marker for {}: {error}",
+                                path.display()
+                            );
+                        }
+                    })
+                    .await;
+                }
+                Err(error) => log::warn!("failed to encode the repository coordinate: {error}"),
+            }
+
             Announcement::from_event(&event).ok_or_else(|| anyhow!("failed to parse announcement"))
         })
     }
@@ -887,14 +861,10 @@ impl Backend {
             // Fan the state out to the relays once a git server holds the objects.
             // Staging already stored the event locally, publishing notifies
             // the repository views and other relays and clients.
-            if let Some(state_event) = &outcome.state_event {
-                if let Err(e) = client.send_event(state_event).broadcast().await {
-                    log::warn!("failed to broadcast repository state: {e}");
-                }
-                this.update(cx, |this, cx| {
-                    this.announce_published(state_event.clone(), cx)
-                })
-                .ok();
+            if let Some(state_event) = &outcome.state_event
+                && let Err(e) = client.send_event(state_event).broadcast().await
+            {
+                log::warn!("failed to broadcast repository state: {e}");
             }
 
             Ok(outcome)
@@ -1066,7 +1036,7 @@ impl Backend {
                 )
                 .await?;
 
-                for url in user_grasp_list_servers(client.clone(), public_key).await? {
+                for url in user_grasp_list_servers(&client, public_key).await? {
                     client.add_relay(url).and_connect().await.ok();
                 }
 
@@ -1185,6 +1155,21 @@ impl Backend {
         .detach();
     }
 
+    /// Sync filters through the SDK's NIP-65 gossip targeting.
+    pub fn sync_auto(&mut self, filters: Vec<Filter>, cx: &mut Context<Self>) {
+        let client = self.client.clone();
+
+        cx.spawn(async move |_this, _cx| {
+            for filter in filters {
+                if let Err(e) = client.sync(filter).await {
+                    log::warn!("gossip relay fetch failed: {e}");
+                }
+            }
+            Ok::<(), Error>(())
+        })
+        .detach();
+    }
+
     pub fn subscribe_bootstrap(&mut self, filters: Vec<Filter>, cx: &mut Context<Self>) {
         let client = self.client.clone();
 
@@ -1202,14 +1187,15 @@ impl Backend {
         .detach();
     }
 
-    pub fn sync_bootstrap(&mut self, filter: Filter, cx: &mut Context<Self>) {
+    /// Sync several bootstrap filters in order, within a single task.
+    pub fn sync_bootstraps(&mut self, filters: Vec<Filter>, cx: &mut Context<Self>) {
         let client = self.client.clone();
         let (tx, mut rx) = SyncProgress::channel();
 
         self.sync_progress = Some((0, 0));
         cx.notify();
 
-        let progress_task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+        cx.spawn(async move |this, cx| {
             let mut last_percent: u64 = 0;
 
             while rx.changed().await.is_ok() {
@@ -1234,23 +1220,29 @@ impl Backend {
                 }
             }
 
-            Ok(())
-        });
-        progress_task.detach();
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
 
         let sync = cx.background_spawn(async move {
-            let opts = SyncOptions::default().progress(tx);
-            sync_bootstrap_only(&client, filter, opts).await
+            let mut first_error = None;
+
+            for filter in filters {
+                let opts = SyncOptions::default().progress(tx.clone());
+                if let Err(error) = sync_bootstrap_only(&client, filter, opts).await {
+                    first_error.get_or_insert(error);
+                }
+            }
+
+            match first_error {
+                Some(error) => Err(error),
+                None => Ok(()),
+            }
         });
 
-        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+        cx.spawn(async move |this, cx| {
             match sync.await {
-                Ok(summary) => {
-                    log::debug!(
-                        "sync done: {} received, {} sent",
-                        summary.received.len(),
-                        summary.sent.len()
-                    );
+                Ok(_) => {
                     this.update(cx, |this, cx| {
                         this.sync_progress = None;
                         cx.emit(BackendEvent::Synced);
@@ -1264,17 +1256,10 @@ impl Backend {
                     })?;
                 }
             }
-            Ok(())
-        });
-        task.detach();
-    }
 
-    /// Emit [`BackendEvent::Published`] for cross-store invalidation.
-    ///
-    /// Callers publish with `client.send_event(...)` directly, then call this
-    /// so stores like `RepoListStore` refresh without re-querying the relays.
-    pub fn announce_published(&self, event: Event, cx: &mut Context<Self>) {
-        cx.emit(BackendEvent::Published(Box::new(event)));
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
     }
 
     /// Publish a NIP-09 deletion for each of `events`, best-effort.
@@ -1299,6 +1284,42 @@ impl Backend {
     }
 }
 
+/// A relay event the backend routes to a store group.
+enum UpdateEvent {
+    Profile(PublicKey),
+    Repo(Update),
+}
+
+/// Await the next relay event from the notification stream.
+async fn next_update(
+    notifications: &mut (impl futures::Stream<Item = ClientNotification> + Unpin),
+    seen: &mut HashSet<EventId>,
+) -> Option<UpdateEvent> {
+    loop {
+        match notifications.next().await {
+            Some(ClientNotification::Message { message, .. }) => {
+                let RelayMessage::Event { event, .. } = *message else {
+                    continue;
+                };
+
+                let update = match event.kind {
+                    Kind::Metadata => UpdateEvent::Profile(event.pubkey),
+                    kind if filters::is_repo_kind(kind) => {
+                        UpdateEvent::Repo(Update::from_event(&event))
+                    }
+                    _ => continue,
+                };
+
+                if seen.insert(event.id) {
+                    return Some(update);
+                }
+            }
+            Some(_) => continue,
+            None => return None,
+        }
+    }
+}
+
 /// Sign and send a single NIP-09 deletion request for `event`.
 async fn retract_event(
     client: &Client,
@@ -1308,16 +1329,14 @@ async fn retract_event(
     let builder = EventDeletionRequest::new()
         .id(event.id)
         .into_event_builder();
+
     let deletion = builder.finalize_async(signer).await?;
     client.send_event(&deletion).broadcast().await?;
+
     Ok(())
 }
 
 /// The event was accepted by at least one relay, or a descriptive error otherwise.
-///
-/// The SDK does not treat "accepted by zero relays" as an error on its own:
-/// [`SendEventOutput::success`] may be empty while the call still returns `Ok`.
-/// This turns that case into an error the caller can surface.
 pub(crate) fn require_relay_accepted(
     output: SendEventOutput,
     event: Event,
@@ -1375,10 +1394,29 @@ async fn connect_repo_relays(
     Ok(())
 }
 
+/// Add and connect the startup relays.
+async fn ensure_bootstrap_relays(client: &Client) -> Result<(), Error> {
+    for url in BOOTSTRAP_RELAYS {
+        client.add_relay(url).and_connect().await?;
+    }
+
+    for url in INDEXER_RELAYS {
+        client
+            .add_relay(url)
+            .capabilities(RelayCapabilities::DISCOVERY)
+            .and_connect()
+            .await?;
+    }
+
+    Ok(())
+}
+
 pub(crate) async fn subscribe_bootstrap_only(
     client: &Client,
     filters: Vec<Filter>,
 ) -> Result<(), Error> {
+    ensure_bootstrap_relays(client).await?;
+
     let opts = SubscribeAutoCloseOptions::default()
         .exit_policy(ReqExitPolicy::ExitOnEOSE)
         .timeout(Some(Duration::from_secs(10)));
@@ -1398,11 +1436,14 @@ pub(crate) async fn sync_bootstrap_only(
     filter: Filter,
     opts: SyncOptions,
 ) -> Result<SyncSummary, Error> {
+    ensure_bootstrap_relays(client).await?;
+
     let output = client
         .sync(filter)
         .with(BOOTSTRAP_RELAYS)
         .opts(opts)
         .await?;
+
     Ok(output.value)
 }
 
@@ -1475,7 +1516,7 @@ fn latest_grasp_list_servers(events: Vec<Event>) -> Vec<RelayUrl> {
 }
 
 pub async fn user_grasp_list_servers(
-    client: Client,
+    client: &Client,
     user: PublicKey,
 ) -> Result<Vec<RelayUrl>, Error> {
     let events: Vec<Event> = client

crates/signed_state/src/checkouts.rs

@@ -10,21 +10,16 @@ use signed_core::{Announcement, RepoAddr};
 
 use crate::backend::{Backend, BackendEvent};
 use crate::git_store::repo_mirror_root;
+use crate::local_repos::LocalReposStore;
 use crate::refresh::{RefreshGate, RefreshRequest};
-use crate::repos::{LocalReposStore, RepoListStore};
+use crate::repos::RepoListStore;
 
 const REFRESH_DEBOUNCE: Duration = Duration::from_millis(300);
 
 /// How often the statuses are recomputed against the local refs.
-///
-/// A commit lands in a checkout long before the remote reconciliation cadence,
-/// so this fast pass surfaces ready-to-push and ready-to-contribute checkouts
-/// within a second or two. It reads the tracking refs only, no network.
 const LOCAL_POLL: Duration = Duration::from_secs(2);
-
 /// How often a full pass refreshes the remotes while any repository panel is open.
 const STATUS_POLL: Duration = Duration::from_secs(15);
-
 /// Remote refresh interval for the `ready to push` badges of the user's own repositories.
 const PUSH_POLL: Duration = Duration::from_secs(60);
 
@@ -45,10 +40,6 @@ pub struct CheckoutStatus {
     /// Commit the branch points at, for tip-based PR dedupe.
     pub head: String,
     /// What the branch is compared against.
-    /// For ready-to-contribute statuses, the announced HEAD branch.
-    /// The fallbacks are `main`, then the first local branch.
-    /// For ready-to-push statuses, the remote-tracking ref.
-    /// Unpushed commits are counted against it.
     ///
     /// It is `refs/remotes/origin/<branch>`, else `origin/HEAD` for new branches.
     pub base: String,
@@ -66,11 +57,6 @@ struct Remembered {
 }
 
 /// Global store of local-checkout associations and per-checkout statuses.
-///
-/// Readers (the sidebar rows, the repository panels) observe this store and
-/// derive what they display from their own snapshots, so publishing needs no
-/// fine-grained entities: the store notifies when a slice changed and each
-/// reader re-derives only what it shows.
 pub struct CheckoutsStore {
     /// Checkout paths per announced repository.
     by_repo: HashMap<RepoAddr, Vec<PathBuf>>,
@@ -143,6 +129,7 @@ impl CheckoutsStore {
                     this.statuses.clear();
                     this.push_statuses.clear();
                     cx.notify();
+
                     this.refresh(cx);
                 }
             }));
@@ -281,9 +268,6 @@ impl CheckoutsStore {
     }
 
     /// Re-resolve the associations and the requested statuses.
-    ///
-    /// Requests arriving while a pass runs fold into a follow-up, requests
-    /// arriving while the debounce timer is pending are dropped.
     pub fn refresh(&mut self, cx: &mut Context<Self>) {
         if self.debounce_pending || self.refresh.request() != RefreshRequest::Schedule {
             return;
@@ -299,12 +283,6 @@ impl CheckoutsStore {
     }
 
     /// One full resolve and apply cycle, the debounced entry point.
-    ///
-    /// Re-resolves the associations from the settings, the scan and the
-    /// announcements, then recomputes the requested statuses against freshly
-    /// fetched remotes. Full passes run on every input change and on the
-    /// remote reconciliation cadence ([`Self::local_tick`]); they also restart
-    /// the fast local pass.
     fn run_refresh(&mut self, cx: &mut Context<Self>) {
         self.debounce_pending = false;
         self.refresh.begin();
@@ -349,7 +327,9 @@ impl CheckoutsStore {
             //
             // The facts are the origin URL and the root commit, both CLI reads.
             let mut facts: Vec<(PathBuf, Option<String>, Option<String>)> = Vec::new();
-            for path in scanned.iter() {
+            for scanned in scanned.iter() {
+                let path = &scanned.path;
+
                 // The browser's mirror clones share the announce URLs and EUCs. They are not user checkouts.
                 if cache_root
                     .as_ref()
@@ -428,10 +408,6 @@ impl CheckoutsStore {
     }
 
     /// Schedule the fast local status pass, unless one is already pending.
-    ///
-    /// Every [`LOCAL_POLL`] the pass recomputes the requested statuses against
-    /// the local refs, with no network, so a new commit in a checkout surfaces in
-    /// a second or two instead of at the next remote reconciliation.
     fn schedule_local_pass(&mut self, cx: &mut Context<Self>) {
         if self.local_pending {
             return;
@@ -449,10 +425,6 @@ impl CheckoutsStore {
     }
 
     /// The fast local status pass.
-    ///
-    /// Recomputes the statuses against the local refs; when the remote
-    /// reconciliation cadence elapsed, it runs a full pass instead so pushes
-    /// made elsewhere do not linger as `to push`.
     fn local_tick(&mut self, cx: &mut Context<Self>) {
         // Nothing watched: the chain idles out until a new request restarts it.
         if self.status_requested.is_empty() && self.push_requested.is_empty() {
@@ -487,10 +459,6 @@ impl CheckoutsStore {
     }
 
     /// Recompute the requested statuses against the tracking refs only.
-    ///
-    /// The refs were last refreshed by a full pass. Comparing against them is
-    /// enough to pick up new local commits, and skipping the network keeps
-    /// this pass cheap enough to run every [`LOCAL_POLL`].
     fn run_local_statuses(&mut self, cx: &mut Context<Self>) {
         let associations = self.by_repo.clone();
 
@@ -632,10 +600,6 @@ fn checkout_status(path: &Path, announced_head: Option<&str>) -> Option<Checkout
 }
 
 /// The `ready to push` status of one checkout of the user's own repository.
-///
-/// `fetch` refreshes the remote heads first, so a full pass sees pushes made
-/// elsewhere; the fast local pass skips it and compares against the tracking
-/// refs left by the last full pass, which is enough to detect local commits.
 fn checkout_push_status(path: &Path, fetch: bool) -> Option<CheckoutStatus> {
     if signed_git::worktree_dirty(path) {
         return None;
@@ -646,8 +610,6 @@ fn checkout_push_status(path: &Path, fetch: bool) -> Option<CheckoutStatus> {
     let origin = signed_git::origin_url(path).ok().flatten()?;
 
     if fetch {
-        // Refresh the remote heads first.
-        // Commits made elsewhere or pushed from another machine must not linger as `to push`.
         signed_git::fetch_repo_refs(path, &[origin], "+refs/heads/*:refs/remotes/origin/*").ok();
     }
 
@@ -675,10 +637,6 @@ fn checkout_push_status(path: &Path, fetch: bool) -> Option<CheckoutStatus> {
 }
 
 /// Compute the requested statuses against the checkout paths of `associations`.
-///
-/// Shared by the full and the local pass. `fetch` refreshes the checkouts'
-/// remote heads first, so the full pass sees remote moves; the fast local
-/// pass reads the tracking refs only, which is enough to detect local commits.
 fn compute_statuses(
     associations: &HashMap<RepoAddr, Vec<PathBuf>>,
     requested: &[(RepoAddr, Option<String>)],
@@ -734,12 +692,14 @@ pub fn pr_proposes_checkout(
     if pr.kind != Kind::GitPullRequest || !open || pr.pubkey != user {
         return false;
     }
+
     let branch_matches = pr
         .tags
         .iter()
         .find(|t| t.kind() == "branch-name")
         .and_then(|t| t.content())
         .is_some_and(|name| name == checkout.branch);
+
     // A renamed branch falls back to the proposed tip commit.
     let tip_matches = pr
         .tags
@@ -747,6 +707,7 @@ pub fn pr_proposes_checkout(
         .find(|t| t.kind() == "c")
         .and_then(|t| t.content())
         .is_some_and(|tip| tip == checkout.head);
+
     branch_matches || tip_matches
 }
 

crates/signed_state/src/inbox.rs

@@ -104,11 +104,16 @@ impl Inbox {
 
     /// Sign the state with a random key and store it locally.
     fn persist(&mut self, cx: &mut Context<Self>) {
-        let Some(me) = Backend::global(cx).read(cx).current_user() else {
+        let backend = Backend::global(cx);
+        let (me, client) = {
+            let backend = backend.read(cx);
+            (backend.current_user(), backend.client())
+        };
+
+        let Some(me) = me else {
             return;
         };
 
-        let client = Backend::global(cx).read(cx).client();
         let state = self.state.clone();
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {

crates/signed_state/src/lib.rs

@@ -2,6 +2,7 @@ mod backend;
 mod checkouts;
 mod git_store;
 mod inbox;
+mod local_repos;
 mod profile;
 mod refresh;
 mod repo;
@@ -15,11 +16,13 @@ use git_store::set_git_cache;
 pub use git_store::{ensure_repo_mirror, open_repo_mirror, repo_mirror_path};
 use gpui::{App, AppContext};
 pub use inbox::{Inbox, query_inbox};
+pub use local_repos::{LocalReposStore, ResolvedLocalRepo, local_repo_addr, resolve_local_repos};
 pub use nostr_sdk::prelude::Timestamp;
 pub use profile::{Profile, ProfileStore};
 pub use refresh::{RefreshGate, RefreshRequest};
 pub use repo::RepoStore;
-pub use repos::{LocalReposStore, RepoActivityCounts, RepoListStore};
+pub use repos::{RepoActivityCounts, RepoListStore};
+pub use signed_git::{GraspSignals, LocalRepo, Nip34Binding, Nip34Kind};
 use signed_nostr::new_backend;
 
 #[cfg(not(target_arch = "wasm32"))]

crates/signed_state/src/local_repos.rs

@@ -0,0 +1,290 @@
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use anyhow::Error;
+use gpui::{App, AppContext, Context, Entity, Global, SharedString, Task};
+use signed_core::{Announcement, RepoAddr, repo_addr};
+use signed_git::{LocalRepo, Nip34Binding, find_git_repos};
+
+struct GlobalLocalReposStore(Entity<LocalReposStore>);
+
+impl Global for GlobalLocalReposStore {}
+
+/// Store of the git repositories discovered under a set of scan paths.
+pub struct LocalReposStore {
+    pub roots: Arc<Vec<PathBuf>>,
+    /// Git repositories discovered under [`Self::roots`], sorted by path.
+    pub repos: Arc<Vec<LocalRepo>>,
+    pub scanning: bool,
+    scan_dirty: bool,
+}
+
+impl LocalReposStore {
+    pub fn global(cx: &App) -> Entity<Self> {
+        cx.global::<GlobalLocalReposStore>().0.clone()
+    }
+
+    pub(crate) fn set_global(entity: Entity<Self>, cx: &mut App) {
+        cx.set_global(GlobalLocalReposStore(entity));
+    }
+
+    pub fn new(roots: Vec<PathBuf>, cx: &mut Context<Self>) -> Self {
+        let weak = cx.entity().downgrade();
+        cx.defer(move |cx| {
+            if let Err(error) = weak.update(cx, |this, cx| this.rescan(cx)) {
+                log::warn!("local repos store dropped before initial scan could run: {error}");
+            }
+        });
+
+        Self {
+            roots: Arc::new(roots),
+            repos: Arc::new(Vec::new()),
+            scanning: false,
+            scan_dirty: false,
+        }
+    }
+
+    /// Forget a repository that has just been published to NIP-34.
+    pub fn remove(&mut self, path: &Path, cx: &mut Context<Self>) {
+        self.repos = Arc::new(
+            self.repos
+                .iter()
+                .filter(|repo| repo.path.as_path() != path)
+                .cloned()
+                .collect(),
+        );
+        cx.notify();
+    }
+
+    pub fn rescan(&mut self, cx: &mut Context<Self>) {
+        if self.scanning {
+            self.scan_dirty = true;
+            return;
+        }
+
+        if self.roots.is_empty() {
+            return;
+        }
+
+        self.scanning = true;
+        cx.notify();
+
+        let roots = self.roots.clone();
+
+        let work = cx.background_spawn(async move {
+            let mut repos = Vec::new();
+            for root in roots.iter() {
+                repos.extend(find_git_repos(root));
+            }
+            repos.sort_by(|a, b| a.path.cmp(&b.path));
+            repos.dedup_by(|a, b| a.path == b.path);
+            repos
+        });
+
+        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+            let repos = work.await;
+            let again = this.update(cx, |this, cx| {
+                this.repos = Arc::new(repos);
+                this.scanning = false;
+                cx.notify();
+
+                let dirty = this.scan_dirty;
+                this.scan_dirty = false;
+                dirty
+            })?;
+
+            // Scans requested while this one ran are coalesced into one follow-up scan.
+            if again {
+                this.update(cx, |this, cx| this.rescan(cx))?;
+            }
+
+            Ok(())
+        });
+
+        task.detach();
+    }
+}
+
+/// The NIP-34 coordinate a repository's detection resolved, when both the owner
+/// and the identifier were recovered.
+pub fn local_repo_addr(repo: &LocalRepo) -> Option<RepoAddr> {
+    let binding = repo.nip34.as_ref()?;
+    let owner = binding.owner?;
+    let identifier = binding.identifier.as_deref()?;
+
+    Some(repo_addr(owner, identifier))
+}
+
+/// A scanned repository resolved against the known announcements.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ResolvedLocalRepo {
+    pub path: PathBuf,
+    /// `None` for a plain repository.
+    pub nip34: Option<Nip34Binding>,
+    /// The known announcement this repository is bound to, when one matched.
+    pub announcement: Option<Announcement>,
+}
+
+impl ResolvedLocalRepo {
+    /// The repository's directory name, or `Untitled` when the path has none.
+    pub fn name(&self) -> SharedString {
+        self.path
+            .file_name()
+            .map(|name| SharedString::from(name.to_string_lossy().into_owned()))
+            .unwrap_or_else(|| SharedString::from("Untitled"))
+    }
+}
+
+/// Resolve the scanned repositories against the known announcements.
+pub fn resolve_local_repos(
+    repos: &[LocalRepo],
+    known: &[Announcement],
+    own: &[Announcement],
+) -> Vec<ResolvedLocalRepo> {
+    let shown: HashSet<RepoAddr> = own.iter().map(Announcement::addr).collect();
+
+    repos
+        .iter()
+        .filter_map(|repo| {
+            let addr = local_repo_addr(repo);
+
+            if let Some(addr) = &addr
+                && shown.contains(addr)
+            {
+                return None;
+            }
+
+            let announcement = addr
+                .as_ref()
+                .and_then(|addr| {
+                    known
+                        .iter()
+                        .find(|announcement| announcement.addr() == *addr)
+                })
+                .cloned();
+
+            Some(ResolvedLocalRepo {
+                path: repo.path.clone(),
+                nip34: repo.nip34.clone(),
+                announcement,
+            })
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use nostr::prelude::*;
+    use signed_git::{GraspSignals, Nip34Kind};
+
+    use super::*;
+
+    const KEY: &str = "0000000000000000000000000000000000000000000000000000000000000001";
+    const OTHER_KEY: &str = "0000000000000000000000000000000000000000000000000000000000000002";
+
+    fn announcement(secret: &str, id: &str) -> Announcement {
+        let keys = Keys::new(SecretKey::from_hex(secret).expect("secret"));
+        let tag = Tag::parse(vec!["d", id]).expect("tag");
+        let event = EventBuilder::new(Kind::GitRepoAnnouncement, "")
+            .tags(vec![tag])
+            .finalize(&keys)
+            .expect("signed");
+
+        Announcement::from_event(&event).expect("parsed")
+    }
+
+    fn owner(secret: &str) -> PublicKey {
+        Keys::new(SecretKey::from_hex(secret).expect("secret")).public_key()
+    }
+
+    fn bound(secret: &str, id: &str) -> LocalRepo {
+        let binding = Nip34Binding {
+            kind: Nip34Kind::Initialized,
+            signals: GraspSignals {
+                nip34_json: true,
+                ..Default::default()
+            },
+            owner: Some(owner(secret)),
+            identifier: Some(id.to_owned()),
+            grasp_urls: Vec::new(),
+        };
+
+        LocalRepo {
+            path: PathBuf::from(id),
+            nip34: Some(binding),
+        }
+    }
+
+    #[test]
+    fn the_users_own_announcement_is_dropped() {
+        let own = announcement(KEY, "mine");
+        let repo = bound(KEY, "mine");
+
+        let own = std::slice::from_ref(&own);
+        assert!(resolve_local_repos(&[repo], own, own).is_empty());
+    }
+
+    #[test]
+    fn another_owners_announcement_is_linked_and_kept() {
+        let known = announcement(OTHER_KEY, "theirs");
+        let repo = bound(OTHER_KEY, "theirs");
+
+        let resolved = resolve_local_repos(&[repo], std::slice::from_ref(&known), &[]);
+
+        assert_eq!(resolved.len(), 1);
+        assert_eq!(resolved[0].announcement.as_ref(), Some(&known));
+    }
+
+    #[test]
+    fn an_unmatched_repository_keeps_its_binding() {
+        let repo = bound(KEY, "unlisted");
+
+        let resolved = resolve_local_repos(&[repo], &[], &[]);
+
+        assert_eq!(resolved.len(), 1);
+        assert!(resolved[0].announcement.is_none());
+        assert_eq!(
+            resolved[0].nip34.as_ref().map(|binding| binding.kind),
+            Some(Nip34Kind::Initialized)
+        );
+    }
+
+    #[test]
+    fn a_plain_repository_is_kept_without_a_binding() {
+        let repo = LocalRepo {
+            path: PathBuf::from("plain"),
+            nip34: None,
+        };
+
+        let resolved = resolve_local_repos(&[repo], &[], &[]);
+
+        assert_eq!(resolved.len(), 1);
+        assert!(resolved[0].nip34.is_none());
+        assert!(resolved[0].announcement.is_none());
+    }
+
+    #[test]
+    fn the_name_is_the_directory_name() {
+        let repo = LocalRepo {
+            path: PathBuf::from("/tmp/my-repo"),
+            nip34: None,
+        };
+
+        let resolved = resolve_local_repos(&[repo], &[], &[]);
+
+        assert_eq!(resolved[0].name(), SharedString::from("my-repo"));
+    }
+
+    #[test]
+    fn a_path_without_a_directory_name_is_untitled() {
+        let repo = LocalRepo {
+            path: PathBuf::from("/"),
+            nip34: None,
+        };
+
+        let resolved = resolve_local_repos(&[repo], &[], &[]);
+
+        assert_eq!(resolved[0].name(), SharedString::from("Untitled"));
+    }
+}

crates/signed_state/src/profile.rs

@@ -5,14 +5,20 @@ use std::time::{Duration, Instant};
 use anyhow::Error;
 use flume::{Receiver, Sender};
 use gpui::{
-    App, AppContext, AsyncApp, Context, Entity, Global, SharedString, Subscription, Task,
-    WeakEntity,
+    App, AppContext, AsyncApp, Context, Entity, Global, SharedString, Subscription, WeakEntity,
 };
 use nostr_sdk::prelude::*;
 use utils::shorten_pubkey;
 
 use crate::backend::{Backend, BackendEvent, sync_bootstrap_only};
 
+/// How long to wait for more requests before firing a batched fetch.
+const BATCH_TIMEOUT: Duration = Duration::from_millis(500);
+/// Max authors per profile request, keeping each filter within relay limits.
+const REQUEST_CHUNK: usize = 100;
+/// Recent profiles prefetched at startup and read back from the cache.
+const WARM_LIMIT: usize = 500;
+
 /// A user profile as plain data for the UI, from the kind-0 metadata.
 #[derive(Debug, Clone)]
 pub struct Profile {
@@ -62,9 +68,6 @@ impl Profile {
     }
 }
 
-/// How long to wait for more requests before firing a batched sync.
-const BATCH_TIMEOUT: Duration = Duration::from_millis(500);
-
 /// Global profile cache.
 ///
 /// Profiles are fetched in batches and kept as plain data.
@@ -92,40 +95,26 @@ impl ProfileStore {
 
     pub(crate) fn new(cx: &mut Context<Self>) -> Self {
         let backend = Backend::global(cx);
+        let entity = cx.entity().downgrade();
+        let client = backend.read(cx).client();
 
-        let subscription = cx.subscribe(&backend, |this, _backend, event, cx| match event {
-            BackendEvent::NostrUpdate(updates) => {
-                for update in updates
-                    .iter()
-                    .filter(|update| update.kind == Kind::Metadata)
-                {
-                    this.apply_author(update.author, cx);
-                }
+        let (sender, receiver) = flume::unbounded::<PublicKey>();
+
+        let subscription = cx.subscribe(&backend, |this, _backend, event, cx| {
+            if let BackendEvent::ProfileUpdates(authors) = event {
+                this.apply_authors(authors.clone(), cx);
             }
-            BackendEvent::Published(event) if event.kind == Kind::Metadata => {
-                let metadata = Metadata::from_json(&event.content).unwrap_or_default();
-                this.profiles
-                    .insert(event.pubkey, Profile::new(event.pubkey, metadata));
-                cx.notify();
-            }
-            _ => {}
         });
 
-        // Fetch requests are queued on a channel, batched into one sync per debounce window.
-        let client = backend.read(cx).client();
-        let (sender, receiver) = flume::unbounded::<PublicKey>();
-        let entity = cx.entity().downgrade();
-
-        cx.spawn(async move |_this, cx| {
-            Self::handle_requests(entity, &client, &receiver, cx).await
+        cx.spawn(async move |this, cx| {
+            if let Err(e) = Self::handle_requests(this, &client, &receiver, cx).await {
+                log::error!("Failed to handle requests: {e}");
+            }
         })
         .detach();
 
-        let weak = cx.entity().downgrade();
         cx.defer(move |cx| {
-            if let Err(error) = weak.update(cx, |this, cx| this.load(cx)) {
-                log::warn!("profile store dropped before initial load could run: {error}");
-            }
+            entity.update(cx, |this, cx| this.load(cx)).ok();
         });
 
         Self {
@@ -160,11 +149,9 @@ impl ProfileStore {
         let client = backend.read(cx).client();
 
         let work = cx.background_spawn(async move {
-            let filter = Filter::new().kind(Kind::Metadata).limit(200);
+            let filter = Filter::new().kind(Kind::Metadata).limit(WARM_LIMIT);
             let events = client.database().query(filter).await?;
 
-            // Parse off the main thread.
-            // Only plain profiles cross back.
             let profiles: Vec<Profile> = events
                 .into_iter()
                 .map(|event| {
@@ -176,7 +163,7 @@ impl ProfileStore {
             Ok::<_, Error>(profiles)
         });
 
-        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+        cx.spawn(async move |this, cx| {
             let profiles = work.await?;
 
             this.update(cx, |this, cx| {
@@ -186,53 +173,13 @@ impl ProfileStore {
                 cx.notify();
             })?;
 
-            Ok(())
-        });
-        task.detach();
+            Ok::<_, Error>(())
+        })
+        .detach();
     }
 
-    fn apply_author(&mut self, public_key: PublicKey, cx: &mut Context<Self>) {
-        let backend = Backend::global(cx);
-        let client = backend.read(cx).client();
-
-        let work = cx.background_spawn(async move {
-            let filter = Filter::new().kind(Kind::Metadata).author(public_key);
-            let events = client.database().query(filter).await?;
-
-            // Parse off the main thread.
-            // Only the profile crosses back.
-            let profile = events
-                .into_iter()
-                .max_by_key(|e| e.created_at)
-                .map(|event| {
-                    let metadata = Metadata::from_json(event.content).unwrap_or_default();
-                    Profile::new(event.pubkey, metadata)
-                });
-
-            Ok::<_, Error>(profile)
-        });
-
-        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
-            let profile = work.await?;
-
-            this.update(cx, |this, cx| {
-                if let Some(profile) = profile {
-                    this.profiles.insert(profile.public_key(), profile);
-                    cx.notify();
-                }
-            })?;
-
-            Ok(())
-        });
-        task.detach();
-    }
-
-    /// Re-read the latest metadata of every requested author from the local database.
-    ///
-    /// Used after a sync, which produces no NostrUpdate events.
-    fn apply_seen(&mut self, cx: &mut Context<Self>) {
-        let authors: Vec<PublicKey> = self.seen.borrow().iter().copied().collect();
-
+    /// Re-read the latest metadata of `authors` from the local database in one query.
+    fn apply_authors(&mut self, authors: Vec<PublicKey>, cx: &mut Context<Self>) {
         if authors.is_empty() {
             return;
         }
@@ -243,9 +190,9 @@ impl ProfileStore {
         let work = cx.background_spawn(async move {
             let filter = Filter::new().kind(Kind::Metadata).authors(authors);
             let events = client.database().query(filter).await?;
-
             // Pick the latest metadata per author off the main thread.
             let mut latest: HashMap<PublicKey, (Timestamp, Metadata)> = HashMap::new();
+
             for event in events {
                 match latest.get(&event.pubkey) {
                     Some((ts, _)) if *ts >= event.created_at => {}
@@ -269,7 +216,7 @@ impl ProfileStore {
             Ok::<_, Error>(profiles)
         });
 
-        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+        cx.spawn(async move |this, cx| {
             let profiles = work.await?;
 
             this.update(cx, |this, cx| {
@@ -279,14 +226,18 @@ impl ProfileStore {
                 cx.notify();
             })?;
 
-            Ok(())
-        });
-        task.detach();
+            Ok::<_, Error>(())
+        })
+        .detach();
     }
 
-    /// Sync metadata for requested authors in batches, debounced to collect requests.
-    ///
-    /// After each batch, the seen profiles are re-read from the database on the main thread.
+    /// Re-read the latest metadata of every requested author from the local database.
+    fn apply_seen(&mut self, cx: &mut Context<Self>) {
+        let authors: Vec<PublicKey> = self.seen.borrow().iter().copied().collect();
+        self.apply_authors(authors, cx);
+    }
+
+    /// Fetch metadata for requested authors in batches, debounced to collect requests.
     async fn handle_requests(
         this: WeakEntity<ProfileStore>,
         client: &Client,
@@ -305,15 +256,20 @@ impl ProfileStore {
 
             // The channel has no async timeout, race the receive against a timer.
             let deadline = Instant::now() + BATCH_TIMEOUT;
+
             loop {
                 let now = Instant::now();
+
                 if now >= deadline {
                     break;
                 }
+
                 let timer = cx.background_executor().timer(deadline - now);
                 futures::pin_mut!(timer);
+
                 let recv = receiver.recv_async();
                 futures::pin_mut!(recv);
+
                 match futures::future::select(recv, timer).await {
                     futures::future::Either::Left((Ok(public_key), _)) => {
                         batch.insert(public_key);
@@ -323,18 +279,21 @@ impl ProfileStore {
                 }
             }
 
-            let filter = Filter::new()
-                .kind(Kind::Metadata)
-                .authors(batch.drain().collect::<Vec<PublicKey>>());
+            let authors: Vec<PublicKey> = batch.drain().collect();
 
-            // Negentropy-sync with the bootstrap relays.
-            // Synced events are written to the database directly, no NostrUpdate.
-            // Re-apply from the database afterwards.
-            match sync_bootstrap_only(client, filter, SyncOptions::default()).await {
-                Ok(_) => {
-                    this.update(cx, |this, cx| this.apply_seen(cx)).ok();
+            for chunk in authors.chunks(REQUEST_CHUNK) {
+                let opts = SyncOptions::default();
+                let filter = Filter::new()
+                    .kind(Kind::Metadata)
+                    .authors(chunk.iter().copied());
+
+                if let Err(e) = sync_bootstrap_only(client, filter, opts).await {
+                    log::warn!("profile fetch failed: {e}");
                 }
-                Err(e) => log::warn!("profile sync failed: {e}"),
+            }
+
+            if this.update(cx, |this, cx| this.apply_seen(cx)).is_err() {
+                return Ok(());
             }
         }
     }

crates/signed_state/src/refresh.rs

@@ -18,10 +18,6 @@ impl RefreshGate {
         self.running
     }
 
-    /// A new refresh request arrived.
-    ///
-    /// Folded into a follow-up run while one is in flight, otherwise the
-    /// caller starts the run itself.
     pub fn request(&mut self) -> RefreshRequest {
         if self.running {
             self.dirty = true;

crates/signed_state/src/repo.rs

@@ -4,13 +4,16 @@ use std::path::PathBuf;
 
 use anyhow::{Error, bail};
 use bitcoin_hashes::sha1::Hash as Sha1Hash;
-use gpui::{App, AppContext, AsyncApp, Context, SharedString, Subscription, Task, WeakEntity};
+use gpui::{App, AppContext, Context, SharedString, Subscription, Task};
 use nostr::event::IntoEventBuilder;
 use nostr_sdk::prelude::*;
+use settings::{EventFetchingStrategy, SettingsStore};
 use signed_core::{
     Announcement, Deletions, RepoAddr, RepoStatus, filters, parse_state, pull_request_patch,
     pull_request_patches,
 };
+use signed_git::Nip34Binding;
+use signed_nostr::UniversalSigner;
 
 use crate::backend::{
     Backend, BackendEvent, grasp_base_url, grasp06_prs_url, pr_clone_urls, require_relay_accepted,
@@ -18,7 +21,6 @@ use crate::backend::{
 };
 use crate::checkouts::CheckoutsStore;
 use crate::git_store::ensure_repo_mirror;
-use crate::refresh::{RefreshGate, RefreshRequest};
 use crate::repos::RepoListStore;
 
 /// Maximum size of one patch event.
@@ -29,7 +31,6 @@ const MAX_PATCH_EVENT_BYTES: usize = 60 * 1024;
 /// Per-repository store.
 ///
 /// Holds the announcement, state, issues, patches, PRs, comments and resolved statuses.
-/// Always derived from the local database.
 pub struct RepoStore {
     /// NIP-34 address. `None` while the repository is local-only.
     addr: Option<RepoAddr>,
@@ -39,6 +40,8 @@ pub struct RepoStore {
     /// Local working copy. The scan path for a local repository, kept when it is
     /// later announced so the panel keeps its worktree.
     pub path: Option<PathBuf>,
+    /// NIP-34 state detected on disk for a local repository, if any.
+    pub nip34: Option<Nip34Binding>,
     /// The first local pass has been applied.
     ///
     /// Views distinguish "no data yet" from a genuinely empty repository with it.
@@ -81,7 +84,12 @@ pub struct RepoStore {
     ///
     /// The per-root fetches cover NIP-22 comments and statuses without an `a` tag.
     root_fetches: HashSet<EventId>,
-    refresh: RefreshGate,
+    /// Maintainers already synced through gossip in Uncensored mode.
+    ///
+    /// Avoids re-running the maintainer Auto sync on every refresh.
+    synced_maintainers: HashSet<PublicKey>,
+    /// In-flight tasks, cancelled when the store drops.
+    tasks: Vec<Task<Result<(), Error>>>,
     /// Backend subscription of an announced repository. `None` while local-only.
     _subscription: Option<Subscription>,
 }
@@ -112,6 +120,7 @@ impl RepoStore {
             addr: Some(addr),
             announcement: hint,
             path: None,
+            nip34: None,
             loaded: false,
             head: None,
             issues: Vec::new(),
@@ -128,17 +137,19 @@ impl RepoStore {
             cloning: false,
             repo_relays: HashSet::new(),
             root_fetches: HashSet::new(),
-            refresh: RefreshGate::default(),
+            synced_maintainers: HashSet::new(),
+            tasks: Vec::new(),
             _subscription: Some(subscription),
         }
     }
 
     /// Local repository discovered by the scan, not announced to NIP-34 yet.
-    pub fn new_local(path: PathBuf) -> Self {
+    pub fn new_local(path: PathBuf, nip34: Option<Nip34Binding>) -> Self {
         Self {
             addr: None,
             announcement: None,
             path: Some(path),
+            nip34,
             loaded: true,
             head: None,
             issues: Vec::new(),
@@ -155,11 +166,24 @@ impl RepoStore {
             cloning: false,
             repo_relays: HashSet::new(),
             root_fetches: HashSet::new(),
-            refresh: RefreshGate::default(),
+            synced_maintainers: HashSet::new(),
+            tasks: Vec::new(),
             _subscription: None,
         }
     }
 
+    /// An announced repository whose working copy is already on disk.
+    pub fn from_worktree(
+        addr: RepoAddr,
+        announcement: Announcement,
+        path: PathBuf,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let mut store = Self::new(addr, Some(announcement), cx);
+        store.path = Some(path);
+        store
+    }
+
     /// Switch a local repository to its NIP-34 mode, keeping its path.
     pub fn announce(&mut self, announcement: Announcement, cx: &mut Context<Self>) {
         self.addr = Some(announcement.addr());
@@ -184,34 +208,22 @@ impl RepoStore {
             };
 
             let relevant = match event {
-                BackendEvent::NostrUpdate(updates) => updates.iter().any(|update| {
-                    // Deletions may target any event of this repository.
+                BackendEvent::RepoUpdates(updates) => updates.iter().any(|update| {
                     let deletion =
                         update.kind == Kind::EventDeletion || update.kind == Kind::RequestToVanish;
+
                     let coordinate = update.coordinate.as_ref() == Some(addr);
                     let author = update.author == addr.public_key;
-                    let kind = update.kind == Kind::GitRepoAnnouncement;
-                    // NIP-22 comments carry no `a` tag.
-                    // Coordinate matching fails for them.
-                    // Any comment may reference this repository's roots.
+
+                    let authored = (update.kind == Kind::GitRepoAnnouncement
+                        || update.kind == Kind::RepoState)
+                        && author;
+
                     let comment = update.kind == Kind::Comment;
-                    // Status events may omit their `a` tag, NIP-34.
-                    // Any status event may reference a root of this repository.
                     let status = RepoStatus::from_kind(update.kind).is_some();
 
-                    deletion || coordinate || (author && kind) || comment || status
+                    deletion || coordinate || authored || comment || status
                 }),
-                BackendEvent::Published(event) => {
-                    let kind = event.kind == Kind::GitRepoAnnouncement;
-                    let author = event.pubkey == addr.public_key;
-                    let coordinate = event.tags.coordinates().into_iter().any(|c| c == *addr);
-                    // Locally published deletions may target any event of this repository.
-                    // Refresh so they take effect immediately, like relay deletions.
-                    let deletion =
-                        event.kind == Kind::EventDeletion || event.kind == Kind::RequestToVanish;
-
-                    coordinate || (kind && author) || deletion
-                }
                 _ => false,
             };
 
@@ -239,8 +251,6 @@ impl RepoStore {
     /// Announcement, state, activity and deletions targeting it.
     fn repo_filters(addr: &RepoAddr) -> Vec<Filter> {
         let mut filters = vec![
-            // Announcement and state share author and identifier.
-            // They combine into one filter, one fewer negentropy reconciliation per relay.
             Filter::new()
                 .kinds([Kind::GitRepoAnnouncement, Kind::RepoState])
                 .author(addr.public_key)
@@ -270,9 +280,71 @@ impl RepoStore {
         self.repo_relays.extend(new.iter().cloned());
 
         let backend = Backend::global(cx);
+        let filters = Self::repo_filters(&addr);
 
         backend.update(cx, |backend, cx| {
-            backend.connect_repo_relays(new, Self::repo_filters(&addr), cx);
+            backend.connect_repo_relays(new, filters, cx);
+        });
+    }
+
+    /// Filters the SDK resolves through NIP-65 gossip in Uncensored mode.
+    fn maintainer_filters(addr: &RepoAddr, maintainers: &[PublicKey]) -> Vec<Filter> {
+        let mut pubkeys = maintainers.to_vec();
+        // NIP-34 events tag the announcement author,
+        // which may not be a maintainer for subordinate forks.
+        if !pubkeys.contains(&addr.public_key) {
+            pubkeys.push(addr.public_key);
+        }
+
+        vec![
+            // Announcement and state events, including co-maintainer states.
+            Filter::new()
+                .kinds([Kind::GitRepoAnnouncement, Kind::RepoState])
+                .authors(pubkeys.clone())
+                .identifier(addr.identifier.clone()),
+            // Activity tagging a maintainer, resolved to their read relays.
+            Filter::new()
+                .kinds(filters::ACTIVITY_KINDS)
+                .coordinate(addr)
+                .pubkeys(pubkeys.clone()),
+            // Activity authored by a maintainer, resolved to their write relays.
+            Filter::new()
+                .kinds(filters::ACTIVITY_KINDS)
+                .coordinate(addr)
+                .authors(pubkeys.clone()),
+            // Deletions authored by a maintainer.
+            Filter::new()
+                .kinds([Kind::EventDeletion, Kind::RequestToVanish])
+                .authors(pubkeys),
+        ]
+    }
+
+    /// In Uncensored mode, sync the maintainer-shaped filters through the SDK's NIP-65 gossip targeting
+    fn sync_maintainer_relays(&mut self, maintainers: &[PublicKey], cx: &mut Context<Self>) {
+        let strategy = SettingsStore::try_global(cx)
+            .map(|store| store.read(cx).settings().event_fetching)
+            .unwrap_or_default();
+        if strategy != EventFetchingStrategy::Uncensored {
+            return;
+        }
+
+        let Some(addr) = self.addr.clone() else {
+            return;
+        };
+
+        if !maintainers
+            .iter()
+            .any(|public_key| !self.synced_maintainers.contains(public_key))
+        {
+            return;
+        }
+        self.synced_maintainers.extend(maintainers.iter().copied());
+
+        let filters = Self::maintainer_filters(&addr, maintainers);
+        let backend = Backend::global(cx);
+
+        backend.update(cx, |backend, cx| {
+            backend.sync_auto(filters, cx);
         });
     }
 
@@ -289,18 +361,10 @@ impl RepoStore {
     }
 
     /// Re-query the local database and update all fields.
-    ///
-    /// Runs immediately. The backend pump already batches the relay events that
-    /// trigger a refresh, so no per-store debounce is needed.
     pub fn refresh(&mut self, cx: &mut Context<Self>) {
         if self.addr.is_none() {
             return;
         }
-
-        if self.refresh.request() != RefreshRequest::Schedule {
-            return;
-        }
-
         self.run_refresh(cx);
     }
 
@@ -309,8 +373,6 @@ impl RepoStore {
             return;
         };
 
-        self.refresh.begin();
-
         let backend = Backend::global(cx);
         let client = backend.read(cx).client();
 
@@ -328,11 +390,10 @@ impl RepoStore {
 
             let deletions = Deletions::from_events(deletion_events);
 
-            // Parse and sort off the main thread.
-            // Only plain data crosses back into the entity.
             let all_announcements = announcements
                 .into_iter()
                 .filter(|e| !deletions.is_deleted(e));
+
             let announcement = latest(all_announcements)
                 .as_ref()
                 .and_then(Announcement::from_event);
@@ -357,8 +418,6 @@ impl RepoStore {
                 }
             }
 
-            // NIP-22 comments reference their root via an `E` or `e` tag.
-            // Not the repository's `a` tag, so query them by the root events.
             let mut seen_comments: HashSet<EventId> = comments.iter().map(|e| e.id).collect();
             let db = client.database();
 
@@ -376,8 +435,6 @@ impl RepoStore {
                 }
             }
 
-            // Status events may omit their `a` tag.
-            // Query them by the root events they reference too.
             let mut seen_statuses: HashSet<EventId> = statuses.iter().map(|e| e.id).collect();
             let db = client.database();
 
@@ -400,9 +457,6 @@ impl RepoStore {
             sort_newest_first(&mut pull_requests);
             sort_oldest_first(&mut comments);
 
-            // Resolve every root's status once here.
-            // Render paths do HashMap lookups instead of per-root status scans.
-            // Those scans are quadratic, with an allocation per pair.
             let maintainers = announcement
                 .as_ref()
                 .map(Announcement::effective_maintainers)
@@ -437,7 +491,7 @@ impl RepoStore {
             ))
         });
 
-        cx.spawn(async move |this, cx| {
+        let task = cx.spawn(async move |this, cx| {
             let (
                 announcement,
                 state,
@@ -452,33 +506,20 @@ impl RepoStore {
                 Ok(data) => data,
                 Err(e) => {
                     return this.update(cx, |this, cx| {
-                        this.refresh.abort();
                         this.last_error = Some(e.to_string());
                         cx.notify();
                     });
                 }
             };
 
-            let again = this.update(cx, |this, cx| {
-                // Compare before moving the freshly queried data in, so a pass
-                // that found nothing new does not notify observers. The store
-                // is polled in bursts while a sync is in flight; notifying on
-                // every identical pass would re-render the repository panel
-                // several times for no visible change.
-                //
-                // The first pass is the exception: it must notify even when it
-                // found nothing, so views can leave their loading state and show
-                // the empty result.
-                //
-                // Keep the open-time hint until that first pass has confirmed what
-                // the database holds; afterwards the database is the truth,
-                // including a deletion.
+            this.update(cx, |this, cx| {
                 let keep_hint = announcement.is_none() && !this.loaded;
-
                 let first_pass = !this.loaded;
+
                 let head_changed = state
                     .as_ref()
                     .is_some_and(|(_, head)| this.head.as_deref() != head.as_deref());
+
                 let changed = first_pass
                     || (!keep_hint && this.announcement != announcement)
                     || head_changed
@@ -493,14 +534,23 @@ impl RepoStore {
                 }
 
                 // The announcement may list relays for this repository's activity.
-                // Connect to any we have not fetched from yet.
                 let relays = this
                     .announcement
                     .as_ref()
                     .map(|a| a.relays.clone())
                     .unwrap_or_default();
+
                 this.connect_announced_relays(&relays, cx);
 
+                // Uncensored mode also covers the maintainers' NIP-65 relays.
+                let maintainers = this
+                    .announcement
+                    .as_ref()
+                    .map(Announcement::effective_maintainers)
+                    .unwrap_or_default();
+
+                this.sync_maintainer_relays(&maintainers, cx);
+
                 if let Some((_, head)) = state {
                     this.head = head;
                 }
@@ -514,10 +564,6 @@ impl RepoStore {
                 this.open_pr_count = open_pr_count;
                 this.loaded = true;
 
-                // Comments and statuses without an `a` tag.
-                // None are addressed to the repository.
-                // Fetch them by the root events they reference.
-                // Use the bootstrap relays and the relays this repository announced.
                 let roots = this
                     .issues
                     .iter()
@@ -534,13 +580,13 @@ impl RepoStore {
 
                 if !new_roots.is_empty() {
                     this.root_fetches.extend(new_roots.iter().copied());
-                    // Batch the per-root filters.
-                    // One filter per root costs a negentropy reconciliation per relay.
+
                     let mut root_filters = filters::comments_for(new_roots.clone());
                     root_filters.push(filters::statuses_for(new_roots.iter().copied()));
 
                     let announced: Vec<RelayUrl> = this.repo_relays.iter().cloned().collect();
                     let backend = Backend::global(cx);
+
                     backend.update(cx, |backend, cx| {
                         backend.subscribe_bootstrap(root_filters.clone(), cx);
                         backend.connect_repo_relays(announced, root_filters, cx);
@@ -550,19 +596,12 @@ impl RepoStore {
                 if changed {
                     cx.notify();
                 }
-
-                this.refresh.finish()
             })?;
 
-            // Requests that arrived while the refresh was running.
-            // They are coalesced into one follow-up refresh.
-            if again {
-                this.update(cx, |this, cx| this.refresh(cx))?;
-            }
-
             Ok(())
-        })
-        .detach();
+        });
+
+        self.tasks.push(task);
     }
 
     /// Resolve the status of a root event, an issue, patch or PR, per NIP-34.
@@ -571,25 +610,16 @@ impl RepoStore {
     }
 
     /// Number of open issues.
-    ///
-    /// Issues whose resolved status is [`RepoStatus::Open`].
-    /// Issues without status events default to open.
     pub fn issue_count(&self) -> usize {
         self.open_issue_count
     }
 
     /// Number of open pull requests.
-    ///
-    /// Only root PR events count, PR updates do not.
-    /// They must resolve to [`RepoStatus::Open`].
     pub fn pull_request_count(&self) -> usize {
         self.open_pr_count
     }
 
     /// Whether `user` is the author or owner of this repository.
-    ///
-    /// The author is the public key of the repository address.
-    /// Only the author may manage pull requests, close, reopen or merge.
     pub fn is_author(&self, user: &PublicKey) -> bool {
         self.addr
             .as_ref()
@@ -704,9 +734,12 @@ impl RepoStore {
         };
 
         let backend = Backend::global(cx);
-        let signer = backend.read(cx).signer();
+        let (signer, client, user) = {
+            let backend = backend.read(cx);
+            (backend.signer(), backend.client(), backend.current_user())
+        };
 
-        let Some(user) = backend.read(cx).current_user() else {
+        let Some(user) = user else {
             self.last_error = Some("Sign in to open a pull request".into());
             cx.notify();
             return;
@@ -741,12 +774,12 @@ impl RepoStore {
                 .collect()
         };
 
-        cx.spawn(async move |this, cx| {
-            // The PR references the root patch event.
-            // Viewers can then find the patch without carrying it inline.
+        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
+            // The PR references the root patch,
+            // viewers can then find the patch without carrying it inline.
             let root_patch = match publish_patch_series(
-                &this,
-                cx,
+                &client,
+                &signer,
                 &addr,
                 owner,
                 euc.as_deref(),
@@ -771,11 +804,14 @@ impl RepoStore {
             // Resolve the servers from the author's latest kind-10317 grasp list.
             // The settings defaults stand in when no list is published or the query fails.
             let author_servers = {
-                let query = this.update(cx, |_this, cx| {
-                    let client = Backend::global(cx).read(cx).client();
-                    user_grasp_list_servers(client, user)
-                })?;
-                match cx.background_spawn(query).await {
+                let query_client = client.clone();
+                let published = cx
+                    .background_spawn(
+                        async move { user_grasp_list_servers(&query_client, user).await },
+                    )
+                    .await;
+
+                match published {
                     Ok(published) if !published.is_empty() => published,
                     _ => defaults,
                 }
@@ -809,24 +845,17 @@ impl RepoStore {
             };
 
             let builder = this.update(cx, |this, _cx| {
-                // NIP-34 PRs carry at least one clone URL.
-                // The tip commit is downloadable from it.
-                // The author's `/prs/` URLs come first.
-                // They are author-controlled and most likely alive.
-                // The announced mirrors follow.
-                // The list is fixed before signing.
-                // The pushed ref name embeds the event id.
-                // Every candidate URL is listed up front.
-                // Dead URLs are inert, the linked patch stays the source of truth.
                 let prs_urls: Vec<Url> = author_targets
                     .iter()
                     .filter_map(|(url, _)| Url::parse(url).ok())
                     .collect();
+
                 let base_clone = this
                     .announcement
                     .as_ref()
                     .map(|a| a.clone.clone())
                     .unwrap_or_default();
+
                 let clone = pr_clone_urls(prs_urls, base_clone);
 
                 let builder = GitPullRequest {
@@ -851,8 +880,6 @@ impl RepoStore {
             })?;
 
             // Sign before publishing.
-            // The tip is pushed to the grasp servers under `refs/nostr/<event-id>`.
-            // Nak's convention, readers fetch that ref for the commit behind the `c` tag.
             let event = cx
                 .background_spawn({
                     let signer = signer.clone();
@@ -863,20 +890,22 @@ impl RepoStore {
             if let Some(path) = push_from.as_ref() {
                 let tip = current_commit.to_string();
                 let reference = format!("refs/nostr/{}", event.id.to_hex());
+
                 let (pushed, failures) = cx
                     .background_spawn({
                         let path = path.clone();
                         let tip = tip.clone();
                         let reference = reference.clone();
                         // Author servers first, then the announced base grasp servers.
-                        // The extra targets are best-effort redundancy.
                         let targets: Vec<(String, String)> = author_targets
                             .into_iter()
                             .chain(base_targets)
                             .collect();
+
                         async move {
                             let mut failures = Vec::new();
                             let mut pushed = 0;
+
                             for (url, label) in &targets {
                                 match signed_git::push_commit_ref(
                                     &path, url, &tip, &reference,
@@ -885,6 +914,7 @@ impl RepoStore {
                                     Err(e) => failures.push(format!("{label}: {e}")),
                                 }
                             }
+
                             (pushed, failures)
                         }
                     })
@@ -901,8 +931,6 @@ impl RepoStore {
                 }
             }
 
-            let client = this.update(cx, |_this, cx| Backend::global(cx).read(cx).client())?;
-
             let publish_result: Result<Event, Error> = async {
                 let output = client.send_event(&event).broadcast().await?;
                 require_relay_accepted(output, event)
@@ -919,11 +947,6 @@ impl RepoStore {
                 }
             };
 
-            this.update(cx, |_this, cx| {
-                Backend::global(cx)
-                    .update(cx, |backend, cx| backend.announce_published(pr_event.clone(), cx))
-            })?;
-
             // A draft PR carries a kind-1633 status event, NIP-34.
             // Publish it right after the PR event so viewers never show it open.
             if draft {
@@ -933,8 +956,8 @@ impl RepoStore {
             }
 
             Ok(())
-        })
-        .detach();
+        });
+        self.tasks.push(task);
     }
 
     /// Generate the patch between `merge_base` and `compare_ref` in `repo_path`,
@@ -998,8 +1021,12 @@ impl RepoStore {
         self.last_warning = None;
 
         let backend = Backend::global(cx);
+        let (user, client, signer) = {
+            let backend = backend.read(cx);
+            (backend.current_user(), backend.client(), backend.signer())
+        };
 
-        let Some(user) = backend.read(cx).current_user() else {
+        let Some(user) = user else {
             self.last_error = Some("Sign in to update the pull request".into());
             cx.notify();
             return;
@@ -1053,19 +1080,21 @@ impl RepoStore {
             self.not_announced(cx);
             return;
         };
+
         let owner = addr.public_key;
         let euc = self.announcement.as_ref().and_then(|a| a.euc.clone());
         let root = root.clone();
+
         let clone: Vec<Url> = self
             .announcement
             .as_ref()
             .map(|a| a.clone.clone())
             .unwrap_or_default();
 
-        cx.spawn(async move |this, cx| {
+        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
             if let Err(e) = publish_patch_series(
-                &this,
-                cx,
+                &client,
+                &signer,
                 &addr,
                 owner,
                 euc.as_deref(),
@@ -1081,7 +1110,7 @@ impl RepoStore {
                 });
             }
 
-            let builder = this.update(cx, |_this, _cx| {
+            let builder = {
                 let builder = GitPullRequestUpdate {
                     repository: addr.clone(),
                     pull_request_event: root.id,
@@ -1098,13 +1127,7 @@ impl RepoStore {
                     Some(euc) => builder.tag(Tag::parse(["r", euc]).expect("valid r tag")),
                     None => builder,
                 }
-            })?;
-
-            let (client, signer) = this.update(cx, |_this, cx| {
-                let backend = Backend::global(cx);
-                let backend = backend.read(cx);
-                (backend.client(), backend.signer())
-            })?;
+            };
 
             let publish_result: Result<Event, Error> = async {
                 let event = builder.finalize_async(&signer).await?;
@@ -1113,25 +1136,16 @@ impl RepoStore {
             }
             .await;
 
-            match publish_result {
-                Ok(event) => {
-                    this.update(cx, |_this, cx| {
-                        Backend::global(cx).update(cx, |backend, cx| {
-                            backend.announce_published(event.clone(), cx)
-                        })
-                    })?;
-                }
-                Err(e) => {
-                    return this.update(cx, |this, cx| {
-                        this.last_error = Some(e.to_string());
-                        cx.notify();
-                    });
-                }
+            if let Err(e) = publish_result {
+                return this.update(cx, |this, cx| {
+                    this.last_error = Some(e.to_string());
+                    cx.notify();
+                });
             }
 
             Ok(())
-        })
-        .detach();
+        });
+        self.tasks.push(task);
     }
 
     /// Set the status of a root event.
@@ -1257,7 +1271,7 @@ impl RepoStore {
             }
             Ok(())
         });
-        task.detach();
+        self.tasks.push(task);
     }
 
     /// The latest announcement of this repository,
@@ -1564,24 +1578,16 @@ impl RepoStore {
             }
             .await;
 
-            match publish_result {
-                Ok(event) => {
-                    this.update(cx, |_this, cx| {
-                        Backend::global(cx)
-                            .update(cx, |backend, cx| backend.announce_published(event, cx))
-                    })?;
-                }
-                Err(e) => {
-                    this.update(cx, |this, cx| {
-                        this.last_error = Some(e.to_string());
-                        cx.notify();
-                    })?;
-                }
+            if let Err(e) = publish_result {
+                this.update(cx, |this, cx| {
+                    this.last_error = Some(e.to_string());
+                    cx.notify();
+                })?;
             }
 
             Ok(())
         });
-        task.detach();
+        self.tasks.push(task);
     }
 }
 
@@ -1651,8 +1657,8 @@ fn patch_current_commit(patch: &str) -> Option<&str> {
 /// Returns the root event, the one a PR references.
 #[allow(clippy::too_many_arguments)]
 async fn publish_patch_series(
-    this: &WeakEntity<RepoStore>,
-    cx: &mut AsyncApp,
+    client: &Client,
+    signer: &UniversalSigner,
     addr: &RepoAddr,
     owner: PublicKey,
     euc: Option<&str>,
@@ -1660,12 +1666,6 @@ async fn publish_patch_series(
     first_marker: &str,
     reply_to: Option<EventId>,
 ) -> Result<Event, Error> {
-    let (client, signer) = this.update(cx, |_this, cx| {
-        let backend = Backend::global(cx);
-        let backend = backend.read(cx);
-        (backend.client(), backend.signer())
-    })?;
-
     let mut root: Option<Event> = None;
     let mut previous = reply_to;
 
@@ -1678,6 +1678,7 @@ async fn publish_patch_series(
         };
 
         let mut tags = vec![Tag::coordinate(addr.clone(), None), Tag::public_key(owner)];
+
         if ix == 0 {
             if let Ok(tag) = Tag::parse(["t", first_marker]) {
                 tags.push(tag);
@@ -1692,28 +1693,25 @@ async fn publish_patch_series(
         {
             tags.push(tag);
         }
+
         if let Some(euc) = euc
             && let Ok(tag) = Tag::parse(["r", euc])
         {
             tags.push(tag);
         }
+
         if let Ok(tag) = Tag::parse(["commit", commit]) {
             tags.push(tag);
         }
+
         if let Ok(tag) = Tag::parse(["r", commit]) {
             tags.push(tag);
         }
 
         let builder = EventBuilder::new(Kind::GitPatch, part.clone()).tags(tags);
-
-        let event = builder.finalize_async(&signer).await?;
+        let event = builder.finalize_async(signer).await?;
         let output = client.send_event(&event).broadcast().await?;
         let event = require_relay_accepted(output, event)?;
-        this.update(cx, |_this, cx| {
-            Backend::global(cx).update(cx, |backend, cx| {
-                backend.announce_published(event.clone(), cx)
-            })
-        })?;
 
         if root.is_none() {
             root = Some(event.clone());
@@ -1752,9 +1750,11 @@ fn comment_builder(
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashSet;
+
     use nostr_sdk::prelude::*;
 
-    use super::{comment_builder, patch_current_commit};
+    use super::{RepoStore, comment_builder, patch_current_commit};
 
     #[test]
     fn parses_format_patch_header() {
@@ -1800,4 +1800,60 @@ mod tests {
         // Signed's own `references_root` must keep matching the comment.
         assert!(signed_core::references_root(&event, &root.id));
     }
+
+    #[test]
+    fn maintainer_filters_name_owner_and_maintainers() {
+        let owner = Keys::generate().public_key();
+        let maintainer = Keys::generate().public_key();
+        let addr = Coordinate::new(Kind::GitRepoAnnouncement, owner).identifier("my-repo");
+
+        // The owner is not among the maintainers, as on a subordinate fork.
+        let filters = RepoStore::maintainer_filters(&addr, &[maintainer]);
+        assert_eq!(filters.len(), 4);
+
+        let expected = HashSet::from([owner, maintainer]);
+
+        // Gossip only resolves pubkeys from `authors` and the lowercase `#p` tag.
+        let named = |filter: &Filter| -> HashSet<PublicKey> {
+            let authors = filter.authors.iter().flatten().copied();
+            let p_tag = filter
+                .generic_tags
+                .get(&SingleLetterTag::LOWERCASE_P)
+                .into_iter()
+                .flatten()
+                .filter_map(|value| PublicKey::from_hex(value).ok());
+            authors.chain(p_tag).collect()
+        };
+
+        // Announcement and state events, scoped to the repository identifier.
+        let announcement = &filters[0];
+        assert_eq!(named(announcement), expected);
+        assert!(
+            announcement
+                .generic_tags
+                .contains_key(&SingleLetterTag::LOWERCASE_D)
+        );
+
+        // Activity filters, scoped to the repository coordinate.
+        for filter in &filters[1..3] {
+            assert_eq!(named(filter), expected);
+            assert!(
+                filter
+                    .generic_tags
+                    .contains_key(&SingleLetterTag::LOWERCASE_A)
+            );
+        }
+
+        // Deletions, named by author only.
+        let deletions = &filters[3];
+        assert_eq!(
+            deletions
+                .authors
+                .clone()
+                .unwrap_or_default()
+                .into_iter()
+                .collect::<HashSet<_>>(),
+            expected
+        );
+    }
 }

crates/signed_state/src/repos.rs

@@ -1,116 +1,15 @@
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::Error;
-use gpui::{App, AppContext, Context, Entity, Global, Subscription, Task};
+use gpui::{App, AppContext, Context, Entity, Global, Subscription};
 use nostr_sdk::prelude::*;
 use signed_core::{Announcement, Deletions, RepoAddr, filters, repo_addr};
-use signed_git::find_git_repos;
 
 use crate::backend::{Backend, BackendEvent};
 use crate::refresh::{RefreshGate, RefreshRequest};
 
-struct GlobalLocalReposStore(Entity<LocalReposStore>);
-
-impl Global for GlobalLocalReposStore {}
-
-/// Store of the git repositories discovered under a set of scan paths.
-pub struct LocalReposStore {
-    pub roots: Arc<Vec<PathBuf>>,
-    /// Git repositories discovered under [`Self::roots`], sorted by path.
-    pub repos: Arc<Vec<PathBuf>>,
-    pub scanning: bool,
-    scan_dirty: bool,
-}
-
-impl LocalReposStore {
-    pub fn global(cx: &App) -> Entity<Self> {
-        cx.global::<GlobalLocalReposStore>().0.clone()
-    }
-
-    pub(crate) fn set_global(entity: Entity<Self>, cx: &mut App) {
-        cx.set_global(GlobalLocalReposStore(entity));
-    }
-
-    pub fn new(roots: Vec<PathBuf>, cx: &mut Context<Self>) -> Self {
-        let weak = cx.entity().downgrade();
-        cx.defer(move |cx| {
-            if let Err(error) = weak.update(cx, |this, cx| this.rescan(cx)) {
-                log::warn!("local repos store dropped before initial scan could run: {error}");
-            }
-        });
-
-        Self {
-            roots: Arc::new(roots),
-            repos: Arc::new(Vec::new()),
-            scanning: false,
-            scan_dirty: false,
-        }
-    }
-
-    /// Forget a repository that has just been published to NIP-34.
-    pub fn remove(&mut self, path: &Path, cx: &mut Context<Self>) {
-        self.repos = Arc::new(
-            self.repos
-                .iter()
-                .filter(|repo| repo.as_path() != path)
-                .cloned()
-                .collect(),
-        );
-        cx.notify();
-    }
-
-    pub fn rescan(&mut self, cx: &mut Context<Self>) {
-        if self.scanning {
-            self.scan_dirty = true;
-            return;
-        }
-
-        if self.roots.is_empty() {
-            return;
-        }
-
-        self.scanning = true;
-        cx.notify();
-
-        let roots = self.roots.clone();
-
-        let work = cx.background_spawn(async move {
-            let mut repos = Vec::new();
-            for root in roots.iter() {
-                repos.extend(find_git_repos(root));
-            }
-            repos.sort();
-            repos.dedup();
-            repos
-        });
-
-        let task: Task<Result<(), Error>> = cx.spawn(async move |this, cx| {
-            let repos = work.await;
-            let again = this.update(cx, |this, cx| {
-                this.repos = Arc::new(repos);
-                this.scanning = false;
-                cx.notify();
-
-                let dirty = this.scan_dirty;
-                this.scan_dirty = false;
-                dirty
-            })?;
-
-            // Scans requested while this one ran are coalesced into one follow-up scan.
-            if again {
-                this.update(cx, |this, cx| this.rescan(cx))?;
-            }
-
-            Ok(())
-        });
-
-        task.detach();
-    }
-}
-
 /// How far back activity events count toward a repository's last activity.
 const ACTIVITY_WINDOW: Duration = Duration::from_secs(90 * 86_400);
 
@@ -148,6 +47,8 @@ pub struct RepoListStore {
     ///
     /// Used for the Popular ranking of the explore list.
     pub counts: Arc<HashMap<RepoAddr, RepoActivityCounts>>,
+    /// Own repositories whose state events were fetched from their announced relays.
+    state_synced_repos: HashSet<RepoAddr>,
     refresh: RefreshGate,
     _subscription: Subscription,
 }
@@ -167,33 +68,11 @@ impl RepoListStore {
 
         let subscription = cx.subscribe(&backend, |this, _backend, event, cx| {
             let relevant = match event {
-                BackendEvent::NostrUpdate(updates) => updates.iter().any(|update| {
-                    // Deletions may target anything we list, always refresh.
-                    if update.kind == Kind::EventDeletion || update.kind == Kind::RequestToVanish {
-                        true
-                    } else if filters::ACTIVITY_KINDS.contains(&update.kind) {
-                        // Activity events are addressed to repos via `a` tags.
-                        // Their author is not the repo owner, always refresh.
-                        true
-                    } else {
-                        let is_announcement = update.kind == Kind::GitRepoAnnouncement;
-                        let is_repo_state = update.kind == Kind::RepoState;
-                        is_announcement || is_repo_state
-                    }
-                }),
-                BackendEvent::Published(event) => {
-                    let announcement = event.kind == Kind::GitRepoAnnouncement;
-
-                    // Locally published deletions are already in the local database.
-                    // Refresh so they take effect immediately, like relay deletions.
-                    let deletion =
-                        event.kind == Kind::EventDeletion || event.kind == Kind::RequestToVanish;
-
-                    announcement || deletion
+                BackendEvent::SignerChanged => {
+                    this.state_synced_repos.clear();
+                    true
                 }
-                // Only a completed sync refreshes the list.
-                // Progress ticks would re-scan the whole database several times
-                // per sync to reveal entries incrementally.
+                BackendEvent::RepoUpdates(_) => true,
                 BackendEvent::Synced => true,
                 _ => false,
             };
@@ -215,6 +94,7 @@ impl RepoListStore {
             announcements: Arc::new(Vec::new()),
             last_activity: Arc::new(HashMap::new()),
             counts: Arc::new(HashMap::new()),
+            state_synced_repos: HashSet::new(),
             refresh: RefreshGate::default(),
             _subscription: subscription,
         }
@@ -233,12 +113,42 @@ impl RepoListStore {
         let backend = Backend::global(cx);
 
         backend.update(cx, |backend, cx| {
-            backend.sync_bootstrap(filters::all_announcements(), cx);
-            // Deletion requests, NIP-09/62, must be known before any announcement is shown.
-            backend.sync_bootstrap(filters::deletions(), cx);
+            backend.sync_bootstraps(
+                vec![
+                    filters::all_announcements(),
+                    filters::all_states(),
+                    // Deletion requests, NIP-09/62, must be known before any announcement is shown.
+                    filters::deletions(),
+                ],
+                cx,
+            );
         });
     }
 
+    /// Fetch the state events of the user's own repositories.
+    fn sync_own_repo_states(&mut self, cx: &mut Context<Self>) {
+        let backend = Backend::global(cx);
+        let Some(me) = backend.read(cx).current_user() else {
+            return;
+        };
+
+        let pending: Vec<(RepoAddr, Vec<RelayUrl>)> = self
+            .announcements
+            .iter()
+            .filter(|announcement| announcement.owner == me && !announcement.relays.is_empty())
+            .map(|announcement| (announcement.addr(), announcement.relays.clone()))
+            .filter(|(addr, _)| !self.state_synced_repos.contains(addr))
+            .collect();
+
+        for (addr, relays) in pending {
+            self.state_synced_repos.insert(addr.clone());
+
+            backend.update(cx, |backend, cx| {
+                backend.connect_repo_relays(relays, vec![filters::state(&addr)], cx);
+            });
+        }
+    }
+
     /// Re-query the local database.
     ///
     /// Runs immediately. The backend pump already batches the relay events that
@@ -290,9 +200,6 @@ impl RepoListStore {
             let mut announcements: Vec<Announcement> = by_repo.into_values().collect();
             announcements.sort_by_key(|a| std::cmp::Reverse(a.created_at));
 
-            // Last activity per repository.
-            // State updates count, and all NIP-34 activity events.
-            // The activity events are patches, PRs, issues and statuses.
             let mut last_activity: HashMap<RepoAddr, Timestamp> = announcements
                 .iter()
                 .map(|a| (a.addr(), a.created_at))
@@ -318,6 +225,7 @@ impl RepoListStore {
             let activity_filter = Filter::new()
                 .kinds(filters::ACTIVITY_KINDS)
                 .since(Timestamp::now() - ACTIVITY_WINDOW);
+
             for event in client.database().query(activity_filter).await? {
                 if deletions.is_deleted(&event) {
                     continue;
@@ -326,8 +234,6 @@ impl RepoListStore {
                     if addr.kind != Kind::GitRepoAnnouncement {
                         continue;
                     }
-                    // Skip events for repos we do not list.
-                    // The map cannot grow beyond the number of announcements.
                     let Some(entry) = last_activity.get_mut(&addr) else {
                         continue;
                     };
@@ -340,13 +246,12 @@ impl RepoListStore {
             let mut counts: HashMap<RepoAddr, RepoActivityCounts> = HashMap::new();
             let count_filter =
                 Filter::new().kinds([Kind::GitIssue, Kind::GitPullRequest, Kind::GitPatch]);
+
             for event in client.database().query(count_filter).await? {
                 if deletions.is_deleted(&event) {
                     continue;
                 }
                 for addr in event.tags.coordinates() {
-                    // Skip events for repos we do not list.
-                    // The map cannot grow beyond the number of announcements.
                     if addr.kind != Kind::GitRepoAnnouncement || !last_activity.contains_key(&addr)
                     {
                         continue;
@@ -379,6 +284,7 @@ impl RepoListStore {
                 this.announcements = Arc::new(announcements);
                 this.last_activity = Arc::new(last_activity);
                 this.counts = Arc::new(counts);
+                this.sync_own_repo_states(cx);
                 cx.notify();
 
                 this.refresh.finish()

crates/signed_ui/src/avatar.rs

@@ -1,21 +1,26 @@
 use gpui::prelude::*;
 use gpui::{App, SharedString, StyleRefinement, Window};
-use gpui_component::avatar::Avatar;
+use gpui_base::{Avatar as BaseAvatar, AvatarFallback, AvatarImage};
 use gpui_component::{ActiveTheme, Sizable, Size, StyledExt};
 
-/// A small user avatar from gpui-component [`Avatar`], rounded with the theme radius.
-/// It shows the user's picture or falls back to name initials.
+use crate::pixel_avatar::{PixelAvatar, side_length};
+
+/// A user avatar built on the unstyled [`gpui_base::Avatar`].
+///
+/// It shows the user's picture when one is set, and falls back to the
+/// deterministic pixel avatar seeded from the name otherwise.
 #[derive(IntoElement)]
-pub struct UserAvatar {
+pub struct Avatar {
     name: SharedString,
     picture: Option<SharedString>,
     size: Size,
     style: StyleRefinement,
 }
 
-impl UserAvatar {
+impl Avatar {
     /// Create an avatar for `name`.
-    /// The name seeds the initials fallback shown when no picture is set.
+    ///
+    /// The name seeds the pixel fallback shown when no picture is set.
     pub fn new(name: impl Into<SharedString>) -> Self {
         Self {
             name: name.into(),
@@ -32,26 +37,35 @@ impl UserAvatar {
     }
 }
 
-impl Sizable for UserAvatar {
+impl Sizable for Avatar {
     fn with_size(mut self, size: impl Into<Size>) -> Self {
         self.size = size.into();
         self
     }
 }
 
-impl Styled for UserAvatar {
+impl Styled for Avatar {
     fn style(&mut self) -> &mut StyleRefinement {
         &mut self.style
     }
 }
 
-impl RenderOnce for UserAvatar {
+impl RenderOnce for Avatar {
     fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        Avatar::new()
-            .name(self.name)
-            .when_some(self.picture, |this, url| this.src(url))
+        let fallback = AvatarFallback::new()
+            .size_full()
+            .child(PixelAvatar::new(self.name.clone()).size_full());
+
+        BaseAvatar::new()
+            .size(side_length(self.size))
+            .flex_shrink_0()
             .rounded(cx.theme().radius)
+            .overflow_hidden()
+            .bg(cx.theme().secondary)
+            .when_some(self.picture, |this, url| {
+                this.image(AvatarImage::new(url).size_full().rounded(cx.theme().radius))
+            })
+            .fallback(fallback)
             .refine_style(&self.style)
-            .with_size(self.size)
     }
 }

crates/signed_ui/src/lib.rs

@@ -1,3 +1,4 @@
+mod avatar;
 mod dropdown_button;
 mod nav_item;
 mod pixel_avatar;
@@ -8,11 +9,11 @@ mod setting;
 mod status_badge;
 mod title_bar;
 mod tree_row;
-mod user_avatar;
 
 pub mod copy_row;
 pub mod util;
 
+pub use avatar::Avatar;
 pub use copy_row::{copy_row, menu_copy_row};
 pub use dropdown_button::DropdownButton;
 pub use nav_item::NavItem;
@@ -24,5 +25,4 @@ pub use setting::{SelectOption, setting_block, setting_row};
 pub use status_badge::status_badge;
 pub use title_bar::title_bar_drag_handlers;
 pub use tree_row::tree_row;
-pub use user_avatar::UserAvatar;
 pub use util::middle_truncate;

crates/signed_ui/src/pixel_avatar.rs

@@ -1,43 +1,46 @@
 use gpui::prelude::*;
 use gpui::{App, Pixels, StyleRefinement, Window, div, px};
 use gpui_base::StyledExt;
-use gpui_component::{ActiveTheme, Colorize};
+use gpui_component::{ActiveTheme, Colorize, Sizable, Size};
 
 /// Number of rows and columns in the pixel grid.
 const GRID_SIZE: usize = 8;
-/// Probability that a cell in the left half is filled.
+/// Empty cells kept between the pattern and the avatar edge, so the art
+/// gathers in the center instead of filling the whole avatar.
+const MARGIN: usize = 1;
+/// Probability that a cell in the left half of the pattern area is filled.
 const FILL_PROBABILITY: f32 = 0.42;
 /// Probability that a filled cell uses the accent shade instead of the main color.
 const ACCENT_PROBABILITY: f32 = 0.25;
 /// Minimum number of filled left-half cells.
-/// A sparse roll still yields a recognizable shape.
-/// Each left-half cell is mirrored to a right-half one.
 const MIN_FILLED: usize = 5;
 
-/// Side length of the avatar in pixels, no setter.
-const AVATAR_SIZE: Pixels = px(16.);
-
 /// A deterministic, offline pixel-art avatar.
-/// An 8×8 grid with horizontal mirror symmetry.
-/// Seeded from a stable string such as the repository id and owner public key.
-/// The same seed always renders the same avatar.
 #[derive(IntoElement)]
 pub struct PixelAvatar {
     seed: u64,
+    size: Size,
     style: StyleRefinement,
 }
 
 impl PixelAvatar {
     /// Create an avatar seeded from `seed`.
-    /// The seed should be a stable string unique to the entity the avatar represents.
     pub fn new(seed: impl AsRef<str>) -> Self {
         Self {
             seed: fnv1a(seed.as_ref().as_bytes()),
+            size: Size::Small,
             style: StyleRefinement::default(),
         }
     }
 }
 
+impl Sizable for PixelAvatar {
+    fn with_size(mut self, size: impl Into<Size>) -> Self {
+        self.size = size.into();
+        self
+    }
+}
+
 impl Styled for PixelAvatar {
     fn style(&mut self) -> &mut StyleRefinement {
         &mut self.style
@@ -48,16 +51,17 @@ impl RenderOnce for PixelAvatar {
     fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
         let theme = cx.theme();
         let pattern = pattern(self.seed);
+        let mut cells = Vec::new();
 
         let hue = self.seed as f32 / u64::MAX as f32;
         let main = theme.blue.hue(hue);
+
         let shade = if theme.is_dark() {
             main.lightness((main.l * 1.6).min(0.95))
         } else {
             main.lightness((main.l * 0.45).max(0.18))
         };
 
-        let mut cells = Vec::new();
         for row in 0..GRID_SIZE {
             for col in 0..GRID_SIZE {
                 let value = pattern[row * GRID_SIZE + col];
@@ -76,28 +80,42 @@ impl RenderOnce for PixelAvatar {
         }
 
         div()
-            .refine_style(&self.style)
             .grid()
             .grid_cols(GRID_SIZE as u16)
             .grid_rows(GRID_SIZE as u16)
-            .size(AVATAR_SIZE)
+            .size(side_length(self.size))
             .flex_shrink_0()
+            .rounded(theme.radius)
             .overflow_hidden()
             .bg(main.opacity(0.16))
             .children(cells)
+            .refine_style(&self.style)
+    }
+}
+
+/// The rendered side length of an avatar at `size`, shared with [`Avatar`].
+pub(crate) fn side_length(size: Size) -> Pixels {
+    match size {
+        Size::XSmall => px(16.),
+        Size::Small => px(24.),
+        Size::Medium => px(48.),
+        Size::Large => px(80.),
+        Size::Size(size) => size,
     }
 }
 
-/// Generate the 8×8 cell pattern for `seed`.
-/// Cells are `0` for empty, `1` for main color and `2` for accent shade.
-/// The right half mirrors the left half.
 fn pattern(seed: u64) -> [u8; GRID_SIZE * GRID_SIZE] {
     let mut rng = PixelRng::new(seed);
     let mut pattern = [0u8; GRID_SIZE * GRID_SIZE];
     let mut filled = 0usize;
 
-    for row in 0..GRID_SIZE {
-        for col in 0..GRID_SIZE / 2 {
+    // Only the inner rows and the inner left half are candidates; mirroring
+    // then keeps the art within the same inset, leaving the outer ring empty.
+    let art_rows = GRID_SIZE - 2 * MARGIN;
+    let art_columns = GRID_SIZE / 2 - MARGIN;
+
+    for row in MARGIN..GRID_SIZE - MARGIN {
+        for col in MARGIN..GRID_SIZE / 2 {
             if rng.chance(FILL_PROBABILITY) {
                 let accent = rng.chance(ACCENT_PROBABILITY);
                 set_cell(&mut pattern, row, col, if accent { 2 } else { 1 });
@@ -106,18 +124,19 @@ fn pattern(seed: u64) -> [u8; GRID_SIZE * GRID_SIZE] {
         }
     }
 
-    // Sparse rolls can come out nearly empty.
-    // Top the pattern up to the minimum fill, scanning from a seeded starting cell.
     if filled < MIN_FILLED {
-        let half = GRID_SIZE * GRID_SIZE / 2;
-        let start = (rng.next() % half as u64) as usize;
-        for offset in 0..half {
+        let total = art_rows * art_columns;
+        let start = (rng.next() % total as u64) as usize;
+
+        for offset in 0..total {
             if filled >= MIN_FILLED {
                 break;
             }
-            let ix = (start + offset) % half;
-            let row = ix / (GRID_SIZE / 2);
-            let col = ix % (GRID_SIZE / 2);
+
+            let ix = (start + offset) % total;
+            let row = MARGIN + ix / art_columns;
+            let col = MARGIN + ix % art_columns;
+
             if pattern[row * GRID_SIZE + col] == 0 {
                 set_cell(&mut pattern, row, col, 1);
                 filled += 1;

crates/workspace/src/views/commit_diff/mod.rs

@@ -18,10 +18,12 @@ use gpui_component::{
     ActiveTheme, Sizable, StyledExt, VirtualListScrollHandle, h_flex, v_flex, v_virtual_list,
 };
 use signed_git::{CommitDiff, DiffHunk, DiffLine, DiffLineKind, DiffStatus, FileCommit, FileDiff};
+use signed_state::RepoStore;
 use signed_ui::{placeholder, tree_row};
 use utils::relative_time_secs;
 
 use crate::views::tree::{build_tree_items, tree_items};
+use crate::views::{repo_tab_avatar, tab_title};
 
 const TREE_WIDTH: f32 = 260.;
 
@@ -293,6 +295,7 @@ impl Render for DiffPane {
 
 pub struct CommitDiffView {
     focus_handle: FocusHandle,
+    store: Entity<RepoStore>,
     worktree: PathBuf,
     repo_name: SharedString,
     commit: FileCommit,
@@ -300,10 +303,12 @@ pub struct CommitDiffView {
     loading: bool,
     error: Option<SharedString>,
     pane: Entity<DiffPane>,
+    tasks: Vec<gpui::Task<Result<(), anyhow::Error>>>,
 }
 
 impl CommitDiffView {
     pub fn new(
+        store: Entity<RepoStore>,
         worktree: PathBuf,
         repo_name: SharedString,
         commit_id: String,
@@ -319,6 +324,7 @@ impl CommitDiffView {
 
         Self {
             focus_handle: cx.focus_handle(),
+            store,
             worktree,
             repo_name,
             commit: FileCommit {
@@ -331,6 +337,7 @@ impl CommitDiffView {
             loading: true,
             error: None,
             pane,
+            tasks: Vec::new(),
         }
     }
 
@@ -378,7 +385,7 @@ impl CommitDiffView {
                 Ok(())
             });
 
-        task.detach();
+        self.tasks.push(task);
     }
 
     fn render_header(&self, cx: &mut Context<Self>) -> AnyElement {
@@ -465,11 +472,11 @@ impl BasePanel for CommitDiffView {
 }
 
 impl Panel for CommitDiffView {
-    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().text_sm().child(SharedString::from(format!(
-            "{}/{}",
-            self.repo_name, self.commit.id
-        )))
+    fn title(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let avatar = repo_tab_avatar(self.store.read(cx), cx);
+        let label = SharedString::from(format!("{}/{}", self.repo_name, self.commit.id));
+
+        tab_title(avatar, label)
     }
 }
 

crates/workspace/src/views/discussion.rs

@@ -7,7 +7,7 @@ use gpui_component::tag::Tag;
 use gpui_component::{ActiveTheme, Icon, Sizable, StyledExt, h_flex, v_flex};
 use nostr::prelude::{Event, EventId, PublicKey};
 use signed_state::{ProfileStore, RepoStore};
-use signed_ui::UserAvatar;
+use signed_ui::Avatar;
 use utils::relative_time;
 
 pub(crate) fn issue_roots(store: &RepoStore) -> &[Event] {
@@ -71,7 +71,7 @@ pub(crate) fn sidebar_section(
                     h_flex()
                         .gap_1()
                         .items_center()
-                        .child(UserAvatar::new(name.clone()).picture(picture))
+                        .child(Avatar::new(name.clone()).picture(picture))
                         .child(div().text_sm().truncate().text_ellipsis().child(name))
                         .into_any_element()
                 })),
@@ -137,7 +137,7 @@ pub(crate) fn comments_section(store: &Entity<RepoStore>, root: EventId, cx: &Ap
                         .child(
                             h_flex()
                                 .gap_1()
-                                .child(UserAvatar::new(author.clone()).picture(picture))
+                                .child(Avatar::new(author.clone()).picture(picture))
                                 .child(author),
                         )
                         .child(

crates/workspace/src/views/inbox.rs

@@ -11,14 +11,14 @@ use gpui::{
 use gpui_component::button::{Button, ButtonVariants};
 use gpui_component::{ActiveTheme, Icon, IconName, IconNamed, Sizable, StyledExt, h_flex, v_flex};
 use nostr::prelude::{Event, EventId, Kind, PublicKey, Timestamp};
-use signed_core::{COVER_NOTE_KIND, InboxItem, InboxReadState, RepoAddr, filters};
+use signed_core::{InboxItem, InboxReadState, RepoAddr};
 use signed_state::{
     Backend, BackendEvent, ProfileStore, RefreshGate, RefreshRequest, RepoListStore, query_inbox,
 };
-use signed_ui::{CountBadge, UserAvatar};
+use signed_ui::{Avatar, CountBadge};
 use utils::relative_time;
 
-use super::{RepoItem, open_repo_item};
+use super::{RepoItem, open_repo_item, panel_avatar, tab_title};
 
 const LIST_OVERDRAW: Pixels = px(400.);
 const MAX_SUB_ACTIVITIES: usize = 5;
@@ -157,21 +157,8 @@ impl InboxView {
 
     fn handle_backend_event(&mut self, event: &BackendEvent, cx: &mut Context<Self>) {
         match event {
-            BackendEvent::NostrUpdate(updates) => {
-                let relevant = updates.iter().any(|update| {
-                    let is_notification = filters::NOTIFICATION_KINDS.contains(&update.kind);
-                    let is_comment = update.kind == Kind::Comment;
-                    let is_event_deletion = update.kind == Kind::EventDeletion;
-                    let is_request_to_vanish = update.kind == Kind::RequestToVanish;
-
-                    is_notification || is_comment || is_event_deletion || is_request_to_vanish
-                });
-
-                if relevant {
-                    self.refresh(cx);
-                }
-            }
-            BackendEvent::Synced | BackendEvent::Published(_) => self.refresh(cx),
+            BackendEvent::RepoUpdates(_) => self.refresh(cx),
+            BackendEvent::Synced => self.refresh(cx),
             _ => {}
         }
     }
@@ -200,12 +187,16 @@ impl InboxView {
         self.refresh.begin();
 
         let backend = Backend::global(cx);
-        let Some(me) = backend.read(cx).current_user() else {
+        let (me, client) = {
+            let backend = backend.read(cx);
+            (backend.current_user(), backend.client())
+        };
+
+        let Some(me) = me else {
             self.refresh.abort();
             return;
         };
 
-        let client = backend.read(cx).client();
         let state = self.state.clone();
 
         let work = cx.background_spawn(async move { query_inbox(&client, me, &state).await });
@@ -553,7 +544,7 @@ fn sub_activity(event: &Event, me: Option<PublicKey>, cx: &App) -> AnyElement {
                 .items_center()
                 .text_xs()
                 .child(
-                    UserAvatar::new(name.clone())
+                    Avatar::new(name.clone())
                         .picture(profile.picture())
                         .xsmall(),
                 )
@@ -570,10 +561,6 @@ fn sub_activity(event: &Event, me: Option<PublicKey>, cx: &App) -> AnyElement {
 }
 
 fn activity_phrase(kind: Kind) -> &'static str {
-    if kind == COVER_NOTE_KIND {
-        return "added a note";
-    }
-
     match kind {
         Kind::GitIssue => "opened an issue",
         Kind::GitPullRequest => "opened a PR",
@@ -619,7 +606,7 @@ impl BasePanel for InboxView {
 
 impl Panel for InboxView {
     fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().text_sm().child(SharedString::from("Inbox"))
+        tab_title(panel_avatar("inbox"), SharedString::from("Inbox"))
     }
 }
 

crates/workspace/src/views/issues/detail.rs

@@ -10,10 +10,11 @@ use gpui_component::{ActiveTheme, StyledExt, h_flex, v_flex};
 use nostr::prelude::EventId;
 use signed_core::activity_subject;
 use signed_state::{ProfileStore, RepoStore};
-use signed_ui::{UserAvatar, placeholder, status_badge};
+use signed_ui::{Avatar, placeholder, status_badge};
 use utils::relative_time;
 
 use crate::views::discussion::{comment_form, comments_section, issue_roots, sidebar_section};
+use crate::views::{repo_tab_avatar, tab_title};
 
 pub struct IssueDetailView {
     focus_handle: FocusHandle,
@@ -65,7 +66,9 @@ impl Panel for IssueDetailView {
             })
             .unwrap_or_else(|| SharedString::from("Issue"));
 
-        div().text_sm().child(short_id)
+        let avatar = repo_tab_avatar(self.store.read(cx), cx);
+
+        tab_title(avatar, short_id)
     }
 }
 
@@ -150,9 +153,7 @@ impl Render for IssueDetailView {
                                             .child(
                                                 h_flex()
                                                     .gap_1()
-                                                    .child(
-                                                        UserAvatar::new(&author).picture(picture),
-                                                    )
+                                                    .child(Avatar::new(&author).picture(picture))
                                                     .child(author),
                                             )
                                             .child(

crates/workspace/src/views/issues/mod.rs

@@ -18,13 +18,14 @@ use gpui_component::{
 use nostr::prelude::EventId;
 use signed_core::{RepoStatus, activity_subject};
 use signed_state::{ProfileStore, RepoStore};
-use signed_ui::{SegmentButton, UserAvatar, placeholder, status_badge};
+use signed_ui::{Avatar, SegmentButton, placeholder, status_badge};
 use utils::relative_time;
 
 pub(super) mod detail;
 
 use self::detail::IssueDetailView;
 use super::status_list::{StatusCounts, filter_by_status};
+use crate::views::{repo_tab_avatar, tab_title};
 
 const ISSUE_ROW_HEIGHT: f32 = 73.;
 
@@ -188,7 +189,7 @@ impl IssuesView {
                             .child(
                                 h_flex()
                                     .gap_1()
-                                    .child(UserAvatar::new(author.clone()).picture(picture))
+                                    .child(Avatar::new(author.clone()).picture(picture))
                                     .child(div().child(author)),
                             )
                             .child(SharedString::from("opened"))
@@ -333,8 +334,11 @@ impl BasePanel for IssuesView {
 }
 
 impl Panel for IssuesView {
-    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().child(SharedString::from(format!("{}/issues", self.repo_name)))
+    fn title(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let avatar = repo_tab_avatar(self.store.read(cx), cx);
+        let label = SharedString::from(format!("{}/issues", self.repo_name));
+
+        tab_title(avatar, label)
     }
 }
 

crates/workspace/src/views/mod.rs

@@ -11,8 +11,53 @@ pub(crate) mod sidebar;
 mod status_list;
 pub(crate) mod tree;
 
+use gpui::prelude::*;
+use gpui::{AnyElement, App, div};
+use gpui_component::{Sizable as _, h_flex};
 pub use inbox::InboxView;
 pub use repo::RepoDetailView;
 pub(crate) use repo::{RepoItem, open_repo_item, open_repo_panel};
 pub use repo_list::RepoListView;
 pub use sidebar::SidebarPanel;
+use signed_state::{ProfileStore, RepoStore};
+use signed_ui::{Avatar, PixelAvatar};
+
+pub(crate) fn tab_title(avatar: AnyElement, label: impl IntoElement) -> impl IntoElement {
+    h_flex()
+        .gap_1p5()
+        .items_center()
+        .child(div().flex_shrink_0().child(avatar))
+        .child(label)
+}
+
+pub(crate) fn panel_avatar(seed: impl AsRef<str>) -> AnyElement {
+    PixelAvatar::new(seed).xsmall().into_any_element()
+}
+
+pub(crate) fn repo_tab_avatar(store: &RepoStore, cx: &App) -> AnyElement {
+    let seed = store
+        .announcement
+        .as_ref()
+        .map(|announcement| format!("{}:{}", announcement.owner, announcement.id))
+        .or_else(|| store.addr().map(|addr| addr.to_string()))
+        .or_else(|| {
+            store
+                .path
+                .as_ref()
+                .map(|path| path.to_string_lossy().into_owned())
+        })
+        .unwrap_or_default();
+
+    let owner = store
+        .announcement
+        .as_ref()
+        .map(|announcement| ProfileStore::global(cx).read(cx).get(&announcement.owner));
+
+    match owner.and_then(|profile| profile.picture().map(|picture| (profile.name(), picture))) {
+        Some((name, picture)) => Avatar::new(name)
+            .picture(Some(picture))
+            .xsmall()
+            .into_any_element(),
+        None => PixelAvatar::new(seed).xsmall().into_any_element(),
+    }
+}

crates/workspace/src/views/pull_requests/detail.rs

@@ -27,11 +27,12 @@ use signed_core::{
 };
 use signed_git::{FileCommit, patch_commits, patch_diffs};
 use signed_state::{Backend, ProfileStore, RepoStore, ensure_repo_mirror};
-use signed_ui::{CountBadge, UserAvatar, placeholder, status_badge};
+use signed_ui::{Avatar, CountBadge, placeholder, status_badge};
 use utils::{relative_time, relative_time_secs};
 
 use crate::views::commit_diff::{CommitDiffView, DiffPane};
 use crate::views::discussion::{comment_form, comments_section, pr_roots, sidebar_section};
+use crate::views::{repo_tab_avatar, tab_title};
 
 const ROW_HEIGHT: f32 = 37.;
 
@@ -78,8 +79,7 @@ pub struct PullRequestDetailView {
     pane: Entity<DiffPane>,
     commit_item_sizes: Rc<Vec<Size<Pixels>>>,
     commit_scroll_handle: VirtualListScrollHandle,
-    /// The dock caches item panels, so without this observer a panel opened
-    /// before the store loaded would stay on its placeholder.
+    tasks: Vec<gpui::Task<Result<(), anyhow::Error>>>,
     _subscription: Subscription,
 }
 
@@ -123,6 +123,7 @@ impl PullRequestDetailView {
             pane,
             commit_item_sizes: Rc::new(Vec::new()),
             commit_scroll_handle: VirtualListScrollHandle::new(),
+            tasks: Vec::new(),
             _subscription: subscription,
         }
     }
@@ -326,7 +327,7 @@ impl PullRequestDetailView {
             Ok(())
         });
 
-        task.detach();
+        self.tasks.push(task);
     }
 
     /// Open the diff of `commit_id` in the bottom dock of the area.
@@ -343,6 +344,7 @@ impl PullRequestDetailView {
 
         let panel = cx.new(|cx| {
             CommitDiffView::new(
+                self.store.clone(),
                 worktree,
                 self.repo_name.clone(),
                 commit_id.into(),
@@ -451,7 +453,7 @@ impl PullRequestDetailView {
                                                 h_flex()
                                                     .gap_1()
                                                     .child(
-                                                        UserAvatar::new(author.clone())
+                                                        Avatar::new(author.clone())
                                                             .picture(picture),
                                                     )
                                                     .child(author),
@@ -788,15 +790,17 @@ impl BasePanel for PullRequestDetailView {
 }
 
 impl Panel for PullRequestDetailView {
-    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+    fn title(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let avatar = repo_tab_avatar(self.store.read(cx), cx);
         let hex = self.pr_id.to_hex();
         let id = SharedString::from(&hex[..8]);
-        let title = if self.repo_name.is_empty() {
+        let label = if self.repo_name.is_empty() {
             id
         } else {
             SharedString::from(format!("{}/{}", self.repo_name, id))
         };
-        div().text_sm().child(title)
+
+        tab_title(avatar, label)
     }
 }
 

crates/workspace/src/views/pull_requests/mod.rs

@@ -16,7 +16,7 @@ use gpui_component::{
 use nostr::prelude::{EventId, Kind};
 use signed_core::{RepoStatus, activity_subject};
 use signed_state::{ProfileStore, RepoStore};
-use signed_ui::{DropdownButton, SegmentButton, UserAvatar, placeholder, status_badge};
+use signed_ui::{Avatar, DropdownButton, SegmentButton, placeholder, status_badge};
 use utils::relative_time;
 
 pub(super) mod detail;
@@ -27,6 +27,7 @@ use self::new::open_new_pull_panel;
 use super::send_patch::open_send_patch_panel;
 use super::status_list::{StatusCounts, filter_by_status};
 use crate::views::repo::RepoAction;
+use crate::views::{repo_tab_avatar, tab_title};
 
 const ROW_HEIGHT: f32 = 73.;
 
@@ -202,7 +203,7 @@ impl PullRequestsView {
                             .child(
                                 h_flex()
                                     .gap_1()
-                                    .child(UserAvatar::new(author.clone()).picture(picture))
+                                    .child(Avatar::new(author.clone()).picture(picture))
                                     .child(div().child(author)),
                             )
                             .child(SharedString::from("opened"))
@@ -333,11 +334,11 @@ impl BasePanel for PullRequestsView {
 }
 
 impl Panel for PullRequestsView {
-    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().child(SharedString::from(format!(
-            "{}/pull-requests",
-            self.repo_name
-        )))
+    fn title(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let avatar = repo_tab_avatar(self.store.read(cx), cx);
+        let label = SharedString::from(format!("{}/pulls", self.repo_name));
+
+        tab_title(avatar, label)
     }
 }
 

crates/workspace/src/views/pull_requests/new.rs

@@ -32,6 +32,7 @@ use signed_state::{
 use signed_ui::{CountBadge, placeholder, ref_selector_trigger};
 
 use crate::views::commit_diff::{COMMIT_ROW_HEIGHT, CommitDiffView, DiffPane, commit_row};
+use crate::views::{repo_tab_avatar, tab_title};
 
 pub struct NewPullRequestView {
     focus_handle: FocusHandle,
@@ -67,6 +68,7 @@ pub struct NewPullRequestView {
     pane: Entity<DiffPane>,
     scroll_handle: VirtualListScrollHandle,
     item_sizes: Rc<Vec<Size<Pixels>>>,
+    tasks: Vec<gpui::Task<Result<(), anyhow::Error>>>,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -322,6 +324,7 @@ impl NewPullRequestView {
             pane,
             scroll_handle: VirtualListScrollHandle::new(),
             item_sizes: Rc::new(Vec::new()),
+            tasks: Vec::new(),
             _subscriptions: subscriptions,
         }
     }
@@ -389,7 +392,8 @@ impl NewPullRequestView {
 
                 Ok(())
             });
-        task.detach();
+
+        self.tasks.push(task);
     }
 
     /// Branches and the current branch are read off the UI thread, then applied.
@@ -418,7 +422,8 @@ impl NewPullRequestView {
 
                 Ok(())
             });
-        task.detach();
+
+        self.tasks.push(task);
     }
 
     fn apply_checkout(
@@ -635,7 +640,8 @@ impl NewPullRequestView {
 
                 Ok(())
             });
-        task.detach();
+
+        self.tasks.push(task);
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -829,7 +835,7 @@ impl NewPullRequestView {
                 Ok(())
             });
 
-        task.detach();
+        self.tasks.push(task);
     }
 
     fn submit(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -910,7 +916,7 @@ impl NewPullRequestView {
                 Ok(())
             });
 
-        task.detach();
+        self.tasks.push(task);
     }
 
     fn open_commit_diff(&mut self, commit_id: &str, window: &mut Window, cx: &mut Context<Self>) {
@@ -924,6 +930,7 @@ impl NewPullRequestView {
 
         let panel = cx.new(|cx| {
             CommitDiffView::new(
+                self.store.clone(),
                 repo_path,
                 self.repo_name.clone(),
                 commit_id.into(),
@@ -1323,11 +1330,11 @@ impl BasePanel for NewPullRequestView {
 }
 
 impl Panel for NewPullRequestView {
-    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().child(SharedString::from(format!(
-            "{}/new-pull-request",
-            self.repo_name
-        )))
+    fn title(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let avatar = repo_tab_avatar(self.store.read(cx), cx);
+        let label = SharedString::from(format!("{}/new-pull-request", self.repo_name));
+
+        tab_title(avatar, label)
     }
 }
 

crates/workspace/src/views/repo/about.rs

@@ -5,7 +5,7 @@ use gpui_component::{ActiveTheme, StyledExt, WindowExt, h_flex, v_flex};
 use nostr::prelude::PublicKey;
 use signed_core::Announcement;
 use signed_state::ProfileStore;
-use signed_ui::{UserAvatar, middle_truncate};
+use signed_ui::{Avatar, middle_truncate};
 
 pub(super) fn open_about_dialog(announcement: Announcement, window: &mut Window, cx: &mut App) {
     window.open_dialog(cx, move |dialog, _window, cx| {
@@ -173,7 +173,7 @@ fn maintainers(maintainers: &[PublicKey], cx: &App) -> AnyElement {
                 .gap_2()
                 .items_center()
                 .min_w_0()
-                .child(UserAvatar::new(name.clone()).picture(picture))
+                .child(Avatar::new(name.clone()).picture(picture))
                 .child(
                     div()
                         .flex_1()

crates/workspace/src/views/repo/history.rs

@@ -106,8 +106,10 @@ impl RepoHistoryView {
         // Same display name as the repo detail panel's title.
         let repo_name = repo_display_name(self.store.read(cx));
 
-        let panel =
-            cx.new(|cx| CommitDiffView::new(worktree, repo_name, commit_id.into(), window, cx));
+        let store = self.store.clone();
+        let panel = cx.new(|cx| {
+            CommitDiffView::new(store, worktree, repo_name, commit_id.into(), window, cx)
+        });
 
         dock_area.update(cx, |dock_area, cx| {
             add_center_panel(dock_area, panel_handle(panel), window, cx);

crates/workspace/src/views/repo/mod.rs

@@ -26,11 +26,12 @@ use nostr::prelude::{RelayUrl, ToBech32, Url};
 use signed_core::{Announcement, RepoAddr, RepoStatus};
 use signed_git::FileCommit;
 use signed_state::{
-    Backend, CheckoutStatus, CheckoutsStore, LocalReposStore, ProfileStore, RepoListStore,
-    RepoStore, ensure_repo_mirror, open_repo_mirror, pr_proposes_checkout,
+    Backend, CheckoutStatus, CheckoutsStore, LocalReposStore, Nip34Binding, Nip34Kind,
+    ProfileStore, RepoListStore, RepoStore, ensure_repo_mirror, open_repo_mirror,
+    pr_proposes_checkout,
 };
 use signed_ui::{
-    CountBadge, DropdownButton, PixelAvatar, UserAvatar, copy_row, menu_copy_row, middle_truncate,
+    Avatar, CountBadge, DropdownButton, PixelAvatar, copy_row, menu_copy_row, middle_truncate,
     ref_selector_trigger,
 };
 
@@ -54,6 +55,7 @@ use crate::views::pull_requests::new::open_new_pull_panel;
 use crate::views::repo::about::open_about_dialog;
 use crate::views::send_patch::open_send_patch_panel;
 use crate::views::tree::{TreeItemSeed, build_tree_items, sorted_worktree_paths};
+use crate::views::{repo_tab_avatar, tab_title};
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum RefKind {
@@ -123,10 +125,26 @@ impl RepoDetailView {
     pub fn new_local(
         dock_area: WeakEntity<DockArea>,
         local_path: PathBuf,
+        nip34: Option<Nip34Binding>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let store = cx.new(move |_cx| RepoStore::new_local(local_path));
+        let store = cx.new(move |_cx| RepoStore::new_local(local_path, nip34));
+        Self::new_common(dock_area, store, window, cx)
+    }
+
+    /// A local repository whose detected binding matches an announcement.
+    ///
+    /// Opens as the announced repository with the local worktree attached.
+    pub fn new_local_announced(
+        dock_area: WeakEntity<DockArea>,
+        announcement: Announcement,
+        local_path: PathBuf,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let addr = announcement.addr();
+        let store = cx.new(move |cx| RepoStore::from_worktree(addr, announcement, local_path, cx));
         Self::new_common(dock_area, store, window, cx)
     }
 
@@ -294,24 +312,17 @@ impl RepoDetailView {
         self.error = None;
         cx.notify();
 
-        let (addr, announcement, local_path) = {
+        let (announcement, local_path) = {
             let store = self.store.read(cx);
-            (
-                store.addr().cloned(),
-                store.announcement.clone(),
-                store.path.clone(),
-            )
+            (store.announcement.clone(), store.path.clone())
         };
 
-        // Local repositories live on disk at their scan path.
-        // No clone step or network refresh applies here.
-        if addr.is_none() {
+        // A repository with a local worktree shows it directly. An announced one
+        // still loads its announcement and activity from the store, which is
+        // subscribed to the relays independently.
+        if let Some(local_path) = local_path {
             self.repo_started = true;
 
-            let Some(local_path) = local_path else {
-                return;
-            };
-
             let task: gpui::Task<Result<(), Error>> = cx.spawn_in(window, async move |this, cx| {
                 let data = cx
                     .background_spawn(async move {
@@ -1254,6 +1265,24 @@ impl RepoDetailView {
             .unwrap_or_default();
         let avatar = PixelAvatar::new(path.clone());
 
+        // A repository already bound to a coordinate is not offered for publishing again.
+        let bound = self.store.read(cx).nip34.clone();
+        let action = match bound
+            .as_ref()
+            .filter(|binding| binding.kind == Nip34Kind::Initialized)
+        {
+            Some(binding) => bound_repo_label(binding, cx),
+            None => Button::new("init")
+                .icon(CustomIconName::Init)
+                .label("Initialize on Nostr")
+                .primary()
+                .tooltip("Publish this repository to Nostr")
+                .on_click(cx.listener(|this, _event, window, cx| {
+                    this.open_init_dialog(window, cx);
+                }))
+                .into_any_element(),
+        };
+
         v_flex()
             .px_4()
             .pb_4()
@@ -1291,16 +1320,7 @@ impl RepoDetailView {
                                     .child(path),
                             ),
                     )
-                    .child(
-                        Button::new("init")
-                            .icon(CustomIconName::Init)
-                            .label("Initialize on Nostr")
-                            .primary()
-                            .tooltip("Publish this repository to Nostr")
-                            .on_click(cx.listener(|this, _event, window, cx| {
-                                this.open_init_dialog(window, cx);
-                            })),
-                    ),
+                    .child(action),
             )
             .child(self.render_header_tabs(cx))
             .into_any_element()
@@ -1471,7 +1491,7 @@ impl RepoDetailView {
                         .child(
                             h_flex()
                                 .gap_1()
-                                .child(UserAvatar::new(owner_name.clone()).picture(owner_picture))
+                                .child(Avatar::new(owner_name.clone()).picture(owner_picture))
                                 .child(div().text_xs().whitespace_nowrap().child(owner_name)),
                         )
                         .when(!rest.is_empty(), |this| {
@@ -1996,6 +2016,37 @@ pub(super) fn repo_display_name(store: &RepoStore) -> SharedString {
         .unwrap_or_default()
 }
 
+/// The owner and identifier a local repository is already bound to.
+fn bound_repo_label(binding: &Nip34Binding, cx: &App) -> AnyElement {
+    let store = ProfileStore::global(cx);
+    let profile = binding.owner.map(|pk| store.read(cx).get(&pk));
+
+    h_flex()
+        .flex_shrink_0()
+        .gap_2()
+        .text_sm()
+        .child("Initialized by")
+        .text_color(cx.theme().muted_foreground)
+        .when_some(profile, |this, profile| {
+            this.child(
+                h_flex()
+                    .gap_1()
+                    .text_color(cx.theme().foreground)
+                    .child(Avatar::new(profile.name()).picture(profile.picture()))
+                    .child(profile.name()),
+            )
+        })
+        .when_some(binding.identifier.as_deref(), |this, ident| {
+            this.child(
+                div()
+                    .text_xs()
+                    .font_semibold()
+                    .child(SharedString::from(format!("/{ident}"))),
+            )
+        })
+        .into_any_element()
+}
+
 impl BasePanel for RepoDetailView {
     fn panel_name(&self) -> &'static str {
         "repo"
@@ -2004,7 +2055,11 @@ impl BasePanel for RepoDetailView {
 
 impl Panel for RepoDetailView {
     fn title(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        repo_display_name(self.store.read(cx))
+        let store = self.store.read(cx);
+        let name = repo_display_name(store);
+        let avatar = repo_tab_avatar(store, cx);
+
+        tab_title(avatar, name)
     }
 }
 

crates/workspace/src/views/repo_list.rs

@@ -16,10 +16,10 @@ use gpui_component::{
 };
 use signed_core::Announcement;
 use signed_state::{ProfileStore, RepoListStore, Timestamp};
-use signed_ui::{SegmentButton, UserAvatar};
+use signed_ui::{Avatar, SegmentButton};
 use utils::relative_time;
 
-use super::open_repo_panel;
+use super::{open_repo_panel, panel_avatar, tab_title};
 
 const COLUMNS: usize = 2;
 const CARD_HEIGHT: f32 = 40. + 64. + 48. + 2. + 6.;
@@ -289,7 +289,7 @@ impl RepoListView {
                         h_flex()
                             .gap_2()
                             .items_center()
-                            .child(UserAvatar::new(owner.name()).picture(owner.picture()))
+                            .child(Avatar::new(owner.name()).picture(owner.picture()))
                             .child(
                                 div()
                                     .text_xs()
@@ -389,7 +389,7 @@ impl BasePanel for RepoListView {
 
 impl Panel for RepoListView {
     fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().text_sm().child(SharedString::from("Explore"))
+        tab_title(panel_avatar("explore"), SharedString::from("Explore"))
     }
 }
 

crates/workspace/src/views/send_patch.rs

@@ -11,6 +11,8 @@ use gpui_component::spinner::Spinner;
 use gpui_component::{ActiveTheme, Icon, IconName, Sizable, h_flex, v_flex};
 use signed_state::RepoStore;
 
+use crate::views::{repo_tab_avatar, tab_title};
+
 pub struct SendPatchView {
     focus_handle: FocusHandle,
     dock_area: WeakEntity<DockArea>,
@@ -205,8 +207,11 @@ impl BasePanel for SendPatchView {
 }
 
 impl Panel for SendPatchView {
-    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        div().child(SharedString::from(format!("{}/send-patch", self.repo_name)))
+    fn title(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let avatar = repo_tab_avatar(self.store.read(cx), cx);
+        let label = SharedString::from(format!("{}/send-patch", self.repo_name));
+
+        tab_title(avatar, label)
     }
 }
 

crates/workspace/src/views/sidebar/grasp_servers.rs

@@ -215,15 +215,19 @@ pub fn load_user_grasp_servers(
     cx: &mut App,
 ) {
     let backend = Backend::global(cx);
-    let Some(user) = backend.read(cx).current_user() else {
+    let (user, client) = {
+        let backend = backend.read(cx);
+        (backend.current_user(), backend.client())
+    };
+
+    let Some(user) = user else {
         state.update(cx, |state, _| state.loading_servers = false);
         return;
     };
-    let client = backend.read(cx).client();
     let handle = window.window_handle();
 
     cx.spawn(async move |cx| {
-        let result = signed_state::user_grasp_list_servers(client, user).await;
+        let result = signed_state::user_grasp_list_servers(&client, user).await;
 
         let _ = cx.update_window(handle, |_, _window, cx| {
             state.update(cx, |state, _| {

crates/workspace/src/views/sidebar/mod.rs

@@ -1,6 +1,6 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::ops::Range;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -10,7 +10,7 @@ use dock::{
 };
 use gpui::prelude::*;
 use gpui::{
-    AnyElement, App, Context, Div, EventEmitter, FocusHandle, Focusable, ObjectFit, Render,
+    AnyElement, App, Context, Div, Entity, EventEmitter, FocusHandle, Focusable, ObjectFit, Render,
     SharedString, Subscription, WeakEntity, Window, div, img, px, relative, uniform_list, white,
 };
 use gpui_base::Button as BaseButton;
@@ -18,11 +18,12 @@ use gpui_component::button::{Button, ButtonVariants};
 use gpui_component::input::InputState;
 use gpui_component::{ActiveTheme, Icon, IconName, Sizable, StyledExt, h_flex, v_flex};
 use nostr::prelude::RelayUrl;
-use signed_core::{Announcement, RepoAddr, identifier_from_name};
+use signed_core::{Announcement, RepoAddr};
 use signed_state::{
-    Backend, BackendEvent, CheckoutsStore, LocalReposStore, Profile, ProfileStore, RepoListStore,
+    Backend, BackendEvent, CheckoutsStore, LocalReposStore, Nip34Binding, Nip34Kind, Profile,
+    ProfileStore, RepoListStore, ResolvedLocalRepo, resolve_local_repos,
 };
-use signed_ui::{NavItem, PixelAvatar, UserAvatar, title_bar_drag_handlers};
+use signed_ui::{Avatar, NavItem, PixelAvatar, title_bar_drag_handlers};
 
 use super::{InboxView, RepoDetailView, RepoListView, open_repo_panel};
 
@@ -35,18 +36,31 @@ mod settings_dialog;
 
 use self::onboarding_dialog::OnboardingState;
 
+/// The platform that bound a repository, `"nak"` or `"ngit"`.
+fn local_platform(binding: &Nip34Binding) -> Option<&'static str> {
+    let signals = &binding.signals;
+
+    if signals.nip34_json || signals.nip34_grasp_remote || signals.nip34_state_refs {
+        Some("nak")
+    } else if signals.nostr_repo_config {
+        Some("ngit")
+    } else {
+        None
+    }
+}
+
 pub struct SidebarPanel {
     focus_handle: FocusHandle,
     dock_area: WeakEntity<DockArea>,
     inbox: Option<WeakEntity<InboxView>>,
     explore: Option<WeakEntity<RepoListView>>,
     banner: SharedString,
-    /// The signed-in user's announced repositories, newest first.
+    /// User's announced repositories.
     announcements: Arc<Vec<Announcement>>,
     /// Local repositories found by the scan that are not announced yet.
-    local_repos: Arc<Vec<PathBuf>>,
+    local_repos: Arc<Vec<ResolvedLocalRepo>>,
     scanning: bool,
-    /// Unpushed commit counts per announced repository, shown as row badges.
+    /// Unpushed commit counts per announced repository.
     unpushed: HashMap<RepoAddr, usize>,
     _subscriptions: Vec<Subscription>,
 }
@@ -65,16 +79,12 @@ impl SidebarPanel {
             let signer_changed = matches!(event, BackendEvent::SignerChanged);
             let signer_required = matches!(event, BackendEvent::SignerRequired);
 
-            if !signer_changed && !signer_required {
-                return;
-            }
-
             if signer_required {
                 this.banner = pick_banner();
                 cx.notify();
             }
 
-            if this.refresh(cx) || signer_required {
+            if this.refresh(cx) || signer_changed {
                 cx.notify();
             }
         }));
@@ -116,30 +126,19 @@ impl SidebarPanel {
         let backend = Backend::global(cx);
         let user = backend.read(cx).current_user();
 
-        let repo_list = RepoListStore::global(cx);
-        let announcements = user
-            .as_ref()
-            .map(|user| repo_list.read(cx).announcements_of(user))
-            .unwrap_or_default();
+        let (announcements, local_repos, scanning) = {
+            let repo_list = RepoListStore::global(cx).read(cx);
 
-        // Drop a scanned repository once the user announces it, so it is not listed twice.
-        let local = LocalReposStore::global(cx);
-        let scanning = local.read(cx).scanning;
+            let announcements = user
+                .as_ref()
+                .map(|user| repo_list.announcements_of(user))
+                .unwrap_or_default();
 
-        let local_repos = {
-            let ids: HashSet<String> = announcements.iter().map(|a| a.id.clone()).collect();
-            local
-                .read(cx)
-                .repos
-                .iter()
-                .filter(|path| {
-                    let Some(name) = path.file_name() else {
-                        return true;
-                    };
-                    !ids.contains(&identifier_from_name(&name.to_string_lossy()))
-                })
-                .cloned()
-                .collect()
+            let local = LocalReposStore::global(cx).read(cx);
+            let local_repos =
+                resolve_local_repos(&local.repos, &repo_list.announcements, &announcements);
+
+            (announcements, local_repos, local.scanning)
         };
 
         let announcements_changed = *self.announcements != announcements;
@@ -259,10 +258,66 @@ impl SidebarPanel {
     }
 
     /// The detail view offers to publish it to NIP-34.
-    fn open_local_repo(&mut self, path: PathBuf, window: &mut Window, cx: &mut Context<Self>) {
+    fn open_local_repo(
+        &mut self,
+        path: PathBuf,
+        nip34: Option<Nip34Binding>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
         let detail =
-            cx.new(|cx| RepoDetailView::new_local(self.dock_area.clone(), path, window, cx));
+            cx.new(|cx| RepoDetailView::new_local(self.dock_area.clone(), path, nip34, window, cx));
+        self.add_detail_panel(detail, window, cx);
+    }
 
+    /// A local repository whose binding matches an announcement opens as the announced repository.
+    fn open_local_announced(
+        &mut self,
+        announcement: Announcement,
+        path: PathBuf,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let detail = cx.new(|cx| {
+            RepoDetailView::new_local_announced(
+                self.dock_area.clone(),
+                announcement,
+                path,
+                window,
+                cx,
+            )
+        });
+        self.add_detail_panel(detail, window, cx);
+    }
+
+    /// A local repository opens as the announced repository
+    /// when its binding matches one, and as a local-only repository otherwise.
+    fn open_local_entry(
+        &mut self,
+        entry: ResolvedLocalRepo,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let ResolvedLocalRepo {
+            path,
+            nip34,
+            announcement,
+        } = entry;
+
+        if let Some(announcement) = announcement {
+            self.open_local_announced(announcement, path, window, cx);
+            return;
+        }
+
+        self.open_local_repo(path, nip34, window, cx);
+    }
+
+    fn add_detail_panel(
+        &mut self,
+        detail: Entity<RepoDetailView>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
         self.dock_area
             .update(cx, |dock_area, cx| {
                 add_center_panel(dock_area, panel_handle(detail), window, cx);
@@ -361,11 +416,10 @@ impl SidebarPanel {
             })
     }
 
-    /// Renders row `ix` of the merged list: an announced repository or a local one.
     fn render_repo_at(
         &self,
         announcements: &[Announcement],
-        local_repos: &[PathBuf],
+        local_repos: &[ResolvedLocalRepo],
         ix: usize,
         cx: &mut Context<Self>,
     ) -> AnyElement {
@@ -376,9 +430,9 @@ impl SidebarPanel {
         }
 
         let local_ix = ix - announcements.len();
-        let path = &local_repos[local_ix];
+        let entry = &local_repos[local_ix];
 
-        self.render_local_row(path, cx).into_any_element()
+        self.render_local_row(entry, cx).into_any_element()
     }
 
     fn render_repo_row(
@@ -387,7 +441,9 @@ impl SidebarPanel {
         cx: &mut Context<Self>,
     ) -> impl IntoElement {
         let name = announcement.name().map(SharedString::from);
-        let avatar = PixelAvatar::new(format!("{}:{}", announcement.owner, announcement.id));
+        // The sidebar rows are compact, so the avatar matches the 16px nav icons.
+        let avatar =
+            PixelAvatar::new(format!("{}:{}", announcement.owner, announcement.id)).xsmall();
         let announcement = announcement.clone();
 
         let unpushed = self
@@ -419,23 +475,52 @@ impl SidebarPanel {
         )
     }
 
-    /// A local repository that is not yet set up for NIP-34, marked with a warning.
-    fn render_local_row(&self, path: &Path, cx: &mut Context<Self>) -> impl IntoElement {
-        let name = path
-            .file_name()
-            .map(|name| name.to_string_lossy().into_owned())
-            .unwrap_or("Untitled".into());
-        let path = path.to_path_buf();
-        let avatar = PixelAvatar::new(path.to_string_lossy());
+    fn render_local_row(
+        &self,
+        entry: &ResolvedLocalRepo,
+        cx: &mut Context<Self>,
+    ) -> impl IntoElement {
+        let name = entry.name();
+        let avatar = local_avatar(entry, cx);
 
-        NavItem::new(format!("local-repo:{}", path.display()), name, avatar)
-            .suffix(
-                Icon::new(IconName::TriangleAlert)
-                    .small()
-                    .text_color(cx.theme().warning),
-            )
+        let id = format!("local-repo:{}", entry.path.display());
+        let entry = entry.clone();
+
+        let suffix: AnyElement = match entry.nip34.as_ref() {
+            Some(binding) => {
+                let (label, tooltip) = match binding.kind {
+                    Nip34Kind::Initialized => {
+                        let platform = local_platform(binding).unwrap_or("Grasp");
+                        let tooltip = match platform {
+                            "nak" => "Initialized with nak",
+                            "ngit" => "Initialized with ngit",
+                            _ => "Initialized for NIP-34",
+                        };
+                        (platform, tooltip)
+                    }
+                    Nip34Kind::Cloned => ("Cloned", "Cloned buts not initialized"),
+                    Nip34Kind::ToolingOnly => ("Tooling", "Grasp tooling only"),
+                };
+
+                Button::new(id.clone())
+                    .xsmall()
+                    .child(div().text_size(px(10.)).child(label))
+                    .tooltip(tooltip)
+                    .secondary()
+                    .into_any_element()
+            }
+            None => Button::new(id.clone())
+                .xsmall()
+                .icon(IconName::TriangleAlert)
+                .tooltip("Not published yet")
+                .ghost()
+                .into_any_element(),
+        };
+
+        NavItem::new(id, name, avatar)
+            .suffix(suffix)
             .on_click(cx.listener(move |this, _ev, window, cx| {
-                this.open_local_repo(path.clone(), window, cx);
+                this.open_local_entry(entry.clone(), window, cx);
             }))
     }
 
@@ -463,7 +548,7 @@ impl SidebarPanel {
                         Button::new("user").text().dropdown_caret(true).child(
                             h_flex()
                                 .gap_1()
-                                .child(UserAvatar::new(name.clone()).picture(picture))
+                                .child(Avatar::new(name.clone()).picture(picture))
                                 .child(div().text_xs().font_semibold().child(name)),
                         ),
                     ),
@@ -563,6 +648,31 @@ pub(super) fn server_host(relay: &RelayUrl) -> SharedString {
         .unwrap_or_else(|| SharedString::from(relay.to_string()))
 }
 
+/// The repository's pixel avatar, with the bound owner's avatar at its bottom right.
+fn local_avatar(entry: &ResolvedLocalRepo, cx: &App) -> AnyElement {
+    // Matches the other sidebar rows, and the badge below sits at its corner.
+    let avatar = PixelAvatar::new(entry.path.to_string_lossy()).xsmall();
+
+    let Some(owner) = entry.nip34.as_ref().and_then(|binding| binding.owner) else {
+        return avatar.into_any_element();
+    };
+
+    let store = ProfileStore::global(cx);
+    let profile = store.read(cx).get(&owner);
+
+    div()
+        .relative()
+        .child(avatar)
+        .child(
+            div().absolute().bottom_neg_0p5().right_neg_0p5().child(
+                Avatar::new(profile.name())
+                    .picture(profile.picture())
+                    .size(px(14.)),
+            ),
+        )
+        .into_any_element()
+}
+
 fn pick_banner() -> SharedString {
     let num = SystemTime::now()
         .duration_since(UNIX_EPOCH)

crates/workspace/src/views/sidebar/settings_dialog.rs

@@ -18,7 +18,7 @@ use gpui_component::{
     ActiveTheme, IconName, IndexPath, Sizable, Theme, ThemeMode, ThemeRegistry, WindowExt, h_flex,
     v_flex,
 };
-use settings::{AppearanceMode, Settings, SettingsStore};
+use settings::{AppearanceMode, EventFetchingStrategy, Settings, SettingsStore};
 use signed_ui::{SelectOption, setting_block, setting_row};
 
 use super::{normalize_server, server_host};
@@ -52,6 +52,7 @@ fn theme_options(cx: &App) -> (Vec<SelectOption>, Vec<SelectOption>) {
 /// Created once when the dialog opens, so control state survives re-renders.
 struct SettingsControls {
     appearance: Entity<SelectState<Vec<SelectOption>>>,
+    event_fetching: Entity<SelectState<Vec<SelectOption>>>,
     light_theme: Entity<SelectState<Vec<SelectOption>>>,
     dark_theme: Entity<SelectState<Vec<SelectOption>>>,
     font_size: Entity<InputState>,
@@ -89,6 +90,23 @@ impl SettingsControls {
             )
         });
 
+        let event_fetching_options = vec![
+            SelectOption::new("curated", "Curated"),
+            SelectOption::new("uncensored", "Uncensored"),
+        ];
+        let event_fetching_value = match settings.event_fetching {
+            EventFetchingStrategy::Curated => "curated",
+            EventFetchingStrategy::Uncensored => "uncensored",
+        };
+        let event_fetching = cx.new(|cx| {
+            SelectState::new(
+                event_fetching_options.clone(),
+                selected_index(&event_fetching_options, event_fetching_value),
+                window,
+                cx,
+            )
+        });
+
         let (light_options, dark_options) = theme_options(cx);
         let light_theme = cx.new(|cx| {
             SelectState::new(
@@ -147,6 +165,19 @@ impl SettingsControls {
             }
         }));
 
+        subscriptions.push(cx.subscribe(&event_fetching, |_, event, cx| {
+            if let SelectEvent::Confirm(Some(value)) = event {
+                let strategy = match value.as_ref() {
+                    "curated" => EventFetchingStrategy::Curated,
+                    _ => EventFetchingStrategy::Uncensored,
+                };
+                let store = SettingsStore::global(cx);
+                store.update(cx, |store, cx| {
+                    store.edit(|settings| settings.event_fetching = strategy, cx);
+                });
+            }
+        }));
+
         subscriptions.push(cx.subscribe(&light_theme, |_, event, cx| {
             if let SelectEvent::Confirm(Some(value)) = event {
                 let store = SettingsStore::global(cx);
@@ -252,6 +283,7 @@ impl SettingsControls {
 
         Self {
             appearance,
+            event_fetching,
             light_theme,
             dark_theme,
             font_size,
@@ -290,8 +322,12 @@ fn settings_view(controls: &SettingsControls, cx: &mut App) -> impl IntoElement
         .child(Separator::horizontal())
         .child(theme_section(&settings, controls, cx))
         .child(Separator::horizontal())
+        .child(tab_bar_section(&settings, cx))
+        .child(Separator::horizontal())
         .child(grasp_servers_section(&settings, controls, cx))
         .child(Separator::horizontal())
+        .child(event_fetching_section(controls, cx))
+        .child(Separator::horizontal())
         .child(repositories_section(&settings, controls, cx))
 }
 
@@ -304,6 +340,16 @@ fn appearance_section(controls: &SettingsControls, cx: &App) -> impl IntoElement
     ))
 }
 
+/// Which relays repository activity is fetched from.
+fn event_fetching_section(controls: &SettingsControls, cx: &App) -> impl IntoElement {
+    v_flex().w_full().gap_3().child(setting_row(
+        cx,
+        "Event Fetching Strategy",
+        "Curated fetches events from relays in the repository's announcement. Uncensored also fetches from every maintainer's relays.",
+        Select::new(&controls.event_fetching).w_full(),
+    ))
+}
+
 fn theme_section(settings: &Settings, controls: &SettingsControls, cx: &App) -> impl IntoElement {
     v_flex()
         .gap_3()
@@ -374,6 +420,26 @@ fn theme_section(settings: &Settings, controls: &SettingsControls, cx: &App) ->
         ))
 }
 
+/// Tab bar chrome, such as its next/previous tab buttons.
+fn tab_bar_section(settings: &Settings, cx: &App) -> impl IntoElement {
+    v_flex().w_full().gap_3().child(setting_row(
+        cx,
+        "Hide Tab Navigation Buttons",
+        "Enable to show navigation buttons when more than 10 tabs.",
+        Switch::new("hide-tab-navigation")
+            .checked(settings.tab_bar.hide_navigation_buttons)
+            .on_click(move |checked: &bool, _window, cx| {
+                let store = SettingsStore::global(cx);
+                store.update(cx, |store, cx| {
+                    store.edit(
+                        |settings| settings.tab_bar.hide_navigation_buttons = *checked,
+                        cx,
+                    );
+                });
+            }),
+    ))
+}
+
 /// Default grasp servers, used until the user's kind `10317` grasp list loads.
 fn grasp_servers_section(
     settings: &Settings,

desktop/Cargo.toml

@@ -12,9 +12,9 @@ path = "src/main.rs"
 name = "Signed"
 product-name = "Signed"
 description = "Nostr Git client for browsing repositories and collaborating"
-identifier = "su.reya.signed"
+identifier = "info.reya.signed"
 category = "DeveloperTool"
-version = "0.1.0-alpha"
+version = "0.2.0-alpha"
 out-dir = "../dist"
 before-packaging-command = "cargo build --release"
 resources = ["Cargo.toml", "src"]

desktop/resources/snap/snapcraft.yaml.in

@@ -17,7 +17,7 @@ contact: https://reya.su
 parts:
   signed:
     plugin: dump
-    source: target/release/signed-linux-$ARCH_SUFFIX.tar.gz
+    source: target/release/signed-linux-$TARBALL_ARCH_SUFFIX.tar.gz
 
     organize:
       # These renames seem to not be necessary, but it's tidier.
@@ -54,4 +54,4 @@ parts:
 apps:
   signed:
     command: usr/bin/signed
-    common-id: su.reya.signed
+    common-id: info.reya.signed

desktop/src/main.rs

@@ -78,7 +78,7 @@ fn main() {
                 cx,
             );
 
-            cx.set_app_identity("su.reya.signed", "Signed");
+            cx.set_app_identity("info.reya.signed", "Signed");
 
             let bounds = Bounds::centered(None, size(px(1120.0), px(750.0)), cx);
             let opts = WindowOptions {

flathub/.gitignore

@@ -2,8 +2,8 @@
 # These are generated by script/prepare-flathub
 vendor/
 vendor.tar.gz
-su.reya.signed.yml
-su.reya.signed.metainfo.xml
+info.reya.signed.yml
+info.reya.signed.metainfo.xml
 release-info.xml
 cargo-config.toml
 build/

flathub/README.md

@@ -19,14 +19,14 @@ Run the preparation script from the repo root:
 This will:
 1. Vendor all Rust dependencies (crates.io + git)
 2. Generate the metainfo.xml with proper release info
-3. Create `su.reya.signed.yml` - the Flatpak manifest for Flathub
+3. Create `info.reya.signed.yml` - the Flatpak manifest for Flathub
 
 ## Files Generated
 
 | File | Purpose |
 |------|---------|
-| `su.reya.signed.yml` | Main Flatpak manifest (submit this to Flathub) |
-| `su.reya.signed.metainfo.xml` | AppStream metadata with release info |
+| `info.reya.signed.yml` | Main Flatpak manifest (submit this to Flathub) |
+| `info.reya.signed.metainfo.xml` | AppStream metadata with release info |
 | `vendor.tar.gz` | Vendored Rust dependencies |
 | `cargo-config.toml` | Cargo configuration for offline builds |
 | `release-info.xml` | Release info snippet for metainfo |
@@ -39,13 +39,13 @@ Before submitting to Flathub, test the build:
 cd flathub
 
 # Build and install locally
-flatpak-builder --user --install --force-clean build su.reya.signed.yml
+flatpak-builder --user --install --force-clean build info.reya.signed.yml
 
 # Test the app
-flatpak run su.reya.signed
+flatpak run info.reya.signed
 
 # Run the Flathub linter (must pass!)
-flatpak run --command=flatpak-builder-lint org.flatpak.Builder manifest su.reya.signed.yml
+flatpak run --command=flatpak-builder-lint org.flatpak.Builder manifest info.reya.signed.yml
 flatpak run --command=flatpak-builder-lint org.flatpak.Builder repo repo
 ```
 
@@ -69,15 +69,15 @@ git clone --branch=new-pr git@github.com:YOUR_USERNAME/flathub.git
 cd flathub
 
 # Create a new branch
-git checkout -b su.reya.signed
+git checkout -b info.reya.signed
 
 # Copy ONLY the manifest file from your project
-cp /path/to/signed/flathub/su.reya.signed.yml .
+cp /path/to/signed/flathub/info.reya.signed.yml .
 
 # Commit and push
-git add su.reya.signed.yml
-git commit -m "Add su.reya.signed"
-git push origin su.reya.signed
+git add info.reya.signed.yml
+git commit -m "Add info.reya.signed"
+git push origin info.reya.signed
 ```
 
 ### 3. Open Pull Request
@@ -92,9 +92,9 @@ git push origin su.reya.signed
 
 1. Flathub's automated CI will build your app
 2. A maintainer will review your submission
-3. Once approved, a new repo `flathub/su.reya.signed` will be created
+3. Once approved, a new repo `flathub/info.reya.signed` will be created
 4. You'll get write access to maintain the app
-5. Future updates: Push new commits to `flathub/su.reya.signed`
+5. Future updates: Push new commits to `flathub/info.reya.signed`
 
 ## Updating the App
 
@@ -104,9 +104,9 @@ To release a new version:
 2. Tag the new release: `git tag -a v0.1.0 -m "Release v0.1.0"`
 3. Push the tag: `git push origin v0.1.0`
 4. Run `./script/prepare-flathub` to regenerate
-5. Clone the flathub repo: `git clone https://github.com/flathub/su.reya.signed.git`
+5. Clone the flathub repo: `git clone https://github.com/flathub/info.reya.signed.git`
 6. Update the manifest with new commit/tag and hashes
-7. Submit PR to `flathub/su.reya.signed`
+7. Submit PR to `flathub/info.reya.signed`
 
 ## Troubleshooting
 
@@ -115,7 +115,7 @@ To release a new version:
 - Ensure `vendor.tar.gz` is properly extracted before building
 
 ### Linter complains about metainfo
-- Ensure `su.reya.signed.metainfo.xml` has at least one `<release>` entry
+- Ensure `info.reya.signed.metainfo.xml` has at least one `<release>` entry
 - Add accessible screenshot URLs if required
 
 ### Missing dependencies

script/bundle-snap

@@ -11,9 +11,12 @@ ARCH=$(uname -m)
 # Snap uses its own architecture names, which must match the file name and
 # the architecture asserted inside the .snap. `x86_64`/`aarch64` here would
 # produce a file like signed_1.0.0_x86_64.snap that snapd cannot match.
+#
+# The source tarball is named by `script/bundle-linux` after `uname -m`, so it
+# keeps the x86_64/aarch64 spelling rather than the snap-native one.
 case "$ARCH" in
-  x86_64|amd64) ARCH_SUFFIX="amd64" ;;
-  aarch64|arm64) ARCH_SUFFIX="arm64" ;;
+  x86_64|amd64) ARCH_SUFFIX="amd64"; TARBALL_ARCH_SUFFIX="x86_64" ;;
+  aarch64|arm64) ARCH_SUFFIX="arm64"; TARBALL_ARCH_SUFFIX="aarch64" ;;
   *) echo "Unsupported architecture: $ARCH"; exit 1 ;;
 esac
 
@@ -27,7 +30,7 @@ envsubst < "desktop/resources/signed.desktop.in" > "snap/gui/signed.desktop"
 cp "desktop/resources/icon.png" "snap/gui/signed.png"
 
 # Generate snapcraft.yaml with version and architecture
-RELEASE_VERSION="$1" ARCH_SUFFIX="$ARCH_SUFFIX" envsubst < desktop/resources/snap/snapcraft.yaml.in > snap/snapcraft.yaml
+RELEASE_VERSION="$1" TARBALL_ARCH_SUFFIX="$TARBALL_ARCH_SUFFIX" envsubst < desktop/resources/snap/snapcraft.yaml.in > snap/snapcraft.yaml
 
 # Clean previous builds
 snapcraft clean

script/flatpak/bundle-flatpak

@@ -16,7 +16,7 @@ archive_match="signed(-[a-zA-Z0-9]+)?-linux-${ARCH_SUFFIX}\.tar\.gz"
 archive=$(ls "target/release" | grep -E ${archive_match})
 
 export ARCHIVE="$archive"
-export APP_ID="su.reya.signed"
+export APP_ID="info.reya.signed"
 export APP_NAME="Signed"
 export BRANDING_LIGHT="#C6FF4D"
 export BRANDING_DARK="#C6FF4D"

script/prepare-flathub

@@ -4,7 +4,7 @@
 # This script:
 # 1. Vendors all Rust dependencies (crates.io + git)
 # 2. Generates release info for metainfo.xml
-# 3. Creates the Flathub manifest (su.reya.signed.yml)
+# 3. Creates the Flathub manifest (info.reya.signed.yml)
 #
 # Usage: ./script/prepare-flathub [--release-date YYYY-MM-DD]
 
@@ -12,7 +12,7 @@ set -euo pipefail
 cd "$(dirname "$0")/.."
 
 # Configuration
-APP_ID="su.reya.signed"
+APP_ID="info.reya.signed"
 APP_NAME="Signed"
 REPO_URL="https://git.reya.su/reya/signed"
 BRANDING_LIGHT="#C6FF4D"
@@ -106,7 +106,7 @@ COMMIT=$(git rev-parse HEAD)
 
 # Generate the YAML manifest
 cat > flathub/${APP_ID}.yml << 'MANIFEST_EOF'
-id: su.reya.signed
+id: info.reya.signed
 runtime: org.freedesktop.Platform
 runtime-version: "24.08"
 sdk: org.freedesktop.Sdk
@@ -153,22 +153,22 @@ modules:
       - install -Dm755 target/release/signed /app/bin/signed
 
       # Install icons
-      - install -Dm644 desktop/resources/icon.png /app/share/icons/hicolor/512x512/apps/su.reya.signed.png
-      - install -Dm644 desktop/resources/icon@2x.png /app/share/icons/hicolor/1024x1024/apps/su.reya.signed.png
+      - install -Dm644 desktop/resources/icon.png /app/share/icons/hicolor/512x512/apps/info.reya.signed.png
+      - install -Dm644 desktop/resources/icon@2x.png /app/share/icons/hicolor/1024x1024/apps/info.reya.signed.png
 
       # Install desktop file
       - |
-        export APP_ID="su.reya.signed"
-        export APP_ICON="su.reya.signed"
+        export APP_ID="info.reya.signed"
+        export APP_ICON="info.reya.signed"
         export APP_NAME="Signed"
         export APP_CLI="signed"
         export APP_ARGS="%U"
         export DO_STARTUP_NOTIFY="true"
         envsubst < desktop/resources/signed.desktop.in > signed.desktop
-        install -Dm644 signed.desktop /app/share/applications/su.reya.signed.desktop
+        install -Dm644 signed.desktop /app/share/applications/info.reya.signed.desktop
 
       # Install metainfo (use pre-generated one with release info)
-      - install -Dm644 su.reya.signed.metainfo.xml /app/share/metainfo/su.reya.signed.metainfo.xml
+      - install -Dm644 info.reya.signed.metainfo.xml /app/share/metainfo/info.reya.signed.metainfo.xml
 
     sources:
       # Main source code - specific commit
@@ -184,7 +184,7 @@ modules:
 
       # Pre-generated metainfo with release info
       - type: file
-        path: su.reya.signed.metainfo.xml
+        path: info.reya.signed.metainfo.xml
         sha256: "@METAINFO_SHA256@"
 
       # Cargo config for vendoring

script/release

@@ -54,66 +54,78 @@ echo "Updating versions..."
 update_version "$WORKSPACE_CARGO"
 update_version "$CRATE_CARGO"
 
-# Check git status before committing
-echo "Checking git status..."
-if git status --porcelain | grep -q .; then
-    echo "Current uncommitted changes:"
-    git status --short
-
-    # Ask user if they want to commit all changes or just version files
-    echo ""
-    echo "Do you want to:"
-    echo "1) Commit all current changes (including the version updates)"
-    echo "2) Commit only the version file changes"
-    echo "3) Abort the release"
-    read -p "Enter choice (1/2/3): " choice
-
-    case $choice in
-        1)
-            echo "Committing all changes..."
-            git add .
-            ;;
-        2)
-            echo "Committing only version file changes..."
-            git add "$WORKSPACE_CARGO" "$CRATE_CARGO"
-            ;;
-        3)
-            echo "Release aborted by user"
-            exit 0
-            ;;
-        *)
-            echo "Invalid choice. Release aborted."
-            exit 1
-            ;;
-    esac
-else
-    # Only version files were modified, add them specifically
-    echo "Only version files were modified, adding them for commit..."
-    git add "$WORKSPACE_CARGO" "$CRATE_CARGO"
-fi
-
-# Commit the changes
 COMMIT_MSG="chore: release version $NEW_VERSION"
 
-if git commit -m "$COMMIT_MSG"; then
-    echo "✓ Committed version changes"
+# When the requested version is already set there is nothing to bump or commit,
+# so the current commit is tagged as-is.
+if git diff --quiet -- "$WORKSPACE_CARGO" "$CRATE_CARGO"; then
+    echo "Version is already $NEW_VERSION, tagging the current commit"
 else
-    echo "Error: Failed to commit version changes"
-    exit 1
-fi
+    # Check git status before committing
+    echo "Checking git status..."
+    # The version files are always modified at this point, so only ask about other changes.
+    if [ -n "$(git status --porcelain -- . ":(exclude,top)$WORKSPACE_CARGO" ":(exclude,top)$CRATE_CARGO")" ]; then
+        echo "Current uncommitted changes:"
+        git status --short
 
-# Push version changes to origin
-echo "Pushing version changes to origin..."
-if git push origin master; then
-    echo "✓ Successfully pushed version changes to origin"
-else
-    echo "Error: Failed to push version changes to origin"
-    exit 1
+        # Ask user if they want to commit all changes or just version files
+        echo ""
+        echo "Do you want to:"
+        echo "1) Commit all current changes (including the version updates)"
+        echo "2) Commit only the version file changes"
+        echo "3) Abort the release"
+        read -p "Enter choice (1/2/3): " choice
+
+        case $choice in
+            1)
+                echo "Committing all changes..."
+                git add .
+                ;;
+            2)
+                echo "Committing only version file changes..."
+                git add "$WORKSPACE_CARGO" "$CRATE_CARGO"
+                ;;
+            3)
+                echo "Release aborted by user"
+                exit 0
+                ;;
+            *)
+                echo "Invalid choice. Release aborted."
+                exit 1
+                ;;
+        esac
+    else
+        # Only version files were modified, add them specifically
+        echo "Only version files were modified, adding them for commit..."
+        git add "$WORKSPACE_CARGO" "$CRATE_CARGO"
+    fi
+
+    # Commit the changes
+    if git commit -m "$COMMIT_MSG"; then
+        echo "✓ Committed version changes"
+    else
+        echo "Error: Failed to commit version changes"
+        exit 1
+    fi
+
+    # Push version changes to origin
+    echo "Pushing version changes to origin..."
+    if git push origin master; then
+        echo "✓ Successfully pushed version changes to origin"
+    else
+        echo "Error: Failed to push version changes to origin"
+        exit 1
+    fi
 fi
 
 # Create git tag
 TAG_NAME="v$NEW_VERSION"
 
+if git rev-parse -q --verify "refs/tags/$TAG_NAME" >/dev/null; then
+    echo "Error: tag $TAG_NAME already exists"
+    exit 1
+fi
+
 if git tag -a "$TAG_NAME" -m "$COMMIT_MSG"; then
     echo "✓ Created git tag: $TAG_NAME"
 else