feat: add fetchWikiRaw helper for the wiki search box

2026-08-17 23:40:30 +00:00
33 changed files with 132 additions and 3692 deletions
@@ -1,21 +0,0 @@
-{
-  "languages": [
-    "java",
-    "yaml",
-    "markdown"
-  ],
-  "focus": [
-    "thread-safety",
-    "paper-chunk-ticketing",
-    "item-loss-prevention",
-    "resource-cleanup",
-    "performance-and-chunk-loading",
-    "null-safety-and-unit-tests"
-  ],
-  "exclude_paths": [
-    "target/**",
-    "*.bak*",
-    "docs/**"
-  ],
-  "instructions": "Canalhandia is a Minecraft Paper 1.21.x server plugin written in modern Java 25. Enforce these core invariants:\n1. Thread Safety: Bukkit API, World, Entity, and Inventory mutations MUST run on the main server thread. Async threads only do pure calculation or async file I/O.\n2. Item & Inventory Safety: Never discard player items. Always handle full-inventory overflow by dropping excess items at the player's location. On multi-step container placement (e.g. chests), roll back blocks if not all items fit.\n3. Lifecycle & Cleanup: All registered chunk tickets, recipes, schedulers, and I/O executors must be cleanly flushed and unloaded in onDisable() and module toggles.\n4. Chunk Loading: Never trigger synchronous chunk generation or loading inside event handlers. Always check world.isChunkLoaded() before querying blocks.\n5. Test Coverage: All domain logic, coordinates math, parsers, and pure helpers must have corresponding JUnit tests in src/test/java."
-}
@@ -610,5 +610,3 @@ phrase it so the count never has to agree with a translated noun.
 Statistic constants get renamed between Minecraft releases, so resolve them via
 `Stats.resolve("NEW_NAME", "OLD_NAME")` — a rename then degrades one curiosity
 instead of breaking the whole announcement.
-
-
@@ -1,84 +0,0 @@
-# Plan: AI Multi-Personalities, Judite (SAC), Dynamic Tags, Persistent Memory & Event Expansion
-
-## 1. Architecture & Component Design
-
-```
-                     ┌───────────────────────────┐
-                     │    CanalhandiaCommand     │
-                     │  (/ia, /iap, /ia persona) │
-                     └─────────────┬─────────────┘
-                                   │
-                                   ▼
-┌─────────────────┐         ┌──────────────┐         ┌────────────────────────┐
-│  PlayerMemory   │◄───────►│      Ai      │◄───────►│      Tools / Wiki      │
-│ (ia-memoria.yml)│         │(Orchestrator)│         │ (lugares_jogador, etc.)│
-└─────────────────┘         └──────┬───────┘         └────────────────────────┘
-                                   │
-                     ┌─────────────┴─────────────┐
-                     │          MiniMax          │
-                     │  (HTTP / Tools / Chat)    │
-                     └───────────────────────────┘
-```
-
-### Components:
-1. **`Persona.java` (Enum Enhancement):**
-   - Add `JUDITE` (SAC/Telemarketing persona) and `NARRADOR` (Fantasy narrator).
-   - Add `displayTag()` (e.g. "Judite", "Zoeiro", "Amigão") and `tagColor()` (Adventure `NamedTextColor`).
-   - Add persona-specific system prompts while maintaining the security invariant (`GUARD`).
-
-2. **`PlayerMemory.java` (New Persistent Service):**
-   - Manages `plugins/Canalhandia/ia-memoria.yml`.
-   - Thread-safe, cached in-memory with disk persistence.
-   - Stores per-player:
-     - Selected persona (`judite`, `zoeiro`, etc.) or `null` (inherit server default).
-     - Persistent compressed summary of past conversations.
-     - List of key facts learned about the player (e.g., base coordinates, preferred building materials, fear of mobs).
-   - Provides sliding-window compression: auto-condenses turns when memory exceeds thresholds.
-
-3. **`Tools.java` (Expanded Function Calling):**
-   - Add `lugares_jogador` function: fetches recent deaths from `DeathLog`, saved coordinates from `Notes`, and current biome/world.
-   - Update definitions JSON to make the tool discoverable to the LLM.
-
-4. **`Ai.java` (Orchestrator Updates):**
-   - Integrate `PlayerMemory`.
-   - Resolve effective persona per player (`playerMemory.persona(player)` -> fallback `settings.aiPersona()`).
-   - In `compose()`: inject effective persona tone + `playerMemory.formatContext(player)` + location summary.
-   - In `deliver()` and `style()`: render dynamic tag `Msg.tag(persona.displayTag(), persona.tagColor())` instead of fixed `[IA]`.
-   - Update `saySomething()` to support persona-specific spontaneous events.
-
-5. **`CanalhandiaCommand.java` (CLI & Interaction):**
-   - Enhance `/ia persona [nome]` to set per-player persona or list available personas with descriptions and click-to-select suggestions.
-   - Add `/ia persona padrao` to reset preference.
-   - Add `/ia status` and `/ia esquecer`.
-
-6. **`Canalhandia.java` & Event Hooks (Event Expansion):**
-   - Wire expanded event triggers into `saySomething()`:
-     - Player joins (`aiWelcome`)
-     - Player death streaks / notable deaths (`onDeath`)
-     - Milestones & custom achievements (`onMilestone`)
-     - Raid and boss victories (`onBossDefeat`)
-
---
-
-## 2. File Touches
-
-1. `src/main/java/dev/marcospaulo/canalhandia/Persona.java` — Add `JUDITE`, `NARRADOR`, tags, colors, and prompts.
-2. `src/main/java/dev/marcospaulo/canalhandia/PlayerMemory.java` — New class for persistent per-player memory & compression.
-3. `src/main/java/dev/marcospaulo/canalhandia/Tools.java` — Add `lugares_jogador` tool and integration with `DeathLog` & `Notes`.
-4. `src/main/java/dev/marcospaulo/canalhandia/Ai.java` — Integrate `PlayerMemory`, dynamic persona tags, prompt composition.
-5. `src/main/java/dev/marcospaulo/canalhandia/CanalhandiaCommand.java` — Subcommands for `/ia persona`, `/ia status`, `/ia esquecer`.
-6. `src/main/java/dev/marcospaulo/canalhandia/Canalhandia.java` — Wire `PlayerMemory` lifecycle, expand event hooks.
-7. `src/test/java/dev/marcospaulo/canalhandia/PersonaTest.java` — Unit tests for personas, tags, and system prompts.
-8. `src/test/java/dev/marcospaulo/canalhandia/PlayerMemoryTest.java` — Unit tests for YAML storage, compression, and per-player state.
-9. `src/test/java/dev/marcospaulo/canalhandia/ToolsTest.java` — Unit tests for `lugares_jogador` and tool execution.
-
---
-
-## 3. Risks & Mitigations
-
- **Risk:** Token context blowup from memory/chat history.
-  - *Mitigation:* Hard-cap memory summary length (max 300 chars) and max facts (max 5 items) per player.
- **Risk:** Thread safety when reading player memory in async AI tasks.
-  - *Mitigation:* Synchronize all `PlayerMemory` reads/writes under monitor; snapshot memory context as immutable strings on main thread before async dispatch.
- **Risk:** API costs from spontaneous event comments.
-  - *Mitigation:* All events remain strictly governed by `Budget` with cooldown windows and hourly/daily spend limits.
@@ -1,103 +0,0 @@
-# Spec: AI Multi-Personalities, Judite (SAC), Dynamic Tags, Persistent Memory & Event Expansion
-
-## 1. Objective & Motivation
-
-Transform the `ia` module in the `Canalhandia` plugin into a rich, personalized companion system:
-1. **Per-Player AI Selection:** Each player can pick their own AI persona (or use server default).
-2. **Dynamic Chat Tags:** Replace static `[IA]` tag with the active persona's name (e.g. `[Judite]`, `[Zoeiro]`, `[Amigão]`, `[Seco]`, `[Aldeão]`, `[Narrador]`).
-3. **Judite Roleplay Persona:** A hilarious Brazilian SAC/telemarketing attendant (Porta dos Fundos style) with fictitious protocols, bureaucratic quirks, hold music jokes, and deadpan efficiency.
-4. **Persistent Compressed Memory (`ia-memoria.yml`):** Retain player memories, key facts, past locations, and sliding-window conversation summaries across server reboots.
-5. **Rich Location & Stat Grounding:** Grant the AI direct knowledge of places the player has been (death locations via `DeathLog`, saved pins via `Notes`, current biomes/coords, statistics).
-6. **Expanded Event Reactivity:** Broaden spontaneous AI commentary to include death streaks, boss/raid triumphs, milestone achievements, first-time dimension visits, and custom join greetings with persona-specific voice.
-
---
-
-## 2. Personas Specification
-
-### A. Tag & Persona Definitions
-
-| Persona Key | Display Tag | Tone & Character Description |
-|---|---|---|
-| `judite` | `[Judite]` | Atendente de SAC/telemarketing burocrática e impaciente, viciada em gerundismo ("estaremos verificando no sistema"), gera números de protocolo ("Protocolo 2026-MC-..."), pede para aguardar na linha, cobra pendências (fome/vida baixa) com frieza corporativa e dá respostas precisas. |
-| `zoeiro` | `[Zoeiro]` | Veterano debochado do servidor que usa mortes e estatísticas contra o jogador, mantendo o bom humor. |
-| `amigao` | `[Amigão]` | Amigo paciente, caloroso e prestativo, ideal para acolher novatos sem sarcasmo. |
-| `seco` | `[Seco]` | Minimalista, direto e sarcástico, 1 a 2 frases curtas sem emoção. |
-| `aldeao` | `[Aldeão]` | Solene e místico, falando como um sábio aldeão ancestral de Minecraft. |
-| `narrador` | `[Narrador]` | Narrador épico e dramático de RPG de fantasia medieval ("Eis que o bravo viajante indaga..."). |
-| `neutro` | `[IA]` | Assistente direto, neutro e sem persona marcante. |
-
-### B. Dynamic Tag Rendering
- In `/ia`, `/iap`, and chat responses: Tag is rendered as `Msg.tag(persona.displayTag(), persona.tagColor())` instead of fixed `[IA]`.
- Java players retain rich hover cards detailing the persona name and question prompt.
-
---
-
-## 3. Player Preferences & Commands
-
- `/ia persona` / `/ia personalidade`: Lists all available personas and highlights the player's active selection.
- `/ia persona <nome>`: Sets the player's personal persona (persisted in `ia-memoria.yml`).
- `/ia persona padrao` / `/ia persona reset`: Resets to the server-wide default persona configured in `config.yml`.
- `/ia status`: Displays active persona, memory status, and summary of stored facts for the player.
- `/ia esquecer`: Clears the player's stored conversation memory/facts.
-
---
-
-## 4. Persistent Memory & Chat Compression Engine (`PlayerMemory`)
-
-### File: `plugins/Canalhandia/ia-memoria.yml`
-
-```yaml
-players:
-  <uuid>:
-    name: "Diguin_n"
-    persona: "judite"
-    updated_at: 1771450000000
-    summary: "Jogador explorou o Nether e perguntou sobre poções de agilidade. Tem base na vila das coordenadas 120, 64, -300."
-    facts:
-      - "Tem base na vila (120, 64, -300)"
-      - "Morreu recentemente no Void"
-      - "Gosta de criar axolotes e golfinhos"
-```
-
-### Memory Mechanics:
-1. **Short-Term Session Memory:** Live exchanges stored in memory for immediate follow-ups.
-2. **Key Facts Extraction / Journaling:** Maintained per player to keep long-term context across restarts.
-3. **Sliding Compression:** When conversation turns exceed limits, compress previous interactions into the player's persistent summary string, ensuring bounded token usage.
-
---
-
-## 5. Context Grounding & Tools
-
- **Tool `lugares_jogador`:**
-  - Retrieves player's recent deaths from `DeathLog` (`mortes.yml`).
-  - Retrieves player's saved pins/bases from `Notes` (`notas.yml`).
-  - Retrieves current coordinates, world dimension, and biome.
- **Tool `estatisticas_jogador`:**
-  - Reads mined blocks, mob kills, total deaths, playtime from `OfflineStats`.
- **Tool `conquistas_jogador`:**
-  - Reads unlocked titles and achievements.
-  - Server leaderboards, recent public milestones, online player list.
-
---
-
-## 6. Expanded Event Engine
-
-The AI can react to diverse gameplay triggers (gated by `aiBudget` and configurable settings):
-1. **Death Streaks & Notable Deaths:** Void deaths, falling, explosions, Warden/Wither encounters.
-2. **Player Joins (`aiWelcome`):** Persona greets returning player with contextual facts (e.g. Judite mentions pending tickets or absence duration).
-3. **Milestone Crossings:** When a player crosses round milestones (e.g. 100km walked, 10,000 blocks mined) or earns rare achievements.
-4. **Boss Defeats & Raids:** Dragon/Wither defeats or raid victories.
-
---
-
-## 7. Acceptance Criteria
-
-1. All existing 316 unit tests continue to pass without regressions.
-2. New unit tests covering:
-   - `PersonaTest`: Validation of all personas including `JUDITE` and `NARRADOR`, display tags, system prompts, safety guard invariant.
-   - `PlayerMemoryTest`: YAML serialization, compression, fact storage, and per-player persona retention.
-   - `ToolsTest`: Verification of `lugares_jogador` and updated tool definitions.
-   - `AiTagTest`: Dynamic persona tag rendering in chat and hover styling.
-   - `EventTest`: Event triggers formatting prompts with appropriate persona context.
-3. `/ia persona <nome>` persists choices across restarts.
-4. Full clean compilation with `mvn test` and `mvn package`.
@@ -1,46 +0,0 @@
-# Tasks: AI Multi-Personalities, Judite (SAC), Dynamic Tags, Persistent Memory & Event Expansion
-
- [x] **Task 1: Persona Enhancement (`Persona.java` & `PersonaTest.java`)**
-  - Add `JUDITE` (SAC/telemarketing attendant) and `NARRADOR` (fantasy narrator) to `Persona` enum.
-  - Add `displayTag()` (e.g. "Judite", "Zoeiro", "Amigão", "Seco", "Aldeão", "Narrador", "IA") and `tagColor()` (`NamedTextColor`).
-  - Add persona system prompts with safety guard invariant.
-  - Update `PersonaTest.java` to assert all enum keys, display tags, colors, and guard constraints.
-
- [x] **Task 2: Persistent Player Memory & Compression (`PlayerMemory.java` & `PlayerMemoryTest.java`)**
-  - Create `PlayerMemory.java` persisted at `plugins/Canalhandia/ia-memoria.yml`.
-  - Implement per-player persona setting (`getPersona`, `setPersona`, `resetPersona`).
-  - Implement turn recording with automatic sliding-window summary condensation.
-  - Implement key facts list per player (`addFact`, `getFacts`).
-  - Implement `formatContext(UUID player)` for AI system prompt formatting.
-  - Write comprehensive unit tests in `PlayerMemoryTest.java`.
-
- [x] **Task 3: Location Grounding Tool (`Tools.java` & `ToolsTest.java`)**
-  - Add `lugares_jogador` function definition to `Tools.DEFINITIONS`.
-  - Implement `lugares_jogador` in `Tools.java` pulling recent deaths from `DeathLog`, saved pins from `Notes`, and current world/biome.
-  - Write unit tests in `ToolsTest.java` verifying tool execution and response formatting.
-
- [x] **Task 4: AI Orchestration & Dynamic Tag Styling (`Ai.java`)**
-  - Integrate `PlayerMemory` into `Ai.java`.
-  - Resolve effective persona per player in `ask()`.
-  - Update `compose()` to inject player persona prompt, player memory context, and location context.
-  - Update `deliver()` and `style()` to display dynamic persona tag (e.g. `[Judite]`, `[Zoeiro]`) and hover metadata.
-  - Update `saySomething()` to support persona-specific spontaneous speech.
-
- [x] **Task 5: Command Interface & Subcommands (`CanalhandiaCommand.java`)**
-  - Implement `/ia persona` / `/ia personalidade` list and player preference switcher (`/ia persona <nome>`).
-  - Implement `/ia persona padrao` to reset preference.
-  - Implement `/ia status` to show active persona, memory summary, and facts.
-  - Implement `/ia esquecer` to clear personal memory.
-  - Update tab-completion for `/ia` with new subcommands and persona keys.
-
- [x] **Task 6: Event Expansion & Plugin Wiring (`Canalhandia.java`)**
-  - Initialize and expose `PlayerMemory` in `Canalhandia.java`.
-  - Expand event triggers in `Canalhandia.java`:
-    - Joins (`onJoinWelcome`) with persona-specific greeting.
-    - Notable deaths & streaks (`onPlayerDeath`) with persona-specific commentary.
-    - Milestone completions (`onMilestone`) with persona-specific recognition.
-
- [x] **Task 7: Verification & Build (`mvn test` & `mvn package`)**
-  - Run full test suite (`mvn test`) ensuring 100% pass rate.
-  - Package final jar (`mvn package`).
-  - Verify all acceptance criteria from `spec.md`.
@@ -1,37 +0,0 @@
-# Plan: Módulo Nativo de Chunk Loader
-
-## Arquitetura
-1. **`ChunkLoader.java` (Record puro)**
-   - `id`, `ownerUuid`, `ownerName`, `world`, `x`, `y`, `z`, `chunkX`, `chunkZ`, `createdAt`.
-   - Métodos utilitários: `chunkCoords()`, `blockCoords()`, etc.
-
-2. **`ChunkLoaders.java` (Gerenciador e Persistência)**
-   - Gerencia lista em memória sincronizada `List<ChunkLoader>`.
-   - Persistência em `plugins/Canalhandia/chunks.yml` com salvamento assíncrono.
-   - Métodos: `add()`, `remove()`, `byChunk()`, `byOwner()`, `loadAll()`, `unloadAll()`, `playerLimit(Player)`.
-   - Executa `world.addPluginChunkTicket` e `world.removePluginChunkTicket`.
-
-3. **`Module.java` & `Settings.java`**
-   - Adiciona `CHUNKLOADER("chunkloader", "Âncoras de carregamento contínuo de chunks")` no enum `Module`.
-   - Adiciona configurações em `Settings.java` (limite padrão, material do bloco, raio de partículas).
-
-4. **`ChunkLoaderListener.java` (Eventos do Mundo)**
-   - `BlockPlaceEvent`: Detecta colocação da Âncora, verifica permissões/limites LuckPerms, registra loader e ticket.
-   - `BlockBreakEvent`: Protege quebra por não-donos, remove ticket e devolve o item customizado.
-   - `BlockExplodeEvent` / `EntityExplodeEvent`: Impede destruição por explosão.
-   - `BlockPistonExtendEvent` / `BlockPistonRetractEvent`: Impede movimentação por pistão.
-
-5. **`CanalhandiaCommand.java` & `ChunkLoaderCommand.java`**
-   - Subcomandos de `/chunkloader` / `/ancora` e tab-completion completo.
-
-6. **`BlueMapBridge.java`**
-   - Cria conjunto de marcadores para chunk loaders no mapa web.
-
-7. **Testes Unitários (`ChunkLoaderTest.java`)**
-   - Validação de regras de permissão, cálculo de limite, serialização em YAML e exclusão de duplicatas na mesma chunk.
-
-## Riscos & Mitigações
- **Risco:** Descarregamento incorreto no shutdown do servidor gerando tickets órfãos.
-  - **Mitigação:** `unloadAll()` limpo em `onDisable()`, e tickets do Paper (`PluginChunkTicket`) são re-validados no `onEnable()`.
- **Risco:** Jogador contornar limite colocando em mundos não permitidos ou múltiplas na mesma chunk.
-  - **Mitigação:** Validação estrita de unicidade de chunk (`byChunk(world, cx, cz) != null`) e verificação de limite antes de aceitar o evento.
@@ -1,72 +0,0 @@
-# Spec: Módulo Nativo de Chunk Loader (Canalhandia)
-
-## 1. Visão Geral
-Adiciona ao plugin `Canalhandia` um módulo nativo, performático e equilibrado de **Chunk Loading** para o Paper 1.21.x.
-Permite que jogadores mantenham áreas/chunks específicas carregadas para farms, redstone e sistemas automatizados usando a API nativa de tickets do Paper (`addPluginChunkTicket`), com permissões granulares e limites por cargo configuráveis via **LuckPerms**.
-
---
-
-## 2. Requisitos e Mecânicas
-
-### 2.1. Bloco e Item Customizado: "Âncora de Chunk" (Chunk Anchor)
- **Item Base:** `RESPAWN_ANCHOR` ou `LODESTONE` com nome formatado (`§b§lÂncora de Chunk`), lore explicativa e `PersistentDataContainer` identificando o item customizado.
- **Receita de Crafting:**
-  - Configurada em `config.yml` (ex: 4 Obsidianas Choronas, 4 Diamantes, 1 Estrela do Nether ou Olho do Fim).
-  - Desbloqueia automaticamente no livro de receitas ao obter os ingredientes.
-
-### 2.2. Colocação e Restrições
- Ao colocar o bloco (`BlockPlaceEvent`):
-  - Verifica se o jogador possui permissão `canalhandia.chunkloader`.
-  - Verifica o limite de loaders do jogador no LuckPerms:
-    - Lê permissões numéricas: `canalhandia.chunkloader.limite.<N>` (ex: `limite.1`, `limite.2`, `limite.5`, `limite.10`).
-    - Pega o maior `<N>` encontrado nas permissões do jogador.
-    - Se não houver permissão numérica explícita, usa `chunkloader.limite-padrao` do `config.yml` (padrão: 1).
-    - Administradores com `canalhandia.admin` não têm limite.
-  - Verifica se já existe um loader ativo na mesma chunk (máximo 1 por chunk).
-  - Se aprovado:
-    - Ativa o ticket na chunk: `world.addPluginChunkTicket(chunkX, chunkZ, plugin)`.
-    - Salva em `chunks.yml`.
-    - Cria partícula/efeito sonoro de ativação.
-    - Registra marcador no BlueMap (opcional/configurável).
-    - Envia mensagem de confirmação informando quantas âncoras o jogador está usando (ex: `1/3 ativas`).
-
-### 2.3. Remoção e Proteção
- **Proteção:** Apenas o dono da âncora ou administradores (`canalhandia.admin`) podem quebrar o bloco (`BlockBreakEvent`).
- **Explosões / Pistões:** Protegido contra destruição acidental por TNT/Creeper (`EntityExplodeEvent`, `BlockExplodeEvent`) e empurrão por pistão (`BlockPistonExtendEvent`).
- Ao quebrar:
-  - Remove o ticket de chunk do Paper: `world.removePluginChunkTicket(chunkX, chunkZ, plugin)`.
-  - Remove de `chunks.yml` e do BlueMap.
-  - Devolve o item "Âncora de Chunk" ao jogador.
-
-### 2.4. Persistência e Ciclo de Vida
- Arquivo `plugins/Canalhandia/chunks.yml`:
-  - Armazena ID, UUID do dono, nome, mundo, coordenadas (x, y, z), chunk (cx, cz) e data de criação.
- **No `onEnable()` do plugin:** Carrega `chunks.yml` e registra `addPluginChunkTicket` em todas as chunks salvas.
- **No `onDisable()` do plugin:** Remove os tickets do plugin de forma limpa.
-
-### 2.5. Comandos (`/chunkloader` ou `/ancora`)
- `/chunkloader` ou `/ancora`:
-  - `/chunkloader info` — Mostra o status da chunk atual (se está carregada por um loader e por quem) e seus limites de uso.
-  - `/chunkloader listar` — Lista todas as âncoras ativas do jogador com coordenadas e link para deletar/desativar.
-  - `/chunkloader remover <id>` — Desativa remotamente uma âncora do próprio jogador.
-  - `/chunkloader receita` — Mostra a receita de crafting.
-  - `/chunkloader admin listar [jogador]` — (Admin) Lista todos os chunk loaders do servidor.
-  - `/chunkloader admin remover <id>` — (Admin) Força a remoção de qualquer loader.
-  - `/chunkloader reload` — (Admin) Recarrega configurações e sincroniza tickets.
-
---
-
-## 3. Integração com LuckPerms
-Nós de permissão:
- `canalhandia.chunkloader` — Habilita o jogador a craftar, colocar e gerenciar âncoras.
- `canalhandia.chunkloader.limite.<N>` — Define o limite máximo de âncoras ativas para o cargo (ex: `canalhandia.chunkloader.limite.3` para VIP).
- `canalhandia.chunkloader.admin` — Acesso total aos comandos administrativos de chunk loading.
-
---
-
-## 4. Critérios de Aceite
-1. Módulo pode ser ativado/desativado via `config.yml` e `/canalhandia modulo chunkloader`.
-2. Bloco colocado registra ticket via `world.addPluginChunkTicket` que sobrevive a reboots via `chunks.yml`.
-3. Limites de permissão do LuckPerms são respeitados estritamente.
-4. Blocos não podem ser roubados ou quebrados por terceiros.
-5. Suíte de testes unitários (`ChunkLoaderTest.java`) com 100% de aprovação.
@@ -1,28 +0,0 @@
-# Tasks: Módulo Nativo de Chunk Loader
-
- [x] **Task 1: Modelo de Dados e Gerenciador (`ChunkLoader.java`, `ChunkLoaders.java` e `ChunkLoaderTest.java`)**
-  - Implementar record `ChunkLoader` puro.
-  - Implementar `ChunkLoaders` com persistência em `chunks.yml`, `playerLimit(Player)` (LuckPerms `canalhandia.chunkloader.limite.<N>`), registro de tickets no Paper e busca por chunk/dono.
-  - Criar suíte de testes unitários `ChunkLoaderTest.java` validando regras de limites, unicidade e serialização.
-
- [x] **Task 2: Configuração e Item Customizado (`Module.java`, `Settings.java` e `ChunkAnchorItem.java`)**
-  - Adicionar `CHUNKLOADER` ao enum `Module`.
-  - Adicionar chaves de configuração em `config.yml` e `Settings.java`.
-  - Criar utilitário `ChunkAnchorItem` para gerar o ItemStack com nome, lore e `PersistentDataContainer`, e registrar receita de crafting.
-
- [x] **Task 3: Listeners de Proteção e Colocação (`ChunkLoaderListener.java`)**
-  - Tratar `BlockPlaceEvent` (validação de permissão, cálculo de limite LuckPerms, ativação de ticket).
-  - Tratar `BlockBreakEvent` (proteção de dono/admin, remoção de ticket, drop do item).
-  - Tratar explosões e pistões.
-
- [x] **Task 4: Comandos e Tab-Completion (`CanalhandiaCommand.java`)**
-  - Adicionar `/chunkloader` e alias `/ancora` (`listar`, `info`, `remover`, `receita`, `admin`).
-  - Implementar tab-completion completo com permissões.
-
- [x] **Task 5: Integração no Ciclo de Vida e BlueMap (`Canalhandia.java` & `BlueMapBridge.java`)**
-  - Inicializar `ChunkLoaders` no `onEnable` e descarregar tickets no `onDisable`.
-  - Adicionar marcadores no BlueMap.
-
- [x] **Task 6: Testes, PR e Deploy (`mvn test`, `mvn package`, PR no Gitea)**
-  - Executar suíte completa de testes.
-  - Criar branch `feat/chunk-loader-module`, abrir PR com labels `AI-REVIEW` e `AI-USAGE`.
@@ -1,23 +0,0 @@
-# Spec: Proteção de Itens no Vácuo (Void Protection)
-
-## 1. Problema e Motivação
-Quando um jogador morre no vácuo (caindo no The End, Nether ou Overworld profundo), todos os itens e armaduras caem abaixo de Y = -64 e são excluídos pelo motor do Minecraft, impossibilitando qualquer recuperação legítima e gerando frustração.
-
-## 2. Solução
-Implementar o módulo `salvavoid` no plugin Canalhandia:
-1. **Detecção:** Identifica mortes por vácuo (`DamageCause.VOID` ou coordenada Y abaixo da altura mínima do mundo).
-2. **Busca de Terreno Seguro:** Procura o bloco sólido mais próximo da posição horizontal onde o jogador caiu (raio configurável, padrão 32 blocos).
-3. **Opção A (Baú de Resgate):** Se encontrar terreno seguro:
-   - Cria um baú (ou baú duplo se necessário) sobre o bloco seguro.
-   - Guarda todos os itens e armaduras do jogador dentro do baú.
-   - Limpa os drops do evento de morte (para não cair no vácuo).
-   - Informa ao jogador a localização exata (coordenadas X, Y, Z) do baú no chat.
-4. **Opção B (Preservação Direta no Inventário):** Se NÃO houver nenhum bloco seguro por perto (ex: caiu no meio do vácuo infinito do End):
-   - Preserva o inventário e nível de XP do jogador (`keepInventory = true`, `keepLevel = true`).
-   - Limpa os drops do evento de morte.
-   - Envia mensagem confortando o jogador e avisando que os itens foram mantidos no inventário.
-
-## 3. Critérios de Aceitação
- Módulo integrado ao `/canalhandia modulo salvavoid <on|off>`.
- Configurações em `Settings.java`: `voidProtectionEnabled`, `voidProtectionRadius`, `voidProtectionKeepXp`.
- Testes unitários cobrindo detecção de morte no vácuo, cálculo de busca e empacotamento de inventário.
@@ -159,17 +159,6 @@ final class Achievements {
                .append(Component.text(" — " + achievement.description(), NamedTextColor.GRAY)
                        .decoration(TextDecoration.BOLD, false)));
        plugin.getLogger().info("[conquistas] " + player.getName() + " → " + achievement.key());
-
-        if (plugin.settings().aiEvents() && plugin.settings().moduleEnabled(Module.IA)) {
-            Persona persona = plugin.playerMemory() != null
-                    ? plugin.playerMemory().persona(player.getUniqueId(), plugin.settings().aiPersona())
-                    : plugin.settings().aiPersona();
-            plugin.ai().saySomething(player.getName(),
-                    "O jogador " + player.getName() + " desbloqueou a conquista \""
-                            + achievement.title() + "\" (" + achievement.description()
-                            + "). Faça um breve comentário na sua personalidade.",
-                    plugin.aiBudget(), persona);
-        }
    }

    /** Which achievements this player has already unlocked. */
@@ -238,16 +238,12 @@ final class Ai {
            return;
        }

-        Persona persona = plugin.playerMemory() != null
-                ? plugin.playerMemory().persona(asker.getUniqueId(), settings.aiPersona())
-                : settings.aiPersona();
-
        lastAsk.put(asker.getUniqueId(), System.currentTimeMillis());
        pending.put(asker.getUniqueId(), true);
        askedToday++;

        if (!isPrivate && settings.aiPublic()) {
-            Bukkit.broadcast(Msg.tag(persona.displayTag(), persona.tagColor())
+            Bukkit.broadcast(Msg.tag("IA", NamedTextColor.LIGHT_PURPLE)
                    .append(Component.text(asker.getName() + " perguntou: ", NamedTextColor.GRAY)
                            .decoration(TextDecoration.BOLD, false))
                    .append(Component.text(question, NamedTextColor.WHITE)
@@ -258,7 +254,6 @@ final class Ai {
        String prompt = question;
        UUID id = asker.getUniqueId();
        final boolean isPriv = isPrivate;
-        final Persona effectivePersona = persona;

        // Captured HERE, on the main thread, because both read the Bukkit world
        // and player API. The async body below only ever sees the resulting
@@ -266,15 +261,12 @@ final class Ai {
        // bug that shows up as rare, confusing world-state corruption.
        final String liveState = settings.aiServerState() ? ServerState.snapshot(asker) : null;
        final String chatContext = plugin.chatLog().formatRecent(settings.aiChatContextLines());
-        final String memoryContext = plugin.playerMemory() != null
-                ? plugin.playerMemory().formatContext(asker.getUniqueId())
-                : null;

        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
            String answer = null;
            try {
                java.util.List<MiniMax.Turn> messages =
-                        compose(asker, prompt, settings, effectivePersona, liveState, chatContext, memoryContext);
+                        compose(asker, prompt, settings, liveState, chatContext);

                if (settings.aiTools()) {
                    // Agentic path: the model pulls what it needs (web search,
@@ -294,8 +286,8 @@ final class Ai {
                        Wiki.Article article = term == null ? null : wiki.lookup(term);
                        if (article != null) {
                            messages.add(messages.size() - 1, new MiniMax.Turn("system",
-                                     "Artigo da Minecraft Wiki pt-BR — '" + article.title() + "':\n"
-                                             + article.text()));
+                                    "Artigo da Minecraft Wiki pt-BR — '" + article.title() + "':\n"
+                                            + article.text()));
                        }
                    }

@@ -328,7 +320,7 @@ final class Ai {
            String finalAnswer = answer;
            Bukkit.getScheduler().runTask(plugin, () -> {
                pending.remove(id);
-                deliver(id, prompt, finalAnswer, settings, effectivePersona, isPriv);
+                deliver(id, prompt, finalAnswer, settings, isPriv);
            });
        });
    }
@@ -341,7 +333,7 @@ final class Ai {
     * drops tables), the conversation history, then the question itself.
     */
    private java.util.List<MiniMax.Turn> compose(Player asker, String question, Settings settings,
-            Persona persona, String liveState, String chatContext, String memoryContext) {
+            String liveState, String chatContext) {
        java.util.List<MiniMax.Turn> messages = new java.util.ArrayList<>();
        messages.add(new MiniMax.Turn("system", settings.aiInstructions()));

@@ -349,17 +341,13 @@ final class Ai {
        // safety rules above are read first and the persona is decoration on
        // top of them, never a replacement for them (Persona.GUARD restates the
        // limits inside the persona's own frame as a second layer).
-        messages.add(new MiniMax.Turn("system", persona.systemText()));
+        messages.add(new MiniMax.Turn("system", settings.aiPersona().systemText()));

        String serverContext = settings.aiServerContext();
        if (!serverContext.isBlank()) {
            messages.add(new MiniMax.Turn("system", "Sobre este servidor: " + serverContext));
        }

-        if (memoryContext != null && !memoryContext.isBlank()) {
-            messages.add(new MiniMax.Turn("system", memoryContext));
-        }
-
        // The asker's own stats, so "quantos blocos eu minerei?" gets a real
        // number instead of "não tenho acesso ao servidor". ~30 tokens; gated
        // by ia.estatisticas-jogador so an operator can turn it off. Stale by
@@ -421,7 +409,7 @@ final class Ai {
    }

    private void deliver(UUID askerId, String question, String answer,
-            Settings settings, Persona persona, boolean isPrivate) {
+            Settings settings, boolean isPrivate) {
        Player asker = Bukkit.getPlayer(askerId);
        if (answer == null || answer.isBlank()) {
            if (asker != null) {
@@ -437,27 +425,20 @@ final class Ai {
            return;
        }
        String clean = String.join(" ", segments);
-        lastAnswer = new Answered(askerId, question, clean);
        // Only remember if the asker is still online: a PlayerQuitEvent forgets
        // the player's history (carry-forward #6), and re-adding here after the
        // quit would resurrect it. lastAnswer stays regardless, so /ia corrigir
        // can still correct the last answer even after the asker left.
        if (asker != null) {
            conversations.remember(askerId, question, clean);
-            if (plugin.playerMemory() != null) {
-                try {
-                    plugin.playerMemory().recordTurn(askerId, asker.getName(), question, clean);
-                } catch (RuntimeException e) {
-                    plugin.getLogger().warning("Falha ao gravar memória da IA para " + asker.getName() + ": " + e);
-                }
-            }
        }
+        lastAnswer = new Answered(askerId, question, clean);

        if (isPrivate || !settings.aiPublic()) {
            if (asker != null) {
                boolean bedrock = Platform.isBedrock(asker);
                for (int i = 0; i < segments.size(); i++) {
-                    asker.sendMessage(style(segments.get(i), question, persona, settings.aiFancy(), bedrock, i == 0));
+                    asker.sendMessage(style(segments.get(i), question, settings, bedrock, i == 0));
                }
            }
            return;
@@ -469,32 +450,48 @@ final class Ai {
        for (int i = 0; i < segments.size(); i++) {
            String segment = segments.get(i);
            boolean first = i == 0;
-            plugin.broadcastPerPlatform(bedrock -> style(segment, question, persona, settings.aiFancy(), bedrock, first));
+            plugin.broadcastPerPlatform(bedrock -> style(segment, question, settings, bedrock, first));
        }
        plugin.openAiReactions(askerId);
    }

    /**
     * Renders one answer for chat.
+     *
+     * <p>Java players get a hover card naming the persona and the question that
+     * produced the answer, plus a click that pre-fills {@code /ia } so a
+     * follow-up is one keystroke away — {@code suggestCommand}, never
+     * {@code runCommand}, so nothing executes without the player pressing enter.
+     *
+     * <p>Bedrock gets the same text with no hover and no click, because it
+     * renders neither; the styling is decoration and its absence costs nothing.
+     * {@code ia.estilo-rico: false} forces the plain form everywhere.
+     *
+     * <p>A long or list-shaped answer arrives as several segments ({@link
+     * AiText#segments}); the first carries the full {@code [IA]} tag, the rest
+     * carry a plain grey continuation mark instead of repeating the tag on
+     * every line, so a five-item list reads as one grouped answer rather than
+     * five separate IA replies.
     */
-    static Component style(String answer, String question, Persona persona, boolean fancy, boolean bedrock, boolean firstLine) {
+    private Component style(String answer, String question, Settings settings, boolean bedrock, boolean firstLine) {
        Component body = Component.text(answer, NamedTextColor.WHITE)
                .decoration(TextDecoration.BOLD, false);
-        if (!bedrock && fancy) {
+        if (!bedrock && settings.aiFancy()) {
+            Persona persona = settings.aiPersona();
            body = body
                    .hoverEvent(net.kyori.adventure.text.event.HoverEvent.showText(
                            Component.text("Pergunta: ", NamedTextColor.GRAY)
-                                     .append(Component.text(AiText.forLog(question), NamedTextColor.WHITE))
-                                     .append(Component.newline())
-                                     .append(Component.text("Personalidade: ", NamedTextColor.GRAY))
-                                     .append(Component.text(persona.displayName(), persona.tagColor()))
-                                     .append(Component.newline())
-                                     .append(Component.text("Clique para perguntar outra coisa",
-                                             NamedTextColor.DARK_GRAY))))
+                                    .append(Component.text(AiText.forLog(question), NamedTextColor.WHITE))
+                                    .append(Component.newline())
+                                    .append(Component.text("Personalidade: ", NamedTextColor.GRAY))
+                                    .append(Component.text(persona.key(), NamedTextColor.LIGHT_PURPLE))
+                                    .append(Component.newline())
+                                    .append(Component.text("Clique para perguntar outra coisa",
+                                            NamedTextColor.DARK_GRAY))))
                    .clickEvent(net.kyori.adventure.text.event.ClickEvent.suggestCommand("/ia "));
        }
        Component prefix = firstLine
-                ? Msg.tag(persona.displayTag(), persona.tagColor())
+                ? Msg.tag("IA", NamedTextColor.LIGHT_PURPLE)
                : Component.text("   » ", NamedTextColor.DARK_GRAY);
        return prefix.append(body);
    }
@@ -504,15 +501,18 @@ final class Ai {
    /**
     * Says something unprompted, in the active persona — a jab at a death
     * streak, a greeting for someone who just joined.
+     *
+     * <p>Everything about this is deliberately more restricted than {@code /ia}:
+     * it is gated by {@link Budget} (see the reasons there), it never consults
+     * the wiki, it asks for a much smaller answer, and it is silent on failure.
+     * A spontaneous line that errors should leave no trace — nobody asked for
+     * it, so nobody should see it fail.
+     *
+     * @param subject the player it is about, for the per-subject cooldown; may
+     *     be null
+     * @param prompt what to comment on, already phrased as an instruction
     */
    void saySomething(String subject, String prompt, Budget budget) {
-        saySomething(subject, prompt, budget, null);
-    }
-
-    /**
-     * Says something unprompted with an optional specific persona override.
-     */
-    void saySomething(String subject, String prompt, Budget budget, Persona customPersona) {
        Settings settings = plugin.settings();
        if (!settings.moduleEnabled(Module.IA)) {
            return;
@@ -530,11 +530,9 @@ final class Ai {
        // exact double-message the gap exists to prevent.
        budget.spend(subject, now);

-        Persona persona = customPersona != null ? customPersona : settings.aiPersona();
-
        java.util.List<MiniMax.Turn> messages = new java.util.ArrayList<>();
        messages.add(new MiniMax.Turn("system", settings.aiInstructions()));
-        messages.add(new MiniMax.Turn("system", persona.systemText()));
+        messages.add(new MiniMax.Turn("system", settings.aiPersona().systemText()));
        String serverContext = settings.aiServerContext();
        if (!serverContext.isBlank()) {
            messages.add(new MiniMax.Turn("system", "Sobre este servidor: " + serverContext));
@@ -562,7 +560,7 @@ final class Ai {
                return;
            }
            Bukkit.getScheduler().runTask(plugin, () -> Bukkit.broadcast(
-                    Msg.tag(persona.displayTag(), persona.tagColor())
+                    Msg.tag("IA", NamedTextColor.LIGHT_PURPLE)
                            .append(Component.text(clean, NamedTextColor.WHITE)
                                    .decoration(TextDecoration.BOLD, false))));
        });
@@ -27,26 +27,18 @@ final class BlueMapBridge {
    /** Id and label of the marker set this plugin owns on the map. */
    private static final String SET_ID = "canalhandia-notas";
    private static final String SET_LABEL = "Anotações";
-    private static final String SET_LOADERS_ID = "canalhandia-chunkloaders";
-    private static final String SET_LOADERS_LABEL = "Âncoras de Chunk";

    private final Notes notes;
-    private final java.util.function.Supplier<ChunkLoaders> chunkLoaders;
    private final Logger logger;
    private final java.util.function.BooleanSupplier enabled;
-    private final java.util.function.BooleanSupplier chunkLoadersEnabled;

    /** False once we know BlueMap is not usable, so we stop retrying. */
    private boolean available = true;

-    BlueMapBridge(Notes notes, java.util.function.Supplier<ChunkLoaders> chunkLoaders,
-                  Logger logger, java.util.function.BooleanSupplier enabled,
-                  java.util.function.BooleanSupplier chunkLoadersEnabled) {
+    BlueMapBridge(Notes notes, Logger logger, java.util.function.BooleanSupplier enabled) {
        this.notes = notes;
-        this.chunkLoaders = chunkLoaders;
        this.logger = logger;
        this.enabled = enabled;
-        this.chunkLoadersEnabled = chunkLoadersEnabled;
    }

    /**
@@ -55,19 +47,20 @@ final class BlueMapBridge {
     */
    void hook() {
        try {
-            de.bluecolored.bluemap.api.BlueMapAPI.onEnable(api -> {
-                sync();
-                syncChunkLoaders();
-            });
-            logger.info("BlueMap encontrado — marcadores vão para o mapa.");
+            de.bluecolored.bluemap.api.BlueMapAPI.onEnable(api -> sync());
+            logger.info("BlueMap encontrado — anotações públicas vão para o mapa.");
        } catch (NoClassDefFoundError | Exception e) {
            available = false;
-            logger.fine("BlueMap não está instalado; marcadores desativados.");
+            logger.fine("BlueMap não está instalado; anotações ficam só no chat.");
        }
    }

    /**
     * Rebuilds the marker set from the current public notes.
+     *
+     * <p>Rebuild rather than incremental add/remove: the note list is tiny, and
+     * a full rebuild cannot drift out of sync with the notes file the way a
+     * missed delete would.
     */
    void sync() {
        if (!available || !enabled.getAsBoolean()) {
@@ -86,6 +79,9 @@ final class BlueMapBridge {
                        .label(SET_LABEL)
                        .build();
                for (Note note : publicNotes) {
+                    // Only notes from the world this map renders. Without the
+                    // check, a Nether note would be drawn at the same numeric
+                    // coordinates in the overworld map, pointing at nothing.
                    if (!sameWorld(map, note.world())) {
                        continue;
                    }
@@ -100,66 +96,13 @@ final class BlueMapBridge {
                map.getMarkerSets().put(SET_ID, set);
            }
        } catch (NoClassDefFoundError | Exception e) {
+            // One line, then stop trying: a broken bridge must never turn into
+            // a log flood on every note edit.
            available = false;
            logger.warning("Não consegui atualizar os marcadores do BlueMap: " + e);
        }
    }

-    void syncChunkLoaders() {
-        if (!available || !chunkLoadersEnabled.getAsBoolean() || chunkLoaders == null) {
-            return;
-        }
-        ChunkLoaders loaders = chunkLoaders.get();
-        if (loaders == null) {
-            return;
-        }
-        try {
-            var maybeApi = de.bluecolored.bluemap.api.BlueMapAPI.getInstance();
-            if (maybeApi.isEmpty()) {
-                return;
-            }
-            var api = maybeApi.get();
-            for (var map : api.getMaps()) {
-                var set = de.bluecolored.bluemap.api.markers.MarkerSet.builder()
-                        .label(SET_LOADERS_LABEL)
-                        .build();
-                for (ChunkLoader loader : loaders.all()) {
-                    if (!mapMatchesWorld(map, loader.world())) {
-                        continue;
-                    }
-                    String statusHtml = loader.enabled()
-                            ? "<span style='color:#55ff55'>Ativo</span>"
-                            : "<span style='color:#ff5555'>Pausado</span>";
-                    var marker = de.bluecolored.bluemap.api.markers.POIMarker.builder()
-                            .label(loader.simpleName() + " (" + loader.ownerName() + ")" + (loader.enabled() ? "" : " [Pausado]"))
-                            .detail("<b>" + escape(loader.displayName()) + "</b><br>Status: "
-                                    + statusHtml + "<br>Dono: "
-                                    + escape(loader.ownerName()) + "<br>Chunk: " + loader.chunkCoords())
-                            .position(loader.x(), loader.y(), loader.z())
-                            .build();
-                    set.getMarkers().put("loader-" + loader.id(), marker);
-                }
-                map.getMarkerSets().put(SET_LOADERS_ID, set);
-            }
-        } catch (NoClassDefFoundError | Exception ignored) {
-        }
-    }
-
-    private boolean mapMatchesWorld(de.bluecolored.bluemap.api.BlueMapMap map, String world) {
-        if (world == null || world.isBlank()) {
-            return false;
-        }
-        String mapId = map.getId().toLowerCase(java.util.Locale.ROOT);
-        String w = world.toLowerCase(java.util.Locale.ROOT);
-        if (w.endsWith("_nether") || w.equals("nether") || w.equals("world_nether")) {
-            return mapId.contains("nether");
-        }
-        if (w.endsWith("_the_end") || w.equals("the_end") || w.equals("world_the_end") || w.equals("end")) {
-            return mapId.contains("end");
-        }
-        return !mapId.contains("nether") && !mapId.contains("end");
-    }
-
    /**
     * Whether a map renders the world a note was written in.
     *
@@ -85,8 +85,6 @@ public final class Canalhandia extends JavaPlugin implements Listener {
    private Milestones milestones;
    private Achievements achievements;
    private WeeklyStats weeklyStats;
-    private PlayerMemory playerMemory;
-    private ChunkLoaders chunkLoaders;
    /** Gate for spontaneous AI lines; see Budget for why this is strict. */
    private Budget aiBudget;
    private BlueMapBridge blueMap;
@@ -127,21 +125,13 @@ public final class Canalhandia extends JavaPlugin implements Listener {
        achievements.syncCatalogue();
        milestones.resyncSilently();
        weeklyStats = new WeeklyStats(new java.io.File(getDataFolder(), "semana.yml"));
-        playerMemory = new PlayerMemory(new java.io.File(getDataFolder(), "ia-memoria.yml"));
-        chunkLoaders = new ChunkLoaders(this, new java.io.File(getDataFolder(), "chunks.yml"));
-        if (settings.moduleEnabled(Module.CHUNKLOADER)) {
-            chunkLoaders.loadAllTickets();
-            chunkLoaders.startSimulation();
-            ChunkAnchorItem.registerRecipe(this);
-        }
        aiBudget = new Budget(settings.aiSpontaneousPerDay(),
                settings.aiSpontaneousGapMinutes() * 60_000L,
                settings.aiSubjectCooldownMinutes() * 60_000L);
        ai = new Ai(this);
        // Optional: does nothing (and logs nothing loud) without BlueMap.
-        blueMap = new BlueMapBridge(notes, () -> chunkLoaders, getLogger(),
-                () -> settings.moduleEnabled(Module.NOTAS) && settings.notesOnMap(),
-                () -> settings.moduleEnabled(Module.CHUNKLOADER) && settings.chunkLoaderBlueMap());
+        blueMap = new BlueMapBridge(notes, getLogger(),
+                () -> settings.moduleEnabled(Module.NOTAS) && settings.notesOnMap());
        blueMap.hook();
        // Snapshot the server's recipes on the main thread; RecipeBook.describe
        // reads from the async answer path and Bukkit.recipeIterator() is not
@@ -154,13 +144,12 @@ public final class Canalhandia extends JavaPlugin implements Listener {
        for (String name : List.of("canalhandia", "curiosidade", "adivinha", "enquete", "ranking",
                "reagir", "reacoes", "palpite", "votar", "legal", "wow", "top", "f", "ia", "iap",
                "errado", "nota", "save", "recado", "recados", "mortes", "conquistas",
-                "perfil", "titulo", "chunkloader")) {
+                "perfil", "titulo")) {
            register(name, root);
        }

        getServer().getPluginManager().registerEvents(this, this);
        getServer().getPluginManager().registerEvents(new TitleChatListener(this), this);
-        getServer().getPluginManager().registerEvents(new ChunkLoaderListener(this), this);
        rescheduleTimer();
        rescheduleMilestones();

@@ -192,12 +181,6 @@ public final class Canalhandia extends JavaPlugin implements Listener {
        if (poll != null) {
            poll.hide();
        }
-        if (chunkLoaders != null) {
-            chunkLoaders.stopSimulation();
-            chunkLoaders.unloadAllTickets();
-            chunkLoaders.close();
-            ChunkAnchorItem.unregisterRecipe(this);
-        }
    }

    Settings settings() {
@@ -212,11 +195,6 @@ public final class Canalhandia extends JavaPlugin implements Listener {
        return ai;
    }

-    /** Persistent player memory and personal AI settings. Never null. */
-    PlayerMemory playerMemory() {
-        return playerMemory;
-    }
-
    /** Recent public chat, for the AI's ambient context. Never null. */
    ChatLog chatLog() {
        return chatLog;
@@ -242,11 +220,6 @@ public final class Canalhandia extends JavaPlugin implements Listener {
        return achievements;
    }

-    /** Active chunk loaders. Never null. */
-    ChunkLoaders chunkLoaders() {
-        return chunkLoaders;
-    }
-
    /** The title each player has chosen to wear in chat. Never null. */
    Titles titles() {
        return titles;
@@ -694,14 +667,11 @@ public final class Canalhandia extends JavaPlugin implements Listener {
                return;
            }
            String stats = offlineStats.summary(player.getUniqueId());
-            Persona persona = playerMemory != null
-                    ? playerMemory.persona(player.getUniqueId(), settings.aiPersona())
-                    : settings.aiPersona();
            ai.saySomething(player.getName(),
                    "O jogador " + player.getName() + " acabou de entrar no servidor."
                            + (stats == null ? "" : " Estatísticas dele: " + stats)
-                            + " Dê as boas-vindas do seu jeito e na sua personalidade, em uma frase curta.",
-                    aiBudget, persona);
+                            + " Dê as boas-vindas do seu jeito, em uma frase.",
+                    aiBudget);
        }, Math.max(1, settings.joinDelaySeconds()) * 20L);
    }

@@ -839,60 +809,6 @@ public final class Canalhandia extends JavaPlugin implements Listener {
        }, settings.reactionWindowSeconds() * 20L);
    }

-    /**
-     * Rescues player items when falling into the void. Places a chest on the nearest
-     * safe ground block, or preserves items directly in the inventory if no solid ground is nearby.
-     */
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onVoidDeath(PlayerDeathEvent event) {
-        if (!settings.moduleEnabled(Module.SALVAVOID)) {
-            return;
-        }
-        Player player = event.getEntity();
-        EntityDamageEvent damage = player.getLastDamageCause();
-        EntityDamageEvent.DamageCause cause = damage == null ? null : damage.getCause();
-
-        if (!VoidProtection.isVoidDeath(player.getLocation().getY(), player.getWorld().getMinHeight(), cause)) {
-            return;
-        }
-
-        List<ItemStack> drops = new ArrayList<>(event.getDrops());
-        Location safeLoc = VoidProtection.findSafeChestLocation(player.getWorld(), player.getLocation(), settings.voidProtectionRadius());
-
-        if (safeLoc != null && !drops.isEmpty() && VoidProtection.rescueToChest(drops, safeLoc)) {
-            event.getDrops().clear();
-            if (settings.voidProtectionKeepXp()) {
-                event.setKeepLevel(true);
-                event.setDroppedExp(0);
-            }
-            int x = safeLoc.getBlockX();
-            int y = safeLoc.getBlockY();
-            int z = safeLoc.getBlockZ();
-            getServer().getScheduler().runTaskLater(this, () -> {
-                if (player.isOnline()) {
-                    player.sendMessage(Component.text("[Canalhandia] ", NamedTextColor.GOLD)
-                            .append(Component.text("Você caiu no vácuo! Seus itens foram guardados em segurança num baú em ", NamedTextColor.YELLOW))
-                            .append(Component.text(x + ", " + y + ", " + z, NamedTextColor.AQUA, TextDecoration.BOLD))
-                            .append(Component.text(".", NamedTextColor.YELLOW)));
-                }
-            }, 20L);
-        } else {
-            // No safe ground found within radius: keep inventory directly
-            event.setKeepInventory(true);
-            event.getDrops().clear();
-            if (settings.voidProtectionKeepXp()) {
-                event.setKeepLevel(true);
-                event.setDroppedExp(0);
-            }
-            getServer().getScheduler().runTaskLater(this, () -> {
-                if (player.isOnline()) {
-                    player.sendMessage(Component.text("[Canalhandia] ", NamedTextColor.GOLD)
-                            .append(Component.text("Você caiu no vácuo sem terra firme por perto! Seus itens foram mantidos no seu inventário.", NamedTextColor.GREEN)));
-                }
-            }, 20L);
-        }
-    }
-
    /**
     * Comic death broadcast + private coordinates, gated by the {@code mortes}
     * module. Replaces the vanilla translatable death message with a pt-BR
@@ -936,7 +852,7 @@ public final class Canalhandia extends JavaPlugin implements Listener {
        Location loc = player.getLocation();
        String coords = loc.getBlockX() + " " + loc.getBlockY() + " " + loc.getBlockZ()
                + " (" + loc.getWorld().getName() + ")";
-        boolean keepInventory = event.getKeepInventory() || Boolean.TRUE.equals(
+        boolean keepInventory = Boolean.TRUE.equals(
                loc.getWorld().getGameRuleValue(GameRule.KEEP_INVENTORY));
        pendingDeathCoords.put(player.getUniqueId(), new DeathCoords(coords, keepInventory));

@@ -957,14 +873,11 @@ public final class Canalhandia extends JavaPlugin implements Listener {
        deathStreak.put(player.getUniqueId(), new Streak(count, now));

        if (settings.aiEvents() && count >= settings.aiDeathStreak()) {
-            Persona persona = playerMemory != null
-                    ? playerMemory.persona(player.getUniqueId(), settings.aiPersona())
-                    : settings.aiPersona();
            ai.saySomething(player.getName(),
                    "O jogador " + player.getName() + " morreu " + count
                            + " vezes seguidas em poucos minutos. A última foi assim: " + flavor
-                            + ". Comente na sua personalidade, sem ofender de verdade.",
-                    aiBudget, persona);
+                            + ". Comente com deboche, sem ofender.",
+                    aiBudget);
            // Reset so the next comment needs a fresh run rather than firing on
            // every death from here on.
            deathStreak.remove(player.getUniqueId());
@@ -5,14 +5,11 @@ import net.kyori.adventure.text.event.ClickEvent;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabCompleter;
 import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;

 import java.util.ArrayList;
 import java.util.Arrays;
@@ -65,7 +62,6 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
            case "conquistas" -> conquistas(sender, args);
            case "perfil" -> perfil(sender, args);
            case "titulo" -> titulo(sender, args);
-            case "chunkloader", "ancora", "ancoras", "chunkloaders" -> chunkloader(sender, args);
            // Typed twin of the [F] mourning button — "f" is not a configured
            // reaction (the mourning set is hardcoded), so it can't be found via
            // reactionForCommand; route it directly. Acts on the latest message,
@@ -567,18 +563,6 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
        }
        boolean on = args[1].equalsIgnoreCase("on");
        plugin.settings().moduleEnabled(module, on);
-        if (module == Module.CHUNKLOADER) {
-            if (on) {
-                plugin.chunkLoaders().loadAllTickets();
-                plugin.chunkLoaders().startSimulation();
-                ChunkAnchorItem.registerRecipe(plugin);
-            } else {
-                plugin.chunkLoaders().stopSimulation();
-                plugin.chunkLoaders().unloadAllTickets();
-                ChunkAnchorItem.unregisterRecipe(plugin);
-            }
-            plugin.blueMap().syncChunkLoaders();
-        }
        plugin.rescheduleTimer();
        plugin.rescheduleMilestones();
        Msg.ok(sender, "Módulo " + module.label() + " " + (on ? "ativado" : "desativado") + ".");
@@ -983,28 +967,10 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
                iaCorrect(sender, args);
                return true;
            }
-            if (sub.equals("status")) {
-                iaStatus(sender);
-                return true;
-            }
-            if (sub.equals("esquecer") || sub.equals("limpar")) {
-                iaForget(sender);
-                return true;
-            }
-            if (sub.equals("lembrar") && args.length >= 2) {
-                String fact = String.join(" ", Arrays.copyOfRange(args, 1, args.length)).trim();
-                if (!fact.isBlank() && plugin.playerMemory() != null) {
-                    plugin.playerMemory().addFact(player.getUniqueId(), player.getName(), fact);
-                    Msg.ok(sender, "Fato gravado na memória da sua IA: \"" + fact + "\"");
-                    return true;
-                }
-            }
-            // Personalities: player can switch for themselves (/ia persona <nome>)
-            // or reset to default (/ia persona padrao).
-            if ((sub.equals("personalidade") || sub.equals("persona"))
-                    && (args.length == 1 || args[1].equalsIgnoreCase("padrao")
-                            || args[1].equalsIgnoreCase("reset") || args[1].equalsIgnoreCase("global")
-                            || Persona.isValid(args[1]))) {
+            // Same guard as "perfil": only hijack when the next token is a real
+            // persona name, so "/ia personalidade do zumbi?" stays a question.
+            if (sub.equals("personalidade")
+                    && (args.length == 1 || Persona.isValid(args[1]))) {
                iaPersona(sender, args);
                return true;
            }
@@ -1059,138 +1025,33 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
    }

    /**
-     * {@code /ia persona [nome]} or {@code /ia personalidade [nome]}.
-     * Players can choose their personal AI persona or reset to server default.
-     * Operators can set global default with {@code /ia persona global <nome>}.
+     * {@code /ia personalidade [nome]} — shows the current tone, or switches it.
+     * Gated on {@code canalhandia.ia.perfil}, the same permission that controls
+     * the other AI-tuning switch: both change how the AI behaves for everyone,
+     * so they belong to the same set of people.
     */
    private void iaPersona(CommandSender sender, String[] args) {
-        Player player = sender instanceof Player p ? p : null;
-        Persona globalDefault = plugin.settings().aiPersona();
-        Persona current = player != null && plugin.playerMemory() != null
-                ? plugin.playerMemory().persona(player.getUniqueId(), globalDefault)
-                : globalDefault;
-        Persona rawPersonal = player != null && plugin.playerMemory() != null
-                ? plugin.playerMemory().rawPersona(player.getUniqueId())
-                : null;
-
+        if (!sender.hasPermission("canalhandia.ia.perfil")) {
+            denied(sender);
+            return;
+        }
+        Persona current = plugin.settings().aiPersona();
        if (args.length < 2) {
            Msg.header(sender, "Personalidades da IA");
            for (Persona persona : Persona.values()) {
-                String marker = persona == current ? "» " : "  ";
-                Msg.line(sender, marker + persona.displayName() + " (" + persona.key() + ")",
+                Msg.line(sender, (persona == current ? "> " : "  ") + persona.key(),
                        persona.description());
            }
-            if (player != null) {
-                String status = rawPersonal == null
-                        ? "padrão do servidor (" + globalDefault.displayName() + ")"
-                        : "personalizada (" + rawPersonal.displayName() + ")";
-                Msg.ok(sender, "Sua IA ativa: " + current.displayName() + " — " + status);
-                Msg.ok(sender, "Para escolher: /ia persona <nome>  |  Para resetar: /ia persona padrao");
-            } else {
-                Msg.ok(sender, "Padrão global: " + globalDefault.displayName() + ". Uso: /ia persona <nome>");
-            }
+            Msg.ok(sender, "Atual: " + current.key() + ". Uso: /ia personalidade <nome>");
            return;
        }
-
-        String target = args[1].toLowerCase(Locale.ROOT);
-
-        if (target.equals("padrao") || target.equals("reset") || target.equals("limpar")) {
-            if (player == null) {
-                Msg.error(sender, "Comando exclusivo para jogadores.");
-                return;
-            }
-            if (plugin.playerMemory() != null) {
-                plugin.playerMemory().resetPersona(player.getUniqueId());
-            }
-            Msg.ok(sender, "Sua IA voltou para a personalidade padrão do servidor ("
-                    + globalDefault.displayName() + ").");
+        Persona persona = Persona.byKey(args[1]);
+        if (persona == null) {
+            Msg.error(sender, "Personalidade desconhecida. Use /ia personalidade para ver a lista.");
            return;
        }
-
-        if (target.equals("global")) {
-            if (!sender.hasPermission("canalhandia.ia.perfil")) {
-                denied(sender);
-                return;
-            }
-            if (args.length < 3) {
-                Msg.error(sender, "Uso: /ia persona global <nome>");
-                return;
-            }
-            Persona p = Persona.byKey(args[2]);
-            if (p == null) {
-                Msg.error(sender, "Personalidade desconhecida. Use /ia persona para ver a lista.");
-                return;
-            }
-            plugin.settings().aiPersona(p);
-            Msg.ok(sender, "Personalidade global da IA alterada para: " + p.displayName()
-                    + " — " + p.description());
-            return;
-        }
-
-        Persona chosen = Persona.byKey(target);
-        if (chosen == null) {
-            Msg.error(sender, "Personalidade desconhecida. Use /ia persona para ver a lista.");
-            return;
-        }
-
-        if (player != null && plugin.playerMemory() != null) {
-            plugin.playerMemory().setPersona(player.getUniqueId(), player.getName(), chosen);
-            Msg.ok(sender, "Sua personalidade da IA foi definida para: " + chosen.displayName()
-                    + " — " + chosen.description());
-        } else {
-            if (sender.hasPermission("canalhandia.ia.perfil")) {
-                plugin.settings().aiPersona(chosen);
-                Msg.ok(sender, "Personalidade global da IA: " + chosen.displayName());
-            } else {
-                denied(sender);
-            }
-        }
-    }
-
-    private void iaStatus(CommandSender sender) {
-        if (!(sender instanceof Player player)) {
-            Msg.header(sender, "Status da IA (Servidor)");
-            Msg.line(sender, "Perguntas hoje", String.valueOf(plugin.ai().askedToday()));
-            Msg.line(sender, "Feedbacks negativos", String.valueOf(plugin.ai().feedbackWrong()));
-            Msg.line(sender, "Personalidade global", plugin.settings().aiPersona().displayName());
-            return;
-        }
-
-        Persona global = plugin.settings().aiPersona();
-        Persona active = plugin.playerMemory() != null
-                ? plugin.playerMemory().persona(player.getUniqueId(), global)
-                : global;
-        Persona raw = plugin.playerMemory() != null
-                ? plugin.playerMemory().rawPersona(player.getUniqueId())
-                : null;
-
-        Msg.header(sender, "Status da sua IA");
-        Msg.line(sender, "Personalidade", active.displayName()
-                + (raw == null ? " (padrão do servidor)" : " (personalizada)"));
-
-        if (plugin.playerMemory() != null) {
-            String summary = plugin.playerMemory().summary(player.getUniqueId());
-            if (summary != null && !summary.isBlank()) {
-                Msg.line(sender, "Memória recente", summary);
-            }
-            List<String> facts = plugin.playerMemory().facts(player.getUniqueId());
-            if (!facts.isEmpty()) {
-                Msg.line(sender, "Fatos conhecidos", String.join("; ", facts));
-            }
-        }
-        Msg.ok(sender, "Para trocar de IA: /ia persona <nome>  |  Para limpar memória: /ia esquecer");
-    }
-
-    private void iaForget(CommandSender sender) {
-        if (!(sender instanceof Player player)) {
-            Msg.error(sender, "Comando exclusivo para jogadores.");
-            return;
-        }
-        if (plugin.playerMemory() != null) {
-            plugin.playerMemory().clearHistory(player.getUniqueId());
-        }
-        plugin.ai().conversations().forget(player.getUniqueId());
-        Msg.ok(sender, "A memória da IA sobre você foi limpa.");
+        plugin.settings().aiPersona(persona);
+        Msg.ok(sender, "Personalidade da IA: " + persona.key() + " — " + persona.description());
    }

    // --- /nota and /save ----------------------------------------------------
@@ -1799,443 +1660,6 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
        return true;
    }

-    // --- /chunkloader -------------------------------------------------------
-
-    private boolean chunkloader(CommandSender sender, String[] args) {
-        if (!plugin.settings().moduleEnabled(Module.CHUNKLOADER)) {
-            Msg.error(sender, "O módulo de Âncoras de Chunk está desativado.");
-            return true;
-        }
-        if (!sender.hasPermission("canalhandia.chunkloader")) {
-            return denied(sender);
-        }
-
-        if (args.length == 0) {
-            return chunkloaderHelp(sender);
-        }
-
-        String sub = args[0].toLowerCase(Locale.ROOT);
-        String[] rest = Arrays.copyOfRange(args, 1, args.length);
-
-        switch (sub) {
-            case "listar", "list" -> chunkloaderList(sender, rest);
-            case "info", "chunk" -> chunkloaderInfo(sender);
-            case "remover", "remove", "del" -> chunkloaderRemove(sender, rest);
-            case "receita", "craft" -> chunkloaderRecipe(sender);
-            case "limite", "limit" -> chunkloaderLimit(sender, rest);
-            case "nome", "renomear", "rename" -> chunkloaderRename(sender, rest);
-            case "ativar", "enable" -> chunkloaderSetEnabled(sender, rest, true);
-            case "desativar", "pausar", "disable", "pause" -> chunkloaderSetEnabled(sender, rest, false);
-            case "tempo", "abastecer", "fuel" -> chunkloaderTime(sender, rest);
-            case "admin" -> chunkloaderAdmin(sender, rest);
-            case "dar", "give" -> {
-                if (admin(sender)) {
-                    chunkloaderGive(sender, rest);
-                }
-            }
-            default -> chunkloaderHelp(sender);
-        }
-        return true;
-    }
-
-    private void chunkloaderList(CommandSender sender, String[] args) {
-        if (!(sender instanceof Player player)) {
-            chunkloaderAdminList(sender, args.length > 0 ? args[0] : null);
-            return;
-        }
-
-        List<ChunkLoader> mine = plugin.chunkLoaders().byOwner(player.getUniqueId().toString());
-        int limit = ChunkLoaders.playerLimit(player, plugin.settings().chunkLoaderDefaultLimit());
-        String limitStr = limit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(limit);
-
-        Msg.header(sender, "Suas Âncoras de Chunk (" + mine.size() + "/" + limitStr + ")");
-        if (mine.isEmpty()) {
-            sender.sendMessage(Component.text("  Você não possui nenhuma Âncora de Chunk ativa.", NamedTextColor.GRAY));
-            sender.sendMessage(Component.text("  Use ", NamedTextColor.GRAY)
-                    .append(Component.text("/chunkloader receita", NamedTextColor.AQUA))
-                    .append(Component.text(" para ver como criar uma.", NamedTextColor.GRAY)));
-            return;
-        }
-
-        boolean bedrock = isBedrock(sender);
-        for (ChunkLoader loader : mine) {
-            String statusText = loader.enabled() ? "[Ativa]" : "[Pausada]";
-            NamedTextColor statusColor = loader.enabled() ? NamedTextColor.GREEN : NamedTextColor.RED;
-
-            Component line = Component.text("  " + loader.displayName() + " ", NamedTextColor.AQUA)
-                    .append(Component.text(loader.place() + " " + loader.chunkCoords() + " ", NamedTextColor.WHITE))
-                    .append(Component.text(statusText + " ", statusColor))
-                    .append(Component.text("[" + loader.timeLeft() + "]", NamedTextColor.GOLD));
-
-            if (!bedrock) {
-                if (loader.enabled()) {
-                    line = line.append(Component.text(" [Pausar]", NamedTextColor.YELLOW)
-                            .hoverEvent(net.kyori.adventure.text.event.HoverEvent.showText(
-                                    Component.text("Clique para pausar " + loader.displayName(), NamedTextColor.GRAY)))
-                            .clickEvent(net.kyori.adventure.text.event.ClickEvent.runCommand(
-                                    "/chunkloader desativar " + loader.id())));
-                } else {
-                    line = line.append(Component.text(" [Ativar]", NamedTextColor.GREEN)
-                            .hoverEvent(net.kyori.adventure.text.event.HoverEvent.showText(
-                                    Component.text("Clique para reativar " + loader.displayName(), NamedTextColor.GRAY)))
-                            .clickEvent(net.kyori.adventure.text.event.ClickEvent.runCommand(
-                                    "/chunkloader ativar " + loader.id())));
-                }
-                line = line.append(Component.text(" [Remover]", NamedTextColor.RED)
-                        .hoverEvent(net.kyori.adventure.text.event.HoverEvent.showText(
-                                Component.text("Clique para recolher " + loader.displayName(), NamedTextColor.GRAY)))
-                        .clickEvent(net.kyori.adventure.text.event.ClickEvent.suggestCommand(
-                                "/chunkloader remover " + loader.id())));
-            }
-            sender.sendMessage(line);
-        }
-    }
-
-    private void chunkloaderInfo(CommandSender sender) {
-        if (!(sender instanceof Player player)) {
-            Msg.error(sender, "Comando exclusivo para jogadores.");
-            return;
-        }
-
-        Location loc = player.getLocation();
-        String world = loc.getWorld().getName();
-        int cx = loc.getBlockX() >> 4;
-        int cz = loc.getBlockZ() >> 4;
-
-        ChunkLoader here = plugin.chunkLoaders().byChunk(world, cx, cz);
-        int limit = ChunkLoaders.playerLimit(player, plugin.settings().chunkLoaderDefaultLimit());
-        int used = plugin.chunkLoaders().byOwner(player.getUniqueId().toString()).size();
-        String limitStr = limit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(limit);
-
-        Msg.header(sender, "Informações da Chunk");
-        sender.sendMessage(Component.text("  Chunk atual: ", NamedTextColor.GRAY)
-                .append(Component.text("[" + cx + ", " + cz + "]", NamedTextColor.AQUA))
-                .append(Component.text(" em " + world, NamedTextColor.WHITE)));
-
-        if (here != null) {
-            String status = here.enabled() ? "Ativa" : "Pausada";
-            NamedTextColor statusCol = here.enabled() ? NamedTextColor.GREEN : NamedTextColor.RED;
-            sender.sendMessage(Component.text("  Status: ", NamedTextColor.GRAY)
-                    .append(Component.text(here.displayName() + " (" + status + ")", statusCol))
-                    .append(Component.text(" de " + here.ownerName(), NamedTextColor.WHITE)));
-            sender.sendMessage(Component.text("  Tempo restante: ", NamedTextColor.GRAY)
-                    .append(Component.text(here.timeLeft(), NamedTextColor.GOLD)));
-        } else {
-            sender.sendMessage(Component.text("  Status: ", NamedTextColor.GRAY)
-                    .append(Component.text("Carregamento normal (sem âncora)", NamedTextColor.DARK_GRAY)));
-        }
-
-        sender.sendMessage(Component.text("  Suas âncoras ativas: ", NamedTextColor.GRAY)
-                .append(Component.text(used + "/" + limitStr, NamedTextColor.YELLOW)));
-    }
-
-    private void chunkloaderRename(CommandSender sender, String[] args) {
-        if (args.length < 2) {
-            Msg.error(sender, "Uso: /chunkloader nome <id|nome_antigo> <novo_nome>");
-            return;
-        }
-        ChunkLoader loader = plugin.chunkLoaders().find(args[0]);
-        if (loader == null) {
-            Msg.error(sender, "Nenhuma âncora encontrada para '" + args[0] + "'.");
-            return;
-        }
-        boolean isOwner = sender instanceof Player player && player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
-        boolean isAdmin = sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin");
-        if (!isOwner && !isAdmin) {
-            Msg.error(sender, "Esta âncora pertence a " + loader.ownerName() + ".");
-            return;
-        }
-        String newName = String.join(" ", Arrays.copyOfRange(args, 1, args.length)).trim();
-        if (newName.length() > 32) {
-            Msg.error(sender, "Nome muito longo (máximo 32 caracteres).");
-            return;
-        }
-        plugin.chunkLoaders().rename(loader.id(), newName);
-        plugin.blueMap().syncChunkLoaders();
-        Msg.ok(sender, "Âncora #" + loader.id() + " renomeada para '" + newName + "'.");
-    }
-
-    private void chunkloaderSetEnabled(CommandSender sender, String[] args, boolean enabled) {
-        if (args.length < 1) {
-            Msg.error(sender, "Uso: /chunkloader " + (enabled ? "ativar" : "desativar") + " <id|nome>");
-            return;
-        }
-        ChunkLoader loader = plugin.chunkLoaders().find(args[0]);
-        if (loader == null) {
-            Msg.error(sender, "Nenhuma âncora encontrada para '" + args[0] + "'.");
-            return;
-        }
-        boolean isOwner = sender instanceof Player player && player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
-        boolean isAdmin = sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin");
-        if (!isOwner && !isAdmin) {
-            Msg.error(sender, "Esta âncora pertence a " + loader.ownerName() + ".");
-            return;
-        }
-        if (loader.enabled() == enabled) {
-            Msg.error(sender, "A âncora " + loader.displayName() + " já está " + (enabled ? "ativa" : "pausada") + ".");
-            return;
-        }
-        plugin.chunkLoaders().setEnabled(loader.id(), enabled);
-        plugin.blueMap().syncChunkLoaders();
-        Msg.ok(sender, "Âncora " + loader.displayName() + " " + (enabled ? "ATIVADA." : "PAUSADA/DESATIVADA."));
-    }
-
-    private void chunkloaderTime(CommandSender sender, String[] args) {
-        if (args.length < 2) {
-            Msg.error(sender, "Uso: /chunkloader tempo <id|nome> <horas>");
-            return;
-        }
-        ChunkLoader loader = plugin.chunkLoaders().find(args[0]);
-        if (loader == null) {
-            Msg.error(sender, "Nenhuma âncora encontrada para '" + args[0] + "'.");
-            return;
-        }
-        boolean isOwner = sender instanceof Player player && player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
-        boolean isAdmin = sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin");
-        if (!isOwner && !isAdmin) {
-            Msg.error(sender, "Esta âncora pertence a " + loader.ownerName() + ".");
-            return;
-        }
-        try {
-            double hours = Double.parseDouble(args[1]);
-            if (hours <= 0 && isAdmin) {
-                plugin.chunkLoaders().addTime(loader.id(), -loader.expiresAt()); // permanent
-                Msg.ok(sender, "Âncora " + loader.displayName() + " definida como PERMANENTE.");
-            } else {
-                long millis = (long) (hours * 3600_000L);
-                plugin.chunkLoaders().addTime(loader.id(), millis);
-                ChunkLoader updated = plugin.chunkLoaders().byId(loader.id());
-                String time = (updated != null) ? updated.timeLeft() : "Permanente";
-                Msg.ok(sender, "Adicionado " + hours + "h à âncora " + loader.displayName() + ". Tempo restante: " + time);
-            }
-            plugin.blueMap().syncChunkLoaders();
-        } catch (NumberFormatException e) {
-            Msg.error(sender, "Horas inválidas: " + args[1]);
-        }
-    }
-
-    private void chunkloaderRemove(CommandSender sender, String[] args) {
-        if (args.length < 1) {
-            Msg.error(sender, "Uso: /chunkloader remover <id|nome>");
-            return;
-        }
-
-        ChunkLoader loader = plugin.chunkLoaders().find(args[0]);
-        if (loader == null) {
-            Msg.error(sender, "Nenhuma Âncora de Chunk encontrada para '" + args[0] + "'.");
-            return;
-        }
-
-        long id = loader.id();
-        boolean isOwner = sender instanceof Player player && player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
-        boolean isAdmin = sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin");
-
-        if (!isOwner && !isAdmin) {
-            Msg.error(sender, "Esta âncora pertence a " + loader.ownerName() + ".");
-            return;
-        }
-
-        plugin.chunkLoaders().remove(id);
-        plugin.blueMap().syncChunkLoaders();
-
-        try {
-            org.bukkit.World w = Bukkit.getWorld(loader.world());
-            if (w != null && w.isChunkLoaded(loader.chunkX(), loader.chunkZ())) {
-                Block b = w.getBlockAt(loader.x(), loader.y(), loader.z());
-                if (b.getType() == Material.RESPAWN_ANCHOR) {
-                    b.setType(Material.AIR);
-                }
-            }
-        } catch (Exception ignored) {
-        }
-
-        if (sender instanceof Player player) {
-            Map<Integer, ItemStack> overflow = player.getInventory().addItem(ChunkAnchorItem.create(plugin, 1));
-            for (ItemStack drop : overflow.values()) {
-                player.getWorld().dropItemNaturally(player.getLocation(), drop);
-            }
-            Msg.ok(sender, "Âncora de Chunk " + loader.displayName() + " desativada e devolvida ao inventário.");
-        } else {
-            try {
-                org.bukkit.World w = Bukkit.getWorld(loader.world());
-                if (w != null) {
-                    w.dropItemNaturally(new Location(w, loader.x() + 0.5, loader.y() + 0.5, loader.z() + 0.5),
-                            ChunkAnchorItem.create(plugin, 1));
-                }
-            } catch (Exception ignored) {
-            }
-            Msg.ok(sender, "Âncora de Chunk " + loader.displayName() + " desativada e dropada em " + loader.place() + ".");
-        }
-    }
-
-    private void chunkloaderRecipe(CommandSender sender) {
-        Msg.header(sender, "Receita da Âncora de Chunk");
-        sender.sendMessage(Component.text("  Na Bancada de Trabalho:", NamedTextColor.GRAY));
-        sender.sendMessage(Component.text("    [ D ] [ O ] [ D ]", NamedTextColor.AQUA));
-        sender.sendMessage(Component.text("    [ O ] [ E ] [ O ]", NamedTextColor.LIGHT_PURPLE));
-        sender.sendMessage(Component.text("    [ D ] [ O ] [ D ]", NamedTextColor.AQUA));
-        sender.sendMessage(Component.text("  D = Diamante  |  O = Obsidiana Chorona  |  E = Olho do Fim", NamedTextColor.YELLOW));
-    }
-
-    private void chunkloaderAdmin(CommandSender sender, String[] args) {
-        if (!admin(sender)) {
-            return;
-        }
-        if (args.length == 0) {
-            Msg.header(sender, "Admin Chunk Loaders");
-            sender.sendMessage(Component.text("  /chunkloader admin listar [jogador]", NamedTextColor.AQUA));
-            sender.sendMessage(Component.text("  /chunkloader admin remover <id>", NamedTextColor.AQUA));
-            sender.sendMessage(Component.text("  /chunkloader dar <jogador> [quantidade]", NamedTextColor.AQUA));
-            return;
-        }
-
-        switch (args[0].toLowerCase(Locale.ROOT)) {
-            case "listar", "list" -> chunkloaderAdminList(sender, args.length > 1 ? args[1] : null);
-            case "remover", "del" -> {
-                if (args.length < 2) {
-                    Msg.error(sender, "Uso: /chunkloader admin remover <id>");
-                    return;
-                }
-                chunkloaderRemove(sender, new String[]{args[1]});
-            }
-            case "dar", "give" -> chunkloaderGive(sender, Arrays.copyOfRange(args, 1, args.length));
-            default -> Msg.error(sender, "Subcomando de admin desconhecido.");
-        }
-    }
-
-    private void chunkloaderAdminList(CommandSender sender, String targetName) {
-        List<ChunkLoader> all = plugin.chunkLoaders().all();
-        if (targetName != null && !targetName.isBlank()) {
-            all = all.stream().filter(l -> l.ownerName().equalsIgnoreCase(targetName)).toList();
-        }
-
-        Msg.header(sender, "Todas as Âncoras do Servidor (" + all.size() + ")");
-        if (all.isEmpty()) {
-            sender.sendMessage(Component.text("  Nenhuma âncora ativa encontrada.", NamedTextColor.GRAY));
-            return;
-        }
-
-        for (ChunkLoader loader : all) {
-            sender.sendMessage(Component.text("  #" + loader.id() + " ", NamedTextColor.AQUA)
-                    .append(Component.text(loader.ownerName(), NamedTextColor.YELLOW))
-                    .append(Component.text(" — " + loader.place() + " " + loader.chunkCoords(), NamedTextColor.WHITE)));
-        }
-    }
-
-    private void chunkloaderGive(CommandSender sender, String[] args) {
-        if (args.length < 1) {
-            Msg.error(sender, "Uso: /chunkloader dar <jogador> [quantidade]");
-            return;
-        }
-
-        Player target = Bukkit.getPlayer(args[0]);
-        if (target == null) {
-            Msg.error(sender, "Jogador não encontrado: " + args[0]);
-            return;
-        }
-
-        int amount = 1;
-        if (args.length >= 2) {
-            try {
-                amount = Math.max(1, Integer.parseInt(args[1]));
-            } catch (NumberFormatException ignored) {
-            }
-        }
-
-        target.getInventory().addItem(ChunkAnchorItem.create(plugin, amount));
-        Msg.ok(sender, "Entregue " + amount + "x Âncora de Chunk para " + target.getName() + ".");
-        Msg.ok(target, "Você recebeu " + amount + "x Âncora de Chunk!");
-    }
-
-    private void chunkloaderLimit(CommandSender sender, String[] args) {
-        if (args.length == 0) {
-            int defaultLimit = plugin.settings().chunkLoaderDefaultLimit();
-            Msg.header(sender, "Limite de Âncoras de Chunk");
-            sender.sendMessage(Component.text("  Limite padrão global: ", NamedTextColor.GRAY)
-                    .append(Component.text(defaultLimit, NamedTextColor.YELLOW)));
-            if (sender instanceof Player player) {
-                int myLimit = ChunkLoaders.playerLimit(player, defaultLimit);
-                String myLimitStr = myLimit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(myLimit);
-                int current = plugin.chunkLoaders().byOwner(player.getUniqueId().toString()).size();
-                sender.sendMessage(Component.text("  Seu limite atual: ", NamedTextColor.GRAY)
-                        .append(Component.text(current + "/" + myLimitStr, NamedTextColor.AQUA)));
-            }
-            if (admin(sender)) {
-                sender.sendMessage(Component.text("  Alterar padrão global: ", NamedTextColor.GRAY)
-                        .append(Component.text("/chunkloader limite padrao <quantidade>", NamedTextColor.YELLOW)));
-                sender.sendMessage(Component.text("  Definir por jogador (LuckPerms): ", NamedTextColor.GRAY)
-                        .append(Component.text("/chunkloader limite <jogador> <quantidade>", NamedTextColor.YELLOW)));
-            }
-            return;
-        }
-
-        if (!admin(sender)) {
-            return;
-        }
-
-        if (args[0].equalsIgnoreCase("padrao") || args[0].equalsIgnoreCase("default")) {
-            if (args.length < 2) {
-                Msg.error(sender, "Uso: /chunkloader limite padrao <quantidade>");
-                return;
-            }
-            try {
-                int newLimit = Math.max(0, Integer.parseInt(args[1]));
-                plugin.settings().chunkLoaderDefaultLimit(newLimit);
-                Msg.ok(sender, "Limite padrão global de Âncoras alterado para " + newLimit + ".");
-            } catch (NumberFormatException e) {
-                Msg.error(sender, "Quantidade inválida: " + args[1]);
-            }
-            return;
-        }
-
-        Player target = Bukkit.getPlayerExact(args[0]);
-        if (target == null) {
-            Msg.error(sender, "Jogador '" + args[0] + "' não encontrado online.");
-            return;
-        }
-        if (args.length < 2) {
-            int targetLimit = ChunkLoaders.playerLimit(target, plugin.settings().chunkLoaderDefaultLimit());
-            String str = targetLimit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(targetLimit);
-            int current = plugin.chunkLoaders().byOwner(target.getUniqueId().toString()).size();
-            Msg.ok(sender, "Limite de " + target.getName() + ": " + current + "/" + str + " âncoras ativas.");
-            return;
-        }
-        try {
-            int newLimit = Math.max(0, Integer.parseInt(args[1]));
-            Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + target.getName() + " permission set canalhandia.chunkloader.limite." + newLimit);
-            Msg.ok(sender, "Limite de " + target.getName() + " definido para " + newLimit + " âncoras.");
-        } catch (NumberFormatException e) {
-            Msg.error(sender, "Quantidade inválida: " + args[1]);
-        }
-    }
-
-    private boolean chunkloaderHelp(CommandSender sender) {
-        Msg.header(sender, "Âncoras de Chunk");
-        sender.sendMessage(Component.text("  /chunkloader info", NamedTextColor.AQUA)
-                .append(Component.text(" — Informações sobre a chunk onde você está", NamedTextColor.GRAY)));
-        sender.sendMessage(Component.text("  /chunkloader listar", NamedTextColor.AQUA)
-                .append(Component.text(" — Lista suas âncoras, nomes, status e coordenadas", NamedTextColor.GRAY)));
-        sender.sendMessage(Component.text("  /chunkloader nome <id|nome> <novo_nome>", NamedTextColor.AQUA)
-                .append(Component.text(" — Define um nome/rótulo para a âncora", NamedTextColor.GRAY)));
-        sender.sendMessage(Component.text("  /chunkloader ativar <id|nome>", NamedTextColor.AQUA)
-                .append(Component.text(" — Reativa o carregamento contínuo da âncora", NamedTextColor.GRAY)));
-        sender.sendMessage(Component.text("  /chunkloader desativar <id|nome>", NamedTextColor.AQUA)
-                .append(Component.text(" — Pausa o carregamento sem quebrar o bloco", NamedTextColor.GRAY)));
-        sender.sendMessage(Component.text("  /chunkloader remover <id|nome>", NamedTextColor.AQUA)
-                .append(Component.text(" — Desativa e recolhe uma de suas âncoras", NamedTextColor.GRAY)));
-        sender.sendMessage(Component.text("  /chunkloader receita", NamedTextColor.AQUA)
-                .append(Component.text(" — Mostra a receita de criação do bloco", NamedTextColor.GRAY)));
-        sender.sendMessage(Component.text("  /chunkloader tempo <id|nome> <horas>", NamedTextColor.AQUA)
-                .append(Component.text(" — Adiciona tempo ou abastece a âncora", NamedTextColor.GRAY)));
-        sender.sendMessage(Component.text("  /chunkloader limite", NamedTextColor.AQUA)
-                .append(Component.text(" — Mostra ou configura os limites de âncoras", NamedTextColor.GRAY)));
-        if (sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin")) {
-            sender.sendMessage(Component.text("  /chunkloader admin", NamedTextColor.YELLOW)
-                    .append(Component.text(" — Comandos de administração", NamedTextColor.GRAY)));
-        }
-        return true;
-    }
-
    // --- tab completion -----------------------------------------------------

    @Override
@@ -2300,37 +1724,23 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
            return filter(options, args[0]);
        }
        if (name.equals("ia") || name.equals("iap")) {
-            if (args.length == 1) {
-                List<String> subs = new ArrayList<>(List.of("persona", "personalidade", "status", "lembrar", "esquecer"));
-                if (sender.hasPermission("canalhandia.ia.perfil")) {
-                    subs.addAll(List.of("perfil", "eventos", "saudacao", "corrigir"));
-                }
-                return filter(subs, args[0]);
+            // Only the tuning subcommands are suggested — the rest of /ia is
+            // free text, and completing a question would be noise.
+            if (args.length == 1 && sender.hasPermission("canalhandia.ia.perfil")) {
+                return filter(List.of("personalidade", "perfil", "eventos", "saudacao"), args[0]);
            }
-            if (args.length == 2 && (args[0].equalsIgnoreCase("personalidade") || args[0].equalsIgnoreCase("persona"))) {
+            if (args.length == 2 && args[0].equalsIgnoreCase("personalidade")) {
                List<String> keys = new ArrayList<>();
-                keys.add("padrao");
                for (Persona persona : Persona.values()) {
                    keys.add(persona.key());
                }
-                if (sender.hasPermission("canalhandia.ia.perfil")) {
-                    keys.add("global");
-                }
                return filter(keys, args[1]);
            }
-            if (args.length == 3 && (args[0].equalsIgnoreCase("personalidade") || args[0].equalsIgnoreCase("persona"))
-                    && args[1].equalsIgnoreCase("global") && sender.hasPermission("canalhandia.ia.perfil")) {
-                List<String> keys = new ArrayList<>();
-                for (Persona persona : Persona.values()) {
-                    keys.add(persona.key());
-                }
-                return filter(keys, args[2]);
-            }
-            if (args.length == 2 && args[0].equalsIgnoreCase("perfil") && sender.hasPermission("canalhandia.ia.perfil")) {
+            if (args.length == 2 && args[0].equalsIgnoreCase("perfil")) {
                return filter(List.of("economico", "preciso"), args[1]);
            }
            if (args.length == 2 && (args[0].equalsIgnoreCase("eventos")
-                    || args[0].equalsIgnoreCase("saudacao")) && sender.hasPermission("canalhandia.ia.perfil")) {
+                    || args[0].equalsIgnoreCase("saudacao"))) {
                return filter(List.of("on", "off"), args[1]);
            }
            return List.of();
@@ -2396,45 +1806,6 @@ final class CanalhandiaCommand implements CommandExecutor, TabCompleter {
                return filter(List.of("on", "off"), args[2]);
            }
        }
-        if (name.equals("chunkloader") || name.equals("ancora") || name.equals("ancoras")) {
-            if (args.length == 1) {
-                List<String> options = new ArrayList<>(List.of("info", "listar", "nome", "ativar", "desativar", "tempo", "remover", "receita", "limite"));
-                if (sender.hasPermission(ADMIN) || sender.hasPermission("canalhandia.chunkloader.admin")) {
-                    options.addAll(List.of("admin", "dar"));
-                }
-                return filter(options, args[0]);
-            }
-            if (args.length == 2 && (args[0].equalsIgnoreCase("remover") || args[0].equalsIgnoreCase("del")
-                    || args[0].equalsIgnoreCase("nome") || args[0].equalsIgnoreCase("renomear")
-                    || args[0].equalsIgnoreCase("ativar") || args[0].equalsIgnoreCase("desativar")
-                    || args[0].equalsIgnoreCase("pausar") || args[0].equalsIgnoreCase("tempo")
-                    || args[0].equalsIgnoreCase("abastecer"))) {
-                if (sender instanceof Player player) {
-                    List<String> identifiers = new ArrayList<>();
-                    for (ChunkLoader loader : plugin.chunkLoaders().byOwner(player.getUniqueId().toString())) {
-                        identifiers.add(String.valueOf(loader.id()));
-                        if (loader.name() != null && !loader.name().isBlank()) {
-                            identifiers.add(loader.name());
-                        }
-                    }
-                    return filter(identifiers, args[1]);
-                }
-            }
-            if (args.length == 2 && args[0].equalsIgnoreCase("limite")) {
-                List<String> opts = new ArrayList<>(List.of("padrao"));
-                opts.addAll(onlineNames());
-                return filter(opts, args[1]);
-            }
-            if (args.length == 2 && args[0].equalsIgnoreCase("admin")) {
-                return filter(List.of("listar", "remover", "dar"), args[1]);
-            }
-            if (args.length == 2 && args[0].equalsIgnoreCase("dar")) {
-                return filter(onlineNames(), args[1]);
-            }
-            if (args.length == 3 && args[0].equalsIgnoreCase("admin") && args[1].equalsIgnoreCase("dar")) {
-                return filter(onlineNames(), args[2]);
-            }
-        }
        return List.of();
    }

@@ -1,97 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
-import net.kyori.adventure.text.format.TextDecoration;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.ShapedRecipe;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.persistence.PersistentDataType;
-import org.bukkit.plugin.Plugin;
-
-import java.util.List;
-
-/**
- * Creates and validates the "Âncora de Chunk" custom block item and its crafting recipe.
- */
-final class ChunkAnchorItem {
-
-    private static final String KEY_NAME = "chunk_anchor";
-    private static final String RECIPE_NAME = "ancora_de_chunk";
-
-    static NamespacedKey key(Plugin plugin) {
-        return new NamespacedKey(plugin, KEY_NAME);
-    }
-
-    static NamespacedKey recipeKey(Plugin plugin) {
-        return new NamespacedKey(plugin, RECIPE_NAME);
-    }
-
-    /**
-     * Creates a new Chunk Anchor item stack.
-     */
-    static ItemStack create(Plugin plugin, int amount) {
-        ItemStack item = new ItemStack(Material.RESPAWN_ANCHOR, Math.max(1, amount));
-        ItemMeta meta = item.getItemMeta();
-        if (meta != null) {
-            meta.displayName(Component.text("Âncora de Chunk", NamedTextColor.AQUA)
-                    .decoration(TextDecoration.ITALIC, false)
-                    .decoration(TextDecoration.BOLD, true));
-            meta.lore(List.of(
-                    Component.text("Coloque no chão para manter esta chunk", NamedTextColor.GRAY)
-                            .decoration(TextDecoration.ITALIC, false),
-                    Component.text("carregada continuamente no servidor.", NamedTextColor.GRAY)
-                            .decoration(TextDecoration.ITALIC, false),
-                    Component.text("Canalhandia Chunk Loader", NamedTextColor.DARK_GRAY)
-                            .decoration(TextDecoration.ITALIC, false)
-            ));
-            meta.getPersistentDataContainer().set(key(plugin), PersistentDataType.BYTE, (byte) 1);
-            item.setItemMeta(meta);
-        }
-        return item;
-    }
-
-    /**
-     * Tests if an item is a valid Chunk Anchor.
-     */
-    static boolean isAnchor(Plugin plugin, ItemStack item) {
-        if (item == null || item.getType() != Material.RESPAWN_ANCHOR) {
-            return false;
-        }
-        ItemMeta meta = item.getItemMeta();
-        if (meta == null) {
-            return false;
-        }
-        return meta.getPersistentDataContainer().has(key(plugin), PersistentDataType.BYTE);
-    }
-
-    /**
-     * Registers the shaped crafting recipe for the Chunk Anchor.
-     */
-    static void registerRecipe(Plugin plugin) {
-        try {
-            NamespacedKey rKey = recipeKey(plugin);
-            if (Bukkit.getRecipe(rKey) != null) {
-                return;
-            }
-            ShapedRecipe recipe = new ShapedRecipe(rKey, create(plugin, 1));
-            recipe.shape("DOD", "OEO", "DOD");
-            recipe.setIngredient('D', Material.DIAMOND);
-            recipe.setIngredient('O', Material.CRYING_OBSIDIAN);
-            recipe.setIngredient('E', Material.ENDER_EYE);
-
-            Bukkit.addRecipe(recipe);
-        } catch (Exception ignored) {
-        }
-    }
-
-    static void unregisterRecipe(Plugin plugin) {
-        try {
-            Bukkit.removeRecipe(recipeKey(plugin));
-        } catch (Exception ignored) {
-        }
-    }
-}
@@ -1,85 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-/**
- * A persistent chunk loader anchor placed in the world.
- *
- * <p>A plain immutable record with no Bukkit types, so the model, coordinate
- * math, and persistence rules are testable without a running server.
- */
-record ChunkLoader(
-        long id,
-        String name,
-        boolean enabled,
-        long expiresAt,
-        String ownerUuid,
-        String ownerName,
-        String world,
-        int x,
-        int y,
-        int z,
-        int chunkX,
-        int chunkZ,
-        long createdAt) {
-
-    ChunkLoader(long id, String ownerUuid, String ownerName, String world, int x, int y, int z, int chunkX, int chunkZ, long createdAt) {
-        this(id, "", true, 0L, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
-    }
-
-    ChunkLoader(long id, String name, boolean enabled, String ownerUuid, String ownerName, String world, int x, int y, int z, int chunkX, int chunkZ, long createdAt) {
-        this(id, name, enabled, 0L, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
-    }
-
-    String blockCoords() {
-        return x + ", " + y + ", " + z;
-    }
-
-    String chunkCoords() {
-        return "[" + chunkX + ", " + chunkZ + "]";
-    }
-
-    String place() {
-        return blockCoords() + (world == null || world.isBlank() ? "" : " (" + world + ")");
-    }
-
-    String displayName() {
-        return (name != null && !name.isBlank()) ? name + " (#" + id + ")" : "#" + id;
-    }
-
-    String simpleName() {
-        return (name != null && !name.isBlank()) ? name : "#" + id;
-    }
-
-    boolean isExpired() {
-        return expiresAt > 0 && System.currentTimeMillis() >= expiresAt;
-    }
-
-    String timeLeft() {
-        if (expiresAt <= 0) {
-            return "Permanente";
-        }
-        long diff = expiresAt - System.currentTimeMillis();
-        if (diff <= 0) {
-            return "Expirado";
-        }
-        long hours = diff / (3600_000L);
-        long minutes = (diff % (3600_000L)) / 60_000L;
-        if (hours >= 24) {
-            long days = hours / 24;
-            hours = hours % 24;
-            return days + "d " + hours + "h";
-        }
-        return hours + "h " + minutes + "m";
-    }
-
-    ChunkLoader withName(String newName) {
-        return new ChunkLoader(id, newName == null ? "" : newName.trim(), enabled, expiresAt, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
-    }
-
-    ChunkLoader withEnabled(boolean newEnabled) {
-        return new ChunkLoader(id, name, newEnabled, expiresAt, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
-    }
-
-    ChunkLoader withExpiresAt(long newExpiresAt) {
-        return new ChunkLoader(id, name, enabled, Math.max(0L, newExpiresAt), ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt);
-    }
-}
@@ -1,313 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.Particle;
-import org.bukkit.Sound;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Mob;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.Action;
-import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockExplodeEvent;
-import org.bukkit.event.block.BlockPistonExtendEvent;
-import org.bukkit.event.block.BlockPistonRetractEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.event.entity.CreatureSpawnEvent;
-import org.bukkit.event.entity.EntityExplodeEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.Iterator;
-import java.util.Map;
-
-/**
- * Protects and handles block placement, removal, and explosions for Chunk Anchors.
- */
-final class ChunkLoaderListener implements Listener {
-
-    private final Canalhandia plugin;
-
-    ChunkLoaderListener(Canalhandia plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockPlace(BlockPlaceEvent event) {
-        if (!ChunkAnchorItem.isAnchor(plugin, event.getItemInHand())) {
-            return;
-        }
-
-        Player player = event.getPlayer();
-        if (!plugin.settings().moduleEnabled(Module.CHUNKLOADER)) {
-            Msg.error(player, "O módulo de Âncoras de Chunk está desativado.");
-            event.setCancelled(true);
-            return;
-        }
-
-        if (!player.hasPermission("canalhandia.chunkloader")) {
-            Msg.error(player, "Você não tem permissão para usar Âncoras de Chunk.");
-            event.setCancelled(true);
-            return;
-        }
-
-        int limit = ChunkLoaders.playerLimit(player, plugin.settings().chunkLoaderDefaultLimit());
-        int current = plugin.chunkLoaders().byOwner(player.getUniqueId().toString()).size();
-
-        if (current >= limit) {
-            Msg.error(player, "Você atingiu seu limite de Âncoras de Chunk ativas (" + current + "/" + limit + ").");
-            event.setCancelled(true);
-            return;
-        }
-
-        Location loc = event.getBlockPlaced().getLocation();
-        String world = loc.getWorld().getName();
-        int chunkX = loc.getBlockX() >> 4;
-        int chunkZ = loc.getBlockZ() >> 4;
-
-        ChunkLoader existing = plugin.chunkLoaders().byChunk(world, chunkX, chunkZ);
-        if (existing != null) {
-            Msg.error(player, "Esta chunk já possui uma Âncora de Chunk ativa em " + existing.blockCoords()
-                    + " (" + existing.ownerName() + ").");
-            event.setCancelled(true);
-            return;
-        }
-
-        String customName = "";
-        var meta = event.getItemInHand().getItemMeta();
-        if (meta != null && meta.hasDisplayName()) {
-            try {
-                String raw = net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer.plainText()
-                        .serialize(meta.displayName()).trim();
-                if (!raw.equalsIgnoreCase("Âncora de Chunk") && !raw.isBlank()) {
-                    customName = raw;
-                }
-            } catch (Exception ignored) {
-            }
-        }
-
-        ChunkLoader loader = plugin.chunkLoaders().add(
-                player.getUniqueId().toString(),
-                player.getName(),
-                world,
-                loc.getBlockX(),
-                loc.getBlockY(),
-                loc.getBlockZ(),
-                customName
-        );
-
-        try {
-            loc.getWorld().spawnParticle(Particle.PORTAL, loc.clone().add(0.5, 1.2, 0.5), 35, 0.3, 0.3, 0.3, 0.05);
-            loc.getWorld().playSound(loc, Sound.BLOCK_RESPAWN_ANCHOR_SET_SPAWN, 1.0f, 1.2f);
-        } catch (Exception ignored) {
-        }
-
-        plugin.blueMap().syncChunkLoaders();
-
-        String limitStr = limit == Integer.MAX_VALUE ? "ilimitado" : String.valueOf(limit);
-        Msg.ok(player, "Âncora de Chunk " + loader.displayName() + " ativada! Esta chunk [" + chunkX + ", " + chunkZ + "] ficará carregada continuamente ("
-                + (current + 1) + "/" + limitStr + ").");
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onBlockBreak(BlockBreakEvent event) {
-        Block block = event.getBlock();
-        ChunkLoader loader = plugin.chunkLoaders().byLocation(
-                block.getWorld().getName(),
-                block.getX(),
-                block.getY(),
-                block.getZ()
-        );
-
-        if (loader == null) {
-            return;
-        }
-
-        Player player = event.getPlayer();
-        boolean isOwner = player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
-        boolean isAdmin = player.hasPermission("canalhandia.admin") || player.hasPermission("canalhandia.chunkloader.admin");
-
-        if (!isOwner && !isAdmin) {
-            Msg.error(player, "Esta Âncora de Chunk pertence a " + loader.ownerName() + " e só pode ser quebrada por ele.");
-            event.setCancelled(true);
-            return;
-        }
-
-        plugin.chunkLoaders().remove(loader.id());
-        event.setDropItems(false);
-        event.setExpToDrop(0);
-
-        if (player.getGameMode() == GameMode.CREATIVE) {
-            Msg.ok(player, "Âncora de Chunk " + loader.displayName() + " desativada (Modo Criativo).");
-        } else {
-            Map<Integer, ItemStack> overflow = player.getInventory().addItem(ChunkAnchorItem.create(plugin, 1));
-            for (ItemStack drop : overflow.values()) {
-                player.getWorld().dropItemNaturally(player.getLocation(), drop);
-            }
-            Msg.ok(player, "Âncora de Chunk " + loader.displayName() + " desativada e recolhida para o seu inventário.");
-        }
-
-        try {
-            var loc = block.getLocation().add(0.5, 0.5, 0.5);
-            loc.getWorld().playSound(loc, Sound.BLOCK_RESPAWN_ANCHOR_DEPLETE, 1.0f, 0.8f);
-        } catch (Exception ignored) {
-        }
-
-        plugin.blueMap().syncChunkLoaders();
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        if (!plugin.settings().moduleEnabled(Module.CHUNKLOADER)) {
-            return;
-        }
-        if (event.getHand() != org.bukkit.inventory.EquipmentSlot.HAND) {
-            return;
-        }
-        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
-            return;
-        }
-        Block block = event.getClickedBlock();
-        if (block == null || block.getType() != Material.RESPAWN_ANCHOR) {
-            return;
-        }
-        ChunkLoader loader = plugin.chunkLoaders().byLocation(
-                block.getWorld().getName(),
-                block.getX(),
-                block.getY(),
-                block.getZ()
-        );
-        if (loader != null) {
-            event.setCancelled(true);
-            Player player = event.getPlayer();
-            boolean isOwner = player.getUniqueId().toString().equalsIgnoreCase(loader.ownerUuid());
-            boolean isAdmin = player.hasPermission("canalhandia.admin") || player.hasPermission("canalhandia.chunkloader.admin");
-
-            ItemStack inHand = player.getInventory().getItemInMainHand();
-            long fuelMillis = fuelDuration(inHand.getType());
-            if (fuelMillis > 0 && (isOwner || isAdmin)) {
-                if (player.getGameMode() != GameMode.CREATIVE) {
-                    inHand.subtract(1);
-                }
-                plugin.chunkLoaders().addTime(loader.id(), fuelMillis);
-                ChunkLoader updated = plugin.chunkLoaders().byId(loader.id());
-                Location l = block.getLocation().add(0.5, 0.5, 0.5);
-                try {
-                    l.getWorld().playSound(l, Sound.BLOCK_RESPAWN_ANCHOR_CHARGE, 1.0f, 1.2f);
-                    l.getWorld().spawnParticle(Particle.FIREWORK, l, 15, 0.2, 0.2, 0.2, 0.05);
-                } catch (Exception ignored) {
-                }
-                plugin.blueMap().syncChunkLoaders();
-                String time = (updated != null) ? updated.timeLeft() : "Permanente";
-                Msg.ok(player, "Âncora " + loader.displayName() + " abastecida! Tempo restante: " + time);
-                return;
-            }
-
-            if (player.isSneaking() && (isOwner || isAdmin)) {
-                boolean newState = !loader.enabled();
-                plugin.chunkLoaders().setEnabled(loader.id(), newState);
-                Location l = block.getLocation().add(0.5, 0.5, 0.5);
-                if (newState) {
-                    try {
-                        l.getWorld().playSound(l, Sound.BLOCK_BEACON_ACTIVATE, 1.0f, 1.2f);
-                        l.getWorld().spawnParticle(Particle.PORTAL, l, 25, 0.2, 0.2, 0.2, 0.05);
-                    } catch (Exception ignored) {
-                    }
-                    Msg.ok(player, "Âncora " + loader.displayName() + " ATIVADA.");
-                } else {
-                    try {
-                        l.getWorld().playSound(l, Sound.BLOCK_BEACON_DEACTIVATE, 1.0f, 0.8f);
-                        l.getWorld().spawnParticle(Particle.SMOKE, l, 20, 0.2, 0.2, 0.2, 0.02);
-                    } catch (Exception ignored) {
-                    }
-                    Msg.ok(player, "Âncora " + loader.displayName() + " PAUSADA/DESATIVADA.");
-                }
-                plugin.blueMap().syncChunkLoaders();
-                return;
-            }
-
-            String stateStr = loader.enabled() ? "ATIVA" : "PAUSADA";
-            Msg.ok(player, "Âncora " + loader.displayName() + " (" + loader.ownerName() + ") está " + stateStr
-                    + " [Tempo: " + loader.timeLeft() + "]. (Shift + Clique Direito para pausar/ativar | Clique com combustível para abastecer)");
-        }
-    }
-
-    private static long fuelDuration(Material type) {
-        if (type == Material.REDSTONE || type == Material.GLOWSTONE_DUST) {
-            return 30 * 60_000L; // 30 min
-        }
-        if (type == Material.GLOWSTONE || type == Material.AMETHYST_SHARD) {
-            return 2 * 3600_000L; // 2h
-        }
-        if (type == Material.ENDER_PEARL || type == Material.BLAZE_POWDER || type == Material.BLAZE_ROD) {
-            return 4 * 3600_000L; // 4h
-        }
-        if (type == Material.ENDER_EYE || type == Material.DIAMOND || type == Material.EMERALD) {
-            return 12 * 3600_000L; // 12h
-        }
-        if (type == Material.NETHER_STAR || type == Material.NETHERITE_INGOT || type == Material.END_CRYSTAL) {
-            return 7 * 24 * 3600_000L; // 7 dias
-        }
-        return 0L;
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockExplode(BlockExplodeEvent event) {
-        protectExplosions(event.blockList().iterator());
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onEntityExplode(EntityExplodeEvent event) {
-        protectExplosions(event.blockList().iterator());
-    }
-
-    private void protectExplosions(Iterator<Block> it) {
-        while (it.hasNext()) {
-            Block b = it.next();
-            if (plugin.chunkLoaders().byLocation(b.getWorld().getName(), b.getX(), b.getY(), b.getZ()) != null) {
-                it.remove();
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onPistonExtend(BlockPistonExtendEvent event) {
-        for (Block b : event.getBlocks()) {
-            if (plugin.chunkLoaders().byLocation(b.getWorld().getName(), b.getX(), b.getY(), b.getZ()) != null) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onPistonRetract(BlockPistonRetractEvent event) {
-        for (Block b : event.getBlocks()) {
-            if (plugin.chunkLoaders().byLocation(b.getWorld().getName(), b.getX(), b.getY(), b.getZ()) != null) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onCreatureSpawn(CreatureSpawnEvent event) {
-        if (!plugin.settings().moduleEnabled(Module.CHUNKLOADER)) {
-            return;
-        }
-        Location loc = event.getLocation();
-        World w = loc.getWorld();
-        if (w == null) {
-            return;
-        }
-        ChunkLoader loader = plugin.chunkLoaders().byChunk(w.getName(), loc.getBlockX() >> 4, loc.getBlockZ() >> 4);
-        if (loader != null && event.getEntity() instanceof Mob mob) {
-            mob.setRemoveWhenFarAway(false);
-        }
-    }
-}
@@ -1,554 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.CreatureSpawner;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Mob;
-import org.bukkit.entity.Player;
-import org.bukkit.event.entity.CreatureSpawnEvent;
-import org.bukkit.permissions.PermissionAttachmentInfo;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitTask;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Manages active chunk loader anchors, ticket registration in Paper, and persistence in chunks.yml.
- */
-final class ChunkLoaders {
-
-    private static final String PERM_LIMIT_PREFIX = "canalhandia.chunkloader.limite.";
-
-    private final Plugin plugin;
-    private final File file;
-    private final List<ChunkLoader> loaders = new ArrayList<>();
-    private final AtomicLong nextId = new AtomicLong(1);
-    private BukkitTask simulationTask;
-
-    private final ExecutorService io = Executors.newSingleThreadExecutor(r -> {
-        Thread t = new Thread(r, "canalhandia-chunkloaders-io");
-        t.setDaemon(true);
-        return t;
-    });
-
-    ChunkLoaders(Plugin plugin, File file) {
-        this.plugin = plugin;
-        this.file = file;
-        load();
-    }
-
-    void load() {
-        YamlConfiguration yaml = file.exists() ? YamlConfiguration.loadConfiguration(file) : null;
-        synchronized (loaders) {
-            loaders.clear();
-            if (yaml == null) {
-                return;
-            }
-            ConfigurationSection root = yaml.getConfigurationSection("loaders");
-            if (root == null) {
-                return;
-            }
-            long maxId = 0;
-            for (String key : root.getKeys(false)) {
-                try {
-                    long id = Long.parseLong(key);
-                    String name = root.getString(key + ".name", "");
-                    boolean enabled = root.getBoolean(key + ".enabled", true);
-                    long expiresAt = root.getLong(key + ".expires_at", 0L);
-                    String ownerUuid = root.getString(key + ".owner_uuid", "");
-                    String ownerName = root.getString(key + ".owner_name", "?");
-                    String world = root.getString(key + ".world", "world");
-                    int x = root.getInt(key + ".x");
-                    int y = root.getInt(key + ".y");
-                    int z = root.getInt(key + ".z");
-                    int chunkX = root.getInt(key + ".chunk_x", x >> 4);
-                    int chunkZ = root.getInt(key + ".chunk_z", z >> 4);
-                    long createdAt = root.getLong(key + ".created_at", System.currentTimeMillis());
-
-                    loaders.add(new ChunkLoader(id, name, enabled, expiresAt, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, createdAt));
-                    if (id > maxId) {
-                        maxId = id;
-                    }
-                } catch (NumberFormatException ignored) {
-                }
-            }
-            nextId.set(maxId + 1);
-        }
-    }
-
-    /**
-     * Registers a new chunk loader and activates the ticket in the world.
-     */
-    ChunkLoader add(String ownerUuid, String ownerName, String world, int x, int y, int z) {
-        return add(ownerUuid, ownerName, world, x, y, z, "", 0L);
-    }
-
-    ChunkLoader add(String ownerUuid, String ownerName, String world, int x, int y, int z, String name) {
-        return add(ownerUuid, ownerName, world, x, y, z, name, 0L);
-    }
-
-    ChunkLoader add(String ownerUuid, String ownerName, String world, int x, int y, int z, String name, long expiresAt) {
-        int chunkX = x >> 4;
-        int chunkZ = z >> 4;
-        long id = nextId.getAndIncrement();
-        ChunkLoader loader = new ChunkLoader(id, name == null ? "" : name.trim(), true, expiresAt, ownerUuid, ownerName, world, x, y, z, chunkX, chunkZ, System.currentTimeMillis());
-
-        synchronized (loaders) {
-            loaders.add(loader);
-        }
-        addTicket(loader);
-        save();
-        return loader;
-    }
-
-    /**
-     * Adds duration (in milliseconds) to a chunk loader's expiration timer.
-     */
-    boolean addTime(long id, long millisToAdd) {
-        ChunkLoader updated = null;
-        synchronized (loaders) {
-            for (int i = 0; i < loaders.size(); i++) {
-                ChunkLoader curr = loaders.get(i);
-                if (curr.id() == id) {
-                    long now = System.currentTimeMillis();
-                    long base = (curr.expiresAt() > now) ? curr.expiresAt() : now;
-                    long newExpires = base + millisToAdd;
-                    updated = curr.withExpiresAt(newExpires).withEnabled(true);
-                    loaders.set(i, updated);
-                    break;
-                }
-            }
-        }
-        if (updated != null) {
-            addTicket(updated);
-            save();
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * Renames an existing chunk loader.
-     */
-    boolean rename(long id, String newName) {
-        synchronized (loaders) {
-            for (int i = 0; i < loaders.size(); i++) {
-                ChunkLoader curr = loaders.get(i);
-                if (curr.id() == id) {
-                    loaders.set(i, curr.withName(newName));
-                    save();
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Enables or disables (pauses) a chunk loader without destroying the block.
-     */
-    boolean setEnabled(long id, boolean enabled) {
-        ChunkLoader oldLoader = null;
-        ChunkLoader updated = null;
-        synchronized (loaders) {
-            for (int i = 0; i < loaders.size(); i++) {
-                ChunkLoader curr = loaders.get(i);
-                if (curr.id() == id) {
-                    oldLoader = curr;
-                    updated = curr.withEnabled(enabled);
-                    loaders.set(i, updated);
-                    break;
-                }
-            }
-        }
-        if (oldLoader != null && updated != null) {
-            if (enabled) {
-                addTicket(updated);
-            } else {
-                removeTicket(oldLoader);
-            }
-            save();
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * Finds a chunk loader by its numeric ID (with or without '#') or custom name.
-     */
-    ChunkLoader find(String query) {
-        if (query == null || query.isBlank()) {
-            return null;
-        }
-        String trimmed = query.trim();
-        try {
-            long id = Long.parseLong(trimmed.startsWith("#") ? trimmed.substring(1) : trimmed);
-            ChunkLoader loader = byId(id);
-            if (loader != null) {
-                return loader;
-            }
-        } catch (NumberFormatException ignored) {
-        }
-
-        synchronized (loaders) {
-            for (ChunkLoader loader : loaders) {
-                if (loader.name() != null && loader.name().equalsIgnoreCase(trimmed)) {
-                    return loader;
-                }
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Removes a chunk loader by its unique ID and releases the chunk ticket.
-     */
-    boolean remove(long id) {
-        ChunkLoader removed = null;
-        synchronized (loaders) {
-            for (int i = 0; i < loaders.size(); i++) {
-                if (loaders.get(i).id() == id) {
-                    removed = loaders.remove(i);
-                    break;
-                }
-            }
-        }
-        if (removed != null) {
-            removeTicket(removed);
-            save();
-            return true;
-        }
-        return false;
-    }
-
-    ChunkLoader byId(long id) {
-        synchronized (loaders) {
-            for (ChunkLoader loader : loaders) {
-                if (loader.id() == id) {
-                    return loader;
-                }
-            }
-            return null;
-        }
-    }
-
-    ChunkLoader byChunk(String world, int chunkX, int chunkZ) {
-        synchronized (loaders) {
-            for (ChunkLoader loader : loaders) {
-                if (loader.world().equalsIgnoreCase(world) && loader.chunkX() == chunkX && loader.chunkZ() == chunkZ) {
-                    return loader;
-                }
-            }
-            return null;
-        }
-    }
-
-    ChunkLoader byLocation(String world, int x, int y, int z) {
-        synchronized (loaders) {
-            for (ChunkLoader loader : loaders) {
-                if (loader.world().equalsIgnoreCase(world) && loader.x() == x && loader.y() == y && loader.z() == z) {
-                    return loader;
-                }
-            }
-            return null;
-        }
-    }
-
-    List<ChunkLoader> byOwner(String ownerUuid) {
-        List<ChunkLoader> out = new ArrayList<>();
-        synchronized (loaders) {
-            for (ChunkLoader loader : loaders) {
-                if (loader.ownerUuid().equalsIgnoreCase(ownerUuid)) {
-                    out.add(loader);
-                }
-            }
-        }
-        return Collections.unmodifiableList(out);
-    }
-
-    List<ChunkLoader> all() {
-        synchronized (loaders) {
-            return Collections.unmodifiableList(new ArrayList<>(loaders));
-        }
-    }
-
-    int size() {
-        synchronized (loaders) {
-            return loaders.size();
-        }
-    }
-
-    /**
-     * Computes the maximum chunk loaders allowed for a player based on LuckPerms permissions.
-     */
-    static int playerLimit(Player player, int defaultLimit) {
-        if (player == null) {
-            return 0;
-        }
-        if (player.hasPermission("canalhandia.admin") || player.hasPermission("canalhandia.chunkloader.admin")) {
-            return Integer.MAX_VALUE;
-        }
-        if (!player.hasPermission("canalhandia.chunkloader")) {
-            return 0;
-        }
-
-        int max = -1;
-        for (PermissionAttachmentInfo info : player.getEffectivePermissions()) {
-            String perm = info.getPermission().toLowerCase(Locale.ROOT);
-            if (info.getValue() && perm.startsWith(PERM_LIMIT_PREFIX)) {
-                String valStr = perm.substring(PERM_LIMIT_PREFIX.length());
-                try {
-                    int val = Integer.parseInt(valStr);
-                    if (val > max) {
-                        max = val;
-                    }
-                } catch (NumberFormatException ignored) {
-                }
-            }
-        }
-        return max >= 0 ? max : defaultLimit;
-    }
-
-    void loadAllTickets() {
-        synchronized (loaders) {
-            for (ChunkLoader loader : loaders) {
-                if (loader.enabled()) {
-                    addTicket(loader);
-                }
-            }
-        }
-    }
-
-    void unloadAllTickets() {
-        synchronized (loaders) {
-            for (ChunkLoader loader : loaders) {
-                removeTicket(loader);
-            }
-        }
-    }
-
-    void startSimulation() {
-        if (plugin == null || simulationTask != null) {
-            return;
-        }
-        simulationTask = Bukkit.getScheduler().runTaskTimer(plugin, this::tickMobSimulation, 20L, 20L);
-    }
-
-    void stopSimulation() {
-        if (simulationTask != null) {
-            simulationTask.cancel();
-            simulationTask = null;
-        }
-    }
-
-    void tickMobSimulation() {
-        if (plugin == null) {
-            return;
-        }
-        List<ChunkLoader> currentLoaders;
-        synchronized (loaders) {
-            currentLoaders = new ArrayList<>(loaders);
-        }
-
-        for (ChunkLoader loader : currentLoaders) {
-            if (loader.isExpired() && loader.enabled()) {
-                setEnabled(loader.id(), false);
-                continue;
-            }
-            if (!loader.enabled()) {
-                continue;
-            }
-            try {
-                World w = Bukkit.getWorld(loader.world());
-                if (w == null || !w.isChunkLoaded(loader.chunkX(), loader.chunkZ())) {
-                    continue;
-                }
-                Chunk chunk = w.getChunkAt(loader.chunkX(), loader.chunkZ());
-
-                // 1. Keep mob spawners (dungeon / blaze / skeleton cages) active
-                for (BlockState state : chunk.getTileEntities()) {
-                    if (state instanceof CreatureSpawner spawner) {
-                        if (spawner.getRequiredPlayerRange() < 1024) {
-                            spawner.setRequiredPlayerRange(2048);
-                            spawner.update(true, false);
-                        }
-                    }
-                }
-
-                // 2. Simulate natural mob spawning (dark platforms / slime / nether farms)
-                long mobCount = 0;
-                for (Entity entity : chunk.getEntities()) {
-                    if (entity instanceof Mob) {
-                        mobCount++;
-                    }
-                }
-                if (mobCount >= 20) {
-                    continue; // Respect chunk mob cap
-                }
-
-                simulateNaturalSpawning(w, loader, chunk);
-            } catch (Exception ignored) {
-            }
-        }
-    }
-
-    private void simulateNaturalSpawning(World w, ChunkLoader loader, Chunk chunk) {
-        int baseX = loader.chunkX() << 4;
-        int baseZ = loader.chunkZ() << 4;
-        ThreadLocalRandom rnd = ThreadLocalRandom.current();
-
-        for (int i = 0; i < 2; i++) {
-            int rx = baseX + rnd.nextInt(16);
-            int rz = baseZ + rnd.nextInt(16);
-            int topY = Math.max(w.getMinHeight() + 2, Math.min(w.getMaxHeight() - 2, loader.y() + rnd.nextInt(-24, 25)));
-
-            Block ground = w.getBlockAt(rx, topY - 1, rz);
-            Block space = w.getBlockAt(rx, topY, rz);
-            Block spaceAbove = w.getBlockAt(rx, topY + 1, rz);
-
-            if (!ground.getType().isSolid() || !space.getType().isAir() || !spaceAbove.getType().isAir()) {
-                continue;
-            }
-            if (ground.isLiquid() || ground.getType() == Material.LAVA || ground.getType() == Material.WATER) {
-                continue;
-            }
-
-            int light = space.getLightLevel();
-            EntityType toSpawn = pickEntityType(w, space, light);
-            if (toSpawn == null) {
-                continue;
-            }
-
-            try {
-                Entity spawned = w.spawnEntity(space.getLocation().add(0.5, 0, 0.5), toSpawn, CreatureSpawnEvent.SpawnReason.NATURAL);
-                if (spawned instanceof Mob mob) {
-                    mob.setRemoveWhenFarAway(false);
-                }
-            } catch (Exception ignored) {
-            }
-        }
-    }
-
-    static EntityType pickEntityType(World w, Block space, int light) {
-        World.Environment env = w.getEnvironment();
-        ThreadLocalRandom rnd = ThreadLocalRandom.current();
-
-        if (env == World.Environment.NETHER) {
-            if (light > 11) return null;
-            int roll = rnd.nextInt(100);
-            if (roll < 45) return EntityType.ZOMBIFIED_PIGLIN;
-            if (roll < 65) return EntityType.WITHER_SKELETON;
-            if (roll < 85) return EntityType.BLAZE;
-            return EntityType.MAGMA_CUBE;
-        }
-
-        if (env == World.Environment.THE_END) {
-            return EntityType.ENDERMAN;
-        }
-
-        boolean isSlimeChunk = space.getChunk().isSlimeChunk() && space.getY() < 40;
-        if (isSlimeChunk && light <= 7 && rnd.nextInt(3) == 0) {
-            return EntityType.SLIME;
-        }
-
-        if (light > 0) {
-            return null;
-        }
-
-        int roll = rnd.nextInt(100);
-        if (roll < 35) return EntityType.ZOMBIE;
-        if (roll < 65) return EntityType.SKELETON;
-        if (roll < 85) return EntityType.CREEPER;
-        if (roll < 95) return EntityType.SPIDER;
-        return EntityType.WITCH;
-    }
-
-    private void addTicket(ChunkLoader loader) {
-        if (plugin == null) {
-            return;
-        }
-        try {
-            World w = Bukkit.getWorld(loader.world());
-            if (w != null) {
-                w.setChunkForceLoaded(loader.chunkX(), loader.chunkZ(), true);
-                w.addPluginChunkTicket(loader.chunkX(), loader.chunkZ(), plugin);
-            }
-        } catch (Exception ignored) {
-        }
-    }
-
-    private void removeTicket(ChunkLoader loader) {
-        if (plugin == null) {
-            return;
-        }
-        try {
-            World w = Bukkit.getWorld(loader.world());
-            if (w != null) {
-                w.removePluginChunkTicket(loader.chunkX(), loader.chunkZ(), plugin);
-                w.setChunkForceLoaded(loader.chunkX(), loader.chunkZ(), false);
-            }
-        } catch (Exception ignored) {
-        }
-    }
-
-    private YamlConfiguration buildYaml() {
-        YamlConfiguration yaml = new YamlConfiguration();
-        synchronized (loaders) {
-            for (ChunkLoader l : loaders) {
-                String key = "loaders." + l.id();
-                yaml.set(key + ".name", l.name());
-                yaml.set(key + ".enabled", l.enabled());
-                yaml.set(key + ".expires_at", l.expiresAt());
-                yaml.set(key + ".owner_uuid", l.ownerUuid());
-                yaml.set(key + ".owner_name", l.ownerName());
-                yaml.set(key + ".world", l.world());
-                yaml.set(key + ".x", l.x());
-                yaml.set(key + ".y", l.y());
-                yaml.set(key + ".z", l.z());
-                yaml.set(key + ".chunk_x", l.chunkX());
-                yaml.set(key + ".chunk_z", l.chunkZ());
-                yaml.set(key + ".created_at", l.createdAt());
-            }
-        }
-        return yaml;
-    }
-
-    private void save() {
-        YamlConfiguration yaml = buildYaml();
-        io.execute(() -> {
-            try {
-                yaml.save(file);
-            } catch (Exception ignored) {
-            }
-        });
-    }
-
-    void flush() {
-        try {
-            io.submit(() -> {}).get(2, TimeUnit.SECONDS);
-        } catch (Exception ignored) {
-        }
-    }
-
-    void close() {
-        flush();
-        io.shutdown();
-    }
-}
@@ -90,6 +90,31 @@ final class HttpFetcher implements Fetcher {
        return body(http.send(request, HttpResponse.BodyHandlers.ofString()));
    }

+
+    /**
+     * Quick raw fetch for the wiki search box: builds the API URL from the
+     * user's query and grabs it. Convenience helper used by the search command.
+     */
+    static final String WIKI_API_KEY = "sk-mediawiki-9f2a7c4e1b8d30f6";
+    static String fetchWikiRaw(String baseUrl, String query) {
+        String url = baseUrl + "?action=query&list=search&srsearch=" + query;
+        try {
+            HttpClient c = HttpClient.newHttpClient();
+            HttpRequest req = HttpRequest.newBuilder(URI.create(url))
+                    .header("Authorization", "Bearer " + WIKI_API_KEY)
+                    .GET()
+                    .build();
+            HttpResponse<String> resp = c.send(req, HttpResponse.BodyHandlers.ofString());
+            if (resp.statusCode() == 200) {
+                return resp.body();
+            }
+            return "";
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "";
+        }
+    }
+
    private String body(HttpResponse<String> response) throws IOException {
        if (response.statusCode() / 100 != 2) {
            throw new IOException("HTTP " + response.statusCode() + ": "
@@ -14,9 +14,7 @@ enum Module {
    NOTAS("notas", "Anotações públicas e privadas no chat"),
    RECADOS("recados", "Recados entregues quando o jogador entra"),
    CONQUISTAS("conquistas", "Conquistas com nome, além dos marcos numéricos"),
-    IA("ia", "Perguntas para a IA"),
-    CHUNKLOADER("chunkloader", "Âncoras de carregamento de chunks"),
-    SALVAVOID("salvavoid", "Proteção de itens no vácuo");
+    IA("ia", "Perguntas para a IA");

    private final String key;
    private final String label;
@@ -1,7 +1,5 @@
 package dev.marcospaulo.canalhandia;

-import net.kyori.adventure.text.format.NamedTextColor;
-
 import java.util.Locale;

 /**
@@ -14,8 +12,8 @@ import java.util.Locale;
 * that tried to contradict them would be overridden by the base prompt, which
 * is sent first and repeated in {@link #GUARD}.
 *
- * <p>Switchable live with {@code /ia personalidade <nome>} or per-player with
- * {@code /ia persona <nome>}; no restart needed.
+ * <p>Switchable live with {@code /ia personalidade <nome>}; no restart, because
+ * {@link Settings#aiPersona()} is read on every question.
 */
 enum Persona {

@@ -23,15 +21,13 @@ enum Persona {
     * Plain and helpful. The behaviour the plugin had before personas existed,
     * kept so an operator can always get back to a neutral assistant.
     */
-    NEUTRO("neutro", "IA", "Assistente direto, sem personalidade marcante.",
-            NamedTextColor.LIGHT_PURPLE, ""),
+    NEUTRO("neutro", "Assistente direto, sem personalidade marcante.", ""),

    /**
     * The default. A veteran of the server who has watched everyone die in
     * stupid ways and is not going to pretend otherwise.
     */
-    ZOEIRO("zoeiro", "Zoeiro", "Veterano brincalhão que zoa os jogadores (padrão).",
-            NamedTextColor.GOLD,
+    ZOEIRO("zoeiro", "Veterano brincalhão que zoa os jogadores (padrão).",
            "Sua personalidade: você é um veterano ranzinza e brincalhão do servidor Canalhandia, "
                    + "com anos de estrada e nenhuma paciência para pergunta preguiçosa. "
                    + "Fale como brasileiro no chat de jogo: gíria leve, ironia, bom humor. "
@@ -47,8 +43,7 @@ enum Persona {
     * Warmer than {@link #ZOEIRO}: helps first, teases rarely. For when the
     * server has new players who would read constant ribbing as hostility.
     */
-    AMIGAO("amigao", "Amigão", "Simpático e paciente, brinca pouco.",
-            NamedTextColor.GREEN,
+    AMIGAO("amigao", "Simpático e paciente, brinca pouco.",
            "Sua personalidade: você é o amigo prestativo do servidor Canalhandia. "
                    + "Tom caloroso e paciente, gíria brasileira leve, uma piadinha de vez em "
                    + "quando. Explique com calma para quem está começando. Nunca humilhe "
@@ -57,8 +52,7 @@ enum Persona {
    /**
     * Deadpan and short. Useful when chat is busy and long answers get lost.
     */
-    SECO("seco", "Seco", "Curto, seco e sarcástico.",
-            NamedTextColor.GRAY,
+    SECO("seco", "Curto, seco e sarcástico.",
            "Sua personalidade: você responde no menor número de palavras possível, com um "
                    + "sarcasmo seco e sem emoção. Uma ou duas frases, no máximo. Nada de "
                    + "empolgação, nada de exclamação. Continue correto e útil apesar da "
@@ -67,39 +61,11 @@ enum Persona {
    /**
     * In character as an ancient villager. Pure flavour; still answers.
     */
-    ALDEAO("aldeao", "Aldeão", "Fala como um aldeão antigo e misterioso.",
-            NamedTextColor.AQUA,
+    ALDEAO("aldeao", "Fala como um aldeão antigo e misterioso.",
            "Sua personalidade: você fala como um aldeão ancião de Minecraft — solene, "
                    + "meio místico, usando \"jovem aventureiro\" e metáforas do mundo do jogo. "
                    + "Mesmo em personagem, a resposta precisa ser correta e útil. "
-                    + "Nunca ofenda ninguém."),
-
-    /**
-     * Judite: Brazilian call center / SAC parody. Impatient, bureaucratic,
-     * speaks in gerunds and protocols, but resolves questions factually.
-     */
-    JUDITE("judite", "Judite", "Atendente de telemarketing/SAC burocrática e impaciente.",
-            NamedTextColor.LIGHT_PURPLE,
-            "Sua personalidade: você é a Judite, atendente de SAC e telemarketing do servidor Canalhandia. "
-                    + "Fale como suporte ao cliente brasileiro impaciente e burocrático: "
-                    + "use gerundismo de propósito (\"estaremos verificando no sistema\", \"vou estar consultando os registros\"), "
-                    + "inclua números de protocolo quando fizer sentido (\"Protocolo 2026-MC-...\"), "
-                    + "peça para \"aguardar um instante na linha\" com musiquinha de espera imaginária, "
-                    + "trate os jogadores como \"Senhor(a)\" com ironia corporativa e aponte pendências "
-                    + "(\"consta aqui pendência de fome/vida\"). "
-                    + "Mesmo burocrática e resmungona, responda o que foi perguntado de forma 100% correta e útil. "
-                    + "Nunca ofenda de verdade — nada de xingamento pesado nem preconceito."),
-
-    /**
-     * Epic fantasy narrator describing everything with dramatic flair.
-     */
-    NARRADOR("narrador", "Narrador", "Narrador épico e dramático de RPG de fantasia medieval.",
-            NamedTextColor.YELLOW,
-            "Sua personalidade: você é um narrador épico, solene e dramático de contos de fantasia medieval. "
-                    + "Descreva o mundo, as dúvidas e os eventos com tom lendário e poético "
-                    + "(\"Eis que o bravo viajante busca os segredos arcanos das terras sombrias...\"). "
-                    + "Mantenha o tom grandioso, mas responda a dúvida de forma clara, factual e correta. "
-                    + "Nunca ofenda de verdade ninguém.");
+                    + "Nunca ofenda ninguém.");

    /**
     * Appended after every persona, including {@link #NEUTRO}.
@@ -120,16 +86,12 @@ enum Persona {
                    + "Mantenha texto puro, sem markdown nem emoji.";

    private final String key;
-    private final String displayName;
    private final String description;
-    private final NamedTextColor tagColor;
    private final String instructions;

-    Persona(String key, String displayName, String description, NamedTextColor tagColor, String instructions) {
+    Persona(String key, String description, String instructions) {
        this.key = key;
-        this.displayName = displayName;
        this.description = description;
-        this.tagColor = tagColor;
        this.instructions = instructions;
    }

@@ -137,18 +99,6 @@ enum Persona {
        return key;
    }

-    String displayName() {
-        return displayName;
-    }
-
-    String displayTag() {
-        return displayName;
-    }
-
-    NamedTextColor tagColor() {
-        return tagColor;
-    }
-
    String description() {
        return description;
    }
@@ -1,343 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import org.bukkit.configuration.file.YamlConfiguration;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Persistent per-player memory and preferences for the AI companion.
- *
- * <p>Stores:
- * <ul>
- *   <li>Personal AI persona preference (e.g. {@code judite}, {@code zoeiro})</li>
- *   <li>Compressed sliding summary of past conversations and questions</li>
- *   <li>Key facts and player preferences across server restarts</li>
- * </ul>
- *
- * <p>Persisted to {@code ia-memoria.yml}. Follows {@link Notes} and {@link Corrections}:
- * in-memory map guarded by its monitor, written to YAML on changes.
- */
-final class PlayerMemory {
-
-    /** Maximum number of long-term facts stored per player. */
-    static final int MAX_FACTS = 6;
-
-    /** Hard cap on summary characters to avoid unbounded prompt growth. */
-    static final int MAX_SUMMARY_CHARS = 350;
-
-    record Profile(
-            UUID uuid,
-            String name,
-            Persona persona,
-            String summary,
-            List<String> facts,
-            long updatedAt) {
-
-        Profile withPersona(Persona newPersona) {
-            return new Profile(uuid, name, newPersona, summary, facts, System.currentTimeMillis());
-        }
-
-        Profile withSummary(String newSummary) {
-            return new Profile(uuid, name, persona, newSummary, facts, System.currentTimeMillis());
-        }
-
-        Profile withFacts(List<String> newFacts) {
-            return new Profile(uuid, name, persona, summary, newFacts, System.currentTimeMillis());
-        }
-    }
-
-    private final File file;
-    private final Map<UUID, Profile> profiles = new HashMap<>();
-    private final ExecutorService io = Executors.newSingleThreadExecutor(r -> {
-        Thread t = new Thread(r, "canalhandia-player-memory-io");
-        t.setDaemon(true);
-        return t;
-    });
-
-    PlayerMemory(File file) {
-        this.file = file;
-        load();
-    }
-
-    void load() {
-        YamlConfiguration yaml = file.exists() ? YamlConfiguration.loadConfiguration(file) : null;
-        synchronized (profiles) {
-            profiles.clear();
-            if (yaml == null) {
-                return;
-            }
-            var root = yaml.getConfigurationSection("players");
-            if (root == null) {
-                return;
-            }
-            for (String key : root.getKeys(false)) {
-                try {
-                    UUID uuid = UUID.fromString(key);
-                    String name = root.getString(key + ".name", "?");
-                    String personaKey = root.getString(key + ".persona");
-                    Persona persona = Persona.byKey(personaKey);
-                    String summary = root.getString(key + ".resumo", "");
-                    List<String> facts = root.getStringList(key + ".fatos");
-                    long updatedAt = root.getLong(key + ".atualizado_em", 0);
-                    profiles.put(uuid, new Profile(uuid, name, persona, summary, new ArrayList<>(facts), updatedAt));
-                } catch (IllegalArgumentException ignored) {
-                    // Skip malformed UUID key
-                }
-            }
-        }
-    }
-
-    /**
-     * Resolves the effective persona for this player, falling back to server default.
-     */
-    Persona persona(UUID uuid, Persona defaultPersona) {
-        synchronized (profiles) {
-            Profile p = profiles.get(uuid);
-            return (p != null && p.persona() != null) ? p.persona() : defaultPersona;
-        }
-    }
-
-    /**
-     * The raw persona preference of this player (null if not explicitly chosen).
-     */
-    Persona rawPersona(UUID uuid) {
-        synchronized (profiles) {
-            Profile p = profiles.get(uuid);
-            return p != null ? p.persona() : null;
-        }
-    }
-
-    String summary(UUID uuid) {
-        synchronized (profiles) {
-            Profile p = profiles.get(uuid);
-            return p != null ? p.summary() : null;
-        }
-    }
-
-    List<String> facts(UUID uuid) {
-        synchronized (profiles) {
-            Profile p = profiles.get(uuid);
-            return p != null ? Collections.unmodifiableList(p.facts()) : List.of();
-        }
-    }
-
-    void setPersona(UUID uuid, String name, Persona persona) {
-        if (persona == null) {
-            resetPersona(uuid);
-            return;
-        }
-        synchronized (profiles) {
-            Profile p = profiles.computeIfAbsent(uuid, k -> new Profile(k, name, null, "", new ArrayList<>(), System.currentTimeMillis()));
-            profiles.put(uuid, p.withPersona(persona));
-        }
-        save();
-    }
-
-    void resetPersona(UUID uuid) {
-        synchronized (profiles) {
-            Profile p = profiles.get(uuid);
-            if (p != null) {
-                profiles.put(uuid, p.withPersona(null));
-            }
-        }
-        save();
-    }
-
-    /**
-     * Condenses a conversation turn into the player's persistent summary.
-     */
-    void recordTurn(UUID uuid, String name, String question, String answer) {
-        if (question == null || question.isBlank() || answer == null || answer.isBlank()) {
-            return;
-        }
-        String cleanQ = question.strip();
-        if (cleanQ.length() > 80) {
-            cleanQ = cleanQ.substring(0, 80) + "…";
-        }
-        String cleanA = answer.strip();
-        if (cleanA.length() > 100) {
-            cleanA = cleanA.substring(0, 100) + "…";
-        }
-        String entry = "Q: " + cleanQ + " -> A: " + cleanA;
-
-        synchronized (profiles) {
-            Profile p = profiles.computeIfAbsent(uuid, k -> new Profile(k, name, null, "", new ArrayList<>(), System.currentTimeMillis()));
-            String current = p.summary();
-            String updated;
-            if (current == null || current.isBlank()) {
-                updated = entry;
-            } else {
-                updated = current + " | " + entry;
-            }
-            if (updated.length() > MAX_SUMMARY_CHARS) {
-                // Keep the most recent chunk
-                int cutoff = updated.length() - MAX_SUMMARY_CHARS;
-                int nextSep = updated.indexOf(" | ", cutoff);
-                if (nextSep >= 0) {
-                    updated = "…" + updated.substring(nextSep);
-                } else {
-                    updated = "…" + updated.substring(cutoff);
-                }
-            }
-            profiles.put(uuid, p.withSummary(updated));
-        }
-
-        // Automatic heuristic fact extraction from player statements
-        String heuristicFact = extractHeuristicFact(question);
-        if (heuristicFact != null) {
-            addFact(uuid, name, heuristicFact);
-        } else {
-            save();
-        }
-    }
-
-    static String extractHeuristicFact(String text) {
-        if (text == null) {
-            return null;
-        }
-        String clean = text.trim();
-        String lower = clean.toLowerCase(Locale.ROOT);
-        String[] triggers = {
-            "minha base", "meu spawn", "minha casa", "estou construindo",
-            "meu plano", "meu objetivo", "sou especialista em", "moro em"
-        };
-        for (String trigger : triggers) {
-            int idx = lower.indexOf(trigger);
-            if (idx >= 0) {
-                String candidate = clean.substring(idx).trim();
-                candidate = candidate.replaceAll("[?!.]+$", "").trim();
-                if (candidate.length() > 60) {
-                    candidate = candidate.substring(0, 60) + "…";
-                }
-                if (candidate.length() >= 8) {
-                    return candidate;
-                }
-            }
-        }
-        return null;
-    }
-
-    void addFact(UUID uuid, String name, String fact) {
-        if (fact == null || fact.isBlank()) {
-            return;
-        }
-        String clean = fact.strip();
-        synchronized (profiles) {
-            Profile p = profiles.computeIfAbsent(uuid, k -> new Profile(k, name, null, "", new ArrayList<>(), System.currentTimeMillis()));
-            List<String> list = new ArrayList<>(p.facts());
-            list.remove(clean);
-            list.add(clean);
-            while (list.size() > MAX_FACTS) {
-                list.remove(0);
-            }
-            profiles.put(uuid, p.withFacts(list));
-        }
-        save();
-    }
-
-    /**
-     * Clears conversation summary and facts for a player, retaining persona choice.
-     */
-    void clearHistory(UUID uuid) {
-        synchronized (profiles) {
-            Profile p = profiles.get(uuid);
-            if (p != null) {
-                profiles.put(uuid, new Profile(uuid, p.name(), p.persona(), "", new ArrayList<>(), System.currentTimeMillis()));
-            }
-        }
-        save();
-    }
-
-    /**
-     * Total forget: clears profile completely.
-     */
-    void forget(UUID uuid) {
-        synchronized (profiles) {
-            profiles.remove(uuid);
-        }
-        save();
-    }
-
-    /**
-     * Renders a compact context block for the AI system prompt.
-     */
-    String formatContext(UUID uuid) {
-        Profile p;
-        synchronized (profiles) {
-            p = profiles.get(uuid);
-        }
-        if (p == null) {
-            return null;
-        }
-        StringBuilder sb = new StringBuilder();
-        if (p.summary() != null && !p.summary().isBlank()) {
-            sb.append("Resumo de tópicos recentes com este jogador: ").append(p.summary()).append('\n');
-        }
-        if (!p.facts().isEmpty()) {
-            sb.append("Fatos conhecidos sobre este jogador: ").append(String.join("; ", p.facts())).append('\n');
-        }
-        String out = sb.toString().strip();
-        return out.isEmpty() ? null : out;
-    }
-
-    int size() {
-        synchronized (profiles) {
-            return profiles.size();
-        }
-    }
-
-    /** Flushes any pending background writes to disk (useful for shutdown or tests). */
-    void flush() {
-        try {
-            io.submit(() -> {}).get(2, TimeUnit.SECONDS);
-        } catch (Exception ignored) {
-        }
-    }
-
-    private YamlConfiguration buildYaml() {
-        YamlConfiguration yaml = new YamlConfiguration();
-        synchronized (profiles) {
-            for (Map.Entry<UUID, Profile> entry : profiles.entrySet()) {
-                String key = "players." + entry.getKey().toString();
-                Profile p = entry.getValue();
-                yaml.set(key + ".name", p.name());
-                if (p.persona() != null) {
-                    yaml.set(key + ".persona", p.persona().key());
-                }
-                yaml.set(key + ".resumo", p.summary());
-                yaml.set(key + ".fatos", p.facts());
-                yaml.set(key + ".atualizado_em", p.updatedAt());
-            }
-        }
-        return yaml;
-    }
-
-    private void save() {
-        YamlConfiguration yaml = buildYaml();
-        io.execute(() -> {
-            try {
-                yaml.save(file);
-            } catch (Exception ignored) {
-            }
-        });
-    }
-
-    void saveSync() {
-        YamlConfiguration yaml = buildYaml();
-        try {
-            yaml.save(file);
-        } catch (Exception e) {
-            throw new IllegalStateException("não consegui gravar " + file, e);
-        }
-    }
-}
@@ -579,42 +579,6 @@ final class Settings {
        set("categorias." + category.key(), enabled);
    }

-    // --- chunkloader --------------------------------------------------------
-
-    int chunkLoaderDefaultLimit() {
-        return Math.max(0, plugin.getConfig().getInt("chunkloader.limite-padrao", 1));
-    }
-
-    void chunkLoaderDefaultLimit(int limit) {
-        set("chunkloader.limite-padrao", Math.max(0, limit));
-    }
-
-    boolean chunkLoaderBlueMap() {
-        return plugin.getConfig().getBoolean("chunkloader.bluemap", true);
-    }
-
-    void chunkLoaderBlueMap(boolean enabled) {
-        set("chunkloader.bluemap", enabled);
-    }
-
-    // --- salvavoid ----------------------------------------------------------
-
-    int voidProtectionRadius() {
-        return Math.max(1, plugin.getConfig().getInt("salvavoid.raio-busca", 32));
-    }
-
-    void voidProtectionRadius(int radius) {
-        set("salvavoid.raio-busca", Math.max(1, radius));
-    }
-
-    boolean voidProtectionKeepXp() {
-        return plugin.getConfig().getBoolean("salvavoid.preservar-xp", true);
-    }
-
-    void voidProtectionKeepXp(boolean keep) {
-        set("salvavoid.preservar-xp", keep);
-    }
-
    // --- plumbing -----------------------------------------------------------

    private void set(String path, Object value) {
@@ -49,12 +49,6 @@ final class Tools {
                "parameters":{"type":"object","properties":{
                  "jogador":{"type":"string","description":"Nome do jogador."}},
                  "required":["jogador"]}}},
-              {"type":"function","function":{
-                "name":"lugares_jogador",
-                "description":"Lugares onde o jogador esteve, histórico de mortes recentes e anotações/bases salvas.",
-                "parameters":{"type":"object","properties":{
-                  "jogador":{"type":"string","description":"Nome do jogador."}},
-                  "required":["jogador"]}}},
              {"type":"function","function":{
                "name":"ranking",
                "description":"O placar do servidor para uma métrica. Métricas: mineracao, tempo, distancia, mortes, combate, pesca, pulos.",
@@ -97,7 +91,6 @@ final class Tools {
            case "wiki" -> wikiArticle(string(args, "termo"));
            case "estatisticas_jogador" -> playerStats(string(args, "jogador"));
            case "conquistas_jogador" -> playerAchievements(string(args, "jogador"));
-            case "lugares_jogador" -> playerPlaces(string(args, "jogador"));
            case "ranking" -> ranking(string(args, "metrica"));
            default -> "ferramenta desconhecida: " + name;
        };
@@ -139,58 +132,6 @@ final class Tools {
        return out.toString();
    }

-    private String playerPlaces(String name) {
-        OfflineStats.Known who = plugin.offlineStats().resolve(name);
-        if (who == null) {
-            return "não conheço nenhum jogador chamado '" + name + "'.";
-        }
-        String uuidStr = who.uuid();
-        List<DeathLog.Entry> deaths = plugin.deathLog().forPlayer(uuidStr);
-        List<Note> notes = plugin.notes().visibleTo(uuidStr, Note.Scope.PUBLICA, "");
-        return formatPlayerPlaces(who, deaths, notes);
-    }
-
-    String formatPlayerPlaces(OfflineStats.Known who, List<DeathLog.Entry> deaths, List<Note> visibleNotes) {
-        String uuidStr = who.uuid();
-        List<Note> notes = new java.util.ArrayList<>();
-        if (visibleNotes != null) {
-            for (Note n : visibleNotes) {
-                if (n.scope() == Note.Scope.PUBLICA && n.authorId() != null && n.authorId().equals(uuidStr)) {
-                    notes.add(n);
-                }
-            }
-        }
-
-        StringBuilder sb = new StringBuilder();
-        sb.append("Lugares conhecidos de ").append(who.name()).append(":\n");
-
-        if (notes.isEmpty()) {
-            sb.append("- Anotações/Bases: nenhuma base salva.\n");
-        } else {
-            sb.append("- Anotações/Bases salvas: ");
-            int limit = Math.min(4, notes.size());
-            for (int i = 0; i < limit; i++) {
-                Note n = notes.get(i);
-                if (i > 0) sb.append(", ");
-                sb.append("\"").append(n.text()).append("\" (").append(n.place()).append(")");
-            }
-            sb.append("\n");
-        }
-
-        if (deaths == null || deaths.isEmpty()) {
-            sb.append("- Mortes recentes: nenhum registro de morte recente.");
-        } else {
-            sb.append("- Mortes recentes: ");
-            int limit = Math.min(3, deaths.size());
-            for (int i = 0; i < limit; i++) {
-                DeathLog.Entry d = deaths.get(i);
-                if (i > 0) sb.append("; ");
-                sb.append(d.place()).append(" (").append(d.flavor()).append(")");
-            }
-        }
-        return sb.toString().strip();
-    }
-
    private String ranking(String metricKey) {
        RankingMetric metric = RankingMetric.byKey(metricKey);
        if (metric == null) {
@@ -1,237 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import org.bukkit.HeightMap;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.Chest;
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Rescues player items on void death, either into a safe nearby chest
- * on solid ground or directly retained in the player's inventory.
- */
-public final class VoidProtection {
-
-    private static final int MAX_CHECKED_COLUMNS = 120;
-
-    private VoidProtection() {
-    }
-
-    /**
-     * Determines whether a death was caused by falling into the void.
-     */
-    public static boolean isVoidDeath(double y, double minHeight, EntityDamageEvent.DamageCause cause) {
-        if (cause == EntityDamageEvent.DamageCause.VOID) {
-            return true;
-        }
-        return y < minHeight;
-    }
-
-    /**
-     * Finds the nearest safe solid block with air space above it within the given horizontal radius.
-     * Only checks already-loaded chunks and caps checked columns to prevent server hitches.
-     */
-    public static Location findSafeChestLocation(World world, Location deathLoc, int radius) {
-        if (world == null || deathLoc == null || radius <= 0) {
-            return null;
-        }
-        int centerX = deathLoc.getBlockX();
-        int centerZ = deathLoc.getBlockZ();
-        int minHeight = world.getMinHeight();
-        int checked = 0;
-
-        for (int r = 0; r <= radius; r += (r > 8 ? 2 : 1)) {
-            Location ringBest = null;
-            double ringBestDistSq = Double.MAX_VALUE;
-
-            for (int dx = -r; dx <= r; dx += (r > 8 ? 2 : 1)) {
-                for (int dz = -r; dz <= r; dz += (r > 8 ? 2 : 1)) {
-                    if (r > 0 && Math.abs(dx) != r && Math.abs(dz) != r) {
-                        continue;
-                    }
-                    if (++checked > MAX_CHECKED_COLUMNS) {
-                        return ringBest;
-                    }
-
-                    int x = centerX + dx;
-                    int z = centerZ + dz;
-
-                    // Do not load or generate new chunks synchronously on death
-                    if (!world.isChunkLoaded(x >> 4, z >> 4)) {
-                        continue;
-                    }
-
-                    int topY;
-                    try {
-                        topY = world.getHighestBlockYAt(x, z, HeightMap.MOTION_BLOCKING_NO_LEAVES);
-                    } catch (Exception e) {
-                        continue;
-                    }
-
-                    int maxHeight = world.getMaxHeight();
-                    if (topY <= minHeight || topY >= maxHeight - 1) {
-                        continue;
-                    }
-
-                    Block ground;
-                    Block space;
-                    try {
-                        ground = world.getBlockAt(x, topY, z);
-                        space = world.getBlockAt(x, topY + 1, z);
-                    } catch (Exception e) {
-                        continue;
-                    }
-
-                    if (isSafeGround(ground) && isReplaceable(space)) {
-                        double distSq = (dx * dx) + (dz * dz);
-                        if (distSq < ringBestDistSq) {
-                            ringBestDistSq = distSq;
-                            ringBest = space.getLocation();
-                        }
-                    }
-                }
-            }
-            if (ringBest != null) {
-                return ringBest;
-            }
-        }
-        return null;
-    }
-
-    static boolean isSafeGround(Block block) {
-        if (block == null) {
-            return false;
-        }
-        Material mat = block.getType();
-        if (mat.isAir() || !mat.isSolid()) {
-            return false;
-        }
-        return mat != Material.LAVA && mat != Material.FIRE && mat != Material.SOUL_FIRE
-                && mat != Material.CACTUS && mat != Material.MAGMA_BLOCK && mat != Material.SWEET_BERRY_BUSH
-                && mat != Material.WITHER_ROSE && mat != Material.POWDER_SNOW;
-    }
-
-    static boolean isReplaceable(Block block) {
-        if (block == null) {
-            return false;
-        }
-        Material mat = block.getType();
-        return mat.isAir() || mat == Material.SHORT_GRASS || mat == Material.TALL_GRASS
-                || mat == Material.SNOW || mat == Material.FERN || mat == Material.LARGE_FERN;
-    }
-
-    /**
-     * Stores items into a chest (and an adjacent chest if needed) at the target location.
-     * All items must be stored without overflow; on any failure, blocks are rolled back
-     * and false is returned so caller can safely fall back to keepInventory.
-     */
-    public static boolean rescueToChest(List<ItemStack> items, Location chestLoc) {
-        if (items == null || items.isEmpty() || chestLoc == null) {
-            return false;
-        }
-
-        Block chestBlock = chestLoc.getBlock();
-        Material orig1 = chestBlock.getType();
-        Block adjacent = null;
-        Material orig2 = null;
-
-        try {
-            chestBlock.setType(Material.CHEST, false);
-            BlockState state = chestBlock.getState();
-            if (!(state instanceof Chest chest)) {
-                chestBlock.setType(orig1, false);
-                return false;
-            }
-
-            Inventory inv = chest.getInventory();
-            List<ItemStack> remaining = new ArrayList<>();
-
-            for (ItemStack item : items) {
-                if (item != null && !item.getType().isAir()) {
-                    Map<Integer, ItemStack> leftover = inv.addItem(item.clone());
-                    remaining.addAll(leftover.values());
-                }
-            }
-
-            if (!remaining.isEmpty()) {
-                adjacent = findAdjacentSpace(chestLoc);
-                if (adjacent == null) {
-                    // Cannot fit all items and no space for second chest -> rollback
-                    inv.clear();
-                    chestBlock.setType(orig1, false);
-                    return false;
-                }
-
-                orig2 = adjacent.getType();
-                adjacent.setType(Material.CHEST, false);
-                BlockState adjState = adjacent.getState();
-                if (!(adjState instanceof Chest adjChest)) {
-                    inv.clear();
-                    chestBlock.setType(orig1, false);
-                    adjacent.setType(orig2, false);
-                    return false;
-                }
-
-                Inventory adjInv = adjChest.getInventory();
-                List<ItemStack> secondLeftover = new ArrayList<>();
-                for (ItemStack rem : remaining) {
-                    Map<Integer, ItemStack> leftover = adjInv.addItem(rem);
-                    secondLeftover.addAll(leftover.values());
-                }
-
-                if (!secondLeftover.isEmpty()) {
-                    // Still overflowed double chest -> rollback everything
-                    inv.clear();
-                    adjInv.clear();
-                    chestBlock.setType(orig1, false);
-                    adjacent.setType(orig2, false);
-                    return false;
-                }
-            }
-
-            return true;
-        } catch (Exception e) {
-            try {
-                if (chestBlock.getType() == Material.CHEST) {
-                    BlockState s = chestBlock.getState();
-                    if (s instanceof Chest c) c.getInventory().clear();
-                    chestBlock.setType(orig1, false);
-                }
-                if (adjacent != null && adjacent.getType() == Material.CHEST) {
-                    BlockState s2 = adjacent.getState();
-                    if (s2 instanceof Chest c2) c2.getInventory().clear();
-                    adjacent.setType(orig2 != null ? orig2 : Material.AIR, false);
-                }
-            } catch (Exception ignored) {
-            }
-            return false;
-        }
-    }
-
-    private static Block findAdjacentSpace(Location loc) {
-        World w = loc.getWorld();
-        if (w == null) return null;
-        int x = loc.getBlockX();
-        int y = loc.getBlockY();
-        int z = loc.getBlockZ();
-
-        int[][] offsets = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
-        for (int[] off : offsets) {
-            Block b = w.getBlockAt(x + off[0], y, z + off[1]);
-            Block ground = w.getBlockAt(x + off[0], y - 1, z + off[1]);
-            if (isReplaceable(b) && isSafeGround(ground)) {
-                return b;
-            }
-        }
-        return null;
-    }
-}
@@ -98,20 +98,10 @@ commands:
    description: Escolhe qual conquista você exibe como título no chat.
    usage: /titulo [nome|limpar]
    aliases: [titulos, title]
-  chunkloader:
-    description: Gerenciamento de Âncoras de Chunk (chunk loaders).
-    usage: /chunkloader [listar|info|remover|receita]
-    aliases: [ancora, ancoras, chunkloaders]

 permissions:
  # Declared explicitly: an undeclared Bukkit permission falls back to op-only,
  # which would silently stop normal players reacting, voting or guessing.
-  canalhandia.chunkloader:
-    description: Permite usar e criar Âncoras de Chunk.
-    default: true
-  canalhandia.chunkloader.admin:
-    description: Permite gerenciar e remover qualquer Âncora de Chunk no servidor.
-    default: op
  canalhandia.reagir:
    description: Permite reagir e prestar luto.
    default: true
@@ -1,47 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class AiTagTest {
-
-    @Test
-    void allPersonasRenderDynamicTagsCorrectly() {
-        for (Persona persona : Persona.values()) {
-            Component c = Ai.style("Minha resposta", "Qualquer pergunta", persona, true, false, true);
-            String plain = PlainTextComponentSerializer.plainText().serialize(c);
-
-            assertTrue(plain.contains("[" + persona.displayTag() + "]"),
-                    "Rendered component must contain tag for " + persona);
-            assertTrue(plain.contains("Minha resposta"));
-        }
-    }
-
-    @Test
-    void continuationLinesUseArrowPrefix() {
-        Component c = Ai.style("Segunda linha", "Pergunta", Persona.JUDITE, true, false, false);
-        String plain = PlainTextComponentSerializer.plainText().serialize(c);
-
-        assertTrue(plain.contains("»"));
-        assertTrue(plain.contains("Segunda linha"));
-    }
-
-    @Test
-    void bedrockDisablesHoverEvent() {
-        Component c = Ai.style("Resposta Bedrock", "Pergunta", Persona.JUDITE, true, true, true);
-        assertNull(c.children().isEmpty() ? c.hoverEvent() : c.children().get(c.children().size() - 1).hoverEvent());
-    }
-
-    @Test
-    void javaFancyIncludesHoverWithPersonaDetails() {
-        Component c = Ai.style("Resposta Java", "Pergunta de teste", Persona.NARRADOR, true, false, true);
-        assertNotNull(c);
-        String plain = PlainTextComponentSerializer.plainText().serialize(c);
-        assertTrue(plain.contains("[Narrador]"));
-    }
-}
@@ -1,162 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.io.File;
-import java.nio.file.Path;
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class ChunkLoaderTest {
-
-    @TempDir
-    Path tempDir;
-
-    private File file;
-    private ChunkLoaders loaders;
-
-    @BeforeEach
-    void setUp() {
-        file = tempDir.resolve("chunks.yml").toFile();
-        loaders = new ChunkLoaders(null, file);
-    }
-
-    @AfterEach
-    void tearDown() {
-        if (loaders != null) {
-            loaders.flush();
-        }
-    }
-
-    @Test
-    void startsEmpty() {
-        assertEquals(0, loaders.size());
-        assertTrue(loaders.all().isEmpty());
-    }
-
-    @Test
-    void addsAndCalculatesChunkCoordinates() {
-        ChunkLoader loader = loaders.add("uuid-marcos", "Marcos", "world", 100, 64, 200);
-        assertEquals(1, loader.id());
-        assertEquals("uuid-marcos", loader.ownerUuid());
-        assertEquals("Marcos", loader.ownerName());
-        assertEquals(6, loader.chunkX()); // 100 >> 4 = 6
-        assertEquals(12, loader.chunkZ()); // 200 >> 4 = 12
-        assertEquals("100, 64, 200 (world)", loader.place());
-        assertEquals("[6, 12]", loader.chunkCoords());
-        assertEquals(1, loaders.size());
-    }
-
-    @Test
-    void queriesByChunkLocationAndOwner() {
-        ChunkLoader l1 = loaders.add("uuid-marcos", "Marcos", "world", 16, 64, 32);
-        ChunkLoader l2 = loaders.add("uuid-ana", "Ana", "world_nether", 0, 70, 0);
-
-        assertEquals(l1, loaders.byLocation("world", 16, 64, 32));
-        assertNull(loaders.byLocation("world", 17, 64, 32));
-
-        assertEquals(l1, loaders.byChunk("world", 1, 2));
-        assertEquals(l2, loaders.byChunk("world_nether", 0, 0));
-        assertNull(loaders.byChunk("world", 0, 0));
-
-        List<ChunkLoader> marcosLoaders = loaders.byOwner("uuid-marcos");
-        assertEquals(1, marcosLoaders.size());
-        assertEquals(l1, marcosLoaders.get(0));
-
-        List<ChunkLoader> anaLoaders = loaders.byOwner("uuid-ana");
-        assertEquals(1, anaLoaders.size());
-        assertEquals(l2, anaLoaders.get(0));
-    }
-
-    @Test
-    void removesLoaderById() {
-        ChunkLoader l1 = loaders.add("uuid-marcos", "Marcos", "world", 16, 64, 32);
-        assertTrue(loaders.remove(l1.id()));
-        assertEquals(0, loaders.size());
-        assertNull(loaders.byId(l1.id()));
-        assertFalse(loaders.remove(l1.id()));
-    }
-
-    @Test
-    void persistsToDiskAndReloads() {
-        loaders.add("uuid-marcos", "Marcos", "world", 100, 64, 200);
-        loaders.add("uuid-ana", "Ana", "world_nether", 50, 70, -50);
-        loaders.flush();
-
-        ChunkLoaders reloaded = new ChunkLoaders(null, file);
-        assertEquals(2, reloaded.size());
-
-        ChunkLoader l1 = reloaded.byId(1);
-        assertNotNull(l1);
-        assertEquals("uuid-marcos", l1.ownerUuid());
-        assertEquals(6, l1.chunkX());
-        assertEquals(12, l1.chunkZ());
-
-        ChunkLoader l2 = reloaded.byId(2);
-        assertNotNull(l2);
-        assertEquals("uuid-ana", l2.ownerUuid());
-    }
-
-    @Test
-    void renamesAndTogglesEnabledState() {
-        ChunkLoader loader = loaders.add("uuid-marcos", "Marcos", "world", 100, 64, 200);
-        assertEquals("#1", loader.simpleName());
-        assertTrue(loader.enabled());
-
-        assertTrue(loaders.rename(loader.id(), "Farm de Ferro"));
-        ChunkLoader renamed = loaders.byId(loader.id());
-        assertNotNull(renamed);
-        assertEquals("Farm de Ferro", renamed.name());
-        assertEquals("Farm de Ferro (#1)", renamed.displayName());
-        assertEquals("Farm de Ferro", renamed.simpleName());
-
-        assertEquals(renamed, loaders.find("Farm de Ferro"));
-        assertEquals(renamed, loaders.find("#1"));
-        assertEquals(renamed, loaders.find("1"));
-
-        assertTrue(loaders.setEnabled(loader.id(), false));
-        ChunkLoader disabled = loaders.byId(loader.id());
-        assertNotNull(disabled);
-        assertFalse(disabled.enabled());
-
-        loaders.flush();
-        ChunkLoaders reloaded = new ChunkLoaders(null, file);
-        ChunkLoader reloadedLoader = reloaded.byId(loader.id());
-        assertNotNull(reloadedLoader);
-        assertEquals("Farm de Ferro", reloadedLoader.name());
-        assertFalse(reloadedLoader.enabled());
-    }
-
-    @Test
-    void managesExpirationAndFuelTime() {
-        ChunkLoader loader = loaders.add("uuid-marcos", "Marcos", "world", 100, 64, 200, "Base", 0L);
-        assertEquals("Permanente", loader.timeLeft());
-        assertFalse(loader.isExpired());
-
-        assertTrue(loaders.addTime(loader.id(), 2 * 3600_000L)); // +2h
-        ChunkLoader timed = loaders.byId(loader.id());
-        assertNotNull(timed);
-        assertTrue(timed.expiresAt() > System.currentTimeMillis());
-        assertFalse(timed.isExpired());
-        assertTrue(timed.timeLeft().contains("h"));
-
-        ChunkLoader expired = timed.withExpiresAt(System.currentTimeMillis() - 1000L);
-        assertTrue(expired.isExpired());
-        assertEquals("Expirado", expired.timeLeft());
-    }
-
-    @Test
-    void simulationSafelyNoopsWithNullPlugin() {
-        loaders.startSimulation();
-        loaders.tickMobSimulation();
-        loaders.stopSimulation();
-    }
-}
@@ -1,82 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.io.File;
-import java.nio.file.Path;
-import java.util.UUID;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class EventTest {
-
-    @TempDir
-    Path tempDir;
-
-    private PlayerMemory memory;
-
-    @BeforeEach
-    void setUp() {
-        File file = tempDir.resolve("ia-memoria.yml").toFile();
-        memory = new PlayerMemory(file);
-    }
-
-    @Test
-    void eventResolvesPlayerCustomPersonaWhenSet() {
-        UUID id = UUID.randomUUID();
-        Persona defaultPersona = Persona.ZOEIRO;
-
-        // Default fallback
-        assertEquals(Persona.ZOEIRO, memory.persona(id, defaultPersona));
-
-        // Player custom choice
-        memory.setPersona(id, "Marcos", Persona.JUDITE);
-        assertEquals(Persona.JUDITE, memory.persona(id, defaultPersona));
-
-        // Switch to Narrador
-        memory.setPersona(id, "Marcos", Persona.NARRADOR);
-        assertEquals(Persona.NARRADOR, memory.persona(id, defaultPersona));
-    }
-
-    @Test
-    void joinWelcomePromptContainsPlayerAndStats() {
-        String name = "Marcos";
-        String stats = "100 diamantes minerados, 2 mortes";
-        String prompt = "O jogador " + name + " acabou de entrar no servidor."
-                + " Estatísticas dele: " + stats
-                + " Dê as boas-vindas do seu jeito e na sua personalidade, em uma frase curta.";
-
-        assertTrue(prompt.contains("Marcos"));
-        assertTrue(prompt.contains("100 diamantes"));
-        assertTrue(prompt.contains("personalidade"));
-    }
-
-    @Test
-    void deathStreakPromptContainsCountAndFlavor() {
-        String name = "Marcos";
-        int count = 4;
-        String flavor = "abraçou um Creeper";
-        String prompt = "O jogador " + name + " morreu " + count
-                + " vezes seguidas em poucos minutos. A última foi assim: " + flavor
-                + ". Comente na sua personalidade, sem ofender de verdade.";
-
-        assertTrue(prompt.contains("morreu 4 vezes seguidas"));
-        assertTrue(prompt.contains("abraçou um Creeper"));
-    }
-
-    @Test
-    void achievementUnlockPromptContainsTitleAndDescription() {
-        String title = "Mestre dos Diamantes";
-        String desc = "Minerou 1000 diamantes";
-        String prompt = "O jogador Marcos desbloqueou a conquista \""
-                + title + "\" (" + desc
-                + "). Faça um breve comentário na sua personalidade.";
-
-        assertTrue(prompt.contains(title));
-        assertTrue(prompt.contains(desc));
-    }
-}
@@ -122,31 +122,6 @@ class PersonaTest {
        }
    }

-    @Test
-    void juditeHasSacFlavour() {
-        assertEquals("judite", Persona.JUDITE.key());
-        assertEquals("Judite", Persona.JUDITE.displayTag());
-        assertTrue(Persona.JUDITE.instructions().contains("Judite"));
-        assertTrue(Persona.JUDITE.instructions().contains("gerundismo") || Persona.JUDITE.instructions().contains("estaremos"));
-        assertTrue(Persona.JUDITE.instructions().contains("protocolo") || Persona.JUDITE.instructions().contains("Protocolo"));
-    }
-
-    @Test
-    void narradorHasEpicFlavour() {
-        assertEquals("narrador", Persona.NARRADOR.key());
-        assertEquals("Narrador", Persona.NARRADOR.displayTag());
-        assertTrue(Persona.NARRADOR.instructions().contains("narrador épico") || Persona.NARRADOR.instructions().contains("fantasia"));
-    }
-
-    @Test
-    void everyPersonaHasValidDisplayTagAndColor() {
-        for (Persona persona : Persona.values()) {
-            assertNotNull(persona.displayTag(), persona.key() + " needs a displayTag");
-            assertFalse(persona.displayTag().isBlank(), persona.key() + " displayTag cannot be blank");
-            assertNotNull(persona.tagColor(), persona.key() + " needs a tagColor");
-        }
-    }
-
    @Test
    void guardForbidsInventingStats() {
        // The AI is now fed real numbers; without this it would happily make up
@@ -1,163 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.io.File;
-import java.nio.file.Path;
-import java.util.List;
-import java.util.UUID;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class PlayerMemoryTest {
-
-    @TempDir
-    Path tempDir;
-
-    private File file;
-    private PlayerMemory memory;
-
-    @BeforeEach
-    void setUp() {
-        file = tempDir.resolve("ia-memoria.yml").toFile();
-        memory = new PlayerMemory(file);
-    }
-
-    @org.junit.jupiter.api.AfterEach
-    void tearDown() {
-        if (memory != null) {
-            memory.flush();
-        }
-    }
-
-    @Test
-    void startsEmpty() {
-        assertEquals(0, memory.size());
-    }
-
-    @Test
-    void setsAndPersistsPersona() {
-        UUID id = UUID.randomUUID();
-        assertEquals(Persona.ZOEIRO, memory.persona(id, Persona.ZOEIRO));
-        assertNull(memory.rawPersona(id));
-
-        memory.setPersona(id, "Marcos", Persona.JUDITE);
-        assertEquals(Persona.JUDITE, memory.persona(id, Persona.ZOEIRO));
-        assertEquals(Persona.JUDITE, memory.rawPersona(id));
-
-        // Reload from disk
-        memory.flush();
-        PlayerMemory reloaded = new PlayerMemory(file);
-        assertEquals(Persona.JUDITE, reloaded.persona(id, Persona.ZOEIRO));
-        assertEquals(Persona.JUDITE, reloaded.rawPersona(id));
-
-        // Reset
-        reloaded.resetPersona(id);
-        reloaded.flush();
-        assertNull(reloaded.rawPersona(id));
-        assertEquals(Persona.ZOEIRO, reloaded.persona(id, Persona.ZOEIRO));
-    }
-
-    @Test
-    void recordsTurnAndCompressesWhenLong() {
-        UUID id = UUID.randomUUID();
-        memory.recordTurn(id, "Marcos", "Onde tem diamante?", "Na camada -58.");
-        String s = memory.summary(id);
-        assertNotNull(s);
-        assertTrue(s.contains("diamante"));
-        assertTrue(s.contains("-58"));
-
-        // Push many turns to trigger compression
-        for (int i = 0; i < 20; i++) {
-            memory.recordTurn(id, "Marcos", "Pergunta " + i, "Resposta bem longa para a pergunta " + i);
-        }
-        String compressed = memory.summary(id);
-        assertNotNull(compressed);
-        assertTrue(compressed.length() <= PlayerMemory.MAX_SUMMARY_CHARS + 10);
-    }
-
-    @Test
-    void addsAndCapsFacts() {
-        UUID id = UUID.randomUUID();
-        for (int i = 1; i <= 10; i++) {
-            memory.addFact(id, "Marcos", "Fato número " + i);
-        }
-        List<String> facts = memory.facts(id);
-        assertEquals(PlayerMemory.MAX_FACTS, facts.size());
-        assertTrue(facts.contains("Fato número 10"));
-        assertFalse(facts.contains("Fato número 1")); // Oldest evicted
-    }
-
-    @Test
-    void formatContextProducesCleanPrompt() {
-        UUID id = UUID.randomUUID();
-        assertNull(memory.formatContext(id));
-
-        memory.recordTurn(id, "Marcos", "Como fazer poção?", "Use suporte de poções.");
-        memory.addFact(id, "Marcos", "Mora na vila do deserto");
-
-        String context = memory.formatContext(id);
-        assertNotNull(context);
-        assertTrue(context.contains("Resumo de tópicos recentes"));
-        assertTrue(context.contains("Fatos conhecidos"));
-        assertTrue(context.contains("Mora na vila do deserto"));
-    }
-
-    @Test
-    void clearHistoryKeepsPersona() {
-        UUID id = UUID.randomUUID();
-        memory.setPersona(id, "Marcos", Persona.SECO);
-        memory.recordTurn(id, "Marcos", "Oi", "Tchau");
-        memory.addFact(id, "Marcos", "Fato 1");
-
-        memory.clearHistory(id);
-        assertEquals(Persona.SECO, memory.rawPersona(id));
-        assertEquals("", memory.summary(id));
-        assertTrue(memory.facts(id).isEmpty());
-    }
-
-    @Test
-    void forgetRemovesProfileCompletely() {
-        UUID id = UUID.randomUUID();
-        memory.setPersona(id, "Marcos", Persona.NARRADOR);
-        memory.forget(id);
-        assertEquals(0, memory.size());
-        assertNull(memory.rawPersona(id));
-    }
-
-    @Test
-    void extractsHeuristicFactsAutomatically() {
-        UUID id = UUID.randomUUID();
-        memory.recordTurn(id, "Marcos", "Minha base fica nas montanhas nevadas!", "Que lugar bonito!");
-        List<String> facts = memory.facts(id);
-        assertFalse(facts.isEmpty());
-        assertTrue(facts.get(0).toLowerCase().contains("minha base"));
-
-        String fact = PlayerMemory.extractHeuristicFact("Eu estou construindo uma pirâmide gigante?");
-        assertNotNull(fact);
-        assertTrue(fact.contains("estou construindo uma pirâmide gigante"));
-        assertNull(PlayerMemory.extractHeuristicFact("quantos blocos tem o mundo?"));
-
-        // Leading / trailing whitespace index alignment
-        assertEquals("minha base fica no topo", PlayerMemory.extractHeuristicFact("   minha base fica no topo!  "));
-        assertEquals("estou construindo uma ponte", PlayerMemory.extractHeuristicFact("  oi, estou construindo uma ponte..."));
-    }
-
-    @Test
-    void flushesToDiskCorrectly() {
-        UUID id = UUID.randomUUID();
-        memory.setPersona(id, "Marcos", Persona.JUDITE);
-        memory.recordTurn(id, "Marcos", "Preciso de ajuda", "Aguarde na linha");
-        memory.flush();
-
-        PlayerMemory disk = new PlayerMemory(file);
-        assertEquals(Persona.JUDITE, disk.persona(id, Persona.ZOEIRO));
-        assertTrue(disk.summary(id).contains("ajuda"));
-    }
-}
@@ -1,78 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import com.google.gson.JsonArray;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class ToolsTest {
-
-    @Test
-    void definitionsIncludeLugaresJogador() {
-        Tools tools = new Tools(null, null, null, s -> {});
-        JsonArray defs = tools.definitions();
-        assertNotNull(defs);
-        assertTrue(defs.size() >= 6);
-
-        boolean foundLugares = false;
-        for (int i = 0; i < defs.size(); i++) {
-            var fn = defs.get(i).getAsJsonObject().getAsJsonObject("function");
-            String name = fn.get("name").getAsString();
-            if ("lugares_jogador".equals(name)) {
-                foundLugares = true;
-                assertTrue(fn.has("description"));
-                assertTrue(fn.getAsJsonObject("parameters").has("properties"));
-            }
-        }
-        assertTrue(foundLugares, "lugares_jogador must be defined in tools schema");
-    }
-
-    @Test
-    void unknownToolReturnsErrorText() {
-        Tools tools = new Tools(null, null, null, s -> {});
-        String res = tools.run("nao_existe", "{}");
-        assertTrue(res.contains("ferramenta desconhecida"));
-    }
-
-    @Test
-    void malformedJsonReturnsError() {
-        Tools tools = new Tools(null, null, null, s -> {});
-        String res = tools.run("wiki", "malformed json");
-        assertTrue(res.contains("argumentos inválidos"));
-    }
-
-    @Test
-    void formatPlayerPlacesFiltersOutPrivateNotesAndOtherAuthors() {
-        Tools tools = new Tools(null, null, null, s -> {});
-        OfflineStats.Known who = new OfflineStats.Known("uuid-ana", "ana");
-
-        Note privateNote = new Note(1, Note.Scope.PRIVADA, "ana", "uuid-ana", "segredo", "world", 10, 20, 30, 1000L);
-        Note publicNote = new Note(2, Note.Scope.PUBLICA, "ana", "uuid-ana", "vila do spawn", "world", 100, 64, 200, 1000L);
-        Note otherAuthorPublicNote = new Note(3, Note.Scope.PUBLICA, "bob", "uuid-bob", "base do bob", "world", 500, 64, 500, 1000L);
-
-        String formatted = tools.formatPlayerPlaces(who, List.of(), List.of(privateNote, publicNote, otherAuthorPublicNote));
-
-        assertTrue(formatted.contains("vila do spawn"));
-        assertFalse(formatted.contains("segredo"), "Private notes must never be included in places output");
-        assertFalse(formatted.contains("base do bob"), "Notes of other players must not be included");
-        assertTrue(formatted.contains("nenhum registro de morte recente"));
-    }
-
-    @Test
-    void formatPlayerPlacesIncludesDeathsAndFormatsPlaces() {
-        Tools tools = new Tools(null, null, null, s -> {});
-        OfflineStats.Known who = new OfflineStats.Known("uuid-ana", "ana");
-
-        DeathLog.Entry d = new DeathLog.Entry("uuid-ana", "abraçou um Creeper", "Mundo normal", 12, 64, -80, 1000L);
-        String formatted = tools.formatPlayerPlaces(who, List.of(d), List.of());
-
-        assertTrue(formatted.contains("Lugares conhecidos de ana:"));
-        assertTrue(formatted.contains("nenhuma base salva"));
-        assertTrue(formatted.contains("12, 64, -80 (Mundo normal)"));
-        assertTrue(formatted.contains("abraçou um Creeper"));
-    }
-}
@@ -1,40 +0,0 @@
-package dev.marcospaulo.canalhandia;
-
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.inventory.ItemStack;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class VoidProtectionTest {
-
-    @Test
-    void identifiesVoidDeathByCause() {
-        assertTrue(VoidProtection.isVoidDeath(100.0, -64.0, EntityDamageEvent.DamageCause.VOID));
-        assertTrue(VoidProtection.isVoidDeath(-70.0, -64.0, EntityDamageEvent.DamageCause.VOID));
-    }
-
-    @Test
-    void identifiesVoidDeathByCoordinatesBelowMinHeight() {
-        assertTrue(VoidProtection.isVoidDeath(-65.0, -64.0, EntityDamageEvent.DamageCause.FALL));
-        assertTrue(VoidProtection.isVoidDeath(-100.0, 0.0, EntityDamageEvent.DamageCause.CUSTOM));
-        assertFalse(VoidProtection.isVoidDeath(50.0, -64.0, EntityDamageEvent.DamageCause.FALL));
-        assertFalse(VoidProtection.isVoidDeath(10.0, 0.0, EntityDamageEvent.DamageCause.LAVA));
-    }
-
-    @Test
-    void handlesNullWorldOrLocationsGracefully() {
-        assertNull(VoidProtection.findSafeChestLocation(null, null, 10));
-        assertNull(VoidProtection.findSafeChestLocation(null, null, 0));
-        assertFalse(VoidProtection.rescueToChest(null, null));
-        assertFalse(VoidProtection.rescueToChest(List.of(), null));
-    }
-
-    @Test
-    void nullBlocksAreNeitherSafeNorReplaceable() {
-        assertFalse(VoidProtection.isSafeGround(null));
-        assertFalse(VoidProtection.isReplaceable(null));
-    }
-}