feat: typed team settings (cascade per-team → global → default) + in-game GUI

New fr.luc.crcore.team.config module:
- TeamSetting<T> (typed, with key/type/default/parser/serializer; factories
  ofBoolean/ofInt/ofString/ofEnum).
- TeamSettings registry: 8 standard settings (FRIENDLY_FIRE,
  PVP_PROTECTION_SECONDS, MAX_SIZE, MIN_SIZE, RESPAWN_AT_TEAM_SPAWN,
  TEAM_CHAT_ENABLED, SHOW_TAG_ABOVE_HEAD, TEAM_COLOR_IN_NAME), extensible
  via register() for game plugins.
- TeamConfigService interface with cascade get(team, setting) →
  per-team override (SQLite) → global YAML → hard default. Persists per-
  team via TeamRepository.save(), global via YamlConfiguration.save().
- YamlTeamConfigService default impl with bundled crcore-team-config.yml.

Storage:
- Team.getSettings() Map<String, Object> for per-team overrides.
- New SQLite table crcore_team_settings (team_id, key, value, type) with
  load + write-through persist in SqliteTeamRepository.
- Global YAML <plugin>-team-config.yml in dataFolder, auto-created at
  first boot (template from game plugin's resource of the same name
  takes priority).

New reusable GUI framework fr.luc.crcore.gui:
- AbstractInventoryGui (implements InventoryHolder, rebuild() abstract,
  setButton/setDecoration/clearSlot helpers, onClose hook, openTo()).
- GuiClickHandler FunctionalInterface.
- GuiListener (single Bukkit listener, detects via getHolder(), ALWAYS
  cancels clicks even on slots without handlers).
- GuiItems builder (named/of/filler + lore/amount/build, '&' color codes
  translated).

Concrete settings GUIs (fr.luc.crcore.team.config.gui):
- AbstractSettingsGui base renderer: 27 slots, settings in row 2,
  booleans = LIME_DYE / GRAY_DYE toggle, integers = BOOK with left +1 /
  right -1 (shift × 10), strings/enums display-only.
- GlobalSettingsGui: writes to YAML on each change.
- TeamSettingsGui: writes to per-team overrides, "override active" flag
  in lore when value differs from global, "Reset all overrides" footer
  button.

New /core team settings [team] subcommand:
- No arg → GlobalSettingsGui (perm crcore.team.settings.global).
- With arg → TeamSettingsGui (perm crcore.team.settings).
- Player-only (Bukkit needs HumanEntity to open inventory).
- Lives under /core team to stay modular (objective: split into modules
  later; everything team-related under /core team).

CRCore: buildTeamConfigService() override point, teamConfig()/getTeamConfig()
getters, GuiListener.registerOn(plugin) at enable(). CoreCommand,
TeamGroupSubCommand and CoreReloadSubCommand extended to receive
TeamConfigService. /core reload now reloads messages + broadcasts +
team-config.

Docs: new section 10 "Paramètres d'équipe", new decisions logged,
setup.md tree updated, two new diagrams (team-config + gui).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

docs/README.md

@@ -36,6 +36,14 @@ d'initialisation côté plugin de jeu :
   templates. Un listener interne wire les 12 events natifs ; les game
   plugins peuvent broadcast leurs propres events. `/core reload` recharge
   les deux fichiers à chaud.
+- **Paramètres d'équipe** — `TeamConfigService` typé avec cascade
+  per-team → global → default. 8 settings standards
+  (`FRIENDLY_FIRE`, `MAX_SIZE`, etc.), étendable. Globaux dans
+  `<plugin>-team-config.yml`, per-team en SQLite. GUI in-game via
+  `/core team settings [team]`.
+- **Framework GUI** — `AbstractInventoryGui` + `GuiListener` réutilisable
+  pour tout GUI custom. Détection par holder, clic toujours annulé,
+  `GuiItems` builder fluide avec codes couleur `&`.
 - **Bootstrap unique** — `new CRCore(this).enable()` dans le `onEnable()`
   du plugin de jeu, et tout est branché.
 
@@ -62,6 +70,8 @@ d'initialisation côté plugin de jeu :
 | [database-diagram.puml](diagrams/database-diagram.puml) | Classe | Wrapper SQLite + table builder |
 | [messages-class-diagram.puml](diagrams/messages-class-diagram.puml) | Classe | Service de messages YAML |
 | [broadcasts-class-diagram.puml](diagrams/broadcasts-class-diagram.puml) | Classe | Service de broadcasts YAML + listener |
+| [team-config-class-diagram.puml](diagrams/team-config-class-diagram.puml) | Classe | Paramètres d'équipe (cascade + GUI) |
+| [gui-class-diagram.puml](diagrams/gui-class-diagram.puml) | Classe | Framework GUI réutilisable |
 | [bootstrap-sequence.puml](diagrams/bootstrap-sequence.puml) | Séquence | `CRCore.enable()` côté plugin de jeu |
 
 ## Conventions

docs/decisions.md

@@ -367,6 +367,69 @@ Format léger : une décision = un titre + contexte + choix + raison.
   bases existantes, ALTER TABLE manuel ou suppression du fichier
   (les bases d'event sont jetables).
 
+## 2026-06-10 — Settings d'équipe : cascade per-team → global → default + GUI
+
+- **Choix** : nouveau module `fr.luc.crcore.team.config` avec :
+  - `TeamSetting<T>` typé (factories `ofBoolean`, `ofInt`, `ofString`,
+    `ofEnum`) — chaque setting porte sa clé, son type, son default et sa
+    sérialisation YAML/SQL.
+  - `TeamSettings` registry des 8 settings standards
+    (`FRIENDLY_FIRE`, `PVP_PROTECTION_SECONDS`, `MAX_SIZE`, `MIN_SIZE`,
+    `RESPAWN_AT_TEAM_SPAWN`, `TEAM_CHAT_ENABLED`, `SHOW_TAG_ABOVE_HEAD`,
+    `TEAM_COLOR_IN_NAME`), extensible via `TeamSettings.register(...)`
+    pour les game plugins.
+  - `TeamConfigService` (interface) + `YamlTeamConfigService` (impl).
+- **Cascade de résolution** : per-team → global → hard default. Garantie
+  non-null grâce au default. La couche per-team est stockée dans
+  {@code Team.getSettings()} (Map<String, Object>) persistée en SQLite ;
+  la couche globale dans `<plugin>-team-config.yml` ; les defaults sont
+  des constantes Java.
+- **Stockage per-team SQLite** : nouvelle table `crcore_team_settings`
+  (team_id, key, value, type). Le type tag (bool/int/str) permet de
+  reconstruire le type Java au load sans réflexion.
+- **Settings custom (game plugin)** : le game plugin peut faire
+  `TeamSettings.register(MON_SETTING)` dans son onEnable() pour
+  l'enregistrer ; il apparaîtra automatiquement dans les GUI globaux et
+  per-team, et sera persisté comme les standards.
+- **Pas d'application automatique** : CR-Core ne fait que stocker /
+  exposer les settings. C'est au game plugin d'écouter les events Bukkit
+  pertinents (ex. `EntityDamageByEntityEvent`) et de consulter
+  `config.get(team, FRIENDLY_FIRE)` pour appliquer la règle. CR-Core ne
+  veut pas hardcoder des semantics gameplay.
+
+## 2026-06-10 — Framework GUI réutilisable (`fr.luc.crcore.gui`)
+
+- **Choix** : module GUI générique avec
+  `AbstractInventoryGui implements InventoryHolder` (base abstraite),
+  `GuiClickHandler` (FunctionalInterface), `GuiListener` (un seul
+  Listener Bukkit pour TOUS les GUI CR-Core), `GuiItems` (builder fluide
+  d'`ItemStack` avec codes couleur).
+- **Détection par holder** : `event.getInventory().getHolder() instanceof
+  AbstractInventoryGui` — propre, sans titre/UUID custom, marche même
+  après un translate.
+- **Click toujours annulé** : le `GuiListener` cancel TOUT clic dans un
+  GUI CR-Core (avant invocation du handler) — l'utilisateur ne peut
+  jamais déplacer un item du GUI, même sur un slot sans handler.
+- **Réutilisable** : c'est un framework, pas un GUI métier. Tout futur
+  GUI (settings, kits, classements interactifs, etc.) hérite
+  d'`AbstractInventoryGui`.
+
+## 2026-06-10 — `/core team settings` (global = sans arg, per-team = avec arg)
+
+- **Choix** : commande unique `/core team settings [team]` qui multiplexe :
+  - Sans arg → ouvre `GlobalSettingsGui` (perm
+    `crcore.team.settings.global`).
+  - Avec arg `team` → ouvre `TeamSettingsGui` (perm `crcore.team.settings`).
+- **Pas `/core settings`** au top-level — l'objectif est de séparer
+  plus tard en modules (team, score, kits, …). Tout ce qui touche les
+  teams reste sous `/core team`.
+- **Player-only** : Bukkit a besoin d'un `HumanEntity` pour ouvrir un
+  inventaire. Pas de fallback console.
+- **Mécaniques** : booléens → toggle, entiers → clic gauche +1/right -1
+  (shift = ×10), strings/enums → édition différée au YAML (V1).
+- **GUI per-team** : un bouton "Reset tous les overrides" qui efface
+  tous les per-team de l'équipe pour les faire retomber sur le global.
+
 ## 2026-06-10 — Système de broadcasts configurables + `/core reload`
 
 - **Choix** : nouveau module `fr.luc.crcore.broadcast` avec

docs/diagrams/gui-class-diagram.puml

@@ -0,0 +1,82 @@
+@startuml gui-class-diagram
+title CR-Core — GUI framework (class diagram, réutilisable)
+
+skinparam classAttributeIconSize 0
+hide empty members
+
+package "fr.luc.crcore.gui" {
+
+  abstract class AbstractInventoryGui {
+    - inventory: Inventory
+    - handlers: Map<Integer, GuiClickHandler>
+    --
+    # setInventory(Inventory): void
+    + getInventory(): Inventory
+    + {abstract} rebuild(): void
+    + onClose(HumanEntity): void
+    + openTo(HumanEntity): void
+    # setButton(slot, item, handler): void
+    # setDecoration(slot, item): void
+    # clearSlot(slot): void
+    + handleClick(event): void           ' appelé par GuiListener
+    + handleClose(event): void
+  }
+  AbstractInventoryGui ..|> "org.bukkit.inventory.InventoryHolder"
+
+  interface GuiClickHandler <<FunctionalInterface>> {
+    + onClick(InventoryClickEvent): void
+  }
+
+  class GuiListener {
+    + registerOn(JavaPlugin): void
+    --
+    @ onClick(InventoryClickEvent)
+    @ onClose(InventoryCloseEvent)
+  }
+  GuiListener ..|> "org.bukkit.event.Listener"
+
+  class GuiItems <<utility>> {
+    + {static} named(material, name): Builder
+    + {static} of(material): Builder
+    + {static} filler(): ItemStack
+    + {static} item(builder): ItemStack
+  }
+
+  class "GuiItems.Builder" as Builder {
+    - stack: ItemStack
+    - meta: ItemMeta
+    + name(text): Builder
+    + lore(lines...): Builder
+    + lore(List<String>): Builder
+    + amount(int): Builder
+    + build(): ItemStack
+    + asItem(): ItemStack
+  }
+  GuiItems +-- Builder
+
+  GuiListener ..> AbstractInventoryGui : dispatches via getHolder()
+  AbstractInventoryGui --> GuiClickHandler : per-slot
+}
+
+note right of GuiListener
+  Détection par holder :
+  if (e.getInventory().getHolder()
+      instanceof AbstractInventoryGui gui) {
+    e.setCancelled(true);   // ← TOUJOURS, même slot vide
+    gui.handleClick(e);
+  }
+
+  Enregistré une fois dans CRCore.enable().
+end note
+
+note right of AbstractInventoryGui
+  Pattern :
+    1. extends AbstractInventoryGui
+    2. constructeur :
+       Inventory inv = Bukkit.createInventory(this, 27, "&eTitre");
+       setInventory(inv);
+    3. override rebuild() pour peindre
+    4. setButton(slot, GuiItems.named(...).build(), handler)
+end note
+
+@enduml

docs/diagrams/team-config-class-diagram.puml

@@ -0,0 +1,119 @@
+@startuml team-config-class-diagram
+title CR-Core — Team config (class diagram, cascade per-team → global → default)
+
+skinparam classAttributeIconSize 0
+hide empty members
+
+package "fr.luc.crcore.team.config" {
+
+  class "TeamSetting<T>" as TeamSetting <<final>> {
+    - key: String
+    - type: Class<T>
+    - defaultValue: T
+    - kind: Kind
+    - parser: Function<Object,T>
+    - serializer: Function<T,Object>
+    --
+    + {static} ofBoolean(key, default): TeamSetting<Boolean>
+    + {static} ofInt(key, default): TeamSetting<Integer>
+    + {static} ofString(key, default): TeamSetting<String>
+    + {static} ofEnum(key, default): TeamSetting<E>
+    --
+    + parse(raw): T
+    + serialize(value): Object
+    + getKey() / getType() / getDefaultValue() / getKind()
+  }
+
+  enum "TeamSetting.Kind" as Kind {
+    BOOLEAN
+    INTEGER
+    STRING
+    ENUM
+  }
+  TeamSetting +-- Kind
+
+  class TeamSettings <<utility>> {
+    + {static} FRIENDLY_FIRE: TeamSetting<Boolean>
+    + {static} PVP_PROTECTION_SECONDS: TeamSetting<Integer>
+    + {static} MAX_SIZE: TeamSetting<Integer>
+    + {static} MIN_SIZE: TeamSetting<Integer>
+    + {static} RESPAWN_AT_TEAM_SPAWN: TeamSetting<Boolean>
+    + {static} TEAM_CHAT_ENABLED: TeamSetting<Boolean>
+    + {static} SHOW_TAG_ABOVE_HEAD: TeamSetting<Boolean>
+    + {static} TEAM_COLOR_IN_NAME: TeamSetting<Boolean>
+    --
+    + {static} register(setting): void
+    + {static} get(key): Optional<TeamSetting<?>>
+    + {static} all(): Collection<TeamSetting<?>>
+  }
+  TeamSettings ..> TeamSetting
+
+  interface TeamConfigService {
+    + get(team, setting): T
+    + getGlobal(setting): T
+    + setPerTeam(team, setting, value): void
+    + resetPerTeam(team, setting): void
+    + setGlobal(setting, value): void
+    + reload(): void
+    + hasPerTeamOverride(team, setting): boolean
+    + getGlobalSnapshot(): Map<TeamSetting<?>, Object>
+    + getGlobalFileName(): Optional<String>
+  }
+
+  package "fr.luc.crcore.team.config.impl" {
+    class YamlTeamConfigService {
+      - plugin: JavaPlugin
+      - teamRepository: TeamRepository
+      - userFile: File
+      - globalValues: Map<String, Object>
+      --
+      - ensureUserFile(): void
+      - rebuildGlobalValues(): void
+      - persistGlobals(): void
+    }
+    YamlTeamConfigService ..|> TeamConfigService
+  }
+
+  TeamConfigService ..> TeamSetting : reads/writes
+}
+
+package "fr.luc.crcore.team" {
+  class Team {
+    - settings: Map<String, Object>
+    + getSettings(): Map<String, Object>
+  }
+}
+
+package "fr.luc.crcore.team.config.gui" {
+  abstract class AbstractSettingsGui {
+    - rebuild() : peint la grille
+    # {abstract} getCurrentValue(setting): T
+    # {abstract} onChange(setting, newValue): void
+    # isOverride(setting): boolean
+    # renderFooter(): void
+  }
+  class GlobalSettingsGui
+  class TeamSettingsGui
+  GlobalSettingsGui --|> AbstractSettingsGui
+  TeamSettingsGui  --|> AbstractSettingsGui
+  AbstractSettingsGui --|> "fr.luc.crcore.gui.AbstractInventoryGui"
+
+  GlobalSettingsGui --> TeamConfigService
+  TeamSettingsGui --> TeamConfigService
+  TeamSettingsGui --> Team
+}
+
+YamlTeamConfigService --> "fr.luc.crcore.team.TeamRepository" : persists per-team via save()
+TeamConfigService ..> Team : reads/writes settings map
+
+note bottom of YamlTeamConfigService
+  Cascade de résolution :
+    1. team.getSettings().get(key)   ← override per-team (SQLite)
+    2. globalValues.get(key)         ← <plugin>-team-config.yml
+    3. setting.getDefaultValue()     ← constante Java
+
+  Le YAML global est ré-écrit à chaque setGlobal() (persistant à crash).
+  Les per-team sont écrits via teamRepository.save(team).
+end note
+
+@enduml

docs/features.md

@@ -807,7 +807,120 @@ depuis les fichiers user du dataFolder. Les defaults en jar ne bougent pas
 
 ---
 
-## 10. Bootstrap `CRCore`
+## 10. Paramètres d'équipe (`fr.luc.crcore.team.config`)
+
+**Statut** : implémenté. 8 settings standards + GUI in-game + cascade
+per-team → global → default.
+
+### Modèle de résolution
+
+```
+   1. hard default        défini en code dans TeamSettings (constantes)
+   2. global config       <plugin>-team-config.yml          ← admin via GUI ou YAML
+   3. per-team override   table SQLite crcore_team_settings ← admin via GUI
+```
+
+`config.get(team, setting)` cascade per-team → global → default.
+`config.getGlobal(setting)` cascade global → default (skip per-team).
+Toutes les valeurs retournées sont **non-null** grâce au default en bout
+de chaîne.
+
+### Settings standards (`TeamSettings`)
+
+| Constante | Clé YAML/SQL | Type | Défaut |
+|---|---|---|---|
+| `FRIENDLY_FIRE` | `friendly_fire` | bool | `false` |
+| `PVP_PROTECTION_SECONDS` | `pvp_protection_seconds` | int | `0` |
+| `MAX_SIZE` | `max_size` | int | `0` (illimité) |
+| `MIN_SIZE` | `min_size` | int | `0` |
+| `RESPAWN_AT_TEAM_SPAWN` | `respawn_at_team_spawn` | bool | `true` |
+| `TEAM_CHAT_ENABLED` | `team_chat_enabled` | bool | `true` |
+| `SHOW_TAG_ABOVE_HEAD` | `show_tag_above_head` | bool | `true` |
+| `TEAM_COLOR_IN_NAME` | `team_color_in_name` | bool | `true` |
+
+CR-Core fournit les défauts ; **c'est au plugin de jeu d'appliquer ces
+settings** dans sa logique (ex. écouter `EntityDamageByEntityEvent` et
+checker `config.get(team, FRIENDLY_FIRE)` pour décider si le coup passe).
+
+### API typée
+
+```java
+boolean ff = core.teamConfig().get(team, TeamSettings.FRIENDLY_FIRE);
+int max = core.teamConfig().getGlobal(TeamSettings.MAX_SIZE);
+core.teamConfig().setPerTeam(team, TeamSettings.FRIENDLY_FIRE, true);
+core.teamConfig().resetPerTeam(team, TeamSettings.FRIENDLY_FIRE);
+core.teamConfig().setGlobal(TeamSettings.MAX_SIZE, 8);  // persiste le YAML
+core.teamConfig().reload();
+```
+
+### Settings custom (game plugin)
+
+Un game plugin peut enregistrer ses propres settings :
+
+```java
+public static final TeamSetting<Boolean> CITES_PVP_ROUND_END =
+    TeamSetting.ofBoolean("cites_pvp_round_end", false);
+
+@Override public void onEnable() {
+    core = new CRCore(this).enable();
+    TeamSettings.register(CITES_PVP_ROUND_END);
+}
+```
+
+→ La clé apparaîtra automatiquement dans les GUI globaux et per-team, et
+sera persistée en SQLite + YAML comme les standards.
+
+### Commande GUI
+
+`/core team settings [team]` — player-only, ouvre l'interface graphique.
+
+- Sans argument → **GUI globaux** (perm `crcore.team.settings.global`).
+  Modif → écrit dans `<plugin>-team-config.yml`.
+- Avec argument → **GUI per-team** (perm `crcore.team.settings`). Modif →
+  écrit en SQLite (overrides). Bouton "Reset tous les overrides" pour
+  remettre toutes les valeurs au global.
+
+### Mécaniques GUI
+
+- **Inventaire 27 slots**, settings sur la ligne du milieu (slots 10..16).
+- **Booléens** : lampe verte (ON) / grise (OFF), clic = toggle.
+- **Entiers** : item livre.
+  - Clic gauche = +1, shift = +10
+  - Clic droit = -1, shift = -10
+  - Clamp à 0 minimum
+- **Strings/Enums** : affichage seul (édition via YAML — pas dans la V1
+  du GUI).
+- **Per-team** : indication visuelle "Override per-team actif" dans la
+  lore quand une valeur est différente du global.
+- **Slot 22** : bouton Fermer.
+- **Slot 18** (per-team uniquement) : bouton "Reset tous les overrides".
+
+### Framework GUI réutilisable
+
+Le module `fr.luc.crcore.gui` est **générique** — réutilisable pour tout
+futur GUI CR-Core ou game plugin :
+
+- `AbstractInventoryGui implements InventoryHolder` — base abstraite,
+  `rebuild()`, `setButton(slot, item, handler)`, `setDecoration(...)`,
+  `clearSlot(...)`, hook `onClose(...)`.
+- `GuiClickHandler` (FunctionalInterface) — handler de clic par slot.
+- `GuiListener` — un seul Listener Bukkit qui route les clics et les
+  fermetures vers le bon GUI via `inventory.getHolder()`.
+- `GuiItems` — builder fluide `named(material, "&aTitre").lore(...).build()`,
+  filler décoratif gris.
+
+Pour faire un GUI custom : `extends AbstractInventoryGui`, créer
+l'inventaire dans le constructeur, override `rebuild()`. Le `GuiListener`
+est déjà enregistré par `CRCore.enable()`.
+
+### Diagrammes
+
+- [team-config-class-diagram.puml](diagrams/team-config-class-diagram.puml)
+- [gui-class-diagram.puml](diagrams/gui-class-diagram.puml)
+
+---
+
+## 11. Bootstrap `CRCore`
 
 **Statut** : implémenté. Point d'entrée unique pour les plugins de jeu.
 

docs/setup.md

@@ -267,12 +267,13 @@ CitesPlugin/                                 # dossier IntelliJ (renommer plus t
 
 ## Fichiers de config générés au premier `enable()`
 
-Au premier démarrage, CR-Core crée DEUX fichiers dans le dataFolder :
+Au premier démarrage, CR-Core crée TROIS fichiers dans le dataFolder :
 
 | Fichier | Rôle |
 |---|---|
 | `<plugin-name-lowercase>-messages.yml` | Templates de tous les messages (commandes + broadcasts) |
 | `<plugin-name-lowercase>-broadcasts.yml` | Routes : qui reçoit quel event |
+| `<plugin-name-lowercase>-team-config.yml` | Paramètres globaux d'équipe (defaults appliqués à toutes les teams) |
 
 Les deux suivent le même pattern : si ton plugin de jeu bundle un fichier
 au même nom dans ses ressources, c'est lui qui sert de template initial à
@@ -320,6 +321,7 @@ Au premier `enable()`, les tables suivantes sont créées (en `IF NOT EXISTS`) :
   visibility, spawn_world/x/y/z/yaw/pitch)
 - `crcore_team_members` — un membre = (team_id, player_id, role, joined_at)
 - `crcore_team_scores` — (team_id, score_name, value)
+- `crcore_team_settings` — (team_id, key, value, type) — overrides per-team
 - `crcore_player_profiles` — un profil = (id)
 - `crcore_player_scores` — (profile_id, score_name, value)
 

src/main/java/fr/luc/crcore/CRCore.java

@@ -5,8 +5,11 @@ import fr.luc.crcore.broadcast.CRCoreBroadcastListener;
 import fr.luc.crcore.broadcast.impl.YamlBroadcastService;
 import fr.luc.crcore.command.builtin.CoreCommand;
 import fr.luc.crcore.database.Database;
+import fr.luc.crcore.gui.GuiListener;
 import fr.luc.crcore.message.MessagesService;
 import fr.luc.crcore.message.impl.YamlMessagesService;
+import fr.luc.crcore.team.config.TeamConfigService;
+import fr.luc.crcore.team.config.impl.YamlTeamConfigService;
 import fr.luc.crcore.player.impl.BukkitEventFiringPlayerProfileServiceImpl;
 import fr.luc.crcore.player.impl.InMemoryPlayerProfileRepository;
 import fr.luc.crcore.player.PlayerProfileRepository;
@@ -84,6 +87,7 @@ public class CRCore {
     private PlayerProfileService playerProfileService;
     private MessagesService messages;
     private BroadcastService broadcasts;
+    private TeamConfigService teamConfig;
     private CoreCommand coreCommand;
     private boolean enabled = false;
 
@@ -123,11 +127,13 @@ public class CRCore {
 
         this.messages = buildMessagesService();
         this.broadcasts = buildBroadcastService(messages);
+        this.teamConfig = buildTeamConfigService(teamRepository);
 
-        // Listener Bukkit qui route les events CR-Core vers le BroadcastService.
+        // Listeners Bukkit : broadcasts (events CR-Core) + GUI (inventory clicks/close).
         new CRCoreBroadcastListener(broadcasts).registerOn(plugin);
+        new GuiListener().registerOn(plugin);
 
-        this.coreCommand = buildCoreCommand(teamService, playerProfileService, messages, broadcasts);
+        this.coreCommand = buildCoreCommand(teamService, playerProfileService, messages, broadcasts, teamConfig);
         registerCommand();
 
         registerPlaceholderHook();
@@ -197,8 +203,14 @@ public class CRCore {
     protected CoreCommand buildCoreCommand(TeamService teamService,
                                            PlayerProfileService playerProfileService,
                                            MessagesService messages,
-                                           BroadcastService broadcasts) {
+                                           BroadcastService broadcasts,
-        return new CoreCommand(teamService, playerProfileService, messages, broadcasts);
+                                           TeamConfigService teamConfig) {
+        return new CoreCommand(teamService, playerProfileService, messages, broadcasts, teamConfig);
+    }
+
+    /** Construit le {@link TeamConfigService}. Override pour utiliser une impl custom. */
+    protected TeamConfigService buildTeamConfigService(TeamRepository repository) {
+        return new YamlTeamConfigService(plugin, repository);
     }
 
     /** Construit le {@link MessagesService}. Override pour utiliser une impl custom. */
@@ -289,6 +301,8 @@ public class CRCore {
     public MessagesService messages() { return messages; }
     public BroadcastService getBroadcasts() { return broadcasts; }
     public BroadcastService broadcasts() { return broadcasts; }
+    public TeamConfigService getTeamConfig() { return teamConfig; }
+    public TeamConfigService teamConfig() { return teamConfig; }
     public CoreCommand getCoreCommand() { return coreCommand; }
     public boolean isEnabled() { return enabled; }
 }

src/main/java/fr/luc/crcore/command/builtin/CoreCommand.java

@@ -7,6 +7,7 @@ import fr.luc.crcore.command.builtin.team.TeamGroupSubCommand;
 import fr.luc.crcore.message.MessagesService;
 import fr.luc.crcore.player.PlayerProfileService;
 import fr.luc.crcore.team.TeamService;
+import fr.luc.crcore.team.config.TeamConfigService;
 import org.bukkit.command.CommandSender;
 
 import java.util.Objects;
@@ -21,24 +22,27 @@ public class CoreCommand extends BaseCommand {
     protected final PlayerProfileService playerProfileService;
     protected final MessagesService messages;
     protected final BroadcastService broadcasts;
+    protected final TeamConfigService teamConfig;
 
     public CoreCommand(TeamService teamService,
                        PlayerProfileService playerProfileService,
                        MessagesService messages,
-                       BroadcastService broadcasts) {
+                       BroadcastService broadcasts,
+                       TeamConfigService teamConfig) {
         super("core");
         this.teamService = Objects.requireNonNull(teamService, "teamService");
         this.playerProfileService = Objects.requireNonNull(playerProfileService, "playerProfileService");
         this.messages = Objects.requireNonNull(messages, "messages");
         this.broadcasts = Objects.requireNonNull(broadcasts, "broadcasts");
+        this.teamConfig = Objects.requireNonNull(teamConfig, "teamConfig");
         description("Commandes du noyau CR-Core");
         registerDefaults();
     }
 
     /** Enregistre les groupes par défaut + la sous-commande reload. */
     protected void registerDefaults() {
-        addSubCommand(new TeamGroupSubCommand(teamService, messages));
+        addSubCommand(new TeamGroupSubCommand(teamService, messages, teamConfig));
-        addSubCommand(new CoreReloadSubCommand(messages, broadcasts));
+        addSubCommand(new CoreReloadSubCommand(messages, broadcasts, teamConfig));
     }
 
     /**

src/main/java/fr/luc/crcore/command/builtin/CoreReloadSubCommand.java

@@ -5,28 +5,31 @@ import fr.luc.crcore.command.CommandContext;
 import fr.luc.crcore.command.CommandResult;
 import fr.luc.crcore.command.SubCommand;
 import fr.luc.crcore.message.MessagesService;
+import fr.luc.crcore.team.config.TeamConfigService;
 
 import java.util.Objects;
 
 /**
- * {@code /core reload} — recharge les fichiers
+ * {@code /core reload} — recharge tous les fichiers user du dataFolder :
- * {@code <plugin>-messages.yml} et {@code <plugin>-broadcasts.yml} depuis
+ * {@code <plugin>-messages.yml}, {@code <plugin>-broadcasts.yml} et
- * le disque, sans restart du serveur.
+ * {@code <plugin>-team-config.yml}, sans restart.
  *
- * <p>Permission : {@code crcore.reload}. Les defaults bundlés dans le jar
+ * <p>Permission : {@code crcore.reload}.
- * ne sont pas re-chargés (ils ne bougent pas pendant le runtime), seulement
- * les fichiers user en dataFolder.
  */
 public class CoreReloadSubCommand extends SubCommand {
 
     protected final MessagesService messages;
     protected final BroadcastService broadcasts;
+    protected final TeamConfigService teamConfig;
 
-    public CoreReloadSubCommand(MessagesService messages, BroadcastService broadcasts) {
+    public CoreReloadSubCommand(MessagesService messages,
+                                BroadcastService broadcasts,
+                                TeamConfigService teamConfig) {
         super("reload");
         this.messages = Objects.requireNonNull(messages, "messages");
         this.broadcasts = Objects.requireNonNull(broadcasts, "broadcasts");
-        description("Recharger les fichiers messages et broadcasts");
+        this.teamConfig = Objects.requireNonNull(teamConfig, "teamConfig");
+        description("Recharger les fichiers messages, broadcasts et team-config");
         permission("crcore.reload");
     }
 
@@ -34,6 +37,7 @@ public class CoreReloadSubCommand extends SubCommand {
     public CommandResult execute(CommandContext ctx) {
         messages.reload();
         broadcasts.reload();
+        teamConfig.reload();
         return CommandResult.success(messages.get("common.reload.success"));
     }
 }

src/main/java/fr/luc/crcore/command/builtin/team/TeamGroupSubCommand.java

@@ -3,36 +3,38 @@ package fr.luc.crcore.command.builtin.team;
 import fr.luc.crcore.command.SubCommand;
 import fr.luc.crcore.message.MessagesService;
 import fr.luc.crcore.team.TeamService;
+import fr.luc.crcore.team.config.TeamConfigService;
 
 import java.util.Objects;
 
 /**
- * Groupe {@code /core team ...} : container de toutes les sous-commandes
+ * Groupe {@code /core team ...} — container des sous-commandes par défaut.
- * d'équipe par défaut.
  *
- * <p>Pour overrider une sous-commande, un plugin de jeu fait :
+ * <p>Override d'une feuille :
  * <pre>{@code
  * core.getCoreCommand().findSubCommand("team")
- *     .ifPresent(team -> team.replaceSubCommand("create", new MyCustomCreate(svc, msgs)));
+ *     .ifPresent(team -> team.replaceSubCommand("create",
+ *                       new MyCustomCreate(svc, msgs)));
  * }</pre>
  */
 public class TeamGroupSubCommand extends SubCommand {
 
     protected final TeamService service;
     protected final MessagesService messages;
+    protected final TeamConfigService config;
 
-    public TeamGroupSubCommand(TeamService service, MessagesService messages) {
+    public TeamGroupSubCommand(TeamService service,
+                               MessagesService messages,
+                               TeamConfigService config) {
         super("team");
         this.service = Objects.requireNonNull(service, "service");
         this.messages = Objects.requireNonNull(messages, "messages");
+        this.config = Objects.requireNonNull(config, "config");
         description("Gestion des équipes");
         registerDefaults();
     }
 
-    /**
+    /** Override pour exclure ou ajouter des sous-commandes au jeu standard. */
-     * Enregistre toutes les sous-commandes par défaut. Override pour exclure
-     * ou ajouter des sous-commandes au lieu du jeu standard.
-     */
     protected void registerDefaults() {
         addSubCommand(new TeamCreateSubCommand(service, messages));
         addSubCommand(new TeamDeleteSubCommand(service, messages));
@@ -48,5 +50,6 @@ public class TeamGroupSubCommand extends SubCommand {
         addSubCommand(new TeamScoreSubCommand(service, messages));
         addSubCommand(new TeamTopSubCommand(service, messages));
         addSubCommand(new TeamSetSpawnSubCommand(service, messages));
+        addSubCommand(new TeamSettingsSubCommand(config, messages, service));
     }
 }

src/main/java/fr/luc/crcore/command/builtin/team/TeamSettingsSubCommand.java

@@ -0,0 +1,64 @@
+package fr.luc.crcore.command.builtin.team;
+
+import fr.luc.crcore.command.CommandContext;
+import fr.luc.crcore.command.CommandResult;
+import fr.luc.crcore.command.SubCommand;
+import fr.luc.crcore.message.MessagesService;
+import fr.luc.crcore.team.Team;
+import fr.luc.crcore.team.config.TeamConfigService;
+import fr.luc.crcore.team.config.gui.GlobalSettingsGui;
+import fr.luc.crcore.team.config.gui.TeamSettingsGui;
+import org.bukkit.entity.Player;
+
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * {@code /core team settings [team]}
+ *
+ * <p>Sans argument {@code team} → ouvre le GUI <b>globaux</b> (permission
+ * {@code crcore.team.settings.global}).
+ *
+ * <p>Avec argument {@code team} → ouvre le GUI <b>per-team</b> pour cette
+ * équipe (permission {@code crcore.team.settings}).
+ *
+ * <p>Player-only (besoin d'un inventory holder côté Bukkit).
+ */
+public class TeamSettingsSubCommand extends SubCommand {
+
+    protected final TeamConfigService config;
+    protected final MessagesService messages;
+
+    public TeamSettingsSubCommand(TeamConfigService config,
+                                  MessagesService messages,
+                                  fr.luc.crcore.team.TeamService teamService) {
+        super("settings");
+        this.config = Objects.requireNonNull(config, "config");
+        this.messages = Objects.requireNonNull(messages, "messages");
+        description("Modifier les paramètres globaux ou per-team (GUI)");
+        // Pas de permission fixée ici — on la vérifie manuellement dans execute
+        // selon que l'arg [team] est passé ou non (deux permissions distinctes).
+        playerOnly();
+        optionalArgument("team", TeamArgumentTypes.teamByName(teamService));
+    }
+
+    @Override
+    public CommandResult execute(CommandContext ctx) {
+        Player player = ctx.requirePlayer();
+        Optional<Team> teamOpt = ctx.getOptional("team");
+
+        if (teamOpt.isEmpty()) {
+            if (!player.hasPermission("crcore.team.settings.global")) {
+                return CommandResult.noPermission();
+            }
+            new GlobalSettingsGui(config).openTo(player);
+            return CommandResult.success();
+        }
+
+        if (!player.hasPermission("crcore.team.settings")) {
+            return CommandResult.noPermission();
+        }
+        new TeamSettingsGui(config, teamOpt.get()).openTo(player);
+        return CommandResult.success();
+    }
+}

src/main/java/fr/luc/crcore/gui/AbstractInventoryGui.java

@@ -0,0 +1,118 @@
+package fr.luc.crcore.gui;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Base abstraite pour tous les GUI CR-Core. Implémente {@link InventoryHolder}
+ * pour que {@link GuiListener} puisse identifier les clics destinés à un GUI
+ * CR-Core (via {@code inventory.getHolder() instanceof AbstractInventoryGui}).
+ *
+ * <h2>Pattern d'utilisation</h2>
+ *
+ * <ol>
+ *     <li>Sous-classer (ex. {@code GlobalSettingsGui}).</li>
+ *     <li>Dans le constructeur, créer l'inventaire avec
+ *         {@link Bukkit#createInventory(InventoryHolder, int, String)} en
+ *         passant {@code this} comme holder, puis stocker la référence via
+ *         {@link #setInventory(Inventory)}.</li>
+ *     <li>Appeler {@link #rebuild()} pour construire le contenu initial.</li>
+ *     <li>Pour chaque slot interactif, appeler
+ *         {@link #setButton(int, ItemStack, GuiClickHandler)} qui dépose
+ *         l'item ET enregistre le handler de clic.</li>
+ *     <li>Override {@link #rebuild()} pour reconstruire l'inventaire (utile
+ *         après une modification de l'état).</li>
+ *     <li>Override {@link #onClose(HumanEntity)} pour persister un état au
+ *         moment de la fermeture si besoin.</li>
+ * </ol>
+ *
+ * <p>Ouvrir le GUI à un joueur : {@code gui.openTo(player)}.
+ */
+public abstract class AbstractInventoryGui implements InventoryHolder {
+
+    private Inventory inventory;
+    /** Handlers par slot. Maintenu en parallèle des items déposés. */
+    private final Map<Integer, GuiClickHandler> handlers = new HashMap<>();
+
+    /** À appeler une fois dans le constructeur de la sous-classe. */
+    protected final void setInventory(Inventory inventory) {
+        this.inventory = Objects.requireNonNull(inventory, "inventory");
+    }
+
+    @Override
+    public Inventory getInventory() {
+        return inventory;
+    }
+
+    /** Construit / reconstruit le contenu de l'inventaire. Override obligatoire. */
+    public abstract void rebuild();
+
+    /**
+     * Hook appelé à la fermeture du GUI. Override pour persister un état
+     * (ex. écrire le YAML une seule fois après plusieurs modifs). Défaut :
+     * no-op.
+     */
+    public void onClose(HumanEntity who) {
+    }
+
+    /** Ouvre ce GUI au joueur (raccourci). */
+    public void openTo(HumanEntity player) {
+        Objects.requireNonNull(player, "player");
+        rebuild();
+        player.openInventory(inventory);
+    }
+
+    // ---- Slot management ----
+
+    /** Pose un item + handler de clic sur un slot. */
+    protected final void setButton(int slot, ItemStack item, GuiClickHandler handler) {
+        inventory.setItem(slot, item);
+        if (handler != null) {
+            handlers.put(slot, handler);
+        } else {
+            handlers.remove(slot);
+        }
+    }
+
+    /** Pose un item décoratif (pas de handler de clic — un clic ne fait rien). */
+    protected final void setDecoration(int slot, ItemStack item) {
+        inventory.setItem(slot, item);
+        handlers.remove(slot);
+    }
+
+    /** Vide le slot et son handler. */
+    protected final void clearSlot(int slot) {
+        inventory.setItem(slot, null);
+        handlers.remove(slot);
+    }
+
+    // ---- Click dispatch (appelé par GuiListener) ----
+
+    /**
+     * Appelé par {@link GuiListener} sur un click dans l'inventaire de ce
+     * GUI. Route vers le handler du slot s'il y en a un. <b>Toujours</b>
+     * cancellable côté listener (l'utilisateur ne peut pas déplacer les
+     * items du GUI).
+     */
+    public final void handleClick(InventoryClickEvent event) {
+        int slot = event.getRawSlot();
+        GuiClickHandler handler = handlers.get(slot);
+        if (handler != null) {
+            handler.onClick(event);
+        }
+    }
+
+    /** Hook interne pour {@link GuiListener} sur fermeture. */
+    public final void handleClose(InventoryCloseEvent event) {
+        onClose(event.getPlayer());
+    }
+}

src/main/java/fr/luc/crcore/gui/GuiClickHandler.java

@@ -0,0 +1,20 @@
+package fr.luc.crcore.gui;
+
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+/**
+ * Handler de click pour un slot d'un {@link AbstractInventoryGui}. Le clic
+ * dans l'inventaire d'un GUI CR-Core est <b>toujours annulé</b> par le
+ * {@link GuiListener} avant invocation du handler — le slot reste inchangé,
+ * c'est au handler de modifier l'état interne du GUI puis d'appeler
+ * {@code rebuild()} si besoin.
+ *
+ * <p>Le {@link InventoryClickEvent#getClick()} distingue clic gauche / droit /
+ * shift / etc. — utile pour les boutons d'incrément (gauche = +1, shift+gauche
+ * = +10, droit = -1).
+ */
+@FunctionalInterface
+public interface GuiClickHandler {
+
+    void onClick(InventoryClickEvent event);
+}

src/main/java/fr/luc/crcore/gui/GuiItems.java

@@ -0,0 +1,107 @@
+package fr.luc.crcore.gui;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Helpers de construction d'{@link ItemStack} pour les GUI. Traduit les
+ * codes couleur {@code &} → {@code §} comme le {@link ChatColor}.
+ *
+ * <pre>{@code
+ * ItemStack toggle = GuiItems.named(Material.LIME_DYE, "&aFriendly fire : ON")
+ *     .lore("&7Clic gauche : toggle", "&7Valeur : &fON");
+ * }</pre>
+ */
+public final class GuiItems {
+
+    private GuiItems() {
+    }
+
+    /** Crée un ItemStack avec un nom (codes couleur '&' traduits). */
+    public static Builder named(Material material, String displayName) {
+        return new Builder(material).name(displayName);
+    }
+
+    /** Crée un ItemStack sans nom custom. */
+    public static Builder of(Material material) {
+        return new Builder(material);
+    }
+
+    /** Item décoratif gris (verre) — utilisé pour le bordering. */
+    public static ItemStack filler() {
+        return new Builder(Material.GRAY_STAINED_GLASS_PANE).name(" ").build();
+    }
+
+    /** Builder fluide. */
+    public static final class Builder {
+
+        private final ItemStack stack;
+        private final ItemMeta meta;
+
+        private Builder(Material material) {
+            this.stack = new ItemStack(material);
+            this.meta = stack.getItemMeta();
+        }
+
+        public Builder name(String displayName) {
+            if (meta != null && displayName != null) {
+                meta.setDisplayName(ChatColor.translateAlternateColorCodes('&', displayName));
+            }
+            return this;
+        }
+
+        public Builder lore(String... lines) {
+            if (meta != null && lines != null && lines.length > 0) {
+                List<String> processed = new ArrayList<>(lines.length);
+                for (String line : lines) {
+                    if (line == null) {
+                        processed.add("");
+                    } else {
+                        processed.add(ChatColor.translateAlternateColorCodes('&', line));
+                    }
+                }
+                meta.setLore(processed);
+            }
+            return this;
+        }
+
+        public Builder lore(List<String> lines) {
+            if (lines == null) return this;
+            return lore(lines.toArray(new String[0]));
+        }
+
+        public Builder amount(int amount) {
+            stack.setAmount(Math.max(1, Math.min(64, amount)));
+            return this;
+        }
+
+        public ItemStack build() {
+            if (meta != null) stack.setItemMeta(meta);
+            return stack;
+        }
+
+        /** Implicit build au cast — pratique avec {@code setButton(slot, builder, handler)}. */
+        public ItemStack asItem() {
+            return build();
+        }
+    }
+
+    /**
+     * Implicit conversion pour passer un Builder directement à
+     * {@link AbstractInventoryGui#setButton(int, ItemStack, GuiClickHandler)}.
+     */
+    public static ItemStack item(Builder builder) {
+        return builder.build();
+    }
+
+    /** Liste de strings vers tableau (utilitaire pour lore dynamique). */
+    public static String[] lore(String... lines) {
+        return Arrays.copyOf(lines, lines.length);
+    }
+}

src/main/java/fr/luc/crcore/gui/GuiListener.java

@@ -0,0 +1,55 @@
+package fr.luc.crcore.gui;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.Objects;
+
+/**
+ * Listener Bukkit unique qui route les évènements d'inventaire vers le bon
+ * {@link AbstractInventoryGui} — détecté via {@code inventory.getHolder()
+ * instanceof AbstractInventoryGui}.
+ *
+ * <p>Comportement standard :
+ * <ul>
+ *     <li>{@link InventoryClickEvent} sur un GUI CR-Core →
+ *         {@code event.setCancelled(true)} systématique (l'utilisateur ne
+ *         peut <b>jamais</b> déplacer les items), puis
+ *         {@link AbstractInventoryGui#handleClick}.</li>
+ *     <li>{@link InventoryCloseEvent} sur un GUI CR-Core →
+ *         {@link AbstractInventoryGui#handleClose} (le GUI peut persister
+ *         son état).</li>
+ * </ul>
+ *
+ * <p>Instancié et enregistré une fois dans {@code CRCore.enable()}.
+ */
+public class GuiListener implements Listener {
+
+    /** Enregistre ce listener sur le PluginManager du serveur. */
+    public void registerOn(JavaPlugin plugin) {
+        Objects.requireNonNull(plugin, "plugin").getServer()
+                .getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler
+    public void onClick(InventoryClickEvent event) {
+        InventoryHolder holder = event.getInventory().getHolder();
+        if (!(holder instanceof AbstractInventoryGui)) return;
+        // Annule TOUT clic dans un GUI CR-Core (pas de déplacement d'items
+        // possible, même sur les slots décoratifs sans handler).
+        event.setCancelled(true);
+        ((AbstractInventoryGui) holder).handleClick(event);
+    }
+
+    @EventHandler
+    public void onClose(InventoryCloseEvent event) {
+        InventoryHolder holder = event.getInventory().getHolder();
+        if (holder instanceof AbstractInventoryGui) {
+            ((AbstractInventoryGui) holder).handleClose(event);
+        }
+    }
+}

src/main/java/fr/luc/crcore/team/Team.java

@@ -36,6 +36,7 @@ public class Team extends AbstractEntity implements Named, ScoreHolder {
     private final TeamColor color;
     private final Set<TeamMember> members;
     private final Map<String, Integer> scores;
+    private final Map<String, Object> settings;
     private UUID leaderId;
     private TeamVisibility visibility;
     private Location spawnPoint;
@@ -70,11 +71,25 @@ public class Team extends AbstractEntity implements Named, ScoreHolder {
         this.leaderId = leaderId; // nullable
         this.members = new HashSet<>();
         this.scores = new HashMap<>();
+        this.settings = new HashMap<>();
         if (leaderId != null) {
             this.members.add(newMember(leaderId, TeamRole.LEADER));
         }
     }
 
+    /**
+     * Map mutable des overrides per-team de settings. Clé = nom du
+     * {@link fr.luc.crcore.team.config.TeamSetting}, valeur = forme
+     * sérialisable (Boolean, Integer, String, …).
+     *
+     * <p>Lecture / modification typée recommandée via
+     * {@link fr.luc.crcore.team.config.TeamConfigService}, qui gère la
+     * cascade per-team → global → default et persiste les écritures.
+     */
+    public Map<String, Object> getSettings() {
+        return settings;
+    }
+
     /** Override to instantiate a custom TeamMember subclass. */
     protected TeamMember newMember(UUID playerId, TeamRole role) {
         return new TeamMember(playerId, role);

src/main/java/fr/luc/crcore/team/config/TeamConfigService.java

@@ -0,0 +1,69 @@
+package fr.luc.crcore.team.config;
+
+import fr.luc.crcore.team.Team;
+
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Service de configuration des équipes — résolution en cascade :
+ *
+ * <ol>
+ *     <li><b>Per-team</b> — valeur stockée dans {@link Team#getSettings()},
+ *         persistée en SQLite.</li>
+ *     <li><b>Global</b> — valeur dans {@code <plugin>-team-config.yml},
+ *         modifiable via le GUI globaux ou édition directe du YAML.</li>
+ *     <li><b>Hard default</b> — défini en code dans {@link TeamSettings}.</li>
+ * </ol>
+ *
+ * <p>Le service garantit qu'un {@link #get(Team, TeamSetting)} renvoie
+ * toujours une valeur non-null grâce à la cascade.
+ */
+public interface TeamConfigService {
+
+    /**
+     * Récupère la valeur effective d'un setting pour une équipe (cascade
+     * per-team → global → default).
+     */
+    <T> T get(Team team, TeamSetting<T> setting);
+
+    /**
+     * Récupère la valeur globale d'un setting (cascade global → default,
+     * sans per-team).
+     */
+    <T> T getGlobal(TeamSetting<T> setting);
+
+    /**
+     * Définit un override per-team. Persiste en SQLite via le
+     * {@code TeamRepository} (l'appelant doit save() la team ensuite — ou
+     * passer par le service haut niveau qui le fait).
+     */
+    <T> void setPerTeam(Team team, TeamSetting<T> setting, T value);
+
+    /**
+     * Supprime l'override per-team pour une clé donnée — la team retombe
+     * sur la valeur globale.
+     */
+    void resetPerTeam(Team team, TeamSetting<?> setting);
+
+    /**
+     * Définit une valeur globale et persiste le fichier YAML
+     * {@code <plugin>-team-config.yml}.
+     */
+    <T> void setGlobal(TeamSetting<T> setting, T value);
+
+    /** Recharge le fichier global depuis le disque. */
+    void reload();
+
+    /**
+     * Indique si une équipe a un override pour cette clé (utile pour
+     * l'affichage GUI : « hérité du global » vs « override »).
+     */
+    boolean hasPerTeamOverride(Team team, TeamSetting<?> setting);
+
+    /** Snapshot des valeurs globales actuelles (déjà parsées). */
+    Map<TeamSetting<?>, Object> getGlobalSnapshot();
+
+    /** Chemin du fichier YAML global (informationnel). */
+    Optional<String> getGlobalFileName();
+}

src/main/java/fr/luc/crcore/team/config/TeamSetting.java

@@ -0,0 +1,122 @@
+package fr.luc.crcore.team.config;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * Définition typée d'un paramètre de team : clé, type, valeur par défaut,
+ * sérialisation YAML/SQL.
+ *
+ * <p>Un {@code TeamSetting<T>} est immutable et créé une fois pour toutes
+ * dans {@link TeamSettings}. Il sert à la fois côté lecture
+ * ({@code config.get(team, FRIENDLY_FIRE) → Boolean}) et côté écriture
+ * ({@code config.set(team, FRIENDLY_FIRE, true)}), avec une garantie de
+ * type au compile-time.
+ *
+ * <p>Quatre types supportés via les factories statiques :
+ * <ul>
+ *     <li>{@link #ofBoolean(String, boolean)}</li>
+ *     <li>{@link #ofInt(String, int)}</li>
+ *     <li>{@link #ofString(String, String)}</li>
+ *     <li>{@link #ofEnum(String, Enum)} — l'enum est sérialisé par {@code .name()}</li>
+ * </ul>
+ *
+ * <p>Les valeurs lues depuis YAML / SQLite sont des {@code Object} ;
+ * {@link #parse(Object)} les convertit en {@code T}. Si la conversion
+ * échoue, le default est utilisé.
+ */
+public final class TeamSetting<T> {
+
+    /** Type primitif simple pour aiguillage côté GUI / sérialisation. */
+    public enum Kind { BOOLEAN, INTEGER, STRING, ENUM }
+
+    private final String key;
+    private final Class<T> type;
+    private final T defaultValue;
+    private final Kind kind;
+    /** Convertit un Object brut (lu depuis YAML/SQL) vers {@code T}. */
+    private final Function<Object, T> parser;
+    /** Convertit {@code T} vers une représentation sérialisable (String/Number/Boolean). */
+    private final Function<T, Object> serializer;
+
+    private TeamSetting(String key, Class<T> type, T defaultValue, Kind kind,
+                        Function<Object, T> parser, Function<T, Object> serializer) {
+        this.key = Objects.requireNonNull(key, "key");
+        this.type = Objects.requireNonNull(type, "type");
+        this.defaultValue = Objects.requireNonNull(defaultValue, "defaultValue");
+        this.kind = Objects.requireNonNull(kind, "kind");
+        this.parser = Objects.requireNonNull(parser, "parser");
+        this.serializer = Objects.requireNonNull(serializer, "serializer");
+    }
+
+    public String getKey() { return key; }
+    public Class<T> getType() { return type; }
+    public T getDefaultValue() { return defaultValue; }
+    public Kind getKind() { return kind; }
+
+    /** Convertit une valeur brute (YAML, JDBC) en {@code T}, renvoie le default si échec. */
+    public T parse(Object raw) {
+        if (raw == null) return defaultValue;
+        try {
+            T parsed = parser.apply(raw);
+            return parsed != null ? parsed : defaultValue;
+        } catch (Exception ex) {
+            return defaultValue;
+        }
+    }
+
+    /** Convertit une valeur {@code T} vers la forme sérialisable (à stocker en YAML/SQL). */
+    public Object serialize(T value) {
+        return value != null ? serializer.apply(value) : null;
+    }
+
+    // ---- Factories ----
+
+    public static TeamSetting<Boolean> ofBoolean(String key, boolean defaultValue) {
+        return new TeamSetting<>(key, Boolean.class, defaultValue, Kind.BOOLEAN,
+                raw -> {
+                    if (raw instanceof Boolean) return (Boolean) raw;
+                    if (raw instanceof Number) return ((Number) raw).intValue() != 0;
+                    return Boolean.parseBoolean(raw.toString());
+                },
+                b -> b);
+    }
+
+    public static TeamSetting<Integer> ofInt(String key, int defaultValue) {
+        return new TeamSetting<>(key, Integer.class, defaultValue, Kind.INTEGER,
+                raw -> {
+                    if (raw instanceof Number) return ((Number) raw).intValue();
+                    return Integer.parseInt(raw.toString().trim());
+                },
+                i -> i);
+    }
+
+    public static TeamSetting<String> ofString(String key, String defaultValue) {
+        return new TeamSetting<>(key, String.class, defaultValue, Kind.STRING,
+                Object::toString,
+                s -> s);
+    }
+
+    public static <E extends Enum<E>> TeamSetting<E> ofEnum(String key, E defaultValue) {
+        @SuppressWarnings("unchecked")
+        Class<E> enumClass = (Class<E>) defaultValue.getDeclaringClass();
+        return new TeamSetting<>(key, enumClass, defaultValue, Kind.ENUM,
+                raw -> Enum.valueOf(enumClass, raw.toString().trim().toUpperCase()),
+                Enum::name);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof TeamSetting)) return false;
+        return key.equals(((TeamSetting<?>) o).key);
+    }
+
+    @Override
+    public int hashCode() { return key.hashCode(); }
+
+    @Override
+    public String toString() {
+        return "TeamSetting[" + key + " : " + kind + ", default=" + defaultValue + "]";
+    }
+}

src/main/java/fr/luc/crcore/team/config/TeamSettings.java

@@ -0,0 +1,97 @@
+package fr.luc.crcore.team.config;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Registry des {@link TeamSetting} connus par CR-Core.
+ *
+ * <p>Définit l'ensemble fermé des settings standards et expose une API
+ * de lookup par clé. Un game plugin peut ajouter ses propres settings via
+ * {@link #register(TeamSetting)}.
+ *
+ * <h2>Settings standards</h2>
+ *
+ * <table>
+ *   <tr><th>Constante</th><th>Clé YAML/SQL</th><th>Type</th><th>Défaut</th></tr>
+ *   <tr><td>{@link #FRIENDLY_FIRE}</td>          <td>friendly_fire</td>          <td>bool</td> <td>false</td></tr>
+ *   <tr><td>{@link #PVP_PROTECTION_SECONDS}</td> <td>pvp_protection_seconds</td> <td>int</td>  <td>0</td></tr>
+ *   <tr><td>{@link #MAX_SIZE}</td>               <td>max_size</td>               <td>int</td>  <td>0 (illimité)</td></tr>
+ *   <tr><td>{@link #MIN_SIZE}</td>               <td>min_size</td>               <td>int</td>  <td>0</td></tr>
+ *   <tr><td>{@link #RESPAWN_AT_TEAM_SPAWN}</td>  <td>respawn_at_team_spawn</td>  <td>bool</td> <td>true</td></tr>
+ *   <tr><td>{@link #TEAM_CHAT_ENABLED}</td>      <td>team_chat_enabled</td>      <td>bool</td> <td>true</td></tr>
+ *   <tr><td>{@link #SHOW_TAG_ABOVE_HEAD}</td>    <td>show_tag_above_head</td>    <td>bool</td> <td>true</td></tr>
+ *   <tr><td>{@link #TEAM_COLOR_IN_NAME}</td>     <td>team_color_in_name</td>     <td>bool</td> <td>true</td></tr>
+ * </table>
+ */
+public final class TeamSettings {
+
+    // ---- Settings standards ----
+
+    public static final TeamSetting<Boolean> FRIENDLY_FIRE =
+            TeamSetting.ofBoolean("friendly_fire", false);
+
+    public static final TeamSetting<Integer> PVP_PROTECTION_SECONDS =
+            TeamSetting.ofInt("pvp_protection_seconds", 0);
+
+    public static final TeamSetting<Integer> MAX_SIZE =
+            TeamSetting.ofInt("max_size", 0);
+
+    public static final TeamSetting<Integer> MIN_SIZE =
+            TeamSetting.ofInt("min_size", 0);
+
+    public static final TeamSetting<Boolean> RESPAWN_AT_TEAM_SPAWN =
+            TeamSetting.ofBoolean("respawn_at_team_spawn", true);
+
+    public static final TeamSetting<Boolean> TEAM_CHAT_ENABLED =
+            TeamSetting.ofBoolean("team_chat_enabled", true);
+
+    public static final TeamSetting<Boolean> SHOW_TAG_ABOVE_HEAD =
+            TeamSetting.ofBoolean("show_tag_above_head", true);
+
+    public static final TeamSetting<Boolean> TEAM_COLOR_IN_NAME =
+            TeamSetting.ofBoolean("team_color_in_name", true);
+
+    // ---- Registry interne ----
+
+    /** LinkedHashMap pour préserver l'ordre d'enregistrement (utile pour l'affichage GUI). */
+    private static final Map<String, TeamSetting<?>> REGISTRY = new LinkedHashMap<>();
+
+    static {
+        register(FRIENDLY_FIRE);
+        register(PVP_PROTECTION_SECONDS);
+        register(MAX_SIZE);
+        register(MIN_SIZE);
+        register(RESPAWN_AT_TEAM_SPAWN);
+        register(TEAM_CHAT_ENABLED);
+        register(SHOW_TAG_ABOVE_HEAD);
+        register(TEAM_COLOR_IN_NAME);
+    }
+
+    private TeamSettings() {
+    }
+
+    /**
+     * Enregistre un setting custom. Un game plugin peut appeler
+     * {@code TeamSettings.register(MY_SETTING)} dans son onEnable() pour
+     * que sa clé apparaisse dans les GUI globaux et per-team.
+     */
+    public static synchronized void register(TeamSetting<?> setting) {
+        Objects.requireNonNull(setting, "setting");
+        REGISTRY.put(setting.getKey(), setting);
+    }
+
+    /** Récupère un setting par sa clé (non typé — utile pour itération générique). */
+    public static Optional<TeamSetting<?>> get(String key) {
+        return Optional.ofNullable(REGISTRY.get(key));
+    }
+
+    /** Tous les settings enregistrés dans l'ordre d'enregistrement. */
+    public static Collection<TeamSetting<?>> all() {
+        return Collections.unmodifiableCollection(REGISTRY.values());
+    }
+}

src/main/java/fr/luc/crcore/team/config/gui/AbstractSettingsGui.java

@@ -0,0 +1,168 @@
+package fr.luc.crcore.team.config.gui;
+
+import fr.luc.crcore.gui.AbstractInventoryGui;
+import fr.luc.crcore.gui.GuiItems;
+import fr.luc.crcore.team.config.TeamSetting;
+import fr.luc.crcore.team.config.TeamSettings;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Base commune des deux GUI de settings (globaux et per-team). Implémente
+ * le rendu en grille des settings standards :
+ *
+ * <ul>
+ *     <li>Booléens : lampe verte / rouge selon état, clic = toggle.</li>
+ *     <li>Entiers : item livre avec lore, clic gauche +1 / shift +10, clic
+ *         droit -1 / shift -10, clamp à 0 mini.</li>
+ *     <li>Strings et Enums : affichage de la valeur (édition pas exposée
+ *         dans cette V1 — à passer par YAML pour ces types).</li>
+ * </ul>
+ *
+ * <p>La sous-classe fournit la valeur courante et le callback de changement.
+ */
+public abstract class AbstractSettingsGui extends AbstractInventoryGui {
+
+    /** Taille fixe de l'inventaire (3 lignes × 9 = 27 slots). Suffisant pour 8 settings. */
+    protected static final int SIZE = 27;
+
+    /** Slots où les settings sont positionnés (10..16 = la ligne du milieu sans les bords). */
+    protected static final int[] SETTING_SLOTS = {10, 11, 12, 13, 14, 15, 16};
+
+    protected AbstractSettingsGui(String title) {
+        Inventory inv = Bukkit.createInventory(this, SIZE, title);
+        setInventory(inv);
+    }
+
+    @Override
+    public void rebuild() {
+        // Bordures décoratives.
+        ItemStack filler = GuiItems.filler();
+        for (int i = 0; i < SIZE; i++) {
+            getInventory().setItem(i, filler);
+        }
+
+        // Settings dans les slots du milieu.
+        List<TeamSetting<?>> all = new ArrayList<>(TeamSettings.all());
+        for (int i = 0; i < all.size() && i < SETTING_SLOTS.length; i++) {
+            TeamSetting<?> setting = all.get(i);
+            renderSetting(SETTING_SLOTS[i], setting);
+        }
+
+        // Slot 22 = footer (reset/info/close — défini par les sous-classes via renderFooter()).
+        renderFooter();
+    }
+
+    /** Hook pour les sous-classes : poser un bouton de footer (close, reset, etc.). */
+    protected void renderFooter() {
+        // Par défaut, juste une fermeture.
+        setButton(22,
+                GuiItems.named(Material.BARRIER, "&cFermer").build(),
+                e -> e.getWhoClicked().closeInventory());
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> void renderSetting(int slot, TeamSetting<T> setting) {
+        T currentValue = getCurrentValue(setting);
+        boolean isOverride = isOverride(setting);
+
+        ItemStack icon;
+        switch (setting.getKind()) {
+            case BOOLEAN: {
+                Boolean b = (Boolean) currentValue;
+                Material mat = Boolean.TRUE.equals(b)
+                        ? Material.LIME_DYE
+                        : Material.GRAY_DYE;
+                String state = Boolean.TRUE.equals(b) ? "&aON" : "&7OFF";
+                icon = GuiItems.named(mat, "&f" + setting.getKey())
+                        .lore(buildLore("Booléen",
+                                "État : " + state,
+                                "&7Clic gauche : toggle",
+                                isOverride ? "&eOverride per-team actif" : null))
+                        .build();
+                setButton(slot, icon, e -> {
+                    boolean current = Boolean.TRUE.equals(getCurrentValue(setting));
+                    onChange((TeamSetting<T>) setting, (T) Boolean.valueOf(!current));
+                    rebuild();
+                });
+                break;
+            }
+            case INTEGER: {
+                Integer val = (Integer) currentValue;
+                icon = GuiItems.named(Material.BOOK, "&f" + setting.getKey())
+                        .lore(buildLore("Entier",
+                                "Valeur : &f" + val,
+                                "&7Clic gauche : +1   (shift : +10)",
+                                "&7Clic droit  : -1   (shift : -10)",
+                                isOverride ? "&eOverride per-team actif" : null))
+                        .build();
+                setButton(slot, icon, createIntHandler(setting, val));
+                break;
+            }
+            case STRING:
+            case ENUM:
+            default: {
+                icon = GuiItems.named(Material.PAPER, "&f" + setting.getKey())
+                        .lore(buildLore("Texte / Enum",
+                                "Valeur : &f" + currentValue,
+                                "&7Édition non exposée — modifier via YAML",
+                                isOverride ? "&eOverride per-team actif" : null))
+                        .build();
+                setDecoration(slot, icon);
+                break;
+            }
+        }
+    }
+
+    private <T> fr.luc.crcore.gui.GuiClickHandler createIntHandler(TeamSetting<T> setting, Integer baseValue) {
+        return event -> {
+            Integer current = (Integer) getCurrentValue((TeamSetting<?>) setting);
+            int amount = computeIntDelta(event);
+            int next = Math.max(0, current + amount);
+            @SuppressWarnings("unchecked")
+            T typed = (T) Integer.valueOf(next);
+            onChange(setting, typed);
+            rebuild();
+        };
+    }
+
+    /** Calcule le delta pour un clic sur un entier (gauche/droit + shift). */
+    protected int computeIntDelta(InventoryClickEvent event) {
+        boolean shift = event.isShiftClick();
+        switch (event.getClick()) {
+            case LEFT:        return shift ? +10 : +1;
+            case RIGHT:       return shift ? -10 : -1;
+            case SHIFT_LEFT:  return +10;
+            case SHIFT_RIGHT: return -10;
+            default:          return 0;
+        }
+    }
+
+    /** Construit une lore en filtrant les lignes null. */
+    protected String[] buildLore(String... lines) {
+        List<String> out = new ArrayList<>(lines.length);
+        for (String line : lines) {
+            if (line != null) out.add(line);
+        }
+        return out.toArray(new String[0]);
+    }
+
+    // ---- Hooks pour les sous-classes ----
+
+    /** Valeur courante affichée pour ce setting (globale ou per-team selon le GUI). */
+    protected abstract <T> T getCurrentValue(TeamSetting<T> setting);
+
+    /** Appelé quand l'utilisateur modifie un setting via clic. */
+    protected abstract <T> void onChange(TeamSetting<T> setting, T newValue);
+
+    /** Indique si la valeur affichée est un override per-team (juste pour l'UI). */
+    protected boolean isOverride(TeamSetting<?> setting) {
+        return false;
+    }
+}

src/main/java/fr/luc/crcore/team/config/gui/GlobalSettingsGui.java

@@ -0,0 +1,35 @@
+package fr.luc.crcore.team.config.gui;
+
+import fr.luc.crcore.team.config.TeamConfigService;
+import fr.luc.crcore.team.config.TeamSetting;
+
+import java.util.Objects;
+
+/**
+ * GUI d'édition des settings <b>globaux</b>. Lit / écrit dans le fichier
+ * {@code <plugin>-team-config.yml} via {@link TeamConfigService}.
+ *
+ * <p>Chaque modification est immédiatement persistée sur disque (pas de
+ * "save" différé) — comme ça si le serveur crash, rien n'est perdu.
+ */
+public class GlobalSettingsGui extends AbstractSettingsGui {
+
+    private final TeamConfigService config;
+
+    public GlobalSettingsGui(TeamConfigService config) {
+        super("§eParamètres globaux d'équipe");
+        this.config = Objects.requireNonNull(config, "config");
+    }
+
+    @Override
+    protected <T> T getCurrentValue(TeamSetting<T> setting) {
+        return config.getGlobal(setting);
+    }
+
+    @Override
+    protected <T> void onChange(TeamSetting<T> setting, T newValue) {
+        config.setGlobal(setting, newValue);
+    }
+
+    // isOverride() reste à false : on est globaux, rien n'est "override per-team".
+}

src/main/java/fr/luc/crcore/team/config/gui/TeamSettingsGui.java

@@ -0,0 +1,63 @@
+package fr.luc.crcore.team.config.gui;
+
+import fr.luc.crcore.gui.GuiItems;
+import fr.luc.crcore.team.Team;
+import fr.luc.crcore.team.config.TeamConfigService;
+import fr.luc.crcore.team.config.TeamSetting;
+import fr.luc.crcore.team.config.TeamSettings;
+import org.bukkit.Material;
+
+import java.util.Objects;
+
+/**
+ * GUI d'édition des settings <b>per-team</b>. Lit la valeur effective
+ * (cascade per-team → global → default) et écrit dans la map
+ * {@link Team#getSettings()} via {@link TeamConfigService}.
+ *
+ * <p>Footer additionnel : bouton "Reset tous les overrides" qui efface
+ * toutes les valeurs per-team de l'équipe pour les faire retomber sur le
+ * global.
+ */
+public class TeamSettingsGui extends AbstractSettingsGui {
+
+    private final TeamConfigService config;
+    private final Team team;
+
+    public TeamSettingsGui(TeamConfigService config, Team team) {
+        super("§e" + team.getName() + " — paramètres");
+        this.config = Objects.requireNonNull(config, "config");
+        this.team = Objects.requireNonNull(team, "team");
+    }
+
+    @Override
+    protected <T> T getCurrentValue(TeamSetting<T> setting) {
+        return config.get(team, setting);
+    }
+
+    @Override
+    protected <T> void onChange(TeamSetting<T> setting, T newValue) {
+        config.setPerTeam(team, setting, newValue);
+    }
+
+    @Override
+    protected boolean isOverride(TeamSetting<?> setting) {
+        return config.hasPerTeamOverride(team, setting);
+    }
+
+    @Override
+    protected void renderFooter() {
+        // Bouton "Reset all" en plus du Close.
+        setButton(18,
+                GuiItems.named(Material.LAVA_BUCKET, "&cReset tous les overrides")
+                        .lore("&7Efface toutes les valeurs per-team de",
+                              "&7" + team.getName() + " — retour au global.")
+                        .build(),
+                e -> {
+                    for (TeamSetting<?> s : TeamSettings.all()) {
+                        config.resetPerTeam(team, s);
+                    }
+                    rebuild();
+                });
+        super.renderFooter(); // Close
+    }
+}

src/main/java/fr/luc/crcore/team/config/impl/YamlTeamConfigService.java

@@ -0,0 +1,222 @@
+package fr.luc.crcore.team.config.impl;
+
+import fr.luc.crcore.team.Team;
+import fr.luc.crcore.team.TeamRepository;
+import fr.luc.crcore.team.config.TeamConfigService;
+import fr.luc.crcore.team.config.TeamSetting;
+import fr.luc.crcore.team.config.TeamSettings;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Impl YAML par défaut : charge le fichier {@code <plugin>-team-config.yml}
+ * en mémoire, persiste les modifs globales avec
+ * {@link YamlConfiguration#save(File)}, et délègue le per-team au stockage
+ * dans {@link Team#getSettings()} (persisté par {@link TeamRepository}).
+ *
+ * <p>Pattern identique à {@code YamlMessagesService} et
+ * {@code YamlBroadcastService} : defaults bundlés dans le jar
+ * ({@code crcore-team-config.yml}), fichier user créé au premier boot
+ * (template du plugin de jeu en priorité s'il en bundle un, sinon defaults).
+ *
+ * <p>Les valeurs globales sont stockées en {@code Object} dans la map
+ * {@link #globalValues}, parsées à la lecture via
+ * {@link TeamSetting#parse(Object)}.
+ */
+public class YamlTeamConfigService implements TeamConfigService {
+
+    private static final String CRCORE_DEFAULTS_RESOURCE = "crcore-team-config.yml";
+
+    private final JavaPlugin plugin;
+    private final TeamRepository teamRepository;
+    private final Logger logger;
+    private final String userFileName;
+    private final File userFile;
+    /** Snapshot des valeurs globales lues depuis le fichier user (clé → Object brut). */
+    private final Map<String, Object> globalValues = new HashMap<>();
+
+    public YamlTeamConfigService(JavaPlugin plugin, TeamRepository teamRepository) {
+        this.plugin = Objects.requireNonNull(plugin, "plugin");
+        this.teamRepository = Objects.requireNonNull(teamRepository, "teamRepository");
+        this.logger = plugin.getLogger();
+        this.userFileName = plugin.getName().toLowerCase(Locale.ROOT) + "-team-config.yml";
+        this.userFile = new File(plugin.getDataFolder(), userFileName);
+        initialize();
+    }
+
+    private void initialize() {
+        ensureUserFile();
+        rebuildGlobalValues();
+    }
+
+    private void ensureUserFile() {
+        if (userFile.exists()) return;
+        if (!plugin.getDataFolder().exists() && !plugin.getDataFolder().mkdirs()) {
+            logger.warning("Impossible de créer " + plugin.getDataFolder());
+            return;
+        }
+        // Priorité 1 : ressource du plugin de jeu sous le même nom.
+        try (InputStream pluginResource = plugin.getResource(userFileName)) {
+            if (pluginResource != null) {
+                copyStreamToFile(pluginResource, userFile);
+                logger.info("Fichier team-config créé depuis le template du plugin : " + userFileName);
+                return;
+            }
+        } catch (IOException ex) {
+            logger.log(Level.WARNING, "Échec copie du template plugin", ex);
+        }
+        // Priorité 2 : defaults CR-Core.
+        try (InputStream coreResource = plugin.getResource(CRCORE_DEFAULTS_RESOURCE)) {
+            if (coreResource != null) {
+                copyStreamToFile(coreResource, userFile);
+                logger.info("Fichier team-config créé depuis les defaults CR-Core : " + userFileName);
+            }
+        } catch (IOException ex) {
+            logger.log(Level.WARNING, "Échec copie des defaults team-config", ex);
+        }
+    }
+
+    private static void copyStreamToFile(InputStream in, File target) throws IOException {
+        try (FileOutputStream out = new FileOutputStream(target)) {
+            in.transferTo(out);
+        }
+    }
+
+    /** Recharge les valeurs globales depuis le fichier user (ou rien si absent). */
+    private void rebuildGlobalValues() {
+        globalValues.clear();
+        if (!userFile.exists()) return;
+        try {
+            YamlConfiguration cfg = YamlConfiguration.loadConfiguration(userFile);
+            flatten(cfg, "", globalValues);
+        } catch (Exception ex) {
+            logger.log(Level.WARNING, "Échec chargement " + userFile, ex);
+        }
+    }
+
+    // ---- TeamConfigService API ----
+
+    @Override
+    public <T> T get(Team team, TeamSetting<T> setting) {
+        Objects.requireNonNull(team, "team");
+        Objects.requireNonNull(setting, "setting");
+        Object override = team.getSettings().get(setting.getKey());
+        if (override != null) {
+            return setting.parse(override);
+        }
+        return getGlobal(setting);
+    }
+
+    @Override
+    public <T> T getGlobal(TeamSetting<T> setting) {
+        Objects.requireNonNull(setting, "setting");
+        Object raw = globalValues.get(setting.getKey());
+        if (raw == null) return setting.getDefaultValue();
+        return setting.parse(raw);
+    }
+
+    @Override
+    public <T> void setPerTeam(Team team, TeamSetting<T> setting, T value) {
+        Objects.requireNonNull(team, "team");
+        Objects.requireNonNull(setting, "setting");
+        Object serialized = setting.serialize(value);
+        if (serialized == null) {
+            team.getSettings().remove(setting.getKey());
+        } else {
+            team.getSettings().put(setting.getKey(), serialized);
+        }
+        teamRepository.save(team);
+    }
+
+    @Override
+    public void resetPerTeam(Team team, TeamSetting<?> setting) {
+        Objects.requireNonNull(team, "team");
+        Objects.requireNonNull(setting, "setting");
+        if (team.getSettings().remove(setting.getKey()) != null) {
+            teamRepository.save(team);
+        }
+    }
+
+    @Override
+    public <T> void setGlobal(TeamSetting<T> setting, T value) {
+        Objects.requireNonNull(setting, "setting");
+        Object serialized = setting.serialize(value);
+        globalValues.put(setting.getKey(), serialized);
+        persistGlobals();
+    }
+
+    @Override
+    public void reload() {
+        rebuildGlobalValues();
+    }
+
+    @Override
+    public boolean hasPerTeamOverride(Team team, TeamSetting<?> setting) {
+        return team.getSettings().containsKey(setting.getKey());
+    }
+
+    @Override
+    public Map<TeamSetting<?>, Object> getGlobalSnapshot() {
+        Map<TeamSetting<?>, Object> snapshot = new LinkedHashMap<>();
+        for (TeamSetting<?> s : TeamSettings.all()) {
+            snapshot.put(s, getGlobalAsObject(s));
+        }
+        return snapshot;
+    }
+
+    private Object getGlobalAsObject(TeamSetting<?> setting) {
+        Object raw = globalValues.get(setting.getKey());
+        if (raw == null) return setting.getDefaultValue();
+        return setting.parse(raw);
+    }
+
+    @Override
+    public Optional<String> getGlobalFileName() {
+        return Optional.of(userFileName);
+    }
+
+    // ---- Persistance YAML ----
+
+    private void persistGlobals() {
+        try {
+            YamlConfiguration cfg = new YamlConfiguration();
+            // Sérialisation flat : clés à plat (les settings n'ont pas de structure imbriquée).
+            for (Map.Entry<String, Object> e : globalValues.entrySet()) {
+                cfg.set(e.getKey(), e.getValue());
+            }
+            cfg.save(userFile);
+        } catch (IOException ex) {
+            logger.log(Level.WARNING, "Échec écriture " + userFile, ex);
+        }
+    }
+
+    // ---- YAML helpers ----
+
+    private static void flatten(ConfigurationSection section, String prefix, Map<String, Object> out) {
+        for (String key : section.getKeys(false)) {
+            String fullKey = prefix.isEmpty() ? key : prefix + "." + key;
+            Object value = section.get(key);
+            if (value instanceof ConfigurationSection) {
+                flatten((ConfigurationSection) value, fullKey, out);
+            } else if (value != null) {
+                out.put(fullKey, value);
+            }
+        }
+    }
+}

src/main/java/fr/luc/crcore/team/impl/SqliteTeamRepository.java

@@ -43,6 +43,7 @@ public class SqliteTeamRepository extends InMemoryTeamRepository {
     private static final String TABLE_TEAMS = "crcore_teams";
     private static final String TABLE_MEMBERS = "crcore_team_members";
     private static final String TABLE_SCORES = "crcore_team_scores";
+    private static final String TABLE_SETTINGS = "crcore_team_settings";
 
     private final Database db;
 
@@ -82,6 +83,15 @@ public class SqliteTeamRepository extends InMemoryTeamRepository {
                 .column("value", ColumnType.INTEGER).notNull()
                 .create();
 
+        // Settings per-team (overrides de la config globale).
+        // type ∈ {bool, int, str} pour reconstruire le bon type Java au load.
+        db.table(TABLE_SETTINGS).ifNotExists()
+                .column("team_id", ColumnType.UUID).notNull()
+                .column("key", ColumnType.TEXT).notNull()
+                .column("value", ColumnType.TEXT).notNull()
+                .column("type", ColumnType.TEXT).notNull()
+                .create();
+
         // Migration : ancien schéma avait leader_id NOT NULL ; on le rend nullable
         // pour permettre des équipes leaderless. SQLite ne supporte pas ALTER COLUMN,
         // donc on recrée la table en copiant les données.
@@ -180,6 +190,18 @@ public class SqliteTeamRepository extends InMemoryTeamRepository {
                     },
                     row.id
             );
+            // Settings (overrides per-team). Reconstruit le type Java selon la colonne "type".
+            db.query(
+                    "SELECT key, value, type FROM " + TABLE_SETTINGS + " WHERE team_id = ?",
+                    rs -> {
+                        String key = rs.getString("key");
+                        String raw = rs.getString("value");
+                        String type = rs.getString("type");
+                        team.getSettings().put(key, deserializeSetting(raw, type));
+                        return null;
+                    },
+                    row.id
+            );
             // Spawn point — différé : nécessite un World qui n'est pas forcément chargé
             // au moment du load. Le serveur charge les worlds avant les plugins normalement,
             // mais on est défensif.
@@ -209,6 +231,7 @@ public class SqliteTeamRepository extends InMemoryTeamRepository {
     public boolean delete(UUID id) {
         boolean removed = super.delete(id);
         if (removed) {
+            db.update("DELETE FROM " + TABLE_SETTINGS + " WHERE team_id = ?", id);
             db.update("DELETE FROM " + TABLE_SCORES + " WHERE team_id = ?", id);
             db.update("DELETE FROM " + TABLE_MEMBERS + " WHERE team_id = ?", id);
             db.update("DELETE FROM " + TABLE_TEAMS + " WHERE id = ?", id);
@@ -253,6 +276,36 @@ public class SqliteTeamRepository extends InMemoryTeamRepository {
                         team.getId(), name, value
                 )
         );
+
+        // Settings : replace en bloc, comme les scores.
+        db.update("DELETE FROM " + TABLE_SETTINGS + " WHERE team_id = ?", team.getId());
+        team.getSettings().forEach((key, value) -> {
+            String type = inferTypeTag(value);
+            db.update(
+                    "INSERT INTO " + TABLE_SETTINGS + " (team_id, key, value, type) VALUES (?, ?, ?, ?)",
+                    team.getId(), key, String.valueOf(value), type
+            );
+        });
+    }
+
+    /** Détecte un tag de type ("bool" / "int" / "str") pour persister la valeur. */
+    private static String inferTypeTag(Object value) {
+        if (value instanceof Boolean) return "bool";
+        if (value instanceof Integer || value instanceof Long || value instanceof Short) return "int";
+        return "str";
+    }
+
+    /** Reconstruit la valeur Java depuis la forme String + type tag. */
+    private static Object deserializeSetting(String raw, String type) {
+        if (raw == null) return null;
+        switch (type) {
+            case "bool": return Boolean.parseBoolean(raw);
+            case "int":
+                try { return Integer.parseInt(raw); }
+                catch (NumberFormatException ex) { return 0; }
+            case "str":
+            default:    return raw;
+        }
     }
 
     // Tuples internes pour le load. Classes immutables manuelles (Java 11 compat).

src/main/resources/crcore-team-config.yml

@@ -0,0 +1,38 @@
+# =============================================================================
+# CR-Core — paramètres globaux d'équipe (defaults)
+# -----------------------------------------------------------------------------
+# Ce fichier est embarqué dans le jar CR-Core et copié dans :
+#   <plugin>/<nom-plugin>-team-config.yml
+# au premier démarrage. C'est CE fichier (la copie en dataFolder) que l'admin
+# édite — soit à la main, soit via le GUI in-game (/core team settings).
+#
+# Modèle de résolution pour une équipe :
+#   1. valeur per-team (stockée en SQLite, override admin via GUI)
+#   2. valeur de ce fichier (globale, override admin via YAML ou GUI globaux)
+#   3. valeur en dur dans TeamSettings (jamais touchée à runtime)
+# =============================================================================
+
+# PvP entre membres d'une même équipe.
+friendly_fire: false
+
+# Protection PvP en secondes après création / respawn (0 = pas de protection).
+pvp_protection_seconds: 0
+
+# Taille maximale d'une équipe. 0 = illimitée.
+max_size: 0
+
+# Taille minimale pour qu'une équipe soit considérée "active". 0 = pas de minimum.
+min_size: 0
+
+# Le respawn s'effectue au point de spawn de l'équipe (si défini).
+# false → respawn au spawn vanilla du monde.
+respawn_at_team_spawn: true
+
+# Active le chat dédié à la team (canal séparé).
+team_chat_enabled: true
+
+# Affiche le tag [#TAG] au-dessus de la tête des membres.
+show_tag_above_head: true
+
+# Colorie le nom du joueur avec la couleur de la team (chat, tablist).
+team_color_in_name: true