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

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

@@ -7,6 +7,66 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/lang/fr/).
 
 ## [Unreleased]
 
+## [3.45.0] - 2026-09-12
+
+- **fix(flows): le gate de `flow run --executor dispatch` exécute l'acceptance structurée d'un node, pas seulement l'enveloppe (#428).**
+  Rejeu réel du 2026-09-11 (épic #307, lot 3) : un nœud V0 déclaré vert alors
+  que sa vraie suite `pytest` ne pouvait pas être collectée (dépendance
+  absente) — le gate ne vérifiait que la conformité de l'enveloppe JSON de
+  l'ouvrier au contrat de sortie, jamais le texte de l'acceptance. `node.acceptance`
+  accepte désormais, en plus du texte libre (rétrocompatible), une forme
+  structurée exécutable (`{"run": "...", "expect_exit": 0, "cwd": ".",
+  "timeout_s": 120, "expect_stdout_contains": "..."}`) ou une evidence
+  mécanique (`{"path_exists": "..."}`, `{"test": "..."}`) — validée au
+  chargement du blueprint (`blueprint_loader.py`), refus nommé sur une forme
+  inconnue. Le gate (`missions/dispatch.py`) exécute ces commandes après la
+  réponse de l'ouvrier et rend trois verdicts, jamais un quatrième :
+  exécutée-verte (succès), exécutée-rouge (échec, suit la cascade normale :
+  réessai/escalade), ou **acceptance inexécutable** (refus nommé — binaire
+  absent, `pytest` 5/4, erreur d'import dans la sortie — qui arrête la
+  cascade net, jamais un succès). `flow status` et le rapport de dispatch
+  montrent par nœud le statut d'acceptance (exécutée/inexécutable/jugée) et
+  la sortie tronquée à 2 Ko. **La classe V0 exige une acceptance
+  structurée** : un nœud dont le texte seul le classerait V0 mais qui n'en
+  déclare aucune est rétrogradé en V1 (cascade démarrant à `mid`, jamais
+  fermé sur la seule enveloppe — marqué à relire), avec un avertissement
+  nommé posé au chargement du blueprint et transmis à la fois au démarrage
+  de la cascade et au rapport, pour que `flow run` et `flow status`
+  s'accordent sur la même classe. Un nœud V1 **déclaré** (vocabulaire de
+  revue) garde le comportement actuel du kit, documenté sans être étendu.
+  Aucun changement côté port Rust des flows (`rust/grimoire-flows-core/`) :
+  seule `NodeContract.outputs` (pins) y traverse la frontière PyO3, inchangée
+  par ce correctif.
+
+- **feat(cockpit): le board de l'espace Exécuter montre le corps réel d'une tâche (description, garde-fous, dépendances) et les commandes d'intention restent gated par la preuve en multi-projet (#140).**
+  L'inspecteur de tâche affichait déjà les critères d'acceptation et les
+  preuves attendues ; il gagne des blocs Description, Garde-fous et
+  Dépendances, tirés du `MissionTask` du ledger — ce que `task-board.yaml`
+  n'a jamais su porter (ADR-005). `kanban.html` reste la vitrine statique et
+  gagne un lien vers le board vivant. Aucune écriture nouvelle : les
+  commandes de transition, le gate de preuve et la restriction au projet de
+  lancement du cockpit existaient déjà ; ce lot les couvre par des tests
+  dédiés (unitaires sur la route `/api/workspace/tasks/<id>/<action>` —
+  succès, refus nommant l'artefact manquant, refus hors projet de lancement —
+  et navigateur sur le critère d'acceptation à la lettre : une carte visée
+  vers *review* sans evidence pack est refusée avec l'artefact nommé, et le
+  board change quand on change de projet).
+
+- feat(traces): sixième port Rust optionnel du cœur du système d'artefact émergent — les agrégations du journal de traces (`TraceLedger.agent_dispatch_counts`/`.agent_miss_counts`/`.oldest_started_at`), la règle de fraîcheur (`compute_agent_freshness`, issue #396) et le déclencheur de propositions d'artefact (`grimoire.proposals` : nommage mécanique, résolution du porteur issue #402, décision de synchronisation seuil/refus issue #395/#394/#389) (issue #354). `rust/grimoire-traces-core/`, bascule `GRIMOIRE_TRACES_BACKEND=python|rust|auto` (lue indépendamment par `grimoire.traces.ledger` et `grimoire.proposals`, qui ne s'importent pas l'un l'autre), jobs CI `rust-traces / cargo` et `rust-traces / parity` dans `.github/workflows/rust-cores.yml`, roue toujours `py3-none-any`. Défaut trouvé par l'oracle Rust et corrigé dans cette même PR : `grimoire.traces.ledger._parse_iso` attrapait `ValueError` mais pas la `TypeError` non rattrapée levée ensuite par `datetime.now(tz=UTC) - datetime.fromisoformat(...)` sur un horodatage ISO-8601 *naïf* (sans décalage) — un journal JSONL édité à la main peut en porter un, et `compute_agent_freshness` revendique explicitement ne jamais lever sur un journal arbitraire ; corrigé en traitant un horodatage naïf comme UTC des deux côtés (même correctif que `grimoire_traces_core`, qui n'a jamais eu ce trou). Invariants de la doctrine rendus impossibles à violer par construction (clampés/exclus dans la fonction de décision elle-même, jamais par un appelant qui pourrait l'oublier) : seuil de proposition jamais sous 2, aucune proposition au premier non-choix, une proposition refusée ne revient que si son compte a doublé depuis le refus, la persona d'entrée est exclue de la recherche de porteur avant même de lire son `use_when`, le match de catégorie se fait par mot entier (limite de mot Unicode) et non par sous-chaîne. Corpus fixture de dix journaux JSONL réalistes (`tests/fixtures/traces_ledgers/`) et fuzz léger (200 enregistrements aléatoires) prouvant qu'aucune des fonctions d'agrégation/fraîcheur ne lève jamais, sous aucun backend, et qu'un champ de contenu libre (`prompt`/`request`) écrit à la main n'est jamais agrégé.
+
+- **fix(up): `identity` ne corrompt plus un scalaire commenté de `project-context.yaml` (#426).**
+  `cmd_setup._apply_project_context` réécrivait chaque ligne `user:` connue
+  avec une regex `.+` qui avalait tout le reste de la ligne — valeur *et*
+  commentaire inline — comme si c'était « la valeur », puis rewrappait ce
+  texte entier entre guillemets. `skill_level: "expert"  # beginner |
+  intermediate | expert` devenait `skill_level: ""expert"  # beginner |
+  intermediate | expert"` à chaque `grimoire up`, y compris quand la valeur
+  ne changeait pas — et cassait ensuite `grimoire doctor` (`GR002`, YAML
+  imparsable). Un nouveau `_split_scalar_and_comment` sépare correctement
+  le scalaire (quoté ou non) du commentaire qui le suit avant toute lecture
+  ou réécriture, et `_apply_project_context` recolle le commentaire original
+  après la nouvelle valeur au lieu de le jeter.
+
 ## [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).**

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grimoire-kit
-Version: 3.44.2
+Version: 3.45.0
 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.2 → grimoire_kit-3.45.0}/pyproject.toml

@@ -208,6 +208,7 @@ ignore_missing_imports = true
 # third such core (issue #354): rust/grimoire-hosts-core/.
 # `grimoire_flows_core` is the fourth: rust/grimoire-flows-core/.
 # `grimoire_dispatch_core` is the fifth: rust/grimoire-dispatch-core/.
+# `grimoire_traces_core` is the sixth: rust/grimoire-traces-core/.
 [[tool.mypy.overrides]]
 module = [
     "grimoire_policies_core",
@@ -215,6 +216,7 @@ module = [
     "grimoire_hosts_core",
     "grimoire_flows_core",
     "grimoire_dispatch_core",
+    "grimoire_traces_core",
 ]
 ignore_missing_imports = true
 

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

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

grimoire_kit-3.45.0/rust/grimoire-traces-core/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["maturin>=1.7,<2"]
+build-backend = "maturin"
+
+[project]
+name = "grimoire-traces-core"
+version = "0.1.0"
+description = "Coeur Rust optionnel des agregations du journal de traces, de la regle de fraicheur et du declencheur de propositions (PyO3). Non publie sur PyPI — build local uniquement, voir CONTRIBUTING.md."
+requires-python = ">=3.12"
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: 3.12",
+    "Private :: Do Not Upload",
+]
+
+[tool.maturin]
+module-name = "grimoire_traces_core"

grimoire_kit-3.45.0/src/grimoire/__version__.py

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

{grimoire_kit-3.44.2 → grimoire_kit-3.45.0}/src/grimoire/cli/cmd_flow.py

@@ -44,6 +44,15 @@ flow_app = typer.Typer(
     no_args_is_help=False,
 )
 
+#: Libellé humain de l'``acceptance_status`` d'un node dispatché (issue #428) —
+#: ``None`` : événement écrit avant ce correctif, rien à afficher.
+_ACCEPTANCE_LABELS: dict[str | None, str] = {
+    "executed": "exécutée",
+    "unrunnable": "inexécutable",
+    "judged": "jugée",
+    None: "n/a",
+}
+
 # Le rendu humain part sur stderr : le JSON de stdout reste pipeable, comme le
 # reste de la CLI (cf. cmd_task.py).
 console = Console(stderr=True)
@@ -127,10 +136,13 @@ def _emit_status(ctx: typer.Context, view: FlowStatusView, project_root: Path) -
         console.print("[bold]dispatch (#311)[/bold] :")
         for row in history:
             relire = " [magenta]à relire[/magenta]" if row["needs_review"] else ""
+            acceptance = _ACCEPTANCE_LABELS.get(row.get("acceptance_status"), "n/a")
             console.print(
                 f"  - {row['node_id']} : {row['verdict']} par {row['provider']} ({row['tier']}), "
-                f"{row['attempts']} tentative(s), coût {row['cost_usd']}{relire}"
+                f"{row['attempts']} tentative(s), coût {row['cost_usd']}{relire} — acceptance {acceptance}"
             )
+            if row.get("verifiability_warning"):
+                console.print(f"      [yellow]![/yellow] {row['verifiability_warning']}")
             for u in row["uncertainties"]:
                 console.print(f"      [dim]incertitude : {u.get('where')} — {u.get('what')}[/dim]")
     if view.contract:
@@ -171,10 +183,13 @@ def _emit_dispatch_outcome(ctx: typer.Context, outcome: FlowDispatchOutcome) ->
         return
     for node in outcome.nodes:
         relire = " [magenta]à relire[/magenta]" if node.needs_review else ""
+        acceptance = _ACCEPTANCE_LABELS.get(node.acceptance_status, "n/a")
         console.print(
             f"  {node.node_id} : {node.verdict} par {node.provider} — {node.attempts} tentative(s), "
-            f"{node.escalations} escalade(s), coût {node.cost_usd}{relire}"
+            f"{node.escalations} escalade(s), coût {node.cost_usd}{relire} — acceptance {acceptance}"
         )
+        if node.verifiability_warning:
+            console.print(f"    [yellow]![/yellow] {node.verifiability_warning}")
     console.print(
         f"[bold]coût total connu[/bold] : {outcome.total_cost_usd} — [bold]escalades[/bold] : {outcome.escalations}"
     )

{grimoire_kit-3.44.2 → grimoire_kit-3.45.0}/src/grimoire/cli/cmd_setup.py

@@ -54,11 +54,49 @@ class SetupResult:
 # ── YAML helpers (simple, no PyYAML dependency) ──────────────────────────────
 
 
+def _split_scalar_and_comment(tail: str) -> tuple[str, str]:
+    """Split the text after a YAML ``key:`` into ``(scalar, comment_suffix)``.
+
+    ``comment_suffix`` keeps its leading whitespace so that reassembling it
+    right after a (possibly new) scalar reproduces the line's trailing
+    comment untouched. A ``#`` inside a quoted scalar is literal, not a
+    comment marker — treating it as one is what corrupted ``skill_level:
+    "expert"  # ...`` into ``skill_level: ""expert"  # ..."`` (issue #426):
+    the old code captured ``"expert"  # comment`` whole as "the value" via
+    ``.+``, so it neither stripped the comment nor recognised the result as
+    quoted (its last character was the comment's, not a quote), then
+    re-wrapped that entire string in a fresh pair of quotes.
+    """
+    body = tail.rstrip("\n")
+    lstripped = body.lstrip(" \t")
+    if lstripped[:1] in ("'", '"'):
+        quote = lstripped[0]
+        i = 1
+        while i < len(lstripped):
+            ch = lstripped[i]
+            if quote == '"' and ch == "\\":
+                i += 2
+                continue
+            if ch == quote:
+                i += 1
+                break
+            i += 1
+        return lstripped[:i], lstripped[i:]
+    # Unquoted scalar: a '#' only starts a comment when it begins the tail
+    # or is preceded by whitespace — YAML's own rule.
+    match = re.search(r"(?:^|\s)#", lstripped)
+    if match is None:
+        value = lstripped.rstrip()
+        return value, lstripped[len(value):]
+    value = lstripped[: match.start()].rstrip()
+    return value, lstripped[len(value):]
+
+
 def _read_key(text: str, key: str) -> str | None:
     m = re.search(rf"^{re.escape(key)}:\s*(.+)$", text, re.MULTILINE)
     if not m:
         return None
-    val = m.group(1).strip()
+    val, _comment = _split_scalar_and_comment(m.group(1))
     if len(val) >= 2 and val[0] == val[-1] and val[0] in ('"', "'"):
         val = val[1:-1]
     return val
@@ -148,11 +186,19 @@ def _apply_project_context(path: Path, vals: UserValues) -> bool:
         start, end = span
         seen: set[str] = set()
         for i in range(start + 1, end):
-            stripped = lines[i].strip()
+            line = lines[i]
+            stripped = line.strip()
             for key in wanted:
                 if stripped.startswith(f"{key}:"):
-                    indent = lines[i][: len(lines[i]) - len(lines[i].lstrip())]
-                    lines[i] = f'{indent}{key}: "{wanted[key]}"'
+                    indent = line[: len(line) - len(line.lstrip())]
+                    # Preserve everything after the scalar (notably an
+                    # inline comment) instead of discarding it — see
+                    # ``_split_scalar_and_comment`` for why the previous
+                    # blind ``f'{key}: "{value}"'`` corrupted lines like
+                    # ``skill_level: "expert"  # ...`` (issue #426).
+                    _key_part, _sep, line_tail = line.partition(":")
+                    _old_value, comment = _split_scalar_and_comment(line_tail)
+                    lines[i] = f'{indent}{key}: "{wanted[key]}"{comment}'
                     seen.add(key)
         missing = [f'  {key}: "{value}"' for key, value in wanted.items() if key not in seen]
         tail = end

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

@@ -713,6 +713,10 @@ _VERDICT_ICON: dict[str, str] = {
     "red": "[red]rouge[/red]",
     "rate_limit": "[yellow]limite/429[/yellow]",
     "timeout": "[yellow]timeout[/yellow]",
+    # « acceptance inexécutable » (issue #428) : un `--check` n'a rendu aucun
+    # verdict exploitable (binaire absent, pytest 5/4, erreur d'import) — la
+    # cascade s'est arrêtée net, jamais un vert.
+    "unrunnable": "[red]acceptance inexécutable[/red]",
 }
 
 
@@ -757,6 +761,8 @@ def _emit_dispatch(ctx: typer.Context, report: Any) -> None:
             console.print(f"[yellow]![/yellow] transition non appliquée : {report.transition_refused}")
         if report.review is not None:
             _print_review(report.review, [str(p) for p in report.review_files], report.review_note)
+    elif report.unrunnable is not None:
+        console.print(f"[red]✗[/red] {report.task_id} — acceptance inexécutable : {escape(report.unrunnable)}")
     else:
         console.print(
             f"[red]✗[/red] {report.task_id} — chaîne épuisée, {len(report.attempts)} tentative(s), aucun vert"

grimoire_kit-3.45.0/src/grimoire/flows/blueprint_loader.py

@@ -0,0 +1,290 @@
+"""Dérive un ordre d'exécution et des contrats de node depuis un blueprint.
+
+Un blueprint ne porte pas d'ordre d'exécution explicite — seulement des
+``edges`` reliant des pins. Le tri topologique ci-dessous (porté depuis le
+prototype jetable de la première étape de #204, une fois vérifié sur
+``web-pipeline.blueprint.json``) le rend explicite une bonne fois, pour que le
+moteur n'ait pas à le redériver à chaque lecture d'un chemin différent.
+
+Le blueprint chargé ici est le même fichier que ``grimoire blueprint compile``
+accepte : ``validate_blueprint_file`` (contrôle structurel léger) est la seule
+vérification que ce module impose. Les contrôles d'état projet de ``compile``
+(extensions installées, artefacts résolus) ne s'appliquent pas : exécuter un
+node ne compile rien, c'est l'hôte qui l'exécute.
+"""
+
+from __future__ import annotations
+
+import shlex
+from pathlib import Path
+from typing import Any
+
+from grimoire.core.exceptions import GrimoireRuntimeError
+from grimoire.flows.schemas import AcceptanceEvidence, AcceptanceRun, NodeContract, PinRef
+from grimoire.missions.verifiability import Verifiability, classify_criteria
+from grimoire.tools.ext_manager import validate_blueprint_file
+
+__all__ = ["build_node_contracts", "load_blueprint", "topo_order"]
+
+#: Les seules clés qu'une entrée d'``acceptance`` structurée reconnaît (issue
+#: #428). Une entrée doit en porter exactement une : ni zéro (forme inconnue),
+#: ni deux ou plus (ambiguïté sur ce qu'il faut exécuter) — les deux sont un
+#: refus nommé au chargement, jamais une garde qui échouerait ouvert.
+_ACCEPTANCE_STRUCTURED_KEYS = ("run", "path_exists", "test")
+
+
+def load_blueprint(path: Path) -> dict[str, Any]:
+    """Charge et valide structurellement un ``.blueprint.json``.
+
+    Lève :class:`GrimoireRuntimeError` (pas ``ExtensionError`` du sous-module
+    ``tools`` : côté flows, une erreur de blueprint est une erreur de moteur,
+    pas une erreur d'extension) en nommant chaque défaut trouvé.
+    """
+    from grimoire.tools.ext_manager import ExtensionError
+
+    try:
+        blueprint, errors = validate_blueprint_file(path)
+    except ExtensionError as exc:
+        raise GrimoireRuntimeError(str(exc)) from exc
+    if errors:
+        raise GrimoireRuntimeError(f"{path} : blueprint invalide — " + "; ".join(errors))
+    return blueprint
+
+
+def topo_order(blueprint: dict[str, Any]) -> list[str]:
+    """Ordre d'exécution des nodes, dérivé des ``edges`` (Kahn, déterministe).
+
+    Déterministe : à dépendances égales, les nodes prêts sont pris dans
+    l'ordre alphabétique de leur id, pas dans l'ordre d'apparition dans le
+    fichier — deux lectures du même blueprint rendent le même ordre.
+    """
+    nodes = [n["id"] for n in blueprint["nodes"]]
+    node_by_pin: dict[str, str] = {}
+    for n in blueprint["nodes"]:
+        for p in n.get("pins", []):
+            node_by_pin[f"{n['id']}.{p['id']}"] = n["id"]
+    deps: dict[str, set[str]] = {nid: set() for nid in nodes}
+    for e in blueprint.get("edges", []):
+        src = node_by_pin.get(e["from"])
+        dst = node_by_pin.get(e["to"])
+        if src is None or dst is None:
+            raise GrimoireRuntimeError(f"edge non résoluble : {e['from']} -> {e['to']}")
+        deps[dst].add(src)
+    order: list[str] = []
+    remaining = set(nodes)
+    while remaining:
+        ready = sorted(n for n in remaining if deps[n] <= set(order))
+        if not ready:
+            raise GrimoireRuntimeError(f"cycle ou dépendance non résolue dans le blueprint : {sorted(remaining)}")
+        order.extend(ready)
+        remaining -= set(ready)
+    return order
+
+
+def _tool_boundary(node: dict[str, Any]) -> tuple[str, ...]:
+    """La frontière d'outils d'un node : ce qu'il touche hors du raisonnement.
+
+    Un ``extension-node`` délègue à un service tiers (CrewAI, LangGraph...) :
+    sa ``ref`` EST la frontière. Un ``pattern`` en rôle ``Gate`` porte
+    ``config.gate`` (mode + params) : c'est une frontière de contrôle, pas
+    d'exécution, mais l'hôte doit savoir qu'un gate le regarde. Tout le reste
+    (patterns de raisonnement pur, artefacts, composites) n'a pas de
+    frontière déclarée en v1 — un tuple vide dit explicitement "aucune".
+    """
+    if node.get("kind") == "extension-node":
+        return (node.get("ref", ""),)
+    gate = (node.get("config") or {}).get("gate")
+    if isinstance(gate, dict):
+        mode = gate.get("mode", "?")
+        params = gate.get("params") or {}
+        checks = params.get("checks")
+        if checks:
+            return (f"gate:{mode}(checks={','.join(checks)})",)
+        server = params.get("server")
+        if server:
+            return (f"gate:{mode}(server={server})",)
+        return (f"gate:{mode}",)
+    return ()
+
+
+def _parse_acceptance_entry(
+    node_id: str, entry: Any
+) -> tuple[str, AcceptanceRun | None, AcceptanceEvidence | None]:
+    """Une entrée d'``acceptance`` : texte libre (inchangé), ou forme structurée (issue #428).
+
+    Rend ``(texte, run, evidence)`` — ``texte`` alimente toujours
+    ``NodeContract.acceptance`` (donc ``verifiability.classify``), qu'il
+    vienne de la prose de l'auteur ou soit dérivé d'une commande ; ``run``/
+    ``evidence`` (au plus un des deux) alimentent le gate qui l'exécute
+    réellement (``flows.dispatch_executor``).
+
+    Une forme structurée reconnaît exactement une clé parmi ``run``,
+    ``path_exists``, ``test`` — zéro ou plusieurs est un refus nommé au
+    chargement (:class:`GrimoireRuntimeError`), jamais une garde silencieuse :
+    « aucune inférence de commande à partir de la prose » est un refus
+    explicite de l'issue, une forme ambiguë ne doit pas se comporter comme si
+    elle en désignait une par accident.
+    """
+    if isinstance(entry, str):
+        text = entry.strip()
+        return (text, None, None) if text else ("", None, None)
+    if not isinstance(entry, dict):
+        raise GrimoireRuntimeError(
+            f"node={node_id} : acceptance de forme inconnue ({entry!r}) — attendu une chaîne ou un objet "
+            "{'run': ...} / {'path_exists': ...} / {'test': ...}"
+        )
+    present = [k for k in _ACCEPTANCE_STRUCTURED_KEYS if k in entry]
+    if len(present) != 1:
+        raise GrimoireRuntimeError(
+            f"node={node_id} : acceptance structurée invalide {entry!r} — attendu exactement une clé parmi "
+            f"{_ACCEPTANCE_STRUCTURED_KEYS}, trouvé {present or 'aucune'}"
+        )
+    key = present[0]
+    if key == "run":
+        raw = str(entry["run"]).strip()
+        if not raw:
+            raise GrimoireRuntimeError(f"node={node_id} : acceptance.run vide")
+        try:
+            argv = tuple(shlex.split(raw))
+        except ValueError as exc:
+            raise GrimoireRuntimeError(f"node={node_id} : acceptance.run illisible ({exc})") from exc
+        if not argv:
+            raise GrimoireRuntimeError(f"node={node_id} : acceptance.run vide après découpage")
+        expect_exit = entry.get("expect_exit", 0)
+        if not isinstance(expect_exit, int) or isinstance(expect_exit, bool):
+            raise GrimoireRuntimeError(f"node={node_id} : acceptance.expect_exit doit être un entier")
+        cwd = entry.get("cwd", ".")
+        if not isinstance(cwd, str) or not cwd.strip():
+            raise GrimoireRuntimeError(f"node={node_id} : acceptance.cwd doit être une chaîne non vide")
+        timeout_s = entry.get("timeout_s", 120.0)
+        if isinstance(timeout_s, bool) or not isinstance(timeout_s, (int, float)) or timeout_s <= 0:
+            raise GrimoireRuntimeError(f"node={node_id} : acceptance.timeout_s doit être un nombre positif")
+        expect_stdout_contains = entry.get("expect_stdout_contains")
+        if expect_stdout_contains is not None and not isinstance(expect_stdout_contains, str):
+            raise GrimoireRuntimeError(f"node={node_id} : acceptance.expect_stdout_contains doit être une chaîne")
+        run = AcceptanceRun(
+            argv=argv,
+            raw=raw,
+            expect_exit=expect_exit,
+            cwd=cwd,
+            timeout_s=float(timeout_s),
+            expect_stdout_contains=expect_stdout_contains,
+        )
+        text = f"la commande « {raw} » retourne le code de sortie {expect_exit} (acceptance exécutée)"
+        return text, run, None
+    if key == "path_exists":
+        value = str(entry["path_exists"]).strip()
+        if not value:
+            raise GrimoireRuntimeError(f"node={node_id} : acceptance.path_exists vide")
+        text = f"le fichier « {value} » existe (acceptance exécutée)"
+        return text, None, AcceptanceEvidence(kind="path_exists", value=value)
+    value = str(entry["test"]).strip()
+    if not value:
+        raise GrimoireRuntimeError(f"node={node_id} : acceptance.test vide")
+    text = f"le test « {value} » passe (suite de tests, acceptance exécutée)"
+    return text, None, AcceptanceEvidence(kind="test", value=value)
+
+
+def _acceptance(
+    node: dict[str, Any], outputs: tuple[PinRef, ...]
+) -> tuple[tuple[str, ...], tuple[AcceptanceRun, ...], tuple[AcceptanceEvidence, ...]]:
+    """Critères d'acceptation : ``node.acceptance``, sinon les evals, sinon les pins.
+
+    Trois sources, dans cet ordre de préférence :
+
+    - ``node.acceptance`` — texte libre écrit par l'auteur du blueprint, ou
+      (issue #428) une forme structurée exécutable, ou un mélange des deux
+      dans la même liste. C'est la seule source qu'une classe de
+      vérifiabilité (#309) peut vraiment lire : ``sortie conforme au contrat
+      « c1 »`` ou ``verdict attendu : ...`` ne nomment ni verdict mécanique
+      reconnu ni revue, et tombent donc toujours ambigus. Un node qui veut
+      être dispatchable par cascade (#311) doit décrire son critère avec ce
+      vocabulaire-là : ``la suite de tests passe`` (V0), ``revue humaine
+      avant fusion`` (V1) — ou, désormais, déclarer directement la commande
+      qui rend ce verdict.
+    - ``config.evals`` — les cas ``assert`` (P1.2, rejoués par ``grimoire
+      blueprint evals``), s'il n'y a pas d'``acceptance`` explicite.
+    - À défaut des deux, un critère dérivé des pins de sortie : la
+      conformité au contrat est le plancher, jamais rien.
+
+    Une forme structurée invalide (clé inconnue, plusieurs clés, type
+    incorrect) lève :class:`GrimoireRuntimeError` en nommant le node — un
+    schéma refusé au chargement, pas un gate qui échouerait ouvert plus tard.
+    """
+    explicit = node.get("acceptance")
+    if isinstance(explicit, list) and explicit:
+        texts: list[str] = []
+        runs: list[AcceptanceRun] = []
+        evidence: list[AcceptanceEvidence] = []
+        for entry in explicit:
+            text, run, ev = _parse_acceptance_entry(node["id"], entry)
+            if text:
+                texts.append(text)
+            if run is not None:
+                runs.append(run)
+            if ev is not None:
+                evidence.append(ev)
+        return tuple(texts), tuple(runs), tuple(evidence)
+    evals = (node.get("config") or {}).get("evals")
+    criteria: list[str] = []
+    if isinstance(evals, dict):
+        for case in evals.get("cases", []):
+            for assertion in case.get("assert", []):
+                kind = assertion.get("kind")
+                if kind == "contract":
+                    criteria.append(f"sortie conforme au contrat « {assertion.get('contract')} »")
+                elif kind == "no-refusal":
+                    criteria.append("aucun refus du modèle")
+                elif kind == "cost":
+                    criteria.append(f"coût ≤ {assertion.get('maxTokens')} tokens")
+                elif kind == "verdict":
+                    criteria.append(f"verdict attendu : {assertion.get('expected')}")
+    if not criteria:
+        criteria = [f"sortie du pin « {p.pin_id} » conforme au contrat « {p.contract} »" for p in outputs]
+    return tuple(criteria), (), ()
+
+
+def _verifiability_warning(node_id: str, acceptance_texts: tuple[str, ...], *, has_structured: bool) -> str | None:
+    """« nœud V0 sans acceptance exécutable » — posé au chargement, jamais au gate (issue #428, suite).
+
+    Un nœud dont le texte seul classe V0 (#309) mais qui ne déclare aucune
+    commande exécutable est le fossé exact que le rejeu du 2026-09-11 a payé :
+    l'auteur du blueprint a écrit un vocabulaire mécanique (« la suite de
+    tests passe ») sans jamais donner au gate de quoi le vérifier — sans ce
+    garde-fou, ``flows.dispatch_executor`` n'aurait toujours que le check
+    d'enveloppe à faire tourner. La règle du kit (« un faux V0 est pire qu'un
+    faux V2 », ``verifiability.py``) s'applique à l'identique ici : ce nœud
+    est traité comme V1 par l'exécuteur de dispatch (jamais fermé sur la
+    seule foi de l'ouvrier), et ce message nommé en dit la raison plutôt que
+    de rétrograder en silence.
+    """
+    if has_structured:
+        return None
+    if classify_criteria(acceptance_texts) is not Verifiability.V0:
+        return None
+    return f"nœud {node_id} classé V0 sans acceptance exécutable : traité comme V1"
+
+
+def build_node_contracts(blueprint: dict[str, Any]) -> dict[str, NodeContract]:
+    """Un :class:`NodeContract` par node du blueprint, indexé par id."""
+    contracts: dict[str, NodeContract] = {}
+    for node in blueprint["nodes"]:
+        pins = node.get("pins", [])
+        inputs = tuple(PinRef(p["id"], p["contract"]) for p in pins if p.get("direction") == "in")
+        outputs = tuple(PinRef(p["id"], p["contract"]) for p in pins if p.get("direction") == "out")
+        acceptance_texts, acceptance_runs, acceptance_evidence = _acceptance(node, outputs)
+        has_structured = bool(acceptance_runs or acceptance_evidence)
+        contracts[node["id"]] = NodeContract(
+            node_id=node["id"],
+            kind=node.get("kind", ""),
+            label=node.get("label", ""),
+            description=node.get("description", ""),
+            inputs=inputs,
+            outputs=outputs,
+            tool_boundary=_tool_boundary(node),
+            acceptance=acceptance_texts,
+            acceptance_runs=acceptance_runs,
+            acceptance_evidence=acceptance_evidence,
+            verifiability_warning=_verifiability_warning(node["id"], acceptance_texts, has_structured=has_structured),
+        )
+    return contracts