Table of Contents

🇬🇧 English version

Voir aussi : Retour à l'index

Limites et contraintes connues

  • InMemoryUnitOfWork n'a par conception aucune étape de persistance durable : les agrégats vivent dans les repositories in-memory et SaveChangesAsync se réduit au dispatch (réel et ordonné) des événements de domaine. Un adapter durable remplacerait cet adapter dans son ensemble ; le code ne porte aucune migration EF.
  • Persistance d'état d'exécution : par défaut, les états d'exécution de crew (ICrewExecutionStateManager) sont in-memory only (pas de reprise après crash). La persistance durable est opt-in : choisir un state store de checkpointing — la section Orkeon:Checkpointing (Enabled, Store json, sqlite ou postgres), lue par orkeon run et orkeon-host, ou AddOrkeonCheckpointing(configuration) / AddOrkeonSqliteCheckpointing / AddOrkeonPostgresCheckpointing dans un hôte écrit en C# — et activer AddCrewExecutionStatePersistence(...) (ou la section Orkeon:ExecutionState:Persistence). Un run échoué ou tué se reprend avec orkeon run --resume <id>|latest à la granularité de la tâche : chaque tâche qu'un run termine est checkpointée à sa fin, et un run repris répond à celles-là depuis le checkpoint sans appeler le modèle. Les décisions du manager d'une crew Hierarchical ou Autonomous sont rejouées en direct à la reprise (seules les tâches sont gardées : le manager est interrogé de nouveau pour affecter et relire), une tâche de décision (decision:) est reposée en Sequential et en Parallel (Graph checkpointe la route qu'une décision a prise et la rejoue), et une tâche en cours quand le processus est mort repart de son début. Une tâche modifiée entre les runs (sa description ou sa sortie attendue telles que les variables du run les remplissent, donc un --var changé compte, son agent ou ses dépendances) est rejouée, ainsi que chaque tâche qui s'exécute après elle, puisque ce qu'elles liraient de sa sortie est périmé ; l'hôte journalise un avertissement qui la nomme. --resume latest prend le run le plus récent de la crew qui n'est pas terminé (un run terminé plus récent ne cache pas un run échoué plus ancien) ; un run encore marqué Running n'est pas repris par latest, car le magasin ne tient aucun bail et il peut être vivant dans un autre processus : le refus donne son id, et --resume <id> le reprend. Une session qui attend une réponse, ou marquée en échec, est refusée par latest, et par son id, seulement quand l'historique des runs prouve son propriétaire vivant (enregistré en cours avec un processus vivant sur cet hôte, ou lancé sur un autre hôte) ; sans trace dans l'historique, elle est reprise. Faute de bail, rien d'autre n'empêche deux processus de reprendre le même run par son id en même temps. Un run se reprend depuis l'endroit où il a été lancé : déplacer ou renommer le checkout (ou le fichier de crew) change la clé de crew et orpheline ses runs précédents. Deux limites de l'identité du run : l'id de tâche A2A et celui de l'API ne sont pas unifiés avec l'id du run (StateStoreA2ATaskStore reste sur sa propre clé __a2a__ et ses propres ids de tâche). La clé de crew d'une session est le nom de la crew, le chemin virtuel de son fichier et une courte empreinte du chemin complet de ce fichier (deux dossiers se lisent tous deux /crew pour le système de fichiers virtuel) : deux crews de même nom ne partagent jamais une session. Orkeon:Checkpointing:Store sans Enabled: true est ignoré et l'hôte le dit à son démarrage. Une fois activée, les états sont persistés à chaque transition et rechargés/réutilisés après redémarrage — voir Sous-systèmes opt-in. Limites v1 : métadonnées persistées en chaînes invariantes, ToolsUsed non persisté.
  • Le framework cible .NET 10 — sa version est définie dans src/Directory.Build.props. .NET 11 n'est pas une cible : ci.yml construit et teste la solution avec le SDK 11.x (job build-test-net11) en guise d'alerte précoce, et les deux dotnet tools (orkeon, orkeon-repl) acceptent un runtime majeur plus récent (RollForward=Major) pour qu'une machine n'ayant que .NET 11 puisse les exécuter. Le passage du target framework, de global.json et des images de base des conteneurs à .NET 11 est prévu ; le CHANGELOG le consignera quand il aura lieu.
  • Le périmètre fonctionnel est gelé à 16 fournisseurs LLM (quatorze vendeurs et deux agrégateurs — OpenRouter et Mammouth AI, la première exception motivée au gel, intégrés documentation d'abord et campagnés le 2026-10-07), 124 outils intégrés (la famille e-mail est la deuxième exception motivée ; Gmail et Hotmail via Graph sont campagnés, Outlook en IMAP et SMTP n'a pas été joué ; la famille drive — Google Drive et OneDrive — est la troisième, campagnée sur des comptes personnels ; l'outil firefox est la quatrième) et 6 stores de mémoire tant que de vrais utilisateurs n'en demandent pas davantage : un mainteneur unique porte toute la surface, et chaque ajout est un coût permanent. Pas de 17ᵉ fournisseur : les endpoints qui parlent le dialecte OpenAI n'ont pas besoin de fournisseur (pointez Llm:BaseUrl dessus) ; les outils s'écrivent en scripts .ork.ts ou en plugins. La règle et ce qui reste bienvenu sont dans CONTRIBUTING.fr.md.
  • Pas d'API batch : les points d'accès batch asynchrones des fournisseurs (Anthropic Message Batches, OpenAI Batch et leurs pairs) ne sont pas pilotés. Un batch répond à l'échelle de l'heure et n'accepte aucun appel d'outil interactif : il ne peut pas porter la boucle agentique (appel, résultat d'outil, appel), et le servir demanderait un mode d'exécution différé qui n'existe pas. Un run qui voudrait le tarif batch n'a aucun chemin pour l'obtenir ; la bascule d'un profil ne s'en sert pas non plus.
  • Une clé de LLM est la clé, jamais un nom de secret. LlmConfig porte la clé d'API elle-même (LlmConfig.ApiKey) ; rien dans le framework ne lit une clé de LLM dans un coffre de secrets. Un hôte qui y garde ses clés résout la clé lui-même et l'affecte à ApiKey ; les chemins supportés pour la fournir sont le fichier de settings (Llm:ApiKey), l'environnement (ORKEON_Llm__ApiKey) et — pour garder la clé hors du fichier — la variable que nomme le fichier (Llm:ApiKeyEnvVar, et par profil Llm:Profiles:<nom>:ApiKeyEnvVar, lue dans l'environnement du processus puis dans la portée Utilisateur de Windows ; voir la configuration).
  • Le streaming LLM est uniforme à la frontière du framework : les 16 providers héritent du lecteur de streaming SSE/NDJSON de HttpLlmProviderBase (IStreamingLlmProvider). SupportsStreaming n'est pas un true inconditionnel : il suit le fait que le provider soit réellement utilisable (une clé d'API quand le fournisseur en exige une, plus l'endpoint de ressource pour Azure), si bien qu'un provider non configuré déclare false et que tout appelant qui teste la capacité prend le chemin tamponné — celui qui rend la réponse explicite « API key is required » — au lieu d'une branche SSE qui se terminerait sans le moindre chunk. L'exception restante par provider est le /api/chat d'Ollama (voir l'entrée Ollama ci-dessous). Un appel streamé court entier sous Llm:TimeoutSeconds et, quand il est posé, sous Llm:StreamIdleSeconds entre deux chunks ; deux bords subsistent : sur la phase des en-têtes le même délai court deux fois (HttpClient.Timeout et le budget du flux, démarrés à un instant d'écart), si bien qu'un délai atteint peut coûter une tentative de connexion de plus avant que l'échec soit rapporté ; et les flux texte seul (GenerateStreamingAsync), qui ne portent aucune métadonnée, ne peuvent pas signaler un flux fermé sans son marqueur de fin après un début de texte — ils se terminent normalement, là où le flux chat porte stream_truncated.
  • Le fournisseur mock diffuse en un seul fragment : Provider: mock (orkeon run --llm-mock) émule le flux en envoyant toute la réponse comme un seul événement de contenu avant la réponse complète, et ne déclare aucun flux natif ; il apparie le dernier message utilisateur d'un appel, pas toute la conversation, et il n'a aucun drapeau de capacité « appel d'outil natif » à déclarer — le framework n'en a pas : ses appels d'outil sont un corps de réponse à la forme OpenAI (choices[0].message.tool_calls), que lit la stratégie d'appel d'outil par défaut de l'hôte, comme elle lit celui d'Ollama, et une crew avec un vrai outil le parcourt de bout en bout. Un hôte qui enregistre une autre stratégie lit ce corps avec elle, et un appel d'outil du mock peut alors ne pas s'y analyser. Le dossier de son fichier de réponses est un montage interne : il ne peut contenir ni la crew ni le script.
  • Une cassette fige les réponses du modèle, pas le run : --llm-record et --llm-replay (guide) rangent chaque appel sous un hachage du profil, des messages, du message système, des outils et du mode d'outil, du format de réponse et de la grammaire ; tout changement d'un prompt, d'un outil ou du format est donc un échec de rejeu (ReplayMissException, jamais un appel réseau) jusqu'à ce que la cassette soit réenregistrée. Les outils s'exécutent de nouveau au rejeu, et les embeddings comme la mémoire ne sont pas enregistrés. La clé tient aussi le modèle et les options d'échantillonnage (température, top-p, graine, pénalités, séquences d'arrêt, nombre maximal de jetons, réflexion) : en changer un est aussi un échec de rejeu. Une cassette n'est masquée que pour la clé configurée et les motifs listés (dans un appel en flux, sur les deltas réunis, si bien qu'un secret coupé entre deux deltas est masqué aussi), et la clé est calculée sur la forme masquée ; un secret qu'aucun motif ne reconnaît n'est ni masqué ni reporté dans la clé : relisez une cassette avant de la versionner. Deux agents qui demandent la même clé au même instant prennent les réponses enregistrées dans l'ordre où ils les demandent : un run dont des appels parallèles identiques changent d'ordre peut les permuter.
  • Le compteur de tokens compte les appels de génération — tous, et seulement eux. cost.updated et run.finished additionnent les appels d'une exécution à travers l'unique décorateur de mesure qui enveloppe chaque fournisseur : les tours d'agent et leurs relances, le manager hiérarchique, le planificateur, les pipelines RAG, les services mémoire, les juges LLM et les appels ctx.llm.*. Les appels d'embeddings ne sont pas comptés — les vecteurs de l'ingestion et de la recherche RAG, de semantic_search, de l'indexation RaggableTree et de la mémoire d'une crew (ce qu'elle range et ce qu'elle rappelle) viennent des ports d'embeddings, que le total ↑/↓ ne voit pas. Deux conséquences de l'emplacement du compteur : un fournisseur qu'un hôte enregistre lui-même n'est mesuré que s'il passe par AddOrkeonLlmProvider ou AddOrkeonLlmProfile, ou s'il est donné au manager d'une crew par CrewBuilder.WithManagerLlm ou à son planificateur par CrewBuilder.WithPlanningLlm (un IChatClient qui ne repose pas sur un ILlmProvider Orkeon n'est pas mesuré du tout), et un flux texte seul, qui ne porte aucun usage, est compté à sa fin sur estimation — signalée par estimatedTokens, jamais chiffrée en coût.
  • A2A dans les binaires livrés : orkeon-host sert les crews qu'expose Orkeon:Host:A2A — une compétence par crew, une tâche étant un run de cette crew par le runner qu'emprunte un message de chat (ses montages, sa borne de concurrence, le délai de l'hôte), le démarrage refusé quand l'écoute irait au-delà de la boucle locale sans authentification — voir Hôte de service ; il ne garde aucun enregistrement de tâche (GET /a2a/tasks/{id} répond 501). L'API de run et les sondes de santé sont un listener à part, éteint sauf Orkeon:Host:Api:Enabled — voir l'API du host : POST /runs/{id}/input répond à la question d'entrée humaine en attente d'un run (200 delivered pour un run tenu, 202 recorded pour un run suspendu), et ses clés d'idempotence ne survivent à un redémarrage que par l'historique de runs. orkeon run et le REPL ne servent pas A2A : un run unique n'a rien à écouter. orkeon-host connecte aussi les MCP:Servers au démarrage, comme orkeon run et orkeon-repl — voir Intégration MCP. Un hôte C# qui appelle AddOrkeonA2A obtient un serveur démarré avec l'hôte générique (EnableServer) dont le routeur exécute l'agent que désigne une tâche — voir Conformité A2A.
  • Défauts DI délibérément minimaux — IKnowledgeStore (in-memory, non persistant ; son SearchAsync ignore la requête) et IAgentExecutionService sont des remplaçants qui s'annoncent chacun par un Warning unique nommant la remédiation ; rien n'appelle un LLM ni ne persiste implicitement. Inventaire complet et gestes de remplacement : Comportements par défaut
  • Les outils custom doivent implémenter IBaseTool ou hériter de ToolBase<TReq,TRes>. Le chargement de plugins au runtime existe (opt-in AddOrkeonPlugins(...) — un manifeste plugin.json par dossier de plugin, AssemblyLoadContext collectables isolés, voir Plugins) ; limites v1 : les assemblies chargées s'exécutent en pleine confiance (pas de sandbox), et il n'y a pas de hot-reload
  • Plusieurs sous-systèmes (A2A, monitoring backend, NIST, DLP, rate-limiting d'outils, rotation de clés, benchmarking, validation multi-modale, hooks de kickoff, le sous-système RAG — AddOrkeonRag + AddOrkeonRagTools, plus l'opt-in AddOrkeonOnnxReranker ; le transport du repli web est câblé par AddOrkeonRag lui-même et gouverné par la configuration) sont opt-in : AddOrkeonInfrastructure()/AddOrkeonApplication() ne les enregistrent pas, et chacun s'active par son extension dédiée — voir Sous-systèmes opt-in.
  • A2A — la persistance des tâches est opt-in : enregistrez un state store de checkpointing plus AddOrkeonA2ATaskPersistence(), et GET /a2a/tasks/{id} répond 200 avec le cycle de vie enregistré (404 pour un id inconnu) tandis que DELETE interrompt une tâche sur laquelle l'agent travaille encore (elle finit Cancelled), répond 409 pour une tâche terminée et 404 pour un id inconnu. Sans l'opt-in, GET continue de renvoyer un 501 explicite plutôt que de fabriquer un état. Les écarts plus larges vis-à-vis de la spec v1.0 (bindings, push notifications, cycle de vie à 9 états, A2A-Version) sont inventoriés dans la matrice de conformité A2A.
  • A2A mTLS — A2AClient charge le certificat client (A2ASecurityOptions.ClientCertificatePath) et applique toujours la validation complète du certificat serveur — il n'existe délibérément aucun opt-out « accepter n'importe quel certificat » ; un serveur auto-signé ou de dev local épingle sa CA via TrustedCertificateAuthorities. Côté serveur, quand RequireMutualTls = true, A2AServer n'accepte que les certificats clients qui chaînent vers l'une des TrustedCertificateAuthorities ou correspondent à une empreinte épinglée de TrustedClientCertificateThumbprints (403 sinon) et refuse de démarrer si aucune ancre de confiance n'est configurée (fail-closed). La révocation n'est pas vérifiée (CA privées sans endpoints CRL/OCSP supposées). L'épinglage CA côté client ne couvre que la chaîne inconnue — un mismatch de nom d'hôte n'est jamais contourné. Quand AllowedAuthSchemes est défini, une requête n'est acceptée qu'avec un identifiant que le validateur de son schéma accepte (401 sinon) : un jeton Bearer validé par un IAuthenticationProvider enregistré (A2A:Security:AzureAD / A2A:Security:Oidc), une ApiKey égale à un secret nommé dans ApiKeySecretNames ; le serveur refuse de démarrer quand un schéma déclaré n'a pas de validateur. A2AClient envoie Authorization: <ClientAuthScheme> <secret> quand ClientAuthScheme et ClientCredentialSecretName sont définis, le secret étant lu via ISecretProvider à chaque appel. La terminaison TLS mutuelle réelle requiert un binding HTTPS de HttpListener (réservation HTTP.sys / certificat serveur) configuré au niveau de l'hôte ; l'endpoint de découverte /.well-known/agent.json reste public.
  • La sélection sémantique d'agents (OrkeonApplicationOptions.AgentSelectionStrategy = Embedding) hérite de la chaîne de résolution d'embeddings réelle : l'IEmbeddingService par défaut adapte le port IEmbeddingProvider (BGE local si AddOrkeonLocalEmbeddings() est enregistré → provider distant via Orkeon:Embeddings → échec explicite InvalidOperationException au premier usage, message actionnable). Il n'y a aucun repli non sémantique silencieux : sans embedding provider, la stratégie Embedding échoue bruyamment — configurer un provider, ou préférer la stratégie Skill (correspondance lexicale, sans dépendance) ou le défaut FirstFit (premier agent disponible).
  • Le chemin RAG ne se dégrade pas en silence — le pipeline d'ingestion (Orkeon.Rag) embedde les chunks à l'ingestion et le document store cherche par similarité vectorielle scorée (les scores survivent de bout en bout jusqu'à ScoredChunk), et le port IEmbeddingProvider se résout BGE local (si AddOrkeonLocalEmbeddings() est enregistré) → provider distant via Orkeon:Embeddings → échec explicite (InvalidOperationException au premier usage, message actionnable). HashBasedEmbeddingProvider est un double de test uniquement — il n'est jamais résolu implicitement.
  • Tool calling natif — Ollama : OllamaLlmProvider atteint /api/chat — et est câblé avec la stratégie native OpenAI — dès que la conversation déclare des outils, rejoue des appels d'outils, ou transporte une part non textuelle (une part audio ou fichier y est alors refusée par NotSupportedException, comme chez OpenAI et Anthropic). Il remet en forme la réponse d'Ollama (message.tool_calls avec arguments en objet JSON, sans tableau choices) dans le corps OpenAI que lit l'unique parser du framework (choices[0].message.tool_calls, arguments en chaîne JSON), et assigne des ids d'appel positionnels puisqu'Ollama n'en émet pas. Limites restantes : tout le reste — conversations simples, génération mono-prompt — passe encore par /api/generate, donc le protocole texte de repli reste aux commandes pour les modèles sans support des tools (un appel streamé prend le même point d'accès que l'appel bufferisé) ; et les images doivent être fournies en octets, puisqu'Ollama prend des payloads base64 nus et ne télécharge jamais une URL distante.
  • Profils RAG adaptive/corrective — les nÅ“uds dépendant d'un LLM se dégradent hors ligne : la route Adaptive-RAG Iterative délègue au pipeline graphe corrective (l'étape route trace delegate=corrective et RagTrace.Route porte la décision). Limites honnêtes restantes : le classifieur de complexité par défaut est l'heuristique déterministe ; le classifieur llm requiert un IChatClient enregistré (sans lui, repli sur l'heuristique avec avertissement) ; et sans vrai LLM le graphe correctif ne peut pas combler un fossé de vocabulaire — en évaluation --offline le stub extractif alimente rewrite_query/evaluate/check_groundedness : le parseur tolérant du grader pêche des mots de grade dans les passages recopiés (verdicts déterministes, dictés par l'unique mot de verdict que le corpus de référence contient ; le repli du vérificateur d'ancrage reste sûrement grounded), et une réécriture déclenchée dégénère en le préfixe fixe du stub — une seule probe dénuée de sens partagée par tous les cas — donc les chiffres corrective offline mesurent les garde-fous de la boucle plus cette dégradation, pas la qualité de réécriture, et peuvent tomber sous quality (tableau mesuré et analyse dans examples/rag/eval/README.md ; le mécanisme de bout en bout — verdict de l'évaluateur → réécriture → citation récupérée sur le cas seedé q-007 — est prouvé par CorrectiveRagMechanismSlowTests avec un LLM scripté, étiqueté comme tel). La même note offline vaut pour les transformers de requête LLM (multi-query/rag-fusion/hyde) : le chemin mesuré offline est QueryTransform.Mode=none + routage heuristique.
  • Les profils RAG balanced/quality/adaptive exigent les paquets du reranker ONNX : leurs presets activent l'étage de rerank cross-encoder. Les trois binaires livrés — orkeon, orkeon-host et orkeon-repl — l'enregistrent. Un hôte C# à soi qui ne référence pas Orkeon.Rag.Onnx + Orkeon.Rag.Onnx.Model et n'appelle pas AddOrkeonOnnxReranker() refuse de démarrer sous ces profils, en nommant onnx et les rerankers qu'il connaît. fast (le défaut) et corrective (le graphe corrige en bouclant, pas d'étage de rerank linéaire) fonctionnent sans les paquets ONNX. adaptive en a besoin car sa route SingleShot délègue à balanced.
  • Runtime natif ONNX — les suites qui le chargent : deux suites de tests chargent la bibliothèque native ONNX Runtime — tests/tools/Orkeon.Tools.Embeddings.Local.Tests (embeddings BGE-micro-v2 locaux) et tests/rag/Orkeon.Rag.Onnx.Tests (reranker cross-encoder ms-marco) — et exigent donc une plateforme où cette bibliothèque se charge ; toutes deux tournent en simples étapes dotnet test en CI et dans un conteneur. Un LocalEmbeddingProvider libéré lève ObjectDisposedException depuis EmbedBatchAsync et Dimensions.
  • Le modèle d'embeddings local lit l'anglais. BGE-micro-v2 — le modèle embarqué d'Orkeon.Tools.Embeddings.Local, derrière la recherche sémantique locale, la récupération RAG par embeddings locaux, la sélection sémantique d'agents et orkeon usecases search — a été entraîné sur de l'anglais. Son vocabulaire WordPiece (30 522 tokens) ne contient aucune lettre accentuée et 244 caractères chinois : « matin », « chaque » ou « résumé » lui arrivent découpés en fragments, alors que « morning » et « report » sont des mots entiers. Un texte français, espagnol, allemand ou chinois obtient bien un vecteur, mais bien plus proche du bruit que du sens : attendez-vous à une recherche sémantique, une récupération ou une sélection d'agents par embeddings nettement plus faibles hors de l'anglais. orkeon usecases search est construit autour : BM25 porte les cinq langues, les fiches sont vectorisées à partir de leur texte anglais, et le sens n'est ajouté que pour les langues où son jeu d'or a mesuré un gain (référence du CLI). Pour une recherche sémantique dans d'autres langues, configurez un fournisseur d'embeddings distant multilingue (Orkeon:Embeddings).
  • Providers d'embeddings : cinq, et un modèle changé est refusé là où un montage porte l'empreinte — Orkeon:Embeddings:Provider accepte openai (tout générateur M.E.AI), ollama, mistral, azure-openai et gemini (providers). Cohere, Voyage et pgvector ne sont pas livrés. Les vecteurs dépendent du modèle qui les a produits. Là où un montage couvre Orkeon:Embeddings:FingerprintPath, l'hôte compare au démarrage le provider, le modèle et les dimensions à l'empreinte qui y est consignée et refuse de démarrer si elles diffèrent ; rien n'est migré, il faut ré-embedder et vider les vecteurs stockés, puis supprimer le fichier d'empreinte. Le garde-fou voit les réglages d'embeddings, pas les magasins de vecteurs : un magasin rempli par un autre hôte, ou par du code qui a construit son propre provider, n'est pas vérifié. Un hôte doté d'un provider d'embeddings est gardé, avec ou sans section Orkeon:Embeddings : un hôte qui a produit des vecteurs avec le défaut embarqué puis nomme un autre provider est refusé (un hôte sans provider d'embeddings n'écrit rien). Il ne garde pas partout : orkeon forge consigne son empreinte par session sous /forge, donc ne garde rien d'une session à l'autre ; orkeon rag n'utilise aucune empreinte d'hôte, et le manifeste de chaque collection refuse un changement de modèle à l'ingest sans --reindex, au search, à eval rag --no-ingest -c et à eval rag -c avec sa passe d'ingestion et sans --reindex (orkeon rag ingest --reindex reconstruit la collection) ; un hôte dont le FingerprintPath ne se trouve sous aucun montage (pas de /workspace) saute le garde-fou en Debug ; sur un montage sans Write ni Create sur le fichier ni Create sur son dossier, une empreinte existante est encore vérifiée et un changement de modèle encore refusé, une empreinte absente n'est pas consignée (Debug, sans Warning) ; un FingerprintPath vide désactive le garde-fou, sans journal. Le MinScore par défaut (0,6) n'a été mesuré que sur le modèle local ; aucun modèle d'embeddings distant n'a encore de mesure.
  • Orkeon.Tools.Embeddings.Local repose sur une pré-release d'un amont archivé — l'opt-in d'embeddings locaux on-device est bâti sur SmartComponents.LocalEmbeddings 0.1.0-preview10148 (épinglé dans Directory.Packages.props), qui est la seule version existante : l'amont n'a jamais publié de version stable, et le dépôt visé par le projectUrl du paquet (dotnet-smartcomponents/smartcomponents) est archivé — le code a déménagé vers dotnet/smartcomponents, qui ne livre toujours pas de 1.0. Attendre un amont stable n'est pas un plan. Le volet licence est tranché et documenté (MIT pour le wrapper comme pour les poids BGE-micro-v2 embarqués, provenance établie à la main dans THIRD-PARTY-NOTICES.md sections 1-2) ; ce qui reste est une contrainte de packaging : NuGet refuse de packager un paquet stable qui dépend d'une pré-release (NU5104). Une version stable d'Orkeon ne peut donc pas porter cette dépendance dans son paquet principal — c'est exactement pour cela que cet opt-in est livré comme paquet Orkeon.Tools.Embeddings.Local à part plutôt que fondu dans le parapluie Orkeon. Conséquence pour un consommateur : référencer cet opt-in fait entrer une dépendance pré-release dans votre propre graphe, et si vous publiez ensuite un paquet stable qui en dépend, vous heurtez NU5104 à votre tour. Échappatoires, de la moins coûteuse à la plus coûteuse : (a) ne pas référencer l'opt-in — le port IEmbeddingProvider résout alors un provider distant depuis Orkeon:Embeddings (voir l'entrée sélection sémantique d'agents ci-dessus) ; (b) implémenter IEmbeddingProvider sur votre propre pile d'embeddings ; (c) vendorer le wrapper d'inférence amont (MIT, donc autorisé) dans une assembly que vous contrôlez et retirer la référence de paquet. La préversion est assumée, pas vendorisée. Un Orkeon.Tools.Embeddings.Local stable dépend de SmartComponents.LocalEmbeddings 0.1.0-preview10148 ; NU5104 est réduit au silence dans ce seul projet de packaging (l'ombrelle, Orkeon.Tools et la CLI ne déclarent jamais la dépendance), un pack stable de toute la ligne réussit, et le README dit en une ligne quel opt-in reste sur une préversion et pourquoi. Vendoriser le wrapper d'inférence (issue (c)) reste possible pour un consommateur qui exige un graphe entièrement stable ; cela ne vaut pas une seconde copie d'un wrapper MIT pour le framework lui-même. Les dotnet tools orkeon / orkeon-repl et les installeurs ne sont pas concernés par NU5104 — un paquet tool est self-contained et c'est sa propre version que NuGet contrôle. Ils embarquent en revanche les poids BGE-micro-v2 (environ 17 Mo, sous LocalEmbeddingsModel/), redistribués sous MIT avec les notices de THIRD-PARTY-NOTICES.md ; le paquet Orkeon.Tools.Embeddings.Local lui-même les retire, puisque son consommateur les obtient autrement. Le paquet SmartComponents.LocalEmbeddings (~40 Ko) ne contient aucun poids : sa cible build/ télécharge model.onnx et vocab.txt depuis huggingface.co au premier build d'un projet qui référence Orkeon.Tools.Embeddings.Local ou Orkeon.Scripting (tous deux laissent passer cette cible) et les copie dans LocalEmbeddingsModel/default/ de sa sortie. Un premier build hors ligne échoue dans la tâche amont DownloadFile ; les builds suivants réutilisent la copie mise en cache à côté du paquet. Pour éviter le téléchargement, mettez ExcludeAssets="build" sur chaque PackageReference qui atteint le paquet, Orkeon.Scripting comme Orkeon.Tools.Embeddings.Local : NuGet réunit les drapeaux, donc une seule référence sans lui garde le téléchargement. Le projet se compile alors hors ligne, sans le modèle. L'embedder local est construit au premier embedding, non au démarrage : un hôte ainsi compilé démarre, et son premier embedding local échoue par une InvalidOperationException qui nomme LocalEmbeddingsModel/default/model.onnx, l'exclusion et chaque référence qui peut porter le modèle (Orkeon.Scripting, Orkeon.Tools.Embeddings.Local, SmartComponents.LocalEmbeddings) ; un hôte qui produit ses embeddings par un fournisseur distant n'y arrive jamais.
  • Le repli web RAG est un double opt-in, désactivé par défaut : le nÅ“ud web_fallback du graphe correctif ne s'exécute que quand les deux interrupteurs sont activés — Orkeon:Rag:Corrective:WebFallback (politique : le graphe a-t-il le droit de sortir du store local) et Orkeon:Rag:WebFallback (transport : endpoint SearxNG — AddOrkeonRag câble le transport, dont l'adaptateur IWebDocumentRetriever du graphe correctif n'est enregistré que si activé avec un endpoint non vide). Chaque page téléchargée est filtrée par PromptInjectionDocumentValidator avant d'entrer dans le working set (les pages Rejected n'entrent jamais ; Suspicious suit la politique configurée) — voir Sécurité
  • Outils e-mail — quelques limites de protocole (Orkeon.Tools.Email, voir le guide) : Gmail a été campagné sur un vrai compte le 2026-10-04 (mot de passe d'application) et le 2026-10-05 (OAuth2) — ce que cela a établi ; Hotmail via Microsoft Graph le 2026-10-12. Outlook en IMAP et SMTP n'a pas été exécuté contre un vrai compte. Une page de recherche contient une dizaine de messages quoi que demande limit, étant coupée à un résultat d'outil : seul un next_cursor nul termine un dossier. Aucun outil ne rend les libellés Gmail d'un message. POP3 ne lit que la boîte de réception — pas de dossiers, de marques, de brouillons ni de corbeille ; une suppression est définitive et exige le droit Purge ; une recherche ne filtre que sur l'expéditeur, l'en-tête To, l'objet et les dates, sur au plus 200 messages par appel. Microsoft Graph accepte 4 Mo par requête, soit environ 3 Mo de pièces jointes (pas de session de chargement), et une recherche texte passe par KQL avec les marques et les dates appliquées côté client : une page peut donc contenir moins de messages que demandé. Sur un serveur IMAP personnalisé, raw_query est refusée (elle exige Gmail ou Graph), et sans UIDPLUS un message déplacé ou un brouillon enregistré revient sans son nouvel id. Outlook en IMAP hérite de la régression OAuth grand public de Microsoft du 2026-09-24, d'où Graph par défaut. Send:MaxPerHour se compte par processus, tentative refusée comprise. Le filtre anti-injection ne voit le contenu caché que par une courte liste de déclarations en ligne (display:none, visibility:hidden, opacity:0, font-size:0, max-height:0, width:0, height:0, mso-hide:all) et l'attribut hidden — un texte masqué par une classe CSS d'un bloc <style>, une police d'un pixel ou du blanc sur blanc n'est ni retiré ni signalé, et une partie texte brut, que lit l'agent quand il y en a une, n'est pas comparée au HTML ; un corps qui imbrique des éléments sur plus de 5000 niveaux est remplacé par un avis d'une ligne. Les fichiers de jetons OAuth sont du JSON en clair — à l'abri des outils du VFS, pas d'un outil shell ou de code qui tourne sous le même utilisateur du système — et orkeon-repl ne tient aucun magasin de jetons : les comptes OAuth ne fonctionnent que sous le CLI orkeon et le démon orkeon-host. Pas dans cette version : supprimer des dossiers, copier un message ou lui donner plusieurs libellés Gmail, l'approbation interactive d'un envoi (email_draft est la voie de relecture).
  • Outils drive — périmètre et limites des fournisseurs (Orkeon.Tools.Drive, voir le guide) : la campagne contre un vrai Google Drive et un vrai OneDrive a été close le 2026-11-17. Son passage consigné, le 2026-10-24, a porté sur un compte Google personnel et un compte Microsoft personnel et a mené aux correctifs de drive_search ; un compte OneDrive professionnel ou scolaire n'a pas été joué, et aucun rapport de campagne n'est écrit. Un compte ne voit que son propre « Mon Drive » ou son OneDrive : les drives partagés Google et les bibliothèques SharePoint ne sont pas atteints. Une recherche sur Google Drive ne peut pas être bornée à une sous-arborescence : ses résultats hors du Root du compte sont écartés, et une page peut contenir moins d'éléments que limit ; sur OneDrive une recherche ne prend que des mots (text ou name_contains), les autres critères étant appliqués à ce qu'elle rend, et raw_query est refusée. Un compte du tenant consumers (comptes Microsoft personnels) ne supprime rien définitivement sur OneDrive. Les documents Google sont lus via leur export texte (texte brut, ou CSV pour une feuille de calcul — sa première feuille) et téléchargés par export ; drive_read récupère au plus 2 Mo, un fichier plus gros ou binaire passant par drive_download et les outils fichiers. La vérification de la racine remonte 32 niveaux de parents au plus. Les chargements s'arrêtent à MaxUploadMegabytes (100 par défaut), envoyés dans une session reprenable vers Google (par tranches de 8 Mio au-delà de 8 Mio) et par tranches de 10 Mio vers OneDrive au-delà de 4 Mio. Les fichiers de jetons sont du JSON en clair — à l'abri des outils du VFS, pas d'un outil shell ou de code qui tourne sous le même utilisateur — et orkeon-repl ne tient aucun magasin de jetons : les comptes drive ne fonctionnent que sous le CLI orkeon et le démon orkeon-host. Un seul répertoire d'identifiants par run : quand Orkeon:Tools:Email:CredentialsDirectory et Orkeon:Tools:Drive:CredentialsDirectory diffèrent, celui de l'e-mail est utilisé. Pas dans cette version : la copie, les révisions, les commentaires, le retrait d'un partage, un drive d'essai pour la forge, un drive monté dans le VFS.
  • MCP — client/serveur dual-era : le client sonde avec server/discover et parle la révision moderne stateless (2026-07-28 — _meta par requête, renégociation de version sur UnsupportedProtocolVersionError) ou retombe sur le handshake initialize legacy (2025-11-25, 2025-06-18, 2024-11-05 ; 2025-03-26 est exclue à dessein — seule révision qui impose le batching JSON-RPC, que cette implémentation ne parle pas) ; le serveur sert les deux ères simultanément — sur stdio seulement, démarré par orkeon mcp serve (pas de transport HTTP pour le serveur), chaque tools/call par le point d'invocation gardé des tours d'agent, les requêtes s'exécutant en concurrence jusqu'à --max-concurrency (4) et annulables par notifications/cancelled, et /output servi comme ressources en lecture seule sous --expose-output (ni resources/subscribe, jamais /workspace), et des prompts seulement pour les tâches des crews que nomme --crew. Limites assumées de la surface moderne : subscriptions/listen en HTTP seulement (les notifications stdio sont entendues d'elles-mêmes et tools/list_changed resynchronise les outils enregistrés), des crews servies comme outils (orkeon mcp serve --crew : run_crew_<nom>, progression par tâche, tâches en prompts) enregistrées dans l'historique des runs quand il est actif, mais ni sampling, ni roots, ni elicitation (une requête du serveur pour l'un d'eux reçoit -32601 : le sampling appellerait un LLM hors du budget, du gardien et du coût du run, les roots exposeraient des chemins physiques, l'elicitation attend le human-in-the-loop durable), pas de requêtes multi-aller-retour (un résultat input_required remonte comme erreur d'outil), un client OAuth pour le serveur (client credentials, device flow : Auth:Type oauth2-client-credentials ou oauth2-device) mais pas de flux authorization-code, pas de découverte de ressource protégée (RFC 9728) ni d'enregistrement dynamique de client (DCR), et le device flow est refusé dans orkeon-host (pas de terminal) — un serveur derrière un identifiant statique s'atteint par MCP:Servers:<id>:Auth (bearer ou basic, lu dans l'environnement) et Headers ; le transport HTTP est du Streamable HTTP (id de session, réinitialisation sur 404, réponses SSE lues événement par événement, flux GET avec Last-Event-ID ; le transport HTTP+SSE de 2024-11-05 à endpoint séparé n'est pas supporté). Côté client, le schéma d'un outil distant est gardé entier à toute profondeur (propriétés, éléments, bornes, anyOf / oneOf, additionalProperties, un allOf d'objets fusionné, $ref locaux résolus, la racine lue comme tout schéma) ; il perd encore, entre autres, un allOf dont un membre n'est pas un objet, not, if / then / else, patternProperties, uniqueItems, multipleOf, dependentRequired, additionalItems, title, minProperties / maxProperties, propertyNames, contains, un membre d'enum qui est null ou n'est pas un scalaire, la position des éléments d'un tuple (lus comme leurs alternatives), une ancre, une référence à un autre document et une référence coupée sur un cycle (n'importe quelle valeur JSON), ce qui se trouve à plus de 32 niveaux de profondeur, et à la racine un additionalProperties autre que false (Intégration MCP liste ce qui est gardé) ; un outil dont l'inputSchema s'étend à plus de 4096 schémas, ou copie plus de 1 Mio de texte, chaque usage d'un $ref compté (une définition utilisée plusieurs fois compte à chaque fois), est écarté avec un avertissement écrit une fois par définition d'outil distincte ; un type en tableau qui ne nomme que "null", ou l'absence de type, est lu comme une absence de type ("type": "null" reste null), un entier qu'aucun entier 64 bits ne contient est lu comme un double, et un tableau dont les éléments ne sont pas connus — pas d'items, des éléments sans type unique — est montré avec items: {}, n'importe quelle valeur JSON ; tools/list, prompts/list et resources/list sont lus entrée par entrée : un outil, un prompt ou une ressource illisible est écarté à lui seul avec un avertissement ; une réponse tools/list de la mauvaise forme (un tools qui n'est ni null ni un tableau, un nextCursor qui n'est pas une chaîne) fait encore échouer la liste, et donc la connexion, avec un message qui nomme le serveur, là où un prompts/list ou un resources/list de la mauvaise forme donne ce qui a pu être lu. Côté serveur, un hôte C# qui désérialise lui-même un message et le remet à ProcessRequestAsync perd un id null (le message est pris pour une notification et ne reçoit rien, là où la boucle stdio d'orkeon mcp serve répond -32600) et un jsonrpc absent (il vaut "2.0" par défaut, le message est donc exécuté là où la boucle le refuse), et une réponse qu'il lui remet reçoit -32600 là où la boucle l'ignore. L'interop contre le serveur de référence (server-everything) tourne chaque nuit, et à la main avec le MCP Inspector — Interop MCP.
  • LanceDB — LanceDbMemoryProvider cible un serveur LanceDB Cloud/Enterprise distant (protocole Lance REST Namespace, payloads Arrow IPC) ; il n'y a pas de store local. Limites de l'API distante (détails dans Système de mémoire) : SearchAsync exige un index FTS sur content (créé automatiquement à la création de la table, sinon l'erreur serveur est propagée — jamais simulée localement) ; HybridSearchAsync émet deux requêtes serveur (classements _distance/_score côté serveur) et fusionne localement les deux listes classées, comme les rerankers des SDK officiels ; l'API delete ne renvoyant pas de compteur, DeleteAsync/UpdateAsync font une requête d'existence préalable pour préserver leur contrat booléen ; la conversion score = 1 − _distance n'est pertinente que pour la métrique cosine (défaut)
  • La détection du Guardian est heuristique — la phase d'entrée et l'assainisseur de résultats d'outil reconnaissent des formulations (ignore previous instructions, jetons de gabarit de chat, …) : une attaque reformulée passe, et une invite honnête peut correspondre — sous Security:Prompt:Policy = Block (le défaut) sa tâche échoue alors avec le motif nommé (Warn la laisse passer avec un avertissement). Les résultats d'outil sont balisés comme données, jamais nettoyés. Seuls les hôtes qui composent AddOrkeonApplication() avec AddOrkeonInfrastructure() ont le Guardian ; un ExecutionOrchestrator construit à la main tourne sans garde tant que ses Guardian et ToolInvocation ne sont pas posés. Voir Sécurité.
  • Modèles de décision : un juge par phase — TypeSafe, Liquid et Kev sont des fournisseurs Decision derrière IDecisionModel, pas des 17ᵉ fournisseurs LLM : un agent ne peut pas en prendre un comme llm. Le juge LLM du gardien (Orkeon:Guardian:Llm, coupé par défaut) juge l'entrée de l'agent et la sortie d'une tâche par l'unique IDecisionModel, sans profil propre, et ajoute un appel de modèle par phase, retarde le streaming d'une tâche jusqu'à ce que sa sortie soit jugée, juge un texte long en entier, par morceaux de MaxContentChars qui se chevauchent d'un quart, sous FailMode: Closed (32 morceaux au plus, au-delà le texte est refusé), mais seulement la première et la dernière moitié de MaxContentChars sous Open (le milieu n'est pas jugé), et ne couvre que les tâches de crew (la réponse d'un ctx.llm.act scripté n'est pas jugée) ; une réponse au sein d'un appel se juge par une étape de réponse d'un profil de décision (Orkeon:Decision:Profiles). Les étapes de requête n'interrogent que le dernier message utilisateur, un rappel après la réponse n'a lieu qu'une fois par appel, et ni les étapes ni le reranker decision ne posent LongContext : un état long ou de nombreux passages peuvent dépasser le contexte par requête du fournisseur et échouer sur son erreur de limite, un 400 max_tokens_exceeded (Modèles de décision). Les opérations supplémentaires de Kev (permuter, séparer, liste des modèles) ne sont pas câblées. Aucun coût n'est calculé pour une décision, seulement ses jetons d'usage. Les poids ouverts de d1 ne sont pas servis par Orkeon : Liquid s'atteint par son API hébergée.
  • La mémoire d'une crew garde tout, rappelle par vecteur sauf si la mémoire cognitive est activée, et ne dure que dans un magasin durable — avec memory: true, une crew range le résultat de chaque tâche réussie et rappelle les plus proches avant chaque tâche (Système de mémoire). Ce qu'elle ne fait pas : il n'y a ni rétention ni remise à zéro — la mémoire croît d'une entrée par tâche réussie, run après run, et IMemoryService.ClearMemoryAsync ne vide que les entrées du run en cours ; avec In-Memory, elle vit en RAM le temps du processus, si bien qu'orkeon run ne se souvient d'un processus à l'autre qu'avec un magasin durable (memoryProvider: sqlite, une base vectorielle, ou un Memory:Provider durable) ; le rappel est une recherche vectorielle, sans extraction de faits par LLM ni score de récence ou d'importance (ceux de CrewAI) — sauf si Orkeon:CognitiveMemory:Enabled vaut true, ce qui rappelle par score composite et analyse ce qui est rangé, au prix d'appels LLM (Système de mémoire) ; MinScore (0,6) est à l'échelle du modèle local anglais, où un texte français obtient un score élevé quoi qu'il dise, et une longue variable d'entrée qui partage le sujet d'un souvenir peut porter une tâche sans rapport au-dessus.
  • Le plan d'une crew est un conseil, fait sur le profil par défaut — avec planning: true, un planificateur écrit un plan pas à pas pour chaque tâche avant la première, et chaque tâche lit son propre plan dans son prompt, dans les six modes ; le plan ne change ni l'ordre ni les agents (Types de processus). Ce qu'il ne fait pas : il planifie sur le fournisseur de planification de la crew (WithPlanningLlm en C#) ou sur le profil par défaut de l'hôte — une crew YAML ou .ork.ts ne peut pas en nommer un autre ; il ne montre au planificateur ni la backstory des agents, ni leur connaissance, ni la mémoire de la crew, et coupe ce qu'il montre (PlanningDefaults) ; une réponse illisible deux fois laisse la crew sans plan — un avertissement, pas un échec ; et sur le fournisseur écho (pas de section Llm), il saute le plan, avec un avertissement.
  • spawn_agent — l'hôte de scripts l'offre, le tool C# est enregistré par l'hôte — l'act d'un script se voit offrir spawn_agent (SpawnAgentScriptTool) : il exécute un agent nommé du crew comme enfant, sous les budgets de profondeur de délégation et de spawn de l'exécution du crew (voir Scripting). Le SpawnAgentTool C# (self-spawn sous budget du mode autonome, dans Orkeon.Infrastructure) est une autre classe et reste enregistré par l'hôte : aucune racine de composition livrée — ni orkeon run ni le REPL — ne le met dans le registre de tools, et un hôte C# qui veut le self-spawn l'enregistre explicitement avec un IAgentFactory. Voir docs/fr/tools/inventory.md et docs/fr/orchestration/autonomous.md.
  • Les espaces de noms de mounts par exécution ne sont entrés que par orkeon-host et l'essai de la forge — IFileSystemScope / AsyncLocalFileSystemScope (Domain) donnent à un flux d'exécution son propre FileSystemRegistry, et FileSystemService consulte cette surcharge ambiante à chaque opération : deux crews dans le même processus peuvent donc adresser chacun son /output sur des dossiers physiques différents — le rejet des chemins virtuels en double est par instance, jamais global. orkeon-host entre un namespace par crew hébergé, depuis Orkeon:Host:Crews:*:Mounts (CrewRunner), et l'essai de la forge en entre un fait des dossiers que sa session a confirmés (ForgeTrialScope). Tous les autres points d'entrée — orkeon run, le reste d'orkeon forge, orkeon rag, orkeon-repl — tournent sur le registre de boot, un jeu de mounts plat par processus dont les chemins virtuels doivent être globalement uniques : d'où le fait qu'ils réservent leurs racines contre les settings — le fichier et l'environnement — au lieu de les cloisonner, et que l'hôte renomme encore les crews auxquels il n'accorde aucun mount (/crews, /crews-1, …). Un hôte qui veut son propre namespace le compose avec ScopedMountComposition.ForExecution : entrer dans un scope remplace le jeu de boot au lieu de fusionner avec lui, donc la composition reporte les mounts de boot et laisse ceux de l'exécution les masquer aux chemins qu'ils revendiquent — les abandonner emporte /llm-logs et /sandbox avec le run, et emporte la racine depuis laquelle le runner charge le crew. Un dossier accordé à une crew est une entrée du démon, lisible où qu'il soit, sans --allow-external-mounts. Les dossiers de la forge sont des entrées aussi : forge resume construit son hôte avec les dossiers confirmés montés et autorisés, et un run sur le point d'essayer l'équipe dans son propre processus refuse, à folders.confirmed, un dossier d'entrée relié à un dossier réel que son validateur n'autorise pas (FORGE-FOLDERS-INVALID). Voir Conformité VFS.
  • Une approbation d'appel d'outil dans orkeon-repl se lit entre deux commandes, ou par un runCrew en attente — la question d'un crew attend la boucle de lecture, qui ne lit que lorsqu'aucune commande ne tourne au premier plan, ou une commande qui attend dans runCrew (synchrone), qui lit la réponse elle-même. Toute autre commande qui tient la boucle laisse la question attendre jusqu'à sa fin. Le ctx.prompt d'une commande qui lit pendant qu'une question attend prend la ligne de l'opérateur à sa place. Dans la console simple sur un terminal, une question écrite pendant l'édition d'une ligne décale l'ancre de l'éditeur, comme le fait déjà la ligne de fin d'un ticket. La pause de l'horloge du script pendant que le contrôle décide vaut pour tout le moteur : chaque agent du crew, chaque course qui partage le moteur d'un fichier de commandes. Le REPL enregistre directement son canal d'approbation (CompositeLineInterceptor), sans le décorateur SerializingToolApprovalChannel que reçoivent les autres hôtes : si deux appels de lecture d'un même tour (qui tournent en parallèle) demandent tous deux, leurs questions ne sont pas mises en file une à la fois. Un act en mode ask sans contrôle de permission échoue fermé (l'appel est refusé). Pendant un rejeu (orkeon-repl --replay, /replay), la ligne suivante du fichier répond à une question dès qu'elle attend : une ligne écrite pour la commande suivante répond à une approbation que le rejeu n'attendait pas ; une ligne répond à une approbation, mais une réponse pour toute la session (s) règle en outre chaque approbation en file pour le même outil, et le fichier ne doit donc porter aucune ligne pour elles ; et une approbation qui attend encore quand le fichier se termine arrête le rejeu (replay ended with an approval waiting: <outil>, code de sortie 1). Une instance d'arrière-plan lancée par un rappel completed() est imputée à la ligne du rejeu en cours quand elle démarre, pas à la ligne qui a lancé son parent. Une question human_input n'émet aucun signal : le rejeu la voit en un quart de seconde au plus, en regardant de nouveau.
  • Aucun hôte livré n'active un agent sur le bus de dispatch des commandes scriptées — un agent déclare des gestionnaires .onCommand(...) et une commande .cmd.ts l'atteint par commands.request / commands.post, mais rien ne relie les deux : orkeon-repl ne charge que des fichiers *.cmd.ts et n'enregistre aucun agent, et le registraire qui le fait est interne. Tant qu'un hôte n'en enregistre pas, request et post lèvent commands: unknown agent '<name>'. Registered: (none). — voir Commandes CLI scriptées.
  • Un appel d'outil d'un agent de crew pour lequel la permission gate demande est refusé quand l'hôte n'a pas de canal d'approbation — la gate est consultée par ToolInvocationPipeline pour les scripts comme pour les crews YAML (permissionMode: d'un agent, sinon Orkeon:Security:PermissionGate:DefaultMode) ; un ask va à l'IToolApprovalChannel de l'hôte, et sans lui (le bot Discord) l'appel est refusé et le modèle en lit la raison. Avec Orkeon:Checkpointing:Enabled la question est durable : le démon et orkeon run la persistent et arrêtent le run dessus (waiting_for_input, sortie 75) au lieu de refuser ; le bot Discord n'a toujours aucun chemin pour y répondre (une session de forge en pause n'est pas un run : elle reste à 0).
  • Le démon ne reprend pas de lui-même un run suspendu — un run dont la question d'entrée humaine a dépassé Orkeon:HumanInput:HoldTimeout (ou Pause: Suspend) finit waiting_for_input ; POST /runs/{id}/input enregistre la réponse et orkeon run <crew> --resume <id> le reprend. Chaque question qu'une tâche parallèle pose est persistée sous son propre id ; le run s'arrête sur l'une d'elles (celle que montrent sa sortie et pending_input), les autres se répondent par leur request_id, et une question restée sans réponse est reposée à la reprise du run. Une question se rejoue au grain de la tâche : la tâche qui l'a posée repart de son début (ses appels d'outils sont refaits), et les décisions des managers Hierarchical et Autonomous ne sont pas checkpointées.
  • La réponse à une question d'entrée humaine est stockée en clair — la session de checkpoint garde les réponses (SessionState.AnsweredInputs) telles qu'elles ont été données, parce que la tâche reprise en a besoin : un magasin sur disque (json, sqlite) ou Postgres les garde lisibles, comme il garde les sorties de tâche. Ce qui est imprimé ou relu d'une question - le prompt sur la ligne stderr d'orkeon run et dans GET /runs/{id} - passe par le masquage de l'historique de run (RedactingRunEventSink.Redact) ; le prompt stocké n'est pas masqué. Une réponse donnée sans id de question (--resume <id> --input "...", ou un POST /runs/{id}/input sans request_id) va à la question sur laquelle le run s'est arrêté ; quand plusieurs sont ouvertes et qu'aucune n'est celle de l'arrêt, elle est refusée (409 request_id_required). Une approbation d'outil stockée n'est réutilisée à la reprise que pour le même outil et les mêmes arguments : un autre appel est redemandé.
  • Le confinement de shell_command : ce que tient chaque backend, et où c'est vérifié — le processus est confiné par défaut (Confinement du shell) : bubblewrap sous Linux, Seatbelt sous macOS, un AppContainer dans un Job Object sous Windows 10 et suivants ; dans un conteneur, ou avec Mode = None, il tourne sur l'hôte sous l'utilisateur de l'hôte et le VFS ne vérifie que les chemins que nomme sa ligne de commande. Où c'est vérifié : les parties pures (les arguments de bwrap, le profil Seatbelt, le plan d'ACL, les lignes de commande Windows, le protocole du shell, le choix d'Auto) sont des tests unitaires que chaque run de CI exécute sous Linux ; un vrai bwrap, un vrai sandbox-exec et un vrai AppContainer ne tournent que dans les jobs nocturnes d'integration.yml (ubuntu-latest, macos-latest, windows-latest), qui échouent plutôt que de sauter leurs tests quand le backend ne peut confiner ; seul le job Linux ouvre l'issue de suivi du run nocturne, un job macOS ou Windows rouge ne se voit que sur le workflow. Ce que la vue ne porte pas : une surcharge de sous-chemin sur un chemin qui n'existe pas à l'ouverture de la session (un parent accessible en écriture laisse le processus le créer ; bubblewrap et AppContainer), un montage interne dont le dossier se trouve dans un montage exposé aux agents (atteignable par ce montage), et un programme hors des répertoires système (/opt, un dossier .dotnet ou nvm du répertoire personnel sous Linux ; /opt/homebrew sous macOS ; tout ce qui est sous le profil utilisateur sous Windows) tant que son dossier n'est pas listé dans Confinement:ReadOnlyPaths. Une racine d'agent qui est un worktree git lié reçoit le répertoire commun du dépôt lié en lecture seule et, par-dessus, ses objects, refs, logs et le répertoire git propre au worktree en lecture-écriture : l'agent peut réécrire les refs de chaque branche et les objets partagés, mais ni le config, les hooks, info, modules du répertoire commun ni les répertoires git des autres worktrees, ni aucun arbre de travail hors de sa racine ; un dépôt sans logs/ ne peut enregistrer de reflog depuis l'agent ; une disposition qui échoue une vérification (commondir ou lien retour qui ne nomme pas les répertoires attendus, un lien symbolique sur le chemin) ne lie rien ; git lancé sur l'hôte dans le worktree de l'agent se fie toujours à ce que l'agent y a écrit, et git lancé sur l'hôte n'importe où dans le dépôt suit un lien que l'agent a créé dans objects, refs ou logs ; un gitdir écrit en chemin virtuel ne fonctionne que sous bubblewrap (Seatbelt et AppContainer montrent les chemins physiques). Pas de réseau sauf Confinement:AllowNetwork : un gestionnaire de paquets ou git fetch échoue jusque-là. Un dépassement de délai ne rend aucune sortie partielle sous Linux et macOS (la session est tuée avant que la sortie de la commande soit relue ; Windows rend ce qui a été capturé), et il réinitialise la session : la commande suivante démarre dans une nouvelle, sans ce que la précédente avait laissé dans son /tmp. Windows : chaque session accorde ses montages par ACE et reprend l'accord à sa fin, et Windows propage une ACE héritable à chaque objet sous la racine du montage : une session coûte une écriture de descripteur de sécurité par fichier de ses montages, dans chaque sens (un node_modules de 100 000 fichiers fait 100 000 écritures à l'ouverture de la session et autant à sa fermeture) ; la DACL est lue, modifiée puis réécrite, ce qu'un autre processus qui modifie la même DACL au même moment peut défaire. Un sous-chemin masqué, ou en lecture seule dans un montage accessible en écriture, a sa DACL protégée le temps de la session et réécrite telle qu'elle était à la fin (le contrôle d'accès du conteneur ignore une ACE de refus) : une modification qu'un autre outil fait entre-temps à cette DACL est perdue. Les commandes dir, vol, attrib et where /r de cmd interrogent la racine du lecteur, qu'une ACL standard n'ouvre pas à un AppContainer : elles répondent « Access is denied. » dans une session confinée. Un fichier de commandes (.bat, .cmd, donc npm.cmd) est refusé dans une session AppContainer et ne tourne qu'avec Mode = None, et un programme n'est cherché que sur le PATH. Après un crash de l'hôte : bubblewrap et le Job Object ne laissent aucun processus (le noyau tue l'arbre), mais les ACE qu'une session AppContainer a posées restent sur les montages jusqu'à ce que la première session de l'hôte suivant les reprenne (elles sont consignées sous %LOCALAPPDATA%\Orkeon\shell-sessions\) ; sous Seatbelt et hors confinement sous Linux et macOS, une sentinelle qui sonde chaque seconde tue l'arbre de processus de la session, auquel échappe un processus qui en est sorti (un double fork). Le runtime scripté termine la portée d'un agent sans l'attendre : la fermeture d'une session peut finir après le retour du corps de l'agent. Sous Linux, l'environnement de la session garde le PATH de l'hôte, avec HOME et TMPDIR sur le /tmp propre à la vue ; la restriction AppArmor d'Ubuntu 24.04 sur les espaces de noms utilisateur fait échouer bwrap sauf si un profil lui accorde userns. Le bus de session n'atteint une session confinée qu'avec Orkeon:Tools:Shell:Environment:SessionBus = true, qui permet à une commande de sortir du bac à sable (systemd-run --user) et de lire le trousseau ; un bus unix:abstract= reste joignable sous bubblewrap avec AllowNetwork, puisqu'une socket abstraite suit l'espace de noms réseau partagé. Jobs d'arrière-plan : un run tient 16 jobs vivants au plus, un id de job ne vaut que dans le run qui l'a lancé, et la fin du run tue les jobs encore en cours.
  • Le périmètre de fichiers d'un agent juge des chemins virtuels (périmètre de fichiers d'un agent) : un lien symbolique dans une entrée qui pointe ailleurs dans le même mount est suivi par les outils du VFS (le validateur de chemins tient les liens aux mounts, pas au périmètre) ; shell_command sous bubblewrap ne lie que les entrées, le lien n'y mène donc nulle part. Un shell non confiné (Mode = None, ou dans un conteneur) ne tient le périmètre que pour les chemins que nomme sa ligne de commande et pour son répertoire de travail, comme il tient les mounts. Une entrée rwnd retient Delete, mais un déplacement peut encore en sortir un fichier : le VFS ne demande que Read et Write à la source d'un déplacement. Les surcharges de sous-chemin d'un mount se comparent toujours en tenant compte de la casse, et le périmètre ne replie ni les noms courts 8.3 de Windows ni les flux de données alternatifs NTFS. En mode hiérarchique, les workers que le manager assigne tournent comme des runs de premier niveau sous leurs propres périmètres : un périmètre déclaré sur l'agent manager ne les borne pas. Seuls les appels d'outil de l'agent sont tenus : ce que le framework lit ou écrit pour le run (mémoire, connaissances, fichiers de sortie) garde les droits des mounts.
  • Coupe du résultat par tool — Orkeon:Tools:ResultLimits (Limits:<tool>, MaxParallelToolCalls, 4 par défaut) est lié par AddOrkeonInfrastructure et lu par les boucles d'agent C# via ExecutionOrchestrator.ToolLimits. L'act des scripts le lit aussi, par ScriptingHostPorts.ToolLimits, que orkeon run, les hôtes des runners (dont orkeon-host), les commandes de script du REPL et l'assistant de crew de la forge renseignent tous ; un hôte de scripts construit sans ce port coupe et parallélise avec les valeurs par défaut intégrées. La coupe par défaut du shell dans le pipeline est de 10000 caractères ; un résultat qu'un tool a déjà borné (ToolCallResponse.AlreadyBounded) n'est pas coupé une seconde fois. La boucle de repli texte (LegacyTextAgentLoop) et le chemin texte du dispatcher ne parallélisent pas.
  • Instances d'agent : une mémoire par nom d'agent — le store durable de ctx.memory.agent (FileScriptAgentMemoryStore) vit sous Orkeon:Scripting:AgentMemory:RootDirectory (par défaut /workspace/.orkeon/agent-memory, voir la référence de configuration) ; la clé est le nom de l'agent, deux agents de même nom le partagent donc. Sans budget(...), MaxSpawnedAgents compte par exécution d'agent, pas par exécution de crew.
  • Le verrou d'ingestion RAG est interne au processus — les ingestions d'une même collection sont sérialisées par un SemaphoreSlim par collection du processus ; deux processus partageant un store persistant ne sont pas coordonnés (un verrou inter-processus demande le support du provider). Prune ne retire que les sources du manifeste absentes des globs demandés ; une suppression en échec est notée dans les erreurs du rapport et garde son entrée de manifeste. Voir Pipeline RAG.
  • Markdown dans le RaggableTree — pas de validation de parse — Les éditions d'un fichier .md (node_replace, node_insert, edit_batch, ensure_section, insert_under_heading, replace_mermaid) ne sont pas validées par un parse : Markdown n'a pas d'erreur de syntaxe à refuser. Sur un bloc de code non fermé de premier niveau, replace_mermaid remplace le corps jusqu'à la fin du fichier sans le fermer.
  • Réindexation incrémentale : bornes énoncées — incremental_reindex re-parse les fichiers modifiés et corrige le store fichier par fichier ; les appels des fichiers inchangés et les liens Markdown vers un nom ajouté ou retiré par les fichiers modifiés sont re-liés sans relire les fichiers inchangés. Les chemins du jeu modifié n'appliquent pas .gitignore. Une arête tests vers un membre surchargé relie toutes les surcharges (le FQN est sans types). Voir RaggableTree.
  • Requêtes du flux de développement : bornes énoncées — affected_tests tire project_depends des seuls csproj, réunit base..HEAD et les changements de l'arbre de travail (non suivis inclus), et répond all quand une requête de projet remplit sa page de 1000 lignes ou qu'une expansion est tronquée ; les symboles sous un module modifié sont lus sur trois niveaux. documents_of lit les sections d'un fichier par une requête plafonnée à 1000 sections par le store. access_cost compte comme une lecture une écriture derrière ConfigureAwait, comme access-cost.py.
  • Opérations d'intention — une grammaire fermée — ensure_import ne voit pas un commentaire // dans des accolades d'import multi-lignes (la liaison suivante est masquée), ni import React, { … } (défaut plus nommées). Les réécritures structurelles et edit_batch sont atomiques au mieux : les fichiers sont écrits un par un avec une sauvegarde ou l'original en mémoire, et restaurés en cas d'échec ; si la restauration échoue elle-même, le journal est conservé et une AggregateException est levée, et les fichiers déjà écrits restent modifiés jusqu'au rejeu du journal (dans structural_rewrite, $$ dans un motif reste deux dollars, un seul dans un correctif).
  • Les tâches de décision ne tournent que dans trois processus. Une tâche avec un bloc decision: ou une condition when est acceptée en Sequential, Parallel et Graph ; en Hierarchical, Consensual et Autonomous le chargement est refusé (DecisionTaskRules.Check), jamais ignoré, et un équipage construit en C# qui les atteint échoue avant sa première tâche.
  • Tâches de décision : ce que la seconde itération laisse de côté. Pas de nÅ“ud de décision avant ou après une tâche (une garde sur l'entrée ou la réponse finale d'une tâche), pas de sortie go-to, de boucle ni de journal des décisions ; ni réessai (une tâche de décision ne peut pas déclarer retry:, et le graphe n'a pas de boucle de retry propre) ni repli quand une requête au modèle de décision échoue (la tâche échoue, le repli ne sert qu'à un circuit coupé) ; ni image ni question box dans un équipage (le port IDecisionModel accepte les deux, fonctions « danger zone » opt-in de TypeSafe depuis Jev 1.13 et 1.14, mais la tâche de décision d'un équipage n'envoie que du texte) ; le reranker decision envoie ses passages en une requête, sans lots.
  • Le retry: d'une tâche rejoue la tâche entière, et rien de plus. Tous les modes réessaient une tâche échouée (retry: {attempts, backoffMs, backoff}), appels d'outils déjà réussis compris : aucun mécanisme ne les déduplique, et une tâche dont les outils écrivent doit pouvoir tourner deux fois sans dommage. Les appels d'outils d'une tentative en échec, la mémoire écrite par des outils, le coût mesuré et les événements restent, et les callbacks de tâche partent une fois par tentative. Une annulation, un refus du gardien et un budget épuisé ne sont jamais réessayés ; un dépassement de temps et une chaîne de basculement épuisée le sont. Il n'y a ni planificateur ni file de messages : un retry est immédiat (ou après son backoff), dans le run.
  • La transcription du REPL n'affiche aucun détail de décision pour les tâches d'un crew. Le JSONL du run porte la raison du saut d'une tâche et les réponses d'une tâche de décision ; la transcription du REPL n'affiche ni raison de saut ni libellé de décision pour une tâche de crew.
  • Le bloc YAML graph: s'exécute sur le moteur Domain seulement. Un graph: hors de process: graph est refusé au chargement, et un passage de relais entre agents n'est pas une arête de graphe. Le constructeur de crew d'un .ork.ts n'a pas de surface graph: : process("graph") y exécute un nÅ“ud par tâche, et un graphe dessiné avec stateGraph(...) s'exécute sur JsStateGraph quand le script appelle .run().
  • ChatOptionsComposer ne traduit qu'une partie de la LlmConfig d'un agent. Il reprend le modèle, les champs d'échantillonnage et de pénalité, le plafond de sortie, la graine, les séquences d'arrêt, Thinking, le format de réponse et le cache ; des champs comme TimeoutSeconds, CustomParameters ou SystemMessage posés sur la LlmConfig propre d'un agent ne sont pas traduits dans les options de chat (la boucle de repli texte les honore).
  • Deux graphies de la même variable de clé d'API. Sous Linux et macOS, quand ORKEON_Llm__ApiKey et ORKEON_LLM__APIKEY sont toutes deux posées avec des valeurs différentes, le run prend l'une ou l'autre, et le runtime n'arbitre pas entre elles.
  • Windows : un refus de connexion peut arriver lentement (non vérifié). La sonde du point d'accès LLM d'un run et celle d'orkeon doctor donnent 2 s chacune et lisent une expiration comme « joignable ». Si la pile Windows réessaie le SYN après le reset, comme attendu, le refus d'un localhost injoignable peut arriver après le délai, et l'échec rapide d'orkeon run ne se déclenche pas. Pas encore constaté sous Windows.
  • La réflexion et l'effort sont jugés contre une table qui est un instantané. Chaque fournisseur juge LlmConfig.Thinking contre la table par modèle (IModelCapabilityRegistry, ORKEXP005) : un effort qu'un modèle listé ne prend pas est abaissé, un interrupteur qu'il ne peut honorer est abandonné, chacun avec un avertissement, et un modèle non listé reçoit les options telles que demandées, avec un avertissement : rien n'a été vérifié. La table tient ce que les vendeurs documentaient et ce que la campagne des fournisseurs a mesuré ce jour-là : un modèle sorti ou modifié depuis répond par sa propre erreur tant que Llm:ModelCapabilities:<id> ne le déclare pas. Azure OpenAI se nomme par déploiement : ses déploiements ne sont pas listés tant qu'ils ne sont pas déclarés. Un identifiant de modèle contenant : (le llama3:8b d'Ollama) ne peut pas être une clé de Llm:ModelCapabilities, la configuration .NET n'ayant pas d'échappement pour : : écrivez son préfixe (llama3). Haiku 5.5 au-delà de 100K jetons de prompt facture davantage (0,50 / 2,50 $/M) ; ModelPricingRegistry ne tarife que le palier jusqu'à 100K, si bien qu'un long prompt Haiku 5.5 est sous-estimé et qu'un budget peut être dépassé sans alerte.
  • Réflexion et effort : ce que la table laisse sans mesure. Le « on » d'Anthropic envoie adaptive à tout modèle Claude, Claude 4.5 et antérieurs compris, où aucune campagne ne l'a mesuré. L'entrée claude-opus-4 (low à high) couvre aussi Opus 4.6 et 4.7, et l'entrée gpt-5 (minimal à high) GPT-5.1 à 5.5, sans mesure. Les identifiants Claude à points d'OpenRouter (anthropic/claude-opus-5.5) ne correspondent pas aux entrées à tirets (claude-opus-5-5) et retombent sur une entrée plus courte (claude-). Une entrée qui ne liste aucun effort (claude-, gemini-) les laisse sans vérification et ne donne pas l'avertissement « rien n'a été vérifié », puisque le modèle est connu. kimi-k3, kimi-k3.1-pro, DeepSeek et les modèles qwen3.8 n'ont pas d'entrée : ils prennent les niveaux du fournisseur, avec cet avertissement. Dans le dialecte OpenAI, « désactivé » et un effort demandés ensemble sont écrits tous les deux (thinking: {type: disabled} à côté de reasoning_effort), au vendeur de juger. Azure OpenAI garde les trois niveaux par défaut, sans mesure. La campagne des fournisseurs confronte la table à ce qu'elle mesure (orkeon llm probe, M15–M17 face à M18), mais seulement le jour où elle tourne : un vendeur qui change entre-temps les valeurs d'un modèle se manifeste par l'erreur propre à ce modèle, jusqu'à ce qu'une entrée ou Llm:ModelCapabilities:<id> suive.
  • context N% dans la console à deux volets lit un appel face à un réglage. Il suit le dernier appel au modèle du tour du prompt : une tâche lancée dans ce tour montre donc son propre chiffre jusqu'au prochain appel de la commande principale. Il est absent pour un crew lancé de façon synchrone par runCrew, dont aucune instance de commande ne reçoit les appels, et sa fenêtre vient du seul Orkeon:Cli:Session:ContextWindowTokens (200000 sans ce réglage) : il ne suit pas /model.
  • Les palettes de la console sont nommées, pas détectées. La palette ne vient jamais du terminal, ctx.setTheme vaut pour la session, et un sélecteur ne peut pas en prévisualiser une en direct : rien ne rappelle un script depuis le fil d'interface.
  • ? seul ne peut pas commencer un message sur un prompt vide de la console à deux volets. Il y liste les touches ; pendant qu'un ctx.prompt de script lit, c'est du texte.
  • Le prompt rappelé sur un transcript remonté cache la ligne sous lui. Remonter d'une ligne de plus la montre.
  • Les deltas d'appels d'outils s'arrêtent aux sinks qui les lisent. Les deltas de raisonnement ne sont pas transmis à ILlmDeltaSink, et le provider mock n'émet aucun delta d'appel d'outil.
  • Le flux dans la console à deux volets. Il est actif dans la REPL et désactivé pour un crew exécuté sauf si Orkeon:Cli:ConsoleStreaming:Enabled dit autre chose, et un texte intermédiaire de l'assistant ne s'affiche pas dans un crew qui ne diffuse pas. Les lignes d'un tableau restent cachées jusqu'à la fin du tableau, et une clôture de bloc de code ajoute une ligne vide.
  • Les diffs et le code de la console à deux volets n'ont pas de coloration syntaxique, qui demanderait un paquet.
  • La sortie d'une commande qui passe à la ligne repart en colonne 0. Les lignes suivantes d'une ligne simple coupée ne s'alignent pas sous le coude.
  • Les prompts d'un script dans la console à deux volets. Un ctx.prompt que le script n'attend pas laisse une lecture ouverte, et la lecture suivante de la boucle peut échouer avec A ReadLineAsync is already in progress. Une ligne tapée au prompt pour une approbation, mise en tampon puis retirée avec sa question, peut atteindre la boucle comme une ligne à part entière (rare).
  • L'historique d'un run hébergé est partiel. orkeon-host enregistre run.started, les événements de tâche, error et run.finished de chaque run (Orkeon:RunHistory, actif par défaut) ; les événements tool.*, llm.call.* et cost.updated ne sont pas publiés pour un run hébergé, car les observateurs d'outils, d'usage et d'appels sont des services du processus et qu'un démon mène plusieurs équipages à la fois : ils restent sur orkeon run --events. L'historique d'un run ne garde aucun llm.delta sans IncludeDeltas. Un run dont l'hôte ne peut pas être construit (un réglage refusé, un équipage illisible) ne laisse aucun historique, pas plus que --resume latest, dont le runner ne nomme le run qu'après avoir regardé dans le magasin. Les événements qu'un run écrit avant que l'historique puisse le rejoindre (run.started et ce que la construction de l'hôte émet) sont gardés dans un tampon de 128 ; au-delà ils restent sur le flux et ne sont pas dans l'historique (un avertissement dit combien). Un run tué avant run.finished n'est orphaned que pour un lecteur du même hôte : sur un autre hôte (un dossier partagé) il reste running, et MaxRuns et la purge continuent de le compter comme en cours. Plusieurs processus peuvent écrire un même dossier d'historique : le magasin Sqlite est en mode WAL avec un délai d'occupation, le magasin JSONL ajoute à son index sans jamais le réécrire ; un run repris sous son propre id (--resume <id>) poursuit la séquence que l'historique tient pour lui, son second run.started porte resumed: true, de sorte que ce que orkeon runs show écrit n'est le flux d'aucun des deux processus ligne pour ligne. L'identifiant du run côté démon est l'ExecutionId du run, la clé de son historique ; hostRunId dans run.started le répète.
  • firefox — bornes énoncées (voir le guide). La politique d'URL vérifie les pages que l'onglet affiche, avant que le navigateur démarre et après chaque action qui peut naviguer ; les sous-ressources qu'une page charge (images, scripts, cadres, XHR) sont récupérées par Firefox lui-même et ne sont pas vérifiées — gardez le navigateur sur un réseau isolé quand la politique compte. Le texte d'une page n'est pas filtré contre l'injection de consignes. search envoie le texte des sections de la page au fournisseur d'embeddings, en une collection éphémère par page visitée (préfixe firefox), jamais supprimée : le sous-système RAG n'a pas d'API pour retirer une collection. Le texte de type est un argument d'outil que le modèle écrit et que la transcription garde : jamais un secret. Un seul onglet est piloté à la fois — un lien qui ouvre un onglet y déplace la session, et l'onglet quitté n'est relu qu'après switch_tab ; les onglets que l'utilisateur ou un autre agent a ouverts dans un navigateur partagé ne sont jamais vus. Un profil nommé est utilisé tel quel : les onglets que Firefox restaure au démarrage sont ceux de l'utilisateur, pas de l'agent, et ce que le profil contient (cookies, sessions, extensions) n'est ni filtré ni supprimé — un agent sur le profil de l'opérateur agit en son nom. La vérification du verrou avant le démarrage ne reconnaît qu'un profil tenu par un Firefox de cette machine ; un profil ouvert sur une autre machine par un dossier partagé n'est pas vu, et Firefox le refuse au démarrage. screenshot écrit un PNG à un chemin virtuel et ne rend rien d'autre : le modèle ne voit pas l'image. Une page restaurée depuis le cache d'historique (back) est reconnue à son adresse : back entre deux entrées d'historique de même adresse attend le délai de commande (CommandTimeoutSeconds, 30 s) avant que la page soit lue. Vérifié sur Firefox 159 sous Linux ; les chemins de lancement Windows et macOS sont écrits, pas campagnés.
  • orkeon eval note ce que la suite sait noter. eval run --crew donne à la crew un prompt par cas (task_description, en contexte initial et en {input}) et ne note que sa sortie finale : les sorties intermédiaires des tâches et les événements du run ne sont pas dans le rapport. eval bench note des sorties enregistrées et n'accepte pas --crew ; ses runs répétés ne diffèrent qu'avec les juges LLM. --offline avec --crew refuse une crew dont un agent (ou le manager) répondrait par un fournisseur autre que le mock - son profil propre, son fournisseur propre ou le défaut de l'hôte - et nomme l'agent et le profil ; il ne regarde pas les outils qui atteignent seuls le réseau.
  • Modèles dotnet new : trois points de départ, pas plus — Orkeon.Templates livre orkeon-host, orkeon-plugin et orkeon-tool. Le modèle d'hôte exécute un crew.ork.ts par ICrewScriptRunner (il demande donc esbuild sur la machine, et tire Orkeon.Tools et les embeddings locaux par Orkeon.Scripting) ; il a la forme du démon orkeon-host (hôte générique, appsettings.json) mais n'est pas le démon : ni registre de crews, ni passerelle de chat, ni canaux. Le modèle de plugin référence Orkeon à la compilation seulement (ExcludeAssets="runtime") et part du manifeste du plugin d'exemple ; un plugin se charge depuis un dossier, rien ne le publie. Chaque projet généré fige les paquets Orkeon à la version du paquet de modèles qui l'a produit : un modèle installé depuis un paquet plus ancien génère un projet de cette ligne. Le rechargement à chaud et une extension d'IDE n'en font pas partie.
  • Le gate de permissions décide après les crochets d'outil d'un script. Le rappel onToolCall d'un script s'exécute avant le gate, qui juge l'entrée qu'il renvoie (une consultation par appel, dans l'invocation avec le pipeline d'invocation des outils) : un appel que le gate refuse a quand même exécuté le rappel. Le budget d'outils n'est débité qu'une fois l'appel admis par le gardien et le gate.
  • Une lecture bornée d'un historique de runs JSONL lit tout le fichier. IRunHistoryReader.ReadEventsAsync(runId, fromSeq, limit, ct) applique la limite en SQL dans le magasin Sqlite ; le magasin JSONL lit le fichier du run et s'arrête après la limite.
  • La permission gate est désactivée tant qu'un hôte ne l'active pas. Orkeon:Security:PermissionGate:Enabled vaut false par défaut : aucun appel d'outil d'un script ou d'une crew YAML n'est filtré, et le permissionMode: d'un agent n'est lu par rien tant que la gate n'est pas activée (configuration). Ce qui borne encore un outil sans elle, ce sont les droits VFS des mounts, le Guardian et le confinement propre de l'outil (shell_command).
  • Le bloc budget: d'une crew ne plafonne que le mode autonomous. Ses tokens, wallTimeSeconds, toolCalls, delegationDepth et spawnedAgents sont lus par process: autonomous ; une crew qui le déclare sur un autre mode est refusée au chargement. Le plafond que tous les modes respectent est Orkeon:CostTracking:DefaultCrewBudget de l'hôte (MaxTokens, MaxCostUsd), cumulé par identifiant de crew — par exécution pour une crew YAML ou C#, qui prend un nouvel identifiant à chaque chargement, tandis que les appels ctx.llm propres à un script se cumulent sous le nom de la crew pendant toute la vie du processus, à part de ses tâches orchestrées : l'appel qui le franchit va à son terme, le suivant est refusé avec BudgetExhaustedException (configuration).
  • Security:Audit:RetentionDays n'est lu par aucun purgeur. La clé est déclarée (90 par défaut) mais rien ne supprime les anciens événements d'audit : le sink en mémoire vit autant que le processus, et les fichiers qu'un JsonFileAuditSink écrit sous AuditDirectory restent jusqu'à ce que l'hôte les supprime.
  • Trois chemins chargent une crew sans le contrôle des livrables. Le contrôle qui avertit, au chargement, d'un livrable tool_call qu'aucun agent ne peut écrire (livrables vérifiés au chargement) s'exécute dans CrewFactory : une crew construite en C# avec CrewBuilder n'est pas contrôlée (l'hôte appelle DeliverableToolCheck.Check lui-même), un .ork.ts procédural sous --validate est bundlé, jamais chargé comme une crew, et un agent dont le modèle exécute ses propres outils (un agent Microsoft Agent Framework) compte comme capable d'écrire. Sur ces chemins, le run signale de toute façon un fichier qui n'a pas été écrit (deliverableMissing).
  • Les drapeaux de plafond d'itérations et de livrable manquant sont best-effort. Seule la boucle d'agent principale (ChatClientAgentLoop) prend le tour sans outils après le plafond d'itérations et pose endedOnIterationCap : les deux boucles de repli, celle du tool calling natif et celle du texte legacy, finissent sur le plafond sans la note et sans le drapeau. Un canal servi par le handler de commandes d'agent d'un script (AgentCommandRegistrar) répond false aux deux drapeaux. deliverableMissing vient d'une sonde du système de fichiers virtuel après la tâche : sans système de fichiers, ou quand la sonde échoue, le drapeau reste false.