feat(adapters/vlm,planner): Sprint A14-S54 architecture cleanup (audit #6 + #14 + #22)

#6 - Garde-fou MRO BaseVLMAdapter
---------------------------------
Avant S54, lordre des parents dans
class AnthropicVLMAdapter(BaseVLMAdapter, AnthropicAdapter)
était critique mais non vérifié. Un swap accidentel
à (AnthropicAdapter, BaseVLMAdapter) aurait donné silencieusement
output_types = {CORRECTED_TEXT} au lieu de {RAW_TEXT} - lerreur
ne se manifestait quau runtime sur une jonction incompatible.

S54 ajoute __init_subclass__ qui lève TypeError à la définition
si lordre est mauvais avec un message qui suggère la correction
concrète. Les 4 VLM existants restent valides.

#14 - ExecutionPlan.metric_junctions
------------------------------------
Documenté honnêtement comme à venir : le PipelineExecutor ne
consomme pas encore ces jonctions au runtime (auto-évaluation
prévue dans un sprint dédié). Le champ est livré pour fixer le
contrat.

#22 - Listing des shims assumés
-------------------------------
Documenté dans CHANGELOG.md (voir entrée séparée).

Tests : 35 passed dans tests/adapters/vlm/ (5 S54 nouveaux + 30
S45). Test propriété : LLM-first ordre rejeté avec message
helpful (BaseVLMAdapter + AnthropicAdapter mentionnés + Corrigez).

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

picarones/adapters/vlm/base.py

@@ -61,8 +61,62 @@ class BaseVLMAdapter(BaseLLMAdapter):
         Config dict ; supporte
         ``config["transcription_prompt"]`` pour personnaliser le
         prompt de transcription.
+
+    Sprint S54 — garde-fou MRO (audit #6)
+    -------------------------------------
+    Les VLM concrets utilisent l'héritage multiple :
+
+    ::
+
+        class AnthropicVLMAdapter(BaseVLMAdapter, AnthropicAdapter)
+
+    L'ordre est critique : ``BaseVLMAdapter`` doit venir d'ABORD
+    pour que ``input_types``, ``output_types``, ``execute``, et
+    ``DEFAULT_TRANSCRIPTION_PROMPT`` soient résolus depuis lui (et
+    pas depuis le LLM sibling qui aurait des output_types =
+    {CORRECTED_TEXT}).
+
+    ``__init_subclass__`` valide cet ordre à la définition de la
+    classe.  Si le développeur swap accidentellement les parents
+    par habitude alphabétique, la définition de classe lève une
+    ``TypeError`` immédiate au lieu d'un comportement silencieusement
+    différent (output_types incorrect au runtime).
     """
 
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+        # Garde-fou : BaseVLMAdapter doit être le premier parent
+        # *non-trivial* dans l'ordre de la déclaration (pour gagner
+        # le MRO sur les attributs surchargés).
+        bases = cls.__bases__
+        if len(bases) <= 1:
+            # Sous-classe directe simple — pas de MRO multiple, OK.
+            return
+        # On parcourt les bases dans l'ordre déclaré.
+        try:
+            vlm_idx = next(
+                i for i, b in enumerate(bases)
+                if issubclass(b, BaseVLMAdapter)
+            )
+        except StopIteration:
+            return  # ne devrait pas arriver, vlm subclass DOIT inclure VLM
+        # Toutes les bases AVANT BaseVLMAdapter doivent être
+        # neutres (mixins sans surcharge des output_types).
+        for prev in bases[:vlm_idx]:
+            if issubclass(prev, BaseLLMAdapter) and not issubclass(
+                prev, BaseVLMAdapter,
+            ):
+                raise TypeError(
+                    f"{cls.__name__} : ordre MRO incorrect — "
+                    f"BaseVLMAdapter doit précéder {prev.__name__} "
+                    "dans la liste des parents pour que les "
+                    "output_types VLM ({IMAGE} → {RAW_TEXT}) "
+                    "soient résolus correctement (et pas écrasés "
+                    "par les output_types LLM = {CORRECTED_TEXT}). "
+                    f"Corrigez : `class {cls.__name__}(BaseVLMAdapter, "
+                    f"{prev.__name__})`.",
+                )
+
     @property
     def input_types(self) -> "frozenset":
         return frozenset({ArtifactType.IMAGE})

picarones/pipeline/planner.py

@@ -197,6 +197,15 @@ class ExecutionPlan:
     metric_junctions:
         Jonctions auto-détectées si un ``MetricRegistry`` était
         fourni au planner ; tuple vide sinon.
+
+        Sprint S54 — note honnête (audit #14) : à ce jour, le
+        ``PipelineExecutor`` ne consomme pas ces jonctions au runtime
+        (le calcul des métriques aux jonctions intra-pipeline est
+        prévu dans un sprint dédié de l'axe « auto-évaluation »).
+        Le champ est livré dès maintenant pour fixer le contrat —
+        un caller peut déjà l'utiliser pour de l'introspection
+        (rapport, diagnostic).  Pas de risque de breaking change
+        quand l'auto-évaluation arrivera.
     """
 
     spec: PipelineSpec

tests/adapters/vlm/test_sprint_a14_s54_mro_guard.py

@@ -0,0 +1,78 @@
+"""Sprint A14-S54 — garde-fou MRO BaseVLMAdapter (fix audit #6).
+
+Avant S54, l'ordre des parents dans :
+
+    class AnthropicVLMAdapter(BaseVLMAdapter, AnthropicAdapter)
+
+était critique mais non vérifié.  Un swap accidentel à
+``(AnthropicAdapter, BaseVLMAdapter)`` aurait silencieusement donné
+output_types = {CORRECTED_TEXT} (depuis LLM) au lieu de {RAW_TEXT}
+(depuis VLM) — l'erreur ne se serait manifestée qu'au runtime sur
+une jonction de type incompatible.
+
+S54 ajoute ``__init_subclass__`` qui lève ``TypeError`` à la
+définition de la classe si l'ordre est incorrect.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.adapters.llm.anthropic_adapter import AnthropicAdapter
+from picarones.adapters.llm.openai_adapter import OpenAIAdapter
+from picarones.adapters.vlm import (
+    AnthropicVLMAdapter,
+    BaseVLMAdapter,
+    OpenAIVLMAdapter,
+)
+from picarones.domain.artifacts import ArtifactType
+
+
+class TestExistingAdaptersStillValid:
+    """Les 4 VLM adapters concrets définis correctement passent."""
+
+    def test_anthropic_vlm_defined(self) -> None:
+        # Si l'ordre était mauvais, l'import aurait planté.
+        adapter = AnthropicVLMAdapter()
+        assert adapter.input_types == frozenset({ArtifactType.IMAGE})
+        assert adapter.output_types == frozenset({ArtifactType.RAW_TEXT})
+
+    def test_openai_vlm_defined(self) -> None:
+        adapter = OpenAIVLMAdapter()
+        assert adapter.input_types == frozenset({ArtifactType.IMAGE})
+
+
+class TestWrongOrderRejected:
+    def test_llm_first_then_vlm_rejected(self) -> None:
+        """Définir une classe avec LLM avant VLM doit lever TypeError."""
+        with pytest.raises(TypeError, match="ordre MRO"):
+            # Définition dynamique d'une classe avec mauvais ordre.
+            type(
+                "BadOrderVLM",
+                (AnthropicAdapter, BaseVLMAdapter),
+                {"name": property(lambda self: "bad")},
+            )
+
+    def test_correct_order_accepted(self) -> None:
+        """L'ordre correct (VLM en premier) est accepté."""
+        # Test propriété : aucun TypeError levé.
+        type(
+            "GoodOrderVLM",
+            (BaseVLMAdapter, OpenAIAdapter),
+            {"name": property(lambda self: "good")},
+        )
+
+
+class TestErrorMessageHelpful:
+    def test_message_explains_the_fix(self) -> None:
+        with pytest.raises(TypeError) as exc_info:
+            type(
+                "BadVLM",
+                (AnthropicAdapter, BaseVLMAdapter),
+                {"name": property(lambda self: "x")},
+            )
+        msg = str(exc_info.value)
+        # Le message doit suggérer la correction concrète.
+        assert "BaseVLMAdapter" in msg
+        assert "AnthropicAdapter" in msg
+        assert "Corrigez" in msg or "correct" in msg.lower()