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

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

@@ -7,6 +7,97 @@ 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).**

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.44.1
+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.1 → grimoire_kit-3.44.2}/registry/kit-file-hashes.json

@@ -1,6 +1,6 @@
 {
  "schema": "grimoire-kit-file-hashes/v1",
- "generated_for": "3.44.1",
+ "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.1 → 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.1 → grimoire_kit-3.44.2}/src/grimoire/core/agentic_standard.py

@@ -77,7 +77,7 @@ from grimoire.core.standard_generation import (
     normalize_task_id,
 )
 from grimoire.core.standard_profile_manifest import read_artifact_paths, read_profile
-from grimoire.core.standard_state import board_omits_task, task_from_board
+from grimoire.core.standard_state import board_omits_task, invalidate_cache, task_from_board
 from grimoire.data import framework_path
 
 PROFILE_MAP_PATH = Path("agentic-standard/profile-map.yaml")
@@ -817,6 +817,13 @@ def setup_standard_profile(
             if configured not in result.written:
                 result.written.append(configured)
 
+    if not dry_run and (result.written or generated):
+        # Le hook lit le profil (et parfois le board) via un cache dérivé,
+        # invalidé par empreinte fichier — voir grimoire.core.standard_state.
+        # Sans cet appel, seule l'invocation *suivante* du hook verrait ce
+        # que cette commande vient d'écrire ; avec, c'est immédiat.
+        invalidate_cache(root)
+
     return result
 
 

{grimoire_kit-3.44.1 → grimoire_kit-3.44.2}/src/grimoire/core/standard_state.py

@@ -9,15 +9,14 @@ call — imports a small module instead of the whole standard engine.
 
 from __future__ import annotations
 
+import contextlib
+import json
 import os
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from ruamel.yaml import YAML
-from ruamel.yaml.error import YAMLError
-
 # Tout vient de ``standard_generation``, le module léger : ce lecteur tourne dans
 # le chemin des hooks, à chaque appel d'outil, et importer le moteur du standard
 # pour lire deux chemins et un identifiant coûtait 48 ms par appel.
@@ -29,11 +28,121 @@ from grimoire.core.standard_generation import (
 
 TASK_BOARD_RELPATH = STANDARD_DIR / "task-board.yaml"
 
+#: Instantané dérivé de ``standard-profile.yaml``/``task-board.yaml``, en JSON —
+#: jamais en YAML : ``ruamel.yaml`` coûte ~8-9 ms à sa première charge dans un
+#: process, sur le chemin du hook déclenché à *chaque* appel d'outil (issue
+#: #419, second lot). ``_grimoire-output/.runs/`` est déjà l'emplacement de
+#: l'état de session éphémère et gitignoré ; ce cache y vit au même titre.
+_CACHE_RELPATH = Path("_grimoire-output") / ".runs" / "standard-state-cache.json"
+_CACHE_VERSION = 1
+
+
+def _stat_fingerprint(path: Path) -> list[int] | None:
+    """``[mtime_ns, size]`` pour *path*, ou ``None`` si absent/illisible.
+
+    L'empreinte, pas le contenu : un ``stat`` coûte un ordre de grandeur de
+    moins qu'un parse YAML, et suffit à détecter un fichier changé entre deux
+    appels de hook.
+    """
+    try:
+        st = path.stat()
+    except OSError:
+        return None
+    return [st.st_mtime_ns, st.st_size]
+
+
+def _read_cache_entries(root: Path) -> dict[str, Any]:
+    """La table ``entries`` du cache, ou ``{}`` — jamais une exception.
+
+    Un cache absent, tronqué, au mauvais format JSON ou d'une version
+    inconnue n'est jamais une erreur au sens du hook : c'est juste une
+    absence, qui retombe sur la relecture YAML.
+    """
+    path = root / _CACHE_RELPATH
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError:
+        return {}
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        return {}
+    if not isinstance(data, dict) or data.get("version") != _CACHE_VERSION:
+        return {}
+    entries = data.get("entries")
+    return entries if isinstance(entries, dict) else {}
+
+
+def _write_cache_entries(root: Path, entries: dict[str, Any]) -> None:
+    """Écriture atomique (fichier temporaire + ``os.replace``) — best-effort.
+
+    Un cache qui échoue à s'écrire ne doit jamais faire échouer un hook : la
+    prochaine invocation retombera simplement sur la relecture YAML, comme si
+    le cache n'existait pas.
+    """
+    path = root / _CACHE_RELPATH
+    payload = json.dumps({"version": _CACHE_VERSION, "entries": entries}, sort_keys=True)
+    tmp = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp.write_text(payload, encoding="utf-8")
+        tmp.replace(path)
+    except OSError:
+        with contextlib.suppress(OSError):
+            tmp.unlink()
+
+
+def _cached_or_fresh(
+    root: Path, key: str, relpath: Path, compute: Callable[[], Any], *, write_cache: bool = True
+) -> Any:
+    """La valeur en cache pour *relpath* si son empreinte tient toujours, sinon fraîche.
+
+    Une absence, une corruption ou un fichier source modifié retombent toutes
+    sur *compute* (qui lit le YAML pour de vrai). Le résultat frais rafraîchit
+    le cache sur disque sauf si *write_cache* est ``False`` — un appelant qui a
+    promis de ne rien écrire (un outil MCP annoté lecture seule, par exemple)
+    lit le cache s'il est chaud mais ne le crée ni ne le corrige jamais lui-même,
+    laissant ce travail au prochain appelant qui, lui, écrit. Le
+    rafraîchissement lui-même reste best-effort : voir :func:`_write_cache_entries`.
+    """
+    fingerprint = _stat_fingerprint(root / relpath)
+    entries = _read_cache_entries(root)
+    cached = entries.get(key)
+    if isinstance(cached, dict) and cached.get("fingerprint") == fingerprint and "value" in cached:
+        return cached["value"]
+    value = compute()
+    if write_cache:
+        entries[key] = {"path": str(relpath), "fingerprint": fingerprint, "value": value}
+        _write_cache_entries(root, entries)
+    return value
+
+
+def invalidate_cache(project_root: Path) -> None:
+    """Purge le cache d'état du standard — à appeler juste après avoir écrit le YAML qu'il dérive.
+
+    Pas requis pour la correction : l'empreinte périmée régénère déjà un
+    cache obsolète au prochain appel de hook. Mais sans cet appel, c'est cet
+    appel *suivant* qui verrait le changement — celui qui vient de l'écrire
+    ne le verrait pas avant. Best-effort, comme le reste du cache : un échec
+    de suppression est rattrapé par le mismatch d'empreinte.
+    """
+    path = project_root.resolve() / _CACHE_RELPATH
+    with contextlib.suppress(OSError):
+        path.unlink(missing_ok=True)
+
 
 def _load_mapping(path: Path) -> dict[str, Any]:
-    """Read a YAML mapping, or an empty one — never raise at a hook boundary."""
+    """Read a YAML mapping, or an empty one — never raise at a hook boundary.
+
+    ``ruamel.yaml`` is imported here, not at module scope: a warm cache means
+    neither this function nor the parser it needs ever runs, and the whole
+    point of the cache is to keep ``ruamel`` off that path.
+    """
     if not path.is_file():
         return {}
+    from ruamel.yaml import YAML
+    from ruamel.yaml.error import YAMLError
+
     try:
         data = YAML(typ="safe").load(path)
     except (OSError, ValueError, YAMLError):
@@ -81,10 +190,22 @@ def is_standard_enrolled(project_root: Path) -> bool:
     return (root / STANDARD_PROFILE_FILE).is_file() or (root / TASK_BOARD_RELPATH).is_file()
 
 
-def active_profile_id(project_root: Path) -> str:
-    """Profile a project is enrolled in, ``starter`` when it declares none."""
-    profile = _load_mapping(project_root.resolve() / STANDARD_PROFILE_FILE).get("profile")
-    return str(profile) if profile else "starter"
+def active_profile_id(project_root: Path, *, write_cache: bool = True) -> str:
+    """Profile a project is enrolled in, ``starter`` when it declares none.
+
+    *write_cache* defaults to ``True`` — the lifecycle hook path (and the CLI)
+    both want the derived JSON cache written back so the *next* call is
+    cheap. A caller that has promised no side effects at all (an MCP tool
+    annotated ``readOnlyHint``) passes ``False``: it still benefits from a
+    cache another caller warmed, it just never creates or repairs one itself.
+    """
+    root = project_root.resolve()
+
+    def compute() -> str:
+        profile = _load_mapping(root / STANDARD_PROFILE_FILE).get("profile")
+        return str(profile) if profile else "starter"
+
+    return str(_cached_or_fresh(root, "profile_id", STANDARD_PROFILE_FILE, compute, write_cache=write_cache))
 
 
 #: Le Mission Ledger, source des tâches (ADR-005). Lu ici sans importer le
@@ -132,7 +253,9 @@ def claimed_task_ids(project_root: Path, *, actor: str = "") -> list[str]:
     return [t.id for t in active]
 
 
-def resolve_active_task(project_root: Path, *, env: Mapping[str, str] | None = None) -> ActiveTask:
+def resolve_active_task(
+    project_root: Path, *, env: Mapping[str, str] | None = None, write_cache: bool = True
+) -> ActiveTask:
     """Task a lifecycle hook should evaluate, with the rule that chose it.
 
     Resolution order:
@@ -148,6 +271,9 @@ def resolve_active_task(project_root: Path, *, env: Mapping[str, str] | None = N
 
     Two concurrent claims (or two in-progress cards) are ambiguous: that level
     is skipped rather than guessed at, and ``GRIMOIRE_TASK_ID`` decides.
+
+    *write_cache* — see :func:`active_profile_id`: ``False`` for a caller that
+    must never write anything (a ``readOnlyHint`` MCP tool).
     """
     environ = os.environ if env is None else env
     override = str(environ.get(TASK_ENV, "")).strip()
@@ -161,18 +287,26 @@ def resolve_active_task(project_root: Path, *, env: Mapping[str, str] | None = N
         except ValueError:
             pass
 
-    tasks = _load_mapping(project_root.resolve() / TASK_BOARD_RELPATH).get("tasks")
-    if isinstance(tasks, list):
-        in_progress = [
+    root = project_root.resolve()
+
+    def compute() -> list[str]:
+        tasks = _load_mapping(root / TASK_BOARD_RELPATH).get("tasks")
+        if not isinstance(tasks, list):
+            return []
+        return [
             str(task.get("task_id", ""))
             for task in tasks
             if isinstance(task, dict) and str(task.get("status", "")) == "in_progress" and task.get("task_id")
         ]
-        if len(in_progress) == 1:
-            return ActiveTask(normalize_task_id(in_progress[0]), "board")
+
+    in_progress = _cached_or_fresh(
+        root, "board_in_progress", TASK_BOARD_RELPATH, compute, write_cache=write_cache
+    )
+    if len(in_progress) == 1:
+        return ActiveTask(normalize_task_id(in_progress[0]), "board")
     return ActiveTask("bootstrap", "bootstrap")
 
 
-def active_task_id(project_root: Path, *, env: Mapping[str, str] | None = None) -> str:
+def active_task_id(project_root: Path, *, env: Mapping[str, str] | None = None, write_cache: bool = True) -> str:
     """Task a lifecycle hook should evaluate — see :func:`resolve_active_task`."""
-    return resolve_active_task(project_root, env=env).task_id
+    return resolve_active_task(project_root, env=env, write_cache=write_cache).task_id

{grimoire_kit-3.44.1 → grimoire_kit-3.44.2}/src/grimoire/hosts/collect.py

@@ -310,6 +310,17 @@ def collect_agents(
     treatment as an import that names a module which does not exist — not a
     warning, and not a silent drop.
 
+    Left ``None`` (the default), this function resolves its own inventory
+    via :func:`collect_skills` — no caller can fall back into the gap that
+    caused issue #423: passing no inventory used to silently become an
+    *empty* one, so every agent with a ``skills:`` frontmatter (the default
+    shape of archetype agents since #377/#387) failed fail-closed as if its
+    skills did not exist, even though :func:`collect_skills` would have
+    found every one of them. Pass an explicit inventory only to reuse one
+    already collected for another purpose (e.g. :func:`build_surface`, which
+    needs the same :class:`SkillSpec` objects, not just their slugs) or to
+    deliberately test the fail-closed path with a narrower set.
+
     *notes* is an optional out-parameter (appended to in place, never
     replaced): when given, an agent declaring a ``tools:`` token that is not
     a member of :class:`ToolVerb` (a frontmatter typo, e.g. ``tools: [read,
@@ -322,7 +333,8 @@ def collect_agents(
     """
     if entry_point is None:
         entry_point = entry_agent_name(project_root)
-    known_skills = known_skills or frozenset()
+    if known_skills is None:
+        known_skills = frozenset(spec.slug for spec in collect_skills(project_root))
     specs: list[AgentSpec] = []
     for path in _agent_files(project_root):
         try:
@@ -626,12 +638,19 @@ def _is_override(definition_ref: str) -> bool:
     return definition_ref.replace("\\", "/").startswith(f"{layout.OVERRIDES_DIR}/")
 
 
-def build_surface(project_root: Path, *, project_name: str | None = None) -> ProjectSurface:
+def build_surface(
+    project_root: Path, *, project_name: str | None = None, write_cache: bool = True
+) -> ProjectSurface:
     """Read *project_root* into the surface every emitter renders from.
 
     Skills are collected before agents on purpose: an agent's ``skills:``
     frontmatter resolves against the skill inventory, so the inventory must
     exist first.
+
+    *write_cache* is forwarded to :func:`grimoire.core.standard_state.active_profile_id`
+    — ``False`` for a caller with a no-side-effects contract (``grimoire_host_status``,
+    a ``readOnlyHint`` MCP tool); ``True`` (default) for ``grimoire host sync``, which is
+    allowed to warm the cache for the hook calls that follow.
     """
     root = project_root.resolve()
     governed = is_standard_enrolled(root)
@@ -675,7 +694,9 @@ def build_surface(project_root: Path, *, project_name: str | None = None) -> Pro
         skills=skills,
         commands=collect_commands(root, governed=governed),
         hooks=governance_hooks(governed=governed),
-        permissions=default_permissions(active_profile_id(root) if governed else "starter"),
+        permissions=default_permissions(
+            active_profile_id(root, write_cache=write_cache) if governed else "starter"
+        ),
         mcp_servers=collect_mcp_servers(root),
         governed=governed,
     )

{grimoire_kit-3.44.1 → grimoire_kit-3.44.2}/src/grimoire/mcp/server.py

@@ -788,7 +788,9 @@ def task_recall(
     root = Path(project_path).resolve()
     try:
         service = _task_service(project_path, ledger_root)
-        resolved = task_id or resolve_active_task(root).task_id
+        # readOnlyHint : ce tool ne doit écrire nulle part, pas même le cache
+        # dérivé de standard_state (issue #419, second lot).
+        resolved = task_id or resolve_active_task(root, write_cache=False).task_id
         service.require(resolved)
         recall = service.recall(resolved)
         return json.dumps(recall.to_dict(), indent=2, ensure_ascii=False, default=str)
@@ -816,7 +818,9 @@ def grimoire_host_status(project_path: str = ".") -> str:
 
     target = Path(project_path).resolve()
     try:
-        surface = build_surface(target)
+        # readOnlyHint : ce tool ne doit écrire nulle part, pas même le cache
+        # dérivé de standard_state (issue #419, second lot).
+        surface = build_surface(target, write_cache=False)
     except (GrimoireError, OSError, ValueError) as exc:
         return _tool_error({"error": str(exc)})
 

{grimoire_kit-3.44.1 → grimoire_kit-3.44.2}/src/grimoire/missions/service.py

@@ -25,6 +25,7 @@ from typing import TYPE_CHECKING, Any
 
 from grimoire.core.exceptions import GrimoireError, GrimoireMissionError
 from grimoire.core.standard_generation import STANDARD_DIR
+from grimoire.core.standard_state import invalidate_cache
 from grimoire.missions.board import board_status_of, build_board, write_board
 from grimoire.missions.gates import GateRefusal, GateVerdict, check_transition
 from grimoire.missions.ledger import MissionLedger
@@ -308,6 +309,10 @@ class TaskService:
             write_board(dest, build_board(self.ledger, project=self.project_root.name))
         except (OSError, GrimoireError):
             return None
+        # Le hook lit la tâche ``in_progress`` du board via un cache dérivé,
+        # invalidé par empreinte fichier (grimoire.core.standard_state) ; sans
+        # cet appel, la reprojection ne serait visible qu'au hook *suivant*.
+        invalidate_cache(self.project_root)
         return dest
 
     # ── Contexte ───────────────────────────────────────────────────────────

grimoire_kit-3.44.2/version.txt

@@ -0,0 +1 @@
+3.44.2

grimoire_kit-3.44.1/src/grimoire/__version__.py

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

grimoire_kit-3.44.1/version.txt

@@ -1 +0,0 @@
-3.44.1