Passation lot 5 : clore la famille D24 (fenêtre workflow, garde requêtes, champ tool)

Deux mesures nouvelles du 25/08/2026 aggravent le dossier : une requête Reading ordinaire query_wms_entities(Products, limit 200) pèse 957 234 caractères et search_wms_data(PAL) 847 543 — le dépassement du seuil de rejet client (~70 000, D24) ne se limite donc pas au Writing ni aux workflows. Les points ouverts correspondants deviennent un lot 5 planifié dans la ROADMAP (L5.1 fenêtre verbatim sur le blob data, L5.2 garde de taille commune aux trois outils de requête avec le cas limite d'une ligne seule au-dessus du plafond, L5.3 balayage du champ tool). Pas de nouveau numéro de décision : le lot étend D24. D27 réservable si besoin. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Révision lot 4 : validé ; ligne Writing énorme et champ tool absent consignés
2026-08-25 11:57:39 +02:00 · 2026-08-25 11:46:50 +02:00 · 2026-08-25 11:24:12 +02:00 · 2026-08-25 11:17:10 +02:00 · 2026-08-25 11:16:17 +02:00 · 2026-08-25 11:12:14 +02:00
14 changed files with 827 additions and 390 deletions
@@ -170,13 +170,18 @@ disponibles : c'est ainsi que Claude sait appeler `switch_wms_profile`.

 ## Caches

-Deux caches, TTL commun `WORKFLOW_CACHE_TTL` (3 600 000 ms), chargement
-paresseux, vidés à chaque bascule de profil (D10).
+TTL commun `WORKFLOW_CACHE_TTL` (3 600 000 ms), chargement paresseux, vidés à
+chaque bascule de profil (D10). Les outils AD et workflow acceptent un
+paramètre **`application`** (défaut : l'application du profil) — les clés de
+cache incluent l'application pour éviter toute pollution croisée (D26).

 | Cache | Granularité | Pagination |
 |---|---|---|
-| `workflow-service` | global (~3 700 workflows) | `WORKFLOW_PAGE_SIZE`, 5000 |
-| `ad-service` | **un par type** (20 types) | `AD_ELEMENT_TYPES` : `View` 200, `Workflow` 5000, `Resource` 15000, autres 100000 |
+| `workflow-service` | **un par application** (~4 000 EasyWMS, 153 CustomApp) + liste allégée d'`Application/GetAll` | `WORKFLOW_PAGE_SIZE`, 5000 |
+| `ad-service` | **un par (application, type)** (20 types) | `AD_ELEMENT_TYPES` : `View` 200, `Workflow` 5000, `Resource` 15000, autres 100000 |
+
+**Ne préchargez jamais les 9 applications** : seule l'application demandée est
+chargée (D26).

 Les tailles de page par type viennent de l'observation des timeouts serveur —
 ne les augmentez pas à l'aveugle.
@@ -205,8 +210,10 @@ la plus fréquente :

 Autres règles :

- **`QueryType: 0` (Reading)**, jamais 1 : les statuts sont alors des chaînes
-  (D3).
+- **`QueryType: 0` (Reading) par défaut** : les statuts sont alors des chaînes
+  (D3). La bascule vers Writing/Metrics passe par le paramètre `query_type`
+  des outils de requête — un opt-in documenté (D25), jamais un défaut : ne
+  recopiez aucun exemple en `QueryType: 1`.
 - **Pas de date relative.** `DateTime.Now`, `DateTime.Today`, `AddDays()` ne
  sont pas traduisibles : écrire `new DateTime(2026, 8, 1)` (D12).
 - **`select_expression` est instable** : les projections via le paramètre
@@ -233,11 +240,13 @@ pluriel), `Tasks`, `Stocks`, `ProductLocations`, `InboundOrders`, `Receptions`,
 confondues) s'obtient par `get_entity_metadata` (API Metadata) — le catalogue
 de la resource `wms://entities` est un raccourci de confort, pas la référence.

-**Application Dictionary** : 20 types, ~38 800 éléments. `Resource` (29 374) est
-de loin le plus lourd ; 3 types sont valides mais vides (`Dashboard`,
-`TimelineTemplate`, `Toggle`). `WorkflowAction` et `WritingModel` ont été
-retirés — 404 (D17). Détail :
-[docs/ad-api-validation.md](docs/ad-api-validation.md).
+**Application Dictionary** : 20 types, ~38 800 éléments (sur `EasyWMS`).
+`Resource` (29 374) est de loin le plus lourd ; 3 types sont valides mais vides
+(`Dashboard`, `TimelineTemplate`, `Toggle`). `WorkflowAction` et `WritingModel`
+ont été retirés — 404 (D17). Détail :
+[docs/ad-api-validation.md](docs/ad-api-validation.md). 9 applications AD sont
+déclarées ; **`CustomApp` porte le spécifique client** (workflows `CST_*`) et
+s'interroge via le paramètre `application` des outils AD et workflow (D26).

 **Paramètres système** : pas d'entité `CommandParameterData`. La configuration
 se lit dans `Parameter` (+ `DefaultValue`) et `ParamValue` (surcharges par
@@ -480,3 +480,91 @@ Deux garde-fous de cadrage :
 Au passage, `totalParameters` a changé de sens : c'était le nombre brut
 d'entités `Parameter` chargées, c'est désormais le total correspondant aux
 filtres avant pagination (identique sans filtre).
+
+---
+
+## D25 — `query_type` : opt-in explicite, D3 reste la règle par défaut
+
+**Contexte (mesures des 24-25/08/2026, `LIMAGRAI2512`).** `QueryType` était
+figé à `0` en dur dans `executeQuery()` et `executeScalarQuery()`, rendant le
+modèle Writing — opérationnel et mesuré (`Context.Products` en `QueryType: 1`
+répond) — inatteignable.
+
+**Décision.** Un paramètre `query_type` (entier, défaut `0`) est exposé sur
+**trois outils** : `call_query_api`, `query_wms_entities`,
+`count_wms_entities`. `get_entity_schema` et `search_wms_data` restent des
+raccourcis Reading, sans paramètre.
+
+**Rapport à D3.** D3 n'est pas révisée : le Reading reste la règle par défaut,
+car en Writing les statuts sont des **énumérations** — les comparaisons de
+chaînes (`== "Release"`), cas le plus courant en debug, y échouent. La bascule
+est un opt-in explicite et les descriptions d'outils portent l'avertissement.
+
+Modalités :
+
+- **Garde de valeur dans le code de l'outil**, pas dans le wrapper : D23 valide
+  les noms de paramètres, pas les valeurs. Hors `0..3` (ou non entier) →
+  erreur locale via `assertValidQueryType()` (`wms-query-service.js`), **avant
+  tout appel réseau**, nommant les quatre contextes.
+- **`2` et `3` sont transmis tels quels** : le WMS répond et son diagnostic
+  remonte entier (L1.1). Sur `LIMAGRAI2512` : `2` = DataWarehouse non configuré
+  (`Could not resolve serviceType 'IDataWarehouse…'`), `3` = Metrics, contexte
+  présent mais modèle distinct (`'ApplicationMetricDataContext' ne contient pas
+  de définition pour 'Products'`).
+- **Interaction avec le resolver (D21)** : la table de résolution est
+  construite sur le Metadata **Reading**. Quand `query_type != 0`, un nom qui
+  se résout se résout normalement (`Products` marche en Writing, mesuré) ; un
+  nom **inconnu** du Reading n'est **pas** bloqué — il passe tel quel avec un
+  `warning` dans la réponse (`allowUnknown` du resolver, même mécanique que le
+  repli « Metadata injoignable »), car le modèle Writing/Metrics peut contenir
+  des entités hors Reading. Le `warning` est conservé aussi dans la réponse
+  d'erreur si le WMS échoue ensuite.
+
+---
+
+## D26 — Paramètre `application` : caches par application, chargement toujours paresseux
+
+**Contexte (mesures des 24-25/08/2026, `LIMAGRAI2512`).** L'application
+interrogée venait de `WMS_APPLICATION` (partagée par tous les profils) : le MCP
+ne voyait que `EasyWMS`. Or `POST /AD/api/Application/GetAll` déclare **9
+applications**, et **CustomApp porte le spécifique client** (153 workflows
+`CST_*` sur ce tenant) — précisément ce qu'on cherche en debug. Les 11 entités
+`CustomApp` ne sont requêtables dans aucun contexte : l'API AD est le seul
+accès au spécifique client.
+
+**Décision.** Un paramètre `application` (défaut : l'application du profil,
+donc comportement strictement inchangé sans lui) sur six outils :
+`get_ad_elements`, `search_ad_elements`, `get_ad_element_details`,
+`search_workflows`, `get_workflow_details`, `list_workflow_categories`.
+
+**Contrat de cache.**
+
+| Service | Clé avant | Clé après |
+|---|---|---|
+| `ad-service` | un cache par type | un cache par **(application, type)** (`app::type`) |
+| `workflow-service` | un cache global | un cache par **application** |
+
+Sans ces clés, un appel CustomApp polluerait le cache EasyWMS du même type.
+Règles associées :
+
+- **L'invalidation reste l'abonnement `onSwitch()`** (D8) : la bascule de
+  profil vide **tous** les caches, toutes applications confondues. Aucune
+  invalidation manuelle inter-module.
+- **Pas de préchargement des 9 applications** (D10) : seule l'application
+  effectivement demandée est chargée — le type `Resource` pèse 29 374 éléments
+  sur la seule EasyWMS.
+- `workflow-service` cache aussi la liste de `Application/GetAll`, **allégée**
+  (`name`, `id`, `version`) : chaque élément de la réponse brute embarque un
+  blob `data` de ~100 Ko (la définition EasyBuilder complète) qu'on ne
+  conserve pas.
+- `list_workflow_categories` est adossé à `Application/GetAll` (les 9
+  applications) et non plus aux `applicationName` du seul cache actif. La note
+  de L1.3 reste vraie — pas de champ catégorie ; les comptes de workflows ne
+  sont affichés que pour les applications déjà chargées (paresseux). Le
+  paramètre `category` de `search_workflows` (filtre sur `applicationName`)
+  subsiste : `application` choisit le jeu chargé, `category` filtre dedans —
+  leur articulation est documentée dans les descriptions.
+- `get_application_summary` regroupe l'état par application puis par type et
+  ne détaille que les entrées **effectivement en cache** : la sortie reste
+  bornée quel que soit le nombre d'applications interrogées (D24). Il expose
+  aussi les caches de workflows par application.
@@ -17,77 +17,13 @@ contient que ce qui reste à faire.
 Deux angles morts constatés le 24/08/2026, plus larges que les lots 2 et 3. Les
 chiffres ci-dessous sont mesurés sur le tenant `LIMAGRAI2512`.

-### L4.1 — Le modèle Writing est inatteignable
+### L4.1 (reliquat) — Explorer le contexte Metrics

-`QueryType` est figé à `0` (Reading) en dur dans `api-service.js`
-(`executeQuery` et `executeScalarQuery`). Or `QueryContextType` a **quatre**
-valeurs. Testées une à une :
-
-| Valeur | Contexte | Résultat sur `LIMAGRAI2512` |
-|---|---|---|
-| `0` | Reading | opérationnel (seul utilisé aujourd'hui) |
-| `1` | Writing | **opérationnel** — `Context.Products` répond |
-| `2` | DataWarehouse | **non configuré** : `Could not resolve serviceType 'IDataWarehouse…'` |
-| `3` | Metrics | contexte présent (`ApplicationMetricDataContext`), modèle non exploré |
-
-Exposer `query_type` sur les outils de requête, défaut `0`. Attention : D3 reste
-vrai — en Writing les champs de statut sont des **énumérations**, donc
-`== "Release"` échoue. La bascule doit être un choix explicite et documenté.
-
-Le contexte `Metrics` mérite une exploration à part : c'est probablement là que
-vivent les données agrégées produites par les jobs `MetricGatherer`.
-
-### L4.2 — Une seule application sur neuf est visible
-
-`Application` vient de `WMS_APPLICATION` dans `.env`, **partagé par tous les
-profils**, sans surcharge par appel ni paramètre d'outil. Le MCP n'interroge donc
-jamais que `EasyWMS`.
-
-`POST /AD/api/Application/GetAll` en déclare **9** :
-
-| Application | Workflows | Queries | Entities |
-|---|---:|---:|---:|
-| EasyWMS | 4012 | 2239 | 338 |
-| **CustomApp** | **153** | **54** | **11** |
-| AGV | 71 | 14 | 5 |
-| Notifications | 26 | 35 | 24 |
-| GalileoFaults | 9 | 20 | 24 |
-| Common | 1 | 7 | 25 |
-| SmartUI, User, WarehouseWebDesigner | 0 | 0–8 | 0 |
-
-**CustomApp porte le spécifique client** — ses workflows sont préfixés `CST_`
-(`CST_SendRejectContainersToPK`, `CST_Task`, `CST_Container`…). C'est
-précisément ce qu'on cherche en debug, et c'est aujourd'hui invisible. Au total
-**260 workflows et ~130 queries** hors périmètre.
-
-Deux chantiers de difficulté très différentes :
-
-**API AD — simple.** L'application est un champ du payload
-(`[application, tenant, pageSize, offset]`). Vérifié : `["CustomApp", tenant,
-5, 0]` sur `/Workflow/GetByApplication` renvoie bien les workflows `CST_`. Il
-suffit d'un paramètre `application` sur les outils AD et workflow, avec une clé
-de cache incluant l'application (sinon un cache pollué mélange les
-applications).
-
-**QueryExecute — tranché : le champ `Application` ne partitionne rien.**
-`Context.AgvTasks` (entité de l'application AGV) répond aussi bien avec
-`Application: "AGV"` qu'avec `Application: "EasyWMS"`. Le contexte de lecture est
-**commun au tenant** : toutes les applications y déversent leurs entités.
-
-Conséquence — traitée : la table de résolution (D21) **agrège le Metadata de
-toutes les applications** déployées, et non le seul `EasyWMS`. Inutile en
-revanche d'ajouter un paramètre `application` à `QueryExecute` : il ne changerait
-rien.
-
-**Les entités `CustomApp` ne sont interrogeables dans aucun contexte.** Les 11
-entités `CST_` ont été testées sous les quatre `QueryType`, au singulier et au
-pluriel : échec partout, et `Metadata/Entities` comme `Metadata/EntitiesAll`
-renvoient **0 entité** pour `CustomApp`. Aucune n'est marquée
-`isDataWarehouse`. Ce sont des définitions EasyBuilder (`FromMetadata: false`)
-sans projection dans un contexte requêtable.
-
-**L'API AD reste donc le seul accès au spécifique client** — ce qui rend le
-paramètre `application` sur les outils AD et workflow d'autant plus utile.
+L'exposition de `query_type` est livrée (D25). Reste l'investigation : le
+contexte `Metrics` (`QueryType: 3`, `ApplicationMetricDataContext`) mérite une
+exploration à part — c'est probablement là que vivent les données agrégées
+produites par les jobs `MetricGatherer`. Livrable : un rapport, pas du code
+(même phase d'investigation que L4.4).

 ### L4.3 — Identifier le MCP dans les logs du WMS

@@ -148,6 +84,41 @@ plus riche que `/AD/api/Application/GetAll`), `GET /healthcheck?tenantCode=` et

 ---

+## Lot 5 — Clore la famille D24 (rejets client sur sorties volumineuses)
+
+Mesures du 25/08/2026 (protocole, LIMAGRAIN), toutes au-dessus du seuil de
+rejet client (~70 000 caractères, D24) :
+
+| Appel | Taille |
+|---|---:|
+| `query_wms_entities("Products", limit: 200)` — Reading ordinaire | **957 234** |
+| `search_wms_data("PAL")` | **847 543** |
+| `get_workflow_details(CST_SendRejectContainersToPK)` | ~101 800 |
+| `call_query_api("Products", query_type: 1, limit: 1)` — **une seule ligne** Writing | **95 288** |
+
+### L5.1 — Paginer le blob `data` de `get_workflow_details`
+
+La définition complète d'un workflow dépasse le seuil (~101 800 pour
+`CST_SendRejectContainersToPK`, 79 092 pour un `StackerCrane_…` EasyWMS).
+Découper le blob `data` en tranches verbatim (paramètres de fenêtre au schéma),
+signalées D24 — sans jamais résumer ni reformuler le contenu.
+
+### L5.2 — Garde de taille sur les outils de requête
+
+Une ligne Writing = un agrégat complet sérialisé (95 288 caractères là où la
+même ligne Reading en fait ~4 500) ; 200 lignes Reading = ~957 000 ; `search_wms_data`
+= ~848 000. Garde de taille commune sur `query_wms_entities`, `call_query_api`
+et `search_wms_data` : lignes entières écartées, `truncated`/`returned`/`omitted`/`hint`
+(D24). Ne pas réduire `MAX_QUERY_ROWS` ni les limites par défaut.
+
+### L5.3 — Champ `tool` absent des erreurs construites localement
+
+Les `catch` locaux d'`api-tools.js` renvoient `{ success: false, error }` sans
+le champ `tool` du contrat (convention 3) — antérieur au lot 4. Balayer tous
+les modules d'outils pour le même motif.
+
+---
+
 ## Écarté

 | Proposition | Raison |
@@ -0,0 +1,212 @@
+# Passation — lot 5 (clore la famille D24)
+
+Tu travailles sur `mcp-wms-api` : un serveur MCP (Node.js, CommonJS, stdio) qui
+donne à Claude un accès en lecture à un WMS EasyWMS (Mecalux) via ses API REST.
+Lis [../CLAUDE.md](../CLAUDE.md) et [../DECISIONS.md](../DECISIONS.md) —
+en particulier **D24**, le contrat de troncature que ce lot généralise — avant
+de toucher au code.
+
+**Mission** : éliminer les derniers cas connus de réponses d'outils dépassant
+le seuil de rejet des clients MCP (~70 000 caractères, D24) — lot 5 de
+[../ROADMAP.md](../ROADMAP.md) : pagination du blob `data` de
+`get_workflow_details` (L5.1), garde de taille sur les trois outils de requête
+(L5.2), champ `tool` manquant dans les enveloppes d'erreur locales (L5.3).
+
+**Hors périmètre** : tout le reste de la roadmap (L4.3, L4.4, L4.5,
+exploration Metrics). **`QueryExecuteStream` est explicitement interdit** —
+piste long terme consignée en L4.5, pas ce lot. Aucun nouvel outil : le compte
+reste à 23. Ne pousse rien (`git push` interdit), ne touche pas au `.env`,
+n'appelle jamais `execute_command` (il écrit dans le WMS).
+
+---
+
+## Contexte matériel
+
+- Profil de travail : `LIMAGRAIN` (par défaut), host `10.255.255.2`, tenant
+  `LIMAGRAI2512`.
+- **Le profil `AD` est cassé et c'est diagnostiqué — ne le réinvestigue pas**
+  (tenant introuvable côté STS, point ouvert de la ROADMAP). La baseline se
+  mesure avec `npm test` (profil par défaut), attendu **4/4, code de sortie 0**.
+- Baseline protocolaire à préserver : **23 outils**, **6 resources**, aucune
+  écriture sur stdout hors JSON-RPC.
+
+Handshake + comptages :
+
+```bash
+printf '%s\n%s\n%s\n%s\n' '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"t","version":"1"}}}' '{"jsonrpc":"2.0","method":"notifications/initialized"}' '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' '{"jsonrpc":"2.0","id":3,"method":"resources/list"}' | node src/index.js 2>/dev/null | node -e "let b='';process.stdin.on('data',d=>b+=d).on('end',()=>{for(const l of b.split('\n').filter(Boolean)){const m=JSON.parse(l);if(m.id===2)console.log('tools:',m.result.tools.length);if(m.id===3)console.log('resources:',m.result.resources.length);}});"
+```
+
+Mesurer la taille d'une réponse d'outil (la mesure qui fait foi est la
+longueur de `content[0].text` via le protocole) :
+
+```bash
+printf '%s\n%s\n%s\n' '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"t","version":"1"}}}' '{"jsonrpc":"2.0","method":"notifications/initialized"}' '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"NOM","arguments":{}}}' | node src/index.js 2>/dev/null | node -e "let b='';process.stdin.on('data',d=>b+=d).on('end',()=>{for(const l of b.split('\n').filter(Boolean)){const m=JSON.parse(l);if(m.id===2)console.log('chars:',m.result.content[0].text.length);}});"
+```
+
+## Contraintes non négociables
+
+1. `console.error()` uniquement (D6).
+2. Contrat d'erreur : `{ success: false, error, tool }`, `isError: true` —
+   c'est précisément l'objet de L5.3.
+3. Messages et hints actionnables.
+4. Aucun accès base de données (D1).
+5. **D23** : le wrapper valide les **noms** de paramètres et les requis contre
+   les schémas — tout paramètre ajouté (fenêtre de L5.1…) doit être déclaré
+   dans l'`inputSchema`. Le wrapper ne valide pas les **valeurs** : les gardes
+   de valeur vivent dans le code de l'outil.
+6. **D24** : signal commun — `truncated: true` **uniquement** quand la réponse
+   est coupée, `hint` actionnable, `returned` vs total avant coupe. `omitted`
+   en plus quand des éléments entiers sont écartés. Réutilise ce vocabulaire
+   exactement ; ne crée pas un second dialecte.
+7. **Pas de nouveau numéro de décision attendu** : ce lot **étend D24**
+   (complète son texte : les outils de requête et `get_workflow_details`
+   entrent dans son périmètre). Si une décision réellement nouvelle s'impose,
+   vérifie le dernier numéro (D26 à ce jour) et réserve D27 dans le commit qui
+   l'acte.
+
+---
+
+## Phase 0 — Confirmer les mesures
+
+Toutes rejouées le 25/08/2026 (protocole, LIMAGRAIN) avec la commande de
+mesure ci-dessus. À **confirmer**, pas à réinvestiguer :
+
+| Appel | Taille constatée |
+|---|---:|
+| `query_wms_entities` `{"entity_type":"Products","limit":200}` (Reading) | **957 234** |
+| `search_wms_data` `{"keyword":"PAL"}` | **847 543** |
+| `call_query_api` `{"entity_type":"Products","query_type":1,"limit":1}` — une seule ligne Writing | **95 288** |
+| `get_workflow_details` sur `CST_SendRejectContainersToPK` (`application: "CustomApp"`) | ~101 800 |
+| `get_workflow_details` `{"workflow_id":"2a320000-0642-47df-aa52-3b89c27c016f"}` (StackerCrane, EasyWMS) | 79 092 (dont blob `data` : 71 512) |
+
+Attention aux noms de paramètres (D23 les fait respecter) : `search_workflows`
+prend `query`, `search_wms_data` et `search_logs` prennent `keyword`. Pour
+trouver l'id du workflow CST :
+`search_workflows {"query":"CST_SendRejectContainersToPK","application":"CustomApp"}`.
+
+---
+
+## L5.1 — Paginer le blob `data` de `get_workflow_details`
+
+**Problème.** La réponse embarque la définition complète du workflow (blob
+`data`, XML/JSON EasyBuilder) : 71 512 caractères sur le StackerCrane mesuré,
+davantage sur les gros `CST_*` — la réponse dépasse le seuil client.
+
+**À faire.**
+- Deux paramètres de fenêtre sur le blob `data` (au schéma, D23) : une taille
+  max de tranche (défaut de l'ordre de **20 000** caractères, cohérent avec
+  D24) et un offset (défaut 0). Nommage à ta main (`max_data_chars` /
+  `data_offset` ou équivalent), documenté dans les descriptions.
+- La réponse porte toujours la taille **totale** du blob ; quand la fenêtre
+  tronque : `truncated: true` + `hint` donnant l'offset suivant.
+- La tranche est **verbatim** : découpe de chaîne, rien d'autre.
+- Les métadonnées du workflow (`id`, `name`, `commonInfo`…) restent complètes
+  dans chaque réponse ; seule `data` est fenêtrée.
+
+**Pente naturelle interdite** : ne résume pas, ne reformule pas, ne « parse »
+pas le blob pour n'en renvoyer que des morceaux jugés utiles — la définition
+EasyBuilder doit rester reconstituable à l'octet près en concaténant les
+tranches.
+
+**Vérification attendue** (protocole, LIMAGRAIN) :
+- `get_workflow_details` sur le StackerCrane (`2a320000-0642-47df-aa52-3b89c27c016f`)
+  sans paramètre de fenêtre → réponse < ~30 000 caractères, `truncated: true`,
+  taille totale annoncée = 71 512, hint avec l'offset suivant.
+- En enchaînant les tranches (offset 0, 20 000, 40 000, 60 000) : la somme des
+  longueurs des tranches = 71 512, et la concaténation est identique au blob
+  d'origine (compare au moins les longueurs et les 100 premiers/derniers
+  caractères).
+- Un workflow à petit blob (< défaut) → réponse strictement inchangée, pas de
+  `truncated`.
+
+## L5.2 — Garde de taille sur les outils de requête
+
+**Problème.** Aucune borne de volume sur `query_wms_entities`, `call_query_api`
+et `search_wms_data` : 957 234 caractères pour 200 lignes Reading, 847 543
+pour une recherche, et **95 288 pour une seule ligne Writing** (le modèle
+Writing sérialise l'agrégat complet — navigations, `$id`… — là où la même
+ligne Reading fait ~4 500).
+
+**À faire.**
+- Garde de taille commune aux trois outils : plafond en variable
+  d'environnement avec défaut (style `MAX_LOG_SEARCH_CHARS`, 25 000 — même
+  ordre de grandeur, nom à ta main, documenté dans CLAUDE.md).
+- Au-delà du plafond : écarter des **lignes entières** (pour `search_wms_data` :
+  des résultats entiers, par entité), et signaler D24 : `truncated: true`,
+  `returned`, `omitted`, `hint` (réduire `limit`, ajouter un `filter` ; et pour
+  `query_type != 0` : rappeler que les lignes Writing sont des agrégats
+  complets et suggérer Reading si l'usage le permet).
+- **Cas limite à traiter explicitement** : une seule ligne dépasse le plafond
+  (réel en Writing). La réponse est alors `returned: 0`, `omitted: <n>`,
+  `truncated: true`, avec un hint qui explique pourquoi et quoi faire — c'est
+  moins bon qu'un résultat, mais c'est mieux qu'un rejet client opaque.
+- **Ne change ni `MAX_QUERY_ROWS`, ni les limites par défaut des outils, ni le
+  comportement sous le plafond** : une requête qui tient aujourd'hui doit
+  renvoyer exactement la même réponse.
+- L'avertissement de volume mérite une phrase dans la description du paramètre
+  `query_type` (D25).
+
+**Vérification attendue** (protocole, LIMAGRAIN) :
+- `query_wms_entities` `{"entity_type":"Products","limit":200}` → réponse sous
+  le plafond (+ marge d'enveloppe), `truncated: true`, `returned` < 200,
+  `omitted` cohérent, hint présent.
+- `search_wms_data` `{"keyword":"PAL"}` → borné et signalé de même.
+- `call_query_api` `{"entity_type":"Products","query_type":1,"limit":1}` →
+  `returned: 0`, `omitted: 1`, `truncated: true`, hint expliquant le volume
+  Writing.
+- `query_wms_entities` `{"entity_type":"Container","limit":1}` → réponse
+  **strictement identique** à aujourd'hui (~4 500 caractères, pas de
+  `truncated`).
+- `count_wms_entities` → non concerné, inchangé.
+
+## L5.3 — Champ `tool` dans les enveloppes d'erreur locales
+
+**Problème.** Les `catch` locaux d'`api-tools.js` (deux blocs, vers les lignes
+145-162 et 191-208) renvoient `{ success: false, error }` **sans** le champ
+`tool` du contrat. Preuve : `call_query_api` `{"entity_type":"Products","query_type":7}`
+répond aujourd'hui `{"success": false, "error": "query_type invalide : …"}` —
+pas de `tool`.
+
+**À faire.** Balayer **tous** les modules de `src/tools/` à la recherche
+d'enveloppes `success: false` construites localement : soit y ajouter `tool`,
+soit laisser l'erreur remonter au wrapper de `src/index.js` (qui l'ajoute) —
+au choix selon le cas, mais le résultat observable est uniforme. Attention à ne
+pas perdre les champs additionnels utiles des enveloppes locales (le `warning`
+de résolution d'`api-tools`, les listes de profils de `profile-tools`…).
+
+**Vérification attendue** : `call_query_api` avec `query_type: 7` → l'enveloppe
+contient `"tool": "call_query_api"` ; un `grep` sur `src/tools/` ne montre plus
+d'enveloppe `success: false` sans `tool` (colle le résultat du grep dans le
+compte-rendu).
+
+---
+
+## Méthode
+
+1. Phase 0 d'abord (cinq mesures, rejouées telles quelles).
+2. L5.1, puis L5.2, puis L5.3 — chaque bloc vérifié **en exécution via le
+   protocole** avant de passer au suivant.
+3. Rappel : le serveur traite les `tools/call` en concurrence (point ouvert de
+   la ROADMAP) — pour les vérifications qui comparent des réponses successives,
+   envoie les requêtes séquentiellement.
+4. Les schémas changent : reboucler sur les 23 noms de `tools/list` (aucun
+   `Unknown tool` ; `execute_command` vérifié statiquement, non appelé) et
+   vérifier qu'un paramètre inconnu est toujours rejeté (D23).
+5. Baseline avant/après : handshake (23/6) + `npm test` (4/4, exit 0).
+6. « Non résolu » est une réponse acceptable pour une investigation
+   time-boxée ; une hypothèse présentée comme solution ne l'est pas.
+
+## Livraison
+
+- Un commit par bloc (L5.1, L5.2, L5.3), messages expliquant le pourquoi,
+  **mesures avant/après dans le corps du message** (tailles en caractères).
+- Documentation dans les mêmes commits : **compléter D24** (périmètre étendu
+  aux outils de requête et à `get_workflow_details`) ; CLAUDE.md — la nouvelle
+  variable d'environnement dans les réglages partagés, la fenêtre de
+  `get_workflow_details` si elle change l'usage documenté ; ROADMAP.md —
+  retirer le lot 5.
+- Ne pousse pas. `.env` intact. Toute anomalie hors périmètre découverte en
+  route : dans ROADMAP.md, pas dans le code.
+- Compte-rendu final : pour chaque bloc, la vérification attendue rejouée et
+  son résultat **mesuré** (colle les tailles et les sorties), plus la baseline
+  finale. Laisse `handoff-lot5.md` en place pour la révision.
@@ -42,9 +42,13 @@ function getAPICatalog() {

 The WMS provides several REST APIs for querying and modifying data.

-**Base URL:** \`${process.env.WMS_API_BASE_URL || 'https://10.255.255.2/ApplicationService/api'}\`
+**Base URL:** \`https://<host>/ApplicationService/api\` — built from the active
+profile's host (see \`get_current_wms_profile\`).
 **Authentication:** OAuth 2.0 Bearer Token (automatic)

+The generated help page at \`https://<host>/ApplicationService/Help\` is the
+authoritative reference for endpoints and fields.
+
 ---

 ## Query API
@@ -60,44 +64,55 @@ Execute LINQ queries against WMS entities.
 \`\`\`json
 {
  "Application": "EasyWMS",
-  "QueryType": 1,
-  "Expression": "Context.{EntityType}.Select(z => z)"
+  "QueryType": 0,
+  "Expression": "Context.Products.Where(z => z.Code == \\"X\\").OrderBy(z => z.Id)",
+  "Take": 100
 }
 \`\`\`

-### Supported Entity Types
+Rules (see the query tools for details):

-| Entity Type | Description |
-|-------------|-------------|
-| Products | Product references and SKUs |
-| Containers | Pallets, boxes, and container types |
-| Stocks | Available inventory by location |
-| ProductLocations | Product placement in warehouse |
-| Tasks | WMS tasks (picks, puts, moves, etc.) |
-| Accounts | Customer accounts |
-| Suppliers | Supplier information |
-| Kits | Product kits and bundles |
-| Aliases | Product aliases and alternative codes |
-| InboundOrders | Inbound/receiving orders |
-| Receptions | Actual receptions |
-| OutboundOrders | Outbound/shipping orders |
+- **\`QueryType: 0\` (Reading) is the default** — status fields are strings
+  (\`"Release"\`). \`QueryType: 1\` (Writing) exists but status fields become
+  enums there: string comparisons fail. Old examples using \`1\` must not be
+  copied. The query tools expose this as the opt-in \`query_type\` parameter.
+- **\`Where\` and \`OrderBy\` go in the Expression; \`Take\`/\`Skip\` are API
+  parameters.** \`OrderBy\` is mandatory as soon as \`Take\` is used.
+- **No \`Select\` projections** — the \`Select\` parameter causes server-side
+  compile errors. Query full rows.
+- **No relative dates** (\`DateTime.Now\`, \`AddDays()\`) — write literal dates:
+  \`new DateTime(2026, 8, 1)\`.

-### Example Queries
+### Entity Types
+
+Common entities: Products, Containers, Stocks, ProductLocations, Tasks,
+Accounts, Suppliers, Kits, Alias (invariant — no plural form), InboundOrders,
+Receptions, OutboundOrders.
+
+**The authoritative list (288 entities) comes from \`get_entity_metadata\`**
+(Metadata API) — entity names are resolved case-insensitively from the AD name
+(Container) or the TableName (Containers).
+
+### Example Expressions

 \`\`\`
-# Get all products (limited)
-Context.Products.Take(100).Select(z => z)
+# Filter + mandatory OrderBy (Take passed as API parameter, not in the expression)
+Context.Products.Where(z => z.Code.Contains("ABC")).OrderBy(z => z.Id)

-# Get specific fields
-Context.Products.Select(z => new { z.Id, z.Code, z.Name })
-
-# Filter and select
-Context.Tasks.Where(z => z.Status == "Pending").Take(50).Select(z => z)
+# Status comparison — strings in Reading (QueryType 0)
+Context.OutboundOrders.Where(z => z.OutboundOrderStatus == "Release").OrderBy(z => z.Id)
 \`\`\`

-### MCP Tool
+### Counting

-Use \`call_query_api\` tool to execute queries.
+**Endpoint:** \`/api/QueryScalarExecute\` — same body, expression ends with
+\`.Count()\` / \`.Sum(...)\`. Prefer the \`count_wms_entities\` tool for any
+"how many" question.
+
+### MCP Tools
+
+\`query_wms_entities\`, \`count_wms_entities\`, \`call_query_api\`,
+\`get_entity_schema\`, \`search_wms_data\`.

 ---

@@ -114,31 +129,7 @@ Execute commands to modify WMS data.
 \`\`\`json
 [
  {
-    "Name": "CommandName, Mecalux.ITSW.EasyWMS.Modules.Contracts",
-    "Properties": {
-      "PropertyName": "value"
-    }
-  }
-]
-\`\`\`
-
-### Common Commands
-
-| Command | Description |
-|---------|-------------|
-| ProductRemoveCommand | Remove a product |
-| ProductUpdateCommand | Update product information |
-| ContainerCreateCommand | Create a new container |
-| TaskCancelCommand | Cancel a task |
-| InboundOrderCancelCommandV2 | Cancel an inbound order |
-| OutboundOrderCancelCommand | Cancel an outbound order |
-
-### Example Command
-
-\`\`\`json
-[
-  {
-    "Name": "Mecalux.ITSW.EasyWMS.Modules.MasterData.Contracts.Commands.ProductRemoveCommand, Mecalux.ITSW.EasyWMS.Modules.Contracts",
+    "Name": "Mecalux.ITSW.EasyWMS.Modules.MasterData.Contracts.Commands.ProductRemoveCommand",
    "Properties": {
      "Id": "product-guid-here"
    }
@@ -146,6 +137,11 @@ Execute commands to modify WMS data.
 ]
 \`\`\`

+**\`Name\` is the \`InternalCommandName\` from the Application Dictionary, used
+as-is.** Never append an assembly suffix (\`, Mecalux.ITSW...Contracts\`) — it
+causes a \`FileLoadException\`. Retrieve the exact name via
+\`get_ad_element_details\` before executing.
+
 ### MCP Tool

 Use \`execute_command\` tool to execute commands.
@@ -154,7 +150,7 @@ Use \`execute_command\` tool to execute commands.

 ---

-## Workflow API
+## Workflow API (Application Dictionary)

 Retrieve workflow definitions by application.

@@ -165,30 +161,23 @@ Retrieve workflow definitions by application.
 ### Request Format

 \`\`\`json
-["EasyWMS", "AD", 5000, 0]
+["EasyWMS", "<tenant>", 5000, 0]
 \`\`\`

-Parameters:
-1. Application name (e.g., "EasyWMS")
-2. Tenant code (e.g., "AD")
-3. Page size (e.g., 5000)
-4. Offset (e.g., 0 for first page)
+Parameters (positional): application name, tenant code, page size, offset.

 ### Response

-Array of workflow objects with:
- Id, Code, Name
- Category, Description
- Version, Status
- Created, Modified
- Definition (JSON)
+An envelope object \`{ "entities": [...] }\` — **not** a bare array. Each
+workflow object carries lowercase keys: \`id\`, \`name\`, \`version\`,
+\`applicationName\`, \`commonInfo\` (createdBy, createDate, updateDate). There
+is no category, code or description field.

 ### MCP Tools

-Use workflow tools to interact with workflows:
- \`search_workflows\` - Search by name, code, description
+- \`search_workflows\` - Search by name
 - \`get_workflow_details\` - Get full workflow definition
- \`list_workflow_categories\` - List all categories
+- \`list_workflow_categories\` - List applications (workflows have no category field)

 ---

@@ -197,13 +186,13 @@ Use workflow tools to interact with workflows:
 All APIs use OAuth 2.0 authentication.

 **Token Endpoint:** \`/EasySTS/OAuth/Token\`
-**Grant Types:** password, refresh_token
+**Grant Types:** password, refresh_token (\`tenant_code\` is mandatory)

 ### Token Management

 - Tokens expire after ~1200 seconds
 - Automatic refresh when < 1000 seconds remaining
- Credentials configured in .env file
+- Credentials come from the active profile (multi-profile \`.env\`)

 The MCP server handles authentication automatically.

@@ -217,16 +206,10 @@ The MCP server handles authentication automatically.
 - \`400\` - Bad request (invalid query/command)
 - \`401\` - Unauthorized (token expired or invalid)
 - \`403\` - Forbidden (insufficient permissions)
- \`500\` - Internal server error
+- \`500\` - Internal server error (incl. LINQ compile errors)

-### Error Response Format
-
-\`\`\`json
-{
-  "error": "Error message",
-  "details": "Detailed error information"
-}
-\`\`\`
+The response body of a 500 carries the real diagnostic (e.g. the compile
+error naming the context) — MCP tools surface it in their error messages.

 ---

@@ -238,24 +221,6 @@ The MCP server handles authentication automatically.

 ---

-## Configuration
-
-API settings are configured via environment variables:
-
-\`\`\`env
-WMS_API_BASE_URL=https://10.255.255.2/ApplicationService/api
-WMS_API_TOKEN_URL=https://10.255.255.2/EasySTS/OAuth/Token
-WMS_API_TENANT=AD
-WMS_API_USERNAME=your-username
-WMS_API_PASSWORD=your-password
-WORKFLOW_API_BASE=https://10.255.255.2/AD/api
-WORKFLOW_PAGE_SIZE=5000
-MAX_QUERY_ROWS=1000
-QUERY_TIMEOUT=30000
-\`\`\`
-
---
-
 **Note:** Use MCP tools to interact with these APIs. Direct API calls require proper authentication handling.
 `;
 }
@@ -7,11 +7,26 @@
 const apiService = require('./api-service').getInstance();
 const profileManager = require('../config/profile-manager');

-// Cache state - one cache per element type
+// Cache state - one cache per (application, element type) (D26)
 const cache = {};
 const cacheTimestamps = {};
 const CACHE_TTL = parseInt(process.env.WORKFLOW_CACHE_TTL) || 3600000; // 1 hour

+/**
+ * Application effective : celle demandée, sinon celle du profil actif.
+ */
+function resolveApplication(application) {
+  return (application && application.trim()) || profileManager.getCurrent().application;
+}
+
+/**
+ * Clé de cache composite (D26) — sans elle, un appel CustomApp polluerait le
+ * cache EasyWMS du même type.
+ */
+function cacheKey(application, elementType) {
+  return `${application}::${elementType}`;
+}
+
 // Invalidate all caches when profile changes — AD elements are per-tenant.
 profileManager.onSwitch(() => invalidateCache());

@@ -44,51 +59,55 @@ const AD_ELEMENT_TYPES = {
 };

 /**
- * Check if cache is valid for a given element type
+ * Check if cache is valid for a given (application, element type)
 */
-function isCacheValid(elementType) {
-  if (!cache[elementType] || !cacheTimestamps[elementType]) {
+function isCacheValid(application, elementType) {
+  const key = cacheKey(application, elementType);
+  if (!cache[key] || !cacheTimestamps[key]) {
    return false;
  }

  const now = Date.now();
-  const age = now - cacheTimestamps[elementType];
+  const age = now - cacheTimestamps[key];
  return age < CACHE_TTL;
 }

 /**
 * Get all elements of a specific type from AD API
- * Implements lazy loading with caching and pagination
+ * Implements lazy loading with caching and pagination.
+ * Lazy par application (D26) : seule l'application demandée est chargée.
 *
 * @param {string} elementType - Type of element (Command, Query, Dialog, etc.)
+ * @param {string} [application] - Application AD (défaut : profil actif)
 * @returns {Promise<Array>} Array of elements
 */
-async function getElements(elementType) {
+async function getElements(elementType, application) {
  // Validate element type
  if (!AD_ELEMENT_TYPES[elementType]) {
    throw new Error(`Unknown element type: ${elementType}. Valid types: ${Object.keys(AD_ELEMENT_TYPES).join(', ')}`);
  }

+  const app = resolveApplication(application);
+  const key = cacheKey(app, elementType);
+
  // Check cache
-  if (isCacheValid(elementType)) {
-    console.error(`[AD] Cache hit: ${elementType} (${cache[elementType].length} elements)`);
-    return cache[elementType];
+  if (isCacheValid(app, elementType)) {
+    console.error(`[AD] Cache hit: ${key} (${cache[key].length} elements)`);
+    return cache[key];
  }

-  console.error(`[AD] Cache expired or empty, fetching ${elementType}...`);
+  console.error(`[AD] Cache expired or empty, fetching ${key}...`);

  try {
    let allElements = [];
    let offset = 0;
    const pageSize = AD_ELEMENT_TYPES[elementType];
-    const profile = profileManager.getCurrent();
-    const application = profile.application;
-    const tenant = profile.tenant;
+    const tenant = profileManager.getCurrent().tenant;

    while (true) {
-      const body = [application, tenant, pageSize, offset];
+      const body = [app, tenant, pageSize, offset];

-      console.error(`[AD] Fetching ${elementType}: offset=${offset}, pageSize=${pageSize}`);
+      console.error(`[AD] Fetching ${key}: offset=${offset}, pageSize=${pageSize}`);

      // Use AD API (useAdApi=true)
      const response = await apiService.post(`/${elementType}/GetByApplication`, body, true);
@@ -115,14 +134,14 @@ async function getElements(elementType) {
    }

    // Update cache
-    cache[elementType] = allElements;
-    cacheTimestamps[elementType] = Date.now();
+    cache[key] = allElements;
+    cacheTimestamps[key] = Date.now();

-    console.error(`[AD] Successfully cached ${allElements.length} ${elementType}`);
+    console.error(`[AD] Successfully cached ${allElements.length} ${key}`);
    return allElements;
  } catch (error) {
-    console.error(`[AD] Error fetching ${elementType}:`, error.message);
-    throw new Error(`Failed to fetch ${elementType}: ${error.message}`);
+    console.error(`[AD] Error fetching ${key}:`, error.message);
+    throw new Error(`Failed to fetch ${elementType} for application "${app}": ${error.message}`);
  }
 }

@@ -131,9 +150,10 @@ async function getElements(elementType) {
 * @param {string} elementType - Type of element
 * @param {string} query - Search query (matches name, description, etc.)
 * @param {number} limit - Maximum results to return
+ * @param {string} [application] - Application AD (défaut : profil actif)
 */
-async function searchElements(elementType, query, limit = 50) {
-  const elements = await getElements(elementType);
+async function searchElements(elementType, query, limit = 50, application) {
+  const elements = await getElements(elementType, application);

  if (!query) {
    return elements.slice(0, limit);
@@ -157,9 +177,10 @@ async function searchElements(elementType, query, limit = 50) {
 * Get element details by ID or name
 * @param {string} elementType - Type of element
 * @param {string|number} elementId - Element ID or name
+ * @param {string} [application] - Application AD (défaut : profil actif)
 */
-async function getElementDetails(elementType, elementId) {
-  const elements = await getElements(elementType);
+async function getElementDetails(elementType, elementId, application) {
+  const elements = await getElements(elementType, application);

  // Try to find by Id, id, Code, code, Name, or name
  const element = elements.find(e =>
@@ -174,45 +195,49 @@ async function getElementDetails(elementType, elementId) {
  );

  if (!element) {
-    throw new Error(`${elementType} not found: ${elementId}`);
+    const app = resolveApplication(application);
+    throw new Error(
+      `${elementType} not found: ${elementId} (application "${app}"). ` +
+      `Utilisez search_ad_elements — pensez au paramètre application ` +
+      `(ex: "CustomApp" pour le spécifique client).`
+    );
  }

  return element;
 }

 /**
- * Get application summary (count of each element type)
- * Only loads types that are already cached to avoid long wait times
+ * Get application summary — état des caches par (application, type) (D26).
+ * Seules les entrées effectivement en cache sont détaillées, pour rester
+ * borné quel que soit le nombre d'applications interrogées (D24).
+ * @returns {Object} application -> type -> { count, cacheAge }
 */
 function getApplicationSummary() {
-  const summary = {};
+  const byApplication = {};

-  Object.keys(AD_ELEMENT_TYPES).forEach(type => {
-    if (cache[type]) {
-      summary[type] = {
-        count: cache[type].length,
-        cached: true,
-        cacheAge: cacheTimestamps[type] ? Math.floor((Date.now() - cacheTimestamps[type]) / 1000) : null
+  Object.keys(cache).forEach(key => {
+    const [app, type] = key.split('::');
+    if (!byApplication[app]) byApplication[app] = {};
+    byApplication[app][type] = {
+      count: cache[key].length,
+      cacheAge: cacheTimestamps[key] ? Math.floor((Date.now() - cacheTimestamps[key]) / 1000) : null
    };
-    } else {
-      summary[type] = {
-        count: 0,
-        cached: false,
-        cacheAge: null
-      };
-    }
  });

-  return summary;
+  return byApplication;
 }

 /**
- * Invalidate cache for a specific type or all types
+ * Invalidate cache for a specific type (across all applications) or all types
 */
 function invalidateCache(elementType = null) {
  if (elementType) {
-    delete cache[elementType];
-    delete cacheTimestamps[elementType];
+    Object.keys(cache)
+      .filter(k => k.endsWith(`::${elementType}`))
+      .forEach(k => {
+        delete cache[k];
+        delete cacheTimestamps[k];
+      });
    console.error(`[AD] Cache invalidated: ${elementType}`);
  } else {
    Object.keys(cache).forEach(k => {
@@ -224,17 +249,19 @@ function invalidateCache(elementType = null) {
 }

 /**
- * Get cache status
+ * Get cache status, par application puis type (D26)
 */
 function getCacheStatus() {
  const status = {};
-  Object.keys(AD_ELEMENT_TYPES).forEach(type => {
-    status[type] = {
-      cached: !!cache[type],
-      count: cache[type] ? cache[type].length : 0,
-      timestamp: cacheTimestamps[type],
-      age: cacheTimestamps[type] ? Math.floor((Date.now() - cacheTimestamps[type]) / 1000) : null,
-      valid: isCacheValid(type)
+  Object.keys(cache).forEach(key => {
+    const [app, type] = key.split('::');
+    if (!status[app]) status[app] = {};
+    status[app][type] = {
+      cached: true,
+      count: cache[key].length,
+      timestamp: cacheTimestamps[key],
+      age: cacheTimestamps[key] ? Math.floor((Date.now() - cacheTimestamps[key]) / 1000) : null,
+      valid: isCacheValid(app, type)
    };
  });
  return status;
@@ -323,14 +323,17 @@ class APIService {
   *   e.g. "Context.OutboundOrders.Where(z => z.OutboundOrderStatus == \"Release\").OrderBy(z => z.Id)"
   *
   * @param {string} expression - LINQ expression (Context.Entity or Context.Entity.Where(...))
-   * @param {object} options    - { take, skip, select, orderBy, inlineCount }
+   * @param {object} options    - { take, skip, select, orderBy, inlineCount, queryType }
   */
  async executeQuery(expression, options = {}) {
-    const { take, skip, select, orderBy, inlineCount } = options;
+    const { take, skip, select, orderBy, inlineCount, queryType } = options;

    const body = {
      Application: profileManager.getCurrent().application,
-      QueryType: 0, // Reading = 0 (status fields are strings), Writing = 1 (enums)
+      // Reading = 0 par défaut (statuts en chaînes) ; Writing/Metrics en
+      // opt-in explicite via query_type (D25) — la garde de valeur vit dans
+      // wms-query-service.assertValidQueryType, pas ici.
+      QueryType: queryType ?? 0,
      Expression: expression,
    };

@@ -363,11 +366,13 @@ class APIService {
   * Execute a scalar LINQ query (Count, Sum, etc.) via QueryScalarExecute.
   * Returns the scalar value directly.
   * @param {string} fullExpression - e.g. "Context.OutboundOrders.Where(...).Count()"
+   * @param {object} options        - { queryType }
   */
-  async executeScalarQuery(fullExpression) {
+  async executeScalarQuery(fullExpression, options = {}) {
    const body = {
      Application: profileManager.getCurrent().application,
-      QueryType: 0, // Reading = 0 — string enum names in filters (Writing=1 fails with enum comparisons)
+      // Reading = 0 par défaut — voir executeQuery / D25.
+      QueryType: options.queryType ?? 0,
      Expression: fullExpression,
    };

@@ -119,15 +119,22 @@ function suggestClosest(input, limit = 5) {
 * Résout un nom d'entité vers son TableName.
 *
 * @param {string} entityType - Name AD ou TableName, insensible à la casse
+ * @param {object} [options]
+ * @param {boolean} [options.allowUnknown=false] - Un nom inconnu du Reading
+ *   passe tel quel avec un warning au lieu d'échouer. Utilisé quand
+ *   query_type != 0 (D25) : la table est construite sur le Metadata Reading,
+ *   or le modèle Writing/Metrics peut contenir des entités hors Reading.
 * @returns {Promise<{tableName: string, warning?: string}>}
 *   - nom connu   : { tableName } (le TableName exact)
 *   - Metadata injoignable : { tableName: entityType, warning } — on laisse
 *     passer le nom tel quel (comportement historique) plutôt que de tout
 *     bloquer, et on le dit dans la réponse
- * @throws {Error} nom inconnu du modèle Reading — AVANT tout appel réseau de
- *   requête, avec suggestions proches et renvoi vers get_entity_metadata
+ * @throws {Error} nom inconnu du modèle Reading (sauf allowUnknown) — AVANT
+ *   tout appel réseau de requête, avec suggestions proches et renvoi vers
+ *   get_entity_metadata
 */
-async function resolveEntityType(entityType) {
+async function resolveEntityType(entityType, options = {}) {
+  const { allowUnknown = false } = options;
  if (!entityType || typeof entityType !== 'string' || entityType.trim() === '') {
    throw new Error('entity_type est requis. Utilisez get_entity_metadata pour la liste des entités interrogeables.');
  }
@@ -150,6 +157,15 @@ async function resolveEntityType(entityType) {

  const suggestions = suggestClosest(trimmed);
  const closest = suggestions.length > 0 ? ` Proches : ${suggestions.join(', ')}.` : '';
+
+  if (allowUnknown) {
+    console.error(`[EntityResolver] "${trimmed}" unknown to Reading metadata, passing through (allowUnknown)`);
+    return {
+      tableName: trimmed,
+      warning: `"${trimmed}" est inconnu du modèle Reading (Metadata) ; il est transmis tel quel car query_type != 0 — le contexte demandé peut contenir des entités hors Reading.${closest}`,
+    };
+  }
+
  throw new Error(
    `"${trimmed}" n'existe pas dans le modèle Reading.${closest} ` +
    `${tableNames.length} entités disponibles — utilisez get_entity_metadata pour la liste.`
@@ -6,6 +6,27 @@
 const apiService = require('./api-service').getInstance();
 const entityResolver = require('./entity-resolver');

+/**
+ * Garde de valeur de query_type (D25). Le wrapper D23 valide les noms de
+ * paramètres, pas les valeurs — cette garde s'exécute AVANT tout appel réseau
+ * (y compris la résolution d'entité) et nomme les quatre contextes.
+ * @param {*} queryType - valeur reçue de l'outil (défaut 0 si absent)
+ * @returns {number} la valeur validée
+ */
+function assertValidQueryType(queryType) {
+  if (queryType == null) return 0;
+  if (!Number.isInteger(queryType) || queryType < 0 || queryType > 3) {
+    throw new Error(
+      `query_type invalide : ${JSON.stringify(queryType)}. Valeurs acceptées : ` +
+      `0 = Reading (défaut — statuts en chaînes, ex. "Release"), ` +
+      `1 = Writing (statuts en énumérations : les comparaisons de chaînes échouent), ` +
+      `2 = DataWarehouse (souvent non configuré), ` +
+      `3 = Metrics (modèle de données distinct).`
+    );
+  }
+  return queryType;
+}
+
 /**
 * Build a LINQ select expression
 * @param {string} entityType - Entity type (Products, Containers, etc.)
@@ -19,11 +40,19 @@ const entityResolver = require('./entity-resolver');
 * @param {string} selectExpression - LINQ select expression
 * @param {string|null} filter - Optional filter
 * @param {number} limit - Result limit
+ * @param {number} queryType - QueryContextType (0 = Reading par défaut, D25)
 */
-async function queryEntities(entityType, selectExpression = 'z => z', filter = null, limit = 100) {
+async function queryEntities(entityType, selectExpression = 'z => z', filter = null, limit = 100, queryType = 0) {
+  // Garde de valeur avant tout réseau (D25).
+  queryType = assertValidQueryType(queryType);
+
  // Résolution Name/TableName -> TableName (D21). Un nom inconnu échoue ici,
  // avant tout appel réseau de requête — l'erreur porte les suggestions.
-  const { tableName, warning } = await entityResolver.resolveEntityType(entityType);
+  // En query_type != 0, un nom hors Reading passe tel quel avec warning : le
+  // modèle Writing/Metrics peut contenir des entités hors Reading (D25).
+  const { tableName, warning } = await entityResolver.resolveEntityType(entityType, {
+    allowUnknown: queryType !== 0,
+  });

  try {
    // Enforce max limit
@@ -39,17 +68,19 @@ async function queryEntities(entityType, selectExpression = 'z => z', filter = n
    // OrderBy must be embedded in the expression (not as a separate API param)
    expression += `.OrderBy(z => z.Id)`;

-    console.error(`[WMSQuery] Querying ${entityType}: ${expression} | take=${actualLimit} select=${selectExpression}`);
+    console.error(`[WMSQuery] Querying ${entityType}: ${expression} | take=${actualLimit} select=${selectExpression} queryType=${queryType}`);

    const result = await apiService.executeQuery(expression, {
      take: actualLimit,
      select: selectExpression !== 'z => z' ? selectExpression : undefined,
+      queryType,
    });

    return {
      entityType,
      resolvedTableName: tableName,
      ...(warning ? { warning } : {}),
+      ...(queryType !== 0 ? { queryType } : {}),
      expression,
      limit: actualLimit,
      count: Array.isArray(result) ? result.length : 0,
@@ -57,7 +88,9 @@ async function queryEntities(entityType, selectExpression = 'z => z', filter = n
    };
  } catch (error) {
    console.error(`[WMSQuery] Query failed:`, error.message);
-    throw new Error(`Query failed for ${entityType}: ${error.message}`);
+    // Le warning de résolution (nom hors Reading en query_type != 0) reste
+    // visible même quand le WMS échoue ensuite.
+    throw new Error(`Query failed for ${entityType}: ${error.message}${warning ? `\nWarning: ${warning}` : ''}`);
  }
 }

@@ -149,11 +182,17 @@ async function getEntitySchema(entityType) {
 * Count entities with optional filter
 * @param {string} entityType - Entity type
 * @param {string|null} filter - Optional filter
+ * @param {number} queryType - QueryContextType (0 = Reading par défaut, D25)
 */
-async function countEntities(entityType, filter = null) {
+async function countEntities(entityType, filter = null, queryType = 0) {
+  // Garde de valeur avant tout réseau (D25).
+  queryType = assertValidQueryType(queryType);
+
  // Résolution Name/TableName -> TableName (D21) — échec avant appel réseau
-  // sur nom inconnu.
-  const { tableName, warning } = await entityResolver.resolveEntityType(entityType);
+  // sur nom inconnu, sauf en query_type != 0 (passage tel quel + warning, D25).
+  const { tableName, warning } = await entityResolver.resolveEntityType(entityType, {
+    allowUnknown: queryType !== 0,
+  });

  try {
    // Build: Context.Entity.Where(...).Count()
@@ -165,20 +204,21 @@ async function countEntities(entityType, filter = null) {
    parts.push('Count()');
    const fullExpression = parts.join('.');

-    console.error(`[WMSQuery] Counting ${entityType}: ${fullExpression}`);
+    console.error(`[WMSQuery] Counting ${entityType}: ${fullExpression} | queryType=${queryType}`);

-    const count = await apiService.executeScalarQuery(fullExpression);
+    const count = await apiService.executeScalarQuery(fullExpression, { queryType });

    return {
      entityType,
      resolvedTableName: tableName,
      ...(warning ? { warning } : {}),
+      ...(queryType !== 0 ? { queryType } : {}),
      filter,
      count
    };
  } catch (error) {
    console.error(`[WMSQuery] Count failed:`, error.message);
-    throw new Error(`Count failed for ${entityType}: ${error.message}`);
+    throw new Error(`Count failed for ${entityType}: ${error.message}${warning ? `\nWarning: ${warning}` : ''}`);
  }
 }

@@ -188,4 +228,5 @@ module.exports = {
  searchEntities,
  getEntitySchema,
  countEntities,
+  assertValidQueryType,
 };
@@ -2,14 +2,19 @@
 * Workflow Service
 * Handles workflow fetching with lazy loading and caching
 * Workflows are only loaded when first requested (not at startup)
+ *
+ * Un cache par application (D26) : le paramètre `application` des outils
+ * sélectionne l'application AD interrogée (défaut : celle du profil actif).
 */

 const apiService = require('./api-service').getInstance();
 const profileManager = require('../config/profile-manager');

-// Cache state
-let workflowCache = null;
-let cacheTimestamp = null;
+// Cache state — un cache de workflows par application (D26)
+let workflowCaches = {};      // application -> workflows[]
+let cacheTimestamps = {};     // application -> timestamp
+let applicationsCache = null; // liste allégée de POST /Application/GetAll
+let applicationsTimestamp = null;
 const CACHE_TTL = parseInt(process.env.WORKFLOW_CACHE_TTL) || 3600000; // 1 hour in milliseconds

 // Clear cache when profile changes — workflows are per-tenant, so the previous
@@ -17,43 +22,52 @@ const CACHE_TTL = parseInt(process.env.WORKFLOW_CACHE_TTL) || 3600000; // 1 hour
 profileManager.onSwitch(() => clearCache());

 /**
- * Check if cache is still valid
+ * Application effective : celle demandée, sinon celle du profil actif.
 */
-function isCacheValid() {
-  if (!workflowCache || !cacheTimestamp) {
+function resolveApplication(application) {
+  return (application && application.trim()) || profileManager.getCurrent().application;
+}
+
+/**
+ * Check if cache is still valid for an application
+ */
+function isCacheValid(application) {
+  if (!workflowCaches[application] || !cacheTimestamps[application]) {
    return false;
  }

-  const now = Date.now();
-  const age = now - cacheTimestamp;
+  const age = Date.now() - cacheTimestamps[application];
  return age < CACHE_TTL;
 }

 /**
- * Fetch all workflows from API with pagination
- * Uses high page size (5000) to minimize API calls
+ * Fetch all workflows of an application from API with pagination.
+ * Uses high page size (5000) to minimize API calls.
+ * Lazy : seule l'application effectivement demandée est chargée (D26) — ne
+ * jamais précharger les 9 applications.
+ * @param {string} [application] - Application AD (défaut : profil actif)
 */
-async function fetchAllWorkflows() {
+async function fetchAllWorkflows(application) {
+  const app = resolveApplication(application);
+
  // Check cache validity
-  if (isCacheValid()) {
-    console.error('[Workflow] Using cached data');
-    return workflowCache;
+  if (isCacheValid(app)) {
+    console.error(`[Workflow] Using cached data for "${app}"`);
+    return workflowCaches[app];
  }

-  console.error('[Workflow] Cache expired or empty, fetching from API...');
+  console.error(`[Workflow] Cache expired or empty for "${app}", fetching from API...`);

  try {
    let allWorkflows = [];
    let offset = 0;
    const pageSize = parseInt(process.env.WORKFLOW_PAGE_SIZE) || 5000;
-    const profile = profileManager.getCurrent();
-    const application = profile.application;
-    const tenant = profile.tenant;
+    const tenant = profileManager.getCurrent().tenant;

    while (true) {
-      const body = [application, tenant, pageSize, offset];
+      const body = [app, tenant, pageSize, offset];

-      console.error(`[Workflow] Fetching page: offset=${offset}, pageSize=${pageSize}`);
+      console.error(`[Workflow] Fetching page: application=${app}, offset=${offset}, pageSize=${pageSize}`);

      // Use AD API (useAdApi=true)
      const response = await apiService.post('/Workflow/GetByApplication', body, true);
@@ -80,17 +94,45 @@ async function fetchAllWorkflows() {
    }

    // Update cache
-    workflowCache = allWorkflows;
-    cacheTimestamp = Date.now();
+    workflowCaches[app] = allWorkflows;
+    cacheTimestamps[app] = Date.now();

-    console.error(`[Workflow] Successfully cached ${allWorkflows.length} workflows`);
+    console.error(`[Workflow] Successfully cached ${allWorkflows.length} workflows for "${app}"`);
    return allWorkflows;
  } catch (error) {
-    console.error('[Workflow] Error fetching workflows:', error.message);
-    throw new Error(`Failed to fetch workflows: ${error.message}`);
+    console.error(`[Workflow] Error fetching workflows for "${app}":`, error.message);
+    throw new Error(`Failed to fetch workflows for application "${app}": ${error.message}`);
  }
 }

+/**
+ * Liste les applications déclarées (POST /Application/GetAll, payload null).
+ * La réponse est une enveloppe { entities: [...] } (D4) dont chaque élément
+ * porte un blob `data` volumineux — on ne conserve que les champs légers.
+ * Cache TTL commun, vidé au switch de profil.
+ * @returns {Promise<Array<{name: string, id: string, version: number}>>}
+ */
+async function fetchApplications() {
+  if (applicationsCache && applicationsTimestamp &&
+      Date.now() - applicationsTimestamp < CACHE_TTL) {
+    return applicationsCache;
+  }
+
+  console.error('[Workflow] Fetching application list (Application/GetAll)...');
+  const response = await apiService.post('/Application/GetAll', null, true);
+  const entities = response?.entities || [];
+
+  applicationsCache = entities.map(a => ({
+    name: a.name || a.Name,
+    id: a.id || a.Id,
+    version: a.version ?? a.Version,
+  })).filter(a => a.name);
+  applicationsTimestamp = Date.now();
+
+  console.error(`[Workflow] Cached ${applicationsCache.length} application(s)`);
+  return applicationsCache;
+}
+
 /**
 * Search workflows by query string.
 * Real AD keys (lowercase, cf. D5): id, name, version, applicationName,
@@ -99,9 +141,10 @@ async function fetchAllWorkflows() {
 * @param {string|null} category - Optional applicationName filter (the only
 *                                 grouping the AD API provides)
 * @param {number} limit - Maximum results to return
+ * @param {string} [application] - Application AD interrogée (défaut : profil)
 */
-async function searchWorkflows(query, category = null, limit = 50) {
-  const workflows = await fetchAllWorkflows();
+async function searchWorkflows(query, category = null, limit = 50, application) {
+  const workflows = await fetchAllWorkflows(application);

  let results = workflows;

@@ -130,15 +173,17 @@ async function searchWorkflows(query, category = null, limit = 50) {
 /**
 * Get workflow details by ID
 * @param {string|number} workflowId - Workflow ID
+ * @param {string} [application] - Application AD interrogée (défaut : profil)
 */
-async function getWorkflowDetails(workflowId) {
+async function getWorkflowDetails(workflowId, application) {
  // Garde d'entrée : sans elle, un workflow_id absent matchait le premier
  // workflow du cache (undefined === undefined sur les clés mortes ci-dessous).
  if (workflowId == null || workflowId === '') {
    throw new Error('workflow_id est requis (id ou nom exact du workflow). Utilisez search_workflows pour le trouver.');
  }

-  const workflows = await fetchAllWorkflows();
+  const app = resolveApplication(application);
+  const workflows = await fetchAllWorkflows(app);

  // Clés réelles de l'API AD (minuscules, D5) : id, name. Les variantes
  // Id/Code/Name n'existent pas sur ces objets — les comparer faisait matcher
@@ -149,82 +194,65 @@ async function getWorkflowDetails(workflowId) {
  );

  if (!workflow) {
-    throw new Error(`Workflow not found: ${workflowId}. Utilisez search_workflows pour trouver l'id ou le nom exact.`);
+    throw new Error(
+      `Workflow not found: ${workflowId} (application "${app}"). ` +
+      `Utilisez search_workflows pour trouver l'id ou le nom exact — ` +
+      `pensez au paramètre application (ex: "CustomApp" pour le spécifique client).`
+    );
  }

  return workflow;
 }

 /**
- * List distinct applicationName values.
- * Workflows have no category field — applicationName is the only grouping the
- * AD API provides, and every workflow of the active application carries the
- * same value (e.g. "EasyWMS").
+ * Get workflow statistics for one application
+ * @param {string} [application] - Application AD interrogée (défaut : profil)
 */
-async function listWorkflowCategories() {
-  const workflows = await fetchAllWorkflows();
-
-  const categories = new Set();
-  workflows.forEach(w => {
-    const applicationName = w.applicationName || w.ApplicationName;
-    if (applicationName) {
-      categories.add(applicationName);
-    }
-  });
-
-  // Sort alphabetically
-  return Array.from(categories).sort();
-}
-
-/**
- * Get workflow statistics
- */
-async function getWorkflowStats() {
-  const workflows = await fetchAllWorkflows();
-  const categories = await listWorkflowCategories();
-
-  // Count workflows per applicationName (the only grouping in the data)
-  const categoryCounts = {};
-  workflows.forEach(w => {
-    const cat = w.applicationName || w.ApplicationName || '(unknown)';
-    categoryCounts[cat] = (categoryCounts[cat] || 0) + 1;
-  });
+async function getWorkflowStats(application) {
+  const app = resolveApplication(application);
+  const workflows = await fetchAllWorkflows(app);

  return {
+    application: app,
    total: workflows.length,
-    categories: categories.length,
-    categoryCounts,
-    cacheAge: cacheTimestamp ? Math.floor((Date.now() - cacheTimestamp) / 1000) : null
+    cacheAge: cacheTimestamps[app] ? Math.floor((Date.now() - cacheTimestamps[app]) / 1000) : null
  };
 }

 /**
- * Clear workflow cache (force refresh on next request)
+ * Clear workflow caches (force refresh on next request) — toutes applications.
 */
 function clearCache() {
-  workflowCache = null;
-  cacheTimestamp = null;
+  workflowCaches = {};
+  cacheTimestamps = {};
+  applicationsCache = null;
+  applicationsTimestamp = null;
  console.error('[Workflow] Cache cleared');
 }

 /**
- * Get cache status
+ * Get cache status, per application (D26)
+ * @returns {Object} application -> { cached, count, timestamp, age, valid }
 */
 function getCacheStatus() {
-  return {
-    cached: workflowCache !== null,
-    count: workflowCache ? workflowCache.length : 0,
-    timestamp: cacheTimestamp,
-    age: cacheTimestamp ? Math.floor((Date.now() - cacheTimestamp) / 1000) : null,
-    valid: isCacheValid()
+  const status = {};
+  Object.keys(workflowCaches).forEach(app => {
+    status[app] = {
+      cached: true,
+      count: workflowCaches[app].length,
+      timestamp: cacheTimestamps[app],
+      age: cacheTimestamps[app] ? Math.floor((Date.now() - cacheTimestamps[app]) / 1000) : null,
+      valid: isCacheValid(app)
    };
+  });
+  return status;
 }

 module.exports = {
  fetchAllWorkflows,
+  fetchApplications,
  searchWorkflows,
  getWorkflowDetails,
-  listWorkflowCategories,
  getWorkflowStats,
  clearCache,
  getCacheStatus
@@ -4,6 +4,7 @@
 */

 const adService = require('../services/ad-service');
+const workflowService = require('../services/workflow-service');

 /**
 * List available AD tools
@@ -12,7 +13,7 @@ function listTools() {
  return [
    {
      name: 'get_application_summary',
-      description: 'Get summary of Application Dictionary elements. Shows count of cached elements per type (Commands, Queries, Dialogs, Views, etc.). Only counts already-loaded types to avoid long waits.',
+      description: 'Get summary of Application Dictionary caches, grouped by application then element type (D26), plus the per-application workflow caches. Only already-loaded entries are detailed to avoid long waits.',
      inputSchema: {
        type: 'object',
        additionalProperties: false,
@@ -21,7 +22,7 @@ function listTools() {
    },
    {
      name: 'get_ad_elements',
-      description: 'Get all elements of a specific type from Application Dictionary. Supports: Command, Query, Dialog, View, Entity, Event, Hook, Report, Dashboard, and 11 other types (20 total). Elements are lazy-loaded and cached for 1 hour.',
+      description: 'Get all elements of a specific type from Application Dictionary. Supports: Command, Query, Dialog, View, Entity, Event, Hook, Report, Dashboard, and 11 other types (20 total). Elements are lazy-loaded and cached for 1 hour, per (application, type).',
      inputSchema: {
        type: 'object',
        additionalProperties: false,
@@ -35,6 +36,10 @@ function listTools() {
            description: 'Maximum number of elements to return (default: 100, max: 1000)',
            default: 100,
          },
+          application: {
+            type: 'string',
+            description: 'AD application to query (default: the active profile\'s application, usually EasyWMS). Client-specific elements live in "CustomApp" (CST_* prefix). Full list via list_workflow_categories.',
+          },
        },
        required: ['element_type'],
      },
@@ -59,6 +64,10 @@ function listTools() {
            description: 'Maximum results (default: 50)',
            default: 50,
          },
+          application: {
+            type: 'string',
+            description: 'AD application to search in (default: the active profile\'s application, usually EasyWMS). Client-specific elements live in "CustomApp" (CST_* prefix).',
+          },
        },
        required: ['element_type', 'query'],
      },
@@ -78,6 +87,10 @@ function listTools() {
            type: 'string',
            description: 'Element ID or name',
          },
+          application: {
+            type: 'string',
+            description: 'AD application the element belongs to (default: the active profile\'s application, usually EasyWMS). Client-specific elements live in "CustomApp" (CST_* prefix).',
+          },
        },
        required: ['element_type', 'element_id'],
      },
@@ -140,23 +153,22 @@ async function executeTool(name, args) {
 async function getApplicationSummaryTool(args) {
  console.error('[ADTools] Getting application summary');

-  const summary = adService.getApplicationSummary();
+  // État par (application, type) — seules les entrées en cache sont
+  // détaillées, la sortie reste bornée quel que soit le nombre
+  // d'applications interrogées (D24, D26).
+  const adByApplication = adService.getApplicationSummary();
+  const workflowsByApplication = workflowService.getCacheStatus();

-  // Calculate totals
-  let totalCached = 0;
+  let cachedEntries = 0;
  let totalElements = 0;
-  const cachedTypes = [];
-  const uncachedTypes = [];
-
-  Object.entries(summary).forEach(([type, info]) => {
-    if (info.cached) {
-      totalCached++;
+  Object.values(adByApplication).forEach(types => {
+    Object.values(types).forEach(info => {
+      cachedEntries++;
      totalElements += info.count;
-      cachedTypes.push(type);
-    } else {
-      uncachedTypes.push(type);
-    }
    });
+  });
+
+  const availableTypes = adService.getAvailableTypes();

  return {
    content: [{
@@ -164,14 +176,14 @@ async function getApplicationSummaryTool(args) {
      text: JSON.stringify({
        success: true,
        summary: {
-          totalTypes: Object.keys(summary).length,
-          cachedTypes: totalCached,
-          uncachedTypes: uncachedTypes.length,
-          totalElements: totalElements
+          availableTypes: availableTypes.length,
+          cachedEntries,
+          totalElements,
+          applications: Object.keys(adByApplication)
        },
-        elementCounts: summary,
-        cached: cachedTypes,
-        notCached: uncachedTypes
+        adElementsByApplication: adByApplication,
+        workflowCachesByApplication: workflowsByApplication,
+        note: 'Caches AD par (application, type) et caches workflows par application — chargés paresseusement à la première demande. Types valides via list_ad_types.'
      }, null, 2)
    }]
  };
@@ -181,11 +193,11 @@ async function getApplicationSummaryTool(args) {
 * Tool: get_ad_elements
 */
 async function getADElementsTool(args) {
-  const { element_type, limit = 100 } = args;
+  const { element_type, limit = 100, application } = args;

-  console.error(`[ADTools] Getting ${element_type} elements (limit: ${limit})`);
+  console.error(`[ADTools] Getting ${element_type} elements (limit: ${limit}, application: ${application || '(profil)'})`);

-  const elements = await adService.getElements(element_type);
+  const elements = await adService.getElements(element_type, application);

  // Limit results
  const limitedElements = elements.slice(0, Math.min(limit, 1000));
@@ -208,6 +220,7 @@ async function getADElementsTool(args) {
      text: JSON.stringify({
        success: true,
        elementType: element_type,
+        ...(application ? { application } : {}),
        count: elements.length,
        returned: mappedElements.length,
        elements: mappedElements
@@ -220,11 +233,11 @@ async function getADElementsTool(args) {
 * Tool: search_ad_elements
 */
 async function searchADElementsTool(args) {
-  const { element_type, query, limit = 50 } = args;
+  const { element_type, query, limit = 50, application } = args;

-  console.error(`[ADTools] Searching ${element_type}: query="${query}", limit=${limit}`);
+  console.error(`[ADTools] Searching ${element_type}: query="${query}", limit=${limit}, application=${application || '(profil)'}`);

-  const results = await adService.searchElements(element_type, query, limit);
+  const results = await adService.searchElements(element_type, query, limit, application);

  // Map to simplified format
  const mappedResults = results.map(e => ({
@@ -240,6 +253,7 @@ async function searchADElementsTool(args) {
      text: JSON.stringify({
        success: true,
        elementType: element_type,
+        ...(application ? { application } : {}),
        query,
        count: mappedResults.length,
        elements: mappedResults
@@ -252,11 +266,11 @@ async function searchADElementsTool(args) {
 * Tool: get_ad_element_details
 */
 async function getADElementDetailsTool(args) {
-  const { element_type, element_id } = args;
+  const { element_type, element_id, application } = args;

-  console.error(`[ADTools] Getting ${element_type} details: ${element_id}`);
+  console.error(`[ADTools] Getting ${element_type} details: ${element_id} (application: ${application || '(profil)'})`);

-  const element = await adService.getElementDetails(element_type, element_id);
+  const element = await adService.getElementDetails(element_type, element_id, application);

  return {
    content: [{
@@ -264,6 +278,7 @@ async function getADElementDetailsTool(args) {
      text: JSON.stringify({
        success: true,
        elementType: element_type,
+        ...(application ? { application } : {}),
        element
      }, null, 2)
    }]
@@ -1,5 +1,6 @@
 const apiService = require('../services/api-service').getInstance();
 const entityResolver = require('../services/entity-resolver');
+const { assertValidQueryType } = require('../services/wms-query-service');

 /**
 * Tools MCP pour interagir avec les APIs WMS
@@ -36,6 +37,11 @@ function listTools() {
            description: 'Limite de résultats (défaut: 100)',
            default: 100,
          },
+          query_type: {
+            type: 'number',
+            description: 'QueryContextType (défaut: 0 = Reading — statuts en chaînes, à garder sauf raison explicite). Opt-in : 1 = Writing (statuts en ÉNUMÉRATIONS — les comparaisons de chaînes comme == "Release" ÉCHOUENT), 2 = DataWarehouse (souvent non configuré), 3 = Metrics (modèle de données distinct). En query_type != 0, un nom d\'entité inconnu du Metadata Reading est transmis tel quel avec un warning.',
+            default: 0,
+          },
        },
        required: ['entity_type'],
      },
@@ -85,12 +91,23 @@ async function executeTool(name, args) {
 * Tool: call_query_api
 */
 async function callQueryAPI(args) {
-  const { entity_type, expression = 'z => z', filter, limit = 100 } = args;
+  const { entity_type, expression = 'z => z', filter, limit = 100, query_type = 0 } = args;
+
+  // Conservé hors du try : si la requête échoue ensuite côté WMS, le warning
+  // de résolution (nom hors Reading) reste dans la réponse d'erreur.
+  let resolution = null;

  try {
+    // Garde de valeur avant tout réseau (D25) — le wrapper D23 ne valide pas
+    // les valeurs.
+    const queryType = assertValidQueryType(query_type);
+
    // Résolution Name/TableName -> TableName (D21) — échec avant appel réseau
-    // sur nom inconnu.
-    const { tableName, warning } = await entityResolver.resolveEntityType(entity_type);
+    // sur nom inconnu, sauf en query_type != 0 (passage tel quel + warning, D25).
+    resolution = await entityResolver.resolveEntityType(entity_type, {
+      allowUnknown: queryType !== 0,
+    });
+    const { tableName, warning } = resolution;

    // Expression = Context.Entity + optional Where + OrderBy (required by EF when Take is used)
    let linqExpression = `Context.${tableName}`;
@@ -103,6 +120,7 @@ async function callQueryAPI(args) {
    const result = await apiService.executeQuery(linqExpression, {
      take: limit || undefined,
      select: expression !== 'z => z' ? expression : undefined,
+      queryType,
    });

    return {
@@ -115,6 +133,7 @@ async function callQueryAPI(args) {
              entityType: entity_type,
              resolvedTableName: tableName,
              ...(warning ? { warning } : {}),
+              ...(queryType !== 0 ? { queryType } : {}),
              result,
            },
            null,
@@ -132,6 +151,7 @@ async function callQueryAPI(args) {
            {
              success: false,
              error: err.message,
+              ...(resolution?.warning ? { warning: resolution.warning } : {}),
            },
            null,
            2
@@ -13,7 +13,7 @@ function listTools() {
    {
      name: 'query_wms_entities',
      description: `Query WMS entities using LINQ expressions. Returns rows (up to 1000).
-Uses QueryExecute with QueryType=Reading — status fields are STRINGS (enum names, not integers).
+Uses QueryExecute with QueryType=Reading by default — status fields are STRINGS (enum names, not integers). Other contexts via query_type (opt-in, see the parameter warning).
 Common entities: Products, Containers, Tasks, Stocks, ProductLocations, Locations, InboundOrders, OutboundOrders, Receptions, Accounts, Suppliers, Kits, Alias. Full list via get_entity_metadata.
 entity_type accepts the AD entity name (Container) or the TableName (Containers), case-insensitive — resolved via the Metadata API.

@@ -44,6 +44,11 @@ Never guess enum string values — they differ between Reading and Writing model
            description: 'Maximum results to return (default: 100, max: 1000)',
            default: 100,
          },
+          query_type: {
+            type: 'number',
+            description: 'QueryContextType (default: 0 = Reading — status fields are strings, keep it unless you know why). Opt-in: 1 = Writing (status fields become ENUMS — string comparisons like == "Release" FAIL), 2 = DataWarehouse (often not configured), 3 = Metrics (different data model). Entity names unknown to the Reading metadata are passed through as-is with a warning when query_type != 0.',
+            default: 0,
+          },
        },
        required: ['entity_type'],
      },
@@ -96,6 +101,11 @@ Verified values (curl-tested):
            type: 'string',
            description: 'Optional LINQ filter condition. Status fields are strings (enum names from Reading model). Always verify enum values via docs://entities/ before use.',
          },
+          query_type: {
+            type: 'number',
+            description: 'QueryContextType (default: 0 = Reading — status fields are strings, keep it unless you know why). Opt-in: 1 = Writing (status fields become ENUMS — string comparisons like == "Release" FAIL), 2 = DataWarehouse (often not configured), 3 = Metrics (different data model). Entity names unknown to the Reading metadata are passed through as-is with a warning when query_type != 0.',
+            default: 0,
+          },
        },
        required: ['entity_type'],
      },
@@ -169,15 +179,16 @@ async function executeTool(name, args) {
 * Tool: query_wms_entities
 */
 async function queryWmsEntities(args) {
-  const { entity_type, select_expression = 'z => z', filter, limit = 100 } = args;
+  const { entity_type, select_expression = 'z => z', filter, limit = 100, query_type = 0 } = args;

-  console.error(`[WMSQueryTools] Querying ${entity_type}: limit=${limit}`);
+  console.error(`[WMSQueryTools] Querying ${entity_type}: limit=${limit} query_type=${query_type}`);

  const result = await wmsQueryService.queryEntities(
    entity_type,
    select_expression,
    filter,
-    limit
+    limit,
+    query_type
  );

  return {
@@ -195,11 +206,11 @@ async function queryWmsEntities(args) {
 * Tool: count_wms_entities
 */
 async function countWmsEntities(args) {
-  const { entity_type, filter } = args;
+  const { entity_type, filter, query_type = 0 } = args;

-  console.error(`[WMSQueryTools] Counting ${entity_type}${filter ? ` where ${filter}` : ''}`);
+  console.error(`[WMSQueryTools] Counting ${entity_type}${filter ? ` where ${filter}` : ''} query_type=${query_type}`);

-  const result = await wmsQueryService.countEntities(entity_type, filter || null);
+  const result = await wmsQueryService.countEntities(entity_type, filter || null, query_type);

  return {
    content: [{
@@ -12,7 +12,7 @@ function listTools() {
  return [
    {
      name: 'search_workflows',
-      description: 'Search workflows by name, description, or code. Returns matching workflows with metadata. Workflows are lazy-loaded from API on first request and cached for 1 hour.',
+      description: 'Search workflows by name. Returns matching workflows with metadata. Workflows are lazy-loaded from API on first request and cached for 1 hour, per application. Client-specific workflows (CST_* prefix) live in the "CustomApp" application — pass application: "CustomApp" to search them.',
      inputSchema: {
        type: 'object',
        additionalProperties: false,
@@ -23,26 +23,34 @@ function listTools() {
          },
          category: {
            type: 'string',
-            description: 'Filter by applicationName — the only grouping the AD API provides (workflows have no category field). All workflows of the active application share the same value (e.g. "EasyWMS").',
+            description: 'Filter by the applicationName field of the returned workflows (workflows have no category field). Since `application` selects which application is fetched, all its workflows share the same applicationName — prefer `application` to change scope; `category` only narrows within the fetched set.',
          },
          limit: {
            type: 'number',
            description: 'Maximum results to return (default: 50)',
            default: 50,
          },
+          application: {
+            type: 'string',
+            description: 'AD application whose workflows are searched (default: the active profile\'s application, usually EasyWMS). Client-specific workflows live in "CustomApp". Full list via list_workflow_categories.',
+          },
        },
      },
    },
    {
      name: 'get_workflow_details',
-      description: 'Get full details of a specific workflow by ID or code',
+      description: 'Get full details of a specific workflow by ID or name',
      inputSchema: {
        type: 'object',
        additionalProperties: false,
        properties: {
          workflow_id: {
            type: 'string',
-            description: 'Workflow ID or code',
+            description: 'Workflow ID or exact name',
+          },
+          application: {
+            type: 'string',
+            description: 'AD application the workflow belongs to (default: the active profile\'s application, usually EasyWMS). Client-specific workflows (CST_*) live in "CustomApp".',
          },
        },
        required: ['workflow_id'],
@@ -50,11 +58,16 @@ function listTools() {
    },
    {
      name: 'list_workflow_categories',
-      description: 'List workflow groupings by applicationName. Workflows have no category field in the AD API — applicationName is the only grouping available, and all workflows of the active application share the same value.',
+      description: 'List the AD applications declared on the tenant (Application/GetAll) with their workflow counts where already loaded. Workflows have no category field — the application is the only grouping. Use the `application` parameter of the workflow/AD tools to query a specific one (e.g. "CustomApp" for client-specific CST_* workflows).',
      inputSchema: {
        type: 'object',
        additionalProperties: false,
-        properties: {},
+        properties: {
+          application: {
+            type: 'string',
+            description: 'Load and count the workflows of this application (default: the active profile\'s application). Other applications are listed without loading them.',
+          },
+        },
      },
    },
  ];
@@ -98,17 +111,18 @@ async function executeTool(name, args) {
 * Tool: search_workflows
 */
 async function searchWorkflows(args) {
-  const { query, category, limit = 50 } = args;
+  const { query, category, limit = 50, application } = args;

-  console.error(`[WorkflowTools] Searching workflows: query="${query}", category="${category}", limit=${limit}`);
+  console.error(`[WorkflowTools] Searching workflows: query="${query}", category="${category}", limit=${limit}, application=${application || '(profil)'}`);

-  const results = await workflowService.searchWorkflows(query, category, limit);
+  const results = await workflowService.searchWorkflows(query, category, limit, application);

  return {
    content: [{
      type: 'text',
      text: JSON.stringify({
        success: true,
+        ...(application ? { application } : {}),
        count: results.length,
        // Clés réelles de l'API AD (minuscules, cf. D5) : id, name, version,
        // applicationName, commonInfo. Pas de code/category/description.
@@ -133,11 +147,11 @@ async function searchWorkflows(args) {
 * Tool: get_workflow_details
 */
 async function getWorkflowDetails(args) {
-  const { workflow_id } = args;
+  const { workflow_id, application } = args;

-  console.error(`[WorkflowTools] Getting workflow details: ${workflow_id}`);
+  console.error(`[WorkflowTools] Getting workflow details: ${workflow_id} (application: ${application || '(profil)'})`);

-  const workflow = await workflowService.getWorkflowDetails(workflow_id);
+  const workflow = await workflowService.getWorkflowDetails(workflow_id, application);

  return {
    content: [{
@@ -154,22 +168,37 @@ async function getWorkflowDetails(args) {
 * Tool: list_workflow_categories
 */
 async function listWorkflowCategories(args) {
-  console.error('[WorkflowTools] Listing workflow categories');
+  const { application } = args || {};

-  const categories = await workflowService.listWorkflowCategories();
-  const stats = await workflowService.getWorkflowStats();
+  console.error(`[WorkflowTools] Listing applications (workflow groupings), application=${application || '(profil)'}`);
+
+  // La liste vient d'Application/GetAll (9 applications sur le tenant mesuré),
+  // pas des applicationName du seul cache actif (D26). Seule l'application
+  // demandée (ou celle du profil) est chargée — pas de préchargement des
+  // autres (D10) : leurs comptes n'apparaissent que si déjà en cache.
+  const applications = await workflowService.fetchApplications();
+  const stats = await workflowService.getWorkflowStats(application);
+  const cacheStatus = workflowService.getCacheStatus();
+
+  const enriched = applications.map(a => ({
+    name: a.name,
+    version: a.version,
+    ...(cacheStatus[a.name]
+      ? { workflowCount: cacheStatus[a.name].count, cacheAge: cacheStatus[a.name].age }
+      : { workflowCount: null }),
+  }));

  return {
    content: [{
      type: 'text',
      text: JSON.stringify({
        success: true,
-        note: 'Workflows have no category field in the AD API — these are the distinct applicationName values, the only grouping available. All workflows of the active application share the same value.',
-        totalCategories: categories.length,
-        categories,
-        stats: {
+        note: 'Workflows have no category field in the AD API — the application is the only grouping. workflowCount is only known for applications already loaded (lazy loading); pass application to search_workflows/get_ad_elements to load one.',
+        totalApplications: applications.length,
+        applications: enriched,
+        loaded: {
+          application: stats.application,
          totalWorkflows: stats.total,
-          categoryCounts: stats.categoryCounts,
          cacheAge: stats.cacheAge
        }
      }, null, 2)
Author	SHA1	Message	Date
Arthur Ria	90b2c89ff1	Passation lot 5 : clore la famille D24 (fenêtre workflow, garde requêtes, champ tool) Deux mesures nouvelles du 25/08/2026 aggravent le dossier : une requête Reading ordinaire query_wms_entities(Products, limit 200) pèse 957 234 caractères et search_wms_data(PAL) 847 543 — le dépassement du seuil de rejet client (~70 000, D24) ne se limite donc pas au Writing ni aux workflows. Les points ouverts correspondants deviennent un lot 5 planifié dans la ROADMAP (L5.1 fenêtre verbatim sur le blob data, L5.2 garde de taille commune aux trois outils de requête avec le cas limite d'une ligne seule au-dessus du plafond, L5.3 balayage du champ tool). Pas de nouveau numéro de décision : le lot étend D24. D27 réservable si besoin. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-25 11:57:39 +02:00
Arthur Ria	b941f367ae	Révision lot 4 : validé ; ligne Writing énorme et champ tool absent consignés Les vérifications attendues des trois blocs rejouées via le protocole passent : api://catalog assaini (plus de QueryType 1, d'Aliases ni de suffixe d'assembly), query_type opérationnel (Writing 1 ligne, Metrics en erreur parlante, 7 rejeté localement sans aucun trafic réseau, warning de résolution conservé jusque dans l'échec WMS), caches par application étanches (4012/153, retour en cache hit, invalidation complète à la bascule). Baseline 23/6, npm test 4/4 exit 0, diffs propres. Deux découvertes consignées en points ouverts : une ligne Products en Writing pèse 95 288 caractères (famille D24), et les catch locaux d'api-tools omettent le champ tool du contrat (antérieur au lot). Leçon de révision : mon appel search_workflows(search_term=...) des lots précédents était silencieusement ignoré pré-D23 — le paramètre s'appelle query. La validation D23 a transformé mon erreur en signal. handoff-lot4.md supprimé (livré et révisé). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-25 11:46:50 +02:00
Arthur Ria	92de85cf53	L4.2 : paramètre application sur les outils AD et workflow (D26) L'application venait de WMS_APPLICATION (partagée par tous les profils) : le MCP n'interrogeait que EasyWMS, alors que CustomApp porte le spécifique client (153 workflows CST_ sur ce tenant) et que 9 applications sont déclarées par Application/GetAll. Paramètre application (défaut : l'application du profil, comportement inchangé sans lui) sur get_ad_elements, search_ad_elements, get_ad_element_details, search_workflows, get_workflow_details, list_workflow_categories. Clés de cache : ad-service passe par (application, type), workflow-service par application — sans quoi un appel CustomApp polluerait le cache EasyWMS. L'invalidation reste l'abonnement onSwitch (D8), le chargement reste paresseux (aucun préchargement des 9 applications, D10). list_workflow_categories s'adosse à Application/GetAll (liste allégée en cache : le blob data de chaque application pèse ~100 Ko) ; get_application_summary regroupe par application et ne détaille que les entrées en cache (D24), workflows compris. Acté en D26 ; CLAUDE.md mis à jour (Caches, AD), L4.2 retiré de la ROADMAP. Vérifications rejouées via le protocole (LIMAGRAIN / LIMAGRAI2512), requêtes séquentielles : - search_workflows(CST_, application:CustomApp) -> 5 objets peuplés dont CST_SendRejectContainersToPK ([Workflow] Successfully cached 153 workflows for "CustomApp"). - get_ad_elements(Workflow, application:CustomApp) -> count 153, éléments CST_* ([AD] Successfully cached 153 CustomApp::Workflow). - Séquence EasyWMS -> CustomApp -> EasyWMS sur search_workflows : 4012 vs 153, retour en cache hit ([Workflow] Using cached data for "EasyWMS"), aucune pollution ; get_application_summary montre les deux caches (workflowCachesByApplication EasyWMS 4012 / CustomApp 153). - Sans paramètre application -> comportement inchangé (W1 = W3). - switch_wms_profile EUROTRAFIC puis retour -> [Workflow] Cache cleared, [AD] All caches invalidated, [EntityResolver] Cache cleared ; summary vide. - list_workflow_categories -> 9 applications, comptes réels des applications chargées. Baseline : tools/list 23 (les 23 noms répondent), resources 6, rejet D23 d'un paramètre inconnu OK (search_workflows/applikation), npm test 4/4 exit 0. Anomalie hors périmètre consignée dans ROADMAP.md : get_workflow_details peut dépasser le seuil de rejet client (~101 800 caractères mesurés sur CST_SendRejectContainersToPK), comportement antérieur au lot. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-25 11:24:12 +02:00
Arthur Ria	706e628715	L4.1 : expose query_type sur les outils de requête (D25) QueryType était figé à 0 en dur dans executeQuery/executeScalarQuery : le modèle Writing, opérationnel et mesuré, était inatteignable. Paramètre query_type (défaut 0) sur call_query_api, query_wms_entities, count_wms_entities — get_entity_schema et search_wms_data restent des raccourcis Reading. D3 reste la règle par défaut : la bascule est un opt-in, avertie dans les descriptions d'outils (statuts en énumérations en Writing). Garde de valeur assertValidQueryType dans le code (le wrapper D23 ne valide pas les valeurs), avant tout réseau. En query_type != 0, un nom inconnu du Metadata Reading passe tel quel avec warning (allowUnknown du resolver) — conservé aussi dans la réponse d'erreur si le WMS échoue ensuite. Acté en D25 ; CLAUDE.md nuancé, L4.1 retiré de la ROADMAP (reliquat : exploration Metrics, rapport à part). Vérifications rejouées via le protocole (LIMAGRAIN / LIMAGRAI2512) : - call_query_api(Products, query_type:1, limit:1) -> success, 1 ligne, queryType:1 dans la réponse. - call_query_api(Products, query_type:3) -> erreur structurée contenant 'ApplicationMetricDataContext' ne contient pas de définition pour 'Products'. - call_query_api(Products, query_type:7) -> erreur locale nommant les 4 contextes, aucun [API] POST/GET dans stderr. - query_wms_entities(Container, limit:1) sans query_type -> comportement inchangé (resolvedTableName Containers, Reading, pas de champ queryType). - call_query_api(FooBar123, query_type:1) -> transmis tel quel (payload QueryType:1 Expression Context.FooBar123...), erreur WMS ApplicationWritingRepository + warning de résolution dans la réponse. - count_wms_entities(Product, query_type:1) -> count 51145 (~51160). Baseline : tools/list 23, resources 6, rejet D23 d'un paramètre inconnu OK. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-25 11:17:10 +02:00
Arthur Ria	88dab289cc	L4.0 (suite) : retire L4.0 de la ROADMAP, oublié au commit précédent Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-25 11:16:17 +02:00
Arthur Ria	cc34894ae4	L4.0 : corrige api://catalog qui enseignait le piège D3 La resource api://catalog, lue par les sessions Claude, contredisait les décisions actées : - exemple QueryExecute en QueryType 1 (D3 interdit de le recopier) ; - Select/Take dans l'expression, contraire à la répartition expression/options et à D13 (projections instables) ; - entité fantôme Aliases (corrigée partout ailleurs au lot 2) ; - exemple Command avec suffixe d'assembly, cause de FileLoadException (D14) ; - réponse Workflow décrite avec des champs inexistants (Category, Status, Definition) au lieu des clés réelles minuscules id/name/version/ applicationName/commonInfo (D4, D5) ; - section Configuration décrivant l'ancien .env mono-profil (D8). L'exemple passe en QueryType 0 avec les règles de répartition, la liste d'entités renvoie vers get_entity_metadata comme source de vérité, la réponse AD documente l'enveloppe { entities: [...] }. Vérifié via le protocole (resources/read api://catalog) : contient "QueryType": 1 : false contient Aliases : false renvoie vers get_entity_metadata : true tools/list : 23 outils, resources : inchangées. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-25 11:12:14 +02:00
Arthur Ria	35b53dbef5	Passation lot 4 : query_type, application AD/workflow, catalog D3 (L4.0-L4.2) Mesures rafraîchies du 25/08/2026 : Writing (QueryType 1) répond 1 ligne sur Context.Products, Metrics (3) existe sans Products, CustomApp renvoie ses workflows CST_ sous la clé entities de GetByApplication. Découverte consignée en L4.0 : la resource api://catalog documente un exemple QueryType: 1 (le piège D3), un Select dans l'expression et l'entité fantôme Aliases. D25 (rapport D3/query_type) et D26 (clés de cache par application) réservées. L4.3-L4.5 et l'exploration Metrics explicitement hors périmètre. Le point délicat resolver/Writing est cadré : nom inconnu du Reading transmis tel quel avec warning quand query_type != 0. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-25 10:58:50 +02:00