grimoire-kit 3.77.0__tar.gz → 3.78.1__tar.gz

{grimoire_kit-3.77.0 → grimoire_kit-3.78.1}/CHANGELOG.md

@@ -7,6 +7,15 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
 ## [Unreleased]
 
+## [3.78.1] - 2026-11-06
+
+- fix(missions): la relecture d'un dispatch ne porte plus que sur ce que l'ouvrier a changé : plus de fausse alerte sur un arbre déjà modifié, et les fichiers qu'il crée ne lui échappent plus (#1101)
+
+## [3.78.0] - 2026-11-05
+
+- feat(providers): écrire le registre de fournisseurs LLM (`grimoire providers add|enable|disable|remove`) et poser une clé en saisie masquée (`set-key`/`remove-key`/`secrets`) dans un magasin léger `~/.env-store/`, jamais dans le registre ; `task dispatch` fusionne désormais ces variables dans l'environnement du sous-processus avant d'invoquer le fournisseur (#1099)
+- fix(cockpit): la Flotte ne rend plus une santé en erreur sous charge (lecteur YAML partagé entre threads) ; ses tests e2e attendent l'état de la table et la fin de la navigation « Ouvrir » (GAO-i15-stabili-001) (#1096)
+
 ## [3.77.0] - 2026-10-30
 
 - chore(release): correctifs intermédiaires des PR fusionnées par commit de fusion, déjà décrits par le fragment de leur PR : e56b9bde, 643cd839, 45360126, ea109781, efb3ea4e, 00f1a297, 195fcb60

{grimoire_kit-3.77.0 → grimoire_kit-3.78.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.77.0
+Version: 3.78.1
 Summary: Dashboard, task board, project memory and evidence check for code you delegate to agents (Claude Code, Copilot).
 Project-URL: Homepage, https://github.com/Guilhem-Bonnet/Grimoire-kit
 Project-URL: Repository, https://github.com/Guilhem-Bonnet/Grimoire-kit

{grimoire_kit-3.77.0 → grimoire_kit-3.78.1}/pyproject.toml

@@ -185,7 +185,7 @@ strict = true
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true
-exclude = ["_grimoire/"]
+exclude = ["_grimoire/", "_scratch/"]
 
 [[tool.mypy.overrides]]
 module = "tests.*"

{grimoire_kit-3.77.0 → grimoire_kit-3.78.1}/registry/kit-file-hashes.json

@@ -1,6 +1,6 @@
 {
  "schema": "grimoire-kit-file-hashes/v1",
- "generated_for": "3.77.0",
+ "generated_for": "3.78.1",
  "digests": {
   "002d1e68ce00769ee09d1e94f4af260b952837f7d1557080c2fd505216c23ac0": {
    "version": "3.11.2",

grimoire_kit-3.78.1/src/grimoire/__version__.py

@@ -0,0 +1 @@
+__version__ = "3.78.1"

{grimoire_kit-3.77.0 → grimoire_kit-3.78.1}/src/grimoire/cli/cmd_providers.py

@@ -16,6 +16,7 @@ départ que ``grimoire task dispatch`` en tire.
 from __future__ import annotations
 
 import json
+from dataclasses import asdict
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Annotated, Any
@@ -25,8 +26,19 @@ from rich.console import Console
 from rich.table import Table
 
 from grimoire.providers.audit import audit_providers
-from grimoire.providers.registry import SUPPORTED_MODEL_TIERS, ProviderRegistryError, ProviderSpec, read_registry
+from grimoire.providers.registry import (
+    SUPPORTED_CURRENCIES,
+    SUPPORTED_MODEL_TIERS,
+    ModelSpec,
+    ProviderRegistryError,
+    ProviderSpec,
+    add_provider,
+    read_registry,
+    remove_provider,
+    set_provider_enabled,
+)
 from grimoire.providers.routing import choose
+from grimoire.providers.secrets import list_secrets, remove_secret, set_secret
 from grimoire.providers.state import ProviderRuntimeState, clear_unknown_suspensions, load_state, record_failure
 
 providers_app = typer.Typer(
@@ -392,3 +404,139 @@ def providers_history(
     console.print(table)
     for history in histories:
         console.print(f"[dim]{history.task_type}/{history.verifiability} : {history.reason}[/dim]")
+
+
+def _parse_model_specs(raw: list[str]) -> tuple[ModelSpec, ...]:
+    """``id:tier`` → :class:`ModelSpec` ; ``typer.Exit`` sur une entrée mal formée."""
+    specs: list[ModelSpec] = []
+    for item in raw:
+        model_id, _, tier = item.partition(":")
+        if not model_id or not tier:
+            console.print(f"[red]modèle invalide {item!r} — attendu id:tier (ex: deepseek-chat:cheap).[/red]")
+            raise typer.Exit(2)
+        if tier not in SUPPORTED_MODEL_TIERS:
+            console.print(f"[red]tier {tier!r} invalide — l'un de {SUPPORTED_MODEL_TIERS}.[/red]")
+            raise typer.Exit(2)
+        specs.append(ModelSpec(id=model_id, tier=tier))
+    return tuple(specs)
+
+
+@providers_app.command("add")
+def providers_add(
+    provider_id: Annotated[str, typer.Argument(help="Identifiant du fournisseur (ex: deepseek, mistral, kimi).")],
+    invocation: Annotated[str, typer.Option("--invocation", help="Commande gabarit avec {model} et {prompt}.")],
+    model: Annotated[
+        list[str], typer.Option("--model", help="Modèle déclaré, format id:tier (ex: deepseek-chat:cheap). Répétable.")
+    ] = [],  # noqa: B006 — Typer a besoin d'un défaut mutable littéral pour un Option répétable
+    currency: Annotated[str, typer.Option("--currency", help=f"L'une de {SUPPORTED_CURRENCIES}.")] = "api",
+    enabled: Annotated[bool, typer.Option("--enabled/--disabled", help="Activer tout de suite.")] = True,
+    project_root: Annotated[Path, _PROJECT_ROOT_OPTION] = Path(),
+) -> None:
+    """Déclarer un nouveau fournisseur LLM — jamais de clé ici (voir `set-key`)."""
+    root = project_root.resolve()
+    models = _parse_model_specs(model)
+    try:
+        add_provider(root, provider_id, invocation=invocation, models=models, currency=currency, enabled=enabled)
+    except ProviderRegistryError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from exc
+    console.print(f"[green]✓[/green] fournisseur {provider_id!r} ajouté ({'activé' if enabled else 'désactivé'}).")
+    if currency == "api":
+        console.print(f"  Pose la clé : [bold]grimoire providers set-key {provider_id} <NOM_VARIABLE>[/bold]")
+
+
+@providers_app.command("enable")
+def providers_enable(
+    provider_id: Annotated[str, typer.Argument(help="Identifiant du fournisseur.")],
+    project_root: Annotated[Path, _PROJECT_ROOT_OPTION] = Path(),
+) -> None:
+    """Activer un fournisseur déjà déclaré."""
+    root = project_root.resolve()
+    try:
+        set_provider_enabled(root, provider_id, enabled=True)
+    except ProviderRegistryError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from exc
+    console.print(f"[green]✓[/green] {provider_id!r} activé.")
+
+
+@providers_app.command("disable")
+def providers_disable(
+    provider_id: Annotated[str, typer.Argument(help="Identifiant du fournisseur.")],
+    project_root: Annotated[Path, _PROJECT_ROOT_OPTION] = Path(),
+) -> None:
+    """Désactiver un fournisseur déjà déclaré."""
+    root = project_root.resolve()
+    try:
+        set_provider_enabled(root, provider_id, enabled=False)
+    except ProviderRegistryError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from exc
+    console.print(f"[yellow]●[/yellow] {provider_id!r} désactivé.")
+
+
+@providers_app.command("remove")
+def providers_remove(
+    provider_id: Annotated[str, typer.Argument(help="Identifiant du fournisseur.")],
+    project_root: Annotated[Path, _PROJECT_ROOT_OPTION] = Path(),
+) -> None:
+    """Retirer un fournisseur du registre (le magasin de clés n'est pas touché)."""
+    root = project_root.resolve()
+    try:
+        remove_provider(root, provider_id)
+    except ProviderRegistryError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from exc
+    console.print(f"[yellow]●[/yellow] {provider_id!r} retiré du registre.")
+
+
+@providers_app.command("set-key")
+def providers_set_key(
+    provider_id: Annotated[str, typer.Argument(help="Identifiant du fournisseur.")],
+    env_var: Annotated[str, typer.Argument(help="Nom de la variable d'environnement (ex: DEEPSEEK_API_KEY).")],
+) -> None:
+    """Poser une clé API en saisie masquée — jamais en argument, jamais dans le registre.
+
+    Écrit dans ``~/.env-store/`` (``grimoire.providers.secrets``), lu
+    automatiquement par `grimoire task dispatch` au moment d'invoquer ce
+    fournisseur.
+    """
+    import getpass
+
+    value = getpass.getpass(f"Valeur pour {env_var} ({provider_id}) — saisie masquée : ")
+    try:
+        path = set_secret(provider_id, env_var, value)
+    except ValueError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from exc
+    console.print(f"[green]✓[/green] {env_var} enregistré pour {provider_id!r} ({path}, chmod 600).")
+
+
+@providers_app.command("remove-key")
+def providers_remove_key(
+    provider_id: Annotated[str, typer.Argument(help="Identifiant du fournisseur.")],
+    env_var: Annotated[
+        str | None, typer.Argument(help="Variable à retirer ; toutes les clés du fournisseur si omis.")
+    ] = None,
+) -> None:
+    """Retirer une clé (ou toutes celles d'un fournisseur) du magasin de secrets."""
+    remove_secret(provider_id, env_var)
+    console.print(f"[yellow]●[/yellow] retiré : {provider_id!r}" + (f" / {env_var}" if env_var else " (toutes les clés)"))
+
+
+@providers_app.command("secrets")
+def providers_secrets_list(ctx: typer.Context, json_output: Annotated[bool, _JSON_OPTION] = False) -> None:
+    """Lister les clés posées (fournisseur, variable, date) — jamais les valeurs."""
+    entries = list_secrets()
+    if json_output or _get_fmt(ctx) == "json":
+        typer.echo(json.dumps([asdict(entry) for entry in entries], indent=2, ensure_ascii=False))
+        return
+    if not entries:
+        console.print("[dim]Aucune clé posée (`grimoire providers set-key`).[/dim]")
+        return
+    table = Table(title="Clés posées")
+    for column in ("Fournisseur", "Variable", "Fichier", "Posée le"):
+        table.add_column(column)
+    for entry in entries:
+        table.add_row(entry.provider, entry.env_var, entry.file, entry.added_at)
+    console.print(table)

{grimoire_kit-3.77.0 → grimoire_kit-3.78.1}/src/grimoire/missions/dispatch.py

@@ -80,6 +80,7 @@ from grimoire.core.standard_generation import STANDARD_DIR
 from grimoire.costs import POLICY_STOP, Cost, cap_reason, validate_policy
 from grimoire.missions.diff_fingerprint import signal_if_stuck
 from grimoire.missions.dispatch_history import recommend_start_tier
+from grimoire.missions.dispatch_worktree import changed_since, worktree_fingerprint
 from grimoire.missions.empty_green import classify_empty_green, invokes_test_runner
 from grimoire.missions.route_dispatch import record_route
 from grimoire.missions.schemas import TaskState
@@ -87,6 +88,7 @@ from grimoire.missions.verifiability import Verifiability, classify
 from grimoire.providers.quota import QuotaSignal, classify_failure, observe_window
 from grimoire.providers.registry import SUPPORTED_MODEL_TIERS, ProviderSpec
 from grimoire.providers.routing import candidates as provider_candidates
+from grimoire.providers.secrets import env_for_provider
 from grimoire.providers.state import (
     available_models,
     load_state,
@@ -97,6 +99,8 @@ from grimoire.providers.state import (
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from grimoire.missions.schemas import LedgerEvent, MissionTask
     from grimoire.missions.service import TaskService
 
@@ -494,24 +498,18 @@ def _matches_review_surface(path: str, surfaces: tuple[str, ...]) -> bool:
     return any(fnmatch.fnmatchcase(path, pattern) for pattern in surfaces)
 
 
-def _classify_review(project_root: Path) -> tuple[str, tuple[str, ...], str | None]:
-    """Classe le diff courant — ``(review, review_files, review_note)`` (issue #327).
+def _classify_review(
+    project_root: Path, before: Mapping[str, str] | None = None
+) -> tuple[str, tuple[str, ...], str | None]:
+    """Classe ce qui a changé depuis ``before`` — ``(review, review_files, review_note)`` (issue #327).
 
-    ``git diff --name-only`` plutôt qu'une lecture du working tree : c'est
-    exactement ce que le prochain relecteur verra. Un projet non versionné ne
-    permet pas de calculer quoi que ce soit ; le déclarer ``review_required``
-    par défaut inventerait une garantie qu'on ne peut pas tenir, donc
-    ``review_optional`` avec une note plutôt qu'un silence trompeur.
+    Un projet non versionné ne permet pas de calculer quoi que ce soit ; le
+    déclarer ``review_required`` par défaut inventerait une garantie qu'on ne
+    peut pas tenir, donc ``review_optional`` avec une note plutôt qu'un silence.
     """
-    try:
-        completed = subprocess.run(
-            ["git", "diff", "--name-only"], cwd=project_root, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=CHECK_TIMEOUT_S
-        )
-    except (OSError, subprocess.TimeoutExpired):
-        return "review_optional", (), "projet non versionné (git indisponible) : relisibilité non calculée"
-    if completed.returncode != 0:
-        return "review_optional", (), "projet non versionné (pas un dépôt git) : relisibilité non calculée"
-    files = tuple(line.strip() for line in completed.stdout.splitlines() if line.strip())
+    files = changed_since(project_root, before or {})
+    if files is None:
+        return "review_optional", (), "projet non versionné (git illisible) : relisibilité non calculée"
     surfaces = _review_surfaces(project_root)
     if _use_rust_backend():
         assert _rust_core is not None  # guarded by _use_rust_backend
@@ -850,9 +848,14 @@ def _run_provider_call(
     """
     argv = render_invocation(provider.invocation or "", prompt=prompt, model=model)
     started = time.monotonic()
+    # Issue #310 suite : la clé d'un fournisseur `currency: api` vient du magasin de
+    # secrets (grimoire.providers.secrets, `~/.env-store/`), jamais du registre ni d'un
+    # argument — fusionnée ici pour que le script d'invocation n'ait rien à en savoir.
+    env = {**os.environ, **env_for_provider(provider.id)}
     try:
         completed = subprocess.run(
-            argv, cwd=project_root, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=call_timeout, shell=False
+            argv, cwd=project_root, capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=call_timeout, shell=False, env=env,
         )
     except subprocess.TimeoutExpired:
         return None, "", "", time.monotonic() - started, "timeout", None
@@ -1271,6 +1274,7 @@ def run_dispatch(
         )
         return service.ledger.append_event("task.dispatched", task_id, "task", actor, payload)
 
+    tree_before = worktree_fingerprint(root)
     attempt_no = 0
     previous_red_diff: str | None = None
     capped_before_next_tier = False
@@ -1335,7 +1339,7 @@ def run_dispatch(
             green = verdict == "green"
             # La relecture ne se pose qu'une fois le résultat accepté (#327) —
             # un check rouge n'a rien produit qu'on ait besoin de relire.
-            review, review_files, review_note = _classify_review(root) if green else (None, (), None)
+            review, review_files, review_note = _classify_review(root, tree_before) if green else (None, (), None)
             # L'incertitude déclarée, elle, vaut pour tout appel qui a répondu,
             # vert ou rouge (#328) : l'ouvrier peut avoir douté d'un travail
             # que le check juge encore insuffisant.

grimoire_kit-3.78.1/src/grimoire/missions/dispatch_worktree.py

@@ -0,0 +1,58 @@
+"""Ce qu'un dispatch a réellement changé dans l'arbre de travail.
+
+``git diff`` seul juge l'arbre entier : il impute à l'ouvrier tout ce qui était
+déjà modifié avant lui et ne voit pas les fichiers qu'il crée. On photographie
+donc l'état des fichiers modifiés ou nouveaux avant la cascade, et on compare.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from collections.abc import Mapping
+from pathlib import Path
+
+_GIT_TIMEOUT_S = 60.0
+_LISTINGS = (
+    ("diff", "--name-only", "--relative", "-z"),
+    ("diff", "--cached", "--name-only", "--relative", "-z"),
+    ("ls-files", "--others", "--exclude-standard", "-z"),
+)
+
+
+def _state(path: Path) -> str:
+    """Taille et date plutôt qu'un hash : l'arbre peut porter de très gros fichiers non suivis."""
+    try:
+        stat = path.lstat()
+    except OSError:
+        return "absent"
+    return f"{stat.st_size}:{stat.st_mtime_ns}"
+
+
+def worktree_fingerprint(root: Path) -> dict[str, str] | None:
+    """État des fichiers modifiés ou nouveaux, ``None`` hors d'un dépôt git lisible."""
+    paths: set[str] = set()
+    for listing in _LISTINGS:
+        try:
+            completed = subprocess.run(
+                ["git", *listing],
+                cwd=root,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="surrogateescape",
+                timeout=_GIT_TIMEOUT_S,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            return None
+        if completed.returncode != 0:
+            return None
+        paths.update(name for name in completed.stdout.split("\0") if name)
+    return {name: _state(root / name) for name in paths}
+
+
+def changed_since(root: Path, before: Mapping[str, str]) -> tuple[str, ...] | None:
+    """Chemins dont l'état diffère de ``before``, retours à l'état propre compris."""
+    after = worktree_fingerprint(root)
+    if after is None:
+        return None
+    return tuple(sorted(name for name in before.keys() | after.keys() if before.get(name) != after.get(name)))

{grimoire_kit-3.77.0 → grimoire_kit-3.78.1}/src/grimoire/providers/registry.py

@@ -158,6 +158,137 @@ def read_registry(root: Path) -> tuple[ProviderSpec, ...]:
     return tuple(spec for spec in specs if spec is not None)
 
 
+class ProviderWriteError(ProviderRegistryError):
+    """Une écriture sur le registre a été refusée (id dupliqué, vocabulaire invalide...)."""
+
+
+def _yaml_roundtrip() -> YAML:
+    """Round-trip (``typ="rt"``) : préserve commentaires et mise en forme du fichier existant.
+
+    Distinct de :func:`_yaml` (``typ="safe"``) — un lecteur n'a pas besoin de
+    préserver la forme, une écriture ne doit jamais effacer les commentaires
+    qui documentent le reste du registre.
+    """
+    yaml = YAML(typ="rt")
+    yaml.preserve_quotes = True
+    return yaml
+
+
+def _load_registry_for_write(root: Path) -> Any:
+    """Document round-trip ; lève si le registre n'existe pas encore.
+
+    Contrairement à :func:`_load_registry_mapping` (lecture, ``{}`` toléré),
+    une écriture sur un registre absent n'a pas de sens : il n'y a pas de
+    ``routing``/``metadata`` à préserver, et en créer un à la volée devinerait
+    une politique que seul ``grimoire standard init`` doit poser.
+    """
+    path = root / REGISTRY_FILE
+    if not path.is_file():
+        msg = f"{REGISTRY_FILE} absent — lancer `grimoire standard init` avant d'ajouter un fournisseur."
+        raise ProviderRegistryError(msg)
+    try:
+        data = _yaml_roundtrip().load(path.read_text(encoding="utf-8"))
+    except (YAMLError, OSError, UnicodeDecodeError) as exc:
+        msg = f"{REGISTRY_FILE} illisible : {type(exc).__name__}: {exc}"
+        raise ProviderRegistryError(msg) from exc
+    if not isinstance(data, dict):
+        msg = f"{REGISTRY_FILE} doit être une table YAML."
+        raise ProviderRegistryError(msg)
+    return data
+
+
+def _save_registry(root: Path, data: Any) -> None:
+    path = root / REGISTRY_FILE
+    with path.open("w", encoding="utf-8") as handle:
+        _yaml_roundtrip().dump(data, handle)
+
+
+def add_provider(
+    root: Path,
+    provider_id: str,
+    *,
+    invocation: str,
+    models: tuple[ModelSpec, ...] = (),
+    currency: str = "api",
+    provider_type: str = "hosted",
+    allowed_capabilities: tuple[str, ...] = ("chat", "code"),
+    enabled: bool = True,
+) -> None:
+    """Déclare un nouveau fournisseur — jamais de clé ici, voir ``grimoire.providers.secrets``.
+
+    Refuse un ``id`` déjà présent (utiliser :func:`set_provider_enabled` pour
+    une bascule), un ``currency``/``tier`` hors vocabulaire, ou une
+    ``invocation`` sans ``{prompt}`` — les mêmes règles que
+    ``standard_checks.verifiers._verify_provider_currency_and_tiers``,
+    vérifiées ici pour ne jamais écrire une entrée qu'un
+    ``grimoire standard verify`` rejetterait ensuite.
+    """
+    if currency not in SUPPORTED_CURRENCIES:
+        msg = f"currency {currency!r} doit être l'une de {SUPPORTED_CURRENCIES}."
+        raise ProviderWriteError(msg)
+    for model in models:
+        if model.tier not in SUPPORTED_MODEL_TIERS:
+            msg = f"tier {model.tier!r} (modèle {model.id!r}) doit être l'un de {SUPPORTED_MODEL_TIERS}."
+            raise ProviderWriteError(msg)
+    if "{prompt}" not in invocation:
+        msg = f"invocation {invocation!r} sans placeholder {{prompt}} : le prompt n'atteindrait jamais la commande."
+        raise ProviderWriteError(msg)
+
+    data = _load_registry_for_write(root)
+    providers = data.setdefault("providers", [])
+    if any(isinstance(entry, dict) and entry.get("id") == provider_id for entry in providers):
+        msg = f"fournisseur {provider_id!r} déjà déclaré — utiliser `grimoire providers enable/disable`."
+        raise ProviderWriteError(msg)
+
+    providers.append(
+        {
+            "id": provider_id,
+            "enabled": enabled,
+            "provider_type": provider_type,
+            "allowed_capabilities": list(allowed_capabilities),
+            "default_models": [model.id for model in models],
+            "currency": currency,
+            "invocation": invocation,
+            "models": [{"id": model.id, "tier": model.tier} for model in models],
+            "data_policy": {
+                "allowed_data_classes": ["public-docs", "project-source", "generated-artifacts", "non-secret-metadata"],
+                "forbidden_data_classes": ["secrets", "credentials", "personal-data", "regulated-data"],
+                "retention_notes": (
+                    "Ajouté via `grimoire providers add` — clé lue depuis le magasin de secrets "
+                    "(grimoire.providers.secrets), jamais dans ce registre."
+                ),
+            },
+            "fallback_order": [],
+            "audit": {"log_prompts": False, "log_metadata": True},
+        }
+    )
+    _save_registry(root, data)
+
+
+def set_provider_enabled(root: Path, provider_id: str, enabled: bool) -> None:
+    """Bascule ``enabled`` pour *provider_id* ; lève si l'id n'est pas déclaré."""
+    data = _load_registry_for_write(root)
+    for entry in data.get("providers") or []:
+        if isinstance(entry, dict) and entry.get("id") == provider_id:
+            entry["enabled"] = enabled
+            _save_registry(root, data)
+            return
+    msg = f"fournisseur {provider_id!r} introuvable dans le registre."
+    raise ProviderWriteError(msg)
+
+
+def remove_provider(root: Path, provider_id: str) -> None:
+    """Retire *provider_id* du registre — le magasin de secrets n'est pas touché."""
+    data = _load_registry_for_write(root)
+    providers = data.get("providers") or []
+    kept = [entry for entry in providers if not (isinstance(entry, dict) and entry.get("id") == provider_id)]
+    if len(kept) == len(providers):
+        msg = f"fournisseur {provider_id!r} introuvable dans le registre."
+        raise ProviderWriteError(msg)
+    data["providers"] = kept
+    _save_registry(root, data)
+
+
 def read_default_fallback_chain(root: Path) -> tuple[str, ...]:
     """``routing.default_fallback_chain`` — le filet posé au niveau registre.
 

grimoire_kit-3.78.1/src/grimoire/providers/secrets.py

@@ -0,0 +1,148 @@
+"""Magasin léger de jetons API : ``~/.env-store/`` + un index (issue #310, suite).
+
+Les clés ne vivent jamais dans ``llm-provider-registry.yaml`` lui-même — sa
+``data_policy.forbidden_data_classes`` interdit déjà ``secrets``/``credentials``
+dans ce qui *transite par* un fournisseur ; ce module applique la même règle
+à ce qui *décrit* un fournisseur. Une valeur se pose en saisie masquée
+(``grimoire providers set-key``, ``getpass``), jamais en argument de ligne de
+commande ni en log — c'est le seul chemin d'écriture exposé par la CLI.
+
+Format du magasin :
+  ``~/.env-store/index.json``     — ``{"entries": [{"provider", "env_var", "file", "added_at"}]}``
+  ``~/.env-store/<provider>.env`` — lignes ``VAR=valeur``, une par variable, ``chmod 600``
+
+``env_for_provider`` est lu par ``missions.dispatch._run_provider_call`` pour
+fusionner ces variables dans l'environnement du sous-processus avant
+d'invoquer le fournisseur — un script d'invocation (``deepseek-cli.py`` et
+analogues) n'a besoin de rien connaître du magasin, il reçoit déjà la
+variable dans son ``os.environ``.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+
+
+def store_dir() -> Path:
+    """``~/.env-store`` — jamais dans le dépôt du projet, jamais versionné."""
+    return Path.home() / ".env-store"
+
+
+def _index_file() -> Path:
+    return store_dir() / "index.json"
+
+
+def _provider_file(provider_id: str) -> Path:
+    return store_dir() / f"{provider_id}.env"
+
+
+@dataclass(frozen=True, slots=True)
+class SecretEntry:
+    """Une ligne de l'index — jamais la valeur, seulement sa provenance."""
+
+    provider: str
+    env_var: str
+    file: str
+    added_at: str
+
+
+def _ensure_store() -> None:
+    store_dir().mkdir(parents=True, exist_ok=True)
+    store_dir().chmod(0o700)
+
+
+def _read_env_file(path: Path) -> dict[str, str]:
+    if not path.is_file():
+        return {}
+    values: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, _, value = stripped.partition("=")
+        values[key.strip()] = value.strip()
+    return values
+
+
+def _write_env_file(path: Path, values: dict[str, str]) -> None:
+    body = "\n".join(f"{k}={v}" for k, v in values.items())
+    path.write_text(f"{body}\n" if values else "", encoding="utf-8")
+    path.chmod(0o600)
+
+
+def _load_index() -> dict[str, list[dict[str, str]]]:
+    path = _index_file()
+    if not path.is_file():
+        return {"entries": []}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {"entries": []}
+    return data if isinstance(data, dict) else {"entries": []}
+
+
+def _save_index(data: dict[str, list[dict[str, str]]]) -> None:
+    path = _index_file()
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    path.chmod(0o600)
+
+
+def set_secret(provider_id: str, env_var: str, value: str) -> Path:
+    """Pose *value* pour *env_var* du fournisseur *provider_id* ; rend le fichier écrit.
+
+    Lève ``ValueError`` sur une valeur vide — un magasin qui accepterait une
+    clé vide masquerait l'absence réelle de configuration.
+    """
+    if not value.strip():
+        msg = "valeur vide refusée."
+        raise ValueError(msg)
+    _ensure_store()
+    path = _provider_file(provider_id)
+    values = _read_env_file(path)
+    values[env_var] = value.strip()
+    _write_env_file(path, values)
+
+    index = _load_index()
+    entries = [e for e in index["entries"] if not (e["provider"] == provider_id and e["env_var"] == env_var)]
+    entries.append(
+        {"provider": provider_id, "env_var": env_var, "file": path.name, "added_at": datetime.now(UTC).isoformat()}
+    )
+    index["entries"] = entries
+    _save_index(index)
+    return path
+
+
+def list_secrets() -> tuple[SecretEntry, ...]:
+    """Entrées déclarées (fournisseur, variable, fichier, date) — jamais les valeurs."""
+    index = _load_index()
+    return tuple(
+        SecretEntry(provider=e["provider"], env_var=e["env_var"], file=e["file"], added_at=e.get("added_at", ""))
+        for e in index.get("entries", [])
+        if isinstance(e, dict) and e.get("provider") and e.get("env_var")
+    )
+
+
+def remove_secret(provider_id: str, env_var: str | None = None) -> None:
+    """Retire une variable, ou tout le fichier de *provider_id* si *env_var* est ``None``."""
+    path = _provider_file(provider_id)
+    values = _read_env_file(path)
+    if env_var is None:
+        path.unlink(missing_ok=True)
+    elif env_var in values:
+        del values[env_var]
+        _write_env_file(path, values)
+    index = _load_index()
+    index["entries"] = [
+        e
+        for e in index["entries"]
+        if not (e["provider"] == provider_id and (env_var is None or e["env_var"] == env_var))
+    ]
+    _save_index(index)
+
+
+def env_for_provider(provider_id: str) -> dict[str, str]:
+    """Variables déjà posées pour *provider_id* — ``{}`` si rien n'est enregistré."""
+    return _read_env_file(_provider_file(provider_id))