grimoire-kit 3.44.0__tar.gz → 3.44.2__tar.gz

{grimoire_kit-3.44.0 → grimoire_kit-3.44.2}/CHANGELOG.md

@@ -7,6 +7,196 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
 ## [Unreleased]
 
+## [3.44.2] - 2026-09-11
+
+- **fix(hosts): `collect_agents` résout ses propres skills quand `known_skills` n'est pas fourni — `SessionStart` et le porteur de proposition ne plantent plus sur un agent à skills attachés (#423).**
+  `entry_persona_context` et `_category_carrier` (déclencheur de propositions)
+  appelaient `collect_agents(project_root)` sans lui passer l'inventaire des
+  skills du projet ; le défaut retombait alors sur un ensemble vide, donc
+  *tout* agent déclarant un `skills:` en frontmatter — la forme par défaut
+  des archétypes depuis #377/#387 — échouait fail-closed comme si ses
+  skills n'existaient pas. `collect_agents(project_root, *, known_skills=None, …)`
+  résout maintenant lui-même l'inventaire via `collect_skills(project_root)`
+  quand `known_skills` vaut `None`, pour qu'aucun appelant ne puisse
+  retomber dans ce trou ; un inventaire explicite reste accepté pour les
+  appelants qui en réutilisent un déjà collecté (`build_surface`, etc.).
+
+- **perf(hosts): cache JSON de l'état du standard, invalidé par empreinte — `grimoire-hook` évite `ruamel.yaml` sur cache chaud (#419).**
+  Suite du découpage de `hosts/decisions.py` (#420) : le profil résiduel
+  identifiait `grimoire.core.standard_state` (`active_task_id`/`active_profile_id`)
+  + `ruamel.yaml` comme le seul poste encore compressible, ~9 ms sur
+  `PreToolUse` destructif. Deux changements distincts s'additionnent :
+  l'import de `ruamel.yaml` dans `standard_state.py` était au niveau module
+  (payé par *tout* appel de hook, même sur un projet non enrôlé, sans
+  standard-profile.yaml ni task-board.yaml à lire) — il est maintenant local
+  à `_load_mapping`, donc jamais payé quand ces fichiers n'existent pas. Sur
+  un projet enrôlé, où ils existent, un cache JSON (stdlib `json`, jamais
+  `ruamel`) sous `_grimoire-output/.runs/standard-state-cache.json` — même
+  emplacement que l'état de session éphémère existant, gitignoré — mémorise
+  `profile_id` et les tâches `in_progress` du board, invalidé par empreinte
+  fichier (`[mtime_ns, size]`) : une source modifiée est relue et le cache
+  regénéré ; un cache absent, tronqué ou au mauvais format retombe
+  silencieusement sur la lecture YAML, jamais une erreur de hook. Écriture
+  atomique (fichier temporaire + `os.replace`). Un outil MCP annoté
+  `readOnlyHint` (`grimoire_host_status`, `task_recall`) ne doit rien écrire :
+  `active_profile_id`/`resolve_active_task`/`active_task_id` et
+  `hosts.collect.build_surface` acceptent un `write_cache: bool = True` que
+  ces deux tools seuls mettent à `False` — ils lisent un cache déjà chaud
+  sans jamais le créer ni le corriger. Le cache est aussi invalidé
+  (supprimé, best-effort) juste après une écriture connue de ces YAML —
+  `setup_standard_profile`, `TaskService.project_board`, `grimoire task
+  board export` — pour que le changement soit visible dès l'appel de hook
+  suivant plutôt que celui d'après ; pas requis pour la correction, l'empreinte
+  périmée suffit, seulement pour la latence d'un cas rare.
+
+  Mesuré par `scripts/bench-rust-cores.py --macro-runs 15` (même machine,
+  projet de bench isolé non enrôlé — c'est le seul fixture du script, donc la
+  seule chose qu'il mesure ici est l'import `ruamel` devenu conditionnel) :
+
+  | commande | avant | après | cible | statut |
+  |---|---|---|---|---|
+  | `grimoire-hook PreToolUse` (tool-policy, destructif — mesure officielle #418/#419) | 62,7 ms | 55,1 ms | < 50 ms | **non atteinte** |
+
+  Le cache lui-même n'a rien à faire sur un projet non enrôlé (aucun YAML à
+  mettre en cache) : mesuré séparément sur un projet **enrôlé** (`standard
+  init --profile governed`, `_grimoire/standard/standard-profile.yaml` +
+  `task-board.yaml` réels), même méthodologie (médiane de 15 exécutions) :
+
+  | événement (décision) | avant | après |
+  |---|---|---|
+  | `PreToolUse` (tool-policy) | 75,7 ms | 54,2 ms |
+  | `SessionStart` (activation) | 73,1 ms | 70,3 ms |
+  | `UserPromptSubmit` (task-context) | 58,9 ms | 39,6 ms |
+  | `PostToolUse` (evidence-trace) | 57,0 ms | 49,0 ms |
+  | `SubagentStop` (subagent-gate) | 131,7 ms | 127,9 ms |
+  | `PreCompact` (context-capsule) | 132,1 ms | 121,2 ms |
+  | `Stop` (evidence-gate) | 144,4 ms | 127,9 ms |
+
+  (Les trois derniers événements sont plus lents dans l'absolu sur un projet
+  `governed` : `evidence-gate`/`context-capsule`/`subagent-gate` y exercent de
+  vraies vérifications de gate, hors périmètre de ce cache.) `cProfile` sur
+  cache chaud (`PreToolUse`, projet enrôlé) : ni `ruamel` ni
+  `grimoire.core.standard_state._load_mapping` n'apparaissent plus dans le
+  profil — confirmé aussi par un `sys.modules` vide de tout module `ruamel.*`
+  en sous-processus frais. **Cible des 50 ms toujours non atteinte sur la
+  mesure officielle (projet non enrôlé)**, assumé : il ne reste, sur ce
+  chemin, que le coût `dataclasses`/`inspect` de la première dataclass
+  chargée dans le process (stdlib, ~6-9 ms, inhérent à `@dataclass` sur
+  `HookInput`/`Decision`/`ToolFacts`/`ActiveTask` — `dataclasses.py` importe
+  `inspect` sans condition, aucune combinaison de `frozen`/`slots` n'y
+  change quoi que ce soit) et le moteur de politique lui-même
+  (`policies.engine`/`policies.schemas`, ~5 ms, propre à `tool-policy`,
+  aucun fichier lu). Les deux sont documentés comme incompressibles avec ce
+  mécanisme par #419 lui-même ; ni l'un ni l'autre n'a de solution triviale
+  sans réécrire ces classes à la main.
+  Tests : `tests/unit/core/test_standard_state.py` (cache créé/lu/régénéré
+  sur source modifiée/corrompu/absent, `invalidate_cache`) ; garde de
+  non-régression `tests/unit/test_hook_cost.py::test_a_warm_standard_state_cache_never_imports_ruamel`
+  (sous-processus froid puis chaud, `sys.modules` sans aucun `ruamel.*` au
+  second) ; `tests/unit/mcp/test_server.py::TestReadOnlyToolsWriteNothing`
+  (déjà existant, aucune modification requise) couvre le contrat
+  `write_cache=False`. Aucun changement de décision : les tests existants de
+  `hosts/decisions.py` et `test_hosts.py` passent sans modification.
+
+## [3.44.1] - 2026-09-11
+
+- **perf(hosts): découper `hosts/decisions.py` par décision — `grimoire-hook` payait la moitié du fichier pour chaque appel (#419).**
+  Suite de mesure de #418 : `grimoire-hook PreToolUse` restait à 69-70 ms
+  malgré le chargement paresseux du CLI, parce que ce point d'entrée
+  (`grimoire.hosts.runtime:main`) ne passe jamais par `grimoire.cli.app`.
+  `grimoire.hosts.decisions` était un seul module de 918 lignes portant les
+  sept décisions (`grimoire.activation`, `.task-context`, `.tool-policy`,
+  `.evidence-trace`, `.evidence-gate`, `.subagent-gate`, `.context-capsule`) :
+  quelle que soit la décision demandée, tout le fichier — et donc le moteur
+  de politique (`grimoire.policies.engine`/`.schemas`) — était importé. C'est
+  devenu un paquet, un module par décision, résolu paresseusement par
+  `grimoire.hosts.decisions.run_decision` via un registre id → module ;
+  `__init__.py` ré-exporte tous les noms publics existants (et le privé
+  `_gate_summary` qu'un test pinne) par `__getattr__` de module, donc aucun
+  import existant ne change. `grimoire.hosts.surface` (446 lignes : IR
+  agent/modèle, fingerprinting, sonde du cœur Rust) est passé par le même
+  chemin : les trois enums que le hook lit sur *chaque* appel (`HookEvent`,
+  `ToolVerb`, `Enforcement`) vivent maintenant dans `grimoire.hosts.events`
+  (nouveau, réexporté par `surface.py` pour compatibilité) — et
+  `grimoire/hosts/__init__.py`, qui importait `ProjectSurface` (donc tout
+  `surface.py`) au niveau module rien que pour une ré-export dont rien dans
+  le dépôt ne se sert (`from grimoire.hosts import ProjectSurface`), le fait
+  maintenant paresseusement lui aussi.
+  Mesuré par `scripts/bench-rust-cores.py --macro-runs 15` (même machine) :
+
+  | commande | avant | après | cible | statut |
+  |---|---|---|---|---|
+  | `grimoire-hook PreToolUse` (tool-policy, destructif) | 70 ms | 64 ms | < 50 ms | **non atteinte** |
+  | `grimoire-hook PreToolUse` (lecture seule) | 69 ms | 58 ms | — | — |
+  | `grimoire-hook SessionStart` | 77 ms | 72 ms | — | — |
+  | `grimoire-hook UserPromptSubmit` | 63 ms | 49 ms | — | atteinte |
+  | `grimoire-hook PostToolUse` | 64 ms | 57 ms | — | — |
+  | `grimoire-hook SubagentStop` | 64 ms | 50 ms | — | — |
+  | `grimoire-hook PreCompact` | 65 ms | 50 ms | — | — |
+  | `grimoire-hook Stop` | 69 ms | 56 ms | — | — |
+
+  **Cible des 50 ms non atteinte pour `PreToolUse`, assumé.** Le profil
+  restant après découpage tient en trois postes incompressibles avec ce
+  mécanisme : le coût `dataclasses`/`inspect` de la première dataclass
+  chargée dans le process (stdlib, ~6-9 ms), `grimoire.core.standard_state`
+  + `ruamel.yaml` (~9 ms — nécessaire : même une commande destructive lit
+  `active_task_id`/`active_profile_id` avant que le moteur de politique ne
+  tranche, sur tous les événements sauf aucun), et le moteur de politique
+  lui-même (`policies.engine`/`policies.schemas`, ~5 ms, propre à
+  `tool-policy`). Découper `decisions.py` plus finement ne change rien à ces
+  trois postes ; les réduire est un chantier distinct (bascule de parseur
+  YAML pour le premier, hors périmètre — `ruamel.yaml` est la seule
+  dépendance YAML déclarée du kit, `pyyaml` n'est que transitive).
+  Garde de régression : `tests/unit/test_hook_cost.py` — un sous-processus
+  propre par décision vérifie qu'exécuter une décision n'importe jamais le
+  module d'une décision sœur (`test_running_one_decision_imports_only_its_own_submodule`,
+  paramétré sur les sept), plus un budget de temps large et portable dans le
+  même esprit que `_COCKPIT_REFRESH_BUDGET_SECONDS`
+  (`tests/test_invariants.py`).
+
+- **perf(cli): charger les sous-commandes à la demande — 60 % du temps de `doctor` était l'arbre Typer (#405).**
+  `grimoire.cli.app` importait sans condition les 20 modules `cmd_*` derrière
+  chaque sous-commande (`cmd_flow`, `cmd_host`, `cmd_memory_lexical`,
+  `cmd_cockpit`, `cmd_up`...) pour construire l'arbre Typer/Click, quelle que
+  soit la commande demandée — `grimoire --version` payait donc l'import de
+  `grimoire.flows`, `grimoire.missions.dispatch`, `grimoire.memory`, etc.
+  `grimoire.cli._lazy.LazyTyperGroup` (nouveau, `cls=` du `typer.Typer`
+  racine) remplace `add_typer()`/`command()` pour ces sous-commandes par un
+  registre nom → (module, attribut, aide courte, panneau, visibilité) ; le
+  module n'est importé qu'à la résolution réelle de la commande (dispatch, ou
+  son propre `--help`) — `grimoire --version` et `grimoire doctor .` ne
+  touchent plus aucun d'entre eux. `grimoire.cli.cmd_up` importait en outre
+  `cmd_init`/`core.scaffold`/`hosts.sync` à son propre niveau module rien que
+  pour les fonctions que `doctor` utilise réellement (`run_env_checks`) —
+  ces imports descendent maintenant dans les fonctions qui les utilisent
+  vraiment (`up()`, `_step_init`, `repair_project_artifacts`).
+  `grimoire --help` et l'aide de chaque sous-commande restent identiques au
+  caractère près (ordre des panneaux et des lignes inclus, garanti par un
+  registre `order` explicite dans `LazyTyperGroup.configure`) —
+  `scripts/compare-cli-help.py` (nouveau) le vérifie avant/après pour les 47
+  commandes. Garde de régression : `tests/unit/cli/test_lazy_startup.py`
+  (sous-processus propre) échoue si l'import de `grimoire.cli.app` amène
+  `grimoire.flows`, `grimoire.missions.dispatch`, `grimoire.memory` ou
+  `grimoire.cli.cmd_cockpit` dans `sys.modules`.
+  Mesuré par `scripts/bench-rust-cores.py` (médiane de 15, même machine) :
+
+  | commande | avant | après | cible | statut |
+  |---|---|---|---|---|
+  | `grimoire --version` | 313 ms | 89 ms | < 150 ms | atteinte |
+  | `grimoire doctor .` | 448 ms | 270 ms | < 300 ms | atteinte |
+  | `grimoire-hook PreToolUse` | 70 ms | 69 ms | < 50 ms | **non atteinte** |
+
+  `grimoire-hook` (point d'entrée séparé, `grimoire.hosts.runtime:main`) ne
+  passe jamais par `grimoire.cli.app` et n'est donc pas concerné par ce
+  mécanisme ; son coût restant vient de `grimoire.hosts.decisions` (918
+  lignes, tous les types de décision dans un seul module) et de
+  `grimoire.hosts.capabilities`/`.surface` — hors du périmètre de ce ticket
+  (« enregistrer les sous-commandes sans importer leur module », pas refondre
+  le moteur de décision des hooks). `grimoire-mcp` (`grimoire.mcp.server`)
+  vérifié : n'importe déjà pas `grimoire.cli.app`, rien à faire.
+
+- fix(flows): un abandon (ou un refus MAST) avant tout progrès n'affiche plus tous les nodes comme complétés dans `grimoire flow status` (#414). `FlowEngine.status()` dérivait `completed_nodes`/`pending_nodes` de la seule position de `current_node` dans l'ordre topologique — sur un run ABORTED/REFUSED, `current_node` devient `None` (terminal) exactement comme un run réussi, donc l'ancien découpage rendait `completed_nodes == order` en entier même quand *aucun* node n'était réellement fait. `completed_nodes` reflète désormais les `completed_steps` du dernier checkpoint réel du `RuntimeKernel` sur un run mort (liste vide si aucun checkpoint n'existe encore, c'est-à-dire un abandon avant le premier `resume()`) ; `pending_nodes` reste vide par convention (on ne sait pas si l'hôte comptait reprendre). Corrigé des deux côtés en même temps, même verdict : `rust/grimoire-flows-core/src/lib.rs` (`status_slices_core`) miroité, `grimoire flow status` (texte et JSON) en hérite sans changement de code propre. Nouveaux tests de parité sous les deux backends (`GRIMOIRE_FLOWS_BACKEND=python|rust`) : abandon avant tout progrès, abandon après k nodes, refus avant progrès, complétion normale (inchangée) — `tests/unit/test_flows_rust_parity.py`.
+
 ## [3.44.0] - 2026-09-11
 
 - feat(dispatch): cinquième port Rust optionnel de la cascade de dispatch et du routage de fournisseurs — `start_tier_for`/`_tier_chain` (plancher et chaîne de paliers par classe de vérifiabilité), la résolution `--start-tier` explicite contre le plancher, `render_invocation` (rendu d'un gabarit en argv), `_looks_rate_limited`, `_extract_cost_usd`/`_uncertainties_search_text`/`_extract_uncertainties` (analyse de la sortie d'un ouvrier délégué), `_matches_review_surface`/`_classify_review` (classification de revue), `DispatchReport.succeeded`/`.exit_code`/`.refusal_message`, et l'ordre/filtre de refroidissement de `providers.routing.candidates` (issue #354). `rust/grimoire-dispatch-core/` (dépendance `serde_json` épinglée `=1.0.151`, strict RFC 8259), bascule `GRIMOIRE_DISPATCH_BACKEND=python|rust|auto` (lue indépendamment par `grimoire.missions.dispatch` et `grimoire.providers.routing`, qui ne s'importent pas l'un l'autre), jobs CI `rust-dispatch / cargo` et `rust-dispatch / parity` dans `.github/workflows/rust-cores.yml`, roue toujours `py3-none-any`. Deux défauts trouvés par l'oracle Rust en portant `_extract_cost_usd`, corrigés côté Python dans cette même PR : `isinstance(True, int)` est vrai en Python, donc un `total_cost_usd` JSON `true`/`false` était jusqu'ici coercé en `1.0`/`0.0` — désormais exclu explicitement des deux côtés ; `json.loads` de CPython accepte par défaut les jetons hors RFC 8259 `NaN`/`Infinity`/`-Infinity`, que le cœur Rust (`serde_json`, strict) n'accepte pas nativement — **corrigé côté Python : JSON strict** (`_reject_non_standard` passé en `parse_constant` à chaque `json.loads` de `dispatch.py`, rattrapé comme un JSON invalide), un document portant un de ces jetons — même ailleurs que dans le champ lu — est désormais rejeté en bloc des deux côtés (coût absent, aucune incertitude extraite), jamais l'inverse (Rust est l'oracle, pas Python). Nouveau corpus fixture de dix sorties d'ouvrier réalistes (`tests/fixtures/dispatch_worker_outputs/`, aucune sortie enregistrée réelle trouvée dans le dépôt) et fuzz léger (200 chaînes aléatoires) prouvant qu'aucune des deux fonctions d'analyse ne lève jamais, sous aucun backend.
@@ -14,6 +204,7 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 - feat(flows): quatrième port Rust optionnel de la machine à états du moteur de flows — `check_output_against_contract`, le calcul du node courant (`FlowEngine._current_node`), la décision de `resume()`/le calcul de `ResumeOutcome`, le découpage completed/pending de `status()`, et la table de transitions de `RuntimeKernel` (`_transition`/`advance_step`) (issue #354). `rust/grimoire-flows-core/`, bascule `GRIMOIRE_FLOWS_BACKEND=python|rust|auto` (lue indépendamment par `grimoire.flows.engine` et `grimoire.runtime.kernel`), jobs CI `rust-flows / cargo` et `rust-flows / parity` dans `.github/workflows/rust-cores.yml`, roue toujours `py3-none-any`. Divergence trouvée par l'oracle Rust et corrigée dans cette PR : `FlowEngine._TERMINAL_STATUSES` omettait `REFUSED` (terminal côté `RuntimeKernel` depuis les plafonds MAST, B11) — `resume()` sur un run REFUSED levait une erreur au message générique du kernel au lieu du message nommé de `resume()`, et `status()` affichait un `current_node`/`pending_nodes` périmés comme si le run continuait de progresser ; `REFUSED` ajouté à `_TERMINAL_STATUSES`, les deux backends s'accordent désormais. Comportement documenté et volontairement non changé : `status()` dérive `completed_nodes` de la position de `current_node` dans l'ordre topologique — un run ABORTED/REFUSED avant tout progrès affiche tous les nodes comme complétés, les deux backends reproduisant ce même comportement à l'identique (voir `rust/grimoire-flows-core/src/lib.rs` et l'issue de suivi citée dans la PR). Nouveau test de parité sur le corpus réel (`registry/blueprints/*.blueprint.json`) et sur la grille complète des 9×9 transitions de `WorkflowStatus`.
 
 - feat(hosts): troisième port Rust optionnel de `grimoire.hosts.collect`/`grimoire.hosts.surface` — lecture du frontmatter d'agent et garde de distinction (issue #354). `rust/grimoire-hosts-core/`, bascule `GRIMOIRE_HOSTS_BACKEND=python|rust|auto`, jobs CI `rust-hosts / cargo` et `rust-hosts / parity` dans `.github/workflows/rust-cores.yml`, roue toujours `py3-none-any`. Divergences trouvées par l'oracle Rust : `_max_turns` plantait avec un `ValueError` non rattrapé sur un chiffre Unicode non-ASCII (`"²"`, `str.isdigit()` vrai mais `int()` refuse) — corrigé dans cette PR (`str.isascii()` en plus) ; `_tool_verbs` ignore un verbe d'outil hors de `ToolVerb` — le périmètre d'outils reste inchangé (changer ça modifierait silencieusement celui d'agents existants), mais le rejet n'est plus silencieux : `collect_agents`/`build_surface` remonte désormais une note `ProjectSurface.notes` par agent nommant les jetons rejetés, identique sous les deux backends. Nouveau test de parité sur le corpus réel (`archetypes/*/agents/*.md`) prouvant que `yaml-rust2` et ruamel s'accordent sur ce que le kit expédie effectivement.
+
 ## [3.43.1] - 2026-09-11
 ### Corrigé
 

{grimoire_kit-3.44.0 → grimoire_kit-3.44.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.44.0
+Version: 3.44.2
 Summary: Composable AI agent platform — personas, memory, workflows, and quality automation for any project.
 Project-URL: Homepage, https://github.com/Guilhem-Bonnet/Grimoire-kit
 Project-URL: Repository, https://github.com/Guilhem-Bonnet/Grimoire-kit

{grimoire_kit-3.44.0 → grimoire_kit-3.44.2}/registry/kit-file-hashes.json

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

grimoire_kit-3.44.2/src/grimoire/__version__.py

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

grimoire_kit-3.44.2/src/grimoire/cli/_lazy.py

@@ -0,0 +1,169 @@
+"""Lazy command-tree loading for the ``grimoire`` CLI (issue #405).
+
+Building the full Typer/Click command tree eagerly means importing every
+sub-command module — and its heavy dependencies (``grimoire.flows``,
+``grimoire.missions.dispatch``, ``grimoire.memory``, ``grimoire.cli.cmd_cockpit``...)
+— before Typer even knows which command the user asked for. That import cost
+used to be paid by *every* invocation, including ``grimoire --version`` and
+every hook/MCP call (see the measurement in issue #405).
+
+:class:`LazyTyperGroup` defers that import to the moment a specific
+sub-command is actually resolved — real dispatch, or that sub-command's own
+``--help``. Importing ``grimoire.cli.app`` or running an unrelated command
+never touches a lazy sub-command's module.
+
+The two registries (:class:`LazyGroupSpec` for ``add_typer``-style sub-apps,
+:class:`LazyCommandSpec` for single ``@app.command`` functions) exist purely
+as name -> (module, attribute) mappings plus the metadata Typer needs to
+render the parent's own ``--help`` panel (short description, hidden flag,
+rich panel) — see ``app.py`` for the actual data.
+"""
+
+from __future__ import annotations
+
+import importlib
+from dataclasses import dataclass
+from typing import Any, ClassVar
+
+import typer
+from typer.core import TyperGroup
+from typer.models import CommandInfo, TyperInfo
+
+# Typer's own default (``typer.Typer(pretty_exceptions_short=True)``).
+# Nothing in this CLI overrides it on the root app or any sub-app (verified:
+# no ``pretty_exceptions_short=`` anywhere under ``grimoire.cli``), and the
+# value isn't retrievable from a built click.Group afterwards — so it's
+# fixed here rather than threaded through every lazy build call.
+_PRETTY_EXCEPTIONS_SHORT = True
+
+
+@dataclass(frozen=True)
+class LazyGroupSpec:
+    """A sub-``typer.Typer`` app, registered by name, imported on first use."""
+
+    module: str
+    attr: str
+    rich_help_panel: str | None = None
+    hidden: bool = False
+
+
+@dataclass(frozen=True)
+class LazyCommandSpec:
+    """A single command function, registered by name, imported on first use."""
+
+    module: str
+    attr: str
+    rich_help_panel: str | None = None
+    hidden: bool = False
+
+
+# Two aliases can point at the same backing module with *different* metadata
+# (``debugger``: visible, panel "Data" / ``dbg``: hidden, no panel) — the
+# built Click object carries that metadata, so it must be cached per (name,
+# spec), not per (module, attr). Re-importing the module for the second alias
+# is free anyway (``sys.modules`` already has it); only the Click-object
+# build is repeated, once, only if both aliases are ever resolved in the same
+# process (never happens on the measured paths — only on a full `--help`).
+_build_cache: dict[tuple[str, Any], Any] = {}
+
+
+def _import_attr(module: str, attr: str) -> Any:
+    return getattr(importlib.import_module(module), attr)
+
+
+def _build_group(name: str, spec: LazyGroupSpec, owner: TyperGroup) -> Any:
+    key = (name, spec)
+    built = _build_cache.get(key)
+    if built is None:
+        sub_typer = _import_attr(spec.module, spec.attr)
+        info = TyperInfo(
+            sub_typer,
+            name=name,
+            hidden=spec.hidden,
+            rich_help_panel=spec.rich_help_panel,
+        )
+        built = typer.main.get_group_from_info(
+            info,
+            pretty_exceptions_short=_PRETTY_EXCEPTIONS_SHORT,
+            rich_markup_mode=owner.rich_markup_mode,
+            suggest_commands=owner.suggest_commands,
+        )
+        _build_cache[key] = built
+    return built
+
+
+def _build_command(name: str, spec: LazyCommandSpec, owner: TyperGroup) -> Any:
+    key = (name, spec)
+    built = _build_cache.get(key)
+    if built is None:
+        func = _import_attr(spec.module, spec.attr)
+        info = CommandInfo(
+            name=name,
+            callback=func,
+            hidden=spec.hidden,
+            rich_help_panel=spec.rich_help_panel,
+        )
+        built = typer.main.get_command_from_info(
+            info,
+            pretty_exceptions_short=_PRETTY_EXCEPTIONS_SHORT,
+            rich_markup_mode=owner.rich_markup_mode,
+        )
+        _build_cache[key] = built
+    return built
+
+
+class LazyTyperGroup(TyperGroup):
+    """``TyperGroup`` that resolves a registered subset of commands lazily.
+
+    Call :meth:`configure` once, right after building the ``typer.Typer``
+    instance that uses this class (``typer.Typer(cls=LazyTyperGroup, ...)``),
+    with the name -> spec registries. Eager commands/sub-typers registered
+    the normal way (``@app.command``, ``app.add_typer``) are unaffected —
+    they still live in ``self.commands``.
+
+    ``order`` is the exact name sequence ``grimoire --help`` rendered before
+    this class existed (every ``@app.command``/``app.command()`` in file
+    order, then every ``add_typer()`` in call order — Typer's own rule for
+    populating a group's ``commands`` dict). Sub-command panels are grouped
+    by ``rich_help_panel``, and rich renders panels/rows in first-seen order,
+    so without ``order`` the panel and row order would depend on which names
+    are eager vs. lazy instead of matching the pre-#405 output byte-for-byte.
+    """
+
+    _lazy_groups: ClassVar[dict[str, LazyGroupSpec]] = {}
+    _lazy_commands: ClassVar[dict[str, LazyCommandSpec]] = {}
+    _lazy_order: ClassVar[list[str]] = []
+
+    @classmethod
+    def configure(
+        cls,
+        *,
+        groups: dict[str, LazyGroupSpec],
+        commands: dict[str, LazyCommandSpec],
+        order: list[str] | None = None,
+    ) -> None:
+        cls._lazy_groups = groups
+        cls._lazy_commands = commands
+        cls._lazy_order = order or []
+
+    def list_commands(self, ctx: Any) -> list[str]:
+        names = set(self.commands) | set(self._lazy_groups) | set(self._lazy_commands)
+        ordered = [n for n in self._lazy_order if n in names]
+        remaining = [n for n in names if n not in self._lazy_order]
+        return ordered + remaining
+
+    def get_command(self, ctx: Any, cmd_name: str) -> Any:
+        cmd = self.commands.get(cmd_name)
+        if cmd is not None:
+            return cmd
+        group_spec = self._lazy_groups.get(cmd_name)
+        if group_spec is not None:
+            built = _build_group(cmd_name, group_spec, self)
+            self.commands[cmd_name] = built
+            return built
+        command_spec = self._lazy_commands.get(cmd_name)
+        if command_spec is not None:
+            built = _build_command(cmd_name, command_spec, self)
+            self.commands[cmd_name] = built
+            return built
+        return None

{grimoire_kit-3.44.0 → grimoire_kit-3.44.2}/src/grimoire/cli/app.py

@@ -19,29 +19,8 @@ from rich.console import Console
 from rich.table import Table
 
 from grimoire.__version__ import __version__
+from grimoire.cli._lazy import LazyCommandSpec, LazyGroupSpec, LazyTyperGroup
 from grimoire.cli._shared import _AUDIT_FILENAME, _log_operation, _status_spinner
-from grimoire.cli.cmd_blueprint import blueprint_app
-from grimoire.cli.cmd_cadrage import cadrage_app
-from grimoire.cli.cmd_cockpit import cockpit_app
-from grimoire.cli.cmd_context_pack import context_pack_command
-from grimoire.cli.cmd_debugger import debugger_app
-from grimoire.cli.cmd_ext import ext_app
-from grimoire.cli.cmd_features import features_app
-from grimoire.cli.cmd_flow import flow_app
-from grimoire.cli.cmd_hooks import hooks_app
-from grimoire.cli.cmd_host import host_app
-from grimoire.cli.cmd_memory_lexical import memory_app
-from grimoire.cli.cmd_migrate import migrate_command
-from grimoire.cli.cmd_proposals import proposals_app
-from grimoire.cli.cmd_providers import providers_app
-from grimoire.cli.cmd_serve import serve as serve_cmd
-from grimoire.cli.cmd_standard import standard_app
-from grimoire.cli.cmd_stigmergy import stigmergy_app
-from grimoire.cli.cmd_task import task_app
-from grimoire.cli.cmd_up import up as up_command
-from grimoire.cli.cmd_upgrade import upgrade_command
-from grimoire.cli.cmd_web import web_app
-from grimoire.cli.cmd_workflows import workflows_app
 from grimoire.core import layout
 from grimoire.core.config import GrimoireConfig
 from grimoire.core.exceptions import GrimoireConfigError, GrimoireError
@@ -94,6 +73,10 @@ def _suggest_command() -> None:
         for group_info in app.registered_groups:
             if group_info.name:
                 _KNOWN_COMMANDS.add(group_info.name)
+        # Lazy sub-commands (issue #405) aren't in app.registered_groups —
+        # they never call add_typer()/command() at import time.
+        _KNOWN_COMMANDS.update(LazyTyperGroup._lazy_groups)
+        _KNOWN_COMMANDS.update(LazyTyperGroup._lazy_commands)
         _KNOWN_COMMANDS.update(_ALIASES)
     if arg in _KNOWN_COMMANDS:
         return
@@ -107,6 +90,7 @@ def _suggest_command() -> None:
 
 app = typer.Typer(
     name="grimoire",
+    cls=LazyTyperGroup,
     help="Grimoire Kit — Composable AI agent platform.",
     no_args_is_help=True,
     rich_markup_mode="rich",
@@ -983,35 +967,65 @@ def update_cmd() -> None:
     self_update()
 
 
-# ── grimoire up ───────────────────────────────────────────────────────────────────
-# Full one-command bring-up (init → identity → standard → doctor summary).
-# Implementation lives in cmd_up.py; registered here.
-
-app.command("up", rich_help_panel="Project")(up_command)
-app.command("context-pack", rich_help_panel="Data")(context_pack_command)
-
-
-# ── grimoire memory ───────────────────────────────────────────────────────────────
-
-app.add_typer(memory_app, name="memory", rich_help_panel="Data")
-
-
-# ── grimoire hooks ────────────────────────────────────────────────────────────────
-
-app.add_typer(hooks_app, name="hooks", rich_help_panel="Project")
-app.add_typer(cadrage_app, name="cadrage", rich_help_panel="Project")
-
-
-# ── grimoire migrate ──────────────────────────────────────────────────────────────
-
-app.command("migrate", rich_help_panel="Project")(migrate_command)
-app.command("upgrade", rich_help_panel="Utilities")(upgrade_command)
-
-
-# ── grimoire debugger ─────────────────────────────────────────────────────────────
-
-app.add_typer(debugger_app, name="debugger", rich_help_panel="Data")
-app.add_typer(debugger_app, name="dbg", hidden=True)
+# ── Lazy sub-commands (issue #405) ─────────────────────────────────────────────
+#
+# Every entry below used to be an eager `from grimoire.cli.cmd_X import Y` at
+# the top of this file plus an `app.add_typer(Y, ...)` / `app.command(...)(Y)`
+# call here — meaning importing `grimoire.cli.app` (hence every CLI
+# invocation, hook, and MCP call) paid for importing all of them, regardless
+# of which command was actually requested. `LazyTyperGroup` (see `_lazy.py`)
+# imports the backing module only when that specific command is resolved:
+# real dispatch, or that command's own `--help`. `grimoire --version` and
+# `grimoire doctor .` never touch any of these modules.
+#
+# Name, rich_help_panel and hidden must match what the corresponding
+# `add_typer`/`command` call passed before — they are what `grimoire --help`
+# renders without importing anything.
+
+LazyTyperGroup.configure(
+    groups={
+        "memory": LazyGroupSpec("grimoire.cli.cmd_memory_lexical", "memory_app", rich_help_panel="Data"),
+        "hooks": LazyGroupSpec("grimoire.cli.cmd_hooks", "hooks_app", rich_help_panel="Project"),
+        "cadrage": LazyGroupSpec("grimoire.cli.cmd_cadrage", "cadrage_app", rich_help_panel="Project"),
+        "debugger": LazyGroupSpec("grimoire.cli.cmd_debugger", "debugger_app", rich_help_panel="Data"),
+        "dbg": LazyGroupSpec("grimoire.cli.cmd_debugger", "debugger_app", hidden=True),
+        "workflows": LazyGroupSpec("grimoire.cli.cmd_workflows", "workflows_app", rich_help_panel="Project"),
+        "wf": LazyGroupSpec("grimoire.cli.cmd_workflows", "workflows_app", hidden=True),
+        "standard": LazyGroupSpec("grimoire.cli.cmd_standard", "standard_app", rich_help_panel="Project"),
+        "ext": LazyGroupSpec("grimoire.cli.cmd_ext", "ext_app", rich_help_panel="Project"),
+        "blueprint": LazyGroupSpec("grimoire.cli.cmd_blueprint", "blueprint_app", rich_help_panel="Project"),
+        "flow": LazyGroupSpec("grimoire.cli.cmd_flow", "flow_app", rich_help_panel="Project"),
+        "cockpit": LazyGroupSpec("grimoire.cli.cmd_cockpit", "cockpit_app", rich_help_panel="Project"),
+        "task": LazyGroupSpec("grimoire.cli.cmd_task", "task_app", rich_help_panel="Project"),
+        "stigmergy": LazyGroupSpec("grimoire.cli.cmd_stigmergy", "stigmergy_app", rich_help_panel="Data"),
+        "features": LazyGroupSpec("grimoire.cli.cmd_features", "features_app", rich_help_panel="Project"),
+        "host": LazyGroupSpec("grimoire.cli.cmd_host", "host_app", rich_help_panel="Project"),
+        "providers": LazyGroupSpec("grimoire.cli.cmd_providers", "providers_app", rich_help_panel="Project"),
+        "proposals": LazyGroupSpec("grimoire.cli.cmd_proposals", "proposals_app", rich_help_panel="Agents"),
+        "web": LazyGroupSpec("grimoire.cli.cmd_web", "web_app", rich_help_panel="Data"),
+    },
+    commands={
+        "up": LazyCommandSpec("grimoire.cli.cmd_up", "up", rich_help_panel="Project"),
+        "context-pack": LazyCommandSpec("grimoire.cli.cmd_context_pack", "context_pack_command", rich_help_panel="Data"),
+        "migrate": LazyCommandSpec("grimoire.cli.cmd_migrate", "migrate_command", rich_help_panel="Project"),
+        "upgrade": LazyCommandSpec("grimoire.cli.cmd_upgrade", "upgrade_command", rich_help_panel="Utilities"),
+        "serve": LazyCommandSpec("grimoire.cli.cmd_serve", "serve", hidden=True),  # alias déprécié — voir `cockpit serve` (#351)
+    },
+    # Exact pre-#405 order: every @app.command/app.command() in file order,
+    # then every add_typer() in call order (Typer's own populating rule) —
+    # keeps `grimoire --help`'s panel/row order byte-identical. See
+    # `LazyTyperGroup.configure`'s docstring for why this is needed.
+    order=[
+        "version", "init", "doctor", "status", "add", "remove", "agent-miss",
+        "validate", "lint", "update", "up", "context-pack", "migrate", "upgrade",
+        "serve", "diff", "schema", "check", "merge", "setup", "env", "history",
+        "repair",
+        "memory", "hooks", "cadrage", "debugger", "dbg", "registry", "workflows",
+        "wf", "standard", "ext", "blueprint", "flow", "cockpit", "task",
+        "stigmergy", "features", "host", "providers", "proposals", "web",
+        "config", "completion", "self", "plugins",
+    ],
+)
 
 
 # ── grimoire registry ─────────────────────────────────────────────────────────────
@@ -1021,25 +1035,6 @@ _reg_query_arg = typer.Argument(None, help="Search query.")
 app.add_typer(registry_app, name="registry", rich_help_panel="Agents")
 
 
-# ── grimoire workflows ───────────────────────────────────────────────────────────
-
-app.add_typer(workflows_app, name="workflows", rich_help_panel="Project")
-app.add_typer(workflows_app, name="wf", hidden=True)
-app.add_typer(standard_app, name="standard", rich_help_panel="Project")
-app.add_typer(ext_app, name="ext", rich_help_panel="Project")
-app.add_typer(blueprint_app, name="blueprint", rich_help_panel="Project")
-app.add_typer(flow_app, name="flow", rich_help_panel="Project")
-app.add_typer(cockpit_app, name="cockpit", rich_help_panel="Project")
-app.add_typer(task_app, name="task", rich_help_panel="Project")
-app.add_typer(stigmergy_app, name="stigmergy", rich_help_panel="Data")
-app.add_typer(features_app, name="features", rich_help_panel="Project")
-app.add_typer(host_app, name="host", rich_help_panel="Project")
-app.add_typer(providers_app, name="providers", rich_help_panel="Project")
-app.add_typer(proposals_app, name="proposals", rich_help_panel="Agents")
-app.add_typer(web_app, name="web", rich_help_panel="Data")
-app.command("serve", hidden=True)(serve_cmd)  # alias déprécié — voir `cockpit serve` (#351)
-
-
 @registry_app.command("list")
 def registry_list(ctx: typer.Context) -> None:
     """List all available archetypes and agents."""

{grimoire_kit-3.44.0 → grimoire_kit-3.44.2}/src/grimoire/cli/cmd_task.py

@@ -71,6 +71,12 @@ def board_export(
         return
 
     write_board(dest, board)
+    if dest == root / _BOARD_RELPATH:
+        # Même empreinte-invalidation que le service (issue #419, second
+        # lot) : sans cet appel, seul le hook *suivant* verrait la reprojection.
+        from grimoire.core.standard_state import invalidate_cache
+
+        invalidate_cache(root)
     counts = _counts(board)
     if _fmt(ctx) == "json":
         typer.echo(json.dumps({"path": str(dest), "tasks": len(board["tasks"]), "by_status": counts}, indent=2, ensure_ascii=False))

{grimoire_kit-3.44.0 → grimoire_kit-3.44.2}/src/grimoire/cli/cmd_up.py

@@ -30,12 +30,17 @@ from rich.console import Console
 from rich.table import Table
 
 from grimoire.cli import cmd_setup
-from grimoire.cli.cmd_init import KNOWN_ARCHETYPES, KNOWN_BACKENDS, run_init
 from grimoire.core import layout
 from grimoire.core.config import GrimoireConfig
 from grimoire.core.exceptions import GrimoireConfigError, GrimoireError
-from grimoire.core.scaffold import TIER_SEED, write_text_if_changed
-from grimoire.hosts.sync import sync_host_surfaces
+
+# NOTE (issue #405): cmd_init/core.scaffold/hosts.sync are only needed by the
+# actual `up`/`--fix` code paths below, not by `run_env_checks` — which
+# `grimoire doctor` imports unconditionally on every run. Importing them here
+# at module level meant every `grimoire doctor .` paid for `grimoire init`'s
+# full dependency tree (scaffold, memory, missions, hosts.*) just to reach a
+# handful of socket probes. They're imported lazily, next to their one use
+# each, instead.
 
 console = Console(stderr=True)
 
@@ -511,7 +516,8 @@ def repair_project_artifacts(target: Path) -> list[str]:
     Returns the list of regenerated labels (relative paths).
     """
     from grimoire.core.archetype_resolver import ResolvedArchetype
-    from grimoire.core.scaffold import ProjectScaffolder, ScaffoldPlan
+    from grimoire.core.scaffold import TIER_SEED, ProjectScaffolder, ScaffoldPlan, write_text_if_changed
+    from grimoire.hosts.sync import sync_host_surfaces
 
     target = target.resolve()
     cfg = _load_config_quiet(target)
@@ -634,6 +640,8 @@ def _step_init(
     dry_run: bool,
 ) -> bool:
     """Run (or skip) express init. Returns True when a config is available after the step."""
+    from grimoire.cli.cmd_init import run_init
+
     config_path = target / "project-context.yaml"
     if config_path.is_file():
         state.steps.append(StepResult("init", "skipped", "project already initialized (project-context.yaml present)"))
@@ -1067,6 +1075,8 @@ def up(
       [cyan]grimoire up . --needs collab-review[/cyan] Standard init from a need profile
       [cyan]grimoire up . --no-standard[/cyan]         Skip the agentic standard step
     """
+    from grimoire.cli.cmd_init import KNOWN_ARCHETYPES, KNOWN_BACKENDS
+
     target = path.resolve()
     fmt = (ctx.obj or {}).get("output", "text")