diff --git a/.ai/guidelines/workflow/02-triage-labels.blade.php b/.ai/guidelines/workflow/02-triage-labels.blade.php
index 56d22eb9a..58bead562 100644
--- a/.ai/guidelines/workflow/02-triage-labels.blade.php
+++ b/.ai/guidelines/workflow/02-triage-labels.blade.php
@@ -43,6 +43,7 @@
| `mod:bot-discord` | `bot-discord` | Discord bot |
| `mod:community` | `community` | Community features |
| `mod:contents` | `contents` | Published content catalogue |
+| `mod:delas` | `delas` | He4rt Delas tag & moderation |
| `mod:economy` | `economy` | Economy/wallet system |
| `mod:events` | `events` | Events & participation |
| `mod:gamification` | `gamification` | XP, levels, ranking |
diff --git a/CONTEXT-MAP.md b/CONTEXT-MAP.md
index 28a78d96b..8b85d7256 100644
--- a/CONTEXT-MAP.md
+++ b/CONTEXT-MAP.md
@@ -9,21 +9,22 @@ This is a modular monorepo (`internachi/modular`). Each bounded context lives un
## Contexts
-| Context | Path | Description |
-| ------------------- | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
-| Moderation | `app-modules/moderation/` | Content moderation pipeline — classification, routing, enforcement, appeals |
-| Bot Discord | `app-modules/bot-discord/` | Discord bot runtime (Laracord websocket, slash commands, event handlers) |
-| Integration Discord | `app-modules/integration-discord/` | Discord platform transport (REST API via Saloon), OAuth, ETL |
-| Identity | `app-modules/identity/` | Users, tenants, external identities, authentication |
-| Events | `app-modules/events/` | Event participation lifecycle — enrollment, check-in, attendance, XP dispatch; community photo gallery (albums) |
-| Gamification | `app-modules/gamification/` | Character progression — XP, levels, badges, seasons, daily bonuses |
-| Panel Admin | `app-modules/panel-admin/` | Filament admin panel — dashboards, resources, moderation UI, marketing |
-| Integration Twitch | `app-modules/integration-twitch/` | Twitch platform transport (Helix API via Saloon), OAuth, EventSub webhooks |
-| Integration GitHub | `app-modules/integration-github/` | GitHub transport (REST via Saloon), OAuth, community contribution ingestion (backfill + webhooks) + event lake |
-| Onboarding | `app-modules/onboarding/` | Universal, mandatory entry layer — polymorphic onboarding state machines by type; owns the per-type completion gate (APTO) |
-| Squads | `app-modules/squads/` | Squad lifecycle, membership and governance (captain/sub-captain, elections, removal, reallocation) |
-| Marketing | `app-modules/marketing/` | Divulgação e sua medição — links curtos (`/l/{slug}`), destino versionado, captura crua de cliques |
+| Context | Path | Description |
+| ------------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| Moderation | `app-modules/moderation/` | Content moderation pipeline — classification, routing, enforcement, appeals |
+| Bot Discord | `app-modules/bot-discord/` | Discord bot runtime (Laracord websocket, slash commands, event handlers) |
+| Integration Discord | `app-modules/integration-discord/` | Discord platform transport (REST API via Saloon), OAuth, ETL |
+| Identity | `app-modules/identity/` | Users, tenants, external identities, authentication |
+| Events | `app-modules/events/` | Event participation lifecycle — enrollment, check-in, attendance, XP dispatch; community photo gallery (albums) |
+| Gamification | `app-modules/gamification/` | Character progression — XP, levels, badges, seasons, daily bonuses |
+| Panel Admin | `app-modules/panel-admin/` | Filament admin panel — dashboards, resources, moderation UI, marketing |
+| Integration Twitch | `app-modules/integration-twitch/` | Twitch platform transport (Helix API via Saloon), OAuth, EventSub webhooks |
+| Integration GitHub | `app-modules/integration-github/` | GitHub transport (REST via Saloon), OAuth, community contribution ingestion (backfill + webhooks) + event lake |
+| Onboarding | `app-modules/onboarding/` | Universal, mandatory entry layer — polymorphic onboarding state machines by type; owns the per-type completion gate (APTO) |
+| Squads | `app-modules/squads/` | Squad lifecycle, membership and governance (captain/sub-captain, elections, removal, reallocation) |
+| Marketing | `app-modules/marketing/` | Divulgação e sua medição — links curtos (`/l/{slug}`), destino versionado, captura crua de cliques |
| Contents | `app-modules/contents/` | Canonical catalogue of content published on external platforms (articles now, video next) — delegated types + provider contract |
+| Delas | `app-modules/delas/` | He4rt Delas no Hub — solicitação da tag, decisão das moderadoras, bloqueios e histórico |
## Relationships
@@ -76,3 +77,4 @@ This is a modular monorepo (`internachi/modular`). Each bounded context lives un
- **Squads** depends on Onboarding (reads the `Squads`-completion gate, "APTO") and Identity (users/tenants). It never imports from presentation; the panels depend on it.
- **Marketing** owns short links and their click record. It depends only on **Identity** (`created_by` / `user_id` on a click) and on no other context. It renders no UI and registers no route: `portal` owns the public `/l/{slug}` edge and the "link unavailable" page, and `panel-admin` owns the staff CRUD and dashboards — both depend on `marketing`, never the reverse.
- **Contents** owns the canonical record of externally published content. It never talks HTTP (the `integration-*` modules implement its provider contract) and never awards anything — it emits `ArticlePublished` and `activity` decides. It depends on Identity (authorship resolution, `ExternalIdentityConnected`); `activity` and the panels depend on it, never the reverse.
+- **Delas** owns the He4rt Delas tag (request, decision, cooldown, blocks and their history). It depends only on **Identity** (`User`, the `delas-moderator` and `delas-lead` cases of `UserRole`). It renders no UI: `panel-app` (profile request and tag) and `panel-admin` (moderation in the Moderation cluster: queue, members, blocks, history, team) depend on it, never the reverse.
diff --git a/app-modules/delas/CONTEXT.md b/app-modules/delas/CONTEXT.md
new file mode 100644
index 000000000..9a6821d08
--- /dev/null
+++ b/app-modules/delas/CONTEXT.md
@@ -0,0 +1,37 @@
+# Contexto do Delas
+
+Este módulo é a fonte da verdade sobre **quem faz parte da He4rt Delas no Hub**: a tag que a
+pessoa pede no perfil, a decisão das moderadoras, os bloqueios de quem não pode pedir e o
+histórico de cada uma dessas decisões.
+
+É um **módulo de domínio puro**: não tem rota, view nem Filament.
+
+- O `panel-app` (`/app`) mostra a solicitação no perfil e a tag no card do perfil.
+- O `panel-admin` (`/admin`) tem a moderação, no grupo He4rt Delas do cluster de Moderação
+ (`/admin/mod`): Fila, Bloqueios, Histórico e Equipe (números, conceder e remover a tag,
+ moderadoras). Moderadoras e líderes entram no `/admin` só para isso
+ ([ADR-0003 do identity](../identity/docs/adr/0003-acesso-ao-admin-por-papel-de-moderacao.md)).
+- A logo, a tag e o ícone da He4rt Delas são do design system (módulo `he4rt`).
+
+Os dois painéis dependem deste módulo, e este módulo só depende do `identity`.
+
+> **Status:** implementado (aguardando PR). O design está na
+> [spec](../../docs/specs/2026-10-06-he4rt-delas-tag-e-moderacao.md) e as decisões na
+> [ADR-0001](docs/adr/0001-modulo-proprio-com-papel-e-historico.md).
+
+## Glossário
+
+| Termo | Definição | Não confundir com |
+| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| **Tag He4rt Delas** | Marca no perfil de que a pessoa faz parte da He4rt Delas. Existe quando a solicitação dela está `approved`. | Um Badge do `gamification`: badges vêm de XP ou claim, a tag vem de uma decisão. |
+| **Solicitação** | Uma linha em `delas_tag_requests`: o pedido da tag e a decisão sobre ele (`pending`, `approved`, `rejected`, `revoked`). | O cargo `he4rt_delas` do Discord, concedido pelo `/cargo-delas`. Os dois ainda não são sincronizados. |
+| **Moderadora He4rt Delas** | Quem tem a role `delas-moderator` (`UserRole::DelasModerator`) e passa no gate `moderate-delas`. Decide solicitações e bloqueia solicitantes. | A moderação de conteúdo do módulo `moderation` (Case, Appeal, Moderator). |
+| **Líder He4rt Delas** | Quem tem a role `delas-lead` (`UserRole::DelasLead`) e passa no gate `lead-delas`. Tudo o que a moderadora faz, mais gerenciar moderadoras, conceder e remover a tag e ver o histórico completo (página Equipe). | Super admin: no `/admin` a líder só acessa a área da He4rt Delas e não nomeia outras líderes. |
+| **Bloqueio** | Uma linha em `delas_requester_blocks`: impede a pessoa de solicitar a tag até ser desbloqueada. Sempre tem motivo. Não tira a tag de quem já tem. | Ban ou suspensão (`UserSituation` do `identity`): o bloqueio não afeta a conta nem o resto do Hub. |
+| **Espera** | Prazo depois de uma solicitação `rejected` ou `revoked` em que a pessoa não pode pedir de novo. Padrão de 15 dias (`delas.request_cooldown_days`). | O bloqueio: a espera acaba sozinha, o bloqueio só acaba quando alguém desbloqueia. |
+| **Discord conectado** | Requisito para pedir a tag (`delas.require_discord`): uma identidade Discord conectada pela própria pessoa (escopo `activelyConnected` do identity). Fica antes de liberar o pedido, depois da espera e do bloqueio. | Ter o cargo `he4rt_delas` no Discord: o cargo ainda não é sincronizado com a tag. |
+| **Concessão direta** | Líder (ou super admin) dá a tag sem solicitação e sem espera (`GrantDelasTag`). Encerra um bloqueio ativo, se houver. | Aprovar uma solicitação: aprovar é decisão sobre um pedido que a pessoa fez. |
+| **Histórico** | `delas_transitions`: uma linha por ação (solicitar, aprovar, rejeitar, conceder, remover, bloquear, desbloquear), com quem fez, quando e motivo. | Logs da aplicação: o histórico é dado de domínio, append-only, gravado pelas próprias actions. |
+| **Candidatas** | Quem pode ser escolhida nos seletores de pessoa da Equipe (`DelasCandidates`): conceder lista quem não tem a tag, remover lista só quem tem e não é da equipe, adicionar moderadora lista só quem tem a tag, sem super admins e a equipe. Quem age nunca aparece. | A regra de negócio: a consulta só filtra a lista; quem valida a ação são as actions de domínio. |
+| **Membra** | Quem tem a tag hoje: solicitação `approved`. Aparece na página Membras, onde a líder pode remover a tag e bloquear novos pedidos junto. | Moderadora: membra é quem tem a tag, moderadora é quem decide sobre ela. |
+| **Edição de motivo** | Linha `reason_corrected` no histórico que aponta (`corrects_id`) para a decisão editada. A original fica como foi escrita; vale a edição mais recente. Na tela, "Editar motivo" e "Editado em". | Sobrescrever o motivo: nada no histórico é apagado. No código, a action se chama `CorrectDelasReason`. |
diff --git a/app-modules/delas/composer.json b/app-modules/delas/composer.json
new file mode 100644
index 000000000..544bf0517
--- /dev/null
+++ b/app-modules/delas/composer.json
@@ -0,0 +1,30 @@
+{
+ "name": "he4rt/delas",
+ "description": "",
+ "type": "library",
+ "version": "1.0.0",
+ "license": "proprietary",
+ "require": {
+ "he4rt/identity": "^1.0.0"
+ },
+ "autoload": {
+ "psr-4": {
+ "He4rt\\Delas\\": "src/",
+ "He4rt\\Delas\\Database\\Factories\\": "database/factories/",
+ "He4rt\\Delas\\Database\\Seeders\\": "database/seeders/"
+ }
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "He4rt\\Delas\\Tests\\": "tests/"
+ }
+ },
+ "minimum-stability": "stable",
+ "extra": {
+ "laravel": {
+ "providers": [
+ "He4rt\\Delas\\DelasServiceProvider"
+ ]
+ }
+ }
+}
diff --git a/app-modules/delas/config/delas.php b/app-modules/delas/config/delas.php
new file mode 100644
index 000000000..92e97a370
--- /dev/null
+++ b/app-modules/delas/config/delas.php
@@ -0,0 +1,41 @@
+ (int) env('DELAS_REQUEST_COOLDOWN_DAYS', 15),
+
+ /*
+ |--------------------------------------------------------------------------
+ | Prazo para corrigir o próprio motivo
+ |--------------------------------------------------------------------------
+ |
+ | Horas em que quem escreveu um motivo pode corrigi-lo. Líderes e super
+ | admins corrigem a qualquer momento. A correção nunca apaga a original.
+ |
+ */
+
+ 'reason_correction_hours' => (int) env('DELAS_REASON_CORRECTION_HOURS', 24),
+
+ /*
+ |--------------------------------------------------------------------------
+ | Discord conectado para pedir a tag
+ |--------------------------------------------------------------------------
+ |
+ | A He4rt Delas acontece no Discord: a moderação conhece a pessoa por lá, e
+ | a conta conectada é o que vai ligar a tag ao cargo `he4rt_delas`.
+ |
+ */
+
+ 'require_discord' => (bool) env('DELAS_REQUIRE_DISCORD', default: true),
+];
diff --git a/app-modules/delas/database/factories/DelasRequesterBlockFactory.php b/app-modules/delas/database/factories/DelasRequesterBlockFactory.php
new file mode 100644
index 000000000..0e2e33498
--- /dev/null
+++ b/app-modules/delas/database/factories/DelasRequesterBlockFactory.php
@@ -0,0 +1,38 @@
+ */
+final class DelasRequesterBlockFactory extends Factory
+{
+ protected $model = DelasRequesterBlock::class;
+
+ /** @return array */
+ public function definition(): array
+ {
+ return [
+ 'user_id' => User::factory(),
+ 'blocked_by' => User::factory(),
+ 'reason' => 'Pedidos repetidos com intenção de tumultuar a fila.',
+ 'blocked_at' => now(),
+ 'lifted_by' => null,
+ 'lifted_at' => null,
+ 'lift_reason' => null,
+ ];
+ }
+
+ public function lifted(string $reason = 'Situação esclarecida com o comitê.'): static
+ {
+ return $this->state(fn (): array => [
+ 'lifted_by' => User::factory(),
+ 'lifted_at' => now(),
+ 'lift_reason' => $reason,
+ ]);
+ }
+}
diff --git a/app-modules/delas/database/factories/DelasTagRequestFactory.php b/app-modules/delas/database/factories/DelasTagRequestFactory.php
new file mode 100644
index 000000000..4dc8ab78f
--- /dev/null
+++ b/app-modules/delas/database/factories/DelasTagRequestFactory.php
@@ -0,0 +1,59 @@
+ */
+final class DelasTagRequestFactory extends Factory
+{
+ protected $model = DelasTagRequest::class;
+
+ /** @return array */
+ public function definition(): array
+ {
+ return [
+ 'user_id' => User::factory(),
+ 'status' => DelasRequestStatus::Pending,
+ 'requested_at' => now(),
+ 'decided_by' => null,
+ 'decided_at' => null,
+ 'decision_reason' => null,
+ ];
+ }
+
+ public function pending(): static
+ {
+ return $this->state(['status' => DelasRequestStatus::Pending]);
+ }
+
+ public function approved(): static
+ {
+ return $this->decided(DelasRequestStatus::Approved);
+ }
+
+ public function rejected(?string $reason = 'Perfil sem informações suficientes.'): static
+ {
+ return $this->decided(DelasRequestStatus::Rejected, $reason);
+ }
+
+ public function revoked(?string $reason = 'A própria pessoa pediu a remoção.'): static
+ {
+ return $this->decided(DelasRequestStatus::Revoked, $reason);
+ }
+
+ private function decided(DelasRequestStatus $status, ?string $reason = null): static
+ {
+ return $this->state(fn (): array => [
+ 'status' => $status,
+ 'decided_by' => User::factory(),
+ 'decided_at' => now(),
+ 'decision_reason' => $reason,
+ ]);
+ }
+}
diff --git a/app-modules/delas/database/factories/DelasTransitionFactory.php b/app-modules/delas/database/factories/DelasTransitionFactory.php
new file mode 100644
index 000000000..289fb773c
--- /dev/null
+++ b/app-modules/delas/database/factories/DelasTransitionFactory.php
@@ -0,0 +1,34 @@
+ */
+final class DelasTransitionFactory extends Factory
+{
+ protected $model = DelasTransition::class;
+
+ /** @return array */
+ public function definition(): array
+ {
+ return [
+ 'user_id' => User::factory(),
+ 'request_id' => null,
+ 'block_id' => null,
+ 'action' => DelasAction::Requested,
+ 'from_status' => null,
+ 'to_status' => DelasRequestStatus::Pending,
+ 'actor_id' => null,
+ 'triggered_by' => DelasTriggeredBy::User,
+ 'reason' => null,
+ ];
+ }
+}
diff --git a/app-modules/delas/database/migrations/2026_10_07_012009_create_delas_tag_requests_table.php b/app-modules/delas/database/migrations/2026_10_07_012009_create_delas_tag_requests_table.php
new file mode 100644
index 000000000..3b945c117
--- /dev/null
+++ b/app-modules/delas/database/migrations/2026_10_07_012009_create_delas_tag_requests_table.php
@@ -0,0 +1,40 @@
+uuid('id')->primary();
+ $table->foreignUuid('user_id')->constrained('users')->cascadeOnDelete();
+ $table->string('status', 20)->comment(DelasRequestStatus::stringifyCases());
+ $table->timestampTz('requested_at');
+ $table->foreignUuid('decided_by')->nullable()->constrained('users')->nullOnDelete();
+ $table->timestampTz('decided_at')->nullable();
+ $table->string('decision_reason', 500)->nullable()->comment('Uso interno: a solicitante não vê.');
+ $table->timestampsTz();
+
+ $table->index(['status', 'requested_at'], 'idx_delas_tag_requests_queue');
+ $table->index(['user_id', 'decided_at'], 'idx_delas_tag_requests_user_decided');
+ });
+
+ // No máximo uma solicitação ativa (pendente ou aprovada) por pessoa.
+ DB::statement(sprintf(
+ "CREATE UNIQUE INDEX uq_delas_tag_requests_active_user ON delas_tag_requests (user_id) WHERE status IN ('%s')",
+ implode("', '", DelasRequestStatus::activeValues()),
+ ));
+ }
+
+ public function down(): void
+ {
+ Schema::dropIfExists('delas_tag_requests');
+ }
+};
diff --git a/app-modules/delas/database/migrations/2026_10_07_012012_create_delas_requester_blocks_table.php b/app-modules/delas/database/migrations/2026_10_07_012012_create_delas_requester_blocks_table.php
new file mode 100644
index 000000000..c0d054a7b
--- /dev/null
+++ b/app-modules/delas/database/migrations/2026_10_07_012012_create_delas_requester_blocks_table.php
@@ -0,0 +1,42 @@
+uuid('id')->primary();
+ $table->foreignUuid('user_id')->constrained('users')->cascadeOnDelete();
+ $table->foreignUuid('blocked_by')->nullable()->constrained('users')->nullOnDelete();
+ $table->string('reason', 500)->comment('Uso interno: a pessoa bloqueada não vê.');
+ $table->timestampTz('blocked_at');
+ $table->foreignUuid('lifted_by')->nullable()->constrained('users')->nullOnDelete();
+ $table->timestampTz('lifted_at')->nullable();
+ $table->string('lift_reason', 500)
+ ->nullable()
+ ->comment('Obrigatório ao desbloquear; nulo enquanto o bloqueio está ativo.');
+ $table->timestampsTz();
+
+ $table->index(['lifted_at', 'blocked_at'], 'idx_delas_requester_blocks_active');
+ });
+
+ // No máximo um bloqueio ativo por pessoa.
+ DB::statement(<<<'SQL'
+ CREATE UNIQUE INDEX uq_delas_requester_blocks_active_user
+ ON delas_requester_blocks (user_id)
+ WHERE lifted_at IS NULL
+ SQL);
+ }
+
+ public function down(): void
+ {
+ Schema::dropIfExists('delas_requester_blocks');
+ }
+};
diff --git a/app-modules/delas/database/migrations/2026_10_07_012015_create_delas_transitions_table.php b/app-modules/delas/database/migrations/2026_10_07_012015_create_delas_transitions_table.php
new file mode 100644
index 000000000..7174144be
--- /dev/null
+++ b/app-modules/delas/database/migrations/2026_10_07_012015_create_delas_transitions_table.php
@@ -0,0 +1,39 @@
+uuid('id')->primary();
+ $table->foreignUuid('user_id')->constrained('users')->cascadeOnDelete();
+ $table->foreignUuid('request_id')->nullable()->constrained('delas_tag_requests')->cascadeOnDelete();
+ $table->foreignUuid('block_id')->nullable()->constrained('delas_requester_blocks')->cascadeOnDelete();
+ $table->string('action', 20)->comment(DelasAction::stringifyCases());
+ $table->string('from_status', 20)->nullable()->comment(DelasRequestStatus::stringifyCases());
+ $table->string('to_status', 20)->nullable()->comment(DelasRequestStatus::stringifyCases());
+ $table->foreignUuid('actor_id')->nullable()->constrained('users')->nullOnDelete();
+ $table->string('triggered_by', 20)->comment(DelasTriggeredBy::stringifyCases());
+ $table->string('reason', 500)->nullable();
+ $table->timestampTz('created_at')->useCurrent();
+
+ $table->index(['created_at'], 'idx_delas_transitions_time');
+ $table->index(['user_id', 'created_at'], 'idx_delas_transitions_user_time');
+ $table->index(['actor_id', 'created_at'], 'idx_delas_transitions_actor_time');
+ });
+ }
+
+ public function down(): void
+ {
+ Schema::dropIfExists('delas_transitions');
+ }
+};
diff --git a/app-modules/delas/database/migrations/2026_10_07_200828_add_corrects_id_to_delas_transitions_table.php b/app-modules/delas/database/migrations/2026_10_07_200828_add_corrects_id_to_delas_transitions_table.php
new file mode 100644
index 000000000..9a9bbe045
--- /dev/null
+++ b/app-modules/delas/database/migrations/2026_10_07_200828_add_corrects_id_to_delas_transitions_table.php
@@ -0,0 +1,32 @@
+foreignUuid('corrects_id')
+ ->nullable()
+ ->after('block_id')
+ ->comment('Linha do histórico cujo motivo esta linha corrige; a original nunca é alterada.')
+ ->constrained('delas_transitions')
+ ->cascadeOnDelete();
+
+ $table->index(['corrects_id', 'created_at'], 'idx_delas_transitions_corrects');
+ });
+ }
+
+ public function down(): void
+ {
+ Schema::table('delas_transitions', static function (Blueprint $table): void {
+ $table->dropIndex('idx_delas_transitions_corrects');
+ $table->dropConstrainedForeignId('corrects_id');
+ });
+ }
+};
diff --git a/app-modules/delas/database/seeders/DelasDemoSeeder.php b/app-modules/delas/database/seeders/DelasDemoSeeder.php
new file mode 100644
index 000000000..3c166356e
--- /dev/null
+++ b/app-modules/delas/database/seeders/DelasDemoSeeder.php
@@ -0,0 +1,307 @@
+`).
+ *
+ * @var array
+ */
+ private const array PEOPLE = [
+ 'lider' => [
+ 'name' => 'Lia Líder',
+ 'email' => 'lider@delas.test',
+ 'note' => 'líder: tudo, mais Equipe, histórico completo e versões do motivo',
+ ],
+ 'moderadora' => [
+ 'name' => 'Mia Moderadora',
+ 'email' => 'moderadora@delas.test',
+ 'note' => 'moderadora: fez os bloqueios e as rejeições abaixo',
+ ],
+ 'moderadora2' => [
+ 'name' => 'Nina Moderadora',
+ 'email' => 'moderadora2@delas.test',
+ 'note' => 'outra moderadora: para testar "só os próprios"',
+ ],
+ 'membra' => [
+ 'name' => 'Ana Membra',
+ 'email' => 'membra@delas.test',
+ 'note' => 'tem a tag',
+ ],
+ 'pendente' => [
+ 'name' => 'Paula Pendente',
+ 'email' => 'pendente@delas.test',
+ 'note' => 'pedido pendente na Fila',
+ ],
+ 'pedido2' => [
+ 'name' => 'Bruna Pedido',
+ 'email' => 'pedido2@delas.test',
+ 'note' => 'pedido pendente na Fila',
+ ],
+ 'pedido3' => [
+ 'name' => 'Carla Pedido',
+ 'email' => 'pedido3@delas.test',
+ 'note' => 'pedido pendente na Fila',
+ ],
+ 'recente' => [
+ 'name' => 'Rita Recente',
+ 'email' => 'recente@delas.test',
+ 'note' => 'rejeitada pela Mia há 1 hora: a Mia ainda edita o motivo',
+ ],
+ 'espera' => [
+ 'name' => 'Eva Espera',
+ 'email' => 'espera@delas.test',
+ 'note' => 'rejeitada pela Mia há 3 dias: em espera, a Mia já não edita',
+ ],
+ 'bloqueada' => [
+ 'name' => 'Bia Bloqueada',
+ 'email' => 'bloqueada@delas.test',
+ 'note' => 'bloqueada pela Mia',
+ ],
+ 'bloqueada2' => [
+ 'name' => 'Gabi Bloqueada',
+ 'email' => 'bloqueada2@delas.test',
+ 'note' => 'bloqueada pela Nina',
+ ],
+ 'nova' => [
+ 'name' => 'Nara Nova',
+ 'email' => 'nova@delas.test',
+ 'note' => 'nunca pediu: pode pedir a tag',
+ ],
+ 'semdiscord' => [
+ 'name' => 'Sofia Sem Discord',
+ 'email' => 'semdiscord@delas.test',
+ 'note' => 'sem Discord conectado: precisa conectar antes de pedir',
+ ],
+ ];
+
+ /**
+ * Conta sem Discord conectado, para testar essa exigência do pedido.
+ */
+ private const string WITHOUT_DISCORD = 'semdiscord';
+
+ /** @var array */
+ private array $people = [];
+
+ public function run(): void
+ {
+ $admin = User::query()->where('email', 'admin@admin.com')->first();
+
+ if (!$admin instanceof User || !$admin->isSuperAdmin()) {
+ $this->command->error('Rode o BaseSeeder antes: falta o super admin admin@admin.com.');
+
+ return;
+ }
+
+ $this->createPeople();
+ $this->resetDelasState();
+
+ $this->at(now()->subDays(10), fn () => $this->formTeam($admin));
+ $this->at(now()->subDays(6), fn () => $this->approveMember());
+ $this->at(now()->subDays(3), fn () => $this->rejectAndBlockByMia());
+ $this->at(now()->subDays(2), fn () => $this->blockByNina());
+ $this->at(now()->subHour(), fn () => $this->rejectRecentlyByMia());
+ $this->openPendingRequests();
+
+ $this->guide();
+ }
+
+ /**
+ * A líder recebe o papel do super admin e dá a tag e o papel às duas
+ * moderadoras. Moderadora precisa ter a tag.
+ */
+ private function formTeam(User $admin): void
+ {
+ $lead = $this->person('lider');
+ $lead->assignRole(UserRole::DelasLead);
+
+ resolve(GrantDelasTag::class)->handle($lead, $admin, 'Liderança da He4rt Delas.');
+
+ foreach (['moderadora', 'moderadora2'] as $key) {
+ resolve(GrantDelasTag::class)->handle($this->person($key), $lead, 'Convidada para moderar.');
+ resolve(AddDelasModerator::class)->handle($this->person($key), $lead);
+ }
+ }
+
+ private function approveMember(): void
+ {
+ $request = resolve(RequestDelasTag::class)->handle($this->person('membra'));
+
+ resolve(ApproveDelasRequest::class)->handle($request, $this->person('moderadora'));
+ }
+
+ /**
+ * Há 3 dias: já passou o prazo de 24 horas para a Mia editar o motivo.
+ */
+ private function rejectAndBlockByMia(): void
+ {
+ $mia = $this->person('moderadora');
+
+ $request = resolve(RequestDelasTag::class)->handle($this->person('espera'));
+ resolve(RejectDelasRequest::class)->handle($request, $mia, 'Perfil sem informações suficientes.');
+
+ resolve(BlockDelasRequester::class)->handle($this->person('bloqueada'), $mia, 'Pedidos repetidos para tumultuar a fila.');
+ }
+
+ /**
+ * Bloqueio de outra moderadora: a Mia não consegue desfazer.
+ */
+ private function blockByNina(): void
+ {
+ resolve(BlockDelasRequester::class)->handle(
+ $this->person('bloqueada2'),
+ $this->person('moderadora2'),
+ 'Mensagens ofensivas no pedido.',
+ );
+ }
+
+ /**
+ * Há 1 hora, com um erro de digitação de propósito: a Mia ainda pode editar.
+ */
+ private function rejectRecentlyByMia(): void
+ {
+ $request = resolve(RequestDelasTag::class)->handle($this->person('recente'));
+
+ resolve(RejectDelasRequest::class)->handle($request, $this->person('moderadora'), 'Perfil sem informaçoes suficientes.');
+ }
+
+ /**
+ * Três pedidos na Fila, com 10 minutos entre eles.
+ */
+ private function openPendingRequests(): void
+ {
+ $minutesAgo = ['pendente' => 30, 'pedido2' => 20, 'pedido3' => 10];
+
+ foreach ($minutesAgo as $key => $minutes) {
+ $this->at(now()->subMinutes($minutes), fn () => resolve(RequestDelasTag::class)->handle($this->person($key)));
+ }
+ }
+
+ /**
+ * Cria as contas que ainda não existem, conecta o Discord e tira os papéis
+ * da He4rt Delas, que os passos seguintes dão de novo.
+ */
+ private function createPeople(): void
+ {
+ foreach (self::PEOPLE as $key => $person) {
+ $user = User::query()->where('email', $person['email'])->first()
+ ?? User::factory()->create([
+ 'name' => $person['name'],
+ 'username' => 'delas.'.$key,
+ 'email' => $person['email'],
+ 'password' => Hash::make(self::PASSWORD),
+ ]);
+
+ if ($key !== self::WITHOUT_DISCORD) {
+ $this->connectDiscord($user);
+ }
+
+ $user->removeRole(UserRole::DelasModerator);
+ $user->removeRole(UserRole::DelasLead);
+
+ $this->people[$key] = $user;
+ }
+ }
+
+ private function connectDiscord(User $user): void
+ {
+ if (resolve(DelasEligibility::class)->hasDiscord($user)) {
+ return;
+ }
+
+ ExternalIdentity::factory()->create([
+ 'model_type' => $user->getMorphClass(),
+ 'model_id' => $user->getKey(),
+ 'provider' => IdentityProvider::Discord,
+ 'connected_by' => $user->getKey(),
+ ]);
+ }
+
+ /**
+ * Apaga o que a He4rt Delas sabe sobre as contas de demonstração, para o
+ * estado voltar ao começo a cada execução.
+ */
+ private function resetDelasState(): void
+ {
+ $ids = array_map(fn (User $user): string => $user->getKey(), array_values($this->people));
+
+ DelasTransition::query()->whereIn('user_id', $ids)->orWhereIn('actor_id', $ids)->delete();
+ DelasRequesterBlock::query()->whereIn('user_id', $ids)->delete();
+ DelasTagRequest::query()->whereIn('user_id', $ids)->delete();
+ }
+
+ /**
+ * Sempre a versão atual da conta: os papéis mudam entre um passo e outro.
+ */
+ private function person(string $key): User
+ {
+ return $this->people[$key]->fresh() ?? $this->people[$key];
+ }
+
+ /**
+ * Roda um passo como se fosse aquele momento, para o histórico e a espera
+ * terem datas de verdade.
+ */
+ private function at(CarbonInterface $moment, callable $step): void
+ {
+ Date::setTestNow($moment);
+
+ try {
+ $step();
+ } finally {
+ Date::setTestNow();
+ }
+ }
+
+ private function guide(): void
+ {
+ $output = $this->command->getOutput();
+
+ $output->writeln('');
+ $output->writeln('Demonstração da He4rt Delas> · /app (perfil) e /admin/mod/delas>');
+ $output->writeln('');
+
+ foreach (self::PEOPLE as $person) {
+ $output->writeln(sprintf('%s> %s>', mb_str_pad($person['email'], 24), $person['note']));
+ }
+
+ $output->writeln('');
+ $output->writeln(sprintf('Senha de todas:> %s · super admin: admin@admin.com / admin>', self::PASSWORD));
+ $output->writeln('');
+ }
+}
diff --git a/app-modules/delas/docs/adr/0001-modulo-proprio-com-papel-e-historico.md b/app-modules/delas/docs/adr/0001-modulo-proprio-com-papel-e-historico.md
new file mode 100644
index 000000000..ce2bdcda5
--- /dev/null
+++ b/app-modules/delas/docs/adr/0001-modulo-proprio-com-papel-e-historico.md
@@ -0,0 +1,121 @@
+---
+type: adr
+title: 'Módulo próprio, papel do Spatie e histórico de decisões'
+module: delas
+status: accepted
+date: 2026-10-06
+deciders:
+ - damacosta
+related:
+ spec: 2026-10-06-he4rt-delas-tag-e-moderacao
+ adr: identity/0003-acesso-ao-admin-por-papel-de-moderacao
+---
+
+# ADR-0001: Módulo próprio, papel do Spatie e histórico de decisões
+
+## Contexto
+
+As issues #570 e #571 pedem que uma pessoa solicite a tag He4rt Delas no perfil e que líderes
+ou moderadoras da He4rt Delas aprovem ou rejeitem o pedido dentro do Hub, com registro de quem
+decidiu e quando. No Discord isso já existe como cargo (`/cargo-delas`), mas no Hub não há nada.
+
+A feature tem estado (pedido, decisão, espera, bloqueio), papéis próprios e histórico. Ela
+precisa morar em algum lugar e ter uma forma de autorizar quem decide.
+
+## Alternativas consideradas
+
+- **Tag como role do Spatie (`he4rt-delas`).** Espelha o cargo do Discord, mas uma role não guarda
+ pedido, decisão, espera nem bloqueio, e mistura autorização com identidade.
+- **Badge do `gamification`.** Badges são progressão por XP ou claim, sem fluxo de aprovação.
+- **Tipo dentro do `onboarding`.** O onboarding é a camada de entrada obrigatória. A tag é
+ opcional e pode ser pedida a qualquer momento.
+- **Subdomínio do `profile`.** Acoplaria o perfil a papéis e moderação.
+- **Permissions granulares do Spatie.** A ADR-0002 do `identity` adota só roles nesta fase.
+
+## Decisão
+
+- **Módulo de domínio `delas`**, dependente só do `identity`. Os painéis dependem dele.
+- **Papéis `delas-moderator` e `delas-lead`** como cases de `UserRole` no `identity`, criados por
+ migration, como a role `streamer`. A líder gerencia moderadoras, concede e remove a tag e vê o
+ histórico completo. _Vai além da #570_ ("atribuível apenas por admins do Hub"): dá autonomia à
+ He4rt Delas sem depender de super admin no dia a dia.
+- **Gates nomeados no `DelasServiceProvider`**: `moderate-delas` (moderadora ou líder) e
+ `lead-delas` (líder). Super admins passam nos dois pelo `Gate::before` do identity.
+ O código checa o gate, nunca o nome da role.
+ - _Diverge do `use-streamer-tools`, que fica no `IdentityServiceProvider`._ Aqui o gate é
+ vocabulário do delas, e o identity não deve conhecer regras de outro módulo.
+- **Solicitação com máquina de estados em enum** (`pending → approved | rejected`,
+ `approved → revoked`), como a ADR-0001 do `events`.
+- **Espera de 15 dias** depois de `rejected` ou `revoked`, configurável.
+- **Bloqueio** como registro próprio, com motivo obrigatório, feito por moderadoras e desfeito por
+ quem bloqueou ou por super admin.
+- **Histórico append-only** em `delas_transitions`, gravado pelas actions, sem trigger (ADR-0003
+ do `events`).
+- **Editar motivo sem apagar.** Cada edição é uma linha nova (`reason_corrected`, `corrects_id`
+ apontando para a original), nunca uma alteração da original. O motivo vigente na solicitação ou
+ no bloqueio passa a ser o editado. Quem escreveu edita até 24 horas depois; a líder, sempre. Só
+ a liderança vê as versões anteriores na tela: quem edita pode ter tirado algo sensível.
+ - _Alternativa descartada:_ editar o campo `reason` direto. Mais simples, mas apagaria o que
+ foi escrito e quebraria o append-only.
+- **Moderação no `/admin`, pedido e tag no `/app`.** Moderação na He4rt mora no `/admin`, no
+ cluster de Moderação (`/admin/mod`). A He4rt Delas entra nele como o grupo "He4rt Delas" da
+ subnavegação, com uma página por parte, cada uma com o próprio gate:
+ - Fila (`moderate-delas`, badge de pendentes): aprovar, rejeitar e bloquear;
+ - Membras (`moderate-delas`, badge de quem tem a tag): consulta; a líder remove a tag e pode
+ bloquear novos pedidos no mesmo passo;
+ - Bloqueios (`moderate-delas`, badge de bloqueios ativos): desbloquear;
+ - Histórico (`moderate-delas`): só decisões para a moderadora, completo e com filtro para a
+ líder;
+ - Equipe (`lead-delas`): números, conceder e remover a tag, adicionar e revogar moderadora.
+
+ No `/app` ficam só o pedido no perfil (`DelasProfileSection`) e a tag no card do perfil. A
+ atribuição de `delas-lead` continua pela seção Papéis do `UserForm`, só para super admin.
+ - _Antes:_ tudo ficava numa página He4rt Delas no `/app`, porque a ADR-0002 do `identity`
+ dizia que o `/admin` era "super admin ou nada". A
+ [ADR-0003 do `identity`](../../../identity/docs/adr/0003-acesso-ao-admin-por-papel-de-moderacao.md)
+ substitui essa regra: papéis de moderação entram no `/admin` e cada Resource, Page e Cluster
+ decide no `canAccess()`. Assim, a alternativa "abrir o `/admin` para moderadoras" deixa de
+ ser descartada e vira a decisão.
+ - _Alternativa descartada:_ manter a moderação no `/app`. Criaria um segundo lugar de
+ moderação, fora do cluster que já existe.
+
+- **Seletores de pessoa como consulta de domínio** (`DelasCandidates`): conceder lista quem não tem
+ a tag, remover lista só quem tem e não é da equipe, adicionar moderadora lista só quem tem a tag, sem super
+ admins, moderadoras e líderes, e a própria pessoa que age nunca aparece. As telas só chamam a consulta.
+- **Discord conectado para pedir a tag** (`delas.require_discord`, ligado por padrão). A He4rt
+ Delas acontece no Discord: a moderação conhece a pessoa por lá, e a conta conectada é o que vai
+ ligar a tag ao cargo `he4rt_delas`. Fica depois da espera e do bloqueio na ordem das
+ verificações, para ninguém ser mandada conectar o Discord sem poder pedir.
+ - _Alternativa descartada:_ exigir o perfil completo. Não prova nada sobre a pessoa, pede
+ dados pessoais a mais (minimização da LGPD) e afasta quem está começando. Ficou só um
+ lembrete no pop-up.
+- **Moderadora precisa ter a tag, e quem é da equipe não perde a tag.** Quem modera a He4rt
+ Delas faz parte dela: para promover alguém de fora, a líder concede a tag antes; para tirar a
+ tag de uma moderadora, revoga o papel antes. `RevokeDelasTag` recusa quem passa no
+ `moderate-delas`: moderadoras, líderes e super admins.
+ - _Alternativa descartada:_ tirar da moderação junto ao remover a tag. Ficaria num passo só,
+ mas uma ação de tag passaria a mexer na equipe por um caminho indireto.
+- **Bloquear não tira a tag.** Tirar a tag é da líder, com motivo próprio ("Remover tag", com a
+ opção de bloquear junto). Se o bloqueio tirasse a tag, a moderadora teria um caminho indireto
+ para remover membras.
+- **"Ver perfil" só leitura, com o mínimo.** A moderação vê o que ajuda a decidir (foto, título,
+ senioridade, "Sobre", Discord), nunca e-mail, data de nascimento ou localização. Não abre a área
+ de Perfis do admin para moderadoras: daria acesso ao perfil de todo mundo.
+- **Marca no design system.** A logo, a tag e o ícone `he4rt-delas` moram no módulo `he4rt`
+ (`x-he4rt::delas.logo`, `x-he4rt::delas.tag`), porque os dois painéis usam. A paleta
+ `--color-delas-*` está no tema dos dois painéis.
+
+## Consequências
+
+- O `identity` ganha um case em `UserRole`, uma migration de role e um state de factory.
+- O campo de roles do `UserForm` passa a ser visível só para super admin. Fora de produção o
+ `/admin` é aberto, e sem isso qualquer pessoa autenticada se daria `delas-moderator`.
+- `delas-moderator` e `delas-lead` entram no `/admin` (`UserRole::grantsAdminAccess()`), mas só
+ acessam o Dashboard (sem widgets) e as páginas da He4rt Delas. Todo o resto do admin tem o
+ trait `SuperAdminOnly`, e um teste de varredura cobra isso.
+- Papéis alterados pelas actions do delas entram no histórico. Os alterados direto no `UserForm`
+ não: essa auditoria é concern do `identity` e vale para todas as roles.
+- Sincronizar a tag com o cargo `he4rt_delas` do Discord fica para depois. Os eventos de domínio
+ deixam o gancho pronto.
+- A tag revela identidade de gênero, dado sensível pela LGPD. Hoje só a própria pessoa e quem
+ modera a veem; exibir a tag publicamente exige nova decisão.
diff --git a/app-modules/delas/lang/en/enums.php b/app-modules/delas/lang/en/enums.php
new file mode 100644
index 000000000..bacaa20dd
--- /dev/null
+++ b/app-modules/delas/lang/en/enums.php
@@ -0,0 +1,51 @@
+ [
+ 'pending' => [
+ 'label' => 'Pending',
+ 'description' => 'Waiting for a He4rt Delas moderator to decide.',
+ ],
+ 'approved' => [
+ 'label' => 'Approved',
+ 'description' => 'The He4rt Delas tag shows on the profile.',
+ ],
+ 'rejected' => [
+ 'label' => 'Rejected',
+ 'description' => 'Not approved. The person can request again after the cooldown.',
+ ],
+ 'revoked' => [
+ 'label' => 'Removed',
+ 'description' => 'The tag was removed. The person can request again after the cooldown.',
+ ],
+ ],
+ 'action' => [
+ 'requested' => ['label' => 'Requested', 'description' => 'The person requested the He4rt Delas tag.'],
+ 'approved' => ['label' => 'Approved', 'description' => 'A pending request was approved.'],
+ 'rejected' => ['label' => 'Rejected', 'description' => 'A pending request was rejected.'],
+ 'granted' => ['label' => 'Granted', 'description' => 'The tag was granted directly, skipping the queue.'],
+ 'revoked' => ['label' => 'Removed the tag', 'description' => 'The tag was removed from someone who had it.'],
+ 'blocked' => ['label' => 'Blocked', 'description' => 'The person was prevented from requesting the tag.'],
+ 'unblocked' => ['label' => 'Unblocked', 'description' => 'The person can request the tag again.'],
+ 'moderator_added' => ['label' => 'Moderator added', 'description' => 'A lead gave the He4rt Delas moderator role.'],
+ 'reason_corrected' => ['label' => 'Reason edited', 'description' => 'The reason of a decision was edited; the original stays in the history.'],
+ 'moderator_removed' => ['label' => 'Moderator removed', 'description' => 'A lead removed the He4rt Delas moderator role.'],
+ ],
+ 'triggered_by' => [
+ 'user' => ['label' => 'The person', 'description' => 'Done by the person who requested the tag.'],
+ 'moderator' => ['label' => 'Moderator', 'description' => 'Done by a He4rt Delas moderator.'],
+ 'lead' => ['label' => 'Lead', 'description' => 'Done by a He4rt Delas lead.'],
+ 'admin' => ['label' => 'Admin', 'description' => 'Done by a super admin.'],
+ 'system' => ['label' => 'System', 'description' => 'Done automatically by the platform.'],
+ ],
+ 'eligibility' => [
+ 'can_request' => ['label' => 'Can request', 'description' => 'The person can request the He4rt Delas tag.'],
+ 'pending' => ['label' => 'Awaiting approval', 'description' => 'There is a pending request.'],
+ 'member' => ['label' => 'Member', 'description' => 'The person has the He4rt Delas tag.'],
+ 'cooldown' => ['label' => 'Cooldown', 'description' => 'A recent rejection or removal prevents a new request for now.'],
+ 'blocked' => ['label' => 'Unavailable', 'description' => 'The person is blocked from requesting the tag.'],
+ 'discord_required' => ['label' => 'Discord missing', 'description' => 'The person needs to connect Discord to request the tag.'],
+ ],
+];
diff --git a/app-modules/delas/lang/en/exceptions.php b/app-modules/delas/lang/en/exceptions.php
new file mode 100644
index 000000000..8107e6efd
--- /dev/null
+++ b/app-modules/delas/lang/en/exceptions.php
@@ -0,0 +1,27 @@
+ 'This person already has a pending or approved request.',
+ 'in_cooldown' => 'You cannot request yet. Try again from :date.',
+ 'blocked' => 'It is not possible to request the He4rt Delas tag right now.',
+ 'discord_required' => 'Connect your Discord account to request the He4rt Delas tag.',
+ 'invalid_transition' => 'A :from request cannot become :to.',
+ 'cannot_decide_own' => 'You cannot decide on your own tag. Someone else on the team has to.',
+ 'reason_required' => 'Provide a reason to continue.',
+ 'cannot_block_team' => 'Moderators, leads, admins and yourself cannot be blocked.',
+ 'already_blocked' => 'This person is already blocked.',
+ 'block_already_lifted' => 'This block has already been lifted.',
+ 'cannot_unblock_others' => 'Only whoever created the block or a lead can lift it.',
+ 'already_has_tag' => 'This person already has the He4rt Delas tag.',
+ 'has_no_tag' => 'This person does not have the He4rt Delas tag.',
+ 'cannot_manage_role' => 'Leads and super admins are managed in /admin.',
+ 'team_member_keeps_tag' => 'He4rt Delas team members (moderators, leads and super admins) keep the tag. Remove the person from the team before removing the tag.',
+ 'moderator_needs_tag' => 'Only people with the He4rt Delas tag can be moderators. Grant the tag first.',
+ 'already_moderator' => 'This person is already a He4rt Delas moderator.',
+ 'not_moderator' => 'This person is not a He4rt Delas moderator.',
+ 'reason_not_correctable' => 'This history entry has no reason that can be edited.',
+ 'cannot_correct_reason' => 'Only whoever wrote the reason can edit it, up to :hours hours later. After that, ask a lead.',
+ 'reason_unchanged' => 'The edited reason is the same as the current one.',
+];
diff --git a/app-modules/delas/lang/pt_BR/enums.php b/app-modules/delas/lang/pt_BR/enums.php
new file mode 100644
index 000000000..1dd0dd0c9
--- /dev/null
+++ b/app-modules/delas/lang/pt_BR/enums.php
@@ -0,0 +1,51 @@
+ [
+ 'pending' => [
+ 'label' => 'Pendente',
+ 'description' => 'Aguardando uma moderadora da He4rt Delas decidir.',
+ ],
+ 'approved' => [
+ 'label' => 'Aprovada',
+ 'description' => 'A tag He4rt Delas aparece no perfil.',
+ ],
+ 'rejected' => [
+ 'label' => 'Rejeitada',
+ 'description' => 'Não aprovada. A pessoa pode pedir de novo depois da espera.',
+ ],
+ 'revoked' => [
+ 'label' => 'Removida',
+ 'description' => 'A tag foi removida. A pessoa pode pedir de novo depois da espera.',
+ ],
+ ],
+ 'action' => [
+ 'requested' => ['label' => 'Solicitou', 'description' => 'A pessoa pediu a tag He4rt Delas.'],
+ 'approved' => ['label' => 'Aprovou', 'description' => 'Uma solicitação pendente foi aprovada.'],
+ 'rejected' => ['label' => 'Rejeitou', 'description' => 'Uma solicitação pendente foi rejeitada.'],
+ 'granted' => ['label' => 'Concedeu', 'description' => 'A tag foi concedida direto, sem passar pela fila.'],
+ 'revoked' => ['label' => 'Removeu a tag', 'description' => 'A tag foi removida de quem tinha.'],
+ 'blocked' => ['label' => 'Bloqueou', 'description' => 'A pessoa foi impedida de solicitar a tag.'],
+ 'unblocked' => ['label' => 'Desbloqueou', 'description' => 'A pessoa voltou a poder solicitar a tag.'],
+ 'moderator_added' => ['label' => 'Moderadora adicionada', 'description' => 'Uma líder deu o papel de moderadora He4rt Delas.'],
+ 'reason_corrected' => ['label' => 'Motivo editado', 'description' => 'O motivo de uma decisão foi editado; a versão original continua no histórico.'],
+ 'moderator_removed' => ['label' => 'Moderadora removida', 'description' => 'Uma líder retirou o papel de moderadora He4rt Delas.'],
+ ],
+ 'triggered_by' => [
+ 'user' => ['label' => 'Própria pessoa', 'description' => 'Ação feita por quem pediu a tag.'],
+ 'moderator' => ['label' => 'Moderadora', 'description' => 'Ação feita por uma moderadora He4rt Delas.'],
+ 'lead' => ['label' => 'Líder', 'description' => 'Ação feita por uma líder He4rt Delas.'],
+ 'admin' => ['label' => 'Admin', 'description' => 'Ação feita por um super admin.'],
+ 'system' => ['label' => 'Sistema', 'description' => 'Ação automática da plataforma.'],
+ ],
+ 'eligibility' => [
+ 'can_request' => ['label' => 'Pode solicitar', 'description' => 'A pessoa pode pedir a tag He4rt Delas.'],
+ 'pending' => ['label' => 'Aguardando aprovação', 'description' => 'Há uma solicitação pendente.'],
+ 'member' => ['label' => 'Faz parte', 'description' => 'A pessoa tem a tag He4rt Delas.'],
+ 'cooldown' => ['label' => 'Em espera', 'description' => 'Uma rejeição ou remoção recente impede um novo pedido por enquanto.'],
+ 'blocked' => ['label' => 'Indisponível', 'description' => 'A pessoa está bloqueada de solicitar a tag.'],
+ 'discord_required' => ['label' => 'Falta o Discord', 'description' => 'A pessoa precisa conectar o Discord para pedir a tag.'],
+ ],
+];
diff --git a/app-modules/delas/lang/pt_BR/exceptions.php b/app-modules/delas/lang/pt_BR/exceptions.php
new file mode 100644
index 000000000..41ab5b0de
--- /dev/null
+++ b/app-modules/delas/lang/pt_BR/exceptions.php
@@ -0,0 +1,27 @@
+ 'Já existe uma solicitação pendente ou aprovada para esta pessoa.',
+ 'in_cooldown' => 'Ainda não é possível solicitar. Tente de novo a partir de :date.',
+ 'blocked' => 'No momento, não é possível solicitar a tag He4rt Delas.',
+ 'discord_required' => 'Conecte sua conta do Discord para pedir a tag He4rt Delas.',
+ 'invalid_transition' => 'Uma solicitação :from não pode passar para :to.',
+ 'cannot_decide_own' => 'Você não pode decidir sobre a própria tag. Outra pessoa da equipe precisa fazer isso.',
+ 'reason_required' => 'Informe o motivo para continuar.',
+ 'cannot_block_team' => 'Não é possível bloquear moderadoras, líderes, admins ou a si mesma.',
+ 'already_blocked' => 'Esta pessoa já está bloqueada.',
+ 'block_already_lifted' => 'Este bloqueio já foi encerrado.',
+ 'cannot_unblock_others' => 'Só quem fez o bloqueio ou uma líder pode desfazê-lo.',
+ 'already_has_tag' => 'Esta pessoa já tem a tag He4rt Delas.',
+ 'has_no_tag' => 'Esta pessoa não tem a tag He4rt Delas.',
+ 'cannot_manage_role' => 'Líderes e super admins são gerenciados no /admin.',
+ 'team_member_keeps_tag' => 'Quem é da equipe da He4rt Delas (moderadora, líder ou super admin) não perde a tag. Tire a pessoa da equipe antes de remover a tag.',
+ 'moderator_needs_tag' => 'Só quem tem a tag He4rt Delas pode ser moderadora. Conceda a tag antes.',
+ 'already_moderator' => 'Esta pessoa já é moderadora He4rt Delas.',
+ 'not_moderator' => 'Esta pessoa não é moderadora He4rt Delas.',
+ 'reason_not_correctable' => 'Esta linha do histórico não tem um motivo que possa ser editado.',
+ 'cannot_correct_reason' => 'Só quem escreveu o motivo pode editá-lo, e até :hours horas depois. Depois disso, peça a uma líder.',
+ 'reason_unchanged' => 'O motivo editado é igual ao atual.',
+];
diff --git a/app-modules/delas/phpstan.ignore.neon b/app-modules/delas/phpstan.ignore.neon
new file mode 100644
index 000000000..f51e71c3f
--- /dev/null
+++ b/app-modules/delas/phpstan.ignore.neon
@@ -0,0 +1,2 @@
+parameters:
+ ignoreErrors: []
diff --git a/app-modules/delas/phpstan.neon b/app-modules/delas/phpstan.neon
new file mode 100644
index 000000000..b577d0f29
--- /dev/null
+++ b/app-modules/delas/phpstan.neon
@@ -0,0 +1,6 @@
+includes:
+ - phpstan.ignore.neon
+
+parameters:
+ paths:
+ - src/
diff --git a/app-modules/delas/src/Block/Actions/BlockDelasRequester.php b/app-modules/delas/src/Block/Actions/BlockDelasRequester.php
new file mode 100644
index 000000000..ea4053541
--- /dev/null
+++ b/app-modules/delas/src/Block/Actions/BlockDelasRequester.php
@@ -0,0 +1,94 @@
+authorize('moderate-delas');
+
+ $reason = Reason::required($reason);
+
+ try {
+ [$block, $rejected] = DB::transaction(function () use ($target, $actor, $reason): array {
+ PersonLock::acquire($target);
+
+ // Ninguém da equipe (nem super admin) é bloqueado, nem a si mesma.
+ throw_if(
+ $target->is($actor) || Gate::forUser($target)->allows('moderate-delas'),
+ DelasException::cannotBlockTeam(),
+ );
+
+ // Travado: se o pedido for aprovado ao mesmo tempo, o Postgres espera e
+ // relê a linha. Já aprovado, ele não volta, e o bloqueio segue sem rejeitar nada.
+ $pending = DelasTagRequest::query()
+ ->where('user_id', $target->getKey())
+ ->pending()
+ ->lockForUpdate()
+ ->first();
+ $rejected = $pending instanceof DelasTagRequest
+ ? $this->rejectRequest->rejectInTransaction($pending, $actor, $reason)
+ : null;
+
+ $block = DelasRequesterBlock::query()->create([
+ 'user_id' => $target->getKey(),
+ 'blocked_by' => $actor->getKey(),
+ 'reason' => $reason,
+ 'blocked_at' => now(),
+ ]);
+
+ $this->recordTransition->handle(
+ action: DelasAction::Blocked,
+ subject: $target,
+ actor: $actor,
+ block: $block,
+ reason: $reason,
+ );
+
+ return [$block, $rejected];
+ });
+ } catch (UniqueConstraintViolationException) {
+ throw DelasException::alreadyBlocked();
+ }
+
+ if ($rejected instanceof DelasTagRequest) {
+ event(new DelasTagRejected($rejected->getKey(), $target->getKey(), $actor->getKey()));
+ }
+
+ event(new DelasRequesterBlocked($block->getKey(), $target->getKey(), $actor->getKey()));
+
+ return $block;
+ }
+}
diff --git a/app-modules/delas/src/Block/Actions/UnblockDelasRequester.php b/app-modules/delas/src/Block/Actions/UnblockDelasRequester.php
new file mode 100644
index 000000000..5b2274380
--- /dev/null
+++ b/app-modules/delas/src/Block/Actions/UnblockDelasRequester.php
@@ -0,0 +1,78 @@
+authorize('moderate-delas');
+
+ $reason = Reason::required($reason);
+
+ throw_unless(
+ $block->blocked_by === $actor->getKey() || Gate::forUser($actor)->allows('lead-delas'),
+ DelasException::cannotUnblockOthers(),
+ );
+
+ $lifted = DB::transaction(fn (): DelasRequesterBlock => $this->liftInTransaction($block, $actor, $reason));
+
+ event(new DelasRequesterUnblocked($lifted->getKey(), $lifted->user_id, $actor->getKey()));
+
+ return $lifted;
+ }
+
+ /**
+ * Para quem já está numa transação, como a concessão direta a alguém
+ * bloqueado. Não checa permissão: quem chama já checou.
+ *
+ * @throws DelasException
+ */
+ public function liftInTransaction(DelasRequesterBlock $block, User $actor, string $reason): DelasRequesterBlock
+ {
+ $locked = DelasRequesterBlock::query()->whereKey($block->getKey())->lockForUpdate()->firstOrFail();
+
+ throw_unless($locked->isActive(), DelasException::blockAlreadyLifted());
+
+ $locked->update([
+ 'lifted_by' => $actor->getKey(),
+ 'lifted_at' => now(),
+ 'lift_reason' => $reason,
+ ]);
+
+ $this->recordTransition->handle(
+ action: DelasAction::Unblocked,
+ subject: $locked->user,
+ actor: $actor,
+ block: $locked,
+ reason: $reason,
+ );
+
+ return $locked;
+ }
+}
diff --git a/app-modules/delas/src/Block/Events/DelasRequesterBlocked.php b/app-modules/delas/src/Block/Events/DelasRequesterBlocked.php
new file mode 100644
index 000000000..9ddf9afe4
--- /dev/null
+++ b/app-modules/delas/src/Block/Events/DelasRequesterBlocked.php
@@ -0,0 +1,22 @@
+ */
+ use HasFactory;
+ use HasUuids;
+
+ protected $fillable = [
+ 'user_id',
+ 'blocked_by',
+ 'reason',
+ 'blocked_at',
+ 'lifted_by',
+ 'lifted_at',
+ 'lift_reason',
+ ];
+
+ /** @return BelongsTo */
+ public function user(): BelongsTo
+ {
+ return $this->belongsTo(User::class);
+ }
+
+ /** @return BelongsTo */
+ public function blocker(): BelongsTo
+ {
+ return $this->belongsTo(User::class, 'blocked_by');
+ }
+
+ /** @return BelongsTo */
+ public function lifter(): BelongsTo
+ {
+ return $this->belongsTo(User::class, 'lifted_by');
+ }
+
+ public function isActive(): bool
+ {
+ return $this->lifted_at === null;
+ }
+
+ /**
+ * @param Builder $query
+ * @return Builder
+ */
+ #[Scope]
+ protected function active(Builder $query): Builder
+ {
+ return $query->whereNull('lifted_at');
+ }
+
+ /** @return array */
+ protected function casts(): array
+ {
+ return [
+ 'blocked_at' => 'datetime',
+ 'lifted_at' => 'datetime',
+ ];
+ }
+}
diff --git a/app-modules/delas/src/DelasServiceProvider.php b/app-modules/delas/src/DelasServiceProvider.php
new file mode 100644
index 000000000..f297ab25a
--- /dev/null
+++ b/app-modules/delas/src/DelasServiceProvider.php
@@ -0,0 +1,38 @@
+mergeConfigFrom(__DIR__.'/../config/delas.php', 'delas');
+ }
+
+ public function boot(): void
+ {
+ $this->loadTranslationsFrom(__DIR__.'/../lang', 'delas');
+
+ $this->defineGates();
+ }
+
+ /**
+ * Super admins passam em todos pelo `Gate::before` do identity.
+ */
+ private function defineGates(): void
+ {
+ Gate::define('moderate-delas', fn (User $user): bool => $user->hasAnyRole([
+ UserRole::DelasModerator,
+ UserRole::DelasLead,
+ ]));
+
+ Gate::define('lead-delas', fn (User $user): bool => $user->hasRole(UserRole::DelasLead));
+ }
+}
diff --git a/app-modules/delas/src/Exceptions/DelasException.php b/app-modules/delas/src/Exceptions/DelasException.php
new file mode 100644
index 000000000..046286964
--- /dev/null
+++ b/app-modules/delas/src/Exceptions/DelasException.php
@@ -0,0 +1,130 @@
+ $nextAllowedAt->timezone(config('app.display_timezone'))->format('d/m'),
+ ]),
+ Response::HTTP_UNPROCESSABLE_ENTITY,
+ );
+ }
+
+ public static function blocked(): self
+ {
+ return new self(__('delas::exceptions.blocked'), Response::HTTP_FORBIDDEN);
+ }
+
+ public static function discordRequired(): self
+ {
+ return new self(__('delas::exceptions.discord_required'), Response::HTTP_UNPROCESSABLE_ENTITY);
+ }
+
+ public static function invalidTransition(DelasRequestStatus $from, DelasRequestStatus $to): self
+ {
+ return new self(
+ __('delas::exceptions.invalid_transition', ['from' => $from->getLabel(), 'to' => $to->getLabel()]),
+ Response::HTTP_UNPROCESSABLE_ENTITY,
+ );
+ }
+
+ public static function cannotDecideOwn(): self
+ {
+ return new self(__('delas::exceptions.cannot_decide_own'), Response::HTTP_FORBIDDEN);
+ }
+
+ public static function reasonRequired(): self
+ {
+ return new self(__('delas::exceptions.reason_required'), Response::HTTP_UNPROCESSABLE_ENTITY);
+ }
+
+ public static function cannotBlockTeam(): self
+ {
+ return new self(__('delas::exceptions.cannot_block_team'), Response::HTTP_FORBIDDEN);
+ }
+
+ public static function alreadyBlocked(): self
+ {
+ return new self(__('delas::exceptions.already_blocked'), Response::HTTP_CONFLICT);
+ }
+
+ public static function blockAlreadyLifted(): self
+ {
+ return new self(__('delas::exceptions.block_already_lifted'), Response::HTTP_CONFLICT);
+ }
+
+ public static function cannotUnblockOthers(): self
+ {
+ return new self(__('delas::exceptions.cannot_unblock_others'), Response::HTTP_FORBIDDEN);
+ }
+
+ public static function alreadyHasTag(): self
+ {
+ return new self(__('delas::exceptions.already_has_tag'), Response::HTTP_CONFLICT);
+ }
+
+ public static function hasNoTag(): self
+ {
+ return new self(__('delas::exceptions.has_no_tag'), Response::HTTP_UNPROCESSABLE_ENTITY);
+ }
+
+ public static function cannotManageRole(): self
+ {
+ return new self(__('delas::exceptions.cannot_manage_role'), Response::HTTP_FORBIDDEN);
+ }
+
+ public static function teamMemberKeepsTag(): self
+ {
+ return new self(__('delas::exceptions.team_member_keeps_tag'), Response::HTTP_UNPROCESSABLE_ENTITY);
+ }
+
+ public static function moderatorNeedsTag(): self
+ {
+ return new self(__('delas::exceptions.moderator_needs_tag'), Response::HTTP_UNPROCESSABLE_ENTITY);
+ }
+
+ public static function alreadyModerator(): self
+ {
+ return new self(__('delas::exceptions.already_moderator'), Response::HTTP_CONFLICT);
+ }
+
+ public static function reasonNotCorrectable(): self
+ {
+ return new self(__('delas::exceptions.reason_not_correctable'), Response::HTTP_UNPROCESSABLE_ENTITY);
+ }
+
+ public static function cannotCorrectReason(int $hours): self
+ {
+ return new self(__('delas::exceptions.cannot_correct_reason', ['hours' => $hours]), Response::HTTP_FORBIDDEN);
+ }
+
+ public static function reasonUnchanged(): self
+ {
+ return new self(__('delas::exceptions.reason_unchanged'), Response::HTTP_UNPROCESSABLE_ENTITY);
+ }
+
+ public static function notModerator(): self
+ {
+ return new self(__('delas::exceptions.not_moderator'), Response::HTTP_UNPROCESSABLE_ENTITY);
+ }
+}
diff --git a/app-modules/delas/src/History/Actions/CorrectDelasReason.php b/app-modules/delas/src/History/Actions/CorrectDelasReason.php
new file mode 100644
index 000000000..2b93ba663
--- /dev/null
+++ b/app-modules/delas/src/History/Actions/CorrectDelasReason.php
@@ -0,0 +1,106 @@
+authorize('moderate-delas');
+
+ throw_unless($original->hasCorrectableReason(), DelasException::reasonNotCorrectable());
+
+ $reason = Reason::required($reason);
+
+ $this->ensureCanCorrect($original, $actor);
+
+ return DB::transaction(function () use ($original, $actor, $reason): DelasTransition {
+ $locked = DelasTransition::query()->whereKey($original->getKey())->lockForUpdate()->firstOrFail();
+
+ throw_if($locked->currentReason() === $reason, DelasException::reasonUnchanged());
+
+ $correction = $this->recordTransition->handle(
+ action: DelasAction::ReasonCorrected,
+ subject: $locked->user,
+ actor: $actor,
+ request: $locked->request,
+ block: $locked->block,
+ reason: $reason,
+ corrects: $locked,
+ );
+
+ $this->updateCurrentReason($locked, $reason);
+
+ return $correction;
+ });
+ }
+
+ /**
+ * @throws DelasException
+ */
+ private function ensureCanCorrect(DelasTransition $original, User $actor): void
+ {
+ if (Gate::forUser($actor)->allows('lead-delas')) {
+ return;
+ }
+
+ $isAuthor = $original->actor_id === $actor->getKey();
+ $isWithinWindow = $original->reasonCorrectionDeadline()?->isFuture() ?? false;
+
+ throw_unless($isAuthor && $isWithinWindow, DelasException::cannotCorrectReason(config()->integer('delas.reason_correction_hours')));
+ }
+
+ /**
+ * Leva o motivo corrigido para o registro que a tela mostra hoje, só se esse
+ * registro ainda estiver no estado que a decisão criou.
+ */
+ private function updateCurrentReason(DelasTransition $original, string $reason): void
+ {
+ match ($original->action) {
+ DelasAction::Rejected, DelasAction::Revoked, DelasAction::Granted => $this->updateRequest($original, $reason),
+ DelasAction::Blocked => $original->block?->update(['reason' => $reason]),
+ DelasAction::Unblocked => $original->block?->update(['lift_reason' => $reason]),
+ default => null,
+ };
+ }
+
+ private function updateRequest(DelasTransition $original, string $reason): void
+ {
+ $request = $original->request;
+
+ if ($request instanceof DelasTagRequest && $request->status === $original->to_status) {
+ $request->update(['decision_reason' => $reason]);
+ }
+ }
+}
diff --git a/app-modules/delas/src/History/Actions/RecordDelasTransition.php b/app-modules/delas/src/History/Actions/RecordDelasTransition.php
new file mode 100644
index 000000000..6c774bf99
--- /dev/null
+++ b/app-modules/delas/src/History/Actions/RecordDelasTransition.php
@@ -0,0 +1,45 @@
+create([
+ 'user_id' => $subject->getKey(),
+ 'request_id' => $request?->getKey(),
+ 'block_id' => $block?->getKey(),
+ 'corrects_id' => $corrects?->getKey(),
+ 'action' => $action,
+ 'from_status' => $from,
+ 'to_status' => $to,
+ 'actor_id' => $actor?->getKey(),
+ 'triggered_by' => $actor instanceof User ? DelasTriggeredBy::for($actor) : DelasTriggeredBy::System,
+ 'reason' => $reason,
+ ]);
+ }
+}
diff --git a/app-modules/delas/src/History/Enums/DelasAction.php b/app-modules/delas/src/History/Enums/DelasAction.php
new file mode 100644
index 000000000..21b20ccfd
--- /dev/null
+++ b/app-modules/delas/src/History/Enums/DelasAction.php
@@ -0,0 +1,112 @@
+
+ */
+ public static function moderationDecisions(): array
+ {
+ return array_values(array_filter(self::cases(), fn (self $action): bool => $action->isModerationDecision()));
+ }
+
+ public function getLabel(): string
+ {
+ return __('delas::enums.action.'.$this->value.'.label');
+ }
+
+ /**
+ * Cada ação tem a sua cor para o histórico ser lido de relance. Não é uma
+ * escala, então a rampa do claro ao vermelho não se aplica.
+ *
+ * @return array
+ */
+ public function getColor(): array
+ {
+ return match ($this) {
+ self::Requested => Color::Gray,
+ self::Approved => Color::Green,
+ self::Granted => Color::Emerald,
+ self::Rejected => Color::Red,
+ self::Revoked => Color::Orange,
+ self::Blocked => Color::Rose,
+ self::Unblocked => Color::Sky,
+ self::ModeratorAdded => Color::Indigo,
+ self::ModeratorRemoved => Color::Slate,
+ self::ReasonCorrected => Color::Yellow,
+ };
+ }
+
+ public function getDescription(): string
+ {
+ return __('delas::enums.action.'.$this->value.'.description');
+ }
+
+ public function getIcon(): Heroicon
+ {
+ return match ($this) {
+ self::Requested => Heroicon::OutlinedPaperAirplane,
+ self::Approved => Heroicon::OutlinedCheck,
+ self::Granted => Heroicon::OutlinedPlusCircle,
+ self::Rejected => Heroicon::OutlinedXMark,
+ self::Revoked => Heroicon::OutlinedMinusCircle,
+ self::Blocked => Heroicon::OutlinedNoSymbol,
+ self::Unblocked => Heroicon::OutlinedLockOpen,
+ self::ModeratorAdded => Heroicon::OutlinedUserPlus,
+ self::ModeratorRemoved => Heroicon::OutlinedUserMinus,
+ self::ReasonCorrected => Heroicon::OutlinedPencilSquare,
+ };
+ }
+
+ /**
+ * Ações cujo motivo pode ser corrigido depois. A correção é uma linha nova
+ * no histórico; a original nunca muda.
+ */
+ public function hasCorrectableReason(): bool
+ {
+ return match ($this) {
+ self::Rejected, self::Revoked, self::Granted, self::Blocked, self::Unblocked => true,
+ self::Requested, self::Approved, self::ModeratorAdded, self::ModeratorRemoved, self::ReasonCorrected => false,
+ };
+ }
+
+ /**
+ * Decisão de moderação sobre uma pessoa: o que conta em "Decisões" na Equipe.
+ * Pedir a tag, mexer na equipe e editar um motivo não contam.
+ */
+ public function isModerationDecision(): bool
+ {
+ return match ($this) {
+ self::Approved, self::Rejected, self::Granted, self::Revoked, self::Blocked, self::Unblocked => true,
+ self::Requested, self::ModeratorAdded, self::ModeratorRemoved, self::ReasonCorrected => false,
+ };
+ }
+}
diff --git a/app-modules/delas/src/History/Enums/DelasTriggeredBy.php b/app-modules/delas/src/History/Enums/DelasTriggeredBy.php
new file mode 100644
index 000000000..2b7d1a8dc
--- /dev/null
+++ b/app-modules/delas/src/History/Enums/DelasTriggeredBy.php
@@ -0,0 +1,72 @@
+isSuperAdmin() => self::Admin,
+ $actor->hasRole(UserRole::DelasLead) => self::Lead,
+ $actor->hasRole(UserRole::DelasModerator) => self::Moderator,
+ default => self::User,
+ };
+ }
+
+ public function getLabel(): string
+ {
+ return __('delas::enums.triggered_by.'.$this->value.'.label');
+ }
+
+ public function getColor(): string
+ {
+ return match ($this) {
+ self::User, self::System => 'gray',
+ self::Moderator => 'info',
+ self::Lead => 'primary',
+ self::Admin => 'danger',
+ };
+ }
+
+ public function getDescription(): string
+ {
+ return __('delas::enums.triggered_by.'.$this->value.'.description');
+ }
+
+ public function getIcon(): Heroicon
+ {
+ return match ($this) {
+ self::User => Heroicon::OutlinedUser,
+ self::Moderator => Heroicon::OutlinedHeart,
+ self::Lead => Heroicon::OutlinedSparkles,
+ self::Admin => Heroicon::OutlinedShieldCheck,
+ self::System => Heroicon::OutlinedCog6Tooth,
+ };
+ }
+}
diff --git a/app-modules/delas/src/History/Models/DelasTransition.php b/app-modules/delas/src/History/Models/DelasTransition.php
new file mode 100644
index 000000000..99803045e
--- /dev/null
+++ b/app-modules/delas/src/History/Models/DelasTransition.php
@@ -0,0 +1,157 @@
+ $corrections
+ */
+#[Table(name: 'delas_transitions')]
+#[UseFactory(factoryClass: DelasTransitionFactory::class)]
+final class DelasTransition extends Model
+{
+ /** @use HasFactory */
+ use HasFactory;
+ use HasUuids;
+
+ public const UPDATED_AT = null;
+
+ protected $fillable = [
+ 'user_id',
+ 'request_id',
+ 'block_id',
+ 'corrects_id',
+ 'action',
+ 'from_status',
+ 'to_status',
+ 'actor_id',
+ 'triggered_by',
+ 'reason',
+ ];
+
+ /** @return BelongsTo */
+ public function user(): BelongsTo
+ {
+ return $this->belongsTo(User::class);
+ }
+
+ /** @return BelongsTo */
+ public function actor(): BelongsTo
+ {
+ return $this->belongsTo(User::class, 'actor_id');
+ }
+
+ /** @return BelongsTo */
+ public function request(): BelongsTo
+ {
+ return $this->belongsTo(DelasTagRequest::class, 'request_id');
+ }
+
+ /** @return BelongsTo */
+ public function block(): BelongsTo
+ {
+ return $this->belongsTo(DelasRequesterBlock::class, 'block_id');
+ }
+
+ /**
+ * A linha cujo motivo esta corrige (só em linhas `reason_corrected`).
+ *
+ * @return BelongsTo
+ */
+ public function corrected(): BelongsTo
+ {
+ return $this->belongsTo(self::class, 'corrects_id');
+ }
+
+ /**
+ * Todas as edições do motivo desta linha, da mais antiga para a mais recente.
+ *
+ * @return HasMany
+ */
+ public function corrections(): HasMany
+ {
+ return $this->hasMany(self::class, 'corrects_id')->oldest('created_at');
+ }
+
+ /**
+ * A correção mais recente do motivo desta linha, se houver.
+ *
+ * @return HasOne
+ */
+ public function latestCorrection(): HasOne
+ {
+ // Sem latestOfMany(): ele desempata por MAX(id), e o Postgres não calcula MAX de UUID.
+ return $this->hasOne(self::class, 'corrects_id')->latest('created_at');
+ }
+
+ /**
+ * O motivo que vale hoje: o da correção mais recente ou o original.
+ */
+ public function currentReason(): ?string
+ {
+ $correction = $this->relationLoaded('corrections') ? $this->corrections->last() : $this->latestCorrection;
+
+ return $correction instanceof self ? $correction->reason : $this->reason;
+ }
+
+ public function hasCorrectableReason(): bool
+ {
+ return $this->reason !== null && $this->action->hasCorrectableReason();
+ }
+
+ /**
+ * Até quando quem escreveu o motivo pode editá-lo (`delas.reason_correction_hours`).
+ * Líderes editam a qualquer momento.
+ */
+ public function reasonCorrectionDeadline(): ?CarbonInterface
+ {
+ return $this->created_at?->copy()->addHours(config()->integer('delas.reason_correction_hours'));
+ }
+
+ /** @return array */
+ protected function casts(): array
+ {
+ return [
+ 'action' => DelasAction::class,
+ 'from_status' => DelasRequestStatus::class,
+ 'to_status' => DelasRequestStatus::class,
+ 'triggered_by' => DelasTriggeredBy::class,
+ 'created_at' => 'datetime',
+ ];
+ }
+}
diff --git a/app-modules/delas/src/History/Queries/DelasOverview.php b/app-modules/delas/src/History/Queries/DelasOverview.php
new file mode 100644
index 000000000..c8cdfbd47
--- /dev/null
+++ b/app-modules/delas/src/History/Queries/DelasOverview.php
@@ -0,0 +1,76 @@
+pending()->count();
+ }
+
+ public function oldestPendingAt(): ?CarbonInterface
+ {
+ $oldest = DelasTagRequest::query()->pending()->min('requested_at');
+
+ return $oldest === null ? null : CarbonImmutable::parse($oldest);
+ }
+
+ public function membersCount(): int
+ {
+ return DelasTagRequest::query()->where('status', DelasRequestStatus::Approved)->count();
+ }
+
+ /**
+ * Horas, em média, entre o pedido e a decisão da moderação (aprovar ou
+ * rejeitar) nos últimos dias. Concessões diretas não entram: não houve
+ * espera.
+ */
+ public function averageDecisionHours(int $days = 90): ?float
+ {
+ $seconds = DelasTransition::query()
+ ->join('delas_tag_requests', 'delas_tag_requests.id', '=', 'delas_transitions.request_id')
+ ->whereIn('delas_transitions.action', [DelasAction::Approved, DelasAction::Rejected])
+ ->where('delas_transitions.created_at', '>=', now()->subDays($days))
+ ->selectRaw('avg(extract(epoch from (delas_transitions.created_at - delas_tag_requests.requested_at))) as seconds')
+ ->value('seconds');
+
+ return $seconds === null ? null : (float) $seconds / 3_600;
+ }
+
+ /**
+ * @return array{approved: int, rejected: int}
+ */
+ public function decisionsSince(CarbonInterface $since): array
+ {
+ $counts = DelasTransition::query()
+ ->where('created_at', '>=', $since)
+ ->whereIn('action', [DelasAction::Approved, DelasAction::Granted, DelasAction::Rejected])
+ ->selectRaw('action, count(*) as total')
+ ->groupBy('action')
+ ->pluck('total', 'action');
+
+ return [
+ 'approved' => (int) ($counts[DelasAction::Approved->value] ?? 0) + (int) ($counts[DelasAction::Granted->value] ?? 0),
+ 'rejected' => (int) ($counts[DelasAction::Rejected->value] ?? 0),
+ ];
+ }
+
+ public function activeBlocksCount(): int
+ {
+ return DelasRequesterBlock::query()->active()->count();
+ }
+}
diff --git a/app-modules/delas/src/Support/PersonLock.php b/app-modules/delas/src/Support/PersonLock.php
new file mode 100644
index 000000000..32fda028e
--- /dev/null
+++ b/app-modules/delas/src/Support/PersonLock.php
@@ -0,0 +1,26 @@
+whereKey($person->getKey())->lockForUpdate()->first();
+
+ // Os papéis carregados antes da trava podem estar velhos.
+ $person->unsetRelation('roles');
+ }
+}
diff --git a/app-modules/delas/src/Support/Reason.php b/app-modules/delas/src/Support/Reason.php
new file mode 100644
index 000000000..00319fad7
--- /dev/null
+++ b/app-modules/delas/src/Support/Reason.php
@@ -0,0 +1,35 @@
+authorize('moderate-delas');
+
+ $approved = DB::transaction(function () use ($request, $actor): DelasTagRequest {
+ $locked = DelasTagRequest::query()->whereKey($request->getKey())->lockForUpdate()->firstOrFail();
+
+ throw_if($locked->user_id === $actor->getKey(), DelasException::cannotDecideOwn());
+ throw_unless(
+ $locked->status->canTransitionTo(DelasRequestStatus::Approved),
+ DelasException::invalidTransition($locked->status, DelasRequestStatus::Approved),
+ );
+
+ $locked->update([
+ 'status' => DelasRequestStatus::Approved,
+ 'decided_by' => $actor->getKey(),
+ 'decided_at' => now(),
+ ]);
+
+ $this->recordTransition->handle(
+ action: DelasAction::Approved,
+ subject: $locked->user,
+ actor: $actor,
+ request: $locked,
+ from: DelasRequestStatus::Pending,
+ to: DelasRequestStatus::Approved,
+ );
+
+ return $locked;
+ });
+
+ event(new DelasTagApproved($approved->getKey(), $approved->user_id, $actor->getKey()));
+
+ return $approved;
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/Actions/GrantDelasTag.php b/app-modules/delas/src/TagRequest/Actions/GrantDelasTag.php
new file mode 100644
index 000000000..3e0d546f3
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/Actions/GrantDelasTag.php
@@ -0,0 +1,108 @@
+authorize('lead-delas');
+
+ throw_if($target->is($actor), DelasException::cannotDecideOwn());
+
+ [$request, $liftedBlock] = DB::transaction(function () use ($target, $actor, $reason): array {
+ PersonLock::acquire($target);
+
+ $activeBlock = DelasRequesterBlock::query()
+ ->where('user_id', $target->getKey())
+ ->active()
+ ->lockForUpdate()
+ ->first();
+ $reason = $activeBlock instanceof DelasRequesterBlock ? Reason::required($reason) : Reason::optional($reason);
+
+ $current = DelasTagRequest::query()
+ ->where('user_id', $target->getKey())
+ ->active()
+ ->lockForUpdate()
+ ->first();
+
+ throw_if($current?->status === DelasRequestStatus::Approved, DelasException::alreadyHasTag());
+
+ $liftedBlock = $activeBlock instanceof DelasRequesterBlock
+ ? $this->unblock->liftInTransaction($activeBlock, $actor, (string) $reason)
+ : null;
+
+ $attributes = [
+ 'status' => DelasRequestStatus::Approved,
+ 'decided_by' => $actor->getKey(),
+ 'decided_at' => now(),
+ 'decision_reason' => $reason,
+ ];
+
+ if ($current instanceof DelasTagRequest) {
+ $current->update($attributes);
+ $request = $current;
+ } else {
+ $request = DelasTagRequest::query()->create([
+ 'user_id' => $target->getKey(),
+ 'requested_at' => now(),
+ ...$attributes,
+ ]);
+ }
+
+ $this->recordTransition->handle(
+ action: DelasAction::Granted,
+ subject: $target,
+ actor: $actor,
+ request: $request,
+ from: $current instanceof DelasTagRequest ? DelasRequestStatus::Pending : null,
+ to: DelasRequestStatus::Approved,
+ reason: $reason,
+ );
+
+ return [$request, $liftedBlock];
+ });
+
+ if ($liftedBlock instanceof DelasRequesterBlock) {
+ event(new DelasRequesterUnblocked($liftedBlock->getKey(), $target->getKey(), $actor->getKey()));
+ }
+
+ event(new DelasTagGranted($request->getKey(), $target->getKey(), $actor->getKey()));
+
+ return $request;
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/Actions/RejectDelasRequest.php b/app-modules/delas/src/TagRequest/Actions/RejectDelasRequest.php
new file mode 100644
index 000000000..2170012d4
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/Actions/RejectDelasRequest.php
@@ -0,0 +1,81 @@
+authorize('moderate-delas');
+
+ $reason = Reason::required($reason);
+
+ $rejected = DB::transaction(fn (): DelasTagRequest => $this->rejectInTransaction($request, $actor, $reason));
+
+ event(new DelasTagRejected($rejected->getKey(), $rejected->user_id, $actor->getKey()));
+
+ return $rejected;
+ }
+
+ /**
+ * Para quem já está numa transação, como o bloqueio, que rejeita a
+ * solicitação pendente junto.
+ *
+ * @throws DelasException
+ */
+ public function rejectInTransaction(DelasTagRequest $request, User $actor, string $reason): DelasTagRequest
+ {
+ $locked = DelasTagRequest::query()->whereKey($request->getKey())->lockForUpdate()->firstOrFail();
+
+ throw_if($locked->user_id === $actor->getKey(), DelasException::cannotDecideOwn());
+ throw_unless(
+ $locked->status->canTransitionTo(DelasRequestStatus::Rejected),
+ DelasException::invalidTransition($locked->status, DelasRequestStatus::Rejected),
+ );
+
+ $locked->update([
+ 'status' => DelasRequestStatus::Rejected,
+ 'decided_by' => $actor->getKey(),
+ 'decided_at' => now(),
+ 'decision_reason' => $reason,
+ ]);
+
+ $this->recordTransition->handle(
+ action: DelasAction::Rejected,
+ subject: $locked->user,
+ actor: $actor,
+ request: $locked,
+ from: DelasRequestStatus::Pending,
+ to: DelasRequestStatus::Rejected,
+ reason: $reason,
+ );
+
+ return $locked;
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/Actions/RequestDelasTag.php b/app-modules/delas/src/TagRequest/Actions/RequestDelasTag.php
new file mode 100644
index 000000000..d93908588
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/Actions/RequestDelasTag.php
@@ -0,0 +1,82 @@
+ensureCanRequest($user);
+
+ $request = DelasTagRequest::query()->create([
+ 'user_id' => $user->getKey(),
+ 'status' => DelasRequestStatus::Pending,
+ 'requested_at' => now(),
+ ]);
+
+ $this->recordTransition->handle(
+ action: DelasAction::Requested,
+ subject: $user,
+ actor: $user,
+ request: $request,
+ to: DelasRequestStatus::Pending,
+ );
+
+ return $request;
+ });
+ } catch (UniqueConstraintViolationException) {
+ // Dois pedidos ao mesmo tempo: o índice único parcial deixa só um passar.
+ throw DelasException::alreadyHasActiveRequest();
+ }
+
+ event(new DelasTagRequested($request->getKey(), $user->getKey()));
+
+ return $request;
+ }
+
+ /**
+ * @throws DelasException
+ */
+ private function ensureCanRequest(User $user): void
+ {
+ $eligibility = $this->eligibility->for($user);
+
+ match ($eligibility->state) {
+ DelasEligibilityState::Pending, DelasEligibilityState::Member => throw DelasException::alreadyHasActiveRequest(),
+ DelasEligibilityState::Blocked => throw DelasException::blocked(),
+ DelasEligibilityState::Cooldown => throw DelasException::inCooldown($eligibility->nextAllowedAt ?? now()),
+ DelasEligibilityState::DiscordRequired => throw DelasException::discordRequired(),
+ DelasEligibilityState::CanRequest => null,
+ };
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/Actions/RevokeDelasTag.php b/app-modules/delas/src/TagRequest/Actions/RevokeDelasTag.php
new file mode 100644
index 000000000..b2304fda8
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/Actions/RevokeDelasTag.php
@@ -0,0 +1,95 @@
+authorize('lead-delas');
+
+ throw_if($target->is($actor), DelasException::cannotDecideOwn());
+
+ $reason = Reason::required($reason);
+
+ return DB::transaction(function () use ($target, $actor, $reason, $alsoBlock): DelasTagRequest {
+ PersonLock::acquire($target);
+
+ // Equipe é quem passa no `moderate-delas`: moderadora, líder ou super admin.
+ throw_if(Gate::forUser($target)->allows('moderate-delas'), DelasException::teamMemberKeepsTag());
+
+ $approved = DelasTagRequest::query()
+ ->where('user_id', $target->getKey())
+ ->where('status', DelasRequestStatus::Approved)
+ ->lockForUpdate()
+ ->first();
+
+ throw_unless($approved instanceof DelasTagRequest, DelasException::hasNoTag());
+
+ $approved->update([
+ 'status' => DelasRequestStatus::Revoked,
+ 'decided_by' => $actor->getKey(),
+ 'decided_at' => now(),
+ 'decision_reason' => $reason,
+ ]);
+
+ $this->recordTransition->handle(
+ action: DelasAction::Revoked,
+ subject: $target,
+ actor: $actor,
+ request: $approved,
+ from: DelasRequestStatus::Approved,
+ to: DelasRequestStatus::Revoked,
+ reason: $reason,
+ );
+
+ // Os eventos são ShouldDispatchAfterCommit: só saem se a transação inteira der certo.
+ event(new DelasTagRevoked($approved->getKey(), $target->getKey(), $actor->getKey()));
+
+ // Quem já está bloqueada continua com o bloqueio que tem.
+ if ($alsoBlock && !resolve(DelasEligibility::class)->isBlocked($target)) {
+ $this->blockRequester->handle($target, $actor, $reason);
+ }
+
+ return $approved;
+ });
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/Enums/DelasEligibilityState.php b/app-modules/delas/src/TagRequest/Enums/DelasEligibilityState.php
new file mode 100644
index 000000000..b533015fc
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/Enums/DelasEligibilityState.php
@@ -0,0 +1,57 @@
+value.'.label');
+ }
+
+ public function getColor(): string
+ {
+ return match ($this) {
+ self::CanRequest => 'primary',
+ self::Pending => 'warning',
+ self::Member => 'success',
+ self::Cooldown, self::Blocked, self::DiscordRequired => 'gray',
+ };
+ }
+
+ public function getDescription(): string
+ {
+ return __('delas::enums.eligibility.'.$this->value.'.description');
+ }
+
+ public function getIcon(): Heroicon
+ {
+ return match ($this) {
+ self::CanRequest => Heroicon::OutlinedHeart,
+ self::Pending => Heroicon::OutlinedClock,
+ self::Member => Heroicon::OutlinedCheckCircle,
+ self::Cooldown => Heroicon::OutlinedClock,
+ self::Blocked => Heroicon::OutlinedInformationCircle,
+ self::DiscordRequired => Heroicon::OutlinedLink,
+ };
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/Enums/DelasRequestStatus.php b/app-modules/delas/src/TagRequest/Enums/DelasRequestStatus.php
new file mode 100644
index 000000000..81655823a
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/Enums/DelasRequestStatus.php
@@ -0,0 +1,109 @@
+
+ */
+ public static function activeValues(): array
+ {
+ return array_values(array_map(
+ fn (self $status): string => $status->value,
+ array_filter(self::cases(), fn (self $status): bool => $status->isActive()),
+ ));
+ }
+
+ public function getLabel(): string
+ {
+ return match ($this) {
+ self::Pending => __('delas::enums.request_status.pending.label'),
+ self::Approved => __('delas::enums.request_status.approved.label'),
+ self::Rejected => __('delas::enums.request_status.rejected.label'),
+ self::Revoked => __('delas::enums.request_status.revoked.label'),
+ };
+ }
+
+ /**
+ * Estados, não níveis: a rampa do claro ao vermelho não se aplica.
+ */
+ public function getColor(): string
+ {
+ return match ($this) {
+ self::Pending => 'warning',
+ self::Approved => 'success',
+ self::Rejected, self::Revoked => 'gray',
+ };
+ }
+
+ public function getDescription(): string
+ {
+ return match ($this) {
+ self::Pending => __('delas::enums.request_status.pending.description'),
+ self::Approved => __('delas::enums.request_status.approved.description'),
+ self::Rejected => __('delas::enums.request_status.rejected.description'),
+ self::Revoked => __('delas::enums.request_status.revoked.description'),
+ };
+ }
+
+ public function getIcon(): Heroicon
+ {
+ return match ($this) {
+ self::Pending => Heroicon::OutlinedClock,
+ self::Approved => Heroicon::OutlinedCheck,
+ self::Rejected => Heroicon::OutlinedXMark,
+ self::Revoked => Heroicon::OutlinedMinusCircle,
+ };
+ }
+
+ public function canTransitionTo(self $target): bool
+ {
+ return match ($this) {
+ self::Pending => in_array($target, [self::Approved, self::Rejected], strict: true),
+ self::Approved => $target === self::Revoked,
+ self::Rejected, self::Revoked => false,
+ };
+ }
+
+ /**
+ * Ocupa o lugar da pessoa: enquanto existir, não dá para pedir de novo.
+ */
+ public function isActive(): bool
+ {
+ return match ($this) {
+ self::Pending, self::Approved => true,
+ self::Rejected, self::Revoked => false,
+ };
+ }
+
+ /**
+ * Encerra a solicitação e abre a espera para um novo pedido.
+ */
+ public function startsCooldown(): bool
+ {
+ return !$this->isActive();
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/Events/DelasTagApproved.php b/app-modules/delas/src/TagRequest/Events/DelasTagApproved.php
new file mode 100644
index 000000000..72ecefaf4
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/Events/DelasTagApproved.php
@@ -0,0 +1,22 @@
+ */
+ use HasFactory;
+ use HasUuids;
+
+ protected $fillable = [
+ 'user_id',
+ 'status',
+ 'requested_at',
+ 'decided_by',
+ 'decided_at',
+ 'decision_reason',
+ ];
+
+ /** @return BelongsTo */
+ public function user(): BelongsTo
+ {
+ return $this->belongsTo(User::class);
+ }
+
+ /** @return BelongsTo */
+ public function decider(): BelongsTo
+ {
+ return $this->belongsTo(User::class, 'decided_by');
+ }
+
+ /** @return HasMany */
+ public function transitions(): HasMany
+ {
+ return $this->hasMany(DelasTransition::class, 'request_id');
+ }
+
+ /**
+ * @param Builder $query
+ * @return Builder
+ */
+ #[Scope]
+ protected function pending(Builder $query): Builder
+ {
+ return $query->where('status', DelasRequestStatus::Pending);
+ }
+
+ /**
+ * Pendentes ou aprovadas: as que ocupam o lugar da pessoa.
+ *
+ * @param Builder $query
+ * @return Builder
+ */
+ #[Scope]
+ protected function active(Builder $query): Builder
+ {
+ return $query->whereIn('status', DelasRequestStatus::activeValues());
+ }
+
+ /** @return array */
+ protected function casts(): array
+ {
+ return [
+ 'status' => DelasRequestStatus::class,
+ 'requested_at' => 'datetime',
+ 'decided_at' => 'datetime',
+ ];
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/Queries/DelasEligibility.php b/app-modules/delas/src/TagRequest/Queries/DelasEligibility.php
new file mode 100644
index 000000000..fab36ae3c
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/Queries/DelasEligibility.php
@@ -0,0 +1,102 @@
+where('user_id', $user->getKey())
+ ->active()
+ ->first();
+
+ if ($active instanceof DelasTagRequest) {
+ $state = $active->status === DelasRequestStatus::Approved
+ ? DelasEligibilityState::Member
+ : DelasEligibilityState::Pending;
+
+ return new DelasEligibilityResult(state: $state, request: $active);
+ }
+
+ if ($this->isBlocked($user)) {
+ return new DelasEligibilityResult(DelasEligibilityState::Blocked);
+ }
+
+ $nextAllowedAt = $this->nextAllowedAt($user);
+
+ if ($nextAllowedAt instanceof CarbonInterface && $nextAllowedAt->isFuture()) {
+ return new DelasEligibilityResult(DelasEligibilityState::Cooldown, nextAllowedAt: $nextAllowedAt);
+ }
+
+ if (config()->boolean('delas.require_discord') && !$this->hasDiscord($user)) {
+ return new DelasEligibilityResult(DelasEligibilityState::DiscordRequired);
+ }
+
+ return new DelasEligibilityResult(DelasEligibilityState::CanRequest);
+ }
+
+ public function hasTag(User $user): bool
+ {
+ return DelasTagRequest::query()
+ ->where('user_id', $user->getKey())
+ ->where('status', DelasRequestStatus::Approved)
+ ->exists();
+ }
+
+ /**
+ * Discord conectado de verdade pela pessoa, não um registro criado por
+ * ingestão (ver o escopo `activelyConnected` do identity).
+ */
+ public function hasDiscord(User $user): bool
+ {
+ return $user->providers()
+ ->where('provider', IdentityProvider::Discord)
+ ->activelyConnected()
+ ->exists();
+ }
+
+ public function isBlocked(User $user): bool
+ {
+ return DelasRequesterBlock::query()
+ ->where('user_id', $user->getKey())
+ ->active()
+ ->exists();
+ }
+
+ /**
+ * A partir de quando a pessoa pode pedir de novo, contado da última
+ * rejeição ou remoção. Nulo se nunca houve uma.
+ */
+ private function nextAllowedAt(User $user): ?CarbonInterface
+ {
+ $lastDecision = DelasTagRequest::query()
+ ->where('user_id', $user->getKey())
+ ->whereIn('status', [DelasRequestStatus::Rejected, DelasRequestStatus::Revoked])
+ ->max('decided_at');
+
+ if ($lastDecision === null) {
+ return null;
+ }
+
+ return CarbonImmutable::parse($lastDecision)->addDays(config()->integer('delas.request_cooldown_days'));
+ }
+}
diff --git a/app-modules/delas/src/TagRequest/ValueObjects/DelasEligibilityResult.php b/app-modules/delas/src/TagRequest/ValueObjects/DelasEligibilityResult.php
new file mode 100644
index 000000000..753c1587e
--- /dev/null
+++ b/app-modules/delas/src/TagRequest/ValueObjects/DelasEligibilityResult.php
@@ -0,0 +1,28 @@
+state === DelasEligibilityState::CanRequest;
+ }
+
+ public function hasTag(): bool
+ {
+ return $this->state === DelasEligibilityState::Member;
+ }
+}
diff --git a/app-modules/delas/src/Team/Actions/AddDelasModerator.php b/app-modules/delas/src/Team/Actions/AddDelasModerator.php
new file mode 100644
index 000000000..df20b551c
--- /dev/null
+++ b/app-modules/delas/src/Team/Actions/AddDelasModerator.php
@@ -0,0 +1,59 @@
+authorize('lead-delas');
+
+ DB::transaction(function () use ($target, $actor): void {
+ PersonLock::acquire($target);
+
+ throw_if(
+ $target->isSuperAdmin() || $target->hasRole(UserRole::DelasLead),
+ DelasException::cannotManageRole(),
+ );
+ throw_if($target->hasRole(UserRole::DelasModerator), DelasException::alreadyModerator());
+ throw_unless($this->eligibility->hasTag($target), DelasException::moderatorNeedsTag());
+
+ $target->assignRole(UserRole::DelasModerator);
+
+ $this->recordTransition->handle(
+ action: DelasAction::ModeratorAdded,
+ subject: $target,
+ actor: $actor,
+ );
+ });
+
+ return $target;
+ }
+}
diff --git a/app-modules/delas/src/Team/Actions/RemoveDelasModerator.php b/app-modules/delas/src/Team/Actions/RemoveDelasModerator.php
new file mode 100644
index 000000000..67a00f164
--- /dev/null
+++ b/app-modules/delas/src/Team/Actions/RemoveDelasModerator.php
@@ -0,0 +1,55 @@
+authorize('lead-delas');
+
+ DB::transaction(function () use ($target, $actor): void {
+ PersonLock::acquire($target);
+
+ throw_if(
+ $target->isSuperAdmin() || $target->hasRole(UserRole::DelasLead),
+ DelasException::cannotManageRole(),
+ );
+ throw_unless($target->hasRole(UserRole::DelasModerator), DelasException::notModerator());
+
+ $target->removeRole(UserRole::DelasModerator);
+
+ $this->recordTransition->handle(
+ action: DelasAction::ModeratorRemoved,
+ subject: $target,
+ actor: $actor,
+ );
+ });
+
+ return $target;
+ }
+}
diff --git a/app-modules/delas/src/Team/Queries/DelasCandidates.php b/app-modules/delas/src/Team/Queries/DelasCandidates.php
new file mode 100644
index 000000000..c46ba59df
--- /dev/null
+++ b/app-modules/delas/src/Team/Queries/DelasCandidates.php
@@ -0,0 +1,118 @@
+
+ */
+ public function forGrant(User $actor): Builder
+ {
+ return $this->others($actor)->whereNotIn('id', $this->members());
+ }
+
+ /**
+ * Quem tem a tag hoje e não é da equipe: moderadoras, líderes e super
+ * admins saem da equipe antes de perder a tag (`RevokeDelasTag`).
+ *
+ * @return Builder
+ */
+ public function forRevoke(User $actor): Builder
+ {
+ $team = [UserRole::SuperAdmin->value, UserRole::DelasModerator->value, UserRole::DelasLead->value];
+
+ return $this->others($actor)
+ ->whereIn('id', $this->members())
+ ->whereDoesntHave('roles', fn (Builder $roles): Builder => $roles->whereIn('name', $team));
+ }
+
+ /**
+ * Quem pode virar moderadora: tem a tag, está fora da equipe (moderadoras e
+ * líderes) e não é super admin. A lista é pequena, então o seletor pode
+ * pré-carregar. Filtra pelo nome da role direto, sem o `withoutRole()` do
+ * Spatie, que quebra quando uma das roles ainda não existe no banco.
+ *
+ * @return Builder
+ */
+ public function forModerator(User $actor): Builder
+ {
+ $teamAndAdmins = [
+ UserRole::SuperAdmin->value,
+ UserRole::DelasModerator->value,
+ UserRole::DelasLead->value,
+ ];
+
+ return $this->others($actor)
+ ->whereIn('id', $this->members())
+ ->whereDoesntHave('roles', fn (Builder $roles): Builder => $roles->whereIn('name', $teamAndAdmins));
+ }
+
+ /**
+ * Busca por nome ou `@username` dentro de um dos escopos acima.
+ *
+ * @param Builder $candidates
+ * @return Collection
+ */
+ public function search(Builder $candidates, string $search, int $limit = self::SEARCH_LIMIT): Collection
+ {
+ $username = mb_ltrim(mb_trim($search), '@');
+
+ return $candidates
+ ->where(fn (Builder $query): Builder => $query
+ // Sem acento dos dois lados: "thais" acha "Thaís".
+ ->whereRaw('lower(translate(name, ?, ?)) like ?', [self::ACCENTED, self::PLAIN, '%'.$this->plain($search).'%'])
+ ->orWhereLike('username', '%'.$username.'%'))
+ ->orderBy('name')
+ ->limit($limit)
+ ->get();
+ }
+
+ private function plain(string $search): string
+ {
+ return mb_strtolower(strtr(mb_trim($search), array_combine(mb_str_split(self::ACCENTED), mb_str_split(self::PLAIN))));
+ }
+
+ /**
+ * @return Builder
+ */
+ private function others(User $actor): Builder
+ {
+ return User::query()->whereKeyNot($actor->getKey());
+ }
+
+ /**
+ * Quem tem a tag hoje: a solicitação está `approved`.
+ *
+ * @return Builder
+ */
+ private function members(): Builder
+ {
+ return DelasTagRequest::query()->where('status', DelasRequestStatus::Approved)->select('user_id');
+ }
+}
diff --git a/app-modules/delas/tests/Feature/Authorization/DelasGatesTest.php b/app-modules/delas/tests/Feature/Authorization/DelasGatesTest.php
new file mode 100644
index 000000000..c0bf95b7a
--- /dev/null
+++ b/app-modules/delas/tests/Feature/Authorization/DelasGatesTest.php
@@ -0,0 +1,32 @@
+value, UserRole::GUARD))->toBeInstanceOf(Role::class);
+})->with([UserRole::DelasModerator, UserRole::DelasLead]);
+
+test('cada papel passa só nos gates do seu nível', function (?string $state, bool $moderate, bool $lead): void {
+ $factory = User::factory();
+ $user = ($state === null ? $factory : $factory->{$state}())->create();
+
+ expect($user->can('moderate-delas'))->toBe($moderate);
+ expect($user->can('lead-delas'))->toBe($lead);
+})->with([
+ 'membra comum' => [null, false, false],
+ 'moderadora' => ['delasModerator', true, false],
+ 'líder' => ['delasLead', true, true],
+ 'super admin' => ['superAdmin', true, true],
+]);
+
+test('ao perder o papel, a moderadora perde o gate na próxima leitura', function (): void {
+ $user = User::factory()->delasModerator()->create();
+
+ $user->removeRole(UserRole::DelasModerator);
+
+ expect($user->fresh()->can('moderate-delas'))->toBeFalse();
+});
diff --git a/app-modules/delas/tests/Feature/Block/BlockDelasRequesterTest.php b/app-modules/delas/tests/Feature/Block/BlockDelasRequesterTest.php
new file mode 100644
index 000000000..60ba12688
--- /dev/null
+++ b/app-modules/delas/tests/Feature/Block/BlockDelasRequesterTest.php
@@ -0,0 +1,132 @@
+block = resolve(BlockDelasRequester::class);
+ $this->unblock = resolve(UnblockDelasRequester::class);
+});
+
+// Bloquear
+
+test('bloquear deixa a pessoa bloqueada por quem bloqueou', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $target = User::factory()->create();
+
+ $block = $this->block->handle($target, $moderator, 'Pedidos repetidos.');
+
+ expect($block->isActive())->toBeTrue();
+ expect($block->blocked_by)->toBe($moderator->getKey());
+ expect(resolve(DelasEligibility::class)->for($target)->state)->toBe(DelasEligibilityState::Blocked);
+});
+
+test('bloquear rejeita a solicitação pendente e registra as duas ações', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $target = User::factory()->create();
+ $request = DelasTagRequest::factory()->for($target)->pending()->create();
+
+ $this->block->handle($target, $moderator, 'Pedidos repetidos.');
+
+ expect($request->fresh()->status)->toBe(DelasRequestStatus::Rejected);
+ expect(DelasTransition::query()->oldest()->pluck('action')->all())
+ ->toEqualCanonicalizing([DelasAction::Rejected, DelasAction::Blocked]);
+});
+
+test('bloquear exige motivo', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $target = User::factory()->create();
+
+ expect(fn () => $this->block->handle($target, $moderator, ' '))
+ ->toThrow(DelasException::class, __('delas::exceptions.reason_required'));
+});
+
+test('não bloqueia quem é da equipe nem a si mesma', function (string $state): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $target = $state === 'self' ? $moderator : User::factory()->{$state}()->create();
+
+ expect(fn () => $this->block->handle($target, $moderator, 'motivo'))
+ ->toThrow(DelasException::class, __('delas::exceptions.cannot_block_team'));
+})->with([
+ 'moderadora' => 'delasModerator',
+ 'líder' => 'delasLead',
+ 'super admin' => 'superAdmin',
+ 'a si mesma' => 'self',
+]);
+
+test('não bloqueia quem já está bloqueada', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $target = User::factory()->create();
+ $this->block->handle($target, $moderator, 'primeiro');
+
+ expect(fn () => $this->block->handle($target, $moderator, 'segundo'))
+ ->toThrow(DelasException::class, __('delas::exceptions.already_blocked'));
+});
+
+test('membra comum não bloqueia', function (): void {
+ $member = User::factory()->create();
+ $target = User::factory()->create();
+
+ expect(fn () => $this->block->handle($target, $member, 'motivo'))
+ ->toThrow(AuthorizationException::class);
+});
+
+// Desbloquear
+
+test('desbloquear exige motivo', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $block = DelasRequesterBlock::factory()->create(['blocked_by' => $moderator->getKey()]);
+
+ expect(fn () => $this->unblock->handle($block, $moderator, ''))
+ ->toThrow(DelasException::class, __('delas::exceptions.reason_required'));
+});
+
+test('moderadora desbloqueia o próprio bloqueio e o histórico registra', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $block = DelasRequesterBlock::factory()->create(['blocked_by' => $moderator->getKey()]);
+
+ $this->unblock->handle($block, $moderator, 'Situação esclarecida.');
+
+ $block->refresh();
+ expect($block->isActive())->toBeFalse();
+ expect($block->lifted_by)->toBe($moderator->getKey());
+ expect($block->lift_reason)->toBe('Situação esclarecida.');
+ expect(DelasTransition::query()->sole()->action)->toBe(DelasAction::Unblocked);
+});
+
+test('moderadora não desbloqueia o bloqueio de outra', function (): void {
+ $block = DelasRequesterBlock::factory()->create();
+ $otherModerator = User::factory()->delasModerator()->create();
+
+ expect(fn () => $this->unblock->handle($block, $otherModerator, 'motivo'))
+ ->toThrow(DelasException::class, __('delas::exceptions.cannot_unblock_others'));
+});
+
+test('líder desbloqueia qualquer bloqueio', function (): void {
+ $block = DelasRequesterBlock::factory()->create();
+ $lead = User::factory()->delasLead()->create();
+
+ $this->unblock->handle($block, $lead, 'motivo');
+
+ expect($block->fresh()->isActive())->toBeFalse();
+});
+
+test('um bloqueio encerrado não é encerrado de novo', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $block = DelasRequesterBlock::factory()->lifted()->create();
+
+ expect(fn () => $this->unblock->handle($block, $lead, 'de novo'))
+ ->toThrow(DelasException::class, __('delas::exceptions.block_already_lifted'));
+});
diff --git a/app-modules/delas/tests/Feature/History/CorrectDelasReasonTest.php b/app-modules/delas/tests/Feature/History/CorrectDelasReasonTest.php
new file mode 100644
index 000000000..eb275f750
--- /dev/null
+++ b/app-modules/delas/tests/Feature/History/CorrectDelasReasonTest.php
@@ -0,0 +1,133 @@
+handle(DelasTagRequest::factory()->pending()->create(), $moderator, $reason);
+
+ return DelasTransition::query()->where('action', DelasAction::Rejected)->latest('created_at')->firstOrFail();
+}
+
+beforeEach(function (): void {
+ $this->correct = resolve(CorrectDelasReason::class);
+});
+
+test('a correção é uma linha nova, de quem corrigiu, ligada à original', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $original = rejectionBy($moderator);
+
+ $correction = $this->correct->handle($original, $moderator, 'Perfil incompleto.');
+
+ expect($correction->action)->toBe(DelasAction::ReasonCorrected);
+ expect($correction->corrects_id)->toBe($original->getKey());
+ expect($correction->actor_id)->toBe($moderator->getKey());
+});
+
+test('depois da correção, a original continua como foi escrita, mas vale o texto novo', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $original = rejectionBy($moderator);
+
+ $this->correct->handle($original, $moderator, 'Perfil incompleto.');
+
+ $original->refresh();
+ expect($original->reason)->toBe('Perfil incompleo.');
+ expect($original->currentReason())->toBe('Perfil incompleto.');
+ expect($original->request->fresh()->decision_reason)->toBe('Perfil incompleto.');
+});
+
+test('vale sempre a correção mais recente', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $original = rejectionBy($moderator);
+
+ $this->correct->handle($original, $moderator, 'Primeira correção.');
+ $this->travel(1)->minutes();
+ $this->correct->handle($original->fresh(), $moderator, 'Segunda correção.');
+
+ expect($original->fresh()->currentReason())->toBe('Segunda correção.');
+ expect(DelasTransition::query()->where('corrects_id', $original->getKey())->count())->toBe(2);
+});
+
+test('corrigir o motivo de um bloqueio atualiza o bloqueio', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $block = resolve(BlockDelasRequester::class)->handle(User::factory()->create(), $moderator, 'Pedidos repetidso.');
+ $original = DelasTransition::query()->where('action', DelasAction::Blocked)->sole();
+
+ $this->correct->handle($original, $moderator, 'Pedidos repetidos.');
+
+ expect($block->fresh()->reason)->toBe('Pedidos repetidos.');
+});
+
+test('quem escreveu não corrige depois do prazo', function (): void {
+ config(['delas.reason_correction_hours' => 24]);
+ $moderator = User::factory()->delasModerator()->create();
+ $original = rejectionBy($moderator);
+
+ $this->travel(25)->hours();
+
+ expect(fn () => $this->correct->handle($original, $moderator, 'Tarde demais.'))
+ ->toThrow(DelasException::class, __('delas::exceptions.cannot_correct_reason', ['hours' => 24]));
+});
+
+test('outra moderadora não corrige o motivo de quem escreveu', function (): void {
+ $original = rejectionBy(User::factory()->delasModerator()->create());
+ $otherModerator = User::factory()->delasModerator()->create();
+
+ expect(fn () => $this->correct->handle($original, $otherModerator, 'Outro texto.'))
+ ->toThrow(DelasException::class);
+});
+
+test('a líder corrige qualquer motivo, a qualquer momento', function (): void {
+ $original = rejectionBy(User::factory()->delasModerator()->create());
+ $lead = User::factory()->delasLead()->create();
+ $this->travel(30)->days();
+
+ $correction = $this->correct->handle($original, $lead, 'Motivo revisado pela liderança.');
+
+ expect($original->fresh()->currentReason())->toBe($correction->reason);
+});
+
+test('recusa motivo vazio', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $original = rejectionBy($moderator, 'Motivo.');
+
+ expect(fn () => $this->correct->handle($original, $moderator, ' '))
+ ->toThrow(DelasException::class, __('delas::exceptions.reason_required'));
+});
+
+test('recusa motivo igual ao atual', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $original = rejectionBy($moderator, 'Motivo.');
+
+ expect(fn () => $this->correct->handle($original, $moderator, 'Motivo.'))
+ ->toThrow(DelasException::class, __('delas::exceptions.reason_unchanged'));
+});
+
+test('recusa corrigir linhas sem motivo', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $approval = DelasTransition::factory()->create([
+ 'action' => DelasAction::Approved,
+ 'actor_id' => $moderator->getKey(),
+ ]);
+
+ expect(fn () => $this->correct->handle($approval, $moderator, 'Qualquer coisa.'))
+ ->toThrow(DelasException::class, __('delas::exceptions.reason_not_correctable'));
+});
+
+test('quem não modera não corrige nada', function (): void {
+ $original = rejectionBy(User::factory()->delasModerator()->create());
+ $member = User::factory()->create();
+
+ expect(fn () => $this->correct->handle($original, $member, 'Texto.'))
+ ->toThrow(AuthorizationException::class);
+});
diff --git a/app-modules/delas/tests/Feature/Schema/DelasSchemaTest.php b/app-modules/delas/tests/Feature/Schema/DelasSchemaTest.php
new file mode 100644
index 000000000..dd4ebf8d2
--- /dev/null
+++ b/app-modules/delas/tests/Feature/Schema/DelasSchemaTest.php
@@ -0,0 +1,67 @@
+create();
+ DelasTagRequest::factory()->for($user)->{$first}()->create();
+
+ expect(fn () => DelasTagRequest::factory()->for($user)->{$second}()->create())
+ ->toThrow(UniqueConstraintViolationException::class);
+})->with([
+ 'pendente + pendente' => ['pending', 'pending'],
+ 'aprovada + pendente' => ['approved', 'pending'],
+]);
+
+test('solicitações encerradas não ocupam o lugar da pessoa', function (): void {
+ $user = User::factory()->create();
+ DelasTagRequest::factory()->for($user)->rejected()->create();
+ DelasTagRequest::factory()->for($user)->revoked()->create();
+
+ $pending = DelasTagRequest::factory()->for($user)->pending()->create();
+
+ $active = DelasTagRequest::query()->where('user_id', $user->getKey())->active()->sole();
+ expect($active->is($pending))->toBeTrue();
+});
+
+test('o banco guarda bloqueios encerrados ao lado do ativo', function (): void {
+ $user = User::factory()->create();
+
+ DelasRequesterBlock::factory()->for($user)->lifted()->create();
+ DelasRequesterBlock::factory()->for($user)->create();
+
+ expect(DelasRequesterBlock::query()->where('user_id', $user->getKey())->count())->toBe(2);
+});
+
+test('o banco recusa dois bloqueios ativos da mesma pessoa', function (): void {
+ $user = User::factory()->create();
+ DelasRequesterBlock::factory()->for($user)->lifted()->create();
+ DelasRequesterBlock::factory()->for($user)->create();
+
+ expect(fn () => DelasRequesterBlock::factory()->for($user)->create())
+ ->toThrow(UniqueConstraintViolationException::class);
+});
+
+test('o histórico guarda enums e só tem data de criação', function (): void {
+ $transition = DelasTransition::factory()->create([
+ 'action' => DelasAction::Approved,
+ 'from_status' => DelasRequestStatus::Pending,
+ 'to_status' => DelasRequestStatus::Approved,
+ ]);
+
+ $stored = $transition->fresh();
+
+ expect($stored->action)->toBe(DelasAction::Approved);
+ expect($stored->from_status)->toBe(DelasRequestStatus::Pending);
+ expect($stored->to_status)->toBe(DelasRequestStatus::Approved);
+ expect($stored->created_at)->not->toBeNull();
+ expect($stored->getAttributes())->not->toHaveKey('updated_at');
+});
diff --git a/app-modules/delas/tests/Feature/TagRequest/DecideDelasRequestTest.php b/app-modules/delas/tests/Feature/TagRequest/DecideDelasRequestTest.php
new file mode 100644
index 000000000..15dfd470f
--- /dev/null
+++ b/app-modules/delas/tests/Feature/TagRequest/DecideDelasRequestTest.php
@@ -0,0 +1,157 @@
+approve = resolve(ApproveDelasRequest::class);
+ $this->reject = resolve(RejectDelasRequest::class);
+ $this->eligibility = resolve(DelasEligibility::class);
+});
+
+// Aprovar
+
+test('moderadora aprova: a solicitação guarda quem decidiu e quando', function (): void {
+ Event::fake([DelasTagApproved::class]);
+ $moderator = User::factory()->delasModerator()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+ $this->freezeSecond();
+
+ $this->approve->handle($request, $moderator);
+
+ $request->refresh();
+ expect($request->status)->toBe(DelasRequestStatus::Approved);
+ expect($request->decided_by)->toBe($moderator->getKey());
+ expect($request->decided_at->toDateTimeString())->toBe(now()->toDateTimeString());
+ Event::assertDispatched(DelasTagApproved::class);
+});
+
+test('aprovada, a pessoa passa a ter a tag', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+
+ $this->approve->handle($request, $moderator);
+
+ expect($this->eligibility->hasTag($request->user))->toBeTrue();
+});
+
+test('aprovar registra no histórico a moderadora e a mudança de situação', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+
+ $this->approve->handle($request, $moderator);
+
+ $transition = DelasTransition::query()->sole();
+ expect($transition->action)->toBe(DelasAction::Approved);
+ expect($transition->triggered_by)->toBe(DelasTriggeredBy::Moderator);
+ expect($transition->from_status)->toBe(DelasRequestStatus::Pending);
+ expect($transition->to_status)->toBe(DelasRequestStatus::Approved);
+});
+
+test('super admin decide sem papel da He4rt Delas e fica registrado como admin', function (): void {
+ $admin = User::factory()->superAdmin()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+
+ $this->approve->handle($request, $admin);
+
+ expect(DelasTransition::query()->sole()->triggered_by)->toBe(DelasTriggeredBy::Admin);
+});
+
+// Rejeitar
+
+test('moderadora rejeita com motivo: a solicitação sai das pendentes e guarda o motivo limpo', function (): void {
+ Event::fake([DelasTagRejected::class]);
+ $moderator = User::factory()->delasModerator()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+
+ $this->reject->handle($request, $moderator, ' Perfil sem informações. ');
+
+ $request->refresh();
+ expect($request->status)->toBe(DelasRequestStatus::Rejected);
+ expect($request->decision_reason)->toBe('Perfil sem informações.');
+ expect(DelasTagRequest::query()->pending()->exists())->toBeFalse();
+ expect(DelasTransition::query()->sole()->reason)->toBe('Perfil sem informações.');
+ Event::assertDispatched(DelasTagRejected::class);
+});
+
+test('rejeitada, a pessoa não tem a tag', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+
+ $this->reject->handle($request, $moderator, 'Perfil sem informações.');
+
+ expect($this->eligibility->hasTag($request->user))->toBeFalse();
+});
+
+test('rejeitar sem motivo é recusado', function (?string $reason): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+
+ expect(fn () => $this->reject->handle($request, $moderator, $reason))
+ ->toThrow(DelasException::class, __('delas::exceptions.reason_required'));
+})->with([null, '', ' ']);
+
+// Quem pode decidir
+
+test('quem não é da equipe não aprova', function (): void {
+ $member = User::factory()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+
+ expect(fn () => $this->approve->handle($request, $member))
+ ->toThrow(AuthorizationException::class);
+
+ expect($request->fresh()->status)->toBe(DelasRequestStatus::Pending);
+});
+
+test('quem não é da equipe não rejeita', function (): void {
+ $member = User::factory()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+
+ expect(fn () => $this->reject->handle($request, $member, 'motivo'))
+ ->toThrow(AuthorizationException::class);
+
+ expect($request->fresh()->status)->toBe(DelasRequestStatus::Pending);
+});
+
+test('moderadora não aprova a própria solicitação', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $ownRequest = DelasTagRequest::factory()->for($moderator)->pending()->create();
+
+ expect(fn () => $this->approve->handle($ownRequest, $moderator))
+ ->toThrow(DelasException::class, __('delas::exceptions.cannot_decide_own'));
+});
+
+test('moderadora não rejeita a própria solicitação', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $ownRequest = DelasTagRequest::factory()->for($moderator)->pending()->create();
+
+ expect(fn () => $this->reject->handle($ownRequest, $moderator, 'motivo'))
+ ->toThrow(DelasException::class, __('delas::exceptions.cannot_decide_own'));
+});
+
+test('uma solicitação já decidida não é decidida de novo', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $otherModerator = User::factory()->delasModerator()->create();
+ $request = DelasTagRequest::factory()->pending()->create();
+ $this->approve->handle($request, $moderator);
+
+ expect(fn () => $this->reject->handle($request, $otherModerator, 'atrasada'))
+ ->toThrow(DelasException::class);
+
+ expect($request->fresh()->status)->toBe(DelasRequestStatus::Approved);
+ expect(DelasTransition::query()->count())->toBe(1);
+});
diff --git a/app-modules/delas/tests/Feature/TagRequest/GrantAndRevokeDelasTagTest.php b/app-modules/delas/tests/Feature/TagRequest/GrantAndRevokeDelasTagTest.php
new file mode 100644
index 000000000..8cd9d0e2f
--- /dev/null
+++ b/app-modules/delas/tests/Feature/TagRequest/GrantAndRevokeDelasTagTest.php
@@ -0,0 +1,203 @@
+grant = resolve(GrantDelasTag::class);
+ $this->revoke = resolve(RevokeDelasTag::class);
+ $this->eligibility = resolve(DelasEligibility::class);
+});
+
+// Conceder
+
+test('líder concede a quem não tem solicitação: cria uma já aprovada', function (): void {
+ Event::fake([DelasTagGranted::class]);
+ $lead = User::factory()->delasLead()->create();
+ $target = User::factory()->create();
+
+ $request = $this->grant->handle($target, $lead);
+
+ $transition = DelasTransition::query()->sole();
+ expect($request->status)->toBe(DelasRequestStatus::Approved);
+ expect(DelasTagRequest::query()->count())->toBe(1);
+ expect($transition->action)->toBe(DelasAction::Granted);
+ expect($transition->triggered_by)->toBe(DelasTriggeredBy::Lead);
+ Event::assertDispatched(DelasTagGranted::class);
+});
+
+test('conceder com solicitação pendente aprova essa solicitação', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $pending = DelasTagRequest::factory()->pending()->create();
+
+ $request = $this->grant->handle($pending->user, $lead);
+
+ expect($request->is($pending))->toBeTrue();
+ expect($pending->fresh()->status)->toBe(DelasRequestStatus::Approved);
+ expect(DelasTagRequest::query()->count())->toBe(1);
+});
+
+test('conceder ignora a espera', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $rejected = DelasTagRequest::factory()->rejected()->create();
+
+ $this->grant->handle($rejected->user, $lead);
+
+ expect($this->eligibility->hasTag($rejected->user))->toBeTrue();
+});
+
+test('conceder a quem está bloqueada exige motivo', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $block = DelasRequesterBlock::factory()->create();
+
+ expect(fn () => $this->grant->handle($block->user, $lead))
+ ->toThrow(DelasException::class, __('delas::exceptions.reason_required'));
+});
+
+test('conceder a quem está bloqueada, com motivo, encerra o bloqueio', function (): void {
+ Event::fake([DelasTagGranted::class, DelasRequesterUnblocked::class]);
+ $lead = User::factory()->delasLead()->create();
+ $block = DelasRequesterBlock::factory()->create();
+
+ $this->grant->handle($block->user, $lead, 'Esclarecido com o comitê.');
+
+ $block->refresh();
+ expect($block->isActive())->toBeFalse();
+ expect($block->lift_reason)->toBe('Esclarecido com o comitê.');
+ expect(DelasTransition::query()->pluck('action')->all())
+ ->toEqualCanonicalizing([DelasAction::Unblocked, DelasAction::Granted]);
+ Event::assertDispatched(DelasRequesterUnblocked::class);
+ Event::assertDispatched(DelasTagGranted::class);
+});
+
+test('não concede a quem já tem a tag', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $approved = DelasTagRequest::factory()->approved()->create();
+
+ expect(fn () => $this->grant->handle($approved->user, $lead))
+ ->toThrow(DelasException::class, __('delas::exceptions.already_has_tag'));
+});
+
+test('líder não concede a tag a si mesma', function (): void {
+ $lead = User::factory()->delasLead()->create();
+
+ expect(fn () => $this->grant->handle($lead, $lead))
+ ->toThrow(DelasException::class, __('delas::exceptions.cannot_decide_own'));
+});
+
+test('moderadora não concede a tag direto', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $target = User::factory()->create();
+
+ expect(fn () => $this->grant->handle($target, $moderator))
+ ->toThrow(AuthorizationException::class);
+});
+
+// Remover
+
+test('moderadora não remove a tag direto', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $approved = DelasTagRequest::factory()->approved()->create();
+
+ expect(fn () => $this->revoke->handle($approved->user, $moderator, 'motivo'))
+ ->toThrow(AuthorizationException::class);
+});
+
+test('remover a tag exige motivo', function (): void {
+ $admin = User::factory()->superAdmin()->create();
+ $approved = DelasTagRequest::factory()->approved()->create();
+
+ expect(fn () => $this->revoke->handle($approved->user, $admin, reason: null))
+ ->toThrow(DelasException::class, __('delas::exceptions.reason_required'));
+});
+
+test('remover a tag não apaga o registro e abre a espera', function (): void {
+ Event::fake([DelasTagRevoked::class]);
+ $admin = User::factory()->superAdmin()->create();
+ $approved = DelasTagRequest::factory()->approved()->create();
+
+ $this->revoke->handle($approved->user, $admin, 'A pessoa pediu a remoção.');
+
+ expect($approved->fresh()->status)->toBe(DelasRequestStatus::Revoked);
+ expect($this->eligibility->for($approved->user)->state)->toBe(DelasEligibilityState::Cooldown);
+ expect(DelasTransition::query()->sole()->triggered_by)->toBe(DelasTriggeredBy::Admin);
+ Event::assertDispatched(DelasTagRevoked::class);
+});
+
+test('não remove de quem não tem a tag', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $withoutTag = User::factory()->create();
+
+ expect(fn () => $this->revoke->handle($withoutTag, $lead, 'motivo'))
+ ->toThrow(DelasException::class, __('delas::exceptions.has_no_tag'));
+});
+
+// Remover e bloquear
+
+test('remover a tag e bloquear acontecem juntos, com o mesmo motivo', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $approved = DelasTagRequest::factory()->approved()->create();
+
+ $this->revoke->handle($approved->user, $lead, 'Conta criada só para conseguir a tag.', alsoBlock: true);
+
+ $block = DelasRequesterBlock::query()->active()->where('user_id', $approved->user_id)->sole();
+ expect($approved->fresh()->status)->toBe(DelasRequestStatus::Revoked);
+ expect($block->reason)->toBe('Conta criada só para conseguir a tag.');
+ expect($block->blocked_by)->toBe($lead->getKey());
+ expect($this->eligibility->for($approved->user)->state)->toBe(DelasEligibilityState::Blocked);
+ expect(DelasTransition::query()->pluck('action')->all())
+ ->toEqualCanonicalizing([DelasAction::Revoked, DelasAction::Blocked]);
+});
+
+test('quem já está bloqueada só perde a tag, sem segundo bloqueio', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $approved = DelasTagRequest::factory()->approved()->create();
+ DelasRequesterBlock::factory()->for($approved->user)->create();
+
+ $this->revoke->handle($approved->user, $lead, 'Motivo.', alsoBlock: true);
+
+ expect(DelasRequesterBlock::query()->where('user_id', $approved->user_id)->count())->toBe(1);
+ expect($approved->fresh()->status)->toBe(DelasRequestStatus::Revoked);
+});
+
+// Quem é da equipe não perde a tag
+
+test('não remove a tag de quem é da equipe', function (string $role): void {
+ $lead = User::factory()->delasLead()->create();
+ $teamMember = User::factory()->{$role}()->create();
+ $approved = DelasTagRequest::factory()->for($teamMember)->approved()->create();
+
+ expect(fn () => $this->revoke->handle($teamMember, $lead, 'Motivo.'))
+ ->toThrow(DelasException::class, __('delas::exceptions.team_member_keeps_tag'));
+
+ expect($approved->fresh()->status)->toBe(DelasRequestStatus::Approved);
+})->with(['moderadora' => 'delasModerator', 'líder' => 'delasLead', 'super admin' => 'superAdmin']);
+
+test('depois de sair da moderação, a pessoa pode perder a tag', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $moderator = User::factory()->delasModerator()->create();
+ $approved = DelasTagRequest::factory()->for($moderator)->approved()->create();
+
+ resolve(RemoveDelasModerator::class)->handle($moderator, $lead);
+ $this->revoke->handle($moderator->fresh(), $lead, 'Saiu da He4rt Delas.');
+
+ expect($approved->fresh()->status)->toBe(DelasRequestStatus::Revoked);
+});
diff --git a/app-modules/delas/tests/Feature/TagRequest/RequestDelasTagTest.php b/app-modules/delas/tests/Feature/TagRequest/RequestDelasTagTest.php
new file mode 100644
index 000000000..decf7068e
--- /dev/null
+++ b/app-modules/delas/tests/Feature/TagRequest/RequestDelasTagTest.php
@@ -0,0 +1,144 @@
+requestTag = resolve(RequestDelasTag::class);
+ $this->eligibility = resolve(DelasEligibility::class);
+});
+
+// Pedir
+
+test('registra a solicitação como pendente e avisa', function (): void {
+ Event::fake([DelasTagRequested::class]);
+ $user = User::factory()->withDiscord()->create();
+
+ $request = $this->requestTag->handle($user);
+
+ expect($request->status)->toBe(DelasRequestStatus::Pending);
+ expect($this->eligibility->for($user)->state)->toBe(DelasEligibilityState::Pending);
+ Event::assertDispatched(fn (DelasTagRequested $event): bool => $event->requestId === $request->getKey());
+});
+
+test('o pedido fica no histórico como ação da própria pessoa', function (): void {
+ $user = User::factory()->withDiscord()->create();
+
+ $this->requestTag->handle($user);
+
+ $transition = DelasTransition::query()->sole();
+ expect($transition->action)->toBe(DelasAction::Requested);
+ expect($transition->triggered_by)->toBe(DelasTriggeredBy::User);
+ expect($transition->actor_id)->toBe($user->getKey());
+});
+
+test('recusa quem já tem uma solicitação pendente ou aprovada', function (string $state): void {
+ $user = User::factory()->create();
+ DelasTagRequest::factory()->for($user)->{$state}()->create();
+
+ expect(fn () => $this->requestTag->handle($user))
+ ->toThrow(DelasException::class, __('delas::exceptions.already_has_active_request'));
+})->with(['pending', 'approved']);
+
+test('recusa quem está bloqueada', function (): void {
+ $user = User::factory()->create();
+ DelasRequesterBlock::factory()->for($user)->create();
+
+ expect(fn () => $this->requestTag->handle($user))
+ ->toThrow(DelasException::class, __('delas::exceptions.blocked'));
+});
+
+test('quem tem a tag continua com ela mesmo bloqueada', function (): void {
+ $user = User::factory()->create();
+ DelasTagRequest::factory()->for($user)->approved()->create();
+ DelasRequesterBlock::factory()->for($user)->create();
+
+ expect($this->eligibility->for($user)->hasTag())->toBeTrue();
+});
+
+// Espera depois de rejeição ou remoção
+
+test('recusa o pedido antes de completar 15 dias da rejeição ou remoção', function (string $state): void {
+ $this->travelTo(today());
+ $user = User::factory()->withDiscord()->create();
+ DelasTagRequest::factory()->for($user)->{$state}()->create(['decided_at' => now()]);
+
+ $this->travelTo(now()->addDays(15)->subMinute());
+
+ expect(fn () => $this->requestTag->handle($user))->toThrow(DelasException::class);
+})->with(['rejected', 'revoked']);
+
+test('aceita o pedido passados 15 dias da rejeição ou remoção', function (string $state): void {
+ $this->travelTo(today());
+ $user = User::factory()->withDiscord()->create();
+ DelasTagRequest::factory()->for($user)->{$state}()->create(['decided_at' => now()]);
+
+ $this->travelTo(now()->addDays(15)->addMinute());
+
+ expect($this->requestTag->handle($user)->status)->toBe(DelasRequestStatus::Pending);
+})->with(['rejected', 'revoked']);
+
+test('a espera vem da config', function (): void {
+ config(['delas.request_cooldown_days' => 3]);
+ $user = User::factory()->withDiscord()->create();
+ DelasTagRequest::factory()->for($user)->rejected()->create(['decided_at' => now()->subDays(4)]);
+
+ expect($this->eligibility->for($user)->canRequest())->toBeTrue();
+});
+
+// Discord
+
+test('sem o Discord conectado, a pessoa aparece como precisando conectar', function (): void {
+ $user = User::factory()->create();
+
+ expect($this->eligibility->for($user)->state)->toBe(DelasEligibilityState::DiscordRequired);
+});
+
+test('sem o Discord conectado, não dá para pedir', function (): void {
+ $user = User::factory()->create();
+
+ expect(fn () => $this->requestTag->handle($user))
+ ->toThrow(DelasException::class, __('delas::exceptions.discord_required'));
+});
+
+test('um Discord desconectado não conta', function (): void {
+ $user = User::factory()->withDiscord()->create();
+
+ $user->providers()->update(['disconnected_at' => now()]);
+
+ expect($this->eligibility->for($user)->state)->toBe(DelasEligibilityState::DiscordRequired);
+});
+
+test('a exigência do Discord vem da config', function (): void {
+ config(['delas.require_discord' => false]);
+ $userWithoutDiscord = User::factory()->create();
+
+ expect($this->eligibility->for($userWithoutDiscord)->canRequest())->toBeTrue();
+});
+
+test('o bloqueio aparece antes de faltar o Discord', function (): void {
+ $blocked = User::factory()->create();
+ DelasRequesterBlock::factory()->for($blocked)->create();
+
+ expect($this->eligibility->for($blocked)->state)->toBe(DelasEligibilityState::Blocked);
+});
+
+test('a espera aparece antes de faltar o Discord', function (): void {
+ $waiting = User::factory()->create();
+ DelasTagRequest::factory()->for($waiting)->rejected()->create(['decided_at' => now()]);
+
+ expect($this->eligibility->for($waiting)->state)->toBe(DelasEligibilityState::Cooldown);
+});
diff --git a/app-modules/delas/tests/Feature/Team/DelasCandidatesTest.php b/app-modules/delas/tests/Feature/Team/DelasCandidatesTest.php
new file mode 100644
index 000000000..4101cb092
--- /dev/null
+++ b/app-modules/delas/tests/Feature/Team/DelasCandidatesTest.php
@@ -0,0 +1,131 @@
+candidates = resolve(DelasCandidates::class);
+ $this->lead = User::factory()->delasLead()->create();
+});
+
+/**
+ * Ids que a busca do seletor de conceder devolve para a líder.
+ *
+ * @return list
+ */
+function delasGrantSearchIds(DelasCandidates $candidates, User $lead, string $term): array
+{
+ return $candidates->search($candidates->forGrant($lead), $term)->pluck('id')->all();
+}
+
+// Escopo de cada seletor
+
+test('conceder: aparece quem não tem a tag, inclusive com pedido pendente ou rejeitado', function (): void {
+ $withoutRequest = User::factory()->create();
+ $pending = DelasTagRequest::factory()->pending()->create()->user;
+ $rejected = DelasTagRequest::factory()->rejected()->create()->user;
+ $member = DelasTagRequest::factory()->approved()->create()->user;
+
+ $ids = $this->candidates->forGrant($this->lead)->pluck('id')->all();
+
+ expect($ids)->toContain($withoutRequest->id, $pending->id, $rejected->id)->not->toContain($member->id);
+});
+
+test('remover: só aparece quem tem a tag', function (): void {
+ $member = DelasTagRequest::factory()->approved()->create()->user;
+ DelasTagRequest::factory()->revoked()->create();
+ DelasTagRequest::factory()->pending()->create();
+ User::factory()->create();
+
+ $ids = $this->candidates->forRevoke($this->lead)->pluck('id')->all();
+
+ expect($ids)->toBe([$member->id]);
+});
+
+test('adicionar moderadora: só quem tem a tag, fora super admin, moderadora ou líder', function (): void {
+ $member = User::factory()->create();
+ $streamer = User::factory()->streamer()->create();
+ $withoutTag = User::factory()->create();
+ $superAdmin = User::factory()->superAdmin()->create();
+ $moderator = User::factory()->delasModerator()->create();
+ $otherLead = User::factory()->delasLead()->create();
+ foreach ([$member, $streamer, $superAdmin, $moderator, $otherLead] as $user) {
+ DelasTagRequest::factory()->for($user)->approved()->create(['decided_by' => $this->lead->getKey()]);
+ }
+
+ $ids = $this->candidates->forModerator($this->lead)->pluck('id')->all();
+
+ expect($ids)->toContain($member->id, $streamer->id)->not->toContain($withoutTag->id, $superAdmin->id, $moderator->id, $otherLead->id);
+});
+
+test('quem age nunca aparece no próprio seletor', function (string $scope, string $actorKind): void {
+ // A líder tem a tag, então só não aparece em remover/adicionar por ser quem age.
+ DelasTagRequest::factory()->for($this->lead)->approved()->create();
+ $actor = $actorKind === 'superAdmin' ? User::factory()->superAdmin()->create() : $this->lead;
+
+ $people = $this->candidates->{$scope}($actor)->pluck('id');
+
+ expect($people)->not->toContain($actor->id);
+})->with([
+ 'conceder, como super admin' => ['forGrant', 'superAdmin'],
+ 'conceder, como líder' => ['forGrant', 'lead'],
+ 'remover, como líder' => ['forRevoke', 'lead'],
+ 'adicionar moderadora, como líder' => ['forModerator', 'lead'],
+]);
+
+// Busca
+
+describe('busca por nome ou @username, dentro do escopo', function (): void {
+ beforeEach(function (): void {
+ $this->ana = User::factory()->create(['name' => 'Ana Souza', 'username' => 'anasouza']);
+ $this->bia = User::factory()->create(['name' => 'Beatriz Lima', 'username' => 'bialima']);
+ $member = User::factory()->create(['name' => 'Ana Membra', 'username' => 'anamembra']);
+ // Decisora fixa: um nome aleatório da factory (ex.: "Mariana") também casaria com "ana".
+ DelasTagRequest::factory()->for($member)->approved()->create(['decided_by' => $this->lead->getKey()]);
+ });
+
+ test('acha pelo nome, sem quem já tem a tag', function (): void {
+ $ids = delasGrantSearchIds($this->candidates, $this->lead, 'ana');
+
+ expect($ids)->toBe([$this->ana->id]);
+ });
+
+ test('acha pelo @username', function (): void {
+ $ids = delasGrantSearchIds($this->candidates, $this->lead, '@bialima');
+
+ expect($ids)->toBe([$this->bia->id]);
+ });
+});
+
+test('a busca respeita o limite', function (): void {
+ User::factory()->count(3)->create(['name' => 'Carla']);
+
+ $results = $this->candidates->search($this->candidates->forGrant($this->lead), 'carla', limit: 2);
+
+ expect($results)->toHaveCount(2);
+});
+
+test('a busca ignora acento e maiúscula', function (string $term): void {
+ $thais = User::factory()->create(['name' => 'Thaís Barbosa', 'username' => 'thaisb']);
+
+ $ids = delasGrantSearchIds($this->candidates, $this->lead, $term);
+
+ expect($ids)->toContain($thais->id);
+})->with(['thais', 'THAÍS']);
+
+test('remover: quem é da equipe não aparece, mesmo com a tag', function (): void {
+ $member = DelasTagRequest::factory()->approved()->create(['decided_by' => $this->lead->getKey()])->user;
+ $moderator = User::factory()->delasModerator()->create();
+ $otherLead = User::factory()->delasLead()->create();
+ $superAdmin = User::factory()->superAdmin()->create();
+ foreach ([$moderator, $otherLead, $superAdmin] as $teamMember) {
+ DelasTagRequest::factory()->for($teamMember)->approved()->create(['decided_by' => $this->lead->getKey()]);
+ }
+
+ $ids = $this->candidates->forRevoke($this->lead)->pluck('id')->all();
+
+ expect($ids)->toContain($member->id)->not->toContain($moderator->id, $otherLead->id, $superAdmin->id);
+});
diff --git a/app-modules/delas/tests/Feature/Team/ManageDelasModeratorsTest.php b/app-modules/delas/tests/Feature/Team/ManageDelasModeratorsTest.php
new file mode 100644
index 000000000..055ca66da
--- /dev/null
+++ b/app-modules/delas/tests/Feature/Team/ManageDelasModeratorsTest.php
@@ -0,0 +1,103 @@
+addModerator = resolve(AddDelasModerator::class);
+ $this->removeModerator = resolve(RemoveDelasModerator::class);
+});
+
+// Adicionar
+
+test('líder adiciona moderadora e a ação vai para o histórico', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $target = DelasTagRequest::factory()->approved()->create(['decided_by' => $lead->getKey()])->user;
+
+ $this->addModerator->handle($target, $lead);
+
+ expect($target->fresh()->can('moderate-delas'))->toBeTrue();
+ expect(DelasTransition::query()->pluck('action')->all())->toBe([DelasAction::ModeratorAdded]);
+});
+
+test('só quem tem a tag vira moderadora', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $withoutTag = User::factory()->create();
+
+ expect(fn () => $this->addModerator->handle($withoutTag, $lead))
+ ->toThrow(DelasException::class, __('delas::exceptions.moderator_needs_tag'));
+
+ expect($withoutTag->fresh()->hasRole(UserRole::DelasModerator))->toBeFalse();
+});
+
+test('não adiciona quem já é moderadora', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $moderator = User::factory()->delasModerator()->create();
+
+ expect(fn () => $this->addModerator->handle($moderator, $lead))
+ ->toThrow(DelasException::class, __('delas::exceptions.already_moderator'));
+});
+
+test('moderadora não gerencia a equipe', function (): void {
+ $moderator = User::factory()->delasModerator()->create();
+ $target = User::factory()->create();
+
+ expect(fn () => $this->addModerator->handle($target, $moderator))
+ ->toThrow(AuthorizationException::class);
+});
+
+test('líder não transforma líder nem super admin em moderadora', function (string $state): void {
+ $lead = User::factory()->delasLead()->create();
+ $target = User::factory()->{$state}()->create();
+
+ expect(fn () => $this->addModerator->handle($target, $lead))
+ ->toThrow(DelasException::class, __('delas::exceptions.cannot_manage_role'));
+})->with(['delasLead', 'superAdmin']);
+
+// Remover
+
+test('líder remove moderadora e a ação vai para o histórico', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $moderator = User::factory()->delasModerator()->create();
+ DelasTagRequest::factory()->for($moderator)->approved()->create(['decided_by' => $lead->getKey()]);
+
+ $this->removeModerator->handle($moderator, $lead);
+
+ expect($moderator->fresh()->can('moderate-delas'))->toBeFalse();
+ expect(DelasTransition::query()->pluck('action')->all())->toBe([DelasAction::ModeratorRemoved]);
+});
+
+test('não remove quem não é moderadora', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $member = User::factory()->create();
+
+ expect(fn () => $this->removeModerator->handle($member, $lead))
+ ->toThrow(DelasException::class, __('delas::exceptions.not_moderator'));
+});
+
+test('líder não remove líder nem super admin', function (string $state): void {
+ $lead = User::factory()->delasLead()->create();
+ $target = User::factory()->{$state}()->create();
+
+ expect(fn () => $this->removeModerator->handle($target, $lead))
+ ->toThrow(DelasException::class, __('delas::exceptions.cannot_manage_role'));
+})->with(['delasLead', 'superAdmin']);
+
+test('a moderadora removida mantém as decisões no histórico', function (): void {
+ $lead = User::factory()->delasLead()->create();
+ $moderator = User::factory()->delasModerator()->create();
+
+ $this->removeModerator->handle($moderator, $lead);
+
+ expect($moderator->fresh()->hasRole(UserRole::DelasModerator))->toBeFalse();
+ expect(DelasTransition::query()->where('user_id', $moderator->getKey())->exists())->toBeTrue();
+});
diff --git a/app-modules/delas/tests/Unit/DelasRequestStatusTest.php b/app-modules/delas/tests/Unit/DelasRequestStatusTest.php
new file mode 100644
index 000000000..4ad07e43c
--- /dev/null
+++ b/app-modules/delas/tests/Unit/DelasRequestStatusTest.php
@@ -0,0 +1,33 @@
+canTransitionTo($target))->toBe($allowed);
+})->with([
+ [DelasRequestStatus::Approved, true],
+ [DelasRequestStatus::Rejected, true],
+ [DelasRequestStatus::Revoked, false],
+ [DelasRequestStatus::Pending, false],
+]);
+
+test('aprovada só vira removida', function (DelasRequestStatus $target, bool $allowed): void {
+ expect(DelasRequestStatus::Approved->canTransitionTo($target))->toBe($allowed);
+})->with([
+ [DelasRequestStatus::Revoked, true],
+ [DelasRequestStatus::Pending, false],
+ [DelasRequestStatus::Rejected, false],
+ [DelasRequestStatus::Approved, false],
+]);
+
+test('rejeitada e removida são finais', function (DelasRequestStatus $from): void {
+ foreach (DelasRequestStatus::cases() as $target) {
+ expect($from->canTransitionTo($target))->toBeFalse();
+ }
+})->with([DelasRequestStatus::Rejected, DelasRequestStatus::Revoked]);
+
+test('só pendente e aprovada ocupam o lugar da pessoa', function (): void {
+ expect(DelasRequestStatus::activeValues())->toBe(['pending', 'approved']);
+});
diff --git a/app-modules/he4rt/resources/svg/delas.svg b/app-modules/he4rt/resources/svg/delas.svg
new file mode 100644
index 000000000..f27b8914c
--- /dev/null
+++ b/app-modules/he4rt/resources/svg/delas.svg
@@ -0,0 +1,4 @@
+
diff --git a/app-modules/he4rt/resources/views/components/delas/logo.blade.php b/app-modules/he4rt/resources/views/components/delas/logo.blade.php
new file mode 100644
index 000000000..1c7007760
--- /dev/null
+++ b/app-modules/he4rt/resources/views/components/delas/logo.blade.php
@@ -0,0 +1,33 @@
+@props(['variant' => 'icon', 'label' => null])
+
+{{-- Logo oficial da He4rt Delas. A cor vem de `currentColor`: use `text-delas-500` (ou branco sobre fundo rosa). --}}
+@php
+ $viewBox = match ($variant) {
+ 'horizontal' => '0 0 249 63',
+ 'vertical' => '0 0 181 63',
+ default => '0 0 66 58',
+ };
+@endphp
+
+
diff --git a/app-modules/he4rt/resources/views/components/delas/tag.blade.php b/app-modules/he4rt/resources/views/components/delas/tag.blade.php
new file mode 100644
index 000000000..2b82071b3
--- /dev/null
+++ b/app-modules/he4rt/resources/views/components/delas/tag.blade.php
@@ -0,0 +1,15 @@
+@props(['size' => 'sm'])
+
+{{-- Tag He4rt Delas: rosa claro com texto e ícone no tom 900 (contraste 4,81:1). --}}
+class([
+ 'bg-delas-primary text-delas-900 inline-flex items-center gap-1 rounded-full font-bold shadow-sm',
+ 'px-3 py-1 text-sm' => $size === 'lg',
+ 'px-2.5 py-0.5 text-xs' => $size !== 'lg',
+ ])
+ }}
+>
+ $size === 'lg', 'h-3' => $size !== 'lg']) />
+ He4rt Delas
+
diff --git a/app-modules/he4rt/src/He4rtServiceProvider.php b/app-modules/he4rt/src/He4rtServiceProvider.php
index c44e2fb0e..04b23a423 100644
--- a/app-modules/he4rt/src/He4rtServiceProvider.php
+++ b/app-modules/he4rt/src/He4rtServiceProvider.php
@@ -4,11 +4,18 @@
namespace He4rt\Core;
+use BladeUI\Icons\Factory as IconFactory;
use Illuminate\Support\ServiceProvider;
class He4rtServiceProvider extends ServiceProvider
{
- public function register(): void {}
+ public function register(): void
+ {
+ // Ícones de marca como set `he4rt` (ex.: `he4rt-delas`, com a cor da marca no próprio SVG).
+ $this->callAfterResolving(IconFactory::class, function (IconFactory $factory): void {
+ $factory->add('he4rt', ['path' => __DIR__.'/../resources/svg', 'prefix' => 'he4rt']);
+ });
+ }
public function boot(): void
{
diff --git a/app-modules/identity/database/factories/UserFactory.php b/app-modules/identity/database/factories/UserFactory.php
index f316e3a14..2fefa8315 100644
--- a/app-modules/identity/database/factories/UserFactory.php
+++ b/app-modules/identity/database/factories/UserFactory.php
@@ -5,6 +5,8 @@
namespace He4rt\Identity\Database\Factories;
use He4rt\Identity\Authorization\Enums\UserRole;
+use He4rt\Identity\ExternalIdentity\Enums\IdentityProvider;
+use He4rt\Identity\ExternalIdentity\Models\ExternalIdentity;
use He4rt\Identity\User\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Facades\Hash;
@@ -46,4 +48,37 @@ public function streamer(): static
$user->assignRole(UserRole::Streamer);
});
}
+
+ public function delasModerator(): static
+ {
+ return $this->afterCreating(function (User $user): void {
+ Role::findOrCreate(UserRole::DelasModerator->value, UserRole::GUARD);
+
+ $user->assignRole(UserRole::DelasModerator);
+ });
+ }
+
+ /**
+ * Conta do Discord conectada pela própria pessoa.
+ */
+ public function withDiscord(): static
+ {
+ return $this->afterCreating(function (User $user): void {
+ ExternalIdentity::factory()->create([
+ 'model_type' => $user->getMorphClass(),
+ 'model_id' => $user->getKey(),
+ 'provider' => IdentityProvider::Discord,
+ 'connected_by' => $user->getKey(),
+ ]);
+ });
+ }
+
+ public function delasLead(): static
+ {
+ return $this->afterCreating(function (User $user): void {
+ Role::findOrCreate(UserRole::DelasLead->value, UserRole::GUARD);
+
+ $user->assignRole(UserRole::DelasLead);
+ });
+ }
}
diff --git a/app-modules/identity/database/migrations/2026_10_07_004125_create_delas_roles.php b/app-modules/identity/database/migrations/2026_10_07_004125_create_delas_roles.php
new file mode 100644
index 000000000..14243ab4e
--- /dev/null
+++ b/app-modules/identity/database/migrations/2026_10_07_004125_create_delas_roles.php
@@ -0,0 +1,33 @@
+ */
+ private const array ROLES = [UserRole::DelasModerator, UserRole::DelasLead];
+
+ public function up(): void
+ {
+ foreach (self::ROLES as $role) {
+ Role::findOrCreate($role->value, UserRole::GUARD);
+ }
+
+ resolve(PermissionRegistrar::class)->forgetCachedPermissions();
+ }
+
+ public function down(): void
+ {
+ Role::query()
+ ->whereIn('name', array_map(fn (UserRole $role): string => $role->value, self::ROLES))
+ ->where('guard_name', UserRole::GUARD)
+ ->delete();
+
+ resolve(PermissionRegistrar::class)->forgetCachedPermissions();
+ }
+};
diff --git a/app-modules/identity/docs/adr/0003-acesso-ao-admin-por-papel-de-moderacao.md b/app-modules/identity/docs/adr/0003-acesso-ao-admin-por-papel-de-moderacao.md
new file mode 100644
index 000000000..e705313bd
--- /dev/null
+++ b/app-modules/identity/docs/adr/0003-acesso-ao-admin-por-papel-de-moderacao.md
@@ -0,0 +1,70 @@
+---
+type: adr
+title: 'Acesso ao /admin por papel de moderação'
+module: identity
+status: accepted
+date: 2026-10-07
+author: damacosta
+related:
+ adr: identity/0002-super-admin-via-spatie-permission
+---
+
+# ADR-0003: Acesso ao /admin por papel de moderação
+
+Substitui a regra "o painel inteiro é super admin ou nada" da
+[ADR-0002](0002-super-admin-via-spatie-permission.md). O resto da ADR-0002 continua valendo.
+
+## Contexto
+
+A ADR-0002 foi escrita na fase 1, quando o único papel era `super-admin`. Por isso ela diz que o
+`/admin` é "super admin ou nada".
+
+Com a He4rt Delas surgiram papéis que moderam alguma coisa (`delas-moderator` e `delas-lead`).
+Moderação na He4rt mora no `/admin`, no cluster de Moderação (`/admin/mod`). Manter a moderação
+da He4rt Delas no `/app` só para não abrir o `/admin` criaria dois lugares de moderação.
+
+Abrir a porta do `/admin` tem duas armadilhas:
+
+- no Filament, um Resource sem policy e uma Page sem `canAccess()` liberam acesso para qualquer
+ pessoa que entrou no painel. Nenhum Resource, Page ou Cluster do `panel-admin` tinha
+ `canAccess()`;
+- o `PanelAdminServiceProvider::buildNavigation()` monta a sidebar com `getNavigationItems()`,
+ que não checa `canAccess()`. O item aparecia na sidebar e dava 403 no clique.
+
+## Decisão
+
+- **Cada papel diz se entra no `/admin`**, em `UserRole::grantsAdminAccess()`, com `match` sem
+ `default`: um papel novo sem essa decisão quebra no PHPStan antes de quebrar em produção.
+ `UserRole::withAdminAccess()` lista os papéis que entram.
+ - `super-admin`, `delas-moderator` e `delas-lead`: entram.
+ - `streamer`: não entra.
+- **`User::canAccessPanel('admin')`** em produção passa a ser
+ `$this->hasAnyRole(UserRole::withAdminAccess())`. Fora de produção a porta continua aberta,
+ como na ADR-0002.
+- **Entrar no painel não dá acesso a nada por si só.** Cada Resource, Page e Cluster decide no
+ `canAccess()`, e isso vale em **todo ambiente**:
+ - o trait `He4rt\PanelAdmin\Concerns\SuperAdminOnly` vai em todo Resource, Page e Cluster
+ do `panel-admin` que não é de um papel de moderação;
+ - as páginas de moderação de um papel checam o gate do módulo dono (ex.: `moderate-delas` e
+ `lead-delas`, definidos no `delas`);
+ - o `ModerationCluster` fica sem o trait, porque é dividido entre papéis. A subnavegação do
+ cluster já filtra por `canAccess()`;
+ - o Dashboard continua acessível como página de entrada, mas os widgets dele são só para
+ super admin (`canView()`).
+- **A sidebar respeita o `canAccess()`.** O `buildNavigation()` monta os itens com um helper
+ `itemsFor()`, que só devolve os itens de quem passa no `canAccess()` (clusters, no
+ `canAccessClusteredComponents()`).
+- **Um teste de varredura** garante que uma moderadora da He4rt Delas só acessa o Dashboard e as
+ páginas da He4rt Delas. Resource ou Page novo sem o trait quebra esse teste.
+
+## Consequências
+
+- Papel novo em `UserRole` precisa decidir se entra no `/admin`, ou o PHPStan acusa o `match`.
+- Todo Resource, Page ou Cluster novo no `panel-admin` precisa do `SuperAdminOnly` ou de um
+ `canAccess()` próprio. O teste de varredura cobra isso.
+- Fora de produção, quem não é super admin entra no `/admin` mas só vê o Dashboard (sem
+ widgets). Para ver o resto localmente: `php artisan identity:grant-super-admin {username}`.
+- A seção Papéis do `UserForm` continua visível só para super admin, por causa da porta aberta
+ fora de produção.
+- `Gate::before` continua liberando tudo para super admin, então as páginas de um papel de
+ moderação também abrem para super admin.
diff --git a/app-modules/identity/src/Authorization/Enums/UserRole.php b/app-modules/identity/src/Authorization/Enums/UserRole.php
index 06c22d4b7..6f8d86988 100644
--- a/app-modules/identity/src/Authorization/Enums/UserRole.php
+++ b/app-modules/identity/src/Authorization/Enums/UserRole.php
@@ -25,14 +25,41 @@ enum UserRole: string implements HasColor, HasDescription, HasIcon, HasLabel
case SuperAdmin = 'super-admin';
case Streamer = 'streamer';
+ case DelasModerator = 'delas-moderator';
+ case DelasLead = 'delas-lead';
public const string GUARD = 'web';
+ /**
+ * @return list
+ */
+ public static function withAdminAccess(): array
+ {
+ return array_values(array_filter(self::cases(), fn (self $role): bool => $role->grantsAdminAccess()));
+ }
+
+ /**
+ * Papéis que entram no `/admin` (ADR-0003). Entrar não libera nada por si só:
+ * cada Resource, Page e Cluster decide no próprio `canAccess()`.
+ *
+ * O `match` não tem `default` de propósito: papel novo sem essa decisão
+ * quebra no PHPStan antes de quebrar em produção.
+ */
+ public function grantsAdminAccess(): bool
+ {
+ return match ($this) {
+ self::SuperAdmin, self::DelasModerator, self::DelasLead => true,
+ self::Streamer => false,
+ };
+ }
+
public function getLabel(): string
{
return match ($this) {
self::SuperAdmin => 'Super admin',
self::Streamer => 'Streamer',
+ self::DelasModerator => 'Moderadora He4rt Delas',
+ self::DelasLead => 'Líder He4rt Delas',
};
}
@@ -44,6 +71,8 @@ public function getColor(): array
return match ($this) {
self::SuperAdmin => Color::Red,
self::Streamer => Color::Purple,
+ self::DelasModerator => Color::hex('#F485A2'),
+ self::DelasLead => Color::hex('#CF6481'),
};
}
@@ -52,6 +81,8 @@ public function getDescription(): string
return match ($this) {
self::SuperAdmin => 'Acesso total ao painel admin. Passa por cima de qualquer verificação de permissão.',
self::Streamer => 'Conecta a Twitch com permissões de broadcaster para usar as ferramentas de live.',
+ self::DelasModerator => 'Aprova, rejeita e bloqueia solicitações da tag He4rt Delas na moderação do /admin.',
+ self::DelasLead => 'Tudo da moderadora, mais gerenciar moderadoras e conceder ou remover a tag He4rt Delas.',
};
}
@@ -60,6 +91,8 @@ public function getIcon(): Heroicon
return match ($this) {
self::SuperAdmin => Heroicon::OutlinedShieldCheck,
self::Streamer => Heroicon::OutlinedVideoCamera,
+ self::DelasModerator => Heroicon::OutlinedHeart,
+ self::DelasLead => Heroicon::OutlinedSparkles,
};
}
}
diff --git a/app-modules/identity/src/User/Models/User.php b/app-modules/identity/src/User/Models/User.php
index 6a711334e..3a82cb2ab 100644
--- a/app-modules/identity/src/User/Models/User.php
+++ b/app-modules/identity/src/User/Models/User.php
@@ -125,7 +125,7 @@ public function registerMediaCollections(): void
public function canAccessPanel(Panel $panel): bool
{
return match ($panel->getId()) {
- 'admin' => app()->isProduction() ? $this->isSuperAdmin() : true,
+ 'admin' => app()->isProduction() ? $this->hasAnyRole(UserRole::withAdminAccess()) : true,
default => true
};
}
diff --git a/app-modules/identity/tests/Unit/Authorization/UserRoleTest.php b/app-modules/identity/tests/Unit/Authorization/UserRoleTest.php
index a2d7cedfa..7bdc72bec 100644
--- a/app-modules/identity/tests/Unit/Authorization/UserRoleTest.php
+++ b/app-modules/identity/tests/Unit/Authorization/UserRoleTest.php
@@ -16,3 +16,8 @@
expect(UserRole::SuperAdmin->value)->toBe('super-admin')
->and(UserRole::GUARD)->toBe('web');
});
+
+test('only super admin and moderation roles grant admin access', function (): void {
+ expect(UserRole::withAdminAccess())->toBe([UserRole::SuperAdmin, UserRole::DelasModerator, UserRole::DelasLead])
+ ->and(UserRole::Streamer->grantsAdminAccess())->toBeFalse();
+});
diff --git a/app-modules/panel-admin/CONTEXT.md b/app-modules/panel-admin/CONTEXT.md
index 9f8c58a92..45815fd9e 100644
--- a/app-modules/panel-admin/CONTEXT.md
+++ b/app-modules/panel-admin/CONTEXT.md
@@ -23,7 +23,7 @@ The admin panel (`/admin`) is the operational hub for the He4rt Developers commu
Panel Admin is a **view layer** module. It:
-- **Reads from** `activity` (messages, voice), `identity` (external identities), `moderation` (cases, appeals, actions), `community` (retrospectives)
+- **Reads from** `activity` (messages, voice), `identity` (external identities), `moderation` (cases, appeals, actions), `community` (retrospectives), `delas` (tag requests, blocks, history)
- **Writes only editorial state** it is the operator UI for: the retrospective's texts, period and
`deck_config` curation. Everything that computes or freezes data goes through a domain Action
(`PublishRetrospective`), never through the panel
@@ -42,9 +42,12 @@ panel-admin/
│ │ │ └── MeetingShowcasePage.php
│ │ └── Widgets/
│ │ └── DiscordStatsWidget.php
+│ ├── Concerns/
+│ │ └── SuperAdminOnly.php
│ ├── Moderation/
│ │ ├── ModerationCluster.php
│ │ ├── Pages/
+│ │ │ └── Delas/ (He4rt Delas: queue, blocks, history, team)
│ │ ├── Resources/
│ │ ├── Widgets/
│ │ └── Livewire/
@@ -60,6 +63,21 @@ panel-admin/
└── docs/adr/
```
+## Access
+
+Entering `/admin` does not unlock anything by itself
+([identity ADR-0003](../identity/docs/adr/0003-acesso-ao-admin-por-papel-de-moderacao.md)):
+
+- In production, `User::canAccessPanel('admin')` admits super admins and every role whose
+ `UserRole::grantsAdminAccess()` is true (today, the He4rt Delas moderator and lead).
+- Every Resource, Page and Cluster uses the `He4rt\PanelAdmin\Concerns\SuperAdminOnly` trait,
+ except the He4rt Delas pages (gated by `moderate-delas` / `lead-delas`), the shared
+ `ModerationCluster` and the `Dashboard` entry page (whose widgets are super-admin only).
+- `buildNavigation()` adds items through `itemsFor()`, which drops anything the user cannot
+ access (clusters via `canAccessClusteredComponents()`).
+- `tests/Feature/Authorization/AdminComponentAccessTest.php` sweeps every component: a new
+ Resource or Page without the trait breaks it.
+
## Navigation pattern
Each cluster has a dedicated navigation builder method in `PanelAdminServiceProvider`. When the URL path contains the cluster slug (e.g. `marketing/`), the sidebar switches to show a "Back to Admin" link + the cluster's sub-navigation. Default navigation shows all clusters as top-level items.
diff --git a/app-modules/panel-admin/lang/en/delas.php b/app-modules/panel-admin/lang/en/delas.php
new file mode 100644
index 000000000..2baf62771
--- /dev/null
+++ b/app-modules/panel-admin/lang/en/delas.php
@@ -0,0 +1,165 @@
+ 'He4rt Delas',
+ 'navigation' => [
+ 'group' => 'He4rt Delas',
+ 'queue' => 'Queue',
+ 'members' => 'Members',
+ 'blocks' => 'Blocks',
+ 'history' => 'History',
+ 'history_full' => 'Full history',
+ 'team' => 'Team',
+ ],
+ 'pages' => [
+ 'queue' => [
+ 'title' => 'He4rt Delas queue',
+ 'subtitle' => 'Review He4rt Delas tag requests. Every decision records who decided, when and why.',
+ ],
+ 'members' => [
+ 'title' => 'He4rt Delas members',
+ 'subtitle' => 'Who has the He4rt Delas tag today.',
+ ],
+ 'blocks' => [
+ 'title' => 'He4rt Delas blocks',
+ 'subtitle' => 'People blocked from requesting the He4rt Delas tag.',
+ ],
+ 'history' => [
+ 'title' => 'He4rt Delas history',
+ 'subtitle' => 'Decisions about the tag, with who did it, when and why.',
+ ],
+ 'team' => [
+ 'title' => 'He4rt Delas team',
+ 'subtitle' => 'He4rt Delas numbers, moderators and direct tag grants.',
+ ],
+ ],
+ 'columns' => [
+ 'requester' => 'Requester',
+ 'person' => 'Person',
+ 'requested_at' => 'Requested at',
+ 'blocked_by' => 'Blocked by',
+ 'blocked_at' => 'Blocked at',
+ 'reason' => 'Reason (internal)',
+ 'date' => 'Date',
+ 'action' => 'Action',
+ 'actor' => 'Done by',
+ 'role' => 'Role',
+ 'decisions' => 'Decisions',
+ 'member_since' => 'Member since',
+ 'decided_by' => 'Decided by',
+ ],
+ 'empty' => [
+ 'pending' => 'No pending requests',
+ 'pending_body' => 'When someone requests the He4rt Delas tag, it shows up here.',
+ 'members' => 'Nobody has the tag yet',
+ 'members_body' => 'People whose request is approved or who get the tag directly show up here.',
+ 'blocks' => 'No active blocks',
+ 'blocks_body' => 'People blocked from requesting the tag show up here.',
+ 'history' => 'Nothing in the history',
+ 'history_body' => 'Decisions about the tag show up here.',
+ 'team' => 'No moderators',
+ 'team_body' => 'Without moderators, only leads and super admins review the queue.',
+ ],
+ 'block_note' => 'A block only prevents new tag requests. It is not a ban or suspension and does not affect the account.',
+ 'reason_hint' => 'Internal: the person does not see this reason.',
+ 'history_hint' => 'Recorded in the history.',
+ 'actions' => [
+ 'correct_reason' => 'Edit reason',
+ 'correct_reason_heading' => 'Edit the reason',
+ 'correct_reason_body' => 'The original stays in the history. Readers see the edited reason, with the date and who edited it.',
+ 'correct_reason_field' => 'Edited reason',
+ 'reason_corrected' => 'Reason edited',
+ 'corrected_note' => 'Edited on :date by :name',
+ 'view_profile' => 'View profile',
+ 'view_versions' => 'view versions',
+ 'versions_heading' => 'Reason versions',
+ 'version_original' => 'Original',
+ 'version_edit' => 'Edit #:number',
+ 'version_current' => 'current',
+ 'close' => 'Close',
+ 'correct_until' => 'You can edit it until :date.',
+ 'correct_anytime' => 'As a lead, you can edit it at any time.',
+ 'message_label' => 'Message:',
+ 'approve' => 'Approve',
+ 'approve_heading' => 'Approve :name?',
+ 'approve_body' => "The He4rt Delas tag will show on @:username's profile.",
+ 'approved' => 'Request approved',
+ 'reject' => 'Reject',
+ 'reject_heading' => "Reject :name's request?",
+ 'reject_body' => ':name can request again from :date.',
+ 'reject_reason' => 'Rejection reason',
+ 'rejected' => 'Request rejected',
+ 'block' => 'Block',
+ 'block_tooltip' => 'Block: only prevents new tag requests. It is not a ban and does not affect the account.',
+ 'block_heading' => 'Block :name from requesting the tag?',
+ 'block_body' => 'This only blocks requesting the He4rt Delas tag. It is not a ban or suspension and does not affect the account. The pending request will be rejected.',
+ 'block_reason' => 'Block reason',
+ 'block_disabled' => 'Moderators, leads, admins and yourself cannot be blocked.',
+ 'blocked' => 'Person blocked',
+ 'unblock' => 'Unblock',
+ 'unblock_heading' => 'Unblock :name?',
+ 'unblock_body' => 'The person can request the tag again, respecting the cooldown after a recent decision.',
+ 'unblock_reason' => 'Unblock reason',
+ 'unblock_disabled' => 'Only whoever created the block or a lead can lift it.',
+ 'unblocked' => 'Block lifted',
+ 'grant' => 'Grant tag',
+ 'grant_heading' => 'Grant the He4rt Delas tag',
+ 'grant_body' => 'A pending request gets approved; without one, an approved request is created. The cooldown is ignored. If the person is blocked, the reason is required and the block is lifted.',
+ 'grant_reason' => 'Reason',
+ 'grant_blocked_heading' => 'This person is blocked',
+ 'grant_blocked_body' => 'Blocked by :name on :date. Reason: :reason. Granting the tag lifts the block, so a reason is required.',
+ 'granted' => 'Tag granted',
+ 'revoke' => 'Remove tag',
+ 'revoke_heading' => 'Remove the He4rt Delas tag',
+ 'revoke_body' => 'The record is kept. The person can request again after the cooldown.',
+ 'revoke_reason' => 'Removal reason',
+ 'revoked' => 'Tag removed',
+ 'revoke_team_disabled' => 'Team members keep the tag. Remove them from moderation first (Team → Revoke moderator).',
+ 'revoke_member_heading' => 'Remove the tag from :name?',
+ 'also_block' => 'Also block new requests',
+ 'also_block_hint' => 'Uses the same reason. Only prevents new tag requests: it is not a ban and does not affect the account.',
+ 'revoked_and_blocked' => 'Tag removed and new requests blocked',
+ 'person' => 'Person',
+ 'person_hint' => 'Search by name or @username.',
+ 'member_hint' => 'Only people who have the tag today.',
+ 'add_moderator' => 'Add moderator',
+ 'add_moderator_heading' => 'Add a He4rt Delas moderator',
+ 'add_moderator_body' => 'The person will see the He4rt Delas queue, blocks and history and decide requests. Leads are assigned by super admins in the user form.',
+ 'moderator_hint' => 'Only members with the tag show up. To add someone without the tag, use “Grant tag” first.',
+ 'moderator_added' => 'Moderator added',
+ 'remove_moderator' => 'Revoke moderator',
+ 'remove_moderator_heading' => "Revoke :name's role?",
+ 'remove_moderator_body' => ':name loses access to He4rt Delas moderation on the next request. Their decisions stay in the history.',
+ 'moderator_removed' => 'Role revoked',
+ 'lead_only' => 'Leads are assigned by super admins in the user form.',
+ ],
+ 'profile' => [
+ 'heading' => 'Profile',
+ 'headline' => 'Headline',
+ 'seniority' => 'Seniority',
+ 'years' => '{1} :years year of experience|[0,*] :years years of experience',
+ 'about' => 'About',
+ 'discord' => 'Discord',
+ 'discord_none' => 'Not connected',
+ 'since' => 'At He4rt since',
+ 'empty' => 'This person has not filled in their professional profile yet.',
+ 'note' => 'Read only. Email, birthdate and location are not shown here.',
+ ],
+ 'stats' => [
+ 'pending' => 'Pending now',
+ 'pending_oldest' => 'oldest :when',
+ 'pending_none' => 'queue up to date',
+ 'members' => 'Members with the tag',
+ 'members_desc' => 'approved and granted',
+ 'avg_decision' => 'Average time to decision',
+ 'avg_decision_desc' => 'in the last 90 days',
+ 'month' => 'Decisions this month',
+ 'month_desc' => 'approved / rejected',
+ 'blocks' => 'Active blocks',
+ 'minutes' => ':value min',
+ 'days' => ':value days',
+ 'blocks_desc' => 'only prevent new requests',
+ ],
+];
diff --git a/app-modules/panel-admin/lang/pt_BR/delas.php b/app-modules/panel-admin/lang/pt_BR/delas.php
new file mode 100644
index 000000000..e3e62665f
--- /dev/null
+++ b/app-modules/panel-admin/lang/pt_BR/delas.php
@@ -0,0 +1,165 @@
+ 'He4rt Delas',
+ 'navigation' => [
+ 'group' => 'He4rt Delas',
+ 'queue' => 'Fila',
+ 'members' => 'Membras',
+ 'blocks' => 'Bloqueios',
+ 'history' => 'Histórico',
+ 'history_full' => 'Histórico completo',
+ 'team' => 'Equipe',
+ ],
+ 'pages' => [
+ 'queue' => [
+ 'title' => 'Fila da He4rt Delas',
+ 'subtitle' => 'Analise os pedidos da tag He4rt Delas. Toda decisão fica registrada com quem decidiu, quando e o motivo.',
+ ],
+ 'members' => [
+ 'title' => 'Membras da He4rt Delas',
+ 'subtitle' => 'Quem tem a tag He4rt Delas hoje.',
+ ],
+ 'blocks' => [
+ 'title' => 'Bloqueios da He4rt Delas',
+ 'subtitle' => 'Quem está bloqueada de solicitar a tag He4rt Delas.',
+ ],
+ 'history' => [
+ 'title' => 'Histórico da He4rt Delas',
+ 'subtitle' => 'As decisões sobre a tag, com quem fez, quando e o motivo.',
+ ],
+ 'team' => [
+ 'title' => 'Equipe da He4rt Delas',
+ 'subtitle' => 'Os números da He4rt Delas, as moderadoras e a concessão direta da tag.',
+ ],
+ ],
+ 'columns' => [
+ 'requester' => 'Solicitante',
+ 'person' => 'Pessoa',
+ 'requested_at' => 'Pedido em',
+ 'blocked_by' => 'Bloqueada por',
+ 'blocked_at' => 'Bloqueada em',
+ 'reason' => 'Motivo (interno)',
+ 'date' => 'Data',
+ 'action' => 'Ação',
+ 'actor' => 'Quem fez',
+ 'role' => 'Papel',
+ 'decisions' => 'Decisões',
+ 'member_since' => 'Membra desde',
+ 'decided_by' => 'Decidido por',
+ ],
+ 'empty' => [
+ 'pending' => 'Nenhuma solicitação pendente',
+ 'pending_body' => 'Quando alguém pedir a tag He4rt Delas, o pedido aparece aqui.',
+ 'members' => 'Ninguém com a tag ainda',
+ 'members_body' => 'Quem tiver o pedido aprovado ou receber a tag direto aparece aqui.',
+ 'blocks' => 'Nenhum bloqueio ativo',
+ 'blocks_body' => 'Pessoas bloqueadas de solicitar a tag aparecem aqui.',
+ 'history' => 'Nada no histórico',
+ 'history_body' => 'As decisões sobre a tag aparecem aqui.',
+ 'team' => 'Nenhuma moderadora',
+ 'team_body' => 'Sem moderadoras, só líderes e super admins analisam a fila.',
+ ],
+ 'block_note' => 'O bloqueio impede apenas novos pedidos da tag. Não é banimento nem suspensão e não afeta a conta da pessoa.',
+ 'reason_hint' => 'Uso interno: a pessoa não vê este motivo.',
+ 'history_hint' => 'Fica registrado no histórico.',
+ 'actions' => [
+ 'correct_reason' => 'Editar motivo',
+ 'correct_reason_heading' => 'Editar o motivo',
+ 'correct_reason_body' => 'A versão original continua no histórico. Quem lê vê o motivo editado, com a data e quem editou.',
+ 'correct_reason_field' => 'Motivo editado',
+ 'reason_corrected' => 'Motivo editado',
+ 'corrected_note' => 'Editado em :date por :name',
+ 'view_profile' => 'Ver perfil',
+ 'view_versions' => 'ver versões',
+ 'versions_heading' => 'Versões do motivo',
+ 'version_original' => 'Original',
+ 'version_edit' => ':numberª edição',
+ 'version_current' => 'vale hoje',
+ 'close' => 'Fechar',
+ 'correct_until' => 'Você pode editar até :date.',
+ 'correct_anytime' => 'Como líder, você edita a qualquer momento.',
+ 'message_label' => 'Mensagem:',
+ 'approve' => 'Aprovar',
+ 'approve_heading' => 'Aprovar :name?',
+ 'approve_body' => 'A tag He4rt Delas passa a aparecer no perfil de @:username.',
+ 'approved' => 'Solicitação aprovada',
+ 'reject' => 'Rejeitar',
+ 'reject_heading' => 'Rejeitar a solicitação de :name?',
+ 'reject_body' => ':name poderá pedir de novo a partir de :date.',
+ 'reject_reason' => 'Motivo da rejeição',
+ 'rejected' => 'Solicitação rejeitada',
+ 'block' => 'Bloquear',
+ 'block_tooltip' => 'Bloquear: impede só novos pedidos da tag. Não é banimento e não afeta a conta.',
+ 'block_heading' => 'Bloquear :name de solicitar a tag?',
+ 'block_body' => 'Isso bloqueia só o pedido da tag He4rt Delas. Não é banimento nem suspensão e não afeta a conta. A solicitação pendente será rejeitada.',
+ 'block_reason' => 'Motivo do bloqueio',
+ 'block_disabled' => 'Não é possível bloquear moderadoras, líderes, admins ou a si mesma.',
+ 'blocked' => 'Pessoa bloqueada',
+ 'unblock' => 'Desbloquear',
+ 'unblock_heading' => 'Desbloquear :name?',
+ 'unblock_body' => 'A pessoa volta a poder solicitar a tag, respeitando a espera se houver uma decisão recente.',
+ 'unblock_reason' => 'Motivo do desbloqueio',
+ 'unblock_disabled' => 'Só quem fez o bloqueio ou uma líder pode desfazer.',
+ 'unblocked' => 'Bloqueio encerrado',
+ 'grant' => 'Conceder tag',
+ 'grant_heading' => 'Conceder a tag He4rt Delas',
+ 'grant_body' => 'Com solicitação pendente, ela é aprovada; sem solicitação, é criada uma já aprovada. A espera é ignorada. Se a pessoa estiver bloqueada, o motivo é obrigatório e o bloqueio é encerrado.',
+ 'grant_reason' => 'Motivo',
+ 'grant_blocked_heading' => 'Esta pessoa está bloqueada',
+ 'grant_blocked_body' => 'Bloqueada por :name em :date. Motivo: :reason. Conceder a tag encerra o bloqueio, por isso o motivo é obrigatório.',
+ 'granted' => 'Tag concedida',
+ 'revoke' => 'Remover tag',
+ 'revoke_heading' => 'Remover a tag He4rt Delas',
+ 'revoke_body' => 'O registro não é apagado. A pessoa poderá solicitar de novo depois da espera.',
+ 'revoke_reason' => 'Motivo da remoção',
+ 'revoked' => 'Tag removida',
+ 'revoke_team_disabled' => 'Quem é da equipe não perde a tag. Tire da moderação antes (Equipe → Revogar moderadora).',
+ 'revoke_member_heading' => 'Remover a tag de :name?',
+ 'also_block' => 'Também bloquear novos pedidos',
+ 'also_block_hint' => 'Usa o mesmo motivo. Só impede novos pedidos da tag: não é banimento e não afeta a conta.',
+ 'revoked_and_blocked' => 'Tag removida e novos pedidos bloqueados',
+ 'person' => 'Pessoa',
+ 'person_hint' => 'Busque por nome ou @username.',
+ 'member_hint' => 'Só aparece quem tem a tag hoje.',
+ 'add_moderator' => 'Adicionar moderadora',
+ 'add_moderator_heading' => 'Adicionar moderadora He4rt Delas',
+ 'add_moderator_body' => 'A pessoa passa a ver a fila, os bloqueios e o histórico da He4rt Delas e a decidir pedidos. Líderes são atribuídas por super admins, no cadastro de usuários.',
+ 'moderator_hint' => 'Só aparecem membras com a tag. Para adicionar alguém sem a tag, use “Conceder tag” antes.',
+ 'moderator_added' => 'Moderadora adicionada',
+ 'remove_moderator' => 'Revogar moderadora',
+ 'remove_moderator_heading' => 'Revogar o papel de :name?',
+ 'remove_moderator_body' => ':name perde o acesso à moderação He4rt Delas na próxima requisição. As decisões dela continuam no histórico.',
+ 'moderator_removed' => 'Papel revogado',
+ 'lead_only' => 'Líderes são atribuídas por super admins, no cadastro de usuários.',
+ ],
+ 'profile' => [
+ 'heading' => 'Perfil',
+ 'headline' => 'Título profissional',
+ 'seniority' => 'Senioridade',
+ 'years' => '{1} :years ano de experiência|[0,*] :years anos de experiência',
+ 'about' => 'Sobre',
+ 'discord' => 'Discord',
+ 'discord_none' => 'Não conectado',
+ 'since' => 'Na He4rt desde',
+ 'empty' => 'A pessoa ainda não preencheu o perfil profissional.',
+ 'note' => 'Só leitura. E-mail, data de nascimento e localização não aparecem aqui.',
+ ],
+ 'stats' => [
+ 'pending' => 'Pendentes agora',
+ 'pending_oldest' => 'mais antiga :when',
+ 'pending_none' => 'fila em dia',
+ 'members' => 'Membras com a tag',
+ 'members_desc' => 'aprovadas e concedidas',
+ 'avg_decision' => 'Tempo médio até a decisão',
+ 'avg_decision_desc' => 'nos últimos 90 dias',
+ 'month' => 'Decisões no mês',
+ 'month_desc' => 'aprovadas / rejeitadas',
+ 'blocks' => 'Bloqueios ativos',
+ 'minutes' => ':value min',
+ 'days' => ':value dias',
+ 'blocks_desc' => 'só impedem novos pedidos',
+ ],
+];
diff --git a/app-modules/panel-admin/resources/views/components/delas/profile-row.blade.php b/app-modules/panel-admin/resources/views/components/delas/profile-row.blade.php
new file mode 100644
index 000000000..3cee8b1a1
--- /dev/null
+++ b/app-modules/panel-admin/resources/views/components/delas/profile-row.blade.php
@@ -0,0 +1,11 @@
+@props(['icon', 'label', 'iconClass' => 'text-gray-400'])
+
+{{-- Uma linha do "Ver perfil": ícone, rótulo pequeno e o valor embaixo. --}}
+
+
+
+
+
{{ $label }}
+
{{ $slot }}
+
+
diff --git a/app-modules/panel-admin/resources/views/moderation/delas/heading.blade.php b/app-modules/panel-admin/resources/views/moderation/delas/heading.blade.php
new file mode 100644
index 000000000..6717309bd
--- /dev/null
+++ b/app-modules/panel-admin/resources/views/moderation/delas/heading.blade.php
@@ -0,0 +1,10 @@
+{{-- Cabeçalho das páginas da He4rt Delas: a logo e o nome da página. --}}
+
+
+
+
+ {{ $label }}
+
+
diff --git a/app-modules/panel-admin/resources/views/moderation/delas/person-profile.blade.php b/app-modules/panel-admin/resources/views/moderation/delas/person-profile.blade.php
new file mode 100644
index 000000000..5bbf7e65f
--- /dev/null
+++ b/app-modules/panel-admin/resources/views/moderation/delas/person-profile.blade.php
@@ -0,0 +1,120 @@
+{{--
+ "Ver perfil": resumo só leitura para a moderação decidir. Fica de fora o que
+ não ajuda a decidir: e-mail, data de nascimento e localização.
+
+ @var \He4rt\Identity\User\Models\User $person
+ @var \He4rt\Delas\TagRequest\ValueObjects\DelasEligibilityResult $eligibility
+ @var \He4rt\Identity\ExternalIdentity\Models\ExternalIdentity|null $discord
+--}}
+@php
+ use He4rt\Delas\TagRequest\Enums\DelasEligibilityState;
+
+ $profile = $person->profile;
+ $state = $eligibility->state;
+ $avatarUrl = $person->getFilamentAvatarUrl();
+
+ $initials = collect(explode(' ', $person->name))
+ ->filter()
+ ->take(2)
+ ->map(fn (string $part): string => mb_strtoupper(mb_substr($part, 0, 1)))
+ ->implode('');
+
+ $experience = $profile?->years_experience !== null
+ ? trans_choice('panel-admin::delas.profile.years', $profile->years_experience, ['years' => $profile->years_experience])
+ : null;
+ $seniority = collect([$profile?->seniority_level?->getLabel(), $experience])->filter()->implode(' · ');
+
+ $hasProfessionalInfo = $profile?->headline || $seniority !== '' || $profile?->about;
+@endphp
+
+
+ {{-- Cartão: faixa do Hub, foto (ou iniciais), nome e a situação na He4rt Delas. --}}
+
+
+
+
+
+ {{ $initials }}
+
+ {{-- Se a foto não carregar (link antigo do Discord, por exemplo), ficam as iniciais. --}}
+ @if ($avatarUrl)
+
+ @endif
+
diff --git a/app-modules/panel-app/src/Livewire/Delas/DelasProfileSection.php b/app-modules/panel-app/src/Livewire/Delas/DelasProfileSection.php
new file mode 100644
index 000000000..80b1de9e0
--- /dev/null
+++ b/app-modules/panel-app/src/Livewire/Delas/DelasProfileSection.php
@@ -0,0 +1,88 @@
+for($this->user());
+ }
+
+ public function requestAction(): Action
+ {
+ return Action::make('request')
+ ->label(__('panel-app::delas.profile.toggle'))
+ ->modalHeading(__('panel-app::delas.profile.modal.heading'))
+ ->modalContent(view('panel-app::livewire.delas.request-modal'))
+ ->modalSubmitActionLabel(__('panel-app::delas.profile.modal.submit'))
+ // Rosa claro com texto 900 (4,81:1): o Filament escolheria texto branco num tom mais escuro.
+ ->modalSubmitAction(fn (Action $action): Action => $action->extraAttributes([
+ 'class' => 'bg-delas-primary! text-delas-900! hover:bg-delas-300! [&_*]:text-delas-900!',
+ ]))
+ ->modalCancelActionLabel(__('panel-app::delas.profile.modal.cancel'))
+ ->modalWidth(Width::Large)
+ ->visible(fn (): bool => $this->eligibility->canRequest())
+ ->action(function (): void {
+ try {
+ resolve(RequestDelasTag::class)->handle($this->user());
+ } catch (DelasException $delasException) {
+ Notification::make()->danger()->title($delasException->getMessage())->send();
+
+ return;
+ } finally {
+ unset($this->eligibility);
+ }
+
+ Notification::make()
+ ->success()
+ ->title(__('panel-app::delas.profile.sent'))
+ ->body(__('panel-app::delas.profile.sent_body'))
+ ->send();
+
+ $this->dispatch('delas-tag-updated');
+ });
+ }
+
+ public function render(): View
+ {
+ return view('panel-app::livewire.delas.profile-section');
+ }
+
+ private function user(): User
+ {
+ $user = auth()->user();
+
+ abort_unless($user instanceof User, 403);
+
+ return $user;
+ }
+}
diff --git a/app-modules/panel-app/src/Pages/ProfilePage.php b/app-modules/panel-app/src/Pages/ProfilePage.php
index 9d0018ba7..1db368cf3 100644
--- a/app-modules/panel-app/src/Pages/ProfilePage.php
+++ b/app-modules/panel-app/src/Pages/ProfilePage.php
@@ -27,6 +27,7 @@
use Filament\Schemas\JsContent;
use Filament\Schemas\Schema;
use Filament\Support\Enums\Width;
+use He4rt\Delas\TagRequest\Queries\DelasEligibility;
use He4rt\Gamification\Character\Models\Character;
use He4rt\Identity\User\Enums\ProfileImage;
use He4rt\Identity\User\Models\User;
@@ -46,6 +47,7 @@
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Str;
use Livewire\Attributes\Computed;
+use Livewire\Attributes\On;
use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;
use Livewire\WithFileUploads;
@@ -57,6 +59,7 @@
* @property-read string|null $coverPreviewUrl
* @property-read int $avatarFocalY
* @property-read int $coverFocalY
+ * @property-read bool $hasDelasTag
*/
class ProfilePage extends Page
{
@@ -525,6 +528,20 @@ public function character(): ?Character
->first();
}
+ #[Computed]
+ public function hasDelasTag(): bool
+ {
+ $user = auth()->user();
+
+ return $user instanceof User && resolve(DelasEligibility::class)->hasTag($user);
+ }
+
+ #[On(event: 'delas-tag-updated')]
+ public function refreshDelasTag(): void
+ {
+ unset($this->hasDelasTag);
+ }
+
#[Computed]
public function initials(): string
{
diff --git a/app-modules/panel-app/src/PanelAppServiceProvider.php b/app-modules/panel-app/src/PanelAppServiceProvider.php
index 787975310..1ae329671 100644
--- a/app-modules/panel-app/src/PanelAppServiceProvider.php
+++ b/app-modules/panel-app/src/PanelAppServiceProvider.php
@@ -6,6 +6,7 @@
use Filament\Support\Assets\Js;
use Filament\Support\Facades\FilamentAsset;
+use He4rt\PanelApp\Livewire\Delas\DelasProfileSection;
use He4rt\PanelApp\Livewire\Events\EventDetail;
use He4rt\PanelApp\Livewire\Events\EventsList;
use He4rt\PanelApp\Livewire\Events\MyEventsList;
@@ -20,8 +21,6 @@
class PanelAppServiceProvider extends ServiceProvider
{
- public function register(): void {}
-
public function boot(): void
{
$this->loadViewsFrom(__DIR__.'/../resources/views', 'panel-app');
@@ -41,5 +40,7 @@ public function boot(): void
Livewire::component('timeline-post-show', PostShow::class);
Livewire::component('timeline-reply-composer', ReplyComposer::class);
Livewire::component('timeline-thread-replies', ThreadReplies::class);
+
+ Livewire::component('delas-profile-section', DelasProfileSection::class);
}
}
diff --git a/app-modules/panel-app/tests/Feature/Delas/DelasProfileSectionTest.php b/app-modules/panel-app/tests/Feature/Delas/DelasProfileSectionTest.php
new file mode 100644
index 000000000..a64c56cc4
--- /dev/null
+++ b/app-modules/panel-app/tests/Feature/Delas/DelasProfileSectionTest.php
@@ -0,0 +1,81 @@
+user = User::factory()->withDiscord()->create();
+ $this->actingAs($this->user);
+});
+
+test('a opção de solicitar aparece para quem pode pedir', function (): void {
+ livewire(DelasProfileSection::class)
+ ->assertOk()
+ ->assertSee(__('panel-app::delas.profile.toggle'))
+ ->assertActionVisible('request');
+});
+
+test('abrir o pop-up de solicitar ainda não registra nada', function (): void {
+ livewire(DelasProfileSection::class)
+ ->mountAction('request')
+ ->assertActionMounted('request')
+ ->assertMountedActionModalSee(__('panel-app::delas.profile.modal.tip'));
+
+ expect(DelasTagRequest::query()->exists())->toBeFalse();
+});
+
+test('confirmar no pop-up registra a solicitação como pendente', function (): void {
+ livewire(DelasProfileSection::class)
+ ->callAction('request')
+ ->assertNotified(__('panel-app::delas.profile.sent'))
+ ->assertSee(__('panel-app::delas.profile.pending_title'))
+ ->assertActionHidden('request');
+
+ expect(DelasTagRequest::query()->sole()->status)->toBe(DelasRequestStatus::Pending);
+});
+
+test('com a tag aprovada, o perfil mostra que a pessoa faz parte', function (): void {
+ DelasTagRequest::factory()->for($this->user)->approved()->create();
+
+ livewire(DelasProfileSection::class)
+ ->assertSee(__('panel-app::delas.profile.member_title'))
+ ->assertActionHidden('request');
+});
+
+test('em espera, mostra a data da próxima tentativa', function (): void {
+ config(['app.display_timezone' => 'America/Sao_Paulo']);
+ $this->travelTo('2026-10-06 15:00:00');
+ DelasTagRequest::factory()->for($this->user)->rejected()->create(['decided_at' => now()]);
+
+ livewire(DelasProfileSection::class)
+ ->assertSee(__('panel-app::delas.profile.cooldown_body', ['date' => '21/10']))
+ ->assertActionHidden('request');
+});
+
+test('bloqueada, mostra só que não é possível solicitar, sem o motivo', function (): void {
+ DelasRequesterBlock::factory()->for($this->user)->create(['reason' => 'motivo interno sigiloso']);
+
+ livewire(DelasProfileSection::class)
+ ->assertSee(__('panel-app::delas.profile.blocked_title'))
+ ->assertDontSee('motivo interno sigiloso')
+ ->assertActionHidden('request');
+});
+
+test('sem o Discord, pede para conectar e não deixa solicitar', function (): void {
+ $this->actingAs(User::factory()->create());
+
+ livewire(DelasProfileSection::class)
+ ->assertSee(__('panel-app::delas.profile.discord_title'))
+ ->assertSee(route('oauth.redirect', ['panel' => 'app', 'provider' => 'discord']), escape: false)
+ ->assertActionHidden('request');
+});
diff --git a/app/Providers/Filament/AppPanelProvider.php b/app/Providers/Filament/AppPanelProvider.php
index d9030b358..5681e67f2 100644
--- a/app/Providers/Filament/AppPanelProvider.php
+++ b/app/Providers/Filament/AppPanelProvider.php
@@ -48,6 +48,7 @@ public function panel(Panel $panel): Panel
->colors([
'primary' => Color::Purple,
'gray' => Color::Zinc,
+ 'delas' => Color::hex('#F485A2'),
])
->viteTheme('resources/css/filament/app/theme.css')
->sidebarCollapsibleOnDesktop()
diff --git a/composer.json b/composer.json
index ecdc67069..5b9bf50b7 100644
--- a/composer.json
+++ b/composer.json
@@ -19,6 +19,7 @@
"he4rt/bot-discord": "^1.0.0",
"he4rt/community": "^1.0.0",
"he4rt/contents": "^1.0.0",
+ "he4rt/delas": "^1.0.0",
"he4rt/docs": "^1.0.0",
"he4rt/economy": "^1.0.0",
"he4rt/events": "^1.0.0",
diff --git a/composer.lock b/composer.lock
index cd0e45f87..89bde4578 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,7 +4,7 @@
"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
"This file is @generated automatically"
],
- "content-hash": "3044d4f3dddf69acd834eca1f013788a",
+ "content-hash": "cc49a31c9de8f58e9b1b2a934ad73e9a",
"packages": [
{
"name": "anourvalar/eloquent-serialize",
@@ -3545,6 +3545,45 @@
"relative": true
}
},
+ {
+ "name": "he4rt/delas",
+ "version": "1.0.0",
+ "dist": {
+ "type": "path",
+ "url": "app-modules/delas",
+ "reference": "b5d246ffe28b5c571da00174c00565e3e7762d0e"
+ },
+ "require": {
+ "he4rt/identity": "^1.0.0"
+ },
+ "type": "library",
+ "extra": {
+ "laravel": {
+ "providers": [
+ "He4rt\\Delas\\DelasServiceProvider"
+ ]
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "He4rt\\Delas\\": "src/",
+ "He4rt\\Delas\\Database\\Factories\\": "database/factories/",
+ "He4rt\\Delas\\Database\\Seeders\\": "database/seeders/"
+ }
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "He4rt\\Delas\\Tests\\": "tests/"
+ }
+ },
+ "license": [
+ "proprietary"
+ ],
+ "transport-options": {
+ "symlink": true,
+ "relative": true
+ }
+ },
{
"name": "he4rt/docs",
"version": "1.0",
diff --git a/docs/specs/2026-10-06-he4rt-delas-tag-e-moderacao.md b/docs/specs/2026-10-06-he4rt-delas-tag-e-moderacao.md
new file mode 100644
index 000000000..46e17d970
--- /dev/null
+++ b/docs/specs/2026-10-06-he4rt-delas-tag-e-moderacao.md
@@ -0,0 +1,540 @@
+---
+type: spec
+title: 'He4rt Delas: solicitação da tag e painel de moderação'
+status: draft
+date: 2026-10-06
+author: damacosta
+related:
+ issues: [570, 571]
+ modules: [delas, identity, panel-app, panel-admin, he4rt]
+ adr: identity/0003-acesso-ao-admin-por-papel-de-moderacao
+---
+
+# He4rt Delas: solicitação da tag e painel de moderação
+
+Spec cross-module: cria o módulo `delas` e altera `identity`, `panel-app`, `panel-admin` e o
+design system (`he4rt`). Por isso fica em `docs/specs/` e não dentro de um módulo.
+
+## Contexto
+
+A He4rt Delas é a iniciativa da comunidade voltada a mulheres e pessoas que se identificam como
+mulheres. No Discord ela já existe como cargo: o `/cargo-delas`
+(`app-modules/bot-discord/src/SlashCommands/CargoDelasCommand.php`) deixa quem tem o cargo
+`comite_delas` conceder o cargo `he4rt_delas`. No Hub, não existe nada equivalente.
+
+As issues [#571](https://github.com/he4rt/heartdevs.com/issues/571) (solicitação da tag) e
+[#570](https://github.com/he4rt/heartdevs.com/issues/570) (painel de moderação) são duas metades
+da mesma feature e serão entregues juntas.
+
+Fatos do código atual que moldam o desenho:
+
+- **Autorização é `spatie/laravel-permission`, só com roles**
+ ([ADR-0002 do identity](../../app-modules/identity/docs/adr/0002-super-admin-via-spatie-permission.md)).
+ Roles são cases de `UserRole` (`super-admin`, `streamer`), criadas por migration no identity
+ (ex.: `2026_10_04_000000_create_streamer_role.php`) e atribuídas pelo `CheckboxList` de roles em
+ `panel-admin/src/Filament/Resources/Users/Schemas/UserForm.php`. `Gate::before` no
+ `IdentityServiceProvider` libera tudo para `super-admin`. O precedente de papel comum é
+ `streamer`, verificado por `Gate::define('use-streamer-tools')`.
+- **Fora de produção, o `/admin` é aberto a qualquer usuário autenticado**
+ (`User::canAccessPanel`). Em produção, entram super admins e os papéis de moderação
+ ([ADR-0003 do identity](../../app-modules/identity/docs/adr/0003-acesso-ao-admin-por-papel-de-moderacao.md),
+ que substitui o "super admin ou nada" da ADR-0002). Em qualquer ambiente, cada Resource, Page e
+ Cluster do admin decide no `canAccess()`.
+- **Moderação mora no `/admin`**, no cluster de Moderação (`/admin/mod`).
+- **Não há perfil público.** "Exibir no perfil" significa a página de perfil do `/app`
+ (`panel-app/src/Pages/ProfilePage.php`) e o card de preview
+ (`components/profile-preview-card.blade.php`), visíveis só para a própria pessoa.
+
+## Objetivos
+
+1. Uma membra solicita a tag He4rt Delas no próprio perfil e acompanha o status.
+2. Moderadoras da He4rt Delas veem a fila de pendentes no `/admin`, no cluster de Moderação, e
+ aprovam, rejeitam ou bloqueiam.
+3. Super admins atribuem o papel de moderadora e podem conceder ou remover a tag diretamente.
+4. Toda decisão sobre a tag fica registrada com quem fez, quando e o motivo.
+5. Toda regra de acesso é aplicada no domínio, não só ocultando a interface.
+
+## Fora do escopo
+
+- Sincronizar a tag com o cargo `he4rt_delas` no Discord (os eventos de domínio deixam pronto).
+- Notificar a solicitante por e-mail ou Discord.
+- Perfil público e exibição da tag para outras pessoas.
+- Auditoria de roles alteradas pelo `UserForm` (concern do identity). As alterações feitas pelas
+ actions do delas (`AddDelasModerator` etc.) entram no histórico.
+- Permissions granulares do Spatie (a ADR-0002 fica só em roles nesta fase).
+
+## Regras de negócio
+
+### Solicitação (membra)
+
+- A opção de solicitar aparece no perfil para contas novas e já existentes.
+- Ativar a opção abre um pop-up explicando o que é a He4rt Delas. A solicitação só é registrada
+ após a confirmação.
+- Enquanto pendente, o perfil mostra o texto de aguardando aprovação e **não** mostra a tag.
+- Após aprovada, a tag aparece no perfil.
+- Não é possível solicitar quando:
+ - já existe uma solicitação `pending` ou `approved`;
+ - a última solicitação foi `rejected` ou `revoked` e ainda não passou a espera
+ (ver [Espera](#espera-de-15-dias));
+ - existe um bloqueio ativo. O perfil informa apenas que não é possível solicitar, sem motivo;
+ - a pessoa não tem o Discord conectado (`delas.require_discord`, ligado por padrão). O perfil
+ pede para conectar, com o botão que já existe nas Conexões. A He4rt Delas acontece no
+ Discord, a moderação conhece a pessoa por lá, e a conta conectada é o que vai ligar a tag ao
+ cargo `he4rt_delas` numa próxima issue. Espera e bloqueio aparecem antes de faltar o Discord.
+- O pop-up de confirmação lembra que perfis com foto e informações básicas são analisados mais
+ rápido. É só um lembrete: o perfil completo não é exigido, para não pedir dados pessoais a mais
+ (minimização da LGPD) nem afastar quem está começando.
+
+### Moderação (moderadoras da He4rt Delas)
+
+- Veem a fila de solicitações `pending`: nome/perfil da solicitante e data do pedido.
+- Aprovam ou rejeitam cada solicitação. Rejeição pede motivo, interno.
+- Bloqueiam uma solicitante, com motivo obrigatório. Bloquear rejeita a solicitação pendente, se
+ houver.
+- Não podem bloquear quem passa no gate `moderate-delas` (outras moderadoras e super admins,
+ via `Gate::before`) nem a si mesmas.
+- Desbloqueiam os bloqueios que elas mesmas fizeram, com motivo obrigatório.
+- Não decidem a própria solicitação: ela fica para outra moderadora, uma líder ou um super admin.
+- O bloqueio vale **só** para solicitar a tag. Não é ban nem suspensão (`UserSituation`) e não
+ afeta a conta.
+- **Bloquear não tira a tag.** Quem já tem a tag continua com ela mesmo bloqueada; o bloqueio só
+ passaria a valer se ela perdesse a tag e tentasse pedir de novo. Por isso o cadeado de bloquear
+ aparece só na Fila, para quem está pedindo.
+ - _Por quê:_ bloquear é da moderadora e serve para pedidos insistentes ou falsos. Tirar a tag
+ de quem já faz parte é mais sério e fica só com a líder, com motivo próprio. Se o bloqueio
+ tirasse a tag, a moderadora teria um caminho indireto para remover membras.
+ - Para tirar a tag **e** impedir novos pedidos, a líder usa "Remover tag" com "Também bloquear
+ novos pedidos" (Membras ou Equipe): as duas coisas na mesma transação, ou nenhuma.
+- Veem a lista de quem tem a tag (página Membras), só para consulta.
+- Editam o motivo que escreveram até 24 horas depois (`delas.reason_correction_hours`); o botão
+ "Editar motivo" mostra até quando. Cada edição é uma linha nova no histórico
+ (`reason_corrected`, com `corrects_id` apontando para a original), e a original nunca muda. Na
+ tabela, a edição não vira uma linha a mais: a linha editada mostra o texto que vale hoje e
+ "Editado em DD/MM/AA por X".
+- Não veem as versões anteriores do motivo. Quem edita pode ter tirado algo sensível, e isso não
+ volta para a tela de toda a equipe.
+
+### Liderança (líderes da He4rt Delas)
+
+Papel `delas-lead`, atribuído só por super admins, no `/admin`. A líder trabalha **na mesma
+área do `/admin` que as moderadoras** (o grupo He4rt Delas do cluster de Moderação) e tem tudo o
+que a moderadora tem, mais:
+
+- página Equipe, com os números da He4rt Delas no topo;
+- histórico completo, com filtro por ação;
+- na Equipe, adiciona e revoga `delas-moderator`. Só quem tem a tag vira moderadora: para
+ promover alguém de fora, a líder concede a tag antes. Não cria nem revoga líderes, e não age
+ sobre super admins;
+- **quem é da equipe não perde a tag.** Equipe é quem passa no `moderate-delas`: moderadora,
+ líder ou super admin. Para tirar a tag de uma moderadora, a líder primeiro revoga o papel
+ (Equipe → "Revogar moderadora") e só depois remove a tag. Líderes e super admins saem da
+ equipe pelo super admin, no cadastro de usuários. Por isso, em Membras, o "Remover tag" fica
+ desabilitado na linha de quem é da equipe, com a dica de como tirar da equipe antes; e quem é
+ da equipe não aparece no seletor da Equipe. A regra também vale no domínio (`RevokeDelasTag`
+ recusa).
+ - _Por quê:_ é o espelho de "moderadora precisa ter a tag". Sem isso, uma moderadora sem a tag
+ continuaria moderando. E, como quem é da equipe nunca pode ser bloqueada, o "Também
+ bloquear" nunca aparece para quem falharia;
+- desbloqueia qualquer bloqueio;
+- edita qualquer motivo, a qualquer momento, e abre "ver versões": a original e cada edição,
+ com quem escreveu e quando;
+- concede e remove a tag direto:
+ - se houver solicitação `pending`, ela é aprovada (`pending → approved`);
+ - se não houver, é criada uma solicitação já `approved`;
+ - se a pessoa já tem a tag, a ação é recusada com exceção de domínio;
+ - se a pessoa estiver bloqueada, a interface mostra quem bloqueou, quando e o motivo, e exige
+ um motivo. O bloqueio é encerrado na mesma transação;
+ - remover (`approved → revoked`) exige motivo. O registro não é apagado, e a pessoa pode
+ solicitar de novo após a espera, salvo se também for bloqueada. Pela Membras (ou pela
+ Equipe), a líder pode marcar "Também bloquear novos pedidos": o bloqueio usa o mesmo motivo
+ e entra na mesma transação. Se a pessoa já estiver bloqueada, só perde a tag.
+
+> _Vai além da #570_, que diz que a permissão é "atribuível apenas por admins do Hub". Precisa do
+> ok da Sther e de um comentário na issue.
+
+### Administração (super admins)
+
+- Atribuem e retiram `delas-lead` pela seção Papéis do formulário de usuário (`UserForm`), que
+ já existe. O acesso some na próxima requisição, porque `hasRole` lê `model_has_roles` a cada
+ request.
+- `delas-moderator` só se ganha e se perde pela Equipe da He4rt Delas (`AddDelasModerator` e
+ `RemoveDelasModerator`), que conferem a tag e gravam o histórico. No `UserForm`, a opção
+ aparece desabilitada, com a dica "Gerencie pela Equipe da He4rt Delas", e o papel fica como
+ está ao salvar. Promover uma moderadora a líder pelo `UserForm` continua possível: líder e
+ moderadora são exclusivas, e marcar líder troca o papel.
+ - _Por quê:_ pelo `UserForm`, alguém sem a tag virava moderadora sem passar pela regra da
+ Equipe e sem registro no histórico.
+- Passam em todos os gates (via `Gate::before`) e veem as páginas da He4rt Delas como uma
+ líder.
+
+### Espera de 15 dias
+
+`next_allowed_at = decided_at + config('delas.request_cooldown_days')` dias, com padrão `15`. A
+comparação é com `now()` em UTC. A data é exibida como DD/MM em
+`config('app.display_timezone')`.
+
+A espera conta sempre da última rejeição ou remoção, e o bloqueio não a pausa nem a reinicia.
+Ao desbloquear, a pessoa pode pedir na hora se a espera já acabou durante o bloqueio, ou espera
+até a data original se ainda não acabou. Como bloquear rejeita o pedido pendente, quem é
+bloqueada com pedido aberto ganha uma espera contada do dia do bloqueio. A concessão direta
+ignora a espera.
+
+- _Por quê:_ o bloqueio já teve motivo próprio. Reiniciar a espera ao desbloquear puniria a pessoa
+ duas vezes pelo mesmo episódio.
+
+Exemplo: pedido no dia 1, bloqueada no dia 3 (o pedido é rejeitado nesse dia, então a espera vai
+até o dia 18).
+
+| Desbloqueada no dia | Pode pedir |
+| ------------------- | -------------------------------------------- |
+| 10 | a partir do dia 18 (a espera ainda corre) |
+| 20 | na hora (a espera acabou durante o bloqueio) |
+
+Se, em vez de desbloquear, a líder conceder a tag no dia 10, a pessoa ganha a tag na hora: a
+concessão direta ignora a espera e encerra o bloqueio.
+
+### Ordem das verificações
+
+Uma pessoa pode estar em mais de uma situação ao mesmo tempo (por exemplo, em espera **e**
+bloqueada), mas o perfil mostra um aviso só. `DelasEligibility` resolve isso como uma fila de
+perguntas: pergunta uma de cada vez e para na primeira resposta "sim".
+
+1. Já tem um pedido aberto ou a tag? → "aguardando aprovação" ou "você faz parte".
+2. Está bloqueada? → "não é possível solicitar", sem motivo e sem data.
+3. Está em espera? → "você poderá pedir a partir de DD/MM".
+4. Falta conectar o Discord? → "conecte seu Discord".
+5. Nada disso → pode pedir.
+
+Exemplo: a Bia foi rejeitada (está em espera) e também foi bloqueada. A pergunta 2 já responde
+"sim", então ela vê "não é possível solicitar" e nunca chega na pergunta 3.
+
+- _Por quê o bloqueio vem antes da espera:_ se a Bia visse "você poderá pedir a partir do dia
+ 18", acharia que no dia 18 está liberada. Mas o bloqueio só acaba quando alguém desbloqueia.
+- _Por quê o Discord vem por último:_ sem isso, a Bia seria mandada conectar o Discord para só
+ então descobrir que não pode pedir.
+
+## Arquitetura
+
+### Módulo `delas`
+
+Novo módulo `app-modules/delas`, namespace `He4rt\Delas\`, dependente só de **identity**. Os
+painéis dependem dele, nunca o contrário.
+
+```
+identity ◀── delas ◀── panel-app
+ ▲ ▲
+ └── panel-admin ─┘
+```
+
+Entram junto com o módulo, conforme o guideline `domain/02-module-architecture`:
+
+- `composer.json` do módulo exigindo `he4rt/identity`, e `he4rt/delas` no `composer.json` raiz;
+- `CONTEXT.md` com glossário e "Não confundir com": **Tag He4rt Delas** ≠ Badge de
+ gamification; **Bloqueio** ≠ ban/suspensão do identity; **Moderadora He4rt Delas** ≠ moderação
+ de conteúdo do módulo `moderation`;
+- `docs/adr/0001-...` registrando as decisões desta spec;
+- linha no `CONTEXT-MAP.md`, na tabela e nas regras de dependência;
+- label `mod:delas` no guideline `workflow/02-triage-labels` e no GitHub;
+- `config/delas.php` dentro do módulo, carregado com `mergeConfigFrom`;
+- textos em `lang/{en,pt_BR}/`.
+
+Subdomínios: `src/TagRequest/`, `src/Block/`, `src/History/`.
+
+### Mudanças no identity
+
+- Cases `DelasModerator = 'delas-moderator'` ("Moderadora He4rt Delas") e
+ `DelasLead = 'delas-lead'` ("Líder He4rt Delas") em `UserRole`, com cor, descrição e ícone (o
+ enum usa `match` sem `default`).
+- Migration `create_delas_roles`, igual à do streamer: `Role::findOrCreate` das duas roles e
+ `forgetCachedPermissions` no `up`, remoção no `down`. O `RolesSeeder` já itera os cases.
+- States `UserFactory::delasModerator()` e `UserFactory::delasLead()`, seguindo `streamer()` e
+ `superAdmin()`.
+
+O case precisa morar em `UserRole` porque enums não são extensíveis por outro módulo.
+
+### Autorização
+
+| Gate | `delas-moderator` | `delas-lead` | `super-admin` |
+| ----------------------------------------------------------------------------------------------------- | :---------------: | :----------: | :-----------: |
+| `moderate-delas` (ver fila, aprovar, rejeitar, bloquear, desbloquear os próprios) | ✓ | ✓ | ✓ |
+| `lead-delas` (números, histórico completo, moderadoras, desbloquear qualquer, conceder/remover a tag) | | ✓ | ✓ |
+
+- Os gates são definidos no `DelasServiceProvider`, porque são vocabulário do delas. Isso diverge
+ do `use-streamer-tools`, que fica no identity; a ADR do módulo registra a escolha.
+- `moderate-delas`: `$user->hasAnyRole([UserRole::DelasModerator, UserRole::DelasLead])`.
+- `lead-delas`: `$user->hasRole(UserRole::DelasLead)`.
+- Não há classes Policy. As actions de domínio recebem o ator no DTO, checam
+ `Gate::forUser($actor)->authorize(...)` e aplicam as regras de negócio com exceções de domínio
+ (`DelasException::cannotBlockModerator()` etc.), como fazem as actions do `events`.
+- "Não bloquear moderadora ou admin" é `Gate::forUser($target)->allows('moderate-delas')`.
+- O `CheckboxList` de roles do `UserForm` passa a ser visível só para `isSuperAdmin()`. Sem
+ isso, fora de produção qualquer pessoa autenticada atribuiria `delas-moderator`.
+- Acesso ao `/admin` (ADR-0003 do identity): `UserRole::grantsAdminAccess()` diz se o papel entra
+ (`match` sem `default`), e `User::canAccessPanel('admin')` em produção usa
+ `hasAnyRole(UserRole::withAdminAccess())`. Dentro do painel, todo Resource, Page e Cluster que
+ não é da He4rt Delas tem o trait `SuperAdminOnly`; o Dashboard é a página de entrada do
+ super admin, com os widgets só para ele. Para quem só modera, o Dashboard some do menu e abrir
+ o `/admin` leva direto à Moderação (e dali à Fila da He4rt Delas). A sidebar (`PanelAdminServiceProvider::buildNavigation()`) só
+ mostra o que passa no `canAccess()`.
+
+### Modelo de dados
+
+Postgres. Migrations criadas com `make:migration --module=delas`. Chaves UUID com `HasUuids`,
+sobrescrevendo o stub do projeto (que gera bigint identity), como nos módulos `events`,
+`marketing` e `streaming`. Colunas de enum são `string` com `->comment(Enum::stringifyCases())`.
+Datas em `timestampTz`.
+
+#### `delas_tag_requests` (model `DelasTagRequest`)
+
+| coluna | tipo | nota |
+| --------------------------- | ---------------- | ----------------------------- |
+| `id` | uuid | PK |
+| `user_id` | uuid | FK `users`, cascade on delete |
+| `status` | string(20) | `DelasRequestStatus` |
+| `requested_at` | timestampTz | |
+| `decided_by` | uuid null | FK `users`, null on delete |
+| `decided_at` | timestampTz null | |
+| `decision_reason` | string(500) null | interno |
+| `created_at` / `updated_at` | timestampTz | |
+
+Índice único parcial em `user_id` onde `status in ('pending', 'approved')`, via `DB::statement`
+(precedente: `identity/.../2026_07_07_000000_drop_multi_tenancy.php`). Ele garante uma
+solicitação ativa por pessoa e resolve a concorrência do primeiro pedido: a
+`UniqueConstraintViolationException` vira exceção de domínio.
+
+`DelasRequestStatus::canTransitionTo()`:
+
+```
+pending → approved | rejected
+approved → revoked
+```
+
+#### `delas_requester_blocks` (model `DelasRequesterBlock`)
+
+| coluna | tipo | nota |
+| --------------------------- | ---------------- | ----------------------------------------------- |
+| `id` | uuid | PK |
+| `user_id` | uuid | FK `users`, cascade on delete |
+| `blocked_by` | uuid null | FK `users`, null on delete |
+| `reason` | string(500) | obrigatório |
+| `blocked_at` | timestampTz | |
+| `lifted_by` | uuid null | FK `users`, null on delete |
+| `lifted_at` | timestampTz null | |
+| `lift_reason` | string(500) null | obrigatório ao desbloquear; nulo enquanto ativo |
+| `created_at` / `updated_at` | timestampTz | |
+
+Índice único parcial em `user_id` onde `lifted_at is null`.
+
+#### `delas_transitions` (model `DelasTransition`, `UPDATED_AT = null`)
+
+Histórico append-only, gravado pelas actions, sem trigger (ADR-0003 do events). Formato mais
+próximo de `squad_membership_events` (ação + trilha) do que de `events_enrollment_transitions`.
+
+| coluna | tipo | nota |
+| --------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `id` | uuid | PK |
+| `user_id` | uuid | FK `users`, cascade on delete; a pessoa afetada |
+| `request_id` | uuid null | FK `delas_tag_requests`, cascade on delete |
+| `block_id` | uuid null | FK `delas_requester_blocks`, cascade on delete |
+| `corrects_id` | uuid null | FK `delas_transitions`, cascade on delete; a linha cujo motivo esta corrige |
+| `action` | string(20) | `DelasAction`: `requested`, `approved`, `rejected`, `granted`, `revoked`, `blocked`, `unblocked`, `moderator_added`, `moderator_removed`, `reason_corrected` |
+| `from_status` / `to_status` | string(20) null | `DelasRequestStatus`, quando há mudança de status |
+| `actor_id` | uuid null | FK `users`, null on delete |
+| `triggered_by` | string(20) | `DelasTriggeredBy`: `user`, `moderator`, `lead`, `admin`, `system` |
+| `reason` | string(500) null | |
+| `created_at` | timestampTz | `useCurrent()` |
+
+Sem coluna `metadata`: nenhum fluxo a preenche, e um jsonb sem forma quebraria o
+`tests/Arch/NoLooseArrayCastsTest.php` (guideline `domain/06`).
+
+#### Models e enums
+
+- Os três models declaram `#[Table]`, `#[UseFactory]` e PHPDoc `@property` sincronizado
+ (guideline `domain/04`). Factories com states `pending`, `approved`, `rejected`, `revoked` e
+ `lifted`.
+- `DelasRequestStatus`, `DelasAction` e `DelasTriggeredBy` implementam `HasLabel`, `HasColor` e
+ `HasDescription` (guideline `domain/07`) e usam `StringifyEnum`. Labels em
+ `delas/lang/{en,pt_BR}/enums.php`. `DelasTriggeredBy` é próprio do módulo; o `TriggeredBy` do
+ `events` não pode ser importado.
+
+### Actions de domínio
+
+`final readonly`, `handle()` com parâmetros tipados (ator sempre explícito), sem sufixo `Action` (padrão de `CreateShortLink`,
+`ReviewAppeal`). As que mudam estado rodam em `DB::transaction` com `lockForUpdate()` e gravam
+a linha de histórico.
+
+As que mudam a situação de uma pessoa (pedir, conceder, bloquear, remover a tag, adicionar e
+revogar moderadora) começam a transação travando a pessoa (`PersonLock`) e só depois
+verificam a situação dela. Assim, duas decisões sobre a mesma pessoa esperam a vez uma da
+outra, e nenhuma decide com uma leitura velha: por exemplo, conceder a tag enquanto alguém
+bloqueia, ou tirar a tag enquanto alguém adiciona a pessoa como moderadora.
+
+| Action | Gate do ator | Faz |
+| -------------------------------------------- | -------------------------------------------------- | -------------------------------------------------------------------------------------- |
+| `RequestDelasTag` | (própria pessoa) | valida ativa, espera e bloqueio; cria `pending` |
+| `ApproveDelasRequest` | `moderate-delas` | `pending → approved` |
+| `RejectDelasRequest` | `moderate-delas` | `pending → rejected`, com motivo |
+| `BlockDelasRequester` | `moderate-delas` | cria bloqueio e rejeita a pendente |
+| `UnblockDelasRequester` | `moderate-delas` (próprios) / `lead-delas` (todos) | encerra bloqueio |
+| `GrantDelasTag` | `lead-delas` | aprova a pendente ou cria `approved`; encerra bloqueio |
+| `RevokeDelasTag` | `lead-delas` | `approved → revoked`, com motivo; opcionalmente bloqueia junto |
+| `CorrectDelasReason` | `moderate-delas` (próprio, 24h) / `lead-delas` | grava `reason_corrected` e atualiza o motivo vigente |
+| `AddDelasModerator` / `RemoveDelasModerator` | `lead-delas` | atribui ou retira `delas-moderator`; recusa líderes, super admins e quem não tem a tag |
+
+A consulta `DelasEligibility` responde para o perfil: pode solicitar, por que não, e
+`next_allowed_at`.
+
+### Eventos de domínio
+
+`DelasTagRequested`, `DelasTagApproved`, `DelasTagRejected`, `DelasTagGranted`,
+`DelasTagRevoked`, `DelasRequesterBlocked`, `DelasRequesterUnblocked`. Classes `final readonly`,
+`Dispatchable`, `ShouldDispatchAfterCommit`, com payload de IDs escalares e enums
+(`requestId`, `userId`, `actorId`), sem models. Quando `GrantDelasTag` encerra um bloqueio,
+dispara também `DelasRequesterUnblocked`. Nenhum listener nesta entrega.
+
+### Interface
+
+**Hub (`/app`, `panel-app`)**
+
+- Perfil (`ProfilePage`): seção He4rt Delas (`DelasProfileSection`) com toggle e pop-up de
+ confirmação, estado pendente, data da próxima tentativa ou aviso de bloqueio. Tag no card de
+ preview, separada dos badges. Textos em `panel-app/lang/{en,pt_BR}/delas.php`.
+- Nada de moderação no `/app`.
+
+**Admin (`/admin`, `panel-admin`)**
+
+- Moderação no `ModerationCluster` (`/admin/mod`), no grupo "He4rt Delas" da subnavegação, com
+ uma página por parte. A subnavegação do cluster já filtra por `canAccess()`, então cada pessoa
+ só vê as páginas do próprio papel. Textos em `panel-admin/lang/{en,pt_BR}/delas.php`.
+
+ | Página | `canAccess()` | Badge | Conteúdo |
+ | --------- | ---------------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+ | Fila | `moderate-delas` | pendentes | aprovar, rejeitar, bloquear |
+ | Membras | `moderate-delas` | membras com a tag | quem tem a tag, desde quando e quem decidiu; líder: remover a tag, com a opção de bloquear novos pedidos |
+ | Bloqueios | `moderate-delas` | bloqueios ativos | desbloquear (moderadora: os próprios; líder: todos) |
+ | Histórico | `moderate-delas` | | moderadora: decisões (os pedidos ela já vê na Fila); líder: completo, com os pedidos, filtro por ação e versões do motivo; editar motivo |
+ | Equipe | `lead-delas` | | números (pendentes, membras com a tag, tempo médio até a decisão, aprovadas e rejeitadas no mês, bloqueios ativos), conceder e remover a tag, adicionar e revogar moderadora |
+
+- Os seletores de pessoa da Equipe usam a consulta de domínio `DelasCandidates` e seguem o
+ padrão de Select do projeto: abrem com as primeiras pessoas do escopo e buscam o resto por nome
+ ou `@username`, sem diferenciar acento nem maiúscula. Quem age nunca aparece.
+- **"Ver perfil"**: em todas as páginas, embaixo do nome, abre na lateral um resumo só leitura
+ com foto, título, senioridade, "Sobre", Discord conectado, "Na He4rt desde" e a situação da
+ pessoa na He4rt Delas. Ficam de fora e-mail, data de nascimento e localização (minimização da
+ LGPD); a pessoa e as conexões só são carregadas quando o resumo abre.
+- Cada ação é uma classe em `panel-admin/src/Moderation/Actions/Delas` (padrão do admin, como
+ `HideInteractionAction`); as páginas só listam as ações e declaram a consulta e as colunas.
+- Cada tabela declara o eager load (`user.roles` na fila, `user` e `blocker` nos bloqueios,
+ `user`, `actor` e `corrections.actor` no histórico, `user` e `decider` na Membras, `roles` na
+ equipe).
+- A seção Papéis do `UserForm`, onde super admins atribuem `delas-lead` (`delas-moderator`
+ aparece desabilitada: é gerenciada pela Equipe), visível só para super admins; a tabela de
+ Usuários só **mostra** as roles (badges).
+
+### Identidade visual
+
+- As telas da He4rt Delas usam o visual normal do Hub e do Filament: superfícies neutras, tokens
+ da He4rt e as cores semânticas padrão (aprovar e aprovada em verde, rejeitar, remover e bloquear
+ em vermelho, pendente em âmbar, encerrado em cinza).
+- O rosa da He4rt Delas aparece **só nos pontos de marca**: a tag, a logo, o ícone do item no
+ menu e o botão principal do pedido ("Enviar solicitação" e o toggle do perfil). Sem degradês e
+ sem fundos rosados.
+- Paleta He4rt Delas (primária `#F485A2`; 50 `#FFD1EE` → 900 `#730835`) como cores `delas-*` no
+ `@theme` dos temas dos dois painéis (`resources/css/filament/{app,admin}/theme.css`).
+- A tag usa o rosa claro com texto e ícone no tom 900. Texto branco só do tom 600 para cima
+ (WCAG AA).
+- Logos oficiais (ícone, vertical e horizontal) no componente `x-he4rt::delas.logo`
+ (`currentColor`) e a tag em `x-he4rt::delas.tag`, no design system (módulo `he4rt`), porque
+ os dois painéis usam. O ícone `he4rt-delas` é registrado pelo `He4rtServiceProvider` como set
+ de ícones `he4rt`, com a cor da marca no próprio SVG.
+- Protótipo de referência validado com a Danielle; tokens e assets a confirmar com a Sther.
+
+## Trade-offs e alternativas consideradas
+
+| Alternativa | Por que não |
+| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| Tag como role Spatie `he4rt-delas`, espelhando o Discord | Role não guarda solicitação, decisão, espera nem bloqueio; misturaria autorização com identidade |
+| Badge de `gamification` | Badges são progressão por XP/claim, sem fluxo de aprovação |
+| Tipo dentro de `onboarding` | Onboarding é a camada de entrada obrigatória; a tag é opcional e pode vir a qualquer momento |
+| Subdomínio em `profile` | Acoplaria o perfil a moderação e papéis; um módulo próprio isola a feature e as regras |
+| Permissions granulares (`delas.solicitacoes.decidir` etc.) | A ADR-0002 adota só roles nesta fase; gates nomeados permitem migrar depois sem mudar chamadas |
+| Moderação numa página única no `/app` | Era a primeira versão. Criaria um segundo lugar de moderação, fora do cluster que já existe |
+
+## Testes
+
+Pest. Feature em `delas/tests/Feature` (grupo e `LazilyRefreshDatabase` vêm do `tests/Pest.php`),
+unitários em `delas/tests/Unit`.
+
+- `DelasRequestStatus::canTransitionTo` (unit).
+- Solicitar: `pending` só após confirmação; recusa se ativa, em espera ou bloqueada; duas
+ solicitações simultâneas, só uma passa.
+- Espera: bloqueada antes de `next_allowed_at` e liberada depois, com `travelTo`.
+- Aprovar e rejeitar: mudam status, gravam histórico com ator e data, recusam sem
+ `moderate-delas`; duas decisões simultâneas, só uma passa; moderadora não decide a própria
+ solicitação.
+- Bloqueio: motivo obrigatório; recusa bloquear moderadora, super admin ou a si mesma; moderadora
+ não desbloqueia bloqueio de outra.
+- Admin: concede com pendente aberta (aprova), sem solicitação (cria), já aprovada (recusa) e
+ bloqueada (encerra o bloqueio); remove a tag, sozinha ou bloqueando junto (desfaz tudo se o
+ bloqueio for recusado).
+- Correção de motivo: linha nova sem mudar a original, vale a mais recente, atualiza o motivo da
+ solicitação ou do bloqueio, prazo de quem escreveu, líder a qualquer momento, recusa motivo
+ vazio, igual ou de ação sem motivo.
+- Papel: perde acesso ao retirar `delas-moderator`; o campo de roles não aparece para quem não é
+ super admin; papéis de moderação entram no `/admin` em produção, `streamer` não.
+- Candidatas (`DelasCandidates`): um teste por escopo (conceder, remover, adicionar moderadora,
+ quem age nunca aparece) e a busca.
+- Páginas do admin (`panel-admin/tests/Feature/Moderation/Delas`): gate de cada página, badges,
+ ações, busca e rótulo dos seletores, "Ver perfil" sem dados pessoais e versões do motivo só
+ para a liderança, com eager load automático desligado e lazy loading proibido, e pelo menos
+ dois registros por tabela.
+- Perfil (`panel-app/tests/Feature/Delas`): pop-up antes de registrar, estados pendente, membra,
+ espera, bloqueada (sem o motivo) e sem Discord.
+- Testes escritos para leitura: um comportamento por teste, arrumar / agir / conferir separados,
+ um `expect` por linha.
+- Testes manuais com as contas do `DelasDemoSeeder`
+ (`php artisan db:seed --class="He4rt\Delas\Database\Seeders\DelasDemoSeeder"`): uma conta por
+ papel e por situação.
+- Varredura: no `/admin`, a moderadora só acessa o Dashboard e as páginas da He4rt Delas; quem
+ não tem papel, só o Dashboard. Quem só modera é levada do Dashboard para a Moderação.
+- Arch (opcional): `He4rt\Delas` não importa `He4rt\Panel*`.
+
+Validação: `make check`, `make test` e `make test-shards`.
+
+## Entrega
+
+- Branch `feature/he4rt-delas`, PR único para `4.x` com `Closes #570` e `Closes #571`, no
+ template do repositório. Commits `feat(delas): ...` (e `feat(identity)`, `feat(panel-app)`,
+ `feat(panel-admin)` onde couber).
+- Labels nas issues: `type:feat`, `mod:delas`, `mod:identity`, `mod:panel-app`,
+ `mod:panel-admin`.
+
+## Pontos em aberto
+
+Dependem de outras pessoas e ficam fora deste PR.
+
+**Alinhar com a Alícia e a Sther** (vão além do texto das issues):
+
+1. **Regras além das issues**: espera de 15 dias, bloqueio, concessão e remoção direta, edição
+ de motivo, moderadora precisa ter a tag e Discord obrigatório para pedir. As que forem
+ recusadas saem do PR; a espera e o Discord são configuráveis
+ (`delas.request_cooldown_days`, `delas.require_discord`).
+2. **Papel `delas-lead`**: a líder gerencia moderadoras. A #570 diz que a permissão é
+ "atribuível apenas por admins do Hub".
+3. **Rejeição**: a solicitante deve ver o motivo? Hoje, não: o motivo é interno.
+
+**Próximas issues** (rascunhos locais, abrir depois do ok):
+
+4. **Tag pública por escolha da pessoa**: a tag revela identidade de gênero, dado sensível pela
+ LGPD. Hoje só a própria pessoa e quem modera a veem. A proposta é um interruptor "Mostrar a
+ tag no meu perfil público", desligado por padrão.
+5. **Integração com o `/cargo-delas` do Discord**: dar e tirar o cargo `he4rt_delas` quando a tag
+ é concedida ou removida. Os eventos de domínio e a conta do Discord conectada (agora
+ obrigatória para pedir) já deixam o gancho pronto.
+
+**Padrões do projeto** (mudar é decisão do time, não deste PR):
+
+6. **Seletores de pessoa**: o projeto pré-carrega todo Select
+ (`FilamentServiceProvider::configureSelect()`). Na revisão, o Daniel sugeriu "Conceder tag" só
+ por busca, porque a lista é a comunidade inteira. Seguimos o padrão do projeto; se fizer
+ sentido mudar, é uma conversa com o time.
diff --git a/resources/css/filament/admin/theme.css b/resources/css/filament/admin/theme.css
index 40308c886..49567d90c 100644
--- a/resources/css/filament/admin/theme.css
+++ b/resources/css/filament/admin/theme.css
@@ -7,6 +7,21 @@
@source '../../../../app-modules/**/resources/**/*';
@source '../../../../app-modules/**/src/**/*';
+/* Paleta da He4rt Delas (Figma da marca). Usada só nos pontos de marca (tag, logo e ícone) da moderação He4rt Delas no cluster de Moderação. */
+@theme {
+ --color-delas-primary: #f485a2;
+ --color-delas-50: #ffd1ee;
+ --color-delas-100: #ffbbd7;
+ --color-delas-200: #ffa4c1;
+ --color-delas-300: #ff8fab;
+ --color-delas-400: #e77996;
+ --color-delas-500: #cf6481;
+ --color-delas-600: #b84f6d;
+ --color-delas-700: #a03a5a;
+ --color-delas-800: #8a2447;
+ --color-delas-900: #730835;
+}
+
.fi-sidebar {
@apply bg-gray-100 dark:bg-gray-900;
}
diff --git a/resources/css/filament/app/theme.css b/resources/css/filament/app/theme.css
index f44a6709a..5488b2e59 100644
--- a/resources/css/filament/app/theme.css
+++ b/resources/css/filament/app/theme.css
@@ -7,6 +7,21 @@
@source '../../../../app-modules/**/panel-app/**/*';
@source '../../../../app-modules/**/resources/views/**/*';
+/* Paleta da He4rt Delas (Figma da marca). Usada só nos pontos de marca: tag, logo, ícone e CTA do pedido. */
+@theme {
+ --color-delas-primary: #f485a2;
+ --color-delas-50: #ffd1ee;
+ --color-delas-100: #ffbbd7;
+ --color-delas-200: #ffa4c1;
+ --color-delas-300: #ff8fab;
+ --color-delas-400: #e77996;
+ --color-delas-500: #cf6481;
+ --color-delas-600: #b84f6d;
+ --color-delas-700: #a03a5a;
+ --color-delas-800: #8a2447;
+ --color-delas-900: #730835;
+}
+
/* Login split layout — strip Filament's card wrapper */
.fi-simple-layout:has(.fi-login-split) {
.fi-simple-main-ctn {