block/buzz

Buzz is a multi-tenant, Nostr-based relay system that facilitates secure, agent-augmented collaboration through channels, forums, and real-time huddles. It provides a comprehensive infrastructure for managing AI agent lifecycles, enforcing strict tenant isolation, and handling media, search, and workflow automation. The system includes a full-featured desktop client for user interaction, alongside robust administrative tools for moderation, instance management, and deployment.

The desktop application now includes the necessary XML resources to render an adaptive icon on Android devices. This change adds a foreground/background structure for the launcher icon and defines a solid black background color, ensuring the app displays correctly on Android 8.0 (API level 26) and above.

desktop/src-tauri/icons · high confidence

The repository now includes a \bin/\ directory that bootstraps and manages pinned versions of development tools using Hermit. This setup ensures reproducible builds by providing specific versions of Node.js (24.15.0), pnpm (11.4.0), Rust toolchain (1.28.2), CMake (4.3.1), Flutter (3.41.7), and other utilities, automatically downloading them as needed and isolating them from system-wide installations.

bin · high confidence

Users can now search for and insert GIFs from the KLIPY provider directly within message composers. This change introduces a new UI component (KlipyGifPicker) that provides a search interface, debounced query handling, and a grid of results. The underlying implementation normalizes KLIPY API responses, sanitizes file names, and securely relays search and share requests through the current Nostr relay using NIP-98 authentication. It also respects user accessibility preferences by displaying static posters instead of animated previews when reduced motion is enabled.

desktop/src/features/gifs · high confidence

A new reference implementation, the countdown bot, has been added to the examples directory. This non-AI bot demonstrates how to interact with the Buzz platform by listening to a specific channel and responding to commands like \!countdown\ and \!fib\. It supports two authentication modes for connecting to relays: standalone (using the bot's key directly) and owner-attested (using NIP-OA signatures), and includes logic to publish a profile and announce channel membership.

examples/countdown-bot · high confidence

The reminders library now includes core logic for managing reminder state and visibility. Users benefit from accurate inbox categorization (Overdue, Today, Upcoming, Completed) and badge counts via \reminderFilters\. Clicking a reminder in the inbox now navigates directly to the original message, including entering the correct thread if it was a reply, handled by \reminderNavigation\. Additionally, the app now polls for due reminders every 30 seconds to ensure notifications fire even when the window is hidden or the app is unfocused, as implemented in \reminderNotificationPoll\.

desktop/src/features/reminders/lib · high confidence

The Android module is scaffolded as a Flutter app with a new Catppuccin-based theme and app branding (icon, name, launch screen). It adds native support for Huddles voice calls (Opus v2 audio engine, microphone permissions, foreground routing), voice notes (AAC-to-MP4 packaging), and image galleries (media permissions, sanitization, and color management). Deep links via the buzz:// scheme are handled, and under-18 users are hard-blocked using the Google Play Age Signals API. The build is aligned with Flutter 3.41.7, and a test suite for the image processor is added.

mobile/android · high confidence

The desktop client now includes a new set of UI components in the shared buzz-logo directory to render the application's branding. This adds a complex SVG-based animation component (BuzzLogoAnimation) supporting multiple morphing variants and texture filters, a static SVG mark (BuzzMark) for immediate rendering, a flapping bee variant (FlappingBee) optimized for compositor-level performance during boot, and a convenience wrapper (FuzzyLogo) that handles texture and pulse animations. These components are accompanied by the necessary CSS styles to support full-screen boot screens, compact modes, and reduced-motion preferences.

desktop/src/shared/ui/buzz-logo · high confidence

The desktop app now supports community-level moderation. Moderators can ban, unban, time out, and untimeout members, as well as kick members from specific channels, via the per-message action menu. Users can report messages through a new dialog that submits NIP-56 reports with category and optional notes. The app also detects and displays a timeout banner in the composer when a user is timed out, showing a live countdown if the expiry is known. This includes the underlying hooks, state management for timeout detection from send rejections, and UI components for these moderation surfaces.

desktop/src/features/moderation · high confidence

The desktop app now supports custom emojis via NIP-30 kind:30030 sets, displaying a 'Custom' category in the emoji picker and allowing users to manage their own emoji palette. To reduce relay traffic and improve performance, the implementation uses a client-side union of community emojis with a 2-minute polling backstop and suppresses unnecessary refetches when the window is focused but the data is fresh.

desktop/src/features/custom-emoji · high confidence

The desktop app now includes an admin console feature that allows relay operators to manage their deployment. This new panel provides three main capabilities: a Reports tab for viewing and acting on moderation reports (including actions like delete, kick, ban, and dismiss), a Feedback tab for reviewing user-submitted product feedback with image attachments, and a Staffing tab for managing operator roles and lifting member restrictions. The console handles authentication probing, enforces attachment size limits to prevent memory pressure, and ensures that operator actions are properly scoped to the active relay identity.

desktop · high confidence

The desktop application entry point (main.tsx) is introduced, establishing the React root with a comprehensive provider stack including communities, onboarding, theming, and UI utilities. The bootstrap sequence initializes user preferences (font size, conversation density), manages legacy storage migration, and implements safeguards against localStorage SecurityErrors that previously caused crashes. It also integrates a dev-mode E2E bridge for testing and sets up a time-based sweep for stale local storage caches.

desktop/src · high confidence

Users can now add AI agents to huddles via a new dialog that lists available managed and relay agents, handles starting local agents, and manages lifecycle errors. Once in the huddle, agents appear in the participant roster with squircle avatars, and users can control their behavior through a voice settings menu that toggles text-to-speech and selects specific voices. The huddle bar and room header display these agents alongside human participants, allowing users to remove agents or interrupt their speech directly from the interface.

desktop/src/features/huddle/components · high confidence

The mobile app now features a full-screen search interface that allows users to search across messages, channels, and people simultaneously. The search page includes a dedicated UI with filter chips to toggle between these scopes, displays results with relevant metadata (such as channel names and user avatars), and maintains a device-local history of recent searches scoped to the active community and account.

mobile/lib/features/search · high confidence

The mobile app now supports NIP-44 v2 for encrypting and decrypting conversation messages, enabling secure, end-to-end encrypted chat using ECDH key exchange, HKDF, and ChaCha20. Additionally, it implements NIP-OA (Owner Attestation) verification, allowing the app to validate that a profile's agent key is authorized by its owner key via Schnorr signatures, ensuring secure device pairing and identity verification.

mobile/lib/shared/crypto · high confidence

Users can now browse Git repositories directly in the web app. The new Repositories page lists available repos, and clicking a repo opens a detail view with a file tree, a rendered README, and a recent commits list. File contents are fetched via isomorphic-git into an IndexedDB-backed virtual filesystem and authenticated using NIP-98 headers, with safe inline previews for text, Markdown, and images, and a sandboxed iframe for HTML. A sidebar shows community members and provides a deep-link button to open the repo in the desktop app.

web/src/features/repos · high confidence

This change introduces the foundational Rust/Tauri structure for the Buzz desktop application. It adds macOS-specific configuration files, including an Entitlements.plist to grant microphone, camera, and local network access, and an Info.plist defining the app name and usage descriptions. The build script (build.rs) is added to embed build-time configuration such as relay URLs, updater settings, and agent environment variables, while also configuring the Tauri WebSocket plugin. Additionally, a custom macOS application menu is implemented to replace the default, ensuring that the Cmd+W shortcut is handled correctly by the webview for terminal tabs or window closing rather than hiding the app to the tray.

desktop/src-tauri · high confidence

The database schema has been rewritten to support multi-tenancy, replacing the previous single-community model. Every tenant-scoped row now includes a \community\_id\ that is resolved server-side from the connection host, ensuring strict isolation between communities. The schema introduces new tables for \communities\, \channels\, \channel\_members\, and \users\, along with custom types for roles, statuses, and policies. Primary keys and unique constraints are scoped to \community\_id\ to prevent cross-community collisions, and triggers enforce immutability of community assignment for channels.

schema · high confidence

This change introduces the Buzz Mobile application, a Flutter-based client for Android and iOS. Key capabilities include Huddles (audio-only voice calls using Opus protocol v2), push notifications via a configurable gateway, and a channel list with relay integration. The mobile app also features worktree-aware debug identities, allowing developers to run multiple app variants side-by-side during development. Configuration is managed through a new \.env.json.example\ file and build-time defines for the push gateway URL.

mobile · high confidence

Users can now capture and edit their profile avatar directly within the app using the device camera. The new inline capture interface supports both animated avatars (3-second recordings with background removal via selfie segmentation) and still photos, allowing users to adjust framing, scale, and background color before saving. The feature includes a dedicated camera disposal barrier to manage camera lifecycle safely and an iOS-specific native text editor for profile fields.

mobile/lib/features/profile · high confidence

This change adds the 'Bestie' feature to the desktop application's protected features layer, making it available only in internal builds (disabled by default in the public OSS release). It introduces a persistent floating avatar overlay that users can drag around the screen to quickly access a designated local agent, alongside a sidebar entry for direct conversation access. The feature also adds a 'Bestie' badge to agent cards, a dedicated action button on messages to ask the agent for context, and a profile action to assign or remove the Bestie agent. Under the hood, it implements the necessary Tauri commands for assignment persistence, React hooks for state management, and UI components for the floating menu and message context, ensuring the Bestie's private DM is filtered from the main channel list.

desktop/src/protectedFeatures · high confidence

The desktop application now includes a new terminal feature called Buzz Term. This change adds the core React components (TerminalBootstrap, TerminalSubstrate) and supporting logic (fade animations, banner rendering, color derivation) that power the terminal interface. Users can now open a terminal panel within the channel workspace, toggle it using the keyboard shortcut (Ctrl/Cmd+J), and interact with a shell session. The implementation includes a splash screen, session management, and visual theming that respects the application's color palette.

desktop/src/features/terminal · high confidence

Added a new \buzz-test-client\ crate providing a WebSocket-based test client for the Buzz relay, along with a \buzz-test-cli\ binary for manual testing. The library supports NIP-42 authentication (including NIP-OA agent authentication), event sending, and subscription management. Two new binaries are included: \mention\ for sending @mention events to specific pubkeys, and \wamp\_bench\ for load-generating benchmarks of kind:9 events to measure relay write-amplification and latency.

crates/buzz-test-client/src · high confidence

The CLI now supports managing agent identities through \agents archive\, \unarchive\, and \archived\ subcommands, which handle identity archival requests and list archived agents. It also introduces \channels create --template\ to bootstrap channels from desktop-local JSON templates, and adds \--ttl\ support to channel creation and updates for ephemeral channels. Additionally, the \channels\ command now includes \--visibility\ filtering and the \agents\ command supports draft-based creation and updates that require owner authentication via \BUZZ\_AUTH\_TAG\.

crates/buzz-cli/src/commands · high confidence

Users can now create and manage forum posts and threaded replies directly within the desktop app. This change adds a new ForumView that displays a list of posts and expands into a thread view for replies, featuring a rich-text ForumComposer with support for @mentions, \#channel links, and media uploads. Post cards display author details, relative timestamps, and reply counts, while a DeleteActionMenu allows authors to remove their own posts or replies via a confirmation dialog. The composer includes draft recovery to persist content across visits and handles agent invitation flows for non-member mentions.

desktop/src/features/forum/ui · high confidence

This change adds the core React context and presence provider for the Huddle feature. HuddleContext.tsx centralizes audio session management, including microphone input, device selection, mute/gain controls, and voice input modes (push-to-talk), while exposing high-frequency audio levels via a separate context to optimize rendering. HuddlePresenceContext.tsx provides a community-wide subscription to track which users are currently in an active huddle, enabling UI indicators. The index.ts exports the new providers, components (HuddleBar, HuddleRoomHeader, etc.), and utilities, establishing the foundation for the huddle UI and audio logic.

desktop/src/features/huddle · high confidence

This change adds a new Kubernetes backend plugin that enables deploying and managing agents as pods within a Kubernetes cluster. The implementation includes a state machine for classifying pod states (e.g., created, terminated, pull failures) and determining the next action (create, delete, observe, report). It handles cluster authentication via kubeconfig, including support for exec credential plugins by prepending standard plugin directories to the PATH. The plugin enforces strict image reference validation, requiring digest-pinned images to ensure immutability, and manages pod lifecycle through garbage collection of terminated pods and orphan secrets. Configuration is parsed from a provider config schema, supporting resource limits, inactivity timeouts, and namespace selection.

crates/buzz-backend-kubernetes · high confidence

A new \git-credential-nostr\ helper enables passwordless Git push and pull operations against the Buzz git server by signing HTTP authentication events using the NIP-98 protocol. Users configure the helper via a local key file or the \NOSTR\_PRIVATE\_KEY\ environment variable, allowing Git to automatically sign requests with the user's Nostr private key when the server challenges with a Nostr realm. The implementation also supports service-bound authentication for agents by injecting NIP-OA owner attestation tags into the signed events, ensuring that delegated access is correctly verified by the relay.

crates/git-credential-nostr · high confidence

Users can now pair a new device (such as a phone) to an existing Nostr identity (such as a desktop app) using the NIP-AB protocol. This feature enables secure, one-time transfer of secrets like \nsec\ keys or NIP-46 bunker strings via a QR code and Short Authentication String (SAS) verification, ensuring the exchange is end-to-end encrypted and resistant to man-in-the-middle attacks even over untrusted relays.

crates/buzz-core/src/pairing · high confidence

The desktop app now includes a new Pulse social notes surface, accessible via a tab bar with sections for Everyone, Following, Liked, Agents, Mine, and Search. This view renders social notes using NoteCard components (supporting replies, upvotes, and reactions) and introduces AgentActivityCard to display activity from relay and managed agents, including squircle avatars and status indicators. The PulseScreen orchestrates this view alongside a profile sidebar panel, while the underlying view logic handles timeline queries for different audiences and filters agent notes from the 'Following' feed unless explicitly followed.

desktop/src/features/pulse/ui · high confidence

Adds a new Pulse tab to the mobile app, providing a social feed with five filterable views: Everyone, Following, Liked, Agents, and Mine. Users can compose new notes or reply to existing ones via a dedicated full-screen page, and interact with content through an optimistic upvote system and follow/unfollow controls. The feed displays standard notes as individual cards and groups recent updates from agents into collapsible activity cards, with pull-to-refresh support.

mobile/lib/features/pulse · high confidence

Users can now install a single 'sprig' binary that acts as a multicall executable, routing commands to specific components based on how it is invoked (via symlinks or name). The binary supports 'personality' names like 'buzz-acp' (ACP harness), 'buzz-agent' (ACP-compliant agent), and 'buzz-dev-mcp' (developer MCP server), as well as helper utilities like 'rg', 'tree', and 'buzz'. This simplifies deployment by consolidating previously separate tools into one package, while maintaining distinct entry points for different agent and developer workflows.

crates/sprig · high confidence

This change adds the core infrastructure for restricting access to users under 18. It introduces an \AgeRestrictionPage\ UI, an \AgeSignalProvider\ that queries a native platform channel for age data, and an \AgeSignalPushBootstrap\ that manages push notification permissions based on age status. The implementation is designed to fail open—allowing access if the native check is unavailable or times out—and is currently disabled in production builds via a feature flag, requiring explicit opt-in for enforcement.

_mobile/lib/features/age\gate · high confidence

The SDK now includes a formal agent-to-broker action contract, defining the closed set of operations (such as channel reads, message posting, reactions, and agent lifecycle management) along with their strict request/response wire formats, argument validation, and HTTP transport binding. This enables agents to interact with a host via a standardized, idempotent API. Additionally, an example utility is provided to compute NIP-OA auth tags for agent keypairs, supporting the authorization flow required by the broker contract.

crates/buzz-sdk · high confidence

The new \buzz-acp\ crate provides the core harness for launching and communicating with AI agent subprocesses (such as Goose, Codex, and Claude) over stdio using the Agent Communication Protocol (ACP). It manages the full agent lifecycle—including initialization, session creation, and prompt execution—with robust timeout handling (idle and hard deadlines) and JSON-RPC 2.0 error mapping. The harness enforces strict security and stability measures, such as capping NDJSON line sizes to prevent OOM and isolating agent-specific environment variables. It also integrates with the Nostr relay to fetch the agent's persistent 'core' memory (engram) and injects a comprehensive base prompt that defines the agent's workspace layout, communication patterns, and engineering discipline.

crates/buzz-acp/src · high confidence

A new \buzz-dev-mcp\ crate provides a set of MCP tools designed to assist agents during development. The \shell\ tool executes commands with a configurable timeout (defaulting to 2 minutes, capped at 20 minutes) and supports overriding the shell via the \BUZZ\_SHELL\ environment variable. File operations (\read\_file\ and \str\_replace\) now correctly handle Windows-specific path formats, including MSYS absolute paths and tilde (\\~\) expansion, ensuring consistent behavior across platforms. Additional tools include \view\_image\ for loading images as content blocks, \todo\ for managing session checklists, and built-in fallback implementations for \rg\ and \tree\ commands.

crates/buzz-dev-mcp · high confidence

Adds the \buzz-push-gateway\ Helm chart (version 0.3.2) to deploy the public APNs last-hop gateway. The chart provisions a hardened Deployment with a pre-install/pre-upgrade migration Job, a Kubernetes Service, and optional HTTPRoute-based ingress. It enforces strict NetworkPolicies for APNs (port 443) and database (port 5432) egress, while keeping the private metrics port (8081) isolated by default. Observability is opt-in via PodMonitor and PrometheusRule templates, and the chart includes schema validation to ensure correct configuration of grant lifetimes, dogfood profiles, and image references.

deploy/charts/buzz-push-gateway · high confidence

Added the \buzz-ws-client\ crate, providing a new WebSocket client for connecting to Nostr relays. This component implements NIP-42 authentication, allowing users to securely authenticate with relays using their keys and optional NIP-OA authorization tags. It handles the full lifecycle of relay interactions, including sending signed events, parsing incoming relay messages (such as events, acknowledgments, and notices), and managing connection timeouts and errors.

crates/buzz-ws-client · high confidence

The \buzz-auth\ crate now centralizes authentication and authorization logic for the Buzz relay. It implements verification for NIP-42 (WebSocket challenge/response) and NIP-98 (HTTP Auth) events, including strict timestamp validation (±60s), replay protection for NIP-98 via a shared community-scoped seen-set, and rate limiting for messages, API calls, GIF searches, and WebSocket connections. The crate also defines a multi-tenant channel access enforcement layer that scopes membership checks by community to prevent cross-community data leakage, and introduces a granular OAuth-style scope system (e.g., \messages:read\, \admin:channels\) to control user permissions.

crates/buzz-auth/src · high confidence

This change adds the core presence logic for the desktop client, including a subscription reconciler that manages live relay subscriptions with automatic retry backoff and seamless author-set updates, and a presence status resolver that determines online/away states based on OS idle time or in-app activity. It also introduces safe parsing of live presence events that ignores untrusted p-tags to prevent spoofing, and defines heartbeat intervals and TTLs for presence caching.

desktop/src/features/presence/lib · high confidence

This change adds the core React Query hooks for the forum feature, including \useForumPostsQuery\ and \useForumThreadQuery\ which implement a 5-minute stale-time policy to suppress unnecessary refetches on window focus, alongside mutations for creating and deleting forum posts and replies. It also introduces a utility for formatting relative timestamps (e.g., "5m ago") and includes unit tests to verify the focus-refetch behavior.

desktop/src/features/forum · high confidence

Added the \ifc-core\ crate, which provides a generic framework for managing reader-set confidentiality labels. This library introduces \ConfidentialityLabel\ and \ReaderSet\ types to enforce that information only flows to destinations that do not widen the set of authorized readers (e.g., restricting access from {Alice, Bob} to {Alice} is allowed, but widening to {Alice, Bob, Carol} is blocked). It supports operations to combine inputs by intersecting reader sets and ensures labels remain within isolated universes, providing the foundational logic for access control without being tied to specific application protocols.

crates/ifc-core · high confidence

Buzz Desktop now includes a local Pocket text-to-speech engine (April INT8 bundle) and a system for importing and managing local reference voices. This change adds the \buzz-voice\ crate, which provides the \PocketTts\ runtime for synthesizing speech using ONNX models, and the \PocketVoiceLibrary\ for validating, storing, and retrieving user-imported voice WAV files. Users can now import local audio files to customize voice styles, with the system handling canonicalization, hashing, and persistence in a local registry.

crates/buzz-voice · high confidence

The mobile app now supports a dedicated forum feature within channels. Users can view a list of forum posts (Nostr kind 45001) with previews, tap to open full threaded discussions, and compose new posts or replies using the existing compose bar. The implementation includes data models for posts and replies, a provider layer to fetch and submit events via the relay, and UI components for post cards and thread pages, including support for agent mentions and profile sheets.

mobile/lib/features/forum · high confidence

The mobile app now supports managing multiple communities simultaneously, replacing the previous single-community model. This change introduces a new \Community\ data model and a \CommunityStorage\ layer that persists community configurations in secure storage, including an automatic migration path for legacy single-community credentials. Users can now switch between paired communities, with the app handling relay icon lookups via NIP-11 and enforcing role-based access control (owner, admin, member) through membership snapshots. Additionally, sensitive actions such as identity export now require explicit device authentication (biometrics or PIN) via a new \SensitiveActionAuthorizer\, ensuring that critical operations are protected by local device security.

mobile/lib/shared/community · high confidence

The desktop app now supports syncing appearance preferences (theme, accent color, and system-follow mode) to individual communities via the relay, ensuring that each community can maintain its own look and feel. This change introduces an adaptive theme engine that derives UI chrome colors from syntax themes, adds the branded Buzz and Buzz Dark themes with sidebar gradients, and includes a new ThemePreviewFrame for visualizing these settings. The system also handles local persistence and outbox-based sync for offline edits, while preserving the user's global appearance as a fallback for new communities.

desktop/src/shared/theme · high confidence

The \buzz-db\ crate now includes a new \buzz-datastore-tracing\ proc-macro (\datastore\_span\) that instruments logical database operations with OpenTelemetry spans and Prometheus histograms, enforcing a security policy that excludes function arguments and error values from logs while recording operation duration and outcome. Additionally, the crate exposes detailed writer-pool connection setup metrics (broken down by steps like \PhysicalConnect\ and \SessionTimeouts\) and operation-aware pool acquisition telemetry, providing operators with granular visibility into database connectivity and pressure.

crates/buzz-db · high confidence

The desktop app now includes a dedicated presence feature, adding UI components (PresenceBadge, PresenceDot) to display user status indicators and React hooks (usePresenceQuery, usePresenceSubscription) to manage presence data via live WebSocket subscriptions and REST fallbacks. This replaces previous polling mechanisms with a subscription-based model that updates the cache in real-time and scopes subscriptions to active query demands, improving responsiveness and reducing unnecessary network traffic.

desktop/src/features/presence · high confidence

The Buzz relay is now deployable via a comprehensive Kubernetes Helm chart that supports both quickstart evaluation and production profiles. The chart includes a main relay Deployment with configurable autoscaling (CPU and WebSocket metrics), a standalone pairing-relay Deployment, and optional in-cluster MinIO for local testing. It provides flexible networking via standard Ingress or Gateway API HTTPRoute, Prometheus monitoring via ServiceMonitor, and robust configuration validation to prevent misconfigurations at template time. Operators can manage secrets via an existing Kubernetes Secret or let the chart auto-generate them for quickstarts, with clear guidance on GitOps safety and backup requirements.

deploy/charts/buzz/templates · high confidence

The \buzz-push-gateway\ crate now provides a stateful, capability-gated last-hop for Apple Push Notification service (APNs) deliveries. It introduces a new database schema for managing installation authority, relay delegations, and endpoint quotas, alongside an App Attest verifier to securely enroll iOS devices. The gateway issues authenticated, expiring endpoint grants and routes push payloads via a configurable HTTP/2 APNs transport, supporting both production and sandbox environments.

crates/buzz-push-gateway · high confidence

The \buzz-cli\ crate is introduced, providing a command-line interface for interacting with the Buzz relay. It enables users to create and update agent drafts via owner-reviewed observer frames, manage ephemeral channels with TTLs, and handle media uploads with NIP-92 metadata and NIP-98 authentication. The CLI also supports parsing and generating \buzz://\ deep links for messages, repositories, pull requests, and issues, ensuring compatibility with the desktop client's rich preview cards. Additionally, it features an agent-friendly help tree, robust retry logic for transient relay failures, and specific error handling for Nostr key operations and relay conflicts.

crates/buzz-cli/src · high confidence

The desktop Home screen now consolidates activity into a single unified view. Users see a main Inbox list that merges channel messages, mentions, and thread activity, alongside a dedicated Reminders section that integrates due reminders into the message timeline. Project work items (pull requests and issues) are surfaced directly in the Inbox with their own filter and canonical subject labels. The new layout supports narrow and wide modes, preserving selection state and draft/reminder details in a side panel, and includes logic to handle unread projections, thread grouping, and deep-linking to channels and messages.

desktop/src/features/home/ui · high confidence

Adds the core infrastructure for displaying user statuses (text and emoji) in the desktop app. This includes a \UserStatusLookupProvider\ that batches pubkey lookups to optimize network requests, hooks for fetching and caching status data via React Query, and logic to handle status expiration and versioning to ensure the most recent status is always shown. Comprehensive tests cover focus-based refetch policies, status expiration, and race conditions between live updates and history resolution.

desktop/src/features/user-status · high confidence

The desktop sidebar now supports user-defined sections that let you group related channels together. You can create, rename, and delete sections, assign channels to them, and reorder both sections and channels within them using drag-and-drop. Sections can be customized with names and emoji icons, and the sidebar context menu includes options to move channels between sections or create new ones directly from a channel.

desktop/src/features/sidebar/ui · high confidence

The \buzz-workflow\ crate now provides the core engine for channel-scoped automations, allowing users to define workflows in YAML that react to events like messages, reactions, or cron schedules. The engine executes steps sequentially, supporting template variable substitution (e.g., \{{trigger.text}}\) and conditional logic. A key architectural change is the introduction of \ActionSink\, which replaces the previous HTTP loopback pattern with direct database access for side effects like sending messages, ensuring workflows post into the correct community context and avoiding authentication errors. The engine also includes a fail-closed authority check to ensure workflow owners retain valid channel permissions before execution.

crates/buzz-workflow · high confidence

A new startup script (script/start) has been added to handle the container entrypoint logic. It bridges Istio's abstract Unix socket to a local file socket using socat when the SIDECAR\_LISTENER\_BIND environment variable is present, ensuring compatibility with the CAKE container contract. The script also configures default ports for health checks (8080) and Prometheus metrics (9102) and executes the buzz-relay binary.

script · high confidence

Users can now define, distribute, and manage AI agent personas using the new Persona Pack format, which extends the Open Plugin Spec. The \buzz-persona\ crate provides the core logic to load pack directories, parse \plugin.json\ manifests and \.persona.md\ files, and resolve behavioral configurations by merging pack-level defaults with per-persona overrides. It also handles validation of pack structure, persona naming, and file sizes, and resolves environment variables for different agent runtimes (e.g., Goose, Buzz-agent).

crates/buzz-persona · high confidence

The desktop app now includes a new feature-gating infrastructure located in \desktop/src/shared/features\. This system reads a \preview-features.json\ manifest to define experimental features (such as Projects and Workflows) and allows users to enable or disable them via a new Experiments settings UI. The implementation provides a \FeatureGate\ component for conditional rendering, React hooks (\useFeatureEnabled\, \useFeatureToggle\) for state management, and a \localStorage\-based override store that persists user preferences. Stable features not listed in the manifest remain enabled by default, while preview features are disabled unless explicitly toggled on.

desktop/src/shared/features · high confidence

The new \buzz-core\ crate provides the shared, zero-I/O foundation types for the Buzz relay, including event wrappers, NIP-01 filter matching, and a registry of custom Nostr event kinds (such as agent engrams, managed agents, and turn metrics). It establishes the data model for channels and member roles, implements the invite-link v2 code contract, and defines the git permission system with ref-pattern matching. Additionally, it introduces strict SSRF protection by classifying and blocking IPv6 transition addresses (NAT64, SIIT) and embedded IPv4 ranges to prevent outbound requests to non-public network targets.

crates/buzz-core/src · high confidence

The relay now exposes a private deployment-admin API at /api/admin/v1 for moderation tasks such as managing reports, feedback, and operator staffing, secured via NIP-98 authentication with configurable Operator and Moderator roles. Additionally, a new shared admission module enforces rate limits on WebSocket and HTTP API traffic, rejecting requests that exceed configured quotas or when the underlying rate limiter is unavailable.

crates/buzz-relay/src · high confidence

Adds the core library for a new durable, heartbeated deletion system that manages community-wide data removal. This implementation introduces a lease-based mechanism (ServingWriteGuard) to coordinate external side effects like S3 and Redis cleanup across replicas, ensuring that deletion operations are not interrupted by network issues or replica failures. It provides the foundational store adapters and execution logic for whole-community deletion requests.

crates/buzz-deletion · high confidence

Adds the core Dart implementation for the mobile push notification system, including a native bridge for iOS authorization and APNs registration, a bootstrap process that waits for relay connectivity and NIP-11 push capability, and a durable outbox for managing push lease revocations. The change also introduces a presentation cache to export verified profile and channel metadata to the native layer, alongside providers that synchronize desired push subscriptions with the user's active community and mute state.

mobile/lib/shared/push · high confidence

The iOS app now includes a dedicated \BuzzPushKit\ framework that handles the full lifecycle of push notifications. This adds support for communication-specific notification presentation (including sender avatars and group context), secure device enrollment with App Attest, and a local presentation cache to ensure notifications display correctly even during cold starts. It also implements age-restriction enforcement via file locking and resolves sender identities using NIP-19 npub labels.

mobile/ios · high confidence

The \buzz-feature-flags\ crate provides a provider-neutral API for evaluating typed boolean and integer feature flags, allowing server components to use flags without importing vendor-specific SDK types. It includes a \StaticEvaluator\ for testing, an \EnvironmentEvaluator\ that reads flags from \BUZZ\_FEATURE\FLAG\\ environment variables, and an optional \LaunchDarklyEvaluator\ gated behind the \launchdarkly\ feature. The crate enforces a compile-time contract requiring exactly one provider feature (\static-feature-flags\, \environment-feature-flags\, or \launchdarkly-feature-flags\) to be selected, ensuring fail-closed startup behavior. This infrastructure is currently not yet wired into the \buzz-relay\ artifact, which remains unchanged.

crates/buzz-feature-flags · high confidence

This change establishes the foundational shell for the desktop application, introducing the main \App\ component that manages the initial boot splash, onboarding flows, and community switching. It adds the \AppShell\ component, which serves as the central layout container for the sidebar, top chrome, and main content surfaces, while also wiring up critical desktop-specific behaviors such as window drag regions, macOS traffic-light clearance, and back/forward navigation controls. The update includes the \AppHuddleShell\ to encapsulate voice conversation UI and the \AppWorkflowEditorOverlayProvider\ to allow workflow editing as an overlay across different app surfaces. Additionally, it implements the \AppShellContext\ to provide a unified source of truth for read-state management (channels, threads, and messages) and adds helper utilities for handling desktop notification activation and routing.

desktop/src/app · high confidence

This change introduces the \buzz-agent\ crate, establishing the core agent runtime logic, authentication mechanisms, and Databricks model integration. The agent runtime (\agent.rs\) implements the main execution loop, including a reply guard to prevent silent turns, recovery from unsupported image inputs and token truncation, and tool call gating via session permissions. Authentication (\auth.rs\, \auth\_http.rs\) provides a PKCE OAuth engine with on-disk caching, cross-process locking, and strict workspace validation for Databricks. The Databricks integration (\catalog.rs\, \databricks.rs\, \databricks\_label\_grammar.rs\) adds model discovery for both workspace endpoints and Unity Catalog, with a deterministic label grammar for human-readable model names. Built-in tools (\builtin.rs\) include lazy skill loading, and configuration (\config.rs\) supports thinking effort levels and provider-specific routing.

crates/buzz-agent/src · high confidence

The desktop app's navigation has been migrated to TanStack Router, introducing file-based route definitions for the Home, Channels, Projects, Workflows, Pulse, Agents, and Settings surfaces. This change adds dedicated route screens for channel threads and forum posts, implements a redirect for the legacy /reminders path to preserve bookmarks, and introduces lazy-loaded components with skeleton loading states across these views. Search highlight state is now managed via route state to persist across navigation, and settings route validation migrates legacy section parameters (doctor, moderation) to their new equivalents (agents, relay-admin).

desktop/src/app/routes · high confidence

The mobile application now bootstraps with a dedicated entry point that initializes push notification handling and pre-loads user preferences to ensure the correct theme is applied immediately. Additionally, upon joining via an invite, the app automatically ensures membership in specific public starter channels (such as 'general' and 'welcome-everyone'), creating them if they do not already exist within the community.

mobile/lib · high confidence

The mobile app now supports full community invitation workflows. Community owners and admins can create invite links with configurable expiration (1, 3, 7, or 30 days) and usage limits (1, 3, 5, 10, 25, or unlimited), then share or copy them. Users can also be invited directly by searching for their npub, with the system resolving their profile and allowing role assignment (subject to the inviter's permissions). Recipients can join via deep links, with the app handling existing community switches and ensuring starter channels are set up after membership is claimed.

mobile/lib/features/invites · high confidence

The mobile app's visual identity has been rebuilt to match the desktop design language, introducing a new theming engine that supports per-community theme preferences and accent color selection. This change replaces the previous Catppuccin-based styling with a system that derives Material 3 color schemes from desktop syntax themes, adds a 'Buzz' branded theme with a distinctive top-section gradient, and standardizes UI elements like border radii, spacing grids, and typography (Inter font) to mirror the desktop 'New York' style. Users will see a more cohesive look across platforms, with the ability to choose from multiple accent colors and have their theme preferences synced per community.

mobile/lib/shared/theme · high confidence

The \buzz-pubsub\ crate introduces a Redis-backed pub/sub system scoped to server-resolved community IDs, enabling multi-tenant event fan-out and presence tracking. To support horizontal scaling, it adds cross-pod cache invalidation (dropping stale membership, visibility, and accessible-channels entries) and connection-control commands (disconnecting banned users across pods) via dedicated Redis pub/sub channels. The subsystem also includes a NIP-98 replay seen-set guard using atomic Redis SET NX EX operations and a fixed-window rate limiter using an atomic Lua script to prevent key-TTL drift.

crates/buzz-pubsub · high confidence

The profile panel now supports archiving and unarchiving identities on the relay, allowing users to manage their visibility. This feature hides archived identities from discovery surfaces like autocomplete and search while ensuring the current user remains visible to themselves to prevent shadowbanning. Users can archive identities if they are the relay owner, admin, or the owner of the identity, with clear toast notifications confirming the action.

desktop/src/features/identity-archive · high confidence

The mobile app now includes an Activity tab that presents a conversation-oriented inbox feed. This feed aggregates mentions, thread replies, workflow approvals (needs-action events), agent job lifecycle updates, and recent direct messages into a unified list. Users can filter the view by category (All, Mentions, Threads, Needs Action, Activity, Agents, Reminders, Drafts) and toggle an unread-only view. Each row displays the sender's avatar, a contextual label (e.g., 'Mentioned in \#channel'), and a message preview; tapping a row deep-links to the oldest unread message in the conversation group. The interface supports swipe-to-mark-as-read/unread actions, displays 'New' dividers between read and unread items, and includes dedicated surfaces for local drafts and NIP-ER reminders.

mobile/lib/features/activity · high confidence

Added a new \buzz-dataset\ benchmark suite to evaluate Buzz agent behavior in collaboration scenarios. The suite includes tasks for resolving ambiguous user mentions, creating channels with precise membership, isolating cross-thread requests, aggregating interleaved agent reports, retrieving cold memory, preserving multiline message formatting, and naming agents in narrative without triggering notifications. Each task includes deterministic verifiers to grade specific behavioral contracts.

benchmarks · high confidence

The desktop Home view now functions as a unified inbox, introducing several new capabilities. It tracks read and done states for feed items using local storage and NIP-RS markers, allowing users to mark items as read or unread. Hidden direct messages can be reopened from the inbox context, with logic to deduplicate requests and handle errors. Drafts are now visible and manageable within the Home feed, with auto-selection and deletion support. The home feed query uses a focus-refetch policy to suppress unnecessary refetches on window focus, improving performance. Additionally, thread context for inbox items is loaded with ancestor and descendant events, and message editing is supported within the inbox context.

desktop/src/features/home · high confidence

This change introduces the core logic for the redesigned Huddle experience in the desktop app. It adds a presence runtime that tracks participant joins, leaves, and session liveness via relay events, ensuring accurate participant lists even after disconnects. It also adds an audio pipeline using Web Audio Worklets to stream microphone input to the Rust backend for speech-to-text, supporting push-to-talk and voice-activity modes. Additionally, it includes logic to route and speak live agent text messages via text-to-speech, and provides utilities for naming huddle channels and handling errors.

desktop/src/features/huddle/lib · high confidence

The mobile app now supports the NIP-AB protocol for pairing devices, replacing the legacy flow. Users can pair by scanning a QR code or pasting a \nostrpair://\ URI, which triggers a cryptographic handshake involving ECDH key exchange and SAS (Short Authentication String) code verification to ensure security. The pairing UI includes a dedicated welcome screen and, on supported iPhones, a native Dynamic Island QR scanner portal that animates from the cutout; other devices use a standard full-screen fallback scanner. The implementation handles ephemeral WebSocket connections for relay communication, parses pairing URIs with strict validation, and supports identity recovery and community addition modes.

mobile/lib/features/pairing · high confidence

This change introduces the core logic for the new Pulse social notes surface, enabling users to interact with and view social content. It adds a \usePulseNoteActions\ hook that provides upvoting, replying, sharing (via native clipboard), and direct messaging capabilities for notes. Supporting libraries handle specific behaviors: \groupAgentNotes\ collapses consecutive notes from the same author into time-bounded groups, \replies.ts\ determines the correct parent note for threaded conversations, \noteActions.ts\ manages reaction state and duplicate error detection, and \projectComments.ts\ filters out repository-related comments to keep the social feed clean.

desktop/src/features/pulse/lib · high confidence

The application now exposes four new React context providers in the shared context layer to manage state and actions for key UI features. AgentSessionContext allows components to trigger the opening of agent sessions by public key and channel. ChannelNavigationContext provides a memoized list of channels and non-DM channel names to optimize rendering for consumers like message rows. ProfilePanelContext enables opening user or agent persona profile panels with specific tab options. WorkflowEditorOverlayContext allows any surface to open the workflow editor as a modal overlay, optionally pre-selecting a channel or passing an existing workflow object to skip loading states.

desktop/src/shared/context · high confidence

Users can now set reminders on messages via a new 'Remind me later' dialog that offers preset times or a custom date/time picker, along with an optional note. The desktop app includes a dedicated Reminders Panel (inbox) that lists reminders, showing the original author and source channel, and allows users to click to navigate back to the message, complete, snooze, or cancel reminders. A context provider manages the dialog state and tracks active reminders for UI cues like channel tinting.

desktop/src/features/reminders/ui · high confidence

The admin-web area now provides a dedicated React-based moderation dashboard that allows operators to review open reports and manage user feedback. The interface displays a list of open reports with community and target details, and allows drilling into a report detail view to see the full reported message content (including deletion status). It also features a feedback management section where operators can view feedback summaries, search and filter by community and time, and update feedback status via PATCH requests. The dashboard handles authentication by probing the relay and supports NIP-98 signed events for API calls, ensuring secure access to moderation data.

admin-web · high confidence

Added a suite of new TypeScript modules and corresponding tests in the agent library to support agent access controls, mention filtering, and UI state management. This includes \agentAccessWarning\ for generating user-facing warnings based on agent run location and access mode, \agentAutocompleteEligibility\ for filtering mentionable agents based on channel membership and allowlists, \agentCardAvatar\ and \agentCardGalleryState\ for resolving avatars and managing gallery view states, \agentCardModelLabel\ for displaying model labels with Databricks alias support, \agentConfigCore\ for deriving configuration field models from runtime catalogs, \agentDescription\ for handling description clamping and counting, \agentParallelism\ for resolving parallelism values and caps, and \autoRestartPolicy\ for managing safe auto-restart conditions.

desktop/src/features/agents/lib · high confidence

Users can now add agents to channels via a new dialog that supports selecting existing personas, creating new generic agents, and managing agent teams, with options to reuse existing agent instances or create new ones. Additionally, a channel canvas history panel has been added, allowing users to view revision history, see line diffs, and restore previous versions of canvas content with conflict checking and accessibility support.

desktop/src/features/channels/ui · high confidence

The desktop application introduces several new UI components for managing agents and teams. Users can now add agents and teams to channels via dedicated dialogs (\AddAgentToChannelDialog\, \AddTeamToChannelDialog\) that handle role assignment and runtime resolution. Agent configuration has been expanded with new fields for selecting ACP commands (\AcpCommandField\) and managing AI defaults (\AgentAiConfigurationMode\, \AgentAiDefaults\), including a badge to indicate when required environment variables are missing. Additionally, a new 'Agent Card' feature allows users to mint, view, and share agent trading cards (\AgentCardMintDialog\, \AgentCardViewerDialog\), which encapsulate agent identity and optional memory.

desktop/src/features/agents/ui · high confidence

Users can now create animated avatars directly in the desktop app by recording a short video clip, adjusting framing and backdrop colors, and reviewing the result. The profile panel also includes a new confirmation dialog for archiving identities or agents, which hides them from the current space without deleting them.

desktop/src/features/profile/ui · high confidence

The \buzz-admin\ tool is introduced to provide administrators with a command-line interface for managing Buzz relay instances. It includes member management commands (add, remove, list) that update the database and publish NIP-43 kind:13534 roster updates via Redis, as well as a \deletions\ subcommand for durable whole-community deletion. Additional capabilities include automatic database migration execution, S3 storage snapshot generation with bounded startup retries, and a \reconcile-channels\ command to republish channel discovery events. The tool also exposes a \product-feedback\ list command for inspecting deployment-wide feedback.

crates/buzz-admin · high confidence

The desktop app now includes a dedicated UI for managing community members and invitations. Users can directly add members by searching for their identity (pubkey/NIP-05) and assigning roles (Member or Admin) via the new AddMemberDialog. Community owners and admins can manage existing members through the CommunityMembersCard and CommunityMembersSettingsCard, allowing them to promote/demote roles and remove members with confirmation dialogs. Additionally, a new CommunityInviteDialog enables sharing invite links with configurable expiration (1, 3, 7, or 30 days) and usage limits (1, 3, 5, 10, 25 uses, or unlimited), with the link automatically copied to the clipboard upon generation.

desktop/src/features/community-members/ui · high confidence

This change introduces a suite of new UI components for the desktop application's community features. Users can now add communities via a new \AddCommunityDialog\ that supports creating hosted communities or joining via invite links. A \CommunitySwitcher\ component provides sidebar and profile-menu navigation for switching between communities, leaving communities, and managing invites. Community settings are now editable through \EditCommunityDialog\ and \CommunityChangeOverlay\, allowing updates to names, relay URLs, tokens, and repository directories, with an integrated \CommunityIconSettingsCard\ for changing icons. The \WelcomeSetup\ page guides new users through joining, creating, or reconnecting to communities, while \HostedCommunityOnboarding\ and \HostedCommunityCreateFlow\ handle the specific flows for hosted community accounts. Error handling is improved with \CommunityApplyErrorScreen\ for connection failures.

desktop/src/features/communities/ui · high confidence

The desktop application introduces a comprehensive new API layer in \desktop/src/shared/api\ to handle core communication and agent management. This includes dedicated modules for managing custom emoji sets (NIP-30), handling invite minting and claiming, and executing community moderation actions (reports, bans, timeouts). It also adds support for editing messages, fetching forum posts and threads, and managing community profile icons. Furthermore, the layer provides direct control over managed agents, allowing users to switch models and cancel turns, while also exposing functions to discover available ACP commands and agent models.

desktop/src/shared/api · high confidence

The desktop build pipeline now includes a suite of new scripts in \desktop/scripts\ to manage protected features, release configurations, and platform-specific packaging. \build-protected-feature-artifacts.mjs\ enforces a contract between OSS and internal builds, ensuring protected 'Bestie' content does not leak into public artifacts. \build-release-config.mjs\ generates Tauri release configurations with updater endpoints and minimum macOS system version requirements. Platform packaging is handled by \package-macos-dmg.sh\ and \fix-appimage.sh\, the latter patching AppImages to resolve crashes on modern Linux distros by removing conflicting bundled libraries. Additional scripts manage demo build identities (\demo-build-config.mjs\), file-size policies (\check-file-sizes.mjs\), UI consistency (\check-pubkey-truncation.mjs\, \check-px-text.mjs\), and CI test visibility (\summarize-flaky-tests.mjs\).

desktop/scripts · high confidence

The desktop messaging interface introduces several new UI components to enhance message composition and display. AudioMessageAttachment enables voice note playback with waveform visualization and download support. ComposerAddressControls provides a visual interface for managing automatically mentioned agents, including animations and removal controls. ChannelAutocomplete adds support for inserting channel links via autocomplete. BotIdenticon generates deterministic avatars for bot instances. ChannelIntroBlock renders the empty-channel state with description and action cards. ComposerAttachments handles media previews, uploads, and editing within the composer. ComposerDockToolbar and ComposerDockBackdrop manage the layout and visual styling of the composer dock. ComposerEmojiPicker integrates emoji and GIF selection into the composer. ComposerImageEditor allows users to annotate images with pen strokes before sending. ComposerActivityAccessory provides a fade-in animation for activity content in the composer dock.

desktop/src/features/messages/ui · high confidence

The desktop app now uses a new set of hooks in the messages feature to manage channel timelines, thread replies, and typing indicators. This includes \useThreadReplies\ for fetching and caching thread subtrees with retry logic for missing events, \useChannelTyping\ and \useTypingBroadcast\ for real-time typing status, and \useFetchOlderMessages\ for scrollback pagination. The \hooks.ts\ file centralizes message creation and sending logic, while \useIndependentThreadPanel\ optimizes thread rendering performance. A new test file \combineThreadRepliesResults.test.mjs\ validates the aggregation of thread reply results.

desktop/src/features/messages · high confidence

The desktop settings UI now includes dedicated panels for managing agent defaults (provider, model, effort, and environment settings inherited by local agents), configuring appearance preferences (theme, font size, conversation density, and link preview style with live previews), and handling NIP-49 encrypted key backups (creation with passphrase generation and verification flow). These changes introduce new UI components and state management logic for these specific settings areas.

desktop/src/features/settings/ui · high confidence

Added \useUpdater\ and \UpdaterProvider\ hooks to manage desktop application updates, including silent background checks every six hours, automatic downloads on supported platforms, and a manual-download fallback for Linux .deb installs. Added \useSendFeedback\ hook to collect diagnostics and submit product feedback with optional image attachments via the relay client.

desktop/src/features/settings/hooks · high confidence

Users can now set and view detailed status messages in the desktop app. The new SetStatusDialog allows selecting from presets (e.g., 'In a meeting', 'Vacationing'), custom emojis via a full emoji picker, and setting expiration durations (1 hour, 8 hours, Today, This week, or Custom). Status indicators, including the selected emoji and huddle presence, are now displayed next to user names in chats and DMs, with tooltips providing additional context.

desktop/src/features/user-status/ui · high confidence

Added a suite of new scripts to the \scripts/\ directory to improve developer experience and CI reliability. \build-sprig.sh\ and \bundle-sidecars.sh\ automate the creation of the all-in-one Sprig multicall binary and the bundling of sidecar binaries for the desktop app. \buzz-adopt-prod-agents.sh\ allows developers to restore production agent records and identity after a reset, preventing duplicate instances. Several pre-push and CI guardrails were introduced: \check-branch-skew.sh\ blocks pushes when local branches are behind main and touch overlapping files; \check-file-sizes-core.mjs\ (with tests) enforces line-count ceilings per surface; \check-pubkey-truncation-core.mjs\ prevents insecure hand-rolled pubkey truncation; \check-px-text-core.mjs\ blocks hardcoded pixel text sizes to ensure zoom scalability; \check-pr-image-urls.sh\ warns against using relay media URLs in PRs; and \check-push-head-scope.sh\ warns when pushing non-checked-out commits. Additionally, \backfill-d-tag.sql\ provides a migration for NIP-33 events, \check-postgres-test-discovery.py\ validates Rust test discovery, \ci-mesh-lifecycle-smoke.sh\ runs a relay-driven mesh lifecycle test, and \\_goose-env.sh\ standardizes the environment for the goose agent.

scripts · high confidence

A new standalone relay service has been added to handle NIP-AB device pairing handshakes. It accepts WebSocket connections, matches incoming kind:24134 events against live subscriptions, and forwards matches to the subscriber. The relay is designed to run behind a reverse proxy, binding to loopback only, and enforces strict security measures including Schnorr signature verification, resource bounds (128 max connections, 4 KiB frames), and deduplication to ensure secure, stateless pairing.

crates/buzz-pair-relay · high confidence

Added a new \git-sign-nostr\ crate that implements NIP-GS, allowing users to sign git commits and tags using Nostr secp256k1 keys via BIP-340 Schnorr signatures. This tool acts as a pluggable signing backend for Git (configured via \gpg.x509.program\), supporting both signing and verification modes. It loads private keys from environment variables (\NOSTR\_PRIVATE\_KEY\ or \BUZZ\_PRIVATE\_KEY\) or keyfiles, and emits GnuPG-compatible status lines to indicate signature validity and NIP-OA (Owner Attestation) status. The implementation is Unix-only and includes best-effort secret zeroization.

crates/git-sign-nostr · high confidence

The \buzz-relay-mesh\ crate introduces a new authenticated QUIC mesh layer that enables direct, low-latency communication between relay pods. This change adds a full mesh transport using the iroh library, featuring boot-unique runtime identities, scuttlebutt-style membership gossip for liveness tracking, and a fenced wire contract that carries both reliable streams (for tunnel data) and realtime datagrams (for huddle media). The mesh is opt-in via the \BUZZ\_MESH\ environment variable and integrates with a Redis-backed ready registry for secure peer discovery, allowing multi-pod deployments to route traffic directly between relays instead of relying solely on the central hub.

crates/buzz-relay-mesh, deploy/local · high confidence

The Projects feature now includes a new set of library modules in \desktop/src/features/projects/lib\ that power core collaboration and repository workflows. \discussionChannels.ts\ and its tests implement logic to discover and group chat channels where a PR, issue, or repository is mentioned, including query construction for full-text search and snippet formatting. \projectAgentConversation.ts\ and \projectAgentConversationStorage.ts\ manage the persistence and restoration of inline agent conversations, ensuring that only relevant messages are shown and that the correct agent is selected. \projectBranches.ts\ and \projectBranchErrors.ts\ provide utilities for normalizing branch names, resolving default branches, and handling relay-specific push errors like missing channel bindings. Finally, \projectCloneUrl.ts\ and \projectCollection.ts\ handle deriving default clone URLs for relay-hosted repositories and merging standalone repositories into project collections.

desktop/src/features/projects/lib · high confidence

The desktop app now includes a dedicated Local Archive Settings card that lets users control which event types are saved locally. This includes toggles for the agent observer feed and agent turn metrics, as well as a grouped checklist for standard event kinds (such as messages, reactions, huddles, and system messages) alongside support for entering custom NIP-01 kind numbers. The interface provides validation for custom inputs and manages subscription state for local archiving.

desktop/src/features/local-archive/ui · high confidence

The mobile app now tracks read status locally using a new \read\_state\ module. This introduces a session-level "force unread" capability, allowing users to mark specific messages or channels as unread (visible in badges and tiles) even if they have been read. The system manages read markers for channels, individual messages, and thread roots, persisting state locally and syncing via NIP-44 encrypted events when remote sync is enabled.

_mobile/lib/shared/read\state · high confidence

The markdown rendering layer in the desktop app has been expanded with a suite of new UI components to support richer message content. Users can now see full destination URLs on masked links via a hover tooltip, and external links feature a custom right-click context menu with options to open or copy the link. Channel deep links are rendered as interactive chips that display metadata (visibility, type, activity status) in a tooltip and allow in-app navigation. Agent and team snapshots appear as importable cards with verification and download actions, while generic files are presented as downloadable cards. Media handling includes a multi-image mosaic grid, an interactive image lightbox with zoom controls, and video players with download eligibility checks. Code blocks now support syntax highlighting with a copy-to-clipboard button, and mentions are rendered as interactive chips that open user profiles. Inline emojis display a popover with the full image and label on hover.

desktop/src/shared/ui/markdown · high confidence

The \buzz-media\ crate introduces a new media storage layer backed by S3/MinIO, featuring configurable URL addressing styles (path vs. virtual) and signing regions. It implements strict NIP-FI compliant authentication for Blossom kind:24242 events, supporting both strict (60s window, mandatory server tag) and permissive (3600s window) modes for backward compatibility. The crate includes a bucket index system for classifying and sweeping S3 keys by community, upload record tracking for moderation side-channels, and video validation with resolution and codec checks.

crates/buzz-media · high confidence

Added several new scripts in the mobile build pipeline: a file-size checker with a policy limiting Dart files in lib to 1200 lines; a tool to generate a mobile-specific emoji dataset from emoji-mart to ensure parity with the desktop client; a script to strip heart and warning emoji mappings from the Inter font to enable native fallback; and a shell/Dart pair to validate and enforce the push gateway origin configuration. These changes support stricter asset management, consistent emoji rendering, and secure push notification configuration in the mobile app.

mobile/scripts · high confidence

This update introduces several new capabilities to the mobile channels experience. Users can now add members to channels via a searchable multi-select sheet that filters out existing participants and handles partial failures. A new agent activity sheet provides a live, auto-scrolling transcript of bot actions, including messages, thoughts, tool executions, and lifecycle events, with a dedicated provider to track which bots are currently typing. Channel management is expanded with a new actions sheet offering options to star channels, toggle read status, move channels to sections, and manage lifecycle actions like archiving or deleting based on user roles. Additionally, the channel data model now supports ephemeral (TTL) channels, and the UI includes an Android-specific IME lift wrapper to improve keyboard interaction stability.

mobile/lib/features/channels · high confidence

This update introduces a comprehensive emoji infrastructure for mobile, including a desktop-compatible emoji dataset, search logic, and visual components like emoji avatars and particle burst animations. It also adds a new 'Remind me later' feature, allowing users to set author-private reminders on messages with preset or custom times.

mobile/lib/shared/widgets · high confidence

The mobile app now uses a dedicated shared relay library (\mobile/lib/shared/relay\) to manage core connectivity and media operations. This introduces a Riverpod-based authentication system that handles community switching and session persistence, alongside a new media pipeline that enforces strict security and performance standards. Users benefit from sanitized animated image uploads (scrubbing EXIF/ICC data from GIFs, PNGs, and WebPs) and authenticated media reads via NIP-98 (kind:24242) tokens, ensuring that media access is tied to the user's identity. Additionally, the new \MediaImageProvider\ prevents fetch stampedes by using stable cache keys and implementing a 429-aware cooldown period, while the app lifecycle provider ensures WebSocket connections are managed efficiently to preserve battery life during backgrounding.

mobile/lib/shared/relay · high confidence

The desktop onboarding flow now includes dedicated UI steps for setting a profile avatar, creating and verifying an encrypted NIP-49 key backup, and completing community profile setup. The backup step lets users view, copy, or download their identity key and offers a password-protected backup option with a verification flow to ensure the file is restorable. The avatar step supports image uploads and emoji avatars with a skip option, while the community flow handles profile details and starter team introduction.

desktop/src/features/onboarding/ui · high confidence

Deployers can now spin up a complete, single-node Buzz relay stack using a new Docker Compose bundle in deploy/compose. This includes a production compose file (compose.yml) that orchestrates the relay with Postgres, Redis, and MinIO, alongside optional configurations for Caddy-based HTTPS (compose.caddy.yml) and development tools like Adminer and Prometheus (compose.dev.yml). The bundle provides a .env.example template for configuration, a run.sh script for lifecycle management (start, stop, upgrade, member management), and documentation in README.md. It supports automatic database migrations via BUZZ\_AUTO\_MIGRATE and configures S3 addressing for the bundled MinIO.

deploy/compose · high confidence

This change introduces the core library logic for the new profile features. It adds \identity.ts\ to stabilize profile lookups and resolve user/agent labels (including 'you' for owned agents), \selfProfileStorage.ts\ to cache self-profiles per relay for offline resilience, \animatedAvatarCapture.ts\ to record and process camera clips into animated avatars, and \nostrIdentityBinding.ts\/\nostrBindCallback.ts\ to handle the browser-based identity binding flow. It also includes \profileActivityAgent.ts\ and \profileActivityFeedScope.ts\ to resolve agent activity status and scope the activity feed, alongside \resolveCanonicalManagedAgent.ts\ to handle persona instance resolution. Comprehensive tests are added for all these modules.

desktop/src/features/profile/lib · high confidence

Added the \buzz-conformance\ crate, which introduces a runtime trace conformance gate to verify that the relay's ingest, auth, and read decisions adhere to the \MultiTenantRelay\ TLA+ spec. The crate defines a trace schema (\TraceStep\, \TraceAction\) emitted at the accept-reject boundary and an independent replay checker that validates these traces against a Rust re-implementation of the spec's \Next\ transition relation. This gate detects violations such as non-interference breaches (foreign community rows in reads), illegal transitions (host/channel mismatches), and coverage breaches (missing trace emissions), ensuring that tenant isolation is observable and verifiable during execution.

crates/buzz-conformance · high confidence

The desktop UI layer introduces a suite of new shared components to standardize appearance and behavior. A canonical PubKey widget now displays and copies public keys with strict validation, preventing fake identities. Visual polish is applied via AnimatedCount for smooth number transitions, AvatarClipPaths for squircle avatar silhouettes, and a unified header hierarchy (PageHeader, SectionHeader, SubsectionLabel). Interaction feedback is enhanced with EmojiBurst and PoofBurst providers for animated reactions, HoverCopyIndicator for clipboard actions, and a DrawerPanelIcon with motion. Structural chrome includes a StartupWindowDragRegion for native window dragging, TopChromeBackdrop for scroll effects, and OverlayPanelBackdrop for side panels. Additional utilities include InlineChip for mention/channel styling, PortalledScrollArea for modal scrolling, and Shimmer for loading states.

desktop/src/shared/ui · high confidence

A new 'MeshComputeSettingsCard' component has been added to the desktop settings UI, providing users with controls to manage shared mesh compute. This interface includes a toggle to enable sharing, a model selector that integrates with the mesh catalog and installed models, and an advanced section for configuring VRAM limits. It also displays real-time serving usage indicators and handles local storage drafts for model preferences, allowing users to easily configure their machine to serve or consume compute within the mesh network.

desktop/src/features/mesh-compute/ui · high confidence

This change introduces a suite of new React hooks in the desktop application to improve responsiveness, layout stability, and user interaction. \useIncrementalMount\ progressively mounts long lists to prevent main-thread blocking, while \useDeferredStartup\ delays non-critical initialization until the UI is interactive. Keyboard handling is refined with \useEscapeKey\ and \escapeSurfaces\ to correctly prioritize panel closures over app-wide shortcuts, and \useWebviewScrollBoundaryLock\ prevents macOS overscroll from disrupting the app layout. Additional hooks manage UI state and layout: \useHistorySearchState\ persists UI state in the URL history stack, \useThreadPanelWidth\ handles resizable panel sizing with session persistence, \use-mobile.tsx\ provides viewport breakpoint detection, \useFileImportZone\ standardizes drag-and-drop file imports, \usePanelReturnTarget\ manages navigation breadcrumbs for panels, \useScrollBoundaryLock\ prevents scroll-overflow, \useStableReference\ optimizes re-renders by preserving object identity, and \useToastEffect\ displays success/error notifications.

desktop/src/shared/hooks · high confidence

Added a suite of new shared libraries in the desktop client to support recent feature work: animated avatars (parsing and building poster/animation URLs), author resolution for relay-signed events, native clipboard integration for text and code blocks, Tailwind CSS class merging, config nudge extraction for agent setup, conversation density preferences, remark plugins for mentions and channel links, custom emoji tag building, and unified relative date formatting for the chat timeline and Inbox.

desktop/src/shared/lib · high confidence

The Desktop app now includes a comprehensive workflow editor and management interface. Users can create, edit, duplicate, and delete workflows via a new dialog that supports both a visual form builder and a raw YAML editor. The UI provides specialized inputs for configuring triggers (including a cron expression builder and channel/author pickers) and actions (such as emoji pickers and duration sliders). Workflows can be managed through a new detail panel that displays run history and definitions, and a card-based list view with inline enable/disable toggles and action menus.

desktop/src/features/workflows/ui · high confidence

Community owners and admins now receive a desktop notification the first time a new key appears in their community roster. This feature uses a persisted ledger to track which members have already been alerted, ensuring that existing members do not trigger notifications on app install or roster sync, and that re-joins or roster updates do not cause duplicate alerts. The system relies on the authoritative kind:13534 membership snapshot for correctness, using kind:8000 deltas only as a latency accelerator to trigger earlier snapshot refetches. It handles edge cases such as burst joins, community switches, and storage quota errors gracefully.

desktop/src/features/community-members · high confidence

The Settings feature now includes a new EncryptedBackupProvider that allows users to create, save, and download password-protected backups of their identity keys, with automatic expiration and toast notifications. Additionally, the update experience has been enhanced with a global UpdateIndicator in the UI, a detailed UpdateChecker section in Settings for manual checks and status tracking, and a new SidebarUpdateCard that notifies users of available updates or requires manual download for certain Linux builds.

desktop/src/features/settings · high confidence

The \buzz-auth\ crate now includes a complete runtime for NIP-FI federated identity, introducing a provider-neutral assertion verifier that validates JWT-based claims against configured issuer policies. This change adds the core verification logic, JWKS key-source management with bounded resource acquisition and snapshot caching, and startup configuration validation to ensure safe deployment. It also defines the public API for verified assertions, including identity resolution, capability extraction, and privacy-preserving denial responses, enabling the relay to enforce federated identity assertions on HTTP ingress.

_crates/buzz-auth/src/nip\fi · high confidence

The Projects surface now includes a suite of new UI components for managing repositories, issues, and pull requests. Users can add or attach repositories via dedicated dialogs, create projects with configurable visibility, templates, and agent personas, and open issues or pull requests with branch selection and validation. A new AgentContextPayloadPreview component lets users inspect the exact metadata appended to outgoing agent messages before sending, improving transparency around untrusted workspace data. Additionally, a DiscussedInChannels component surfaces related conversation channels in PR, issue, and commit detail views, linking users to relevant discussions.

desktop/src/features/projects/ui · high confidence

The Projects feature in the desktop client has been significantly expanded with new capabilities for managing repository branches, handling issue assignments, and tracking project activity. Users can now create and delete remote project branches directly from the UI, with mutations that automatically refresh the repository state. Issue assignment and unassignment operations are now supported, allowing users to assign tasks to specific participants and view the assignment history, which is fetched exhaustively to ensure accuracy even when buried behind many comments. Additionally, a new activity summary system aggregates project events (issues, PRs, commits) into daily contribution graphs and participant lists, providing a richer overview of project engagement. The feature also includes robust project creation and deletion flows, with proper handling of related channels and tombstoning.

desktop/src/features/projects · high confidence

Users can now view an agent's stored memories (engrams) as a structured graph within the profile panel. This read-only feature fetches and decrypts memory entries, displaying them as a tree rooted at the agent's core memory, while separately listing orphaned memories and broken internal links. Access is strictly gated: the section is only visible to the agent's declared owner (verified via local key custody or NIP-OA ownership), ensuring that remote owners can still view their data even if the agent runs on a different desktop. The UI includes skeleton loading states, error handling with retry options, and a manual refresh button.

desktop/src/features/agent-memory · high confidence

The Reminders feature in the desktop app now provides a complete lifecycle for managing due items. Users see a live count of due reminders in the Inbox navigation badge, which updates as items cross their due time. The system introduces new actions to snooze or cancel reminders, with all changes immediately reflected across the UI via a shared query invalidation strategy. Additionally, a new background polling mechanism detects when reminders become due while the app is running, firing desktop notifications (with sound and dock bounce) and updating the UI badge without requiring a manual refresh. A persistent watermark ensures that reminders that became due while the app was closed are surfaced in the UI but do not trigger duplicate notification toasts upon restart.

desktop/src/features/reminders · high confidence

The web application is initialized as a React + Vite + TypeScript project named "Buzz". It establishes a file-based routing structure using TanStack Router with pages for the home view, repository listing, repository detail, invite acceptance, and in-browser file blob viewing. The UI layer is built on shadcn/ui components styled with Tailwind CSS v4 and the Inter variable font, featuring a Catppuccin-inspired color theme with light/dark mode support. Functionally, the client includes a Nostr integration layer (NIP-01 queries, NIP-42 relay authentication, and NIP-07 extension signing) and a platform-aware download resolver that directs users to the appropriate app store or desktop installer based on their device.

web · high confidence

The desktop search experience has been enhanced with two key capabilities. First, the search query parser now recognizes Slack-style operators—\from:\, \in:\, \after:\, and \before:\—allowing you to filter results by author, channel, and date range directly within the search bar. Second, search results now visually highlight the specific terms that matched your query, making it easier to scan and identify relevant messages and channels in the results list.

desktop/src/features/search/ui · high confidence

This change introduces three new shared utilities in the mobile library to support richer content rendering and user interactions. It adds syntax highlighting for code blocks using the \highlight\ package, providing both light and dark theme styles for formatted code display. It also implements a shared animated avatar URL scheme (compatible with the desktop client) that encodes static posters and animated PNGs, along with parsing and building helpers. Finally, it provides a reusable clipboard utility that copies text to the system clipboard and displays a confirmation snackbar.

mobile/lib/shared · high confidence

The desktop sidebar now synchronizes channel muting, starring, custom sections, and sort preferences (alphabetical or recent) across all your devices. These settings are persisted locally with strict storage limits and merged using a last-write-wins strategy when syncing via the relay, ensuring your custom sidebar organization remains consistent whether you switch computers or clients.

desktop/src/features/sidebar/lib · high confidence

The repository now provides a structured local development setup for the Buzz backend. A new \.env.example\ file documents all required configuration variables for Postgres, Redis, Typesense, and the relay, including specific connection strings and pool size defaults. A \.dockerignore\ file has been added to exclude build artifacts, local environment files, and non-essential directories from Docker build contexts, ensuring cleaner and faster image builds. Additionally, a \.gitattributes\ file enforces LF line endings across all platforms to prevent formatting failures in CI, and a \.gitignore\ file standardizes the exclusion of local artifacts, secrets, and tool-specific caches.

(repo-wide) · high confidence

The mobile app now renders community custom emojis (NIP-30) within message bodies and markdown. It fetches a unioned palette of per-user emoji sets from the relay, resolves \:shortcode:\ patterns to their corresponding images, and displays them inline. If an image fails to load or a shortcode is unknown, the app falls back to displaying the literal text, ensuring messages remain readable.

_mobile/lib/shared/custom\emoji · high confidence

The desktop app now supports opening the 'Add Community' dialog with pre-filled data when triggered by a deep link. This is implemented in the \addCommunityPrefill\ module, which manages the request lifecycle and exposes a \useAddCommunityDialogState\ hook to automatically open the dialog and handle cleanup when the user dismisses it.

desktop/src/features/communities · high confidence

The mobile app now parses and handles \buzz://\ deep links, enabling users to navigate directly to specific channels, messages, or relay invite pages from external sources. This change introduces parsing logic for \buzz://channel/\<uuid\>\, \buzz://message?channel=\<uuid\>&id=\<hex\>\[&thread=\<hex\>\]\, and \buzz://join?relay=\<ws\>&code=\<code\>\ URIs, along with a provider to queue and dispatch these links once the app is ready, ensuring that navigation targets are fully validated before use.

mobile/lib/shared/deeplink · high confidence

The \buzz-audit\ crate introduces a new audit logging system that records events (such as event creation, channel updates, and authentication attempts) in a tamper-evident, append-only hash chain. Each community maintains an independent chain keyed by \community\_id\, ensuring that audit data from one tenant cannot interfere with or reveal information about another. The system uses a new TLV-based hash encoding (version 2) for new entries, which prevents field ambiguity and ensures deterministic hashing by sorting JSON keys and truncating timestamps to Postgres microsecond precision. Existing entries remain verifiable using the legacy hash method. The implementation includes per-community advisory locks to ensure chain consistency across relay processes without global serialization bottlenecks.

crates/buzz-audit · high confidence

The new \buzz-terminal\ crate introduces strict security boundaries for the embedded terminal. It prevents command injection by validating channel names and substituting unsafe characters with a UUID, and it stops secret leakage by clearing the child shell's environment and using an allowlist for inherited variables. Additionally, it protects against resource exhaustion and UI freezes by enforcing byte-count limits on parser input and synchronised updates.

desktop/src-tauri/crates/buzz-terminal · high confidence

The agents feature has been restructured to enforce a single source of truth for harness capabilities, moving all metadata (model, provider, effort) to the Rust runtime catalog and removing hardcoded harness-ID checks from the UI. A new boot-warm gate prevents the interface from displaying a cold, unauthoritative catalog during startup, while a split cheap/forced discovery path optimizes runtime updates. Agent turn tracking now uses per-channel watermarks and clock-skew correction to accurately display active work, and a new agent management request system allows agents to request profile updates with strict ownership and channel-visibility validation.

desktop/src/features/agents · high confidence

The desktop layout system now uses a unified \AuxiliaryPanel\ shell to manage right-side panels (such as settings and profiles) across docked, standalone, and floating overlay modes. This change introduces a shared context and header component that handle consistent chrome styling, backdrop blurring, and resize handles, while a new layout engine allows the panel width to scale on ultrawide monitors (up to 720px) while reserving space for the main pane. Supporting infrastructure includes a \MainInsetContext\ and \TopChromeInsetHeader\ to align content with the global top chrome, and a \useMeasuredCssVariable\ hook that dynamically updates CSS variables based on element sizes to ensure proper spacing and clearance.

desktop/src/shared/layout · high confidence

The monolithic global styles for the desktop application have been split into a structured set of modular CSS files (including animations, components, composer, markdown, motion, theme, typography, and scrollbars) along with corresponding test coverage. This refactoring introduces a unified motion system with standardized timing and easing tokens, defines semantic color tokens for the Huddle drawer and tooltips, and implements new user-facing preferences for font size and conversation density that adjust text scaling and spacing independently of layout. The change also adds specific styling for the image lightbox zoom slider, video volume controls, and terminal output, while ensuring all new animations and transitions respect the \prefers-reduced-motion\ accessibility setting.

desktop/src/shared/styles/globals · high confidence

The desktop application has been renamed to Buzz, reflected by the new app icon (buzz.svg) and associated branding assets. Additionally, a dedicated boot stylesheet (boot.css) has been introduced to manage the initial background color, ensuring the window does not flash an unstyled background on cold start while avoiding Tauri Content Security Policy nonce conflicts that would otherwise block runtime style injection.

desktop/public · high confidence

The desktop application now uses a new shared module in \desktop/src/shared\ to handle all deep links (\buzz://\ URIs). This change introduces dedicated React hooks (\useAppDeepLinks\, \useMessageDeepLinks\, \useEntityDeepLinks\) that subscribe to Tauri backend events for messages, entities (repos, projects, issues), and community joins. The logic is centralized in \deep-link.ts\, which manages the queuing and draining of pending deep links to prevent race conditions during app startup or community resets. This refactoring makes the deep-linking behavior unit-testable and ensures consistent routing for both OS-level opens and in-app navigation.

desktop/src/shared · high confidence

The desktop messaging experience now supports editing messages with correct tag merging (attachments, mentions, and emoji) and introduces agent address mentions to preserve composer tray state across edits. Clipboard operations for agent and team snapshots are now supported, allowing users to copy and paste rich agent/team cards as attachments. Voice note handling has been improved with waveform visualization, playback speed controls, and a 5-minute recording limit. Audio media loading is now scheduled with a concurrency cap to prevent performance issues. Agent mention authorization is revalidated at send time, ensuring only authorized agents are mentioned. The system also preserves agent audiences across messages and supports auto-pinning of mentioned agents.

desktop/src/features/messages/lib · high confidence

This change introduces the core logic for desktop notifications in the Buzz app, covering how alerts are triggered, formatted, and handled. It adds per-event sound controls with distinct slots for direct messages, mentions, thread replies, and agent jobs, while silencing notifications from Huddle backing channels. Notification titles now consistently display sender names and channel context, falling back to neutral copy instead of raw public keys. The system prevents duplicate notifications by excluding direct messages from the home feed (relying on WebSocket updates) and ensures that clicking a notification routes the user to the correct thread context, with a fallback mechanism to drain pending macOS activation events if the window invoke hangs. Additionally, it implements channel and thread muting logic to suppress alerts for muted channels or threads, except when the user is directly mentioned or in a broadcast reply.

desktop/src/features/notifications/lib · high confidence

The desktop sidebar now loads instantly by persisting a per-relay, per-identity channel snapshot in localStorage, complete with integrity checks and memoized parsing to avoid redundant reads. Channel member display names update immediately across all cached views without triggering redundant network requests, and hidden direct messages are automatically resurfaced when new activity arrives. Additionally, optimistic canvas saves now provide distinct user guidance for pre-write conflicts versus post-write supersessions, and the inbox correctly preserves forced-unread states across reloads.

desktop/src/features/channels · high confidence

The desktop profile management now includes a robust verification and synchronization layer for avatar uploads. When a user uploads a new avatar, the system first displays a local preview while simultaneously probing the remote server to confirm the image assets are accessible, handling animated avatars by verifying both the poster and animation frames. If the remote verification fails, the system falls back to the original avatar and offers a retry option. The profile data is only saved to the relay and synchronized across all local caches (including search results and batch queries) once the remote presentation is confirmed ready. This process includes automatic retry logic with exponential backoff for transient network errors and ensures that cache refreshes are cancelled if the user switches communities or identities during the save operation.

desktop/src/features/profile · high confidence

The Mesh Compute sharing experience in the desktop app is now more robust and transparent. A fix prevents the 'Share' toggle from incorrectly activating when the machine is merely consuming a peer's compute (client mode) rather than sharing its own (serve mode), ensuring the switch accurately reflects the active role. Additionally, users now receive live feedback during model downloads via a new progress indicator and can see real-time usage statistics—such as whether their shared compute is being used by other mesh members or local agents—through a dedicated usage indicator on the share card.

desktop/src/features/mesh-compute · high confidence

The desktop application now uses a new global stylesheet (globals.css) as the central entry point for styling, importing Tailwind CSS v4 along with a suite of modular style sheets covering themes, typography, animations, and specific UI components like avatars and image lightboxes. This change introduces two critical custom CSS variants: a 'hover' variant that bypasses the default media-query gate to ensure hover interactions work correctly on Windows hosts where pointer capabilities are misreported, and a 'dark' variant that explicitly targets the app's persisted .dark class rather than relying on system preferences.

desktop/src/shared/styles · high confidence

The mobile app now handles user profile data through a new shared profile layer that improves performance and identity accuracy. Profile event parsing and NIP-01 signature verification are offloaded to a background isolate to prevent UI blocking, while an in-memory cache coalesces profile requests into batched relay queries. The system now distinguishes agent identities by verifying the NIP-OA \auth\ tag, exposing a verified owner public key on profiles. Additionally, profile display labels are standardized to show the display name when available, falling back to a compact npub format for unnamed users, ensuring consistent identity presentation.

mobile/lib/shared/profile · high confidence

The \buzz-search\ crate now provides full-text search backed by PostgreSQL's native \tsvector\/GIN index instead of the previous external service. Every search query is strictly scoped to a server-resolved \CommunityId\, ensuring that results from one community never leak into another. The implementation supports filtering by channel scope (including a corrected handling of channel-less events), NIP-01 kind/author filters, and time ranges, with a new \Prefix\ mode for typeahead-style matching. The search layer returns relevance-ranked event IDs, which the relay then refetches and re-authorizes to maintain access control boundaries.

crates/buzz-search · high confidence

The mobile home screen now uses a floating bottom tab bar with three destinations: Home (Channels), Activity, and Search. Switching between tabs triggers a directional slide and fade animation for the content, and the layout is anchored to remain stable even when the on-screen keyboard is visible.

mobile/lib/features/home · high confidence

The mobile app now uses a dedicated shared library to manage agent identities and mention resolution. It fetches relay agent profiles (kind:10100) and verifies NIP-OA ownership to build a directory of known agents, which is used to resolve display names for mentions when local profiles are missing. The new mention binding logic ensures that same-name mentions are bound to their exact selected identities, preventing ambiguous retargeting, and standardizes how public-key identities are displayed (e.g., using npub format). This provides a consistent and accurate mention experience across the mobile client.

mobile/lib/shared/mentions · high confidence

The desktop chat interface now uses a new ChatHeader component that renders the channel title, context-specific icons (such as Lock for private channels, Bot for agents, or Activity for Pulse), and a copy-to-clipboard button. This component supports custom window chrome by wrapping the header in a draggable, blurred backdrop when below the system title bar, and integrates status badges and update indicators to provide consistent visual feedback and navigation context across different desktop views.

desktop/src/features/chat · high confidence

The invite landing page now requires users to explicitly confirm they are 18+ and agree to the Terms of Service and Privacy Policy before they can join a community. This is enforced via a new policy notice component that displays checkboxes for age and legal agreement, with links to view the full documents. The join flow is blocked until these requirements are met, and the policy configuration (including markdown content and versioning) is fetched from the server. Additionally, the page now supports claiming invites directly in the browser using NIP-05 authentication, providing an alternative to the native app deep-link flow.

web/src/features/invite · high confidence

The local archive feature now defaults to enabled for both observer frames and agent turn metrics. On first run, the app automatically seeds the necessary subscriptions (kinds 24200 and 44200) unless the user has previously opted out. User preferences are persisted in device-level localStorage, ensuring that explicit choices (opt-in or opt-out) are respected across app restarts and identity switches. The observer archive reconciliation must complete successfully before the archive sync task starts, preventing data loss for ephemeral frames. Tests confirm that the seeding logic respects user choices, handles storage errors safely, and correctly manages concurrent seeding scenarios.

desktop/src/features/local-archive · high confidence

The mobile Huddles implementation has been updated to use the v2 audio protocol (HuddleWireV2). This change introduces a new shared library in \mobile/lib/shared/huddle\ that handles the v2-specific audio framing, authentication envelope, and transport logic, ensuring compatibility with relays that have not yet rolled out the v3 protocol.

mobile/lib/shared/huddle · high confidence

The database schema has been rewritten to support multi-tenancy, where every tenant-scoped row is bound to a \community\_id\ resolved from the connection host. This introduces new tables for community management, channel membership, and user profiles, alongside a partitioned events table. The update also adds a comprehensive moderation system (reports, bans, timeouts, and audit logs), a git repository name registry, and the durable infrastructure required for push notifications (leases, wake outboxes, and gateway authority). Performance is improved with GIN indexes for event tags, and storage is optimized by excluding encrypted agent metrics and NIP-RS payloads from full-text search.

migrations · high confidence

The desktop client now uses a new \ReadStateManager\ to handle read receipts according to the NIP-RS specification. This change introduces per-message and per-thread read markers (prefixed with \msg:\ and \thread:\) that respect a hierarchical frontier rule, ensuring that reading a parent thread does not incorrectly mark child messages as read. To handle large numbers of channels, the manager splits read-state blobs across multiple relay slots (up to 8) when the data exceeds the 32 KB plaintext budget. Local storage is now bounded by a 7-day horizon and a cap of 1,000 prunable context entries to prevent quota errors, with burst writes coalesced into single persistence operations.

desktop/src/features/channels/readState · high confidence

This change introduces a suite of new TypeScript modules in the channels library to standardize channel data handling and improve the user experience. Canonical channel names are now normalized by stripping leading hashes and whitespace, ensuring consistent matching across the app. Channel search has been enhanced with a lightweight, separator-aware fuzzy scoring algorithm that handles typos and collapsed separators (e.g., matching 'releasenotes' to 'release-notes'). The library also adds logic for managing channel lifecycle states (project, ongoing, temporary) with TTL formatting, refines member roster ordering to sort unnamed members by their full canonical npub, and implements precise recency merging to keep channel lists up-to-date during concurrent updates. Additionally, it enforces stricter rules for private channel member invitations and provides utilities for DM huddle availability and participant display.

desktop/src/features/channels/lib · high confidence

The Pulse feature now uses a custom refetch policy that suppresses redundant data refreshes when the application window regains focus, preventing duplicate network requests that would otherwise overlap with the existing 30-second polling interval. This change, implemented in the Pulse hooks and validated by new unit tests, ensures that data is only re-fetched when it is genuinely stale (older than 5 minutes), improving performance and reducing unnecessary API calls while maintaining up-to-date social notes and reactions.

desktop/src/features/pulse · high confidence

The desktop app now supports platform-standard keyboard shortcuts for history navigation: on macOS, Command+\[ and Command\] trigger back and forward, while on Windows and Linux, Alt+Left and Alt+Right do the same. These shortcuts work globally, including when focus is inside text editors, and also respond to mouse X1/X2 buttons and horizontal swipe gestures on macOS. To prevent data loss, a new navigation guard system intercepts all navigation attempts (route changes, history traversal, and search-result clicks), allowing active components to block or allow the transition before it occurs.

desktop/src/app/navigation · high confidence

The visual appearance of the textured card used during private key onboarding has been refined. This change introduces a new development tool in \desktop/scripts/texture-card\ that generates the nine-slice PNG assets (including light, dark, and compact variants) from a procedural SVG recipe, allowing the team to tune parameters like blur, frequency, and noise to achieve the updated look.

desktop/scripts/texture-card · high confidence

The agent activity feed in the desktop client has been restructured around a new classifier registry and twelve distinct render classes, replacing the previous monolithic rendering logic. This change introduces dedicated components for specific activity types—including messages, tools, thoughts, plans, lifecycle events, permissions, and raw metadata—allowing for more precise visual treatment and behavior. Users will see improved rendering for agent messages (with hover cues to open in chat), clearer permission outcomes (approved/denied/cancelled with distinct styling), and better grouping of tool bursts and plan updates. The new system also supports compact preview variants and ensures that raw JSON-RPC payloads are displayed safely in \<pre\> blocks while other metadata uses polished accordions.

desktop/src/features/agents/ui/activityRenderClasses · high confidence

The mobile settings interface has been completely rebuilt to support per-community appearance customization and streamlined identity handling. Users can now select from a variety of light, dark, and system-following themes, along with distinct accent colors, with a dedicated preview screen that shows how the app will look before applying changes. The settings page is organized into clear sections: Community (for invites and theme selection), Connection (for viewing the public identity key and sending it to desktop for recovery), and Notifications (iOS-only push notification controls). Profile editing is now accessible via a compact bottom sheet, and the overall UI uses a frosted-glass aesthetic consistent with the desktop design language.

mobile/lib/features/settings · high confidence

The desktop notification system has been restructured to support per-event sound slots and alert controls, moving from a single master switch to granular \slotAlertsEnabled\ settings stored in a v2 model. This change introduces a home badge feature that intelligently excludes thread activity already visible in channel previews and respects per-message read markers for accurate unread counts. Additionally, desktop notifications now resolve sender names using a cache-first strategy (React Query and local storage) to ensure toasts display names immediately without waiting for network responses, while also preventing duplicate notifications and managing seen-item history to avoid unbounded storage growth.

desktop/src/features/notifications · high confidence

The desktop client now uses a dedicated set of constants to distinguish conversational messages from system, job, and huddle lifecycle events. This ensures that non-conversational events—such as channel creation, member joins, job updates, and huddle status changes—no longer inflate the unread badge count, eliminating phantom unread notifications while preserving accurate unread tallies for actual chat messages.

desktop/src/shared/constants · high confidence

The app now consistently displays Nostr identities using the NIP-19 npub format instead of raw hexadecimal keys. A new utility in shared utils validates input (accepting both hex and npub strings) and provides a canonical full npub for copying, while showing a compact, truncated label (e.g., npub1…abcd) for recognition in the UI. Invalid or malformed identities are safely replaced with an 'Unknown identity' label rather than leaking raw hex data.

mobile/lib/shared/utils · high confidence

The desktop app now features a centralized emoji picker and a new settings card for managing custom emoji. Users can add, upload, and remove their own custom emoji via the Settings UI, while a unified community palette (the union of all members' sets) is available for selection across all contexts, including message composition, reactions, and status updates. The picker now correctly handles custom emoji shortcodes and disables browser spellcheck/autocorrect on the search field to prevent input interference. Additionally, the emoji search index is prewarmed at idle to ensure the picker opens instantly without performance lag.

desktop/src/features/custom-emoji/ui · high confidence

The desktop search feature now uses a centralized \useSearchMessagesQuery\ hook that enforces a minimum query length of 2 characters for global searches and 1 character for channel-scoped searches, while \useSearchResults\ integrates operator parsing (e.g., \from:\, \in:\) to resolve authors and channels before executing queries. This change ensures that search requests are only triggered when the query meets the specific length threshold for the current scope, reducing unnecessary network calls and stabilizing performance by leveraging React Query's caching and deduplication.

desktop/src/features/search · high confidence

Applies patches to the \virtua\ library to correct virtualized list behavior. The changes introduce support for per-item row heights (allowing the \itemSize\ prop to accept a function), fix scroll correction logic during prepend operations, and resolve issues with timeline virtualization row height seeding, resulting in smoother scrolling and more accurate layout for variable-height content.

patches · high confidence

The workflows feature now uses a custom focus-refetch policy to prevent unnecessary network requests when the app returns to the foreground. Workflow lists and run details skip refetching if the data is less than 10 seconds old, while run approvals skip refetching if less than 5 minutes old, relying instead on their existing polling intervals. Additionally, the workflow runs query now dynamically adjusts its polling interval to 1 second only when active runs are present, stopping the poll when no runs are active to reduce background load.

desktop/src/features/workflows · high confidence

Added benchmark test for channel message delivery performance; Added desktop E2E tests for active-turn resilience, activity scope labels, and agent access controls; Added e2e test suites for multi-tenant isolation, agent content management, and protocol features; Added harness to verify multi-tenant relay bus scaling; Added integration tests for ACP harness, task execution, and diagnostics; Added integration tests for CSP policy and team catalog validation; Added integration tests for buzz-agent recovery, auth, and tool gating; Added integration tests for relay boot lifecycle; Added test coverage for mobile push notification subsystem; Added test coverage for mobile shared widgets and emoji features; Added test coverage for the mobile Activity feature; Added test coverage for the mobile age-gating feature; Added tests for NIP-44 decryption and NIP-OA authentication; Added tests for Pulse compose and note card UI behavior; Added tests for auth provider community transition and credential handling; Added tests for community icon retrieval, membership parsing, and device authentication; Added tests for custom emoji rendering and tag handling; Added tests for deep link parsing, pending link handling, and reminder features; Added tests for mobile agent mention identity and binding logic; Added tests for mobile channel features; Added tests for mobile invite creation and joining flows; Added tests for mobile pairing page, provider, QR scanner, and socket; Added tests for mobile profile editing and camera capture; Added tests for mobile relay shared components; Added tests for mobile settings page behavior and UI; Added tests for mobile theme system and community theme synchronization; Added tests for native font fallback of heart and warning emojis; Added tests for profile caching, user profile display, and identity string utilities; Added tests for search history persistence and search page UI behavior; Added unit tests for mobile Huddles audio and transport layers; Added widget test for app initialization; Added widget testing helper for Riverpod and theme integration; New Playwright E2E test helpers for the desktop app; New e2e testing infrastructure for desktop; New mesh-llm smoke test harnesses for shared compute and admission; New onboarding test coverage for community and machine flows.

This change introduces the foundational dependency configuration for the project, adding the root \Cargo.toml\ and \Cargo.lock\ for the Rust workspace (defining crates like \buzz-relay\, \buzz-core\, and \buzz-acp\ with dependencies such as \tokio\, \axum\, \sqlx\, and \nostr\ v0.44), alongside \package.json\ for the \admin-web\ client (using React v19, Vite v8, and TypeScript v6). It also includes Python project manifests for the \harbor-buzz-orchestra\ benchmark suite. These files establish the build environment and library versions for the backend and admin interfaces.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 53 → 55 (+2.2)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 66 → 67 (+0.5)
• Architecture 50 → 52 (+1.5)
• Maturity 77 → 71 (-6.0)
• Readiness 46 → 52 (+5.4)
• Security 75 → 76 (+0.6)
• Accessibility 54 → 54 (-0.1)
• Performance 70 (new)

• AcpClient::spawn (cognitive 17) (crates/buzz-acp/src/acp.rs)
• Change-coupling hub: e2eBridge.ts → tests.rs, hooks.ts, DefaultConfigStep.tsx, SetupStep.tsx, relayClientSession.ts (desktop/src/testing/e2eBridge.ts)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (crates/buzz-cli/README.md)
• Documentation: written for insiders (benchmarks/buzz-dataset/read-named-path-outside-workspace/README.md)
• Documentation: written for insiders (benchmarks/buzz-dataset/reply-to-thread/README.md)
• Duplicated block (10 lines × 2) (crates/buzz-relay/src/api/media.rs)
• Duplicated block (10 lines × 3) (crates/buzz-relay/src/api/bridge.rs)
• Duplicated block (10 lines × 4) (crates/buzz-relay/src/api/bridge.rs)
• Duplicated block (10–12 lines × 2) (crates/buzz-relay/src/audio/handler.rs)
• Duplicated block (10–12 lines × 2) (desktop/src-tauri/src/relay.rs)
• Duplicated block (11 lines × 2) (crates/buzz-db/src/store/event.rs)
• Duplicated block (12 lines × 3) (crates/buzz-relay/src/api/bridge.rs)
• Duplicated block (13 lines × 2) (crates/buzz-db/src/store/event.rs)
• Duplicated block (14 lines × 2) (crates/buzz-relay/src/api/gifs.rs)
• Duplicated block (15 lines × 5) (crates/buzz-db/src/store/event.rs)
• Duplicated block (15–16 lines × 2) (desktop/src-tauri/src/relay.rs)
• Duplicated block (17 lines × 2) (crates/buzz-db/src/store/event.rs)
• Duplicated block (17–18 lines × 2) (crates/buzz-agent/src/auth.rs)
• Duplicated block (18 lines × 2) (crates/buzz-relay/src/handlers/ingest.rs)
• …and 196 more

• AcpClient::spawn_with_env (cognitive 21) (crates/buzz-acp/src/acp.rs)
• AcpClient::spawn_with_env (cyclomatic 17) (crates/buzz-acp/src/acp.rs)
• AdminConsoleFeedbackTab.AttachmentViewer (cognitive 21) (desktop/src/features/admin-console/AdminConsoleFeedbackTab.tsx)
• AdminConsoleFeedbackTab.AttachmentViewer (cyclomatic 18) (desktop/src/features/admin-console/AdminConsoleFeedbackTab.tsx)
• AdminConsolePanelHelpers.parseImetaAttachments (cognitive 16) (desktop/src/features/admin-console/AdminConsolePanelHelpers.tsx)
• AdminConsoleReportsTab.ResolveReportForm (cognitive 19) (desktop/src/features/admin-console/AdminConsoleReportsTab.tsx)
• AdminConsoleReportsTab.ResolveReportForm (cyclomatic 22) (desktop/src/features/admin-console/AdminConsoleReportsTab.tsx)
• AdminConsoleSettingsCard.AdminConsoleSettingsSession (cognitive 48) (desktop/src/features/admin-console/AdminConsoleSettingsCard.tsx)
• AdminConsoleSettingsCard.AdminConsoleSettingsSession (cyclomatic 42) (desktop/src/features/admin-console/AdminConsoleSettingsCard.tsx)
• AdminConsoleStaffingTab.RestrictionsSection (cognitive 40) (desktop/src/features/admin-console/AdminConsoleStaffingTab.tsx)
• AdminConsoleStaffingTab.RestrictionsSection (cyclomatic 40) (desktop/src/features/admin-console/AdminConsoleStaffingTab.tsx)
• AdminConsoleStaffingTab.StaffingTab (cognitive 27) (desktop/src/features/admin-console/AdminConsoleStaffingTab.tsx)
• AdminConsoleStaffingTab.StaffingTab (cyclomatic 33) (desktop/src/features/admin-console/AdminConsoleStaffingTab.tsx)
• Ambiguous distinction between 'bearer' and 'bearer_no_browser'. It is unclear if 'bearer' implies a browser-based flow by default or if it is a generic alias. If 'bearer' is the standard method, 'bearer_no_browser' suggests a variant that should perhaps be the default or named more explicitly (e.g., 'fetch_silent').
• AnimatedAvatarCameraControls.AnimatedAvatarCameraControls (cognitive 23) (desktop/src/features/profile/ui/AnimatedAvatarCameraControls.tsx)
• AnimatedAvatarCameraControls.AnimatedAvatarCameraControls (cyclomatic 18) (desktop/src/features/profile/ui/AnimatedAvatarCameraControls.tsx)
• BuzzDevPushEnrollmentDriver.completeEnrollment (cognitive 21) (mobile/ios/BuzzPushKit/Sources/BuzzPushKit/BuzzDevPushEnrollmentDriver.swift)
• BuzzDevPushEnrollmentDriver.completeEnrollment (cyclomatic 18) (mobile/ios/BuzzPushKit/Sources/BuzzPushKit/BuzzDevPushEnrollmentDriver.swift)
• BuzzPushSnapshotBridge.syncCommunities (cognitive 19) (mobile/ios/Runner/PushSnapshotBridge.swift)
• CanvasHistoryPanel.CanvasHistoryPanel (cognitive 31) (desktop/src/features/channels/ui/CanvasHistoryPanel.tsx)
• …and 504 more

• 92 commits — 51 feature/other, 41 fixes

• crates/buzz-db — 11 commits
• desktop/src — 10 commits
• mobile/lib — 9 commits
• (root) — 8 commits
• crates/buzz-relay — 7 commits
• desktop/src-tauri — 7 commits
• crates/buzz-acp — 5 commits
• deploy/charts — 5 commits
• mobile/ios — 4 commits
• mobile/test — 4 commits
• .github/workflows — 3 commits
• crates/buzz-agent — 3 commits
• desktop/tests — 3 commits
• docs/nips — 3 commits
• crates/buzz-push-gateway — 2 commits
• .github/ci — 1 commit
• crates/buzz-admin — 1 commit
• crates/buzz-audit — 1 commit
• crates/buzz-feature-flags — 1 commit
• crates/buzz-mesh-smoke — 1 commit

• fix: Fix Apple Silicon iOS simulator builds (#7646)
• fix: Fix desktop onboarding regressions (#7659)
• fix: Fix mobile heart and warning emoji with native font fallback (#7842)
• fix: fix(acp): improve hints in pi agent setup guide (#7594)
• fix: fix(admin): allow cold storage worker DB startup (#7770)
• fix: fix(agent): preserve Databricks Opus UC reasoning and tool continuation (#7840)
• fix: fix(audit): frame hash inputs with TLV (#7492)
• fix: fix(ci): bootstrap the reusable MinIO image in GHCR (#7869)
• fix: fix(ci): consume the published MinIO image (#7870)
• fix: fix(ci): don't run desktop tests for purely mobile client changes (#7709)
• fix: fix(ci): pull pinned MinIO images from Quay (#7599)
• fix: fix(ci): run the admin disabled-mode DB test in the PostgreSQL lane (#7900)
• fix: fix(ci): select runtime suites from PR changes only (#7843)
• fix: fix(db): allow naturally expired push lease replacement (#7653)
• fix: fix(db): limit event transactions to listener mention kinds (#7932)
• fix: fix(desktop): bound startup request bursts and recover quota refusals (#7790)
• fix: fix(desktop): keep managed agent avatars usable across communities (#7732)
• fix: fix(desktop): refresh channels after access-revoked closure (#7784)
• fix: fix(desktop): register macOS badges for new and existing installs (#7783)
• fix: fix(desktop): remember Inbox unread-only choice (#7672)
• …and 72 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

block/buzz was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.