Changelog

All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

Unreleased

1.3.0 - 2026-11-18

A minor release: it adds public members (PublicAPI.Shipped.txt grows), so it is not a patch. It carries no [breaking] change: three new members are overloads that take the id of the provider (#396), and the interface one has a default body; the others are init-only properties of ParameterSchema and ToolSchema, whose defaults leave a schema built before them as it was, and two methods that write it (#415). #415 also changes the tool schema every provider and orkeon mcp serve send, and its entries say what a model or an MCP client sees differently. #413, #414 and #416 change what the MCP server and client put on the wire; that surface is experimental (ORKEXP004), outside the commitment of 1.x, and each entry below says what a client or an installation sees differently. #418 changes the version the telemetry and the agent card carry and the User-Agent of the HTTP tools: no public member is added or removed, one default changes (A2AOptions.AgentVersion, experimental, is empty where it was 1.0.0; AgentCard.Version keeps 1.0.0), and its entry says what a collector, a peer or a site sees. #416 empties the default of McpServerOptions.Version the same way. #417 and the entry on listings change what the client keeps of a server: an entry it cannot read is set aside alone, and a prompt with no name or a resource with no uri is no longer listed.

Added

  • ITokenBudgetTracker.RecordUsage, TokenBudgetTracker.RecordUsage and TokenBudgetTracker.EstimateCost each gain an overload that takes the id of the provider that served the call (#396). The interface member has a default body that forwards to the provider-less one, so a tracker written before it still compiles and ignores the provider.
  • orkeon forge: a folder of the team can say that its contents change from run to run (#400). examples: true on an input folder — set by the assistant from the need, or by a client in folders.confirmed — makes the files found in it at the fill step examples of what will come: the plan prompt presents them as such, asks for tasks made for whatever the folder holds when the team runs, and tells the assistant to name none of them in a task, a goal or a backstory, and the terminal marks the folder (contents change — its files are examples). The large-file reading rule is then said for any large file, not for one by name, and a shorter one (search first, read only the ranges found) is said even when none of the examples is large. Absent, the plan is made as before: for the files that are there, by their names. An input folder a client confirms without the property keeps the value the proposal gave the same path (a renamed folder says it again); examples: true on an output folder is refused, a FORGE-FOLDERS-INVALID in a confirmed list and a refused brief_submit in the assistant's brief.
  • A tool's schema says all of JSON Schema a model reads (#415): ParameterSchema gains Properties (the properties of an object parameter, each with its Required), Items (the schema of an array's items, at any depth), AnyOf, AllowsAdditionalProperties (false writes additionalProperties: false), and the bounds Minimum, Maximum, ExclusiveMinimum, ExclusiveMaximum, MinLength, MaxLength, Pattern, MinItems and MaxItems; ToolSchema gains AllowsAdditionalParameters. ParameterSchema.ToJsonSchema() and ToolSchema.ToInputJsonSchema() write the JSON Schema, and are the one writer of every provider - the OpenAI and the Anthropic tool formats, Ollama's included - and of orkeon mcp serve. A schema that sets none of the added members goes out as in v1.2.0 but for this: a property with an empty description no longer carries "description": "", the MCP server now publishes the names of an EnumMap as its enum, as the providers did, and an array whose items are not known carries items: {} (the #415 entry under Fixed). The value schema of a dictionary is sent as in v1.2.0 unless it sets an added member, but an array value carries items: {}; orkeon mcp serve also publishes the format and the items its writer left out. A replay cassette recorded with v1.2.0 is still found: the key of a call leaves out the added members while they hold their defaults. ItemsType, ItemsFormat and ItemProperties still work: they are read when Items is not set. McpToolAdapter.ConvertToToolSchema and the McpToolAdapter constructor (experimental) now throw InvalidOperationException for a schema beyond the client's budgets (the #415 entry under Fixed).

Fixed

  • shell_command dropped the identity of a commit (#404): the command it starts receives a fixed list of the host's variables, and GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, GIT_COMMITTER_NAME and GIT_COMMITTER_EMAIL were not on it. Where git reads no ~/.gitconfig - in a container, the image of this release among them, or in a session confined by bubblewrap, Seatbelt or AppContainer, whose HOME is a folder of its own - a crew allowed to commit (Orkeon:Tools:Shell:AllowInterpreters) stopped on Author identity unknown whatever identity the caller set; Orkeon:Tools:Shell:Environment:Propagate could not carry them either, its secret filter refusing GIT_AUTHOR_* for the AUTH of AUTHOR. The four are now on the built-in list, under every confinement backend. They hold a name and an address; no other GIT_* variable follows (GIT_ASKPASS, GIT_SSH_COMMAND, GIT_CONFIG_GLOBAL). The code sandbox is unchanged.
  • The code index recorded no import of a Python file (#406): the module of an import is a dotted name, which the index did not read, so dependency_graph returned the modules with no edge and package_summary no dependency. A Python import is now read from its syntax and resolved against the files of the tree: a/b.py or a/b/__init__.py under the folders Python would search - for a script its own folder then each folder above it, for a file of a package the folder above its topmost package first; a name of from a.b import c that is a submodule reaches its file, the others reach a.b; import a.b where b is an attribute reaches a.py; a relative import starts from the importing file's package. An absolute import that no folder holds goes to ext::pypi::<first segment>. A base class named by its short name, when several files declare it, now also resolves to the one in a file a Python import reaches. An incremental refresh re-resolves the unchanged importers of a Python file that joins the tree when their import had gone to ext::pypi:: with a name of the new path below the indexed root, or to the __init__.py of a package above it; any other importer keeps its edges until it changes or the index is rebuilt. An index built before this change holds no such edge until it is rebuilt.
  • orkeon mcp serve wrote every member it did not carry as null (#405): a response held "error": null beside its result, or "result": null beside its error, where JSON-RPC allows one of the two. The client of the MCP TypeScript SDK - the one Claude Code and most MCP hosts use - refuses such a message, so the answer to initialize was dropped and the connection timed out. A response now carries result or error, never both, and an optional member is absent when it has no value: nextCursor of a list, mimeType and data of a text content, data of an error, description of a resource or a prompt, and the others of the MCP types. The answer to a line that could not be parsed keeps "id": null, as JSON-RPC asks. The MCP client is corrected the same way: a request or a notification without parameters no longer carries "params": null, and a tools/call without arguments no "arguments": null.
  • The container image ghcr.io/orkeon/orkeon had no git (#404). A crew that runs it through shell_command on the repository mounted on /workspace got git: not found, and read the empty output as an empty repository. The image now installs git, and declares every directory safe to it (safe.directory, system-wide): a repository whose owner on the host is not the user the container runs as - a --user that differs, a mount owned by root - is read all the same. The image sets no git identity: a commit needs GIT_AUTHOR_* and GIT_COMMITTER_* from the caller. The shell allowlist is unchanged: shell_command runs git status, log, diff and show by default, and any other git command (rev-parse, commit) still needs Orkeon:Tools:Shell:AllowInterpreters, which the image does not set. The release workflow runs the image's git on a mounted repository, as a user that does not own it, before it pushes the image.
  • orkeon mcp serve (McpServer) handed an array or an object of a tools/call to the tool as its raw JSON text (#402). A tool that validates its parameters refused the call (Parameter 'edge_kinds' has invalid type. Expected: array), and one that does not read the text as one value (rag_ingest took its sources for a single path): 26 of the tools the server serves have an array parameter, and 11 a required one (count_pattern, docx_writer, edge_list, edit_batch, email_delete, email_mark, email_move, local_embed_text, rag_ingest, sub_graph, xlsx_writer), so they could not be called from an MCP client. The arguments now reach the tool as typed values: an array is a list, an object a dictionary, a number written without a fraction or an exponent that fits a long is a long (it was a double), any other number a double, and null is null (it was the string null). tools/list publishes the items of an array parameter (their type, and their properties for an array of objects), as the schema an agent's model reads does. rag_ingest answers a glob rooted outside every mount with a tool error that names the path and the mounts, where the call ended in the JSON-RPC error -32603, and its sources parameter says it holds strings.
  • The opt-in token budget priced a call without its provider (#396). TokenBudgetTracker looked a price up by model alone, so it never read a row scoped to a provider: the built-in rows of DeepSeek, Z.AI, Kimi, Qwen, Gemini, Mistral, Grok, MiniMax, Together, Mammouth and Ollama, and a CustomPricings row with a Provider. The cost it compared with MaxCostPerCrew came from its own approximate rates instead, and an Ollama model was counted at those rates, not at 0. A host that passes the provider's id (ollama, deepseek, zai...) to the new RecordUsage overload now gets the row the pricing registry picks for that provider. A call to the provider-less overload is priced as before.
  • orkeon mcp serve answered a line that is no valid request with -32700, -32601, a success or nothing (#414). -32700 is now kept for text that is not JSON, and -32600 Invalid Request answers a value that is no object (a scalar, null, an array: batching is not spoken, so a batch gets one answer for the whole line), a jsonrpc that is absent or not "2.0", a method that is absent, empty or no string, an id that is null or neither a string nor an integer, and a params that is neither an object nor an array. A response (a result or an error with no method) is dropped, as JSON-RPC asks: it used to be answered -32601. The answer carries the id when it could be read, null otherwise. A message that carries an id beside a notifications/* method is now answered (-32600, with its id): it used to be taken for a notification, obeyed and left without an answer. A C# host that calls McpServer.ProcessRequestAsync gets the same answers for the request it is handed, except what a request it deserialized itself no longer holds: a null id and an absent jsonrpc (the limitations). A line of valid JSON nested deeper than 64 levels answered -32700, as if it were no JSON: it answers -32600.
  • orkeon mcp serve let bad tools/call parameters through (#413). arguments that were present and no object were replaced by none, and the tool ran: they are refused with -32602, for a registry tool, a run_crew_* tool and prompts/get alike. A params that is an array or a name that is no string answered -32603 Internal error: it answers -32602. A number beyond the range of a double (1e400) failed the call with the .NET serializer's own message: the call now answers isError: true with Argument 'x' is not a finite number. (x[0], x.y when nested, ["a.b"] for a name that holds a dot or a bracket), and the tool is not called.
  • One tool of a remote MCP server could take every tool of that server away (#417). The MCP client threw on a parameter whose type is an array (["string", "null"], a nullable parameter), on an enum of numbers or booleans, and on a required entry or a description that is no string; the connection failed with a .NET message that named neither the tool nor the property. A type array is now read as its one member that is not "null", every scalar enum value is kept, and a tool that cannot be registered - a null entry of the list, a tool with no name, an inputSchema that still cannot be read, a name, a description or annotations of the wrong JSON type - is set aside on its own, with a warning that names the server and the tool (mcp.tool.unreadable, written once for that entry, and once for that definition of an inputSchema that cannot be read): tools/list is read tool by tool. A tool that becomes unreadable at a tools/list_changed leaves the registry.
  • The rest of what an MCP server lists is read the same way. prompts/list and resources/list were read a page at a time: one prompt or resource of the wrong JSON type failed the listing with a .NET message, and a "prompts": null or "resources": null failed it too. They are read entry by entry: a prompt with no name, a resource with no uri or an entry of the wrong JSON type is set aside alone, with a warning written once (mcp.entry.unreadable), and null lists nothing; a prompt name or a resource uri listed twice is kept once, the first (mcp.entry.duplicate); a prompt's "arguments": null is no argument, and a prompts or resources member of the wrong shape lists what could be read, with a warning (mcp.listing.unreadable). A tools/list answer of the wrong shape - a tools that is neither null nor an array, a nextCursor that is no string - still fails the listing, and so the connection: no empty listing stands for it, which would take the server's tools out of the registry at a tools/list_changed. Its message now names the server and the member, where it was the .NET serializer's. A name one server lists twice was logged as an error, a collision with an already-registered tool, and counted among the server's rejected tools, though its first copy was registered: it is one tool, warned about once (mcp.entry.duplicate), the names compared without their case as the registry compares them. A tool whose "description" is null has an empty description.
  • The MCP client kept too little of a remote tool's parameter (#415): the items of an array were dropped, so an agent's model saw a bare array, and so were the format and the additionalProperties of a dictionary. They are kept, with the properties of an array of objects, and an array whose items cannot be read (none, several types) is shown with items: {}, any JSON value, where a provider that wants items on every array refused the bare one, and with it every call of the agent; the MCP server and the built-in tools' schemas do the same. A parameter with no type ({}, an anyOf of several schemas, a $ref that names nothing local) was read as a string: it now has no type, and the model may give any JSON value. A default is kept as the value it is: a whole number stays whole (it was read as a double), an array or an object is no longer its JSON text, and "default": null is no default (it was the text null). A number no double holds (1e400) is dropped from an enum or a default, and items that declare properties and no type are read as objects. The client now keeps the whole schema: the properties of an object parameter, arrays of arrays, the enum, description and default of items, the bounds, additionalProperties: false, the alternatives of anyOf / oneOf, a const, and the local $ref / $defs it resolves; a nullable anyOf (Pydantic's Optional) is read as its one schema, and an allOf of objects as one object. A tool whose inputSchema expands to more than 4096 schemas, or copies more than 1 MiB of text, each use of a $ref counted (a definition used many times counts each time), is set aside with a warning written once per distinct tool definition. A tool served by orkeon mcp serve now publishes the format of its parameters, a remote tool's included. The limitations name what a remote parameter still loses.
  • The MCP server and the MCP client introduced themselves as version 1.0.0, whatever the release (#416), in the legacy handshake (serverInfo, clientInfo) and in the _meta of the modern era. Both announce the version of the release they run, the one orkeon --version prints. MCP:Server:Version is empty by default and still wins when it is set. An installation that copied "Version": "1.0.0" from appsettings.sample.json keeps announcing 1.0.0: remove MCP:Server:Version or leave it empty.
  • Outside MCP too, Orkeon announced a fixed 1.0.0 whatever the release (#418). The OpenTelemetry resource (service.version), the activity sources - Orkeon.Scripting, which reported none, included - and the meter, and the agent card of the A2A server now carry the version of the release that runs, the one orkeon --version prints. They all read it from one place, the Orkeon.Domain assembly, the User-Agent and Orkeon.Scripting included: an application that mixes Orkeon packages of two versions announces one version, not one per assembly. One HttpClient handed to several HTTP tools carried the product once per tool in its User-Agent: it carries it once. A2A:AgentVersion is empty by default and still wins when it is set; an installation that copied "AgentVersion": "1.0.0" from appsettings.sample.json keeps announcing 1.0.0: remove the key or leave it empty. The HTTP tools send User-Agent: Orkeon/<version> (+https://github.com/Orkeon/orkeon) where they sent Orkeon/1.0: a site that filters on the exact former string sees the change at every release. The public constants OrkeonDiagnostics.ServiceVersion, OrkeonActivitySources.Version, PlatformDefaults.Version and HttpDefaults.DefaultUserAgent keep their value for the callers that compiled them in; Orkeon no longer reads them (DefaultUserAgent is the fallback when a build's version is no valid product token). GitHubTool sent a bare User-Agent: Orkeon: it sends the same value as the other HTTP tools. AgentCard.Version keeps its default, 1.0.0: an agent card read from a peer that names no version reads 1.0.0, as before.
  • orkeon forge (#400): an input folder confirmed without examples kept the proposal's value only when its path was the proposal's to the letter, case included, while a list compares two of its paths ignoring case (/Inbox and /inbox are one folder listed twice). A client that confirms the names in lowercase, as Orkeon Studio does, turned an inbox of examples into fixed material without a word. The value is now carried over to the same path, letter case aside.

Documentation

  • The campaign of the drive tools against real accounts (DRIVE-07) is closed (#397, #399): its recorded pass ran on one personal Google account and one personal Microsoft account; a work or school OneDrive account was not run, as the limitations say.

1.2.0 - 2026-11-16

A minor release: it adds public members (PublicAPI.Shipped.txt grows), so it is not a patch. It also carries five changes marked [breaking] below, made on purpose as exceptions to the 1.x commitment of the stability policy. None of them removes or changes a member of the frozen surface: each one changes a behaviour that was wrong, and its entry gives the migration:

  • A RAG collection indexed with another embedding model is refused (#381).
  • orkeon doctor fails when tsc is required by TypeCheck: Always and missing (#387).
  • The forge assistant tags its crews sequential (#382).
  • A forge plan must list the writer of every path its tasks and agents read (#388).
  • The forge writes source: final_message for a deliverable its agents cannot write, and refuses a plan whose binary deliverable an agent that may run its task cannot write (#392).

Added

  • ModelPricing.Provider scopes a pricing row to a provider (null means any provider), and IModelPricingRegistry gains the provider-aware TryGetPricing(string? provider, string model) and CalculateCost(string? provider, string model, ...) overloads, as default interface methods that delegate to the existing members: an implementation of your own still compiles. RegisterPricing files a row that names a Provider under that provider, and GetAllPricings lists the provider-less rows only, custom rows included: a provider-scoped row, built-in or custom, is not in it. Orkeon:CostTracking:CustomPricings:<i>:Provider sets it from the settings (#383).
  • TaskResult.EndedOnIterationCap, TaskResult<TOutput>.EndedOnIterationCap, TaskExecutionSnapshot.EndedOnIterationCap and CrewExecutionEvent.EndedOnIterationCap (all bool, false by default, init properties) mark a task whose answer came from the tool-free turn after the agent loop's iteration cap. The task keeps Success and AgentExitReason.Completed: the flag sits beside them, it is no new enum member. The task.completed line of orkeon run --events carries it as endedOnIterationCap (always written, just before deliverableMissing), the forge trial's task.completed too, and a resumed capped task, typed or not, replays it from its checkpoint (#388). The flag is set in every orchestration mode, a peer takeover in Autonomous mode (AttemptDelegationAsync) included: AgentChannelResponse.EndedOnIterationCap (experimental, ORKEXP002) carries it back from the channel. The one exception is a channel answered by a script's agent-command handler (AgentCommandRegistrar), which has no cap information and answers false. The two fallback agent loops, the native tool-calling one and the legacy text one, cannot take the tool-free turn: they end on the cap without the note and without the flag, as before. DelegateWorkResponse.EndedOnIterationCap (JSON ended_on_iteration_cap) tells the delegating agent that its coworker ended on its cap, and the tool's message says so. TaskResult<TOutput> gains CacheHitTokens, CacheMissTokens (long?) and EndedAt (DateTimeOffset?), init properties, and its TokensUsed, PromptTokens, CompletionTokens, IterationsUsed and RetryCount, which a typed task left at 0, now carry the task's figures; a resumed typed task replays the cache tokens and EndedAt from its checkpoint (a typed checkpoint written before this change holds none of them: it replays no cache tokens and no date). The run.finished line carries cappedTasks, the number of tasks whose last attempt ended on the iteration cap (always written, 0 when none did): orkeon run, the forge trial (counted per trial), orkeon-host and the MCP crew tool host write it (#388).
  • Loading a crew, YAML or .ork.ts, checks its tool_call deliverables: a task whose deliverable no agent able to run it can write (the agent it names in a sequential, parallel or graph crew, every agent when it names none or one the crew does not carry; every agent but the manager in a hierarchical or consensual crew, every agent in an autonomous one; with a built-in tool that writes that path: docx_writer, xlsx_writer, image_generation, firefox for their formats, or file_write for a text file, never a binary one) logs a warning, and orkeon run --validate prints it once as a WARNING: line on stderr with the exit code unchanged; nothing is refused. A toolbelt holding a tool Orkeon does not ship (MCP, script, plugin) is not warned about, nor is an agent whose model runs its own tools (a Microsoft Agent Framework agent), which counts as able to write. DeliverableToolCheck.Check(tasks, agents, processType, managerAgentId), DeliverableToolFinding (with Kind and Message, the sentence a host reports) and DeliverableFindingKind (Orkeon.Application.Crew) expose the check to a C# host, with DeliverableToolCheck.IsBinary, WritersOf, PreferredWriterOf (string?), WriterHeldFor, CanWrite, FileWriterToolNames and the FileWriteToolName constant, and DeliverableBaselineScope.Begin() (Orkeon.Application.Crew.Execution), which the crew orchestrator opens for each run, holds a run's first-attempt state of each deliverable; CrewFactoryOptions.WarnOnDeliverableTools (default true) set to false turns the load warning off (#392).

Changed — a collection indexed with another embedding model is refused [breaking] (#381)

Before: orkeon rag ingest, rag search and eval rag read and wrote a collection whatever embedding model had built it, so a changed model mixed the vectors of two models. Now: the provider, the model and the dimensions that the manifest of a collection records are compared with the current model, and a different one is refused on rag ingest (without --reindex), on rag search, on eval rag --no-ingest -c <collection> and on eval rag -c <collection> when its ingest pre-pass runs without --reindex: exit 1, one line that names the collection, both models and orkeon rag ingest --reindex. A collection with no manifest, and eval rag without -c, are not checked. What to do: run orkeon rag ingest --reindex to rebuild the collection with the current model, or go back to the model that built it.

Changed — orkeon doctor fails when tsc is required and missing [breaking] (#387)

Before: a missing or unusable tsc was a warning (exit 0) whatever the type-check mode. Now, by Orkeon:Scripting:Toolchain:TypeCheck: under Off a tsc that is missing, a configured TscPath that does not exist or a tsc that does not answer --version is ok (unused); under Validate a tsc found nowhere is ok (optional) and the other two cases warn; under Always a tsc found nowhere or a TscPath that does not exist is fail (exit 1, ExitScriptError; a tsc that does not answer --version stays warn), and its detail gives the reason, then the installed remedy (npm install -g typescript, Orkeon:Scripting:Toolchain:TscPath, TypeCheck: off), and the checkout bootstrap only when orkeon runs from a checkout. What to do: install typescript, point TscPath at it, or set TypeCheck to Off or Validate where a CI step runs orkeon doctor under Always without tsc.

Changed — the forge assistant tags its crews sequential [breaking] (#382)

Before: the forge assistant's orkeon.crew.process tag read autonomous, a process the runtime ignored. Now: it reads sequential. The tag is the one of the crew.run span of the Orkeon.Scripting source, which the assistant's procedural run opens; the crew.run span of the Orkeon.Crew source and the orkeon.crew.executions and orkeon.crew.active metrics, which report the process of a crew the orchestrator runs, are unchanged. The Procedural crew script warning each forge turn logged about process("autonomous") is gone. What to do: a dashboard or a filter that selects the assistant by orkeon.crew.process = autonomous must select sequential.

Changed — a forge plan must list the writer of every path its tasks and agents read [breaking] (#388)

Before: the forge did not check the paths a plan's texts name: a task could name a file under a deliverable root that no task it depends on writes (a later task's, an unrelated task's, or no task's), and the goal and the backstory of the agents were not read either. Now: a path under a deliverable root that a task names in its description or its expected output must be the task's own deliverable, the deliverable of a task it depends on (directly or through other dependencies), or a file already present under an output folder of the team, held by the forge or bound to a user dir, as the fill step recorded it: every file counts, found recursively, up to 10 000 per folder, with no 40-entry cap; a file put in a folder after the fill step is not known. In every process, a plan that breaks the rule is refused with an error that names the task and the path, which the designer gets back to fix. A path is read up to any Unicode whitespace (a no-break space, the narrow space before a French :) or a quote (« » “ ” ‘ ’), and starts after whitespace, = or : (path=/output/x, fichier:/output/x). A path that is a folder is accepted when an allowed deliverable or an existing file lies under it (/output/reports with a deliverable /output/reports/summary.md), for tasks and agents alike.

The same rule reads each agent's goal and backstory: a path under a deliverable root named there must be a deliverable of one of the agent's tasks, of a task they depend on, or an existing file. An agent with no task (a manager, an arbiter) may name any task's deliverable, and so may any agent of a hierarchical, consensual or autonomous crew; sequential, parallel and graph crews, and a crew with no or an unknown process, keep the per-agent rule. A path that no task delivers and no existing file holds is refused in every mode. The refusal names agents[i] ('key'): its goal|backstory names '<path>'. orkeon forge reopen of a crew promoted before this rule does not fail on it: the crew opens, and the next validation (the Blueprint stage, a blueprint_submit, a verdict edit) enforces it.

What to do: for a task, list the task that writes the file among the dependencies of the task that reads it. For an agent, remove the path from its goal or backstory, give the agent the task that writes it, or a dependency on that task. A team promoted before this release records no folder survey, nor does a brief that forge reopen derives from the crew files: after forge reopen, a path to a file the user put in a folder is refused like any other, until a task delivers it or the text no longer names it.

Changed — the forge writes source: final_message for a deliverable its agents cannot write [breaking] (#392)

Before: every deliverable of a forged crew was source: tool_call, so a task whose agent held no tool to write it never wrote its file. Now: the forge keeps tool_call when every agent that may run the task writes the path itself (the agent the task names in a sequential crew, which a plan naming no process gets, or in a parallel or graph one; every agent but the manager in a hierarchical or consensual crew, every agent in an autonomous one), and writes source: final_message otherwise: the framework saves the agent's final answer to the path. An agent's tools are its own plus the ones the task grants (a crew file's task-level tools:), as the engine counts them; forge reopen reads those back and the forge writes them into the crew files (tools: in YAML, .tools([...]) in crew.ork.ts), where 1.1.0 dropped them, and refuses a task tool outside the catalogue (FORGE-TOOL-UNKNOWN); a promoted team whose session holds no folder list mounts /workspace read-only (its input/ folder) when a task's tools: grants file_read or directory_read, as when an agent holds it. A binary deliverable (.docx, .xlsx, .pdf, an image…) is never switched: a plan whose agent lacks the tool that writes its format is refused, with an error naming the task, the agents and the tool to give (docx_writer, xlsx_writer, image_generation), or a text format when no built-in tool writes it; file_write never counts for a binary file, and forge reopen applies this refusal too, naming the crew file to fix. The YAML crew writes source: final_message only; crew.ork.ts always writes the source (source: "tool_call" or "final_message", which the typings require). forge reopen derives the source again from the plan, so a source edited by hand in the crew files is replaced. What to do: a forged team regenerated after this change may differ from the one before by its source lines and, for a crew whose tasks grant tools, by their tools: lines; a plan that delivered a binary file from an agent without its writer tool gives that agent the tool, or delivers a text format.

Fixed

  • A project that references Orkeon.Scripting or Orkeon.Tools.Embeddings.Local with ExcludeAssets="build" now builds offline and its host starts: the local embedder is built once, at the first embedding, and the embedded model reports its 384 dimensions without loading. A missing model fails the first local embedding with an InvalidOperationException that names LocalEmbeddingsModel/default/model.onnx and the exclusion. Put ExcludeAssets="build" on every reference that reaches the package, Orkeon.Scripting and Orkeon.Tools.Embeddings.Local alike: NuGet unions the flags, so one reference without it keeps the model download. A Slow end-to-end test pins both. A custom LocalEmbeddingOptions.ModelPath that holds no loadable model builds the provider the same way and fails the first embedding with an InvalidOperationException that names the ModelPath, the library's error as inner exception; neither the failure of the embedder nor that of Dimensions is cached, so the next call tries again (#376). The guard reports a provider that cannot give its dimensions with the provider's own message, as a Warning.
  • The embedding model guard no longer warns where it cannot act (#381); the refusal of a changed model by orkeon rag and eval rag is a breaking change, filed under Changed. orkeon forge records its fingerprint per session, at /forge/embedding-fingerprint.json (the default of Orkeon:Embeddings:FingerprintPath at the lowest precedence: an explicit setting still wins), so it guards nothing across sessions. orkeon rag and orkeon eval rag use no host fingerprint (their default FingerprintPath is empty): the manifest of each collection guards the collection instead, and orkeon rag ingest --reindex, which rebuilds it, is no longer blocked. The warning of a fingerprint it cannot read or write names Orkeon:Embeddings:FingerprintPath; a provider that cannot give its dimensions is warned with its own message (#376). Where the covering mount, overrides included, lacks Write or Create on the fingerprint file, or Create on its folder (a read-only /workspace, a promoted reading team), the guard still reads and compares a recorded fingerprint and still refuses a changed model, but writes nothing, and when no fingerprint is recorded yet logs one Debug line, never a Warning; any other failure still warns. A run whose FingerprintPath lies under no mount (no /workspace) skips the guard at Debug, with no "Access denied" line and no Warning.
  • Every paid provider's default model is priced: DeepSeek, Z.AI, Kimi, Qwen, Gemini, Mistral, Grok and MiniMax, and the Together and Mammouth gateways by their own provider-scoped rows. ollama and Docker Model Runner models cost 0 without a warning. Hugging Face stays unpriced (its routed provider sets the price): a call warns once per model per host process (an orkeon-host daemon warns once for its lifetime), no longer once per call, naming Orkeon:CostTracking:CustomPricings, and under a MaxCostUsd budget, the crew's or an agent's, a second warning, once per crew and model, says the budget cannot count that model's calls (it needs a cap above 0 and a call that carries tokens). A CustomPricings row always wins over a built-in one: a row with no Provider applies to every provider, a row that names a provider to that provider only. In 1.1.0 a custom row shorter than a built-in one lost to it (the longest pattern won): a CustomPricings row written as a fallback (gpt, claude) now prices every model it prefixes; narrow its ModelPattern, or scope it with Provider. gemini-3.8-flash is priced 1.50 / 7.50 per million tokens with a cache read at 0.15 (Google's rate from 2027-01-01, kept as the conservative figure for budgets) and deepseek-flash has a cache read at 0.006. A few other models of these providers are priced too: gemini-3.7-flash (0.75 / 3.75 through Gemini, 1.50 / 7.50 through Mammouth), glm-5.3, glm-5.3-flash, kimi-k3 and grok-4.7. Long-context price tiers are not modelled (#383). What to do: a MaxCostUsd cap set while one of these models cost 0 now counts its calls and can stop a run 1.1.0 let finish: raise the cap, or add a CustomPricings row for that model at 0.
  • Orkeon:CostTracking:Enabled false now does what its documentation says: every call is recorded and priced (the history, the report and the unpriced-model warning of the registry are unchanged), none is refused, and no budget alert and no "budget cannot count this model" warning is raised. true is unchanged (#383).
  • The SECURITY line of the shell interpreters is logged once per host, at the first shell_command call validated once interpreters are enabled, instead of at construction and listing of shell_command. It states the confinement in force: the backend, or none with its reason (a container, Mode = None), or unavailable when every call fails. Under a confining backend it also says network on or network off (from Confinement.AllowNetwork), and under bubblewrap system directories are read-only; under Mode = None, or unconfined inside a container, it always says network on (the unconfined shell never cuts the network) and makes no read-only claim (#384).
  • A blank model id under Llm:ModelCapabilities ("", " " or a key :Vision), whatever the entry holds, stopped the host at start with a raw ArgumentException (ParamName id) that named neither the section nor the file. It is now a settings refusal naming Llm:ModelCapabilities: the host build refuses it with a RunnerSettingsException, and orkeon run, --validate and --list-tools print the settings error and exit 1 (#385).
  • orkeon doctor no longer reports a missing tsc as a warning when nothing needs it (#387); the fail under Orkeon:Scripting:Toolchain:TypeCheck Always is a breaking change, filed under Changed.
  • A task that ends on its iteration cap says so (#388). The tool-free turn after the cap tells the agent that tools are no longer available and asks it to state what it could not do (a file it did not write); an agent with two iterations left is told so once, while it can still act (nothing is sent when the cap is two or less); and the run summary labels the task ⚠ completed on its iteration cap, next to ⊘ skipped. An empty answer on the last allowed iteration takes the cap path too: the nudge is sent and the flag is set. The forge designs for a large document: a file of 128 KiB or more in a folder the user filled or bound with a dir is named to the designer with its size (report.md (750 KB), largest first), and the plan prompt adds the reading rules (search with grep first, then read by range) and a maxIterations of at least 30 for an agent that reads it. The hand-off rule that refuses a plan whose task reads a path it does not write or depend on is a breaking change, filed under Changed.
  • A task resumed from its checkpoint replays its RetryCount, typed or not, and reports the attempt that ended it: the replay sets the run's attempt to RetryCount + 1, so task.completed says attempt 3 for a task that took three attempts, where it said 1 (untyped, typed and decision replays alike). A checkpoint written before this change holds no retryCount and replays 0. A peer takeover in Autonomous mode whose task fails is now reported as a failure: the channel answers the peer's error (else the peer failed), the delegating agent takes its [DELEGATION FAILED] path and the task's snapshot reads Success = false; it read as a success with an empty answer before (#388). A run whose takeover failed can therefore end failed where 1.1.0 ended it green: the failure was there, unreported.
  • A forge trial whose test bench crashes now ends its --events stream with a run.finished line (success: false, outputPath null, zero durations and tokens, the cappedTasks and missingDeliverables of what ran before the crash) before its stage fails; it wrote run.started and no run.finished before. A cancelled trial still writes none (#388).
  • Repository tooling: the E2E pack tests pack the lineup under a run version (<version>-e2e-<8 hex>) and fail a restore that did not take the packages they packed, and packing Orkeon.Templates from a checkout stages its templates under obj-linux/ instead of under the project folder; the published packages are unchanged (#390).
  • An agent without file_write is no longer told to write its tool_call deliverable with it: the prompt always names the path, and the tool only when the effective toolbelt (the agent's tools plus the task's) holds a built-in tool that writes that path, the tool of its format first (docx_writer for a .docx), never file_write for a binary file. A final_message deliverable is announced too: the framework writes the final answer as-is to the path, so the agent gives the complete content and does not write the file itself (#392).
  • A task that succeeds with a tool_call deliverable whose file it did not write during the run (absent when an attempt ends, or unchanged since the task's first attempt of the run started, so a retry or a revision that keeps the file an earlier attempt wrote is not flagged) is no longer silent: it keeps Success, is flagged by TaskResult.DeliverableMissing, TaskResult<TOutput>.DeliverableMissing, TaskExecutionSnapshot.DeliverableMissing, CrewExecutionEvent.DeliverableMissing and AgentChannelResponse.DeliverableMissing (experimental, ORKEXP002) (all bool, false by default, init properties), logs a warning naming the task (its key, else the start of its description), the agent and the path, and shows as ⚠ completed without writing its deliverable in AUTO_SUMMARY.md (⚠ completed on its iteration cap without writing its deliverable when it also ended on its cap). The check goes through the virtual file system and is best-effort: a probe that fails leaves the flag false, a cancellation during it cancels the task. Only a successful task is flagged (a hierarchical task the manager rejected to the end is not), and a consensual task judges the file on the whole vote. The task.completed line carries deliverableMissing (always written, the last key), in every orchestration mode and in the forge trial; a resumed task replays it from its checkpoint (one written before this change replays false) and reports it when the file of a tool_call deliverable is gone at resume, while a final_message or structured_output file gone at resume only loses its path (CheckpointingAgentExecutionService.FileSystem, init). The failed output of a hierarchical task the manager rejected to the end names no deliverable path to the tasks after it. The run.finished line carries missingDeliverables, counted like cappedTasks on each task's last attempt when it succeeded (always written, 0 when none): orkeon run, the forge trial (per trial), orkeon-host and the MCP crew tool host write it. A decision task that declares a deliverable: is reported once at load, in a YAML crew, a crew.ork.ts and under orkeon run --validate alike, by its own finding (DeliverableFindingKind.DecisionTask): a decision runs no agent and never writes it (#392).
  • A previous task output cut to fit a later prompt now names the file of its deliverable when that file is known to exist: [full result in '<path>': read it with file_read] after the cut text, and [result of task <id> in '<path>': read it with file_read] for an output left out entirely, both only to an agent whose toolbelt holds file_read. TaskResult.DeliverablePath, TaskResult<TOutput>.DeliverablePath, AgentChannelResponse.DeliverablePath (experimental, ORKEXP002) and the application TaskOutput.DeliverablePath (string?, init) carry that path, in every mode, an autonomous takeover and a resumed task included (#392).

1.1.0 - 2026-11-15

A minor release: it adds public members (PublicAPI.Shipped.txt grows), so it is not a patch. It also carries three changes marked [breaking] below, made on purpose as exceptions to the 1.x commitment of the stability policy; each one fixes behaviour that was wrong, and its entry gives the migration:

  • crew.run()'s output (#369): JsCrewResult.output is an object?, where it was a string holding the CLR type name of an object output. It is the one line removed from the 1.0.0 frozen surface.
  • Thinking and effort are judged against the model on every provider (#356).
  • A C# host that evaluates a script catches a Jint.Runtime.JavaScriptException, the CLR exception on its clr property, where it caught the CLR type itself (#364).

Added

  • ctx.fileSystem.prompt (#378): an agent body reads the ## File system section a declarative turn of the agent holds in its system prompt (its scope, else the agent-facing mounts, sorted by virtual path, their rights, its working root or where relative paths resolve, the note on read-write paths) and places it in the system prompt it gives ctx.llm.act, which stays the script's: nothing is added to it. "" when no path is visible, when none of the agent's tools uses the file system, or when it sets .announceMounts(false), which so gains a meaning for a body. Both shapes render it through AgentFileSystemPrompt.Render (Orkeon.Application.Agent), so the wording and the order cannot drift, and a body no longer needs a list_mounts call to rebuild part of it.
  • llm.profiles (#364): the names llm.profile(name) takes, a frozen array — "default" first, then the host's profiles in the order and the spelling it declared them, those its allow-list refuses left out. Names only, never an endpoint or a key: a script checks a name before it asks for the profile, without case as llm.profile compares.
  • InvalidScriptError (#366): a script's own mistake the host refuses (clrType "InvalidScriptException": a builder method or build(), a stateMachine/stateGraph literal, llm.profile, an llm option, the rejection of an awaited ctx.llm.* call) is an instance of this global class, an Error subclass, so a script tests e instanceof InvalidScriptError instead of comparing clrType. A value over a domain limit (ArgumentException) and an out-of-range ErrorAction.retry delay (OverflowException) stay a plain Error; a C# caller still gets the InvalidScriptException.
  • Every LLM provider takes a resilience policy and a tool calling strategy together (#367): a public constructor (config, httpClientFactory, resiliencePolicy, toolCallingStrategy, logger = null) on the fourteen OpenAI-compatible providers, OllamaLlmProvider and AnthropicLlmProvider. A caller that brings its own Polly policy can still keep the text protocol (null strategy), which the constructor taking a policy alone no longer allows since it sends the tools natively.
  • An agent declares the only virtual paths its tools may touch (#349): filesystem: in YAML, a list of paths or {path, access} items (ro, rw, rwnd), AgentBuilder.FileSystem(...) in C#, .filesystem([...]) in .ork.ts. An entry selects and narrows the mount that holds it, never widens it; an entry under no mount or above the mount's rights refuses the run at start, naming the agent and the entry; so does an entry that grants no right, and in YAML a filesystem: that is not a list (no value, ~ or null is no declaration). During the agent's tool calls the file system refuses every other path on every mount (FileSystemService, so the file, search, RAG and attachment tools alike), in a denial that names the scope and no other mount; a path is read as the host reads it (a backslash off Windows, case and trailing dots or spaces), never granting more than the most specific entry; a listing gives only what a read would allow, and a recursive delete is refused when an entry below withholds Delete. list_mounts lists the scope, shell_command binds the scope's entries alone, start_job logs only where the scope writes, rag_ingest judges every source that is not a web address, and the semantic-graph tools leave out the nodes, edges, hits and source of files outside the scope. A spawned or delegated child runs under its parent's scope, which its own can only narrow (one that declares none holds the parent's rights under its own name); a working_root must lie inside the scope. In .ork.ts, ctx.delegate hands the caller's scope down, a run started from code while agents run takes the open attempts' scope (refused when they differ), an agent's hooks run under its scope and a crew's under its first agent's, and rag.ingest from a scoped body stays inside it. The C# side is FileSystemScopeEntry, AgentFileSystemScope and AgentRunScope.FileSystem.
  • The system prompt of an agent with a file-system tool gains a ## File system section (#348): its scope, else the run's agent-facing mounts, with their rights, sorted by path, and its working root (or the directory relative paths resolve against, said to lie outside the scope when it does). email_parser, image_generation, firefox, index_codebase and incremental_reindex count as file-system tools. announce_mounts: false turns it off for an agent or, at crew level, for every agent that does not set its own (AgentBuilder.AnnounceMounts, .announceMounts(false)). A tool says it touches the file system with IBaseTool.UsesFileSystem (ToolBase.UsesFileSystem, false by default).
  • orkeon llm probe tests the reasoning controls per model: M15 sends the thinking toggle on then off, M16 sweeps the effort levels (low to max then the values of M18's effort:* fragments, or the list of the new --sweep-efforts, which takes vendor values such as none), M17 sends a thinking budget. Each step reports what went on the wire (sent, lowered to another level, omitted) or the vendor's refusal, with the provider's warnings, the reasoning trace and tokens and the finish reason. The campaign kit runs them by default, renders a Reasoning section in each report and a "Reasoning per model" table in the campaign results page.
  • orkeon llm probe gains M18, the raw reasoning matrix, and its --raw-reasoning <file> option: each {label, body} item of the JSON file replaces the reasoning fields of the request just before it leaves, bypassing Orkeon's capability judgement, and the step is reported accepted or refused by the vendor.
  • Each reasoning step of orkeon llm probe also reports what the vendor's answer itself carried, read on the wire before the provider parses it: vendorTrace, vendorReasoningTokens and vendorFinishReason, in every dialect (chat completions, Anthropic messages, the Responses API, Gemini, Ollama). A trace the vendor sent but the provider did not surface reads wire only. The reasoning prompt is now a counting problem, so that a model with adaptive thinking reasons at all.
  • orkeon llm probe checks the model capability table (#356): once every mode ran, each M15–M17 step is confronted with the M18 fragments of the same run. A value Orkeon sent and the vendor refused (400, 422) reads missing restriction, a value Orkeon lowered or left out that the vendor takes reads too narrow (the off switch and none only when they stopped the reasoning; nothing when the vendor keeps reasoning at effort:none); either fails the mode. M15 now reads the Hugging Face switch (chat_template_kwargs.enable_thinking). The steps carry tableCheck and tableNote in the JSON, a Table column in the report, and the campaign's "Reasoning per model" table gains a Table column naming the contradictions.
  • A script reads what a model takes for reasoning (#359): LlmConfig.capabilities gives { model, known, thinking, efforts }, the effort levels being the provider's narrowed by the model's (empty when the model takes none), thinking one of none, effortOnly, toggle, budget, and known whether the capability table has an entry. The C# side is ILlmProvider.DescribeReasoning(model) (LlmReasoningCapabilities, ORKEXP005).
  • A script reads what became of the effort it asked (#360): reasoning on LlmConfig, on the results of act and chat and on the object stream() returns gives { model, asked, sent, notice }, sent null when no effort went out and notice lowered, dropped or unchecked, whichever set the effort (the call, the agent, the configuration or Llm:Thinking:Effort). The C# side is ILlmProvider.ReportEffort(config) (LlmEffortReport, LlmEffortNotice, ORKEXP005), judged as the call is and forwarded by every decorator. Inside an agent, ctx.llm.reasoning(opts) and ctx.llm.capabilities(opts) answer for the call those options name, on the agent's provider, model and effort: the report complete and extract cannot carry. The typings name the levels EffortLevel. Azure OpenAI's and Ollama's GenerateStreamingAsync now send the reasoning effort, the response format and the system message as their buffered calls do, where they dropped them in silence.

Changed — thinking and effort are judged against the model, on every provider [breaking] (#356)

One per-model table, IModelCapabilityRegistry (ORKEXP005), now says what each model takes for thinking, and every provider reads it before writing LlmConfig.Thinking, Anthropic and Ollama included. A ModelCapabilities entry gains Thinking (None, EffortOnly, Toggle, Budget), set from the configuration with Llm:ModelCapabilities:<name>:Thinking; the support that applies is the lower of the provider's and the model's.

  • An effort a listed model does not take is lowered to the highest level below it that both the provider's field and the model take, with a warning; it used to be omitted. A vendor value outside the five levels (none, minimal) is sent when the model's list holds it or the model is unknown.
  • On a model that always reasons (EffortOnly: GLM-5.3, kimi-k2.7-code, MiniMax-M3.1-Flash…), "on" sends no switch and "off" is dropped with a warning. Kimi K3 now receives the thinking switch it honours (it used to be stripped).
  • The models that do not reason are entered with Thinking: None (gpt-3.5, gpt-4, gpt-4-turbo, gpt-4o, gpt-4.1, the OpenAI audio models, gpt-5-chat, gemini-1.5, gemini-2.0): thinking asked on them is dropped with a warning instead of being sent.
  • An entry can name the provider that serves the model, <provider>/<model>, looked up first (the whole id) by IModelCapabilityRegistry.TryGet(model, provider), then the model's own entry: built in for mammouth/gemini-3.7 and -3.8, openrouter/google/gemini-3.7 and -3.8 (always reasoning, minimal to max, where Google's own API takes none to high) and together/zai-org/glm-5.3 (unrestricted, where Z.AI's own API refuses the off switch and most efforts); configured as Llm:ModelCapabilities:<provider>/<model>:.... A Thinking value holding a comma is refused.
  • A token budget is judged against the provider's declared support alone, so OpenRouter keeps sending one to Gemini 3.7, which always reasons; efforts compare case-insensitively. On Ollama, "off" with an effort sends think: false and warns that the effort is not sent.
  • Anthropic: "on" sends thinking: {type: adaptive, display: summarized}; "off" sends the model's own value (between_tools on Sonnet 5.5 up to effort high, disabled up to xhigh on Sonnet 5 and up to high elsewhere) and is left out with a warning above that effort. A buffered answer now carries its thinking blocks in the reasoning_content metadata, as the stream did.
  • Declared levels widen to what the provider campaign measured: up to xhigh on OpenAI and Grok; the five on DeepSeek, Kimi, Qwen, Together AI, Hugging Face, MiniMax and Mammouth AI. Together AI, Hugging Face and MiniMax now declare a thinking switch (reasoning: {enabled}, chat_template_kwargs.enable_thinking, thinking: disabled), Mammouth AI an effort.
  • The reasoning tokens (completion_tokens_details.reasoning_tokens) are read for every OpenAI-compatible dialect, buffered and streamed, and the stream reads the trace from reasoning_content or reasoning, the declared field first. The chat-client adapter maps the provider's finish reason onto ChatResponse.FinishReason: Gemini's MODEL_CONTEXT_WINDOW_EXCEEDED reads as Length, its RECITATION and PROHIBITED_CONTENT as ContentFilter.
  • Fallback chains are warned about when the fallback's model has a lower effective thinking support or fewer efforts than the primary's, not only its provider; a vendor value (none, minimal) is not reported missing on a fallback model the table does not list.
  • OpenAICompatibleProviderBase.EffortLevelsFor is gone: a dialect writes its thinking fields in the internal WriteReasoningFields. OpenRouterLlmProvider, QwenLlmProvider and ZaiLlmProvider keep their ApplyProviderSpecificOptions override for the public surface; it now only runs the base method.

Migration:

  • An effort a listed model refuses is now sent lowered (medium reaches GLM-5.3 as low) where it used to be omitted: read the warning, and ask for a level the model takes to send exactly that.
  • Thinking asked on a model that does not reason (gpt-4o, gemini-2.0…) and "off" asked on a model that always reasons are now dropped with a warning: remove the option, or pick a model that honours it.
  • A built-in entry that does not fit your endpoint (a model a vendor changed, a gateway serving it differently) is replaced field by field with Llm:ModelCapabilities:<model>:Thinking and :ReasoningEfforts, or for one provider alone with Llm:ModelCapabilities:<provider>/<model>:... (openrouter/google/gemini-3.7); a model the table does not know is added the same way, which also silences its "nothing was checked" warning.
  • A host that implements IModelCapabilityRegistry itself gets TryGet(model, provider) as a default method reading TryGet(model); implement it to serve provider-scoped entries.

Fixed

  • relational_database_query (and mysql_query, mariadb_query, postgres_query, sqlserver_query) refuses a SELECT whose max_rows is below 1 or above 100000, and any query whose timeout_seconds is below 1 (#372), in a message that names the field and its default. A small model that filled every field sent max_rows: 0, got no row and a success, and the crew reported made-up figures; a timeout_seconds: 0 waited without bound. An Execute or a Scalar query, which never reads max_rows, still takes any value. A SELECT response carries truncated, true when the result set held rows max_rows left out (absent on Execute and Scalar). csv_reader refuses a max_rows below 1 the same way, its truncated is no longer true when the file holds exactly max_rows rows, and a cancelled read is a cancellation instead of a partial success.

  • The other tools that read a result limit refuse a value that would return nothing as a success (#372), in a message that names the field and its default: janusgraph_query and arcadedb_query max_results, rag_search top_k, rag_eval k, structural_search max_results and max_files, structural_rewrite max_files, file_read max_length (where a negative value threw), and count_pattern max_matches_returned when include_matches is true (a negative value was silently read as 0), package_summary max_exports, dependency_graph max_cycle_members and max_nodes (max_cycles keeps 0 as its count-only mode, now stated in its schema, and refuses a negative value), flow_trace max_depth, impact_analysis max_depth and max_nodes, sub_graph depth and max_nodes, flow_trace max_paths, codebase_search and statement_query top_k, complexity_report top_n, symbol_detail max_children (also refused above 200), symbol_source max_lines and codebase_map max_entries (where 0 was silently read as 1). On a Find, mongodb_query refuses a limit below 1 (MongoDB reads 0 as "no limit": the whole collection came back) and a negative skip. A limit of int.MaxValue on codebase_search, statement_query, flow_trace, codebase_map or dependency_graph no longer overflows the one-past probe that sets truncated, which asked the store for nothing.

  • A consumer of Orkeon.Tools.Embeddings.Local or Orkeon.Scripting gets the BGE-micro-v2 model (#368). The SmartComponents.LocalEmbeddings package (~40 KB) carries no weights: its build/ target downloads model.onnx and vocab.txt from huggingface.co on the consumer's first build and copies them to LocalEmbeddingsModel/default/. Orkeon.Tools.Embeddings.Local referenced SmartComponents, and Orkeon.Scripting referenced Orkeon.Tools.Embeddings.Local, with NuGet's default private assets, so each nuspec excluded Build on that dependency, the target never ran in a consumer, and AddOrkeonLocalEmbeddings() (which RunnerHost calls by default) threw at startup. Both references now carry PrivateAssets="none", and scripts/check-package-closure.py refuses a lineup project, or a packed nuspec, that hides build on any dependency whose closure reaches that package. The first build of such a consumer needs the network: offline, it fails in the upstream DownloadFile task.

  • A provider constructed by hand sends an agent's tools (#367): the constructors without an IToolCallingStrategy — new OllamaLlmProvider(llm, httpClientFactory) as bootstrap.md shows, new OpenAILlmProvider(...) and every OpenAI-compatible provider, new AnthropicLlmProvider(...) — left the strategy null and sent no tools, so the model wrote the call as text and the task completed without it. They now take the vendor's native strategy, as LlmProviderFactory does; the overload that takes a strategy still accepts null to keep the text protocol.

  • crew.run()'s output is the last agent output that was not null (#369) [breaking]: an object stays an object, the same value as that run's tasks[i].output, where it was the object's CLR type name ("System.Dynamic.ExpandoObject"); false, 0 and "" count, and "" still means every output was null. CrewResult.output is unknown in crew.d.ts and JsCrewResult.output an object? in C#: this edits a member of the 1.0.0 frozen surface (*REMOVED* in PublicAPI.Unshipped.txt), a deliberate exception to the stability policy — a string output reads the same, and the type name an object gave was of no use. Migration: a script that read res.output as a string narrows it (typeof res.output === "string"); a C# caller of JsCrew.RunAsync casts output. The REPL's script-host.runCrew summary shows an object output as its JSON.

  • Eight scripting examples print their run (#370): 01–07 and 14 ended with a bare await crew.run(), so orkeon run printed {"result": null}; 01–07 now end with globalThis.result = await crew.run(). 14-decision-and-when hands its crew off (globalThis.crew = crew) instead: run procedurally, its decision and when tasks never ran and its body-less agent returned nothing; the declarative engine runs them, and the examples CI validates it by name. The first snippet of write-a-crew-in-typescript.md does the same, and the result row of scripting-dsl.md no longer says a CrewResult cannot be serialised.

  • A script catches the refusals of the llm namespace (#364): llm.profile(name) on a profile the host does not offer, llm.model(name) and LlmConfig.with(...) on a value they refuse, and ctx.llm.reasoning, ctx.llm.capabilities and ctx.llm.stream on a llm: { profile } the host lacks threw a CLR exception that crossed every try … catch and ended the command. They now throw an Error through JsHostError.Guard (SCR-25), with the same message and the CLR exception on clr. The awaited ctx.llm.complete, chat, extract and decide rejected on the same refusal with the wrapped CLR AggregateException, no message: a script's mistake (InvalidScriptException) now rejects as an Error too. Uncaught, a bridged error reaches the host as its CLR exception: orkeon run reports InvalidScriptException as the root cause after the JavaScriptException wrapper, where it stopped at the wrapper.

  • A script catches the refusals of the builders and factories too (#364): every method of agentBuilder(), taskBuilder(), crewBuilder() and toolBuilder(), stateGraph(...), stateMachine(...), ErrorAction.* and the test namespace (a failed test.assertLlmCalled, a refused mock) threw its CLR exception the same raw way, so agentBuilder().effort(level) on a level read from data could not fall back inside a try. Each goes through JsHostError.Guard now: an Error with the same message, its clrType naming the exception (InvalidScriptException, ArgumentException, OverflowException, DuplicateAgentNameException, AssertionException, RegexParseException). The synchronous members of a built crew (has, findByName, findById, findByRole, instances, stop), tool.execute, ctx.events.queue and topic, and an LlmConfig's capabilities and reasoning follow the same rule; ctx.memory.*.store and delete reject rather than throw; ctx.llm.interrupt() called after the agent's attempt ended does nothing, where it threw ObjectDisposedException. The engine's own limits (time, memory, recursion, statement count) still stop the script: Guard lets them through. A C# caller of new JsAgentBuilder() still gets the raw exception.

  • [breaking] A C# host that evaluates a script and catches the refusal's CLR type (InvalidScriptException, DuplicateAgentNameException, AssertionException…) around Engine.Evaluate now gets a Jint.Runtime.JavaScriptException: the CLR exception is on the clr property of its Error (ex.Error.Get("clr").ToObject()). orkeon run and the error policy's codes unwrap it already (#364).

  • Z.AI's reasoning_effort takes xhigh (#356): the campaign of 2026-11-14 found GLM-5.2 accepting it and reasoning at it, between high and max, where Orkeon lowered it to high. The provider now declares the five levels; the GLM-5.3 family keeps its table restriction (low, high, max). The campaign re-run of M15–M18 on 14 providers finds the capability table in agreement with every vendor's own answer.

  • grep takes a file as path and searches it alone, as rg <file> does; a glob given beside a file is refused with a message naming the fix, and a missing path says Path not found instead of Directory not found; an empty glob beside a file counts as absent (#351).

  • Z.AI's GLM-5.3 family takes the efforts low, high and max only: a medium asked for is lowered to low with the provider's warning instead of failing every call with HTTP 400 code 1210; the per-model capability table says it (#354, #356).

  • A provider failure (an HTTP error, a timeout) no longer reaches a script as an empty answer: ctx.llm.extract and ctx.llm.decide raise it with its status and the vendor's message, and ctx.llm.chat answers with the <undefined-llm:…> marker complete and act already gave (#354).

  • ctx.llm.extract says why a reply is not JSON: an empty reply is named as such, with the output budget the model ran with (MaxTokens, else its resolved limit) when it ended on length or max_tokens; an unparsable one gives the line and byte of the JSON error and the reply's beginning and end; both carry the finish reason and the prompt, completion and reasoning tokens. Every provider now records the vendor's stop reason, raw, under finish_reason (LlmResponseMetadataKeys.FinishReason) on buffered and streamed answers alike: finish_reason of the OpenAI dialect, stop_reason of Anthropic, done_reason of Ollama; Azure's text-only stream aside (#353).

  • In orkeon-repl, a human_input question a background task asks no longer hides in that task's screen: it is tagged [t8] <task> asks: … and shows on the displayed screen too, the prompt reads answer [t8]> (the TUI follows the question through TuiIntegration.AnswerPrompt and QuestionChanged), the answer is taken from the main field or from the task's thread (TuiIntegration.SendToTask is now wired), and [t8] answer taken: … closes it; several questions are asked one at a time, the next announced, a withdrawn one says so, and a waiting tool approval keeps the main field first (#352).

1.0.0 - 2026-11-12

The first final release. Since 1.0.0-rc.7: the container image and its switch take their final names, the dependency graphs are locked, and the account statuses of the e-mail and drive tools gain their problems as a list. From this version on, every public member listed in the PublicAPI.Shipped.txt files of the published packages is the 1.x stability commitment: a removal or a signature change waits for 2.0. The APIs marked [Experimental] (ORKEXP001–007) stay outside it, and a member whose signature carries a type of Jint, TreeSitter.DotNet or Terminal.Gui follows that library's major version. The rules are on the stability page. Before that surface froze, the last cut made it consistent: every public async interface method takes a CancellationToken, a few names were fixed, the tool base classes expose their services as properties, and the plumbing types — third-party wrappers among them — became internal. No alias is kept: the product was never deployed.

Changed — the container image is ghcr.io/orkeon/orkeon [breaking]

The image published by the Release workflow drops its -runners suffix, and the variable that picks the executable the container starts is renamed after what it does. There is no alias: the old variable is no longer read, so a container given only ORKEON_RUNNER=repl or =shell starts the default orkeon CLI instead. The Release job that builds it is now docker-image. Dockerfile.runners keeps its name, since the root Dockerfile builds the REPL image.

Before After
ghcr.io/orkeon/orkeon-runners:<version> / :latest ghcr.io/orkeon/orkeon:<version> / :latest
-e ORKEON_RUNNER=orkeon\|repl\|shell -e ORKEON_ENTRYPOINT=orkeon\|repl\|shell
local tags orkeon-runners:granite / :gemma4 orkeon:granite / :gemma4

Changed — every public async interface method takes a CancellationToken [breaking]

Each one ends with CancellationToken cancellationToken = default, so a caller compiles unchanged; an implementer adds the parameter. Concerned: IToolRegistry (ReplaceToolAsync included), IMemorySystem, IContextWindowManager, IDynamicAgentService, IManagerAgent.AssignTaskAsync, ICsvSerializer, IEmbeddingService, IMemoryScope, IAgentCommunicationService, IShortTermMemory, ILongTermMemory, IEntityMemory and IContextualMemory. RunnerExecution.RunListToolsAsync takes externalCt, like the other Run*Async entry points.

Changed — renames, removals and internal plumbing [breaking]

Before After
ICrewOrchestrationService.KickoffAsyncNoWait(...) KickoffNoWaitAsync(..., cancellationToken)
OpenAIProvider OpenAILlmProvider
SerialisingToolApprovalChannel SerializingToolApprovalChannel
LlmDefaults.LegacyModelName removed
const LlmProviderDefaultModels.*, LlmDefaults.DefaultModelName, DockerModelRunnerDefaults.DefaultModel static readonly (a default model changes without recompiling the callers; no longer usable in an attribute or a switch case)
LlmConfig.ApiKeySecretName, LlmConfig.WithDefaultModelSecret(...), LlmConfig.ClaudeWithSecret(...) removed: assign ApiKey (read the secret through ISecretProvider first)
the binary-serialization constructors (SerializationInfo, StreamingContext) and GetObjectData of the exceptions removed
Orkeon.Infrastructure.Stubs.*: InMemoryKnowledgeStore, InMemoryMemorySystem, NullLlmCache, NullAgentExecutionService, SimpleAgentSelectionService, HashBasedEmbeddingProvider and their kin internal: the defaults stay registered by AddOrkeon*, resolve them through their interfaces
TokenUsage (Orkeon.Application.Interfaces.Services), the positional record of CrewOutput.TokensUsed removed: CrewOutput.TokensUsed is the one TokenUsage of Orkeon.Application.Common.DTOs, which gains CacheHitTokens, CacheMissTokens and CacheHitRatio; build it with an initializer (new TokenUsage { PromptTokens = …, CompletionTokens = …, TotalTokens = … })
TokenUsage (Orkeon.Application.Interfaces.Security), the running total of ITokenBudgetTracker TokenBudgetUsage (Orkeon.Application.Common.DTOs), required init properties, TokenBudgetUsage.None
TokenUsageReport TokenBudgetReport
IEmbeddingService (Orkeon.Application.Interfaces.Ports), the twin of the Domain port, and DomainEmbeddingServiceAdapter removed: implement and resolve Orkeon.Domain.Memory.IEmbeddingService
ToolCallProtocol and ToolCallRequest (Orkeon.Domain.Tools), used by nothing removed: a tool call is Orkeon.Domain.Tools.Protocol.ToolCallRequest
TokenUsage (Orkeon.Application.Common.DTOs), a settable class sealed record with init properties
AddMemoryResult, CreateMemoryStoreResult, SearchMemoryResult AddMemoryResponse, CreateMemoryStoreResponse, SearchMemoryResponse
the DTO, command and query records of Orkeon.Application, and every public record of Orkeon.Application and Orkeon.Domain nothing derives from (CrewInput, CrewOutput, BudgetCheckResult, ValidationResult, GuardResult, ToolCallRequest, AgentSkill, MemoryEntity and their kin) sealed: their Equals(T) is no longer virtual, EqualityContract and the copy constructor are private

Plumbing that was public by accident is internal: the tool-call parsers, formatters and strategies (AnthropicToolCallParser, AnthropicToolSchemaFormatter, AnthropicToolCallingStrategy, OpenAIToolCallParser, OpenAIToolSchemaFormatter, OpenAIToolCallingStrategy, NullToolCallingStrategy, TextFallbackToolCallParser), ContentConverter, the serialization converters (BoolTolerantConverter, DecimalInvariantConverter, DoubleInvariantConverter, IntTolerantConverter, LongTolerantConverter, UriTolerantConverter, ImmutableArrayStringTolerantConverter, RawObjectConverter, TolerantEnumConverter<TEnum>, TolerantEnumConverterFactory, JsonElementConverter, MemoryMetadataConverter), CsvHelperSerializer (reach it through ICsvSerializer), CrewExecutionStateMapper, JsonSchemaToGbnfConverter, HtmlAgilityPackParser, MarkdownParser, AgentMapper, ControlFlowBuilder, DataFlowAnalyzer and their kin.

Changed — the tool base classes expose their services as properties [breaking]

Before After
ToolBase._logger, ToolBase._jsonOptions protected properties Logger, JsonOptions
HttpToolBase._httpClient protected property HttpClient
FileToolBase._fileSystemService protected property FileSystemService
a tool's [LoggerMessage] instance methods static partial methods taking the ILogger first (LogFetched(Logger, city))
the mutable request and response DTOs of Orkeon.Tools.FileSystem, .Web and .Data init properties, IReadOnlyDictionary<,> for the maps

The JSON a tool reads and writes keeps its shape. docs/tools/new-tool-pattern.md shows the new members.

Changed — Tree-sitter, Terminal.Gui, ML tokenizer and Jint plumbing is internal [breaking]

TreeSitterParserPool, ParsedTree, ITreeSitterParser, StatementExtractor, StatementExtractionResult, TreeSitterNodeExtensions, SchemeFactory, CrossEncoderBatchEncoder, JsEngineFactory.Create, EsbuildTranspiler are internal, and so are:

  • the Jint plumbing of Orkeon.Scripting: the *Binding classes (AgentBuilderBinding, CrewBuilderBinding, TaskBuilderBinding, ToolBuilderBinding, ErrorActionBinding, LlmNamespaceBinding, RagNamespaceBinding, ToolsNamespaceBinding, TestNamespaceBinding, StateGraphBinding, StateMachineBinding), the script-side builders and namespaces (JsCrewBuilder, JsTaskBuilder, JsToolBuilder, JsLlmNamespace, JsErrorActionFactory, JsTestNamespace) and the test mocks (JsMockLlmHandle, JsMockLlmExpectationBuilder, JsMockToolHandle, JsMockToolExpectationBuilder). A script reaches them through the .ork.ts API its typings declare;
  • the Jint plumbing of the scripted REPL commands (Orkeon.Cli.Commands.Scripting): ArgsSchemaParser, ConsoleShim, ConsoleShimBinding, ContextBinding, DefineCommandBinding, DefineAsyncCommandBinding, AgentCommandRegistrar, CommandRuntimeContext, CompletionDrainQueue, JsLogShim, PendingCompletion, PromptDispatcher, ScriptCommandBinding;
  • the Terminal.Gui shims of the REPL: AcceptHandlers, MouseClipboardBehavior, KeyCapturedEventArgs, with ReplPaneView.Input and ReplPaneView.KeyCaptured;
  • the constructors of the Tree-sitter tools of Orkeon.Tools.Analysis (EditBatchTool, NodeEnsureTool, NodeInsertTool, NodeOutlineTool, NodeReadTool, NodeReplaceTool, StructuralRewriteTool, StructuralSearchTool), which took a TreeSitterParserPool.

No third-party type leaks through them. Register the analysis tools with AddRaggableTreeTools(), and transpile through IScriptTranspiler. What still carries a type of Jint, TreeSitter.DotNet or Terminal.Gui follows the third-party clause of the stability page.

Added

  • The e-mail and drive account statuses keep their problems as a list and show the effective connection values (#339). EmailAccountStatus and DriveAccountStatus gain ConfigurationProblems (the registry's problems in order, the section's first; empty when the account resolves) and CredentialProblem (the diagnosis of a resolved account), which Problem used to merge into one joined string a sentence holding ; could not be split back from. EmailAccountStatus also carries what a blank field resolves to — IncomingHost/Port/Security, OutgoingHost/Port/Security, Username, SaveSentCopy, TokenEndpoint —, DriveAccountStatus its TokenEndpoint. orkeon email accounts --json and orkeon drive accounts --json write them in snake case, and the text listing of orkeon email accounts shows the connection on one line. A client such as Orkeon Studio checks a configuration through ListAsync instead of the internal binder. Additive: Problem keeps its text.
  • A stability page — docs/reference/stability.md (and its French mirror) states what a patch, a minor and a major version may change, which surface is frozen, what stays outside the commitment and how a member is deprecated. experimental-apis.md, CONTRIBUTING.md and the READMEs link to it.

Changed

  • NuGet lock files — every project of Orkeon.sln outside examples/ restores with a committed packages.lock.json, and CI restores in locked mode (CI=true), so a package is built from the dependency graph that was reviewed. The net11 lane restores unlocked. A restore with a runtime identifier (the per-RID installer publishes, the dotnet publish -r steps inside Dockerfile.runners) resolves another graph: it writes its own lock file under the project's intermediate folder and is not locked, so it never rewrites the committed one. The examples, which ship nothing, and the dotnet new templates carry no lock file. A package change regenerates the lock files with dotnet restore (CONTRIBUTING.md).
  • The install commands drop --prerelease — the READMEs, the docs and the package READMEs install the final release; the dev channel keeps it. SECURITY.md supports the latest 1.x minor; the apt stable channel carries the final releases; opt-in-subsystems.md marks experimental APIs instead of a "Beta" status.
  • The orkeon-plugin template asks for [1.0.0,2.0.0) in plugin.json.
  • NuGet.org waits for the release — on a v* tag, publish.yml pushes to NuGet.org only once the release.yml run of the same tag has succeeded, so a package never precedes installers that failed their smokes. docs.yml pins docfx (2.81.0).
  • The dev apt build restores without a shared cache — apt-dev.yml, whose packages are signed and published, no longer reads or writes an actions/cache (CodeQL actions/cache-poisoning).
  • The container image follows the GitHub Release — release.yml pushes ghcr.io/orkeon/orkeon after the Release, smokes the start of its REPL (ORKEON_ENTRYPOINT=repl) before the push, and labels it with the OCI source, description and licenses annotations.
  • Dependabot watches tools/scripting-typecheck and the NuGet packages of examples/.
  • Documentation aligned with the code — the API index, the security policy, the opt-in subsystems (labelled Preview), the package READMEs and ten examples, which described features that do not exist, now say what the code does; the stability page states the third-party clause.

Fixed

  • Orkeon.Compliance.Vfs loads in a stock SDK again — the analyzer compiles against Roslyn 4.8.0 once more; the release candidates built it against 5.9.0, so an SDK with an older compiler skipped it with CS9057 and the VFS rule went unchecked outside the repository. A test reads the Roslyn references of the compiled analyzer and fails above 4.8.0.
  • ORKEON_ENTRYPOINT=repl starts — the REPL of the image exited at once, with no file system mount. Its wrapper now mounts /workspace read-write by default; a --mount on /workspace, or a --settings file declaring Orkeon:FileSystem:Mounts, replaces that mount. The REPL reads its settings only from --settings: the documented commands pass the mounted settings file with it.
  • A refused configuration stops the Windows service instead of crashing it (#336). After a refusal (exit 78), orkeon-host used to leave without telling the SCM it had stopped. The SCM took that for a crash, and the MSI's recovery started the host again after 10 s, twice, on a configuration the operator had to fix first. The host now stops through its lifetime, which reports SERVICE_STOPPED with exit code 78 before the process leaves, so crash-only recovery stays out of it. The Windows service smokes also check the System log for an SCM crash record (events 7031 and 7034), which a status poll could miss.
  • Seven CodeQL cs/unsynchronized-static-access alerts — the decision probe and its test double build their dictionaries with ImmutableDictionary.CreateRange instead of ImmutableDictionary<K,V>.Empty.Add; same contents, same comparer.
  • The apt publication retries a push refused by git 2.53 — publish-apt-channel.sh took the newer wording of a moved branch (incorrect old value provided) for a refusal of another kind and gave up instead of applying the channel again on the new tip.

1.0.0-rc.7 - 2026-11-11

A release candidate for 1.0.0. Since 1.0.0-rc.6: Orkeon Studio moves to its own repository and the CLI family ships to NuGet for it; the framework closes its gaps — record and replay of LLM calls, durable human-in-the-loop, a durable run history, one checkpoint per task and orkeon run --resume, a retry per task, an LLM judge, orkeon eval, the YAML graph: block, dotnet new templates, OAuth and Streamable HTTP for MCP, crews served as MCP tools, health probes and a run API on orkeon-host (FWK-01..28); decision tasks and when conditions serve three decision-model providers (ADR-015, ADR-016); the compatibility shims are removed; and the public API in PublicAPI.Shipped.txt is the candidate 1.x stability commitment.

Added

  • act prunes stale tool results on the script's word (#327) — ActOptions.onContextPressure runs before a model turn once the loop's messages pass contextPressure.thresholdTokens (100000 estimated tokens by default). It is handed the loop's older results of read tools that ran (tool, input, result size, age in turns): a write, a command, a refused call and a result seeded from an earlier act are never offered, since running them again is not harmless. It answers keep, head or drop per call, and a verdict settles the call for the rest of the loop; a pruned result leaves a line naming the call (its input cut to 200 characters) and saying it can be run again, the call itself stays, and the tool share of the next turn's context drops. The estimate counts text, tool calls and reasoning, not images nor tool schemas; token_budget reads the session buffer and does not see the loop. A callback that throws, or no callback, prunes nothing.
  • LLM campaign results page — docs/reference/llm-campaign-results.md (and its French mirror) gives the latest real-API result of every campaigned model: score, failed modes, default marker and report, merging the reports of the model's latest campaign day so the vision companion's M9 and the paid D8 join the main run. The campaign kit's lib/recap.sh and lib/recap.ps1 regenerate it after every campaign, together with the same table in llmproviders-test/README.md.
  • orkeon llm probe runs the decision providers — -p typesafe, liquid or kev runs seven decision modes, D1–D7 (noul, choice, score, box on an image, the context-limit refusal, a typed error for an unknown model, cancellation), through SystemOneDecisionModel, and writes the same JSON as the chat modes. The LLM provider campaign kit takes typesafe like any provider: the catalog gives it its modes, its key variable and jev-preview as candidate. An eighth mode, D8, sends the oversized state with long context set and checks that a sentence buried halfway is found; at about 100k input tokens a run it is in no default set and runs only when named.
  • The LLM provider campaign kit checks around its runs — each provider opens with one call (--no-preflight to skip it), and a refused key, an empty balance or an exhausted quota skips the provider there instead of failing every mode of every model; the reports carry <commit>-dirty when src/ holds uncommitted changes; the end of a campaign lists the identifiers each provider serves that lib/served-models.json does not, and those it no longer serves; a report points at the provider's notes in lib/catalog.json instead of copying them. The nightly integration run passes the TYPESAFE_API_KEY repository secret to the TypeSafe integration tests.

Added — one ctx.llm call on another LLM profile

  • { llm: { profile } } runs one ctx.llm call on a host profile (#331) — LlmCallOptions.llm, and so ActOptions.llm, takes profile beside model: ctx.llm.act(brief, { llm: { profile: "small" } }) runs that call (and complete, chat, stream, extract, decide) on the provider of Llm:Profiles:small, while the agent keeps its own for its other calls. The rule is llm.profile(name)'s: a name the host does not offer throws, listing the known profiles; "default" is the host's own provider; a decision profile applies its stages to the call. A model beside the profile is the model within that profile's provider — { profile, model } is llm.profile(profile, { model }). An LlmConfig passed as llm (llm.profile(...).with(...)) is refused, since its temperature and token cap would not apply; an empty profile name is refused; stream checks the profile when it is called, not at its first chunk; embed, a local stub, reads no option.

Changed — Together AI's default model [breaking]

  • LlmProviderDefaultModels.Together [breaking] is now zai-org/GLM-5.3-Flash. meta-llama/Llama-3.3-70B-Instruct-Turbo is no longer serverless: every call to it answers Unable to access non-serverless model (LLM campaign of 2026-11-11), so a Together provider built without a model failed on its first call. GLM-5.3-Flash was Together's own replacement target since the 2026-09-19 review: 1 M context, tools and JSON, reads images, 0.15 / 0.50 $/M, 11/0/1 on the last run of that campaign day (10/1/1 on the first, M10 red). The value changes in PublicAPI.Shipped.txt.

    Before After
    no model, or meta-llama/Llama-3.3-70B-Instruct-Turbo on Together zai-org/GLM-5.3-Flash, or a dedicated endpoint for the Llama model

Changed — Gemini's, OpenRouter's, Mammouth's and MiniMax's default models [breaking]

  • LlmProviderDefaultModels.Gemini [breaking] is now gemini-3.8-flash (was gemini-3.7-flash, which the vendor labels "previous generation"), and OpenRouter and Mammouth follow it (google/gemini-3.8-flash, gemini-3.8-flash): on the full LLM campaign rerun of 2026-11-11, 3.8 Flash was 12/12 direct and on OpenRouter where 3.7 Flash was 11/0/1 and 11/1 (M10); Mammouth is 9/1/2 on both (M10). Same price until 2026-12-31, same 65 536 output cap. The values change in PublicAPI.Shipped.txt.

  • LlmProviderDefaultModels.MiniMax [breaking] is now MiniMax-M3 (was MiniMax-M2, listed as legacy): 10/0/2 that day, reading the image, where MiniMax-M2 was 6/4/2 (M2, M5, M9, M10). The vendor publishes no output cap for M3: it keeps the 4096 fallback it was campaigned on. The campaign kit retires its MiniMax vision companion, the default now sees.

    Before After
    no model on Gemini, OpenRouter or Mammouth, running Gemini 3.7 Flash Gemini 3.8 Flash; pin Model: gemini-3.7-flash (google/gemini-3.7-flash on OpenRouter) to keep the former model
    no model on MiniMax, running MiniMax-M2 MiniMax-M3; pin Model: MiniMax-M2 to keep the former model

Changed — Kimi's and Z.AI's default models [breaking]

  • LlmProviderDefaultModels.Kimi [breaking] is now kimi-k3.1-pro (was kimi-k2.6): 12/12 on the LLM campaign of 2026-11-11, where kimi-k2.6 stayed 10/1/1 (M8 json_object fenced in markdown, M10 no cache breakdown). The K3 family fixes temperature (only 1 is allowed) and top_p and refuses a thinking field: KimiLlmProvider now leaves those three fields out of a K3 request, on the buffered and the streaming paths alike, and reports each as a structured warning (event 110) instead of letting the API answer 400. The output-cap catalogue pins kimi-k3.1-pro at 131 072 like kimi-k3. The value changes in PublicAPI.Shipped.txt.

  • LlmProviderDefaultModels.Zai [breaking] is now glm-5.3-flashx (was glm-5.2): 12/12 on 2026-10-07 and on the first run of 2026-11-11, 11/1 on the last run of that day (M10 red) (it reads images, its cache is read), where glm-5.2 stayed 10/2 (M9 code 1210, text only; M10 0 cached). The GLM-5.3 family cannot switch thinking off: ZaiLlmProvider no longer sends thinking: disabled to it and reports the option instead; an enabled toggle and the effort hint are sent as before. The value changes in PublicAPI.Shipped.txt.

    Before After
    no model on Kimi, running kimi-k2.6 kimi-k3.1-pro; pin Model: kimi-k2.6 to keep the former model
    Temperature, TopP or Thinking.Enabled set for a K3 model not sent, one warning each; pick a kimi-k2 model to steer them
    no model on Z.AI, running glm-5.2 glm-5.3-flashx; pin Model: glm-5.2 to keep the former model
    Thinking.Enabled = false on a GLM-5.3 model not sent, one warning; pick glm-5.2 to turn reasoning off

Fixed

  • The firefox tool starts its browser again when the first session.new goes unanswered (#335) — a nightly run saw Firefox 159 announce its WebDriver BiDi endpoint, take the WebSocket, and leave session.new without an answer for CommandTimeoutSeconds; the order of our start was checked (the receive loop runs before the first send, the answer is registered before it, the path is /session) and holds. A browser silent on that first command is now killed, its disposable profile removed, and one new browser started, with a logged warning; a second silence fails with a timeout error that says Firefox was started again. Any other start failure, and a later command timing out, are not retried.
  • An async scripted command is work in flight until its completed() callbacks are wired — an instance that settled before WireCompletions attached its drain let the registry report no work left, and a completed() failure arrived after the drain had ended. The dispatch now holds a work handle until its completions are wired.
  • Two MCP GET-loop tests move their manual clock by the pending backoff alone — a five-minute move could also fire the next backoff, armed meanwhile, and run the stream past the GET count the test waited for.
  • A 429 for an exhausted balance fails at once (#328) — Z.AI (Insufficient balance), Kimi (exceeded_current_quota_error) and OpenAI (insufficient_quota) answer 429 when the account has no money left, and the retry policy waited each one out like a rate limit: a call that could never succeed spent the whole Llm:MaxRetries budget (21 minutes for one Z.AI campaign). The policy and the streaming connect now read a 429's body and do not retry one that names a spent balance; the error line adds (account balance exhausted: ...) (Anthropic's lines included), the decision model reports it as not transient, and a profile's fallback chain still moves to the next provider. A body that cannot be read leaves the 429 a rate limit; a balance refused as 400/402 and the code-graph embedding provider are out of scope (docs/architecture/llm-providers.md).
  • orkeon llm models -p gemini lists usable identifiers — Google's OpenAI-compatible /models names every model models/<id>, a form no configuration writes; the listing now drops the prefix. The LLM campaign kit compared those names with the bare ids of lib/served-models.json and reported every Gemini model both new and no longer served.
  • The campaign catalogue's misfiled candidates run again — gpt-6.1-terra, claude-fable-5-2, gemini-4-argon, gemini-4-carbon and MiniMax-M3.1-Flash sat in their provider's notes instead of candidateModels, so --candidates skipped them; they are candidates again, as the README already listed them.
  • reasoning_effort: none reaches OpenAI again — since the effort levels gained xhigh and max (#242), a value outside low…max was "lowered" to low, and the gpt-5 row of the model capability table caught gpt-5.6-* and omitted none there: every GPT-5.6 and GPT-6 tier that needs none to take function tools on chat/completions answered tools and the messages-array shape with a 400 (LLM campaign of 2026-11-11). LlmThinkingConfig.EffortFor now returns a value outside the levels unchanged, for the vendor to judge, and gpt-5.6 has its own unrestricted row.

Fixed — the dotnet tools carry the natives of every desktop runtime

  • orkeon and orkeon-repl run on Windows and macOS again (#324) — the build trim that drops the native assets of other runtimes also ran while dotnet pack packed a tool, so the 1.0.0-rc.6 Orkeon.Scripting.Cli package, packed on Linux, held the linux-x64 and unix natives alone and did not start on Windows or macOS. The trim now skips a tool project while it is packed (its plain builds stay trimmed), and the iOS and Android natives are stripped from every tool package: both tools weigh about 187 MB.

Changed — three runtime messages name no roadmap version

  • The refusal of an agent's .concurrency(n) other than 1 now reads .concurrency(1) is the only value accepted: an agent's concurrency is a mutex., RecursiveAgentInvocationException Recursive invocation of agent '<name>' is not supported., and a second waiter on an agent's inbox Only one waiter per inbox is supported.; none names a version any more.

Fixed — a scripted spawn emits agent.spawned

A script's spawn_agent (the model calling it during ctx.llm.act) and ctx.spawnBackground were built with new, outside DI, so the hosting decorator never wrapped them and an observed run (orkeon run --events) showed no agent.spawned for a child a script started. The spawn now reports it itself, once the spawn is accepted (an unknown agent or a spent budget emits nothing): role is the child's role and name its crew agent name; the input is never in the event. The run's publisher reaches the script host through the new ScriptingHostPorts.RunEvents, experimental like the IRunEventSink it holds (ORKEXP007); null keeps a script unobserved. A scripted spawn is no tool call on the stream: no tool.called precedes it, no tool.returned follows.

Fixed — Aspire is pinned to 13.6.5 (GHSA-f7vh-h5g3-7jrh)

An advisory published on 2026-11-10 (high, CVE-2026-120006: elevation of privilege) flags Aspire.Hosting and Aspire.Hosting.AppHost below 13.6.5, so the restore audit (NU1903) failed every -warnaserror build that touches the Aspire integration: Orkeon.Hosting.Aspire, its NuGet package, its tests and the AppHost example. Directory.Packages.props takes both packages at 13.6.5 and the AppHost example the Aspire.AppHost.Sdk of the same version. No API change; the shipped applications do not redistribute Aspire, so the third-party notices are unchanged.

Fixed — the host's cost budget is enforced [breaking]

  • Orkeon:CostTracking:DefaultCrewBudget [breaking]: MaxTokens and MaxCostUsd were recorded and never applied — no path read IsWithinBudget. Every LLM call now passes through ICostBudgetManager.CheckBudget at the provider entrance (MeteredLlmProvider, wired for YAML crews, .ork.ts scripts, the planner, the manager and the service host): once what a crew recorded reaches a cap, its next call is refused before anything is sent, with BudgetExhaustedException (dimension Tokens, or the new BudgetDimension.Cost; BudgetExhaustedError.dimension is "cost" in a script). The call that crosses a cap completes; a refused call ends its task BudgetExhausted (ChatClientAgentLoop no longer folds it into LlmCallFailed), and no retry asks again. The budget is summed per crew id — per run for a YAML or C# crew, which takes a new id at each load; a script's own ctx.llm calls are summed under the crew's name. A call outside a crew run is under no budget, and Orkeon:CostTracking:Enabled = false records without refusing. An event recorded twice (the meter and a host's usage sink) is counted once, and nested meters each record what the inner one left out (its sink, or the budget). The TokenBudgetExceeded and CostBudgetExceeded alerts are now raised when the total reaches the cap, as the refusal is, not only past it.

  • BudgetLimit.MaxCallsPerMinute and BudgetAlertType.RateLimitExceeded are removed [breaking]: the key was read by nothing that limited a call; RateLimiting is the call limiter.

  • Who carries the budget manager: MeteredLlmProvider.Wrap, ManagerLlmResolver and SequentialCrewOrchestrator take it as an optional last argument, and LlmProviderFactoryOptions.Budget carries it to the factory; the host's registrations pass the one AddOrkeonCostTracking registers.

    Before After
    DefaultCrewBudget: { MaxCallsPerMinute: 30 } RateLimiting: { GlobalRequestsPerMinute: 30 }
    a custom ICostBudgetManager implements CheckBudget(crewId, agentId)

Documentation — what the qualification review found

  • decision-models.md: a decision task takes no agent, but its crew still declares one (the YAML loader refuses a crew with none). llm-providers-comparison.md and yaml-schema.md: an explicit thinking budget is honoured by Qwen and OpenRouter. verify-what-you-install.md: seventeen attestation subjects (fourteen nuget.org packages, two GitHub-only, the SBOM). limitations.md: the permission gate is off by default, a crew's budget: caps the autonomous mode only, and Security:Audit:RetentionDays is read by no purger.

Removed — Orkeon Studio moved to its own repository (Orkeon/orkeon-studio) [breaking]

  • Orkeon Studio [breaking]: the desktop and terminal front-end lives in Orkeon/orkeon-studio and is no longer built, tested, packaged or documented here. Removed from this repository: the Orkeon.Studio.Core, Orkeon.Studio.Config, Orkeon.Studio.Run and Orkeon.Studio.Wpf projects and their test projects, all out of Orkeon.sln; the orkeon-studio, orkeon-studio-config and orkeon-studio-run executables from the MSI, ZIP, tarball and .deb installers (the "Orkeon Studio" Start-menu shortcut included); the Studio smoke steps of the release pipeline; the Studio documentation page (docs/architecture/studio.md, EN and FR); and the third-party notices only Studio needed. Studio drives the orkeon CLI and its event protocol from its own repository; what it needs from them is generic (see the next section).

    Before After
    The Windows zip, the MSI, the Linux archives and the .deb install Orkeon Studio next to the CLI They install the CLI (and the REPL, the service host where packaged) only; install Orkeon Studio from Orkeon/orkeon-studio

Changed — no Studio name left in what Orkeon writes or defaults to [breaking]

  • Launchers, TeamLauncherSpec [breaking]: WrittenByStudio is removed, replaced by string? WriterNote. When it is set, TeamLauncherScript writes it as one comment line right after the header of both run.cmd (rem) and run.sh (#); a line break or any control character becomes a space, and in run.cmd a character beyond ASCII becomes ? and a trailing caret is dropped, so the note never leaves its comment. Null or blank, no line.

  • orkeon run --client [breaking]: the default observing peer is client (client://client), no longer studio. A client that relied on the default passes --client <name>; a crew whose links: block named client:studio for the default peer names client:client.

  • Team sidecar [breaking]: ConventionalNames.TeamSidecarFile is team.json, no longer studio-team.json. orkeon usecases export writes it, orkeon forge rename renames the team in it and orkeon forge promote keeps it under that name only: a studio-team.json is not read. Rename it in an existing team folder.

    Before After
    new TeamLauncherSpec { …, WrittenByStudio = true } new TeamLauncherSpec { …, WriterNote = "<the writer's note>" }
    orkeon run crew.yaml --events jsonl answers at client://studio it answers at client://client; pass --client studio to keep the old address
    <team>/studio-team.json <team>/team.json

Added — the CLI family ships to NuGet, for a standalone Orkeon Studio

  • Packages [breaking]: three ids join the NuGet.org lineup, so an application outside this repository (Orkeon Studio) builds against packages rather than project references. Orkeon.Constants.Cli (runner option names, exit codes, session-state keys) and Orkeon.Cli.Abstractions (the interactive-runner contracts) are packed straight from their projects; Orkeon.Cli.TerminalGui is packed by the new src/packaging/Orkeon.Cli.TerminalGui wrapper and depends on Orkeon, which carries the Orkeon.Constants.Configuration it reads, and on Orkeon.Cli.Abstractions. Orkeon.Scripting no longer embeds Orkeon.Constants.Cli: it takes a nuspec dependency on it, so no assembly ships in two packages. Orkeon.Hosting stays inside Orkeon.Scripting, and the SuppressVfsCompliance / SuppressConsoleCompliance attributes inside Orkeon (Orkeon.Domain); Orkeon.Compliance.Vfs remains the analyzer alone. scripts/check-package-closure.py counts a lineup package packed from its own project as carrying its assembly and project closure.

    Before After
    Orkeon.Scripting carries Orkeon.Constants.Cli.dll in lib/ Orkeon.Scripting depends on the Orkeon.Constants.Cli package, restored with it

Fixed — orkeon run --validate judges a .ork.ts the way orkeon run does (#315, #316)

  • --validate, procedural scripts (#316): a .ork.ts whose source never assigns globalThis.crew (a crew published through an imported helper, or run with crew.run()) runs on the scripting host, and --validate no longer loads it through the declarative loader, whose checks (a task required, no contextTokens on an autonomous budget) are not the ones such a script answers to. It checks the version directive, the types and the esbuild bundle, never evaluates the script — the old load ran a crew.run() at its top level — and prints VALIDATION OK: <config> (procedural script: bundled, not run). RunnerOptionsBase.ProceduralScript carries the routing.
  • Type check, referenced typings (#315): a module that keeps /// <reference path="…/.orkeon/orkeon.d.ts" /> for its editor no longer fails with TS6200 on every identifier. A copy identical to the build's roll-up stands in for it; a copy that differs fails with one TS6200 line on the copy that says to run orkeon typings.

Removed — the { context } verdict of onToolCall (#307) [breaking]

  • Scripts, onToolCall (#307) [breaking]: { context: string } is no longer an onToolCall verdict. ctx.llm.act accepted it and ignored the string, running the call as "allow" would; it is now an unknown shape and denies the call (DENIED: onToolCall returned no valid verdict), the gate not consulted. The typings no longer list it.

    Before After
    onToolCall: () => ({ context: "note" }) runs the call, the note dropped return "allow"; to change what the model reads of the result, return { context } from onToolResult

Fixed — paths of the shell on Windows and WSL, and the gate after onToolCall (#300–#303, #305)

  • Shell, quoted paths (#300): in the output, a physical path that follows an opening " or ' is rewritten to its closing quote on the same line, spaces included ("C:\ici est\un dossier\f.txt" → "/workspace/un dossier/f.txt"); a ; still separates two entries. Unquoted, the token still ends at whitespace.

  • Shell, Windows bases (#301): a Windows base (C:\proj, \\server\share) matches without case and with / for any \, so c:\Proj\src\a.ts and git's C:/proj/src/a.ts come back as /workspace/src/a.ts. A POSIX base still matches ordinally.

  • Shell under WSL (#302): new Orkeon:Tools:Shell:WindowsPaths:<virtual path>, the Windows spelling of a mount's base (what wslpath -w prints), and ShellCommandTool.WindowsPaths. Under WSL, unconfined, a Windows program on the PATH (a .exe under /mnt/<d>/) receives its mount-prefixed arguments in that spelling, after the same rights check; a mount the key does not name, on a Windows drive, gets that drive's spelling (/mnt/c/proj → C:\proj). What a program prints in that spelling comes back virtual. Outside WSL nothing changes.

  • Scripts, onToolCall before the gate (#303) [breaking]: without the host's invocation pipeline, ctx.llm.act runs onToolCall first and consults the permission gate once, on the input the callback returns, so a script that canonicalises a path (C:\proj\a.ts → /workspace/a.ts) has the canonical path judged. A { deny } from the callback no longer reaches the gate; "ask" is put to the operator once the mode admitted the call.

    Before After
    gate on the raw input, then onToolCall, then the gate again on a rewritten { input } onToolCall, then the gate once on the input it returns
    a gate denial skips onToolCall onToolCall runs, then the gate denies
  • Typings, onToolCall and onToolResult (#305): orkeon typings describes that order (onToolCall, then the gate once on the input it returns; a { deny } never consults the gate), and says that through the host's invocation pipeline a call the guardian or the gate refused, an operator's refusal included, reaches onToolResult as a DENIED: … result. Run orkeon typings again to pick it up.

Fixed — adversarial review of the FWK lots [breaking]

  • Human input and checkpoints [breaking]: a stored answer is reused only for the question it answered: same kind, and for a tool approval the same tool and arguments' hash; any other call is asked again (it used to take the stored allow). A session holds every pending question (SessionState.PendingInputs; PendingInput is now the computed one shown), an answer closes only its own, and the run stops on a persisted question (SessionState.SuspendedOn); an answer that names no question goes to that one, and with several open and none of them the one the run stopped on it is refused (PendingInputAnswerOutcome.RequestIdRequired, 409 request_id_required on the API). The resume fingerprint reads a task's description and expected output with the kickoff variables in them: a changed --var reruns the task. A task failure no longer marks the session Failed (ICheckpointManager.FailSessionAsync does, for the crew), and --resume checks the liveness of a Failed session as of a waiting one. The agents of a Consensual task each get their own checkpoint. A stored structured output is resolved from an exact allowlist of JSON types, and one that cannot be built reruns its task. The Json store writes its version files and manifest atomically, rebuilds an unreadable manifest from the version files, and keeps at most Orkeon:Checkpointing:MaxVersions versions per session (20; zero or negative keeps all), deleting the oldest; JsonFileStateStore's constructor takes maxVersions.

  • Host API and A2A [breaking]: /healthz answers 200 ("status": "stopping") while the host drains; only /readyz answers 503. A second, different answer to a question already handed to a held run answers 409 no_pending_input (it was 202 recorded, then overwritten); the same answer again answers 200 already_answered. POST /runs/{id}/input answers 409 input_unavailable on a host without checkpoints. RequireMutualTls without an ApiKey or Bearer scheme keeps the 415/421 checks (HostApiOptions.IsUnauthenticated is replaced by NeedsBrowserGuard). The A2A listener without ApiKey or Bearer refuses a POST without Content-Type: application/json (415) and a Host that does not name it (421), through the new BrowserRequestGuard. The run timeout no longer restarts during a hold when a new question arrives while the last one is released.

  • MCP client [breaking]: a server Url that receives credentials (an Auth type, or an env: header) must be https, or http on loopback. Headers refuses Accept, Content-Type, Mcp-Session-Id, MCP-Protocol-Version, Mcp-Method, Mcp-Name and Last-Event-ID, and a static header never overwrites one the transport set. prompts/list, prompts/get, resources/list, resources/read and the subscriptions are bounded by CallTimeout, after a device sign-in owed first. A new session is adopted only once initialize and notifications/initialized succeeded. SSE events and JSON bodies are capped at 16 MiB; the transport's own HttpClient follows no redirect and has no client timeout; an empty SSE id: resets Last-Event-ID; a slow tools/list relisting no longer ends the watch of list_changed; a resumed legacy stream relists the tools; stdio answers a server ping; the authenticators are disposed with their transport.

  • orkeon mcp serve --crew [breaking]: at most four calls wait for a crew while it runs; another one is answered at once as busy (isError). When stdin closes, the server stops admitting (IMcpServerExtension.StopAdmitting(), a new member): calls that would wait for their crew are let go with an error result, and a call that finds its crew free still runs. A crew that fails or no longer loads answers a generic message; the detail goes to the server's log.

  • Permissions, guardian and plugins [breaking]: the guardian and gate exemption of delegate_work_to_coworker and ask_question_to_coworker is bound to the tool type ICoworkerDelegationTool (seen through IToolWrapper), and ToolRegistry refuses any other tool under those names (an MCP server or a plugin could claim them); ToolInvocationPipeline.IsDelegationTool(string) is removed and MemoryRecallTool takes a new constructor. An onToolCall that answers "ask" is first checked under plan, dontAsk or a stricter delegated mode; only a call they allow goes to the operator. Through the pipeline, the tool-call budget is charged only once the guardian and the gate admit the call (ToolInvocationCaller.Admitted). A spawn_agent child runs under the stricter of its own permission mode and its spawner's, and so do a ctx.spawnBackground child of it and a later crew.send to it (new PermissionModes.Stricter). The fail-closed judge's chunks overlap by a quarter (LlmJudgeGuard.ChunkStep). A relative TscPath is refused. memory_recall answers only for a crew with memory. A .dll dropped flat in the plugin directory is refused and recorded (fail fast by default). With Plugins:ContinueOnError: true a plugin tool registered by type, factory or key that its manifest does not declare, or that fails to build, resolves to null and is recorded once in IPluginRegistry.Failures instead of failing every resolution of IEnumerable<IBaseTool>.

  • LLM and eval [breaking]: the cassette key holds the system message, the tool mode, the grammar, top-p, the seed, the penalties, the stop sequences and the system_message custom parameter: re-record existing cassettes. A secret split across streamed deltas is redacted on the joined stream. A replay checks a plain prompt as a live call does and no longer takes a lease of the host's rate limiter (its usage is still reported as recorded). The mock provider gets a logger, so its per-option warnings are no longer dropped. Every host with an embedding provider is guarded, with or without an Orkeon:Embeddings section. A guarded task's held output keeps its order while the hold is released. eval bench reads --baseline before it writes its report and refuses a baseline that is the file it writes; eval run reports carry their dataset, and bench/compare refuse a report without it, of another dataset or another evaluator set, the same file twice, and a --threshold outside 0..1.

  • File system (security) [breaking]: IFileSystemService.ResolveAndValidate (through FileSystemRegistry.ResolveAndCheckRights) resolves every symbolic link and junction on a path, from the root to the deepest existing component, the mount's own root included, and refuses a path whose real location leaves its mount's real root. A link two levels or more above a file (/workspace/a/link/sub/file.txt, link pointing outside) let a read or a write reach past the mount, since PathValidator resolved only the file and its parent. A dangling link is followed to its target, so a write through it is refused too; a link that leads into another mount is refused (it borrowed the rights of the mount it was written under); a link that stays inside its mount works as before. A link swapped between the check and the open is not seen.

  • Public surface: new Orkeon.Constants.Protocol.RunFinishedStatuses.WaitingForInput, the one spelling of waiting_for_input for the runner, the run histories and the host API.

    Before After
    GET /healthz answers 503 during a drain 200, "status": "stopping"; /readyz answers 503
    a second answer to a held question: 202 recorded 409 no_pending_input (200 already_answered for the same answer)
    HostApiOptions.IsUnauthenticated HostApiOptions.NeedsBrowserGuard
    an unauthenticated A2A listener reads any POST 415 without Content-Type: application/json, 421 for a foreign Host
    MCP:Servers:<name>:Url: http://remote/... with Auth or an env: header an https address, or http on loopback
    MCP:Servers:<name>:Headers:MCP-Protocol-Version (and the other transport headers) refused at configuration
    IMcpServerExtension implements StopAdmitting() too
    ToolInvocationPipeline.IsDelegationTool(name) CoworkerDelegation and the tool type ICoworkerDelegationTool
    a tool of another kind named delegate_work_to_coworker or ask_question_to_coworker refused by ToolRegistry
    new JsonFileStateStore(fs, path) keeps every version maxVersions (default 20)
    a link inside a mount that leads outside it, or into another mount (/workspace/a/link/...) refused: link only within the mount, or declare the target as its own mount
    a cassette recorded before this version recorded again
    an eval run report without dataset read by eval compare refused: run it again
    a host enumerating IBaseTool itself under ContinueOnError skips null

Fixed — final review of the FWK lots [breaking]

  • MCP [breaking]: orkeon mcp serve --tools no longer unregisters tools: it sets MCP:Server:AllowedTools, which McpServer applies on tools/list and tools/call, so an excluded tool cannot come back on an upstream list_changed. A --crew call no longer holds a --max-concurrency slot while it waits for its crew. Raw exception messages are no longer returned to MCP clients (a generic JSON-RPC internal error; a crew that fails, or no longer loads, answers that the details are in the server's log, where the message goes). Static headers the transport sets itself are refused at configuration (the full list is under the adversarial review above). The device sign-in runs outside ConnectTimeout and CallTimeout. Closing a session never signs in and never throws out of DisposeAsync; a failed re-initialisation keeps the stale session and starts over at the next 404; an SSE priming event (an id and no data) is skipped; the client sends notifications/cancelled when a call times out or is cancelled; mcp serve ends on an interrupt and disposes its crews; a listen stream that ends at once counts as a failure for the backoff.
  • Host API [breaking]: on an unauthenticated host API, a POST needs Content-Type: application/json (415) and the Host header must name the listener (421). /readyz checks no longer carry a description, and their result is cached for Orkeon:Host:Api:ReadinessCacheTtl (3 s). Event streams are capped by Orkeon:Host:Api:MaxEventStreams (64, then 503 too_many_streams). POST /runs/{id}/input with no request_id while several questions are held answers 409 request_id_required with their ids; the same answer posted again answers 200 already_answered. The run timeout stops while the run holds on a question, so the hold's own timeout can switch it to suspend. With Orkeon:RunHistory off, a hosted run runs under the id POST /runs returned. Added IPendingInputBroker.HeldRequestIds/WatchHolds and IRunHistoryReader.ReadEventsAsync(runId, fromSeq, limit, ct).
  • Run history: a resumed run keeps its started_at and inputs in the Sqlite history; a run waiting for input is never purged; a JSONL history whose last line was torn starts a new line.
  • Checkpoints and human input [breaking]: a checkpoint is written to a temporary file and moved into place (IFileSystemService.MoveAsync, atomic in FileSystemService); a corrupt checkpoint raises an error naming the session. A Parallel task that asked nothing keeps its checkpoint when another task suspends the run. When two tasks ask at once, the run suspends on the question the store holds. Questions are numbered again from .1 on every attempt of a retried task. --resume <id> --input given twice with the same answer continues (PendingInputAnswerOutcome.AlreadyAnswered). A session waiting for an answer is taken over by --resume latest (or its id) only when the run history does not prove its owner alive; ResumeEngine takes optional IRunHistoryReader and IRunProcessProbe. A failure message is sanitized before it is persisted, and a stored structured type is resolved only when it is the task's declared type. The Sqlite state store serializes its commands and lists sessions from new phase and completed_count columns. Cognitive memory is consolidated only when the run ends, not when it suspends.
  • LLM [breaking]: cassette keys now include the model and the sampling options, and secret-shaped values are redacted before hashing (the full key is under the adversarial review above): re-record cassettes made before this version. A redacted value followed by an escaped quote no longer breaks the cassette line, and sk-/AIza patterns match only at a word boundary. A replay re-raises a recorded provider failure as the same kind, and runs the same audio and effort checks as a live call. Vendor error labels (overloaded_error, rate_limit_*, server_error, api_error) fail over; a label-only invalid_api_key, authentication_error or permission_error is refused. The embedding model guard (FWK-25) runs in orkeon run, the other runner commands and the REPL, not only in hosts that start their services (EmbeddingModelGuard.CheckAsync). llm.profile(...) providers answer from test.mockLlm under orkeon run --test. The mock LLM provider warns for each option it cannot honour, and gpt-5-chat takes no reasoning effort.
  • Guardian, permissions, scripting, plugins, graph [breaking]: under FailMode: Closed the LLM judge judges a long text whole in chunks of MaxContentChars that overlap by a quarter (32 at most, LlmJudgeGuard.MaxChunks, then refused). A delegated coworker runs under the stricter of the delegator's and its own permission mode. orkeon run --validate no longer resolves tsc from the working directory (configured TscPath, the install directory or PATH); a node warning on a successful type check is not a diagnostic, a grandchild holding the pipes cannot hang the check, and unknown absolute paths are redacted from its failure tail. A plugin manifest takes an optional entryType, and a plugin whose assembly holds one plugin type activates that type alone. A decision node with no otherwise edge is refused when the graph is built, not mid-run.

Added — record and replay of LLM calls (FWK-11)

  • orkeon run --llm-record <file> and --llm-replay <file> (YAML crews and procedural scripts): the first writes every LLM call of the run, with its answer, to a JSONL cassette; the second answers every call from it, with no network call and no model. A call the cassette does not hold fails with ReplayMissException (never a fallback on the network). The two switches and --llm-mock are exclusive two by two (exit 1). The cassette's folder is an internal mount at /llm-cassette. See the guide.
  • Llm:Replay:Mode (off, record, replay) and Llm:Replay:Cassette set the same thing for a host written in C#. LlmProviderFactory puts RecordingLlmProvider or ReplayLlmProvider under the call-mode layer, above the vendor's provider, so the cassette holds the messages that really went over the wire and LlmProviderEntrance.Enter and its callers do not change. ILlmCallObserver was not enough to record: it announces a call and its token counts, never its answer.
  • A call is filed under the SHA-256 of its profile, messages, system message, tools and tool mode, response format, grammar, model and sampling options (temperature, top-p, seed, penalties, stop sequences, max tokens, thinking) and the system_message custom parameter (timestamps and generated identifiers left out), with an occurrence number for a repeated call; a streamed call is kept as its deltas. The configured API key, Bearer tokens, sk- and AIza keys, key=/api_key=/token= query values and URL user info are redacted from every line.
  • orkeon eval run --crew takes --llm-record and --llm-replay too, and an offline run accepts a replay on any profile (it reaches no endpoint).

Changed — the profile name reaches the provider factory (FWK-11)

  • [breaking] LlmProviderFactory takes a last optional LlmReplayOptions. LlmSettings.ReadProfiles now sets LlmConfig.Profile to the profile's name (null stays the default profile).
  • [breaking] RunnerVirtualRoots.LlmCassette (/llm-cassette) joins RunnerVirtualRoots.All: a user mount may not claim it. RunnerMountPlan gains LlmRecordCassette and LlmReplayCassette; MeteredLlmProvider.Unwrap looks through the cassette decorators.

Added — Mistral, Azure OpenAI and Gemini embeddings, and a guard on the embedding model (FWK-25)

  • Orkeon:Embeddings:Provider accepts mistral (MistralEmbeddingProvider, mistral-embed, 1024 dimensions), azure-openai (AzureOpenAIEmbeddingProvider, Model is the deployment name, Endpoint the resource URL) and gemini (GeminiEmbeddingProvider, gemini-embedding-001, 3072 dimensions, Google's OpenAI-compatible endpoint). They share OpenAICompatibleEmbeddingProviderBase: answers re-ordered by index, batches cut at BatchSize, a vector whose length is not Dimension refused, a 4xx or 5xx raised as an HttpRequestException that never carries the key.
  • New Orkeon:Embeddings keys: ApiKey (secret), ApiKeyEnvVar, Endpoint, ApiVersion and FingerprintPath. mistral and gemini swap in their own model and dimensions when Model and Dimension keep the global defaults.
  • A startup guard refuses a changed embedding model: the first start records the provider, model and dimensions at Orkeon:Embeddings:FingerprintPath (default /workspace/.orkeon/embedding-fingerprint.json); a different one stops the host with an error naming both. Nothing is migrated. Every host with an embedding provider is guarded, with or without an Orkeon:Embeddings section (a host that embedded under the default and then names another provider is refused); with no /workspace mount, or an empty FingerprintPath, it runs unguarded with a warning.
  • mistral and gemini refuse, when the provider is built and before any call, a Dimension other than the fixed size of mistral-embed (1024) or gemini-embedding-001 (3072). Embedding calls do not retry; Llm:MaxRetries is for chat.
  • A provider name outside the five now fails validation with a message listing them. Cohere, Voyage and pgvector stay out.

Added — a capability table per model, and audio as input (FWK-21)

  • IModelCapabilityRegistry (ORKEXP005, experimental) maps a model id prefix to ModelCapabilities (AudioInput, AudioOutput, Vision, ReasoningEfforts); the longest prefix wins. The built-in table is in code (OpenAI chat, audio and reasoning families, Gemini, Claude); Llm:ModelCapabilities:<id> (AudioInput, AudioOutput, Vision, ReasoningEfforts) adds a model or replaces an entry. LlmProviderCapabilities stays per provider.
  • Audio as input: an audio part sent to a model the table credits with audio input becomes an input_audio part (raw bytes, audio/wav or audio/mpeg) on the OpenAI-compatible family (OpenAI, Gemini). A model without audio, or unknown to the table, is refused with a NotSupportedException naming the model and the key that declares it. Anthropic and Ollama stay refusals; audio output is out of scope.
  • Reasoning effort is judged against the model on the OpenAI-compatible family: an effort a listed model does not take is omitted with a structured warning (event 110); a model the table does not know gets it as asked, with a warning (event 113).
  • A Llm:ModelCapabilities:<id> entry merges with the built-in value field by field (a field left out keeps it); a registry the host registers itself wins over the configured one; the "effort sent unchecked" warning (event 113) is given once per provider instance and model. A model id containing : cannot be a key (no escape in .NET configuration): key its prefix.
  • LlmProfileRegistry reads the table when it warns about a fallback that lacks what the primary has: audio input and reasoning efforts join vision, response format, thinking and grammar.

Changed — the model id reaches the content converter (FWK-21)

  • [breaking] ContentConverter.ToOpenAIContentParts, ToAIContents and ToChatMessage take the model id the request is sent to (and an optional IModelCapabilityRegistry): audio is judged against it. Pass the model of the call. LlmProviderFactory's constructor takes a last optional IModelCapabilityRegistry.

Added — durable human-in-the-loop (FWK-23) [breaking]

  • A question to a human survives the process. With Orkeon:Checkpointing:Enabled, DurableHumanInputProvider and DurableToolApprovalChannel persist the question with the run's checkpoint session (SessionState.PendingInput, SessionPhase.WaitingForInput, PendingInputRequest, PendingInputKind; the answers in SessionState.AnsweredInputs), in the store the task checkpoints already use, through IPendingInputStore (implemented by CheckpointManager). The id is <TaskKey>#<n>.<q>, the same on every resume; the answer is matched by that id (a tool approval also by its tool and its arguments' hash) and the prompt shown is the one persisted the first time. The first answer wins (compare-and-set).
  • Orkeon:HumanInput (Pause Hold|Suspend, HoldTimeout): Hold waits on an IPendingInputBroker up to HoldTimeout, whose expiry suspends (the question stays persisted, nothing is refused); Suspend stops the run with RunSuspendedException (final: never retried, never a failed checkpoint). Unset: Hold when a person can be asked, Suspend otherwise; orkeon-host holds 30 minutes, --events without limit.
  • orkeon run --resume <id> --input "..." answers the question; refused without --resume (exit 1) and when the run waits for none. [breaking] a run that stops on a question exits 75 (EX_TEMPFAIL, RunExitCodes.WaitingForInput) and its run.finished carries status: "waiting_for_input", requestId; RunStatus.WaitingForInput in the run history, waiting_for_input in orkeon runs and the API. input.needed carries requestId (and is correlated by it); input.given is also written for a held run's answer.
  • POST /runs/{id}/input on the host API (pending_input on GET /runs/{id}), same authorization as the other run routes: 200 delivered to a held run, 202 recorded for a suspended one, 409 for a second answer or another question. [breaking] orkeon-host now registers the human_input tool and its provider (it had none).
  • A2A: A2ATaskStatus.InputRequired, serialized input-required by [JsonStringEnumMemberName] on that member alone; a hosted run waiting for input answers input-required.
  • Permission gate: a tool approval is a durable question of kind ToolApproval (ToolName, ArgsHash): a run with nobody to answer stops on it instead of refusing the call. ToolInvocationPipeline stops the agent's loop when a tool left its run waiting for input; IHumanInputProvider.AsksAPerson (default true; false for the auto-approve provider); ICrewExecutionHook.OnHumanInputAsync; KickoffOptions.ResumeInput, CrewOutput.PendingInput; RunnerOptionsBase.Input.
  • The prompt of a durable question is masked as the run history masks (RedactingRunEventSink.RedactText) where it is printed or read back (the orkeon run stderr line, GET /runs/{id}, the output of a suspended run); the stored prompt and answer stay in plaintext, which docs/reference/limitations.md says.
  • Documented: the daemon records an answer for a suspended run but does not resume it.

Added — health probes, a run API and idempotency on orkeon-host (FWK-14)

  • Orkeon:Host:Api (Enabled, Prefix, Security, ReadinessTags, IdempotencyTtl, IdempotencyMaxKeys) starts a HostApiServer on its own HttpListener, off by default. GET /healthz (liveness, system_resources only, never an external service) and GET /readyz (crew_registry, state_store, run_history, memory_provider, and llm_provider only when ReadinessTags lists llm) answer without authentication; once the stop has closed admission /readyz answers 503 and /healthz stays 200 ("status": "stopping"). POST /runs (202, 429 + Retry-After, 404, 503, 409), GET /runs, GET /runs/{id}, GET /runs/{id}/events (SSE with id: seq and Last-Event-ID, else NDJSON) and POST /runs/{id}/cancel. A prefix beyond the loopback without authentication is refused at start. Reference: docs/reference/host-api.md.
  • Keep-alive: a quiet event stream writes a frame every SseKeepAliveInterval (15 s; an SSE comment, a blank NDJSON line), so a client that went away is noticed and its stream ends; a disconnect ends a stream quietly, logged at Debug. The start refusals of A2ACredentialValidator and HttpRequestAuthenticator name the configuration section of their caller (sectionName, A2A:Security by default).
  • Idempotency: idempotency_key plus a hash of the request. The same key and request answers 200 on the first run, another request 409; two requests at once start one run. Keys live in memory for IdempotencyTtl (24 h) and are written into run.started; the history gives them back at start, so they survive a restart while the history keeps the run.
  • HttpRequestAuthenticator, HttpSecurityOptions, HttpAuthorization (Orkeon.Infrastructure.AgentCommunication, experimental ORKEXP006): the mutual-TLS and Bearer/ApiKey checks of A2AServer, extracted so the host API enforces the same rules. A2ACredentialValidator takes the neutral options too. AddOrkeonHealthChecks() (Orkeon.Infrastructure.Telemetry.HealthChecks, tags live, ready, llm) registers the health checks.
  • One id end to end [breaking]: the daemon's run id is now the run's ExecutionId (a 26-character ULID, was twelve hexadecimal characters). The chat /stop, the A2A task, the API, orkeon runs, the history and the checkpoint session name a run by it. ICrewRunner.RunAsync takes a trailing RunIdempotency?.
  • Health checks always registered [breaking]: they were added by AddOrkeonTelemetry, so a host without telemetry had none. AddOrkeonInfrastructure() now registers them through AddOrkeonHealthChecks(), and llm_provider carries the tag llm, memory_provider ready, system_resources live.

Added — the YAML graph: block: nodes, edges and decision branches (FWK-28) [breaking]

  • graph: {start?, nodes?: [{id, task}], edges: [{from, to, when?}], maxTransitions, maxVisits, circuitBreakerPreset, maxTotalDurationSeconds} under process: graph describes the graph the crew runs (ADR-018): to: END ends the run, several edges from one from are one conditional edge evaluated in the order declared, the first whose when holds wins and the edge without when is the "otherwise". A when keeps the grammar of the task-level one (<task>.<question>[.<option>]), on the decision task the edge leaves; a loop is an edge leading back to a node, bounded by maxVisits, and on a revisit the latest output and decision win. edges without nodes gives one node per task, named after it; without graph: the crew still runs one node per task in execution order. A node whose task fails ends the run.

  • Refused at load, each message naming the node or the task: a when on a task that is no decision, a decision with no edge without when, two edges without when from one node, several edges on an ordinary task, an orphan node, a node with no way to END, an unknown node or task, a task run by two nodes or by none, a task-level when: or dependencies: beside nodes or edges, and a graph: outside process: graph. The topology faults come from GraphTopologyValidator, all at once; the export checks them before it writes and writes graph: back, so import, export and import give the same graph.

  • A decision node's answer is checkpointed under the task's invocation key (<task>#<n>) and replayed when the run is resumed instead of being asked again, so a resumed run takes the route the interrupted one took (Graph process; CheckpointingAgentExecutionService keeps the decision outcome in the stored result). Sequential and Parallel still ask their decision tasks again on resume.

  • Domain: GraphConfig gains Start, Nodes (GraphNodeConfig) and Edges (GraphEdgeConfig, with an optional TaskCondition) and the constant GraphConfig.End. GraphProcessStrategy builds the described graph on the Domain engine, with the default budgets of the implicit graph (visits = sum of 1 + retries, transitions = 2 × visits + 1).

  • [breaking] the YAML graphConfig: block is replaced by graph:; a crew that still writes graphConfig is refused at load, pointing to graph:. maxStateVisits becomes maxVisits, and there is no maxCycles (a bound on cycles is maxVisits, a retry is the task's retry:).

    Before After
    graphConfig: { circuitBreakerPreset, maxTransitions, maxTotalDurationSeconds } graph: { circuitBreakerPreset, maxTransitions, maxTotalDurationSeconds }
    graphConfig.maxStateVisits graph.maxVisits
    CrewYamlConfig.GraphConfig, CrewSettingsYamlConfig.GraphConfig, CrewMappingSettings.GraphConfig Graph
    GraphYamlConfig.MaxStateVisits GraphYamlConfig.MaxVisits (the domain GraphConfig.MaxStateVisits keeps its name)

    The example 09-experimental/102-graph-orchestration and the round-trip witnesses are migrated (a new graph.yaml witness sets every key of the block).

Added — dotnet new templates (FWK-26)

  • Orkeon.Templates (src/packaging/Orkeon.Templates, PackageType=Template, in the NuGet.org lineup) adds three templates: orkeon-host (a generic host that runs a crew.ork.ts through ICrewScriptRunner, configured from appsettings.json), orkeon-plugin (an IOrkeonPlugin, one tool and the plugin.json that declares it) and orkeon-tool (a ToolBase<TRequest, TResponse> class). dotnet new install Orkeon.Templates --prerelease.
  • A generated project carries explicit package versions: the templates hold the token $(OrkeonVersion) and the pack replaces it with the version of src/Directory.Build.props. orkeon init keeps the settings file and does not overlap.
  • Orkeon.Plugins now ships inside the Orkeon umbrella package, one of its thirteen assemblies (IOrkeonPlugin, the plugin loader), which the plugin template compiles against; it was packed nowhere before. dotnet add package Orkeon.Plugins still resolves nothing: the umbrella carries it. The assembly and its public API are unchanged.
  • publish.yml installs the packed template package, generates each template and builds it before the push; TemplatesPackTests (Category=Slow, tests/e2e) does the same offline, nightly, on a local feed of the packed nupkgs.
  • The source layout counts one more project.

Added — tool-call deltas in the stream and an enriched llm.delta (FWK-20)

  • LlmStreamEventKind.ToolCallDelta and ToolCallDelta(Index, Id, Name, ArgumentsDelta) (LlmStreamEvent.ToolCall): the chat stream tells its caller about a tool call while the model builds it. The OpenAI dialect (fourteen providers) emits one delta per delta.tool_calls fragment, Anthropic one when a tool_use block opens and one per input_json_delta, Ollama one complete delta per call. The terminal event still carries the whole call, unchanged; no provider of the 16 stays mute.
  • ILlmDeltaSink.OnToolCallDelta (default: nothing), onToolCallDelta on ctx.llm.act (typings in context.d.ts), and CrewExecutionEvent.ToolCall for a streamed run.
  • llm.delta gains deltaKind (content on every text delta, tool_call on a fragment) and toolCall: {index, id?, name?, argumentsDelta}. The field is deltaKind and not kind: kind is already the event's own name on the wire. The text delta is otherwise unchanged.
  • DLP: a host that registered AddOrkeonDlp gets the arguments of each streamed call held by index until the stream ends, scanned whole by the external-output interceptor and emitted as one redacted delta (ExecutionOrchestrator.ToolCallDlp; for the scripted act, ScriptingHostPorts.ToolCallDlp, which the hosts fill with ToolCallDeltaDlp.From(services) whatever their delta sink, the forge's own calls included); without one the fragments stream as they arrive. The held fragments follow the guardian's output hold (FWK-19). An interceptor that fails empties the arguments, never leaks them.
  • A fallback chain (FWK-05) already commits to a provider at its first event: a tool-call delta counts, so the partial deltas of a failed provider never reach the caller.
  • [breaking] AddLlmConsoleStreaming(configuration) becomes AddLlmConsoleStreaming(configuration, enabledByDefault = false): the REPL passes true and so streams to the console unless Orkeon:Cli:ConsoleStreaming:Enabled is false; a crew run keeps it off. A call that passed only the configuration compiles unchanged and keeps the old default.

Added — crews as MCP tools and server-side prompts (FWK-24)

  • orkeon mcp serve --crew <a.yaml> [<b.yaml> …] serves each crew as the tool run_crew_<name> (the crew's name, lower case): its inputSchema is one required string property per {placeholder} of the tasks' description and expectedOutput, its result the crew's final output (a crew that fails is a result with isError), and a call carrying _meta.progressToken gets one notifications/progress per finished task. Only the crews named are served: no tool takes a path. Each crew is loaded through CrewRunEntryPoint, in a host of its own, so the budget, the guardian and the permission gate are those of orkeon run; --allow-external-mounts is the orkeon run guard for a crew outside the working directory. A call is recorded in the run history (Orkeon:RunHistory:Enabled) like any run of the host, under its own run id, and nothing is written with the history off. Calls of one crew run one at a time (its host and its mounts are shared), and notifications/cancelled cancels the running crew. The progress total is the number of tasks, which a retry or a hierarchical manager can exceed. The serve host reads the real settings: there is no offline mode.
  • prompts/list and prompts/get: every task of every served crew is the prompt <name>_task_<n>, its arguments the task's placeholders, the message its description and expected output interpolated. The prompts capability is advertised only with --crew.
  • New public types IMcpServerExtension, IMcpProgress and McpRequestException (ORKEXP004). [breaking] McpServer's constructor takes an optional extension after logger: a caller passing arguments by position past logger adapts.
  • --crew follows the repository's option grammar: several crews go space-separated after one flag, which cannot be repeated.

Added — type-checking .ork.ts in --validate (FWK-12)

  • [breaking] orkeon run --validate type-checks a .ork.ts by default, so a script with a type error that used to validate now fails with exit 1 wherever tsc is installed. Orkeon:Scripting:Toolchain:TypeCheck: Off is the opt-out; a machine without tsc only gets a warning.

    Before After
    --validate on a .ork.ts never looked at its types --validate runs tsc first; a type error is VALIDATION FAILED: type errors, exit 1
    no setting Orkeon:Scripting:Toolchain:TypeCheck Validate (default), Off, Always; Off restores the old behaviour
  • The check runs tsc against the orkeon.d.ts roll-up this build embeds (test.d.ts included), after the MCP servers connect and before the crew loads, on the script and the local modules it imports. A type error prints VALIDATION FAILED: type errors, then <virtual path>:line:col TSxxxx message per error. The compiler reads and prints physical paths, so it checks a scratch copy (the orkeon-script pragma blanked in the script and in every imported module, line count kept; relative imports still resolve) written outside the VFS, and every path of its output and of a failure message is mapped back to the VFS before display.

  • Orkeon:Scripting:Toolchain:TypeCheck (Off, Validate default, Always), TscPath and TypeCheckTimeout (60 s). Always also checks before every run (ERROR: type errors, exit 2). tsc is found through TscPath (the only candidate when set), tools/scripting-typecheck/node_modules/.bin/, then PATH; nothing is downloaded. Without it, Validate warns (WARNING: type check skipped: …) and goes on, Always fails (VALIDATION FAILED: type check unavailable). A tsc that dies without a diagnostic (crash, signal, non-zero exit) is a failure (type check failed (exit N)), never "no errors"; cancelling the run kills it.

  • orkeon doctor gains a tsc check; TscTypeChecker, TscOutputParser, TypeCheckDiagnostic, TscNotFoundException and TypeCheckMode join the public surface of Orkeon.Scripting.

Added — an LLM judge on a task's input and output (FWK-19)

  • Orkeon:Guardian:Llm (Enabled, Phases, BlockThreshold, WarnThreshold, Risks, FailMode, MaxContentChars) turns on LlmJudgeGuard, which asks the decision model (IDecisionModel, no profile of its own) one question per risk on an agent's input and on a task's output. Off by default: it costs a model call per phase.

  • GuardPhase.Output joins Input, ToolExecution and Delegation, with GuardianPolicy.OutputGuardEnabled (default true). ExecutionOrchestrator runs it on the validated output, before the deliverable, the memory and task.completed: a block fails the task (GuardianBlocked, Blocked by Guardian (output): <reason>) and nothing is kept. A call that ended LlmCallFailed has no output and is not judged. The judge runs once per call, outside the profile fallback chain: a refusal never makes a profile fail over.

  • FailMode: Closed (default) refuses a text the model could not judge; Open lets it in with a warning. Both audit guardian.judge.unavailable. A text longer than MaxContentChars (8000) is judged whole under Closed, in chunks of that size that overlap by a quarter (any chunk that blocks blocks; beyond LlmJudgeGuard.MaxChunks chunks the text is refused, audited as guardian.judge.truncated); under Open it is judged on its first and last half of that budget, with a marker between them: what lies between is not judged, and the cut is audited as guardian.judge.truncated.

  • While the output phase is guarded, a task's streamed deltas (llm.delta, the host's ILlmDeltaSink) are held until the guardian has judged the output: released when it allows it, dropped when it blocks it, so a blocked output reaches neither the stream, the console nor the run history. Streaming is delayed until the judgement; IGuardianPipeline.IsPhaseGuarded tells the orchestrator when.

  • A host that enables the judge without a decision model is refused at start, and so is a Phases value other than Input or Output (ToolExecution and Delegation are checked by rules).

  • The output phase covers crew tasks (ExecuteTaskCoreAsync) only: a scripted ctx.llm.act crosses the input phase but its answer is not judged.

  • [breaking] DecisionInputGuard is renamed LlmJudgeGuard, DecisionGuardOptions is merged into GuardianLlmOptions and the section Orkeon:Decision:Guard moves to Orkeon:Guardian:Llm; and the default when the judge is on is now fail-closed (it was fail-open). ADR-015 is amended (2026-11-08).

    Before After
    DecisionInputGuard LlmJudgeGuard
    DecisionGuardOptions GuardianLlmOptions (under GuardianOptions.Llm)
    Orkeon:Decision:Guard:* Orkeon:Guardian:Llm:*
    Orkeon:Decision:Guard:FailClosed: false (default) Orkeon:Guardian:Llm:FailMode: Open
    Orkeon:Decision:Guard:FailClosed: true Orkeon:Guardian:Llm:FailMode: Closed (the new default)

Added — a retry per task, in every mode (FWK-15) [breaking]

  • retry: {attempts, backoffMs, backoff} on a task (YAML, taskBuilder().retry({...}) in a script, CrewTaskBuilder.Retry(TaskRetryPolicy) in C#) runs a failed task again, up to attempts runs in all (the first included, at least 1, required); backoffMs (default 0) and backoff (fixed, the default, or exponential, doubling and capped at five minutes) set the wait, taken on the host's TimeProvider and cancelled with the run. One decorator, RetryingAgentExecutionService, sits between the checkpoint decorator and the execution core, so the six modes behave alike and the strategies never retry; only the attempt that ended the task is checkpointed, and its TaskCheckpoint.RetryCount (new retryCount argument of ICheckpointManager.CheckpointAsync) and TaskResult.RetryCount say how many attempts came before it.
  • A new attempt replays the whole task, tool calls that already succeeded included: nothing deduplicates them, the crew author keeps the tools idempotent. Never retried: a cancellation, a guardian refusal (GuardianBlocked), an exhausted budget. A timeout (ExecutionTimeExceeded) and an exhausted failover chain (FallbackExhausted) are retried, after the backoff. A decision task cannot declare retry: (refused at load, and by CrewTaskBuilder.Build()). A retry is announced by a task.started carrying attempt (additive field of the JSONL protocol, also on task.completed, where it says which attempt ended the task; TaskStartSnapshot.Attempt, CrewExecutionEvent.Attempt; the strategy's own start is attempt 1).
  • [breaking] graphConfig.maxRetryCycles is removed: a crew that writes it is refused at load as an unknown key, and GraphConfig.MaxRetryCycles, GraphYamlConfig.MaxRetryCycles and GraphProcessStrategy.MaxRetryCycles go with it. The Graph process no longer retries a failed task by itself (CrewGraphState.RetryCounts, MaxRetryCycles, RetryRequested and the self-edge a node took to run its task again are removed: every node leads to the next one): a task that needs attempts declares retry:. Migrate graphConfig: {maxRetryCycles: 2} to retry: {attempts: 3} on the tasks that need it. The default breaker bounds of a Graph crew count the attempts: maxStateVisits is the sum over the tasks of 1 + retries (retries = attempts - 1), maxTransitions twice that plus one. The script engine's own stateGraph maxRetryCycles is unchanged.
  • [breaking] a Graph run no longer checkpoints a task under a second ordinal (second#2) after a failure: the graph does not run a task twice, the attempts are inside one invocation. ICheckpointManager.CheckpointAsync gains a trailing int retryCount = 0.
  • [breaking] decision tasks lose the old graph retry: a decision-model failure used to be retried by the graph's retry cycles and now fails the task at once (the decision circuit's fallback is the recovery); the graph's maxRetryCycles is gone and a decision task cannot declare retry:.

Added — orkeon eval and the Evaluation section read by the runner hosts (FWK-09)

  • orkeon eval run --dataset <json> [--evaluators ...] [--llm-judge] [--offline] [--output /output/eval] [--min-score 0.7] [--crew <file>] scores a dataset with the default suite and writes a JSON report; exit 1 under --min-score. With --crew the crew runs once per case first (its prompt is the case's task_description), offline on the mock provider with --llm-mock; its final output replaces output in the report and the dataset file is never modified. eval bench --runs N --baseline <json> and eval compare a.json b.json exit 1 on a regression.
  • RunnerHost binds the Evaluation section (AddOrkeonEvaluation(configuration), next to the permission gate) and registers AddOrkeonBenchmarking(): Evaluation:EnableLlmJudge was bound by no shipped binary. orkeon and orkeon-host now list Evaluation among the sections they read.
  • CrewRunEntryPoint (Orkeon.Hosting, internal) loads a crew and kicks it off in a scope of its own and hands the output back; orkeon run prints from it, and eval run --crew reads it once per case.
  • --offline with --crew refuses a crew that would reach a real model: CrewRunEntryPoint.RunAsync(..., offline: true) checks, once the crew is loaded, the model of every agent (its own profile, its own provider, the host default) and of the manager, and refuses with the agent and the profile named. RedactingRunEventSink.Redact is now public: the strings of an eval report go through the redaction of the run history.
  • ReportExporter.ToJson (evaluation, benchmark and comparison reports, snake_case) and ReportExporter.ReadComparableReport.

Changed — orkeon rag eval is orkeon eval rag (FWK-09)

  • [breaking] orkeon rag eval is now orkeon eval rag, with the same options and no alias; rag keeps ingest and search. Migration: replace orkeon rag eval with orkeon eval rag in scripts and CI (rag-eval.yml does). The error lines read orkeon eval rag: ....

Added — OAuth for the MCP client: client credentials and device flow (FWK-16)

  • MCP:Servers:<id>:Auth:Type takes oauth2-client-credentials and oauth2-device (the enum names OAuth2ClientCredentials and OAuth2Device are read too) with the keys TokenUrl, DeviceAuthorizationUrl, ClientId, ClientSecretEnv, Scopes and Audience. OAuthMcpAuthenticator keeps the access token in memory only (never on disk), renews it 60 seconds before it expires, and on a 401 renews it once and sends the request again once; a second 401 is the answer. Requests refused together share one renewal; the GET stream renews and reopens once in a row. IMcpRequestAuthenticator gains HandleUnauthorizedAsync (default: nothing to renew). OAuth2Client (internal to Orkeon.Tools.Abstractions, now visible to Orkeon.Infrastructure) gains RequestClientCredentialsAsync; OAuthSettings gains Audience and OAuthFlow.ClientCredentials.
  • Auth:Type is read from a closed list of spellings (the names, and oauth2-client-credentials / oauth2-device); anything else, a number included, is refused with the list. The configuration binder drops a server whose settings it cannot convert without a word, so McpStartup now reads each such server again and reports the reason on one line naming it (MCP:Servers:<id> was set aside: ...). Requests refused together share the renewal and, when it fails, its error. OAuthTokenSet no longer prints its tokens.
  • The token endpoint is reached through the named HttpClient orkeon-mcp-oauth (McpServiceExtensions.OAuthHttpClientName), excluded from the LLM exchange log; it must be https (loopback http excepted). The client secret and the tokens are scrubbed from every error and log line.
  • orkeon run, --validate/--list-tools and the REPL register an IOAuthLoginInteraction that shows the device code on stderr; orkeon-host registers none, so a server in oauth2-device is set aside at startup with an error naming it. McpToolProvider's constructor takes a trailing IOAuthLoginInteraction?. Not supported: RFC 9728 discovery and dynamic client registration (docs/reference/limitations.md). Guide: docs/architecture/mcp.md.

Added — a profile that fails over to another (FWK-05)

  • Llm:Profiles:<name>:Fallback: [b, c] (and FallbackBudgetSeconds) names the profiles a call moves to when <name> fails in a way a retry cannot cure: a transport error, a 5xx, a 429 once Llm:MaxRetries is spent, a timeout. A 4xx, a blocked content and a failure nothing is known about are the answer and move nothing. FallbackLlmProvider is the outermost link, above profiles already assembled, so each keeps its call mode and the meter and the trace name the provider that answered; a stream moves on only before its first delta; an exhausted chain answers with one error naming every profile (ErrorType FallbackExhausted). Unknown names, self-references and cycles refuse LlmProfileRegistry's construction; a fallback with fewer LlmProviderCapabilities logs one warning. LlmFailureClassifier is the one classification, and ResiliencePolicies takes its retryable statuses from it (no change of behaviour). Code: AddOrkeonLlmProfile(name, provider, baseConfig, fallback) and LlmProfileRegistration.Fallback / FallbackBudget. Guide: docs/architecture/llm-providers.md#profile-fallback.
  • llm.fallback (profile, from, to, reason) joins RunEventKinds (nineteen kinds) and the --events stream, written through the new ILlmFallbackObserver port; a consumer that does not know the kind ignores it (UnknownEventKindToleranceTests locks that for the inbound pump).
  • The provider batch APIs stay out: documented in docs/reference/limitations.md with the reason.

Changed — one graph validator, one node per task, and graph.node.entered (FWK-27, ADR-018)

  • GraphTopologyValidator (Orkeon.Domain.Graph) checks the shape of a graph and returns every fault, not the first: an empty, reserved or repeated node id, an edge from or to an undeclared node (the ids that exist are named), a node with no outgoing edge, an orphan, no path from START to END, a node that cannot reach END, and a fixed edge beside another. StateGraph<TState>.Compile() and the script's stateGraph(...) both call it; the YAML mapper and the export will (FWK-28). An edge whose targets are unknown (a script's function edge, a conditional edge declared without possibleTargets) is assumed to reach END and any node. [breaking] Compile() now also refuses an orphan and a graph with no path to END, and stateGraph(...) also refuses an orphan, a node with no outgoing edge and an edge from an undeclared node; a script that built such a graph is refused at construction, with every fault in one message.
  • The Graph process builds one node per task: the node id is the task's name (its id when the name is missing or taken), the nodes are chained in execution order, the last one leads to END. [breaking] the single execute_task / route loop is gone: traces, logs and graph.node.entered name the tasks. CrewGraphState.PendingTaskIds and FailedTaskIds are removed. The visit bound (graph.maxVisits, the Domain's MaxStateVisits) counts the visits of one node, not of the whole run. A failing task is retried only by its own retry: (FWK-15); the graph does not loop a node on itself (FWK-28 removed graphConfig and maxRetryCycles). GraphProcessStrategy's constructor takes a trailing IGraphNodeObserver?.
  • graph.node.entered, a new run event kind (node, visit, task?, graph?), is written by orkeon run --events jsonl for both engines: GraphRunner<TState>.OnNodeEntered for a crew, stateGraph for a script (ScriptingHostPorts.GraphObserver). A reader that does not know the kind ignores it (UnknownEventKindToleranceTests).
  • On a script's stateGraph, maxRetryCycles: k and maxStateVisits: k + 1 are the same bound on a graph that loops on one node (GraphBudgetParityTests); a YAML crew bounds a node with graph.maxVisits; the defaults of each engine are documented as they are (scripting-dsl.md).

Added — orkeon mcp serve runs requests concurrently and serves /output as resources (FWK-18)

  • Requests run at once. RunStdioAsync starts one task per request, at most --max-concurrency <n> (MCP:Server:MaxConcurrency, 4) running while the others wait their turn; the answers go through one channel to one writer, so two answers never interleave on stdout. When stdin closes, every request already read is answered first.
  • notifications/cancelled cancels the request its requestId names, running or waiting for its turn, and a cancelled request is not answered. An id already in flight is refused with -32600.
  • --expose-output (MCP:Server:ExposeOutput, off) serves /output as read-only resources: resources/list (paged, ResourcesPageSize 100, opaque nextCursor) and resources/read (text or base64 blob, up to MaxResourceBytes 1 MiB) on orkeon:///output/<path>, through IFileSystemService and its Read right. /workspace and any other mount are never exposed, no URI or error carries a physical path, and there is no resources/subscribe. McpServerOptions gains MaxConcurrency, ExposeOutput, ResourcesPageSize and MaxResourceBytes.
  • [breaking] McpServer's constructors take a required IFileSystemService after the invocation pipeline (new McpServer(registry, pipeline, fileSystem, options)); a host that built the server by hand passes its file system. The container registers it already.

Added — a durable run history and orkeon runs (FWK-08)

  • Orkeon:RunHistory (Enabled false in the library and orkeon run, true in orkeon-host and the orkeon init template; Store jsonl or sqlite; Path /runs; RetentionDays 30; MaxRuns 1000; IncludeDeltas false) keeps the events of every run after it ended, under ./.orkeon/runs mounted at /runs as an internal mount next to the checkpoint state (RunnerVirtualRoots.Runs). The jsonl store writes <run id>.jsonl and index.jsonl through the VFS, one serialized writer per run; the sqlite store (SqliteRunEventSink, WAL) holds runs and run_events. A purge applies the retention at start and when a run finishes; a run in flight is never purged.
  • orkeon runs list [--crew] [--limit] | show <id> | tail <id> [--follow] [--from <seq>] reads the history back: show and tail print the very lines of orkeon run --events jsonl. Exit 1 on an unknown subcommand, a run absent from the history or a history not enabled.
  • Ports IRunEventSink and IRunHistoryReader (Orkeon.Application.Runs, experimental ORKEXP007) with RunEvent, RunQuery, RunSummary, RunEventWire (the one wire form) and RunHistoryRetention. The observers of a run write to a RunEventPublisher (Orkeon.Hosting), which stamps each event once and fans it out to every destination. The stdout stream of --events is unchanged byte for byte, pinned by a golden test.
  • orkeon-host records every hosted run under the run's ExecutionId (opened as the run identity before run.started, adopted by the kickoff): run.started (with the daemon's own run id as hostRunId), the task events, error and run.finished. The tool.*, llm.call.* and cost.updated events of a hosted run are not published (stated in docs/reference/limitations.md).
  • A run is recorded with or without --events once Orkeon:RunHistory:Enabled is true (read from the settings before the host exists, so run.started is the history's first event); without --events nothing goes to stdout and the run's stdin and logs are left alone. --resume latest and a run whose host cannot be built are not recorded.
  • A killed run is orphaned: run.started is recorded with the pid and host of the writing process, and a run still running whose process is gone from the same host is read orphaned by list, show and tail --follow (which ends), and is purgeable. On another host it stays running. RunStatus gains Orphaned; RunSummary gains Pid, Host, ProcessStartedAt.
  • Several writers, one folder: the JSONL index is only appended to (a purge appends a tombstone, no rewrite), a run file the index lost is listed from its own events, the purge belongs to the writing side (first write and run.finished), never to orkeon runs or a host that only reads, and the store writes through a file system of its own, so that run.finished of orkeon run is written after the host is gone. The Sqlite store sets a busy timeout next to WAL.
  • Secrets are masked before the JSONL and Sqlite sinks write (RedactingRunEventSink, over LogSanitizer); orkeon init writes Orkeon:RunHistory:Enabled and adds .orkeon/ to the .gitignore of the current folder. The early-event buffer (128) logs how many events it could not keep.
  • A resumed run keeps one sequence: --resume <id> runs under the same run id, and the history (JSONL file and Sqlite) continues the sequence from the last number it holds for that run instead of restarting at 1, so seq is strictly increasing within a run id and ReadEventsAsync(id, fromSeq) and tail --follow are unambiguous; the second run.started of the history carries resumed: true. The stdout stream of each process still counts from 1.
  • The scripting path reserves /state and /runs as the YAML one does (--mount ./d:/runs:rw is refused).
  • [breaking] RunEventObserver, ObservedTool (with ObservedToolDecorator) and RunEventsLlmCallObserver moved from the orkeon CLI to Orkeon.Hosting (Orkeon.Hosting.Runs, internal) and take an IRunEventSink instead of the CLI's OrkeonEventWriter; ObservedRunContext takes a RunEventPublisher. OrkeonEventWriter stays for the forge, email, drive and usecases streams, now over RunEventWire, and implements IRunEventSink. RunnerMountPlan gains RunHistoryByDefault; Orkeon.Hosting references Orkeon.Constants.Protocol; Orkeon:RunHistory joins SettingsSections.Known.

Added — a plugin.json manifest, checked before a plugin loads (FWK-13)

  • A plugin is a sub-folder of the plugin directory holding plugin.json (name, version, orkeonVersion as a NuGet range, entryAssembly, tools) and the entry assembly it names. The manifest is read through the VFS before the load context is created. PluginManifestException (a PluginLoadException, so Plugins:ContinueOnError records it) refuses a plugin whose manifest is absent, malformed or incomplete, whose entry assembly is missing, does not match Plugins:SearchPattern or is denied by the mount rights, whose range excludes the running Orkeon (a pre-release sorts below its release, build metadata ignored), whose manifest names no plugin of the assembly or disagrees with it on the version, or that registers an IBaseTool its tools list does not declare. A refused plugin leaves no registration (the service collection is restored, a throwing ConfigureServices included). A tool given as an instance is checked at registration; one registered by type, factory or key is checked by the host's own provider when it builds the tool (no scratch provider, one construction), where an undeclared name is a PluginManifestException naming the plugin and a failure of the tool's code a PluginLoadException. [breaking] With Plugins:ContinueOnError: true such a tool is dropped: it resolves to null, the refusal is recorded once in IPluginRegistry.Failures, and Orkeon's consumers of IEnumerable<IBaseTool> skip it, so a host that enumerates IBaseTool itself must skip null; with false (fail fast) the resolution throws. A minimal plugin and its manifest are in the test fixtures (Fixtures/SamplePlugin/). Guide: docs/architecture/plugins.md.
  • [breaking] a .dll dropped flat in the plugin directory is no longer loaded, and a folder holding a .dll without plugin.json is refused: move each plugin to <dir>/<name>/ with a manifest. Only the plugin the manifest names is configured: the other IOrkeonPlugin types of its assembly are constructed (Name is an instance property) but their ConfigureServices is never called, and a constructor that throws fails the load. Plugins:SearchPattern filters the entry assembly's file name. PluginLoadException is no longer sealed; PluginAssemblyCandidate gains Manifest and ManifestFailure, LoadedPluginAssembly gains Manifest, PluginLoader gains a constructor taking the Orkeon version.

Added — one checkpoint per task and orkeon run --resume (FWK-07)

  • orkeon run <crew> --resume <id>|latest continues a failed or killed run instead of starting another: the tasks it had completed are answered from the checkpoint (no model is asked), the others run, and the run keeps its id. A failed run prints that id on stderr. It needs Orkeon:Checkpointing:Enabled=true, and is refused with --validate, --list-tools, a procedural .ork.ts, and with --events when the id is latest. KickoffOptions.Resume is the same request for a host written in C#.
  • Every task a crew run completes is checkpointed as it ends, in the six orchestration modes, by CheckpointingAgentExecutionService (a decorator of IAgentExecutionService, inactive outside a run and for a task without a key), under "{TaskKey}#{n}": the task's name in the crew definition and the ordinal of its invocation in the run (a Hierarchical revision or a Graph retry). A checkpoint that cannot be written fails the task. Manager decisions of a Hierarchical or Autonomous crew are replayed live on a resume; decision tasks are asked again.
  • Next to its output a checkpoint keeps a fingerprint of the task (description, expected output, agent, dependencies): a resumed run that finds a task edited since runs it again with every task after it, and logs one warning naming it. --resume latest takes the most recent run of the crew that is not completed, and refuses one still marked Running (no lease: name its id to take it over).
  • The host names the crew key with the crew's name, the virtual path of its file and a 16-hex digest of the file's full path (moving or renaming the checkout orphans its earlier runs): two crews of one name, in different files or folders, never resume each other's state. CrewOutput.ExecutionId carries the id of the run. task.completed carries resumed in every mode. TaskResult<TOutput> gains Resumed, TokensUsed, PromptTokens, CompletionTokens and IterationsUsed; ResumeResult.Refusal, ResumePlan.ResumedTaskIds and RunnerOptionsBase.WorkingDirectory are new, and CheckpointingAgentExecutionService takes an optional ITaskRepository. TaskResult.Resumed, TaskExecutionSnapshot.Resumed, ResumeOptions.ExecutionId, ICrewTask.Key and RunOptionNames.Resume are new.
  • A task name is unique in a crew: CrewBuilder.Build() refuses two tasks of one key, as the YAML and TypeScript loaders already did.
  • CheckpointManager.StartSessionAsync continues a session that already exists instead of overwriting it (a resumed run keeps its id), and serialises the writes of one session, so the tasks of a parallel wave never lose one another's checkpoint.
  • [breaking] ResumeResult.ResumeFromIndex is removed: a resume is keyed by task, an index does not survive the non-linear modes. RunScope.Resume is a ResumePlan? (the session and the outputs it completed), no longer a string?. SequentialCrewOrchestrator's constructor takes a trailing IResumeEngine?, and RunnerRunIdentity.Ambient is gone. A run whose crew did not succeed now ends its session Failed (resumable); it was Completed.

Added — cognitive memory wired into the runners (FWK-04)

  • Orkeon:CognitiveMemory:Enabled (false) wires ICognitiveMemoryService into orkeon, orkeon-host and orkeon-repl. A crew with memory: true then recalls by composite score (similarity, recency, importance; floors Orkeon:CrewMemory:MinCompositeScore, 0.4, distinct from MinScore, and MinSemanticScore, 0.5: relevance is required apart, a fresh memory otherwise reaches the composite floor alone), stores through RememberAsync (an analysis that fails stores the memory with the default importance and logs memory.analysis.degraded), holds the new memory_recall(query, limit) tool (injected only with memory: true), and consolidates its memory when a run ends, whatever its outcome, under Orkeon:CrewMemory:ConsolidateOnRunEnd (false). No YAML key: the analysis cost is the operator's. Without the setting nothing changes.
  • Orkeon:CognitiveMemory:Profile names the LLM profile the analyzer, the contradiction detector and the consolidator run on, so their calls are metered like any other (they took the root provider, off the meter).
  • [breaking] ICognitiveMemoryService is registered as a singleton (was scoped): resolve it from the root provider. MemoryCoordinator's constructor takes a trailing ICognitiveMemoryService? cognitiveMemory, and TaskToolbelt.Compose a trailing bool memoryEnabled: a caller that built either by hand recompiles. IMemoryCoordinator.FinishRunAsync is a default interface method.

Added — a browser for the agents

  • firefox, a built-in tool of Orkeon.Tools.Web: the Firefox installed on the machine, driven over WebDriver BiDi on a WebSocket — no driver, no vendor package, no browser download. One action argument: navigate, back, snapshot, read, find, search, click, type, press, evaluate, screenshot, tabs, new_tab, switch_tab, close_tab, close; the reading actions pass in plan mode, screenshot is an edit, the others executions. A page is read as a semantic graph (PageOutlineMapper in Orkeon.Analysis, the new UniversalNodeKind.Control) in a RaggableTree of its own, whose node ids (p2#7) the next actions take; search embeds the sections of the page as an ephemeral RAG collection and names the section each hit belongs to. One browser per agent run, closed with the run, on a disposable profile unless Orkeon:Tools:Firefox:Profile names one of the host's Firefox (AllowedProfiles are the ones an agent may ask for with the profile argument, DeniedProfiles the ones no browser ever starts on); SharedInstance gives the host one browser per profile, shared between the runs, each driving tabs of its own (tabs, new_tab, switch_tab, close_tab); Lifetime: host keeps the browser, its tabs and its profile from one run to the next - one browser per profile, the run bound to the profile of its first action - until close, the user closes the window, or the host stops; the browsers belong to the host, whichever tool instance a crew resolved, and the disposable folders no Firefox holds are removed when a new one is created (#296). The window is visible unless Orkeon:Tools:Firefox:Headless is set or the machine has no display. Every address, the ones a click lands on included, goes through the host's URL policy. An answer carries only the lists the action produced: nodes, hits, tabs and dialogs are absent, never empty, when the action did not fill them. Guide: docs/guides/firefox.md.

Changed — Streamable HTTP client, subscriptions and reference-server interop for MCP (FWK-17)

  • [breaking] SseMcpTransport is renamed StreamableHttpMcpTransport (no alias) and is a real Streamable HTTP client (FWK-17): an SSE answer is read event by event instead of keeping its last data:, the Mcp-Session-Id is kept and sent back, a 404 on a session replays the initialize handshake, a legacy session opens a GET stream resumed with Last-Event-ID, and a request of the server is answered -32601. Its constructor takes a trailing TimeProvider. McpServerConfig.Transport keeps the value Sse, which means Streamable HTTP; the HTTP+SSE transport of 2024-11-05 with a separate endpoint is not supported. McpClient gains ListenAsync (subscriptions/listen), SubscribeResourceAsync and UnsubscribeResourceAsync; McpToolProvider keeps the listen stream open on a modern HTTP server and gains SubscribeResourceAsync and ReadResourceAsync (cached for subscribed resources, invalidated by resources/updated); McpCapabilityInfo gains Subscribe. The nightly runs McpReferenceServerInteropTests against server-everything. McpClient.ReadResourceAsync returns McpResourceReadResult (the spec's contents array) instead of McpToolCallResult, which read an empty content from a real server; resources/read now sends Mcp-Name (the uri) as the 2026-07-28 revision requires. McpToolProvider also gains UnsubscribeResourceAsync; a ping of the server is answered with an empty result on HTTP. Migration: replace SseMcpTransport by StreamableHttpMcpTransport, and read Contents instead of Content after a resource read.

Added — authentication, tool filter and call timeout for MCP servers (FWK-03)

  • MCP:Servers:<id> gains Auth (None, Bearer, Basic, credentials read from the environment variables it names on every request), Headers (literal or env:VAR; an Authorization header is refused), Tools:Allow / Tools:Deny (applied before registration; an entry that matches no tool warns) plus CallTimeout (60 s; expiry ends the call as a typed tool error, McpCallTimeoutException) and ConnectTimeout (30 s, the handshake and tool listing of any caller). Non-positive timeouts, and Auth or Headers on a Stdio server, are refused; the shared client follows no redirect. An invalid server is set aside at startup with an error naming the key. The HTTP transport uses the shared orkeon-mcp client, excluded from the LLM exchange log.
  • [breaking] McpServerConfig gains Headers, Auth, Tools, CallTimeout and ConnectTimeout; the constructors of McpToolProvider (IHttpClientFactory?), StreamableHttpMcpTransport (IMcpRequestAuthenticator?, named SseMcpTransport until FWK-17) and McpToolAdapter (TimeSpan? callTimeout) each take one more optional parameter, so the three signatures change; McpServerStatus gains UnmatchedToolFilters.

Changed — one run identity and a configurable checkpoint store (FWK-01) [breaking]

  • A run has one identifier, an ExecutionId: the checkpoint session id, the correlationId of the events orkeon run --events writes, and the id KickoffAsyncNoWait returns (it used to create one, then let KickoffAsync create another). KickoffOptions.ExecutionId, CrewKey and Resume carry what the caller decides, through the new ICrewOrchestrationService.KickoffAsync(crewId, input, options, ct); IRunScope (AsyncLocalRunScope, registered by AddOrkeonInfrastructure) shows the run in flight to decorators and observers.
  • [breaking] ICheckpointManager.StartSessionAsync(string crewId) is StartSessionAsync(ExecutionId sessionId, string crewKey): the session id is the run's id, no longer a new Guid. ICrewOrchestrationService has a new member (the kickoff with options): implementers add it.
  • [breaking] SessionState.CrewId and SessionSummary.CrewId are CrewKey: the stable key of a crew (its name, or name and virtual path of its file), the ids of a crew and its tasks being regenerated at each load. IStateStore.GetLatestForCrewAsync, ICheckpointManager.GetLatestCheckpointAsync and IResumeEngine filter on it. The SQLite and PostgreSQL column crew_id is crew_key, with no migration: a database written by an earlier build is not read.
  • [breaking] AddOrkeonSqliteCheckpointing and AddOrkeonPostgresCheckpointing replace the registered IStateStore (Replace) instead of leaving the in-memory store in place after AddOrkeonInfrastructure (TryAdd). ICheckpointManager and IResumeEngine stay TryAdd.
  • Orkeon:Checkpointing (Enabled, Store memory, json, sqlite or postgres, Path, ConnectionString) chooses the store: AddOrkeonCheckpointing(IConfiguration). orkeon run and orkeon-host read it, and Orkeon:ExecutionState:Persistence with it; json and sqlite write under ./.orkeon/state, mounted at /state (RunnerVirtualRoots.State).
  • OrkeonEventWriter fills correlationId from IRunScope when an event names none (an additive field of the JSONL envelope): orkeon run --events opens the run's identity before run.started, so every line of the stream, the lifecycle ones included, carries the id of the checkpoint session.
  • [breaking] ICrewOrchestrationService gains two members: KickoffAsync(crewId, input, options, ct) and KickoffStreamingAsync(crewId, input, options, ct).
  • RunnerMountPlan.WorkingDirectory names the folder ./.orkeon/state is resolved against (the process's by default); the host plans /state itself, whichever command builds it, and the store reaches it through the privileged view of the file system (an internal mount). Orkeon:Checkpointing:Store without Enabled: true is ignored, with a warning at the host's start.
  • Not unified yet: the A2A task id and the API's (StateStoreA2ATaskStore keeps its __a2a__ key, FWK-14), and the crew key is the crew's name, or its name and virtual path when the host knows the file (FWK-07).

Changed — the permission gate reaches the YAML crews [breaking]

  • ToolInvocationPipeline consults the IPermissionGate (FWK-06), after the Guardian, for the calls of an agent: YAML crews are gated as scripts are, once Orkeon:Security:PermissionGate:Enabled is true. It is the one place the gate is consulted for a call: ctx.llm.act no longer asks it itself when the host hands the facade a pipeline that gates (IToolInvocationPipeline.GatesPermissions; it still does without one), so an approval is put once: an onToolCall that answers ask goes to the pipeline as a call to approve (ToolInvocationCaller.RequireApproval), and the script's clock and wall-time budget stop while the pipeline waits for the gate or an operator (ToolInvocationCaller.WaitScope). The pipeline takes permissionGate, approvalChannel and defaultMode (a constructor change); ToolInvocationCaller carries PermissionMode and GateExempt. An ask with no approval channel is a refusal. The delegation tools, orkeon mcp serve and the forge's assistant are not put to the gate.
  • permissionMode on a YAML agent (default, acceptEdits, bypassPermissions, plan, dontAsk), AgentBuilder.PermissionMode, Agent.PermissionMode and the Orkeon.Domain.Security.PermissionMode enum; Orkeon:Security:PermissionGate:DefaultMode for an agent that declares none.

Added — running a crew without a model

  • Provider: mock: an LLM profile (or the Llm section) written "Provider": "mock", "Responses": "<virtual path>" answers from a JSONL file of {match, regex?, content, toolCalls?} lines through JsonlMockLlmProvider (Orkeon.Infrastructure.LLMs.Mock): offline, deterministic, streamed as one chunk, tool calls rendered in the OpenAI response shape. LlmProviderKeys.Mock is not one of the sixteen providers. Provider takes no other value.
  • The mock matches a prompt's lines in order of rounds (one line per round of tool results, so successive tool calls are scriptable, and a script that runs out fails instead of looping), substitutes $1 / ${name} in content for a regex line, fails a call on an unreadable file, a timed-out pattern or a malformed line (its number is named), streams as one chunk (an error throws), and logs one warning per mock provider built, naming the profile.
  • orkeon run --llm-mock <file> turns every profile of the run into that mock; the file's folder is mounted read-only at /llm-mock ([breaking] RunnerVirtualRoots.LlmMock joins RunnerVirtualRoots.All: a user mount may not claim it) and may hold neither the crew nor the script. The pre-run endpoint probe is skipped.
  • orkeon run --test binds the global test (test.mockLlm, test.mockTool, test.assertLlmCalled, test.assertToolCalled) in a procedural script, over a TestOverrideLlmProvider that wraps the configured provider: an expectation of test.mockLlm is served before the profile. Without the flag there is no test; on a YAML crew, a crew directory, a declarative script or --validate the flag is refused (exit 1) rather than ignored. TestOverrideLlmProvider keeps the streaming of the configured provider. Typings/test.d.ts declares it, and the typings parity test covers it. JsEngineFactory.EnableTestNamespace is the switch.
  • MockLlmProvider.When(string | Regex).Respond(...) and MockTool.When(string | Regex).Respond(...): a public builder for .NET tests; AddExpectation stays internal.
  • scripts/validate-all-examples.sh --llm-mock runs the examples that have an examples/mock-responses/<example>.jsonl — one per orchestration mode: sequential, parallel, hierarchical, consensual, graph and autonomous (examples/autonomous-budget) — and keeps --validate for the others.

Changed — the LLM provider factory takes the file system [breaking]

  • [breaking] LlmProviderFactory's constructor takes an IFileSystemService as its third parameter (the mock provider reads its responses file through it): new LlmProviderFactory(httpClientFactory, loggerFactory, fileSystem, ...). The container registers it over the privileged view of the file system. LlmProviderFactory.WithoutMounts(...) builds one for a tool that only looks at a provider (orkeon doctor, orkeon llm probe).
  • [breaking] Llm:Provider and Llm:Responses (and the same keys of each profile) are now read; Provider other than mock is refused at load.

Added — notifications, pagination and prompts for the MCP client (FWK-10)

  • tools/list, resources/list and prompts/list follow nextCursor (100 pages at most, then InvalidOperationException); a server that paginates is no longer truncated.
  • A frame of the server without an id reaches IMcpTransport.Notifications instead of being dropped (bounded channel of 256, DropOldest, with a warning); a request of the server to the client is answered -32601.
  • notifications/tools/list_changed: McpToolProvider lists the tools again after 500 ms, unregisters the tools the server dropped, registers the new ones, and ignores a name another tool holds with the warning mcp.tool.rejected. A task in progress keeps its tools.
  • McpClient.ListPromptsAsync and GetPromptAsync, McpToolProvider.ListPromptsAsync and GetPromptAsync, and the built-in tool mcp_prompt_get (Orkeon.Infrastructure, 124 tool classes), registered by AddOrkeonMcp.
  • IToolRegistry gains ReplaceToolAsync(current, replacement), an atomic swap (a default implementation unregisters then registers); ToolRegistry overrides it.
  • [breaking] IMcpTransport (experimental, ORKEXP004) gains Notifications; McpToolProvider takes an optional TimeProvider as its last constructor argument. Sampling, roots and elicitation stay out: a server request for them is answered -32601.

Changed — compatibility shims removed [breaking]

The 1.0.0-rc.* line removes compatibility shims directly, with no [Obsolete] step (CONTRIBUTING.md, "Deprecation window (from 1.0)"): every shim an audit of the repository confirmed is gone, each public removal is gone from the PublicAPI.Shipped.txt of its project, and the table below gives the migration. The shims the audit kept (the flat crew triplet, the HttpToolBase constructors without a validator, IStateStore's default methods, the MCP protocol eras) are documented as current forms.

Hosting and configuration

  • [breaking] The examples/_shared/appsettings.json settings fallback is removed: RunnerSettings.ResolveSettingsPath walks up from the crew directory looking only for appsettings/appsettings.json. Move a _shared/appsettings.json to appsettings/appsettings.json, or pass --settings.
  • [breaking] Retired settings keys are no longer refused with a migration hint: Memory:ConnectionString, Orkeon:Rag:ConnectionString, Orkeon:Rag:ProviderOptions, Orkeon:Pinecone:Environment, Orkeon:TypeSafe:Guard, MCP:EnableServer, Telemetry:ExportToConsole, Telemetry:PrometheusEndpoint and the RaggableTree keys Exclude, RootAlias, IndexMode, EnrichWithLlm, IncludeStatements fall under the generic refusal (<key> is not a setting: <section> carries ...). Delete the key; connect memory and RAG stores from the section of their provider (Orkeon:Redis, Orkeon:Sqlite, Orkeon:ChromaDb, Orkeon:Pinecone:Host, Orkeon:LanceDb), put the guard under Orkeon:Guardian:Llm, send telemetry to an OTLP collector (Telemetry:OtlpEndpoint), start an MCP server with orkeon mcp serve, pass index options to each index_codebase call.
  • [breaking] AddOrkeonMcp and AddOrkeonMcpServer no longer throw a dedicated InvalidOperationException for MCP:EnableServer, nor AddOrkeonTelemetry for Telemetry:ExportToConsole / Telemetry:PrometheusEndpoint: a C# host that never runs the start validation ignores those keys.
  • [breaking] AddOrkeonCliTerminalGui(Action<TerminalGuiOptions>?) is removed; AddOrkeonCliTerminalGui(TerminalGuiOptions? options = null) is the one overload, and a null options registers the defaults.

Domain, application and infrastructure

  • [breaking] LlmConfig.Gpt4, Gpt4WithSecret, Gpt35Turbo and Gpt35TurboWithSecret are removed: LlmConfig.Create(model, apiKey) with the model named.
  • [breaking] ToolSchemaGenerator.GenerateReturns (both overloads) is removed: GenerateReturnsWithTypes<T>().Returns.
  • [breaking] AgentSelectionResult.SelectedAgent and Score are removed: SelectedAgentId and ConfidenceScore. CrewInput.Parameters is removed: CrewInput.Variables.
  • [breaking] Deconstruct is removed from LlmMetadata, TypedTaskExecutionContext, AgentStepContext and StepMetadata: read the properties by name.
  • [breaking] Orkeon.Domain.Common.Identity<T> is removed: the EntityId<T> ids (AgentId, TaskId, ...).
  • [breaking] ToolBase.ExecuteCoreAsync(string, CancellationToken) is removed: override ExecuteCoreAsync(ProtocolToolCallRequest, CancellationToken); ExecuteAsync(string) converts the string into a protocol call.
  • [breaking] WebPageLoader no longer accepts the web kind: url.
  • [breaking] The [Obsolete] ProcessIsolationSandbox alias is removed: HostProcessRunner (its file is now HostProcessRunner.cs).
  • [breaking] The IPerformanceMetrics port, PerformanceMetricsCollector and their records (PerformanceReport, AgentMetrics, ToolMetrics, LlmMetrics, ProviderMetrics, MemoryMetrics, OperationMetrics, DurationStatistics) are removed, with the AgentExecutionService constructor parameter that took the port. Metrics come from OpenTelemetry only.
  • [breaking] The flat AgentStep.CreateSuccess(output, structuredOutput, agentId, taskId, action, input, toolsUsed, context), the flat ExecutionMetadata constructor and the flat ExecutionSnapshot constructor are removed: pass AgentStepInfo, ExecutionTimingInfo + ExecutionIdentityInfo, and ExecutionStatusInfo + ExecutionTiming.
  • [breaking] Application.Execution.TaskOutput.RawOutput is removed: Content. FunctionCallInfo and LlmMessage.FunctionCallInfo are removed: LlmMessage.RawToolCalls.
  • [breaking] TokenBudgetTracker.EstimateCost(int, int, string) is removed: EstimateCost(prompt, completion, model, registry) (registry: null keeps the built-in table).
  • [breaking] IncrementalReindexTool takes an IndexFreshnessService, now required; the constructor with a store and a builder factory, and its fallback path, are removed.
  • [breaking] IncrementalReindexRequest loses Languages and EnrichWithLlm (languages and enrich_with_llm of incremental_reindex): only the removed fallback path read them; a refresh takes root_path with changed_files or from_commit/to_commit.
  • [breaking] Tolerant enum converters read names only: a JSON number is refused for every enum, flags enums included, with the list of valid names. ImmutableArrayEnumTolerantConverter<TEnum> and its registration in JsonComponentSerializer are removed, with its coercions (a scalar read as a one-element array, null as an empty array, an array encoded as a JSON string). Tool and evaluator I/O now reads arrays of enum names through the default serializer only, which expects a JSON array of names; there is no public replacement.
  • Orphan #pragma warning disable/restore CS0618 lines (no obsolete member behind them) are removed from the LLM providers, the orkeon CLI commands and the tests.

Analysis

  • [breaking] InlineFqnValidationResult loses its positional constructor (ExtractedFqns, UnknownFqns): the object initializer.
  • [breaking] edge_kinds of dependency_graph, sub_graph, flow_trace and edge_list no longer falls back to EdgeKind member names: extends and implements are canonical workflow names (GraphKindNames.EdgeKindNames is contains, calls, imports, inherits, extends, implements, tests, documents, project_depends), so a script sends back the edges[].kind it read; ProjectDepends is refused as an unknown name, send project_depends. Names stay case-insensitive. The tool schemas and tools.generated.d.ts drop the "Legacy enum names … are still accepted" sentence.
  • [breaking] Orkeon.Analysis.Abstractions.Interfaces.IEmbeddingProvider gains string? ModelName (default null): an implementation overrides it to have its model recorded (see Fixed below). The index_codebase cache key carries that model name: an existing cache entry misses once and is rebuilt.

Scripting

  • orkeon-cli.d.ts no longer announces aborted / throwIfAborted aliases on CommandSignal: only the PascalCase members exist at runtime.
  • Comments that described current code as "legacy" or "for backward compatibility" now say what it does: JsCrewConfigurationAdapter (.withAutonomousTool(...) takes tool instances; .expect({...}) fills Context["expect_schema"], read by the hierarchical manager prompt), ToolsNamespaceBinding, the esbuild probe (the "main-package" layout node_modules/esbuild/bin, in its error message and three test names too), ScriptCommandLoaderOptions and its registration.

Docs and tooling

  • CONTRIBUTING.md (and CONTRIBUTING.fr.md): the deprecation window applies from 1.0; during the 1.0.0-rc.* line a shim is removed directly, with a *REMOVED* line and a **[breaking]** entry.
  • Comments and docs that called a current form "legacy", "deprecated" or "backward-compatible" say what it is: the apiKey parameter of LlmConfig (kept; ApiKeySecretName is preferred), the constructors of HttpToolBase, HttpToolBase<TRequest, TResponse> and HttpApiTool that take no IUrlValidator (the fail-closed default SSRF guard applies), the decision reranker (no typesafe alias), the S107 pragmas of the flat Crew, Agent, TaskOutput and MemoryMetadata forms, CrewInput's positional constructor, the defaults of docs/reference/opt-in-subsystems.md, and the flat crew.yaml + agents.yaml + tasks.yaml triplet, a supported layout YamlCrewExporter writes.
  • scripts/lint-example-configs.py: the dead runner parameter of manifest_from_list_tools is removed.
Before After
_shared/appsettings.json found by the walk-up not read; appsettings/appsettings.json only
MCP:EnableServer refused naming orkeon mcp serve generic unknown-key refusal
Telemetry:ExportToConsole / PrometheusEndpoint refused naming OTLP generic unknown-key refusal
Memory:ConnectionString, Orkeon:Rag:ConnectionString, Orkeon:Rag:ProviderOptions, Orkeon:Pinecone:Environment, Orkeon:TypeSafe:Guard refused with a migration generic unknown-key refusal
RaggableTree:Exclude / RootAlias / IndexMode / EnrichWithLlm / IncludeStatements refused naming index_codebase generic unknown-key refusal
services.AddOrkeonCliTerminalGui(o => o.X = ...) services.AddOrkeonCliTerminalGui(new TerminalGuiOptions { X = ... })
{DynamicResource WarningBrush} WarningInkBrush (text), WarningIconBrush (icon, stroke)
SandBrush, FieldLineBrush removed (no consumer; FieldBorderBrush for fields)
LlmConfig.Gpt4(key) / LlmConfig.Gpt35Turbo(key) (and …WithSecret) LlmConfig.Create("gpt-4", key) / LlmConfig.Create("gpt-3.5-turbo", key)
ToolSchemaGenerator.GenerateReturns<T>() / GenerateReturns(type) ToolSchemaGenerator.GenerateReturnsWithTypes<T>().Returns
result.SelectedAgent / result.Score result.SelectedAgentId / result.ConfidenceScore
input.Parameters (CrewInput) input.Variables
var (a, b, ...) = metadata; metadata.A, metadata.B
Identity<T> EntityId<T> (AgentId, TaskId, ...)
override ExecuteCoreAsync(string input, ct) override ExecuteCoreAsync(ProtocolToolCallRequest request, ct)
kind: "web" (WebPageLoader) kind: "url"
ProcessIsolationSandbox HostProcessRunner
IPerformanceMetrics / PerformanceMetricsCollector / PerformanceReport and its records OpenTelemetry metrics
AgentStep.CreateSuccess(out, so, agentId, taskId, ...) AgentStep.CreateSuccess(out, so, new AgentStepInfo(agentId, taskId, ...))
new ExecutionMetadata(start, end, max, id, parent, ...) new ExecutionMetadata(new ExecutionTimingInfo(start, end, max), new ExecutionIdentityInfo(id, parent), ...)
new ExecutionSnapshot(id, crew, status, progress, task, error, start, end, meta) new ExecutionSnapshot(id, crew, new ExecutionStatusInfo(status, progress, task, error), new ExecutionTiming(start, end), meta)
taskOutput.RawOutput (Application) taskOutput.Content
message.FunctionCallInfo / FunctionCallInfo message.RawToolCalls
TokenBudgetTracker.EstimateCost(p, c, model) TokenBudgetTracker.EstimateCost(p, c, model, registry)
new IncrementalReindexTool(store, builderFactory, ...) new IncrementalReindexTool(freshnessService, gitDiff, logger)
incremental_reindex with languages / enrich_with_llm the arguments are refused: drop them
ImmutableArrayEnumTolerantConverter<TEnum> none; arrays of enum names are read by the default serializer (no scalar, null or string-encoded array coercion)
"edge_kinds": 3 / "level": 1 "edge_kinds": "imports, calls" / "level": "L1_Package"
new InlineFqnValidationResult(extracted, unknown) new InlineFqnValidationResult { ExtractedFqns = extracted, UnknownFqns = unknown }
edge_kinds: ["ProjectDepends"] edge_kinds: ["project_depends"]
edge_kinds: ["Extends"] / ["Implements"] (fallback on EdgeKind names) edge_kinds: ["extends"] / ["implements"] (canonical, any case)
an IEmbeddingProvider without a model name override ModelName to have the model recorded

Fixed — bugs found while removing the shims

  • CreateTaskCommand.AgentId and the agent ids of CreateCrewCommand accept a ULID, the form every AgentId prints, and still a GUID: CreateTaskCommandValidator and CreateCrewCommandValidator refused ULIDs, and the crew validator let Guid.Empty through to a handler that threw. A ULID is accepted only when it is Crockford base32 that fits 128 bits (Ulid.TryParse decodes any 26 characters into some id); the validators' error reads is not a valid agent id (a ULID or a GUID).
  • The embedding model an index records (embedding_stats.model of index_codebase) is the one the embedding provider names (IEmbeddingProvider.ModelName: the OpenAI, Ollama and local providers return theirs, LocalEmbeddingProvider.EmbeddedModelName = bge-micro-v2, or the ModelPath when set), no longer the request's embedding_model default text-embedding-3-small while the host embeds locally with bge-micro-v2; the request's value is recorded only when the provider names none.
  • The RAG ingestion pipeline records the same name: AnalysisEmbeddingProviderAdapter takes the inner provider's ModelName before its analysis-embedding default, so a local index built through Orkeon.Rag no longer records analysis-embedding for bge-micro-v2.

Added — tasks in the thread, palettes and the way back

  • In the split-pane console, tasks launched together read as one group with a branch per task, and the end line of a task says its tools, tokens and time, its glyph coloured by how it ended.
  • A transcript scrolled up offers the way back (↓ more below, by a click or Ctrl+End) and recalls on its first row the prompt that has left the screen.
  • The bar under the prompt shows context N%: what the latest model call of the turn sent, against Orkeon:Cli:Session:ContextWindowTokens (200000 when unset, as for token_budget). It is absent before any call and leaves when the session is emptied. ? on an empty prompt lists the keys, except while a script's ctx.prompt reads.
  • Palettes: the setting Orkeon:Cli:Tui:Theme (Dark, Light, None), NO_COLOR when it is left out, and ctx.setTheme / ctx.theme to change it for the session. A value that names no palette is refused at the start. A selection follows the palette.

Added — markdown in the transcript

  • In the split-pane console, an assistant's reply and ctx.writeBlock markdown show as text: headings, bold, italics, code, links, lists, quotes and tables in a box. A line is styled when it ends, a table when it is complete. Copying a whole line gives back its markdown.

Added — what a tool call changed

  • Terminal: a call to edit_file or file_write shows what it changed in the transcript: numbered rows on red and green lines, the changed words marked, and the counts on the step's summary. ctx.writeBlock patches get the same painting. What the model receives does not change. The change is read from the path the tool reads, under the agent run's root; a file over 1 MiB, a binary or unreadable one, or an entry that is not a regular file (a FIFO, a device) shows the call without its change, and an observer that throws leaves the call and its result alone.

Added — the calls of each step

  • In the split-pane console, the rows above the status line count the calls of the current step and list the latest ones with what they work on, a failed call marked. When the step ends, with the next text or with its task or turn even on a call still open, one line stays in the transcript (Read 1 file, ran 2 shell commands), and ctrl+o on an empty prompt lists the calls of the last one. Only the argument named for each tool reaches the screen; the model's input and the run's stream do not change. The activity sentence counts only the calls no step shows.

Added — a menu of commands above the prompt

  • In the split-pane console, a / at the start of the prompt opens a menu of the commands with their descriptions, which typing narrows (a name that starts with the text first, then an alias, then a name that holds it). The arrows walk it, Tab fills the command in, Enter runs it, Esc leaves it and keeps the text without arming the interrupt. A line recalled from the history does not open it, and Tab keeps its completion elsewhere. A completion source offers it by implementing IReplCommandCatalog.

Added — a selection panel for ctx.prompt and tool approvals

  • In the split-pane console, ctx.prompt opens a panel for select and confirm in place of the prompt rows: a numbered list that moves with the arrows or a digit, the value in force marked, a value adjusted with the side arrows, Enter to answer, Esc to leave. A confirm opens on Yes unless its default is false, and its key line says what Esc answers: its default, or No without one. The draft and the history wait behind it. A choice may be an object (value, label, description, hint, current); title, description, keys, control, cancellable and detailed describe the panel. ctx.interactive says whether it opens: the plain console and a replay keep the numbered lines and read the same answers.
  • A select left with Esc answers null, so PromptResult now includes null [breaking for a script that type-checks it].
  • A tool approval opens the same panel, on Yes, so Enter straight allows that call once: its options answer that question by its id (y, s or n) and never reach a read as a line, Esc denies, / or a letter no option carries hands it to the prompt with the letters typed so far, and it passes before a panel already open. The status line stops repeating a question its panel asks.

Changed — a task that ended leaves the list, and a crew can be the conversation

  • runCrewAsync takes { onMain: true }: in the split-pane console the crew writes its text, calls, diffs and approvals on the main screen, with no row in the list. Its text streams there too. It writes an end line only when it failed or its token expired, a cancel on request runs no completed, Esc Esc reaches it whatever was typed since, and a second such crew launched meanwhile is an ordinary task.
  • The main row shows only beside another task.
  • The turn's summary line (Read 20 files, used session_store ×15…) is gone from the split-pane console: it counted only what scripts call on their own account, the model's calls being in the steps.
  • In the split-pane console, a task that ended no longer stays listed under the prompt: it leaves at the next poll, with its screen, and its end line stays in main. Only the task whose screen is being read stays, until the prompt returns to main.

Changed — installing the REPL from source is documented, and the script says how

  • install-from-source run with the default set on Windows or macOS now ends by saying that -AppSet full / --app-set full adds orkeon-repl, which that set leaves out.
  • The READMEs, the docs index and the CLI reference lead to the install script; Three ways to run Orkeon gains the section "Install the REPL from source", and "Install what you just cloned" is now "Install from source".

Fixed — the status line shows the whole name of a tool

  • The first underscore of a line was read as a hot key: file_write showed as filewrite.

Fixed — a scripted command may wait longer than ten seconds

  • A defineCommand handler still pending after ten seconds failed with Jint's promise timeout while it kept running. When it was waiting on ctx.prompt, that read stayed open and the next read of the split-pane REPL crashed the process (A ReadLineAsync is already in progress). The command profile now leaves cancellation as the only bound on a wait (ScriptingLimitsOptions.PromiseTimeout), and the ExecutionTimeout clock stops while a prompt waits for its answer.
  • With that bound gone, a completed whose promise never settles keeps its file's engine: cancelling the invocation that waits for that engine (Esc Esc, Ctrl+C) ends the wait, and ctx.signal in a completed follows it.

Added — the split-pane transcript paints what it shows

  • A submitted entry sits on a grey bar; what a slash command writes hangs under its echo, on an elbow; a turn of ten seconds or more closes on a dim line with its time and tokens. A copy of a whole prompt line returns what was typed. ADR-017.
  • ctx.writeBlock({ kind: "markdown" | "diff", text }) hands a typed block to a console able to style it (IBlockConsole); any other console writes the source as plain lines.

Fixed — the split-pane console keeps a streamed > and counts the tools of ctx.llm.act

  • A streamed delta ending in > (Map<string>) was read as a prompt and left the transcript for the prompt label. A console now offers IStreamConsole.WriteStream, which ConsoleLlmDeltaSink prefers over Write: a token is never taken for a prompt. Write and its heuristic stay for what the runner writes.
  • ctx.llm.act opens one execute_tool span on the Orkeon.Scripting source per call the model makes, so the activity sentence (Read 1 file, edited 2 files) and the status line's tool state cover a prompt's turn, which they missed. Tool spans now carry their tags from their start, which ToolActivityAggregator.HasOpenToolCall needs: it never read true.

Fixed — orkeon typings writes an orkeon.d.ts that TypeScript parses (#288)

  • The build copies Typings/*.d.ts into the roll-up byte for byte (an inline MSBuild task instead of ReadLinesFromFile/WriteLinesToFile): a line no longer travels as an MSBuild item, whose backslashes Linux turned into slashes, so the *\/ escape of a doc comment (**\/*.cs) no longer becomes *// and closes the comment early. Blank lines of the sources are kept too. The target is skipped when no typings file changed (Inputs/Outputs). Three tests read the embedded roll-up: equal to the sources byte for byte, parsed by esbuild, and scripts/check-scripting-typings.sh typechecks the built roll-up with tsc (--rollup in CI after the build).

Fixed — every tool description says what question it answers, which tool is next and where it stops (#284)

  • The descriptions of file_read, file_write, edit_file, directory_read, grep, glob, shell_command, count_pattern, codebase_search, symbol_detail, sub_graph, flow_trace, impact_analysis, dependency_graph, codebase_map, package_summary, structural_search, structural_rewrite, affected_tests, edge_list, node_read, rag_search and rag_ingest open with the question the tool answers, name the neighbouring tool for the adjacent need and state the bound (max_results, top_k, max_nodes, max_paths, the 10 000-character cut of shell_command). file_read no longer sends .eml files to email_parser; edit_file says that replace_all lifts the "exactly once" rule; rag_search no longer offers 'raggable-tree' as a collection, so a code question goes to codebase_search and never to RAG.
  • shell_command.action publishes its values (run, start_job, job_status, job_tail) as an enum.
  • docs/tools/inventory.md follows the descriptions.

Fixed — a cut analysis result still says what it is, and truncated has one meaning (#283) [breaking]

  • Every analysis response declares truncated, cycles_truncated, next_cursor, total and the counts before its bulky collections, and mermaid_flowchart / dot last: the pipeline cuts a result from the end, so the model kept reading a cut dependency_graph or edge_list as a complete one. A test serialises dependency_graph and sub_graph through the real tool path and asserts the key order.
  • include_mermaid defaults to false on dependency_graph and sub_graph [breaking]: the rendering is for a human reader and doubled the result; a caller that wants it passes include_mermaid: true.
  • AgentDefaults.MaxToolResultLengthOverrides bounds dependency_graph, sub_graph, edge_list, flow_trace, impact_analysis, codebase_map, package_summary, symbol_detail, codebase_search, structural_search, structural_rewrite and affected_tests at 12 000 characters (AgentDefaults.AnalysisToolResultLength) instead of 4 000.
  • directory_read returns 200 entries by default instead of 500 [breaking].
  • truncated means "more results exist than were returned" everywhere: codebase_search, flow_trace, statement_query, dependency_graph and codebase_map said true on a page that was exactly full; they now ask the store for one item past the bound. The rule is in docs/tools/new-tool-pattern.md.

Fixed — every analysis tool publishes its parameter schema, and the typings are rendered from it (#282)

  • ToolSchemaGenerator keeps the request properties carrying [FieldSchema] alone, and the analysis DTOs carried almost none: the model received sub_graph without seeds nor direction, symbol_detail without expand, codebase_search without query, flow_trace, impact_analysis, codebase_map, package_summary, symbol_source, statement_query, complexity_report, index_codebase, incremental_reindex, is_path_indexed, affected_tests, batch_anchors, access_cost, documented_in, documents_of, structural_search (language, paths, glob, max_results, max_files) and structural_rewrite with no parameter at all; session_store, session_snip and progress_report were in the same case. Every request property now carries [FieldSchema] with its description, default and, for a C# enum, its names (direction, scope, level, mode, metric); seeds, query, from, target, fqn, root_path, virtual_path and label are required.
  • A [Flags] enum (symbol_detail.expand) is published as a free string whose description lists the names, one or several joined by commas, instead of an enum map that refused "Members, Callers".
  • Guard: BuiltInToolSchemaTests (Orkeon.Hosting.Tests) reads every tool a run registers and fails, naming the tool and the property, when a public settable property of a typed request is absent from Schema.Parameters; no allowlist. StructuralToolSchemaTests covers structural_search, structural_rewrite, affected_tests, edge_list, sub_graph and symbol_detail.
  • Typings/tools.generated.d.ts is rendered from the published schema (names, required flags, types, enums as literal unions, item properties, descriptions) instead of reflecting the request record, so a script sees exactly what the model sees; | null is kept where the request member is nullable. Regenerated.

Added — ctx.llm.extract takes a system option, a messages form for a re-ask, and sends the schema as json_schema (#285)

  • extract took a prompt string alone, appended its JSON instruction to it and always asked for json_object: no system prompt, no way to re-ask with the refused answer, and a provider validating a JSON Schema never received it. The first argument is now a prompt string, a message array or { messages: [...] } (the forms chat takes), the caller's turns sent in order through ChatAsync. The new system option goes first as a system message carrying the JSON instruction, so the user content is sent untouched; without it the instruction is appended to the prompt (unchanged, GenerateAsync) or to the last user message of the messages form (to a leading system message when there is none).
  • When a schema object is given and the provider declares ResponseFormatSupport.JsonSchema, the call sets LlmResponseFormat.JsonSchema("extract", schema, strict: false) (a hand-written schema rarely carries the additionalProperties: false and full required a strict one needs, which OpenAI would refuse); otherwise json_object as before. An explicit responseFormat on the call still wins, "text" included. Usage is metered under extract as before.
  • chat({ messages: [...] }) sent an empty conversation: the object form is read as the bare array is. Typings: MessageList, ExtractOptions, overloads of chat and extract.

Added — memory_store keeps its typed memory per project across restarts (#286) [breaking]

  • The typed memory behind memory_store (user, project, feedback and reference entries) was held in InMemoryCategoryMemoryStore and died with the process. New FileCategoryMemoryStore keeps it at <Orkeon:Cli:Memory:RootDirectory>/<project slug>/memory.json (default root /workspace/.orkeon/memory), under the same project slug as the session file; read at the first access, written after every mutation, with a persisted next id so an id is never reused after a delete; a missing or empty file is an empty store, an unreadable one is refused and left untouched. New section Orkeon:Cli:Memory (Persist, default off; RootDirectory, must not be blank when Persist is on), bound and judged at the host's start; AddOrkeonSessionTools resolves the file store when Persist is on and the in-memory one otherwise; the REPL turns Persist on when the key is absent, as it does for the session.
  • memory_store gains replace (id, content: retires a stale fact in place, same id and category, created_at set again) and list takes newest_first (created_at descending, then id descending). The descriptions say that add returns id and that every entry carries created_at.
  • [breaking] ICategoryMemoryStore.ListAsync takes (string? category, bool newestFirst, CancellationToken ct) and the port gains ReplaceAsync(int id, string content, CancellationToken ct) -> bool; InMemoryCategoryMemoryStore follows. MemoryEntry serialises in snake case (id, category, content, created_at) in the tool's responses, as every other API-exposed record.

Fixed — session_snip keeps whole turns: retain_count counts turns, not messages (#287) [breaking]

  • session_snip documented retain_count as a number of recent exchanges and kept that many messages: asking for 5 exchanges kept 5 messages, and the cut could fall between a request and its answer or between a tool trace and the answer that used it. retain_count (default 3, unchanged) now counts turns; a turn starts at a user message and owns the tool, assistant and note messages that follow it. The head message is still kept on its own; a buffer holding fewer turns than asked, or no user message, is left untouched; retain_count: 0 keeps the head alone. The truncate operation of session_store follows the same rule.
  • The response gains kept_from (index, in the buffer before the cut, of the first message kept after the head, always a user message; -1 when nothing was removed or the head alone was kept).
  • [breaking] ISessionBufferService.Truncate(int retainTurns) answers a SessionTruncation record (RemovedCount, KeptFromIndex) instead of an int; InMemorySessionBufferService, FileSessionBufferService and every other implementation follow.

Added — edge_list lists every edge of the given kinds across the whole index, paginated; the inheritance graph is complete and resolved (#280) [breaking]

  • New analysis tool edge_list (the 121st built-in tool, the 29th of AddRaggableTreeTools): edge_kinds (required, workflow names), optional root_fqn, cursor and page_size (default 200, at most 1000). It walks the whole index, unlike dependency_graph whose max_nodes bounds the nodes before the edges are collected, and answers edges: [{ from, to, kind, from_id, to_id }] (ends as FQNs and node ids), next_cursor (null on the last page) and total. Edges come in a stable order (source FQN, target FQN, kind, edge id) and the cursor resumes after the last edge returned. root_fqn keeps the edges with an end at or under one node, resolved as codebase_map and dependency_graph resolve theirs: a package or a file by path, a type or a member by FQN with a boundary (Orkeon.Domain no longer matches Orkeon.DomainTests), a namespace by the files declaring it and its name as an FQN prefix, an unknown text as a path and as an FQN prefix. IRaggableStore gains ListEdgesAsync(EdgeListQuery, CancellationToken), answered with an EdgeListPage, and NodeQuery gains RootFqn with the same meaning, so codebase_map and dependency_graph filter by root inside the store and their page and truncated describe the root's subset (a root whose nodes lay past the first page answered nothing). SemanticSearchAsync answers a SemanticSearchResult (Hits, PreFilterCapped) instead of a hit list, so codebase_search reads whether the store capped its prefilter instead of probing it with a second query: an implementation outside the repository adds both. Registered with the other read tools (ModePermissionGate, the standard tool manifest).
  • [breaking] A C# base list draws Implements toward an interface and Extends toward a class, as Java and TypeScript already did. Every C# base was an Extends edge: a query for implements over C# code now finds them, and one for extends no longer lists interfaces.
  • A base named by its short name, when several types declare it, resolves to the declaration in the owner's file, then to the one in the nearest named scope enclosing the owner (a declaration outside any namespace or type encloses nothing), then to the one in a file the owner's file imports (a relative import, a Go or Rust module, a C# using of its namespace), then to the only type left; otherwise no edge is drawn. It was linked to the first declaration found by FQN: in TypeScript, import { Base } from './b' could link /r/a.ts::Base. The declarations of one C# namespace count as one type (a partial type); in a module language each file declares its own.
  • symbol_detail with expand: "inheritance" adds derived_by and implemented_by, the types that extend or implement the symbol, and gives extends and implements as FQNs (they were node ids).
  • [breaking] flow_trace.edge_kinds is a list of workflow names read by GraphKindNames.ParseEdgeKinds, as dependency_graph and sub_graph read theirs: inherits follows both extends and implements, an unknown name is refused naming it, an empty list follows calls. FlowTraceRequest.EdgeKinds is an ImmutableArray<string> (was ImmutableArray<EdgeKind>); a legacy enum name (Calls) is still read.
  • codebase_search sets truncated also when its kind or language prefilter matched more than the 1000 nodes it ranks: the hits came from a cut candidate set and truncated stayed false.

Fixed — the console copies a keyboard selection and takes the terminal's paste over SSH

  • Over SSH (the dotnet driver, no X display) Terminal.Gui reports the REPL pane, not its input field, as the focused view: a selection made with Shift+arrow in the field was invisible to Ctrl+C, which printed its hint instead of copying, and the terminal's own paste (Ctrl+Shift+V, Shift+Insert, bracketed paste) was delivered to the pane, which dropped it. Ctrl+C now reads the field's selection after the focused view and before the transcript, and the pane forwards a paste it receives to the field at the caret.
  • TUI_DIAG=1 also traces every modified key and bracketed paste the driver delivers, the focused view at Ctrl+C, and the surfaces each copy reached and each paste read from.

Fixed — the REPL console opens no context menu

  • A right click in the input of the Terminal.Gui console flashed Terminal.Gui's own TextView context menu open and closed against the right-click paste. MouseClipboardTextView (the input, the transcript and agents panes) no longer passes a right button to the native handler, and its Command.Context (Ctrl+click, the menu's key) does nothing: a right click pastes, nothing else.

Added — ctx.llm.act takes its context apart from the request, so a decision guard judges the request alone (#276)

  • ActOptions.context is seeded as a user message of its own, after system and before the prompt. The prompt stays the last user message, the request the guard and route stages of a decision profile judge: an application that sent context, history and request in one message had the whole block judged, and the context diluted the risk (a prompt injection measured at 0.83 alone fell to 0.42 behind 1.3 KB of context, under a harmless request's 0.30 band). system no longer has to carry a context that changes every turn, and keeps its prompt-cache hit.
  • LlmJudgeGuard still judges an agent's whole input in a crew: the context of a task can carry an indirect injection itself.

Fixed — a [Flags] enum of a tool request or response is written and read by name (#274) [breaking]

  • edges[].kind of dependency_graph and sub_graph was a number (1, 3) while the typings say string: a script comparing it to a name never matched. Every scalar [Flags] enum now goes over the wire as its snake_case member names, joined by , for a combination (imports, project_depends, imports, calls); for EdgeKind these are the names edge_kinds takes. A value that is itself a named member keeps that name (ExpandModes.All is all).
  • Reading is tolerant: case, _, - and spaces inside a name are ignored, a combination is separated by , or | or given as an array, and a number whose bits all belong to members is still accepted. symbol_detail now takes expand: "members" or "callers, callees", which failed with a JsonException; an unknown name lists the valid ones.
  • An ImmutableArray<EdgeKind> writes the same names (project_depends, was projectDepends).
  • GraphCycle.EdgeKind (cycles[].edge_kind) is an EdgeKind again, not a string; on the wire imports, calls (was Imports, Calls). Persisted RaggableTree graphs are untouched: RaggableTreeSerializer keeps its own options.

Added — dependency_graph names the members of each cycle (#272)

  • The response carries cycles: each strongly connected component of the scope as { fqns, member_count, edge_kind }, the largest first, members as sorted FQNs. Until now only metrics.cycle_count reached the caller, which could not say where the cycles were.
  • The list is bounded: max_cycles (default 20) caps the cycles, max_cycle_members (default 50) the members of each, member_count keeps a cycle's size and cycles_truncated says whether either cap cut the list. metrics.cycle_count keeps the full count.
  • The tool description and the GraphMetrics doc comment say which figures cover what: cycles and cycle_count the whole scope, node_count and edge_count the nodes returned (selected by max_nodes, root_fqn and node_kinds).
  • The cycles follow the edge kinds the graph follows. An empty edge_kinds drew edges over imports but searched cycles over every kind and labelled them Calls; both now use imports. A cycle's edge_kind names every kind followed (Imports, Calls), not the first one only.

Fixed — decision profiles in an agent loop: verify judges answers, questions carry instructions, a block reaches scripts typed (#267, #268, #269, #270)

  • A verify stage lets a response that calls tools pass unjudged: in an agent loop each step escalated, since a tool call does not answer the request yet (#267). Steps: "all" judges the steps too; final is the default.
  • The guard and verify questions carry instructions with their criterion (GuardDecisionStage.Instructions, VerifyDecisionStage.Instructions): a System One server built on Liquid's reference code answered 500 to a question without them, and the stage failed open (#268).
  • A blocked call carries decision_profile, decision_stage, decision_risk and decision_reason; DecisionBlockedException.FromResponse reads them, and a text stream throws that exception instead of an InvalidOperationException [breaking]. A script receives a block as a DecisionBlockedError (errorType, profile, stage, risk, reason; onError code decision_blocked) from complete, chat, extract, decide, act and stream, never as an <undefined-llm:…> marker; uncaught, it fails the run with the DecisionBlockedException (#269). JsLlmFacade.complete, chat, extract and decide are now bridged JS functions (JsValue) [breaking]: a C# caller uses CompleteAsync, ChatAsync, ExtractAsync, DecideAsync.
  • The stage log no longer prints (null) for a verdict without a target: stage guard decided Block (…) (#270).

Changed — the decision model serves three providers (TypeSafe, Liquid, Kev); the TypeSafe-only names go [breaking] (UC-01, UC-02, UC-03)

The decision model is no longer TypeSafe's alone. One client, SystemOneDecisionModel, serves TypeSafe, Liquid and Kev on the same System One wire, through three provider descriptors. The host starts with one active provider, named by Orkeon:Decision:Provider or deduced from the settings, logs it, and refuses the ambiguous or unsafe cases at start. The input guard moves to its own section, Orkeon:Guardian:Llm, and signs its verdicts with the active provider's name. Consumers rename:

Before After
AddOrkeonTypeSafe AddOrkeonDecisionProvider
TypeSafeDecisionModel SystemOneDecisionModel
TypeSafeOptions SystemOneProviderOptions
TypeSafeInputGuard LlmJudgeGuard
Orkeon:TypeSafe:Guard:* Orkeon:Guardian:Llm:*
reranker alias typesafe removed: use decision

A settings file still holding Orkeon:TypeSafe:Guard:* is refused at start as an unknown key; the guard lives under Orkeon:Guardian:Llm.

Added: the Liquid provider (Orkeon:Liquid, LIQUID_API_KEY, model d1.1 or d1-ultra), the Kev provider (Orkeon:Kev, KEV_API_KEY optional, default address http://127.0.0.1:8009/v1, never deduced), and Orkeon:Decision:Provider (typesafe, liquid or kev). Both hosted sections, or no section and both keys, refuse the start; a Kev address without an http/https scheme, or a Kev key towards a non-local http address, is refused too. The open d1 weights served behind Kev or another System One-compatible local server are used as Kev.

Changed — IDecisionModel.ListModelsAsync removed [breaking] (R-68, D8)

IDecisionModel.ListModelsAsync is removed from the port and from TypeSafeDecisionModel: nothing called it. The unused DecisionModelDto goes with it. Consumers drop the override.

Fixed — documentation closes on what F1-F8 ship; an empty Orkeon:TypeSafe section registers the decision model (R-16, R-57, R-59 to R-65, R-72, R-74, R-75)

A present-but-empty Orkeon:TypeSafe section now registers the decision model (R-64). The doc corrections: the Anthropic price list and cache tariffs (R-57), the decision-model pages (retry set, reader of a jump's reason, reserved question name defaulted, R-63, R-65, R-75), ADR-015 and ADR-016 amendments, and the RaggableTree tool count gate in scripts/check-doc-claims.py (R-61).

Fixed — the scripting DSL refuses ill-formed decision and when forms at load; a decision-and-when example ships (R-03, R-28, R-30, R-31, R-32, R-34)

Breaking: a second .when() on one task throws an InvalidScriptException naming the task; a non-array state, a non-object fallback and a non-string choice value, score entry or fallback value are refused at load naming the task and the key; two tasks with the same name are refused at load. A task without .name() is keyed by its full description (truncation is display only). task.d.ts documents fallback as strings and the decision model (IDecisionModel), and examples/scripting/14-decision-and-when.ork.ts shows a decision with when fan-out.

Fixed — rate-limit wait, effort and cache refusals at load, Anthropic cost grid (R-09, R-40, R-41, R-42, R-43, R-44, R-45, R-47, R-58)

retry-after-ms now takes priority over Retry-After and is then compared with the reset headers (the longer wins); a value beyond the window raises LlmRateLimitException, never OverflowException. A thinking effort outside low, medium, high, xhigh, max (exact case) refuses the load in the YAML mapper and in Llm:Thinking (LlmThinkingConfig.ValidateEffort) instead of falling back to low; the per-model effort table is deferred (docs/reference/limitations.md). A cache ttl without system or tools is refused by the YAML block as the script and Llm:Cache already did (LlmCacheConfig.Request throws). The chat client adapter drops a host Llm:Cache for a provider whose cache is implicit, so orkeon run no longer logs a cache_ttl warning on every OpenAI call. claude-opus-4-5 (dated ids included) is priced at the official 5 / 25 $/M instead of the claude-opus-4 prefix's 15 / 75, and the 1-hour share of a cache write (usage.cache_creation.ephemeral_1h_input_tokens) is read by AnthropicLlmProvider, buffered and streamed, and costed at 2x the prompt rate: LlmResponse.CacheWrite1hTokens and CostUsageEvent.CacheWrite1hTokens are new (additive).

Fixed — an exclusive launch stays exclusive until its work ends; the host-work memory exclusion holds (R-12, R-48, R-49, R-53, R-54, R-55, R-73)

cancel() no longer frees an exclusive crew: the target is released when the work really stops (the finally of postWork), so a relaunch right after a cancel() is refused until the cancelled run has finished. A synchronous runCrew of a crew held by an exclusive runCrewAsync is refused with ExclusiveLaunchRefusedException like a second runCrewAsync, and exclusive: null is a script error (the option is a boolean or absent). The exclusion of host-tool work from MemoryLimitBytes is closed on every exit of its scope, exception included, survives nesting and Reset(), and belongs to the thread that opened it; the documentation now says that only the execution of a host tool is outside the limit, not the rest of ctx.llm.act. The postWork signature change of #239 is declared as a break.

Fixed — Anthropic replays the signed thinking blocks of a tool-call turn, and a malformed tool call is named (R-08, R-46)

An assistant turn that held thinking or redacted_thinking blocks and tool_use calls was replayed without the thinking blocks, which Anthropic rejects when extended thinking is on. NativeToolCallTranscript.AssistantTurn now keeps them raw, buffered or streamed, in the new LlmMessage.RawThinkingBlocks, and AnthropicLlmProvider re-emits them unchanged and first. A replayed tool call without id, name or an object arguments raises an InvalidOperationException naming its index, its name and the field, instead of a bare KeyNotFoundException.

Fixed — decision tasks: retried dependencies, failure record, answer validation, skipped turns

A Graph decision reads the last successful output of a retried dependency, else its last attempt. A failing decision is recorded as a failed output marked as a decision, with its cause, and the exception is logged. The model's answer is validated: a choice outside the options fails the task non-transiently. The output has one form: score answers are keyed by level position and carry no chosen, the fallback included; TokensUsed is the usage the model reports. The domain refuses a non-finite confidence floor and repeated score levels, and TaskCondition.Holds is false for an otherwise clause. A skipped task takes no agent turn in round-robin, a crew of decision tasks only is admitted with no agent, and a failed or cancelled decision stops its dependants in Parallel and Graph. CrewExecutionEvent, the KickoffStreamingAsync stream, gains IsDecision and DecisionAnswers, and the documentation of Skipped and SkipReason cites the when condition.

Fixed — RaggableTree index: gitignore translation, ignore files in the cache, Go importers, SQLite busy (R-04..R-07, R-35..R-39)

respect_gitignore now follows gitignore(5): **/ covers zero directories, a final /** covers all the content, a / at the start or in the middle anchors the pattern, an escaped trailing space is kept; POSIX classes such as [[:alpha:]] stay unsupported. Nested .gitignore files and .git/info/exclude enter the cache validity markers (a change forces a full rebuild) and the incremental path skips ignored paths. After a refresh, unchanged Go importers of a package that gains a file are re-resolved. A Rust use super::* inside an inline mod no longer draws a wrong import edge. Only SQLITE_CORRUPT / SQLITE_NOTADB erase the cache database: a busy or locked base abandons the save and keeps it. A refused go.mod or package marker read counts as absent, and parallel Parse progress is monotonic. DiscoveryResult (Orkeon.Analysis.Abstractions) gains IgnoreFileContents.

Fixed — session_store access per operation, atomic multi-key writes; grep completeness flags (R-10, R-11, R-50, R-51, R-52, R-56)

SessionStoreTool declared the same access for every operation, so plan mode admitted set_state, append_message, reset and truncate: reads (get_state, read_messages, get_metadata) now declare Read, every write declares a write access and is denied in plan mode. set_state with several values / keys goes through the new ISessionBufferService.SetStates(IReadOnlyDictionary<string, string?>), which changes every key under the buffer's one lock (all or nothing; breaking for any other implementation of the port, which must add the method); a values / keys overlap, or key / value mixed with values / keys, is refused with the keys named. grep: truncated is true when count mode cuts its counts, and scan_complete is false when a file over 1 MiB was skipped.

Added — session_store reads several keys, writes several, appends one message (#263)

A script paid one session_store call per state key it read, and two calls carrying the whole buffer for every message it added. get_state now takes keys: string[] and answers values, one entry per key that is set (a key never set is absent, undefined in a script); set_state takes values: { key: value } to write several keys and keys: string[] to remove several (the tool pipeline drops a null value, so removal goes through keys); key and value keep working as before. The new append_message operation (role, content, an optional timestamp) adds one message at the end of the buffer, which is neither returned nor rewritten; ISessionBufferService gains AppendMessage(SessionMessage) for it.

Added — grep counts: output_mode: "count", total_matches on every answer (#260)

A "how many" question over a tree took one grep call per file, or a hit list far too long for a single number. grep now takes output_mode ("hits", the default, or "count"). In count mode the answer carries no hit line: total_matches, files_matched and counts, the per-file counts highest first, cut to max_results entries. In both modes total_matches and files_matched are returned, and scan_complete says whether every candidate file was scanned to its end: reaching max_results no longer stops the scan, only max_files or a timeout does, so a total read with scan_complete: true is exact even when the hits were cut. truncated says when hits, files or counts were left out (count mode cutting its counts at max_results or at the character budget reports it too, and scan_complete is false when a file over 1 MiB was skipped). The default hits mode keeps scanning to max_files or to the 20 s budget even after max_results is reached, so a wide tree can end timed_out or truncated.

Fixed — Anthropic pricing: Haiku 5.x priced, the prompt cache at its own rates (#257)

ModelPricingRegistry had no entry for claude-haiku-5*, so a Haiku 5.5 call counted as unpriced, and no Anthropic entry declared CacheWritePricePerMillion / CacheReadPricePerMillion, so a cached call paid the full prompt rate on every token. Every Anthropic entry now carries both rates (a write at 1.25x the prompt rate, a read at 0.1x, or the vendor's own figure: 0.20 $/M on Opus 5.5 and Sonnet 5.5, 0.25 $/M on Fable 5.1), claude-haiku-5 is priced at 0.10 / 0.50, and claude-opus-5-5 (4 / 20) and claude-opus-4-6, -4-7, -4-8 (5 / 25) get their own entries since the claude-opus-5 and claude-opus-4 prefixes overcharged them. The write rate is the 5-minute TTL's, 1.25x; the 1-hour share of a write is costed at 2x since the rc.6 review (R-47, below).

Added — a script agent can request the prompt cache (#254)

agentBuilder().cache({ systemPrompt?, tools?, ttl?: "5m" | "1h" }) and the cache key of LlmConfig.with({...}) request Anthropic's cache_control breakpoints as the YAML llm.cache: block does: both map onto the same LlmCacheConfig through LlmCacheConfig.Request. A TTL other than 5m/1h, an unknown key, a non-boolean flag or a ttl with nothing marked cacheable throws a script error; an object marking nothing turns an inherited cache off. The typings declare LlmCacheOptions. The YAML ttl is now validated too: a value other than 5m or 1h is refused when the crew loads instead of reaching the vendor.

Changed — an unreported cache or reasoning count is null, not 0 [breaking] (#254)

ModelUsage.CacheReadTokens, CacheWriteTokens and ReasoningTokens are long?: null when no call reported them, the sum of the reported ones otherwise (null + 5 = 5, ModelUsage.SumReported). The same holds for CommandInstanceUsage, the usage service's report() (cacheHitTokens, cacheWriteTokens, reasoningTokens are number | null) and session_stats by_model_tokens[], which gains reasoning_tokens and leaves an unreported count out instead of writing 0. A /usage command that printed the count prints n/a for null.

Before After
ModelUsage.CacheReadTokens / CacheWriteTokens / ReasoningTokens : long (0 when unreported) long? (null when unreported)
CommandInstanceUsage.CacheHitTokens / CacheWriteTokens / ReasoningTokens : long long?
ScriptUsageReport, ScriptModelUsage, ScriptCommandUsage cacheHitTokens / cacheWriteTokens / reasoningTokens : long long? (number \| null in orkeon-cli.d.ts)
ModelTokensEntry.CacheWriteTokens / CacheReadTokens : long long?, plus ReasoningTokens (reasoning_tokens)

Fixed — orkeon:cache_ttl alone requests the system-prompt cache (#254)

A per-call orkeon:cache_ttl on an agent with no cache configuration placed no breakpoint, so the lifetime cached nothing. The chat client adapter now treats it as the request: it marks the system prompt with that TTL. A provider that cannot write a TTL keeps logging the structured unhonoured-option warning (event 110, cache_ttl).

Added — a host default prompt cache, Llm:Cache [breaking] (#254)

Llm:Cache:SystemPrompt, Llm:Cache:Tools and Llm:Cache:Ttl (and Llm:Profiles:<name>:Cache:*) set the cache every agent asks for when it sets none of its own. They are validated through LlmCacheConfig.Request: a Ttl other than 5m or 1h, or a Ttl with nothing marked, refuses the load and names the key. The default applies only to a provider whose cache is explicit (ExplicitPromptCaching, Anthropic); elsewhere it is dropped from the provider's BaseConfig and neither reaches the call nor warns. orkeon settings lists the keys. An agent's or task's own cache always wins, and one that marks nothing (cache: {}, cache({}), with({ cache: {} })) is now an explicit Off, LlmCacheConfig.Off, that turns the host default off too; a cache left out inherits.

Before After
YAML cache: {} / script cache({}) mapped to null (inherit) LlmCacheConfig.Off (explicit off, beats Llm:Cache)

Fixed — ctx.llm calls of a procedural agent apply the builder's cache and effort (#254)

A script agent's .cache(...) and .effort(...) (or the cache/effort of the LlmConfig given to .llm(...)) reached its declarative calls only: the procedural ctx.llm.complete(...)/chat(...) calls ran without them. They now run with both, a call's own effort or cache winning.

Changed — the crew pipeline's cache counts are null when unreported [breaking] (#254)

The cache counts carried from the agent loop to the crew result stay null when no call reported them, as ModelUsage.SumReported does, instead of reading 0: AgentLoopResult, TaskResult, TaskExecutionSnapshot, the crew totals and hit ratio, every orchestration strategy (TokenUsageTally, CrewGraphState) and the run metadata, which writes a key only when it was reported (a reported 0 included). The auto summary prints n/a for an unreported count, never 0. This pipeline carries no reasoning count.

Before After
TaskResult.CacheHitTokens / CacheMissTokens : long long?
TaskExecutionSnapshot.CacheHitTokens / CacheMissTokens, CrewExecutionSnapshot.TotalCacheHitTokens / TotalCacheMissTokens : long long?
CrewGraphState.CacheHitTokensUsed / CacheMissTokensUsed : long; AddResultUsage(int, long, long) long?; AddResultUsage(int, long?, long?)

Added — an index cache between sessions (index_codebase use_cache) (#244)

AddRaggableTree now registers CachingTreeBuilder, and index_codebase saves the index under <root>/.orkeon/cache/raggable-tree/index.db, a SQLite database in a folder holding its own .gitignore. The nodes are stored per source file, gzip-compressed, and a refresh rewrites only the files whose nodes changed; the schema (primary keys, the node_runs.group_id foreign key, constraints) is in docs/architecture/raggable-tree.md. The next session reloads it when no file changed (cache: "hit"), reindexes only the changed files when at most half of them changed and no package marker did ("refreshed", with reindexed_file_count), and rebuilds otherwise ("miss"). The key covers the options, the Analysis version and the adapters, summarizer and embedder (with its dimension) the host wires. use_cache: false rebuilds from scratch, then saves ("bypassed"); a tool built without the cache answers "disabled". The database keeps up to RaggableTreeCache.MaxEntries (3) keys side by side and evicts the least recently used. A file whose size and write time match the saved stamp keeps its saved SHA-256 without being read (DiscoveryRequest.KnownFiles, FileStamp, DiscoveredFile.LastModified), as git status does; a file written within two seconds of the discovery is hashed again at the next call.

Before After
IRaggableTreeCache.LoadAsync(root, adapterVersions, embeddingProfile) / IsValidAsync / RaggableTreeCacheLoadResult / EmbeddingCacheProfile LoadAsync(root, cacheKey) returning a RaggableTreeCacheEntry?; SaveAsync(root, entry) returns false when the root cannot be written
new RaggableTreeCache(serializer, discoverer, fileSystem, adapterVersions, embeddingProfile) writing manifest.json and tree.json new RaggableTreeCache(fileSystem) writing index.db; RaggableTreeCache.DatabaseFileName
new IndexCodebaseTool(store, builderFactory, logger) new IndexCodebaseTool(store, builderFactory, cachingBuilder, logger)
DetectedPackage.MarkerFile only (the ecosystem) plus MarkerPath, the marker file under the root

Fixed — a C# using, a Go import and a Rust use draw import edges (#252)

The C#, Go and Rust adapters resolved no import path, so dependency_graph showed no file import edge for these languages and package_summary reported no dependencies for their packages. The dependency graph now resolves them after every file is parsed. A C# using N; reaches the files declaring a type of namespace N whose name the importing file uses, not every file of N (using static N.T; and using A = N.T; reach the files declaring T, a global using counts in the file that holds it); a namespace the tree does not declare goes to an ext::dotnet::N node. A Go import under the module path of a go.mod (read through the VFS, tagged go_module on the package node) reaches the non-test .go files of the directory below it; any other path goes to ext::go::<path>. A Rust use crate::a::b::C reaches src/a/b.rs or src/a/b/mod.rs, the longest prefix that is a module file; super::, self:: and a child module of the current one start from the current module, and any other first segment goes to ext::cargo::<crate>. An incremental refresh rebuilds the import edges of the files it parses again with the same rules.

Fixed — the index reads every ignore file of the tree (#258)

index_codebase applied the root .gitignore alone: a folder named only in .git/info/exclude (a package cache checked out beside the sources) or in a nested .gitignore was walked and parsed. With respect_gitignore (the default) the discovery now applies the ignore files as git does — .git/info/exclude, the root .gitignore, then each nested .gitignore for the paths under its folder, the last matching pattern deciding and a deeper file over a shallower one. A nested .gitignore whose own folder is ignored is not read.

Fixed — package_summary entry points by exact name, .gitignore character classes (#249, #250, #251)

package_summary takes a module as an entry point only when its file name without extension is exactly main, __main__, program or index (#249). Its dependencies come from the Imports edges of the package's modules, mapped to the packages holding their targets (#250). The .gitignore matcher honours character classes ([abc], [a-z], [!abc], [^abc]) and the backslash escape; a [ with no closing ] stays literal (#251).

Fixed — a host tool no longer counts against a script's memory limit (#247)

Jint's LimitMemory reads the allocation counter of the engine's thread, and a tool whose async method completes synchronously (the index cache's SQLite calls, an index build) ran whole on that thread: index_codebase on a large repository charged gigabytes to the script, which failed at random with MemoryLimitExceededException under the 2 GiB trusted ceiling. The engine's memory constraint now leaves out what a host tool allocates on the engine thread, for tools.* and for the tool calls of ctx.llm.act, which reached that thread after a model call that completed synchronously: a tool's work is not counted, however heavy, and --memory-limit-mb 0 is no longer needed for it. The tool still runs where it did, so the order of its effects is unchanged, and the script's own allocations after the call are still counted. The window also holds when a host continuation drives the engine from another thread: what the previous thread counted is kept and the new thread is counted from its own counter, where Jint subtracted one thread's counter from another's and could fail a script that had allocated nothing.

Fixed — the index cache drops the entries of another runtime (#248)

An index cache entry saved by another cache format or Analysis version could never be hit again, yet kept its full share of index.db (about 460 MB on the Orkeon repository) until two newer keys evicted it. cache_entries now holds the runtime that saved each entry (schema version 3: an older database is recreated at the next save), and a save deletes the entries of every other runtime before the LRU eviction. A database whose free pages pass half of its pages is compacted with VACUUM after the save, so the file shrinks back on disk; a compaction that fails leaves the saved entries as they are.

Fixed — Anthropic replays a tool call turn (#245)

On Anthropic, every ctx.llm.act turn and crew agent turn that called a tool failed on its second model call with a KeyNotFoundException: AnthropicLlmProvider replayed LlmMessage.RawToolCalls in the OpenAI shape only ({id, function: {name, arguments}}), while NativeToolCallTranscript stores Anthropic tool_use blocks as received. The replay now accepts both shapes, and the property documents them.

Fixed — incremental_reindex keeps the unresolved calls of the files it does not reparse (#244)

IncrementalReindexEngine dropped every Calls edge to an ext::unresolved::* target whose caller sat in an unchanged file, so a refresh lost them (3129 of 11868 edges on one repository). They are kept now, and the one a reindexed file makes resolvable (a newly defined function) is replaced by the resolved edge: a refresh gives the edges of a full build.

Changed — the dependency graph of an index builds in seconds, not minutes (#244)

DependencyGraphBuilder rebuilt the short-name symbol table for every file, checked each new edge against every edge already found, compiled its tree-sitter queries once per file, and looked an unresolved call target up by scanning every node. It now builds the table and compiles the queries once per resolution and checks duplicates through a set and ids through a dictionary. On Orkeon's own src (3166 files, 45107 nodes, 62758 edges) a full index_codebase build drops from 221 s to 15 s; the tree is byte-for-byte the same (same edges in the same order, same links and tags, same IndexId).

Added — parallel index build (index_codebase max_parallelism) (#243)

index_codebase reads and parses files max_parallelism at a time (IndexCodebaseRequest.MaxParallelism): 0, the default, uses one per processor, 1 parses them one after the other as before, and a negative value is refused with a tool error (RaggableTreeBuilder.BuildAsync throws ArgumentOutOfRangeException). Each file is extracted on its own, then merged in discovery order, so the index is the same whatever the degree: same nodes, same edges, same order, same IndexId. Parse progress reports may arrive out of order. incremental_reindex is unchanged.

Changed — effort takes xhigh and max

The effort of a thinking setting (act({ effort }), the other ctx.llm calls, LlmConfig.with({ effort }), agentBuilder().effort(level), YAML thinking.effort) accepts five levels, low|medium|high|xhigh|max (LlmThinkingConfig.Levels), where the scripting layer refused all but the first three. A provider declares the levels its field knows, LlmProviderCapabilities.EffortLevels (low, medium, high by default; the five for Anthropic and OpenRouter; max without xhigh for DeepSeek and Z.ai), and sends, for a level it does not know, the highest declared level below it (LlmThinkingConfig.EffortFor) with a warning naming both (event 112), never a silent change. The typings of LlmConfigOverrides now declare effort.

Added — model provider categories and TypeSafe decision models (ADR-015)

Model providers now come in four categories (ModelProviderCategory: Generation, Embedding, Reranking, Decision), listed with their key variable and endpoint in ModelProviderCatalog (Orkeon.Constants.Llm). The new Decision category has its own port, IDecisionModel (Orkeon.Application), with typed choice, score, noul and box questions and their answers; AddOrkeonTypeSafe(configuration) binds Orkeon:TypeSafe and serves TypeSafe's Jev (jev-latest, key in TYPESAFE_API_KEY, 429, 5xx, 408 and network errors retried, usage metered as decision, errors citing TypeSafe's request id). TypeSafe is not an LLM provider: the count stays at 16. The three shipped binaries (orkeon run, orkeon-host, orkeon-repl) call it when their settings hold Orkeon:TypeSafe or TYPESAFE_API_KEY is set. AddOrkeonDecisionProfiles(configuration), which the three binaries call in every case, reads Orkeon:Decision:Profiles and registers each one as an LLM profile wrapped in DecisionLlmProvider, whose route, guard and verify stages block, route or escalate a call before and after it, without rewriting the messages or the response (fail-open by default, FailClosed to block). Also opt-in: the agent input guard (LlmJudgeGuard, Orkeon:Guardian:Llm:Enabled), the RAG reranker rerank.kind: decision and the tool system_one_decide. See Decision models.

Added — decision tasks and when conditions (ADR-016)

A task can carry a decision block instead of an agent: it sends typed questions to the decision model in one request and its output is the answers. A later task carries a when condition naming a decision task and the answers it needs (an option under a confidence floor, a threshold on a probability in [0, 1] or on a score read as a level position from 0 to n-1, or otherwise). A false condition skips the task, it does not fail it: the skip reason is recorded, a task whose dependencies were all skipped is skipped too, and a skipped task leaves nothing in a later task's context. Sequential, Parallel and Graph run them; Hierarchical, Consensual and Autonomous refuse them on load, and fail before their first task when a crew built in C# reaches them. orkeon run --no-decision (or Orkeon:Decision:Enabled=false, or no decision model) switches the decision circuit off: decision tasks answer from their fallback; a question the model leaves unanswered fails the task. The task.completed event gains skipReason, defaulted, isDecision and decision (the answers as compact JSON), TaskExecutionSnapshot gains SkipReason, Defaulted, IsDecision and DecisionAnswers, and the run's JSONL shows the skip reason, the defaulted flag and the decision answers. See ADR-016 and Decision models.

Added — an exclusive crew launch [breaking] (#239)

script-host.runCrewAsync(name, input, { exclusive: true }) refuses a crew whose previous exclusive launch is still running, before any LLM call, with a JS throw naming its ticket (crew 'code-review' already running (ticket t2)). The check and the registration of the instance are one step (CommandDispatchService.postWork(..., exclusive: true), ExclusiveLaunchRefusedException); the crew is free again once that instance completes, fails or is cancelled. A command that launches such a crew no longer needs maxConcurrent, which also blocked its aliases. See scripted commands. Migration: the public CommandDispatchService.postWork gains a trailing bool exclusive = false parameter and its previous signature (rc.6) is removed, with no overload; a host that calls it recompiles, and a host that binds it by reflection passes the new argument.

Before (rc.6) After
postWork(label, target, work, bool continueChain = false) postWork(label, target, work, bool continueChain = false, bool exclusive = false)

Changed — TaskCompletedEvent.AgentId is nullable; ParallelProcessStrategy takes CrewStrategyDependencies [breaking]

TaskCompletedEvent.AgentId is now AgentId?: a decision task answered by the decision runner completes without an agent. The public constructor of ParallelProcessStrategy now takes a CrewStrategyDependencies (the way the sequential and graph strategies do); the former eight-argument constructor is internal. A task whose condition names a decision task it does not depend on fails the run at entry, and the parallel run's final output is the output of the last task that ran in declared order. Migration: a consumer reading TaskCompletedEvent.AgentId handles null; a host constructing ParallelProcessStrategy passes a CrewStrategyDependencies.

Before After
new ParallelProcessStrategy(taskRepository, agentRepository, executionService, memoryScope, logger, hook, selector, domainEvents) new ParallelProcessStrategy(new CrewStrategyDependencies(taskRepository, agentRepository, executionService, memoryScope, domainEvents), logger, hook, selector)
string agentId = completed.AgentId; string? agentId = completed.AgentId; (null for a decision task)

Fixed — the rate-limit window reads retry-after-ms

RateLimitResetHeaders reads the retry-after-ms header (milliseconds) that OpenAI and TypeSafe send beside Retry-After, so a 429 announcing a sub-second window is waited out for that window instead of the whole second Retry-After rounds it up to. retry-after-ms replaces Retry-After, the longest of it and the reset headers wins, a value that is not a finite number is ignored, and a finite value beyond the window fails with LlmRateLimitException (R-09, R-43).

Fixed — the orkeon-runners image builds again

Dockerfile.runners copied the root Directory.Build.props but not the root Directory.Build.targets, which src/Directory.Build.targets imports since #195. The import resolved to an empty path, dotnet publish failed with MSB4020 on both platforms, and the v1.0.0-rc.6 run pushed no image to GHCR. The build stage now copies the file.

1.0.0-rc.6 - 2026-10-28

The release candidate of the agent loop and the scriptable runtime. Since 1.0.0-rc.5: agents get file tools made for the loop — edit_file, ranged reads, glob, grep —, structural editing, a working root, background agents, durable memory and sessions (RT-01..44, #136–#179); scripted commands read the runtime that runs them — its version, the session's usage by model and by command, a token budget that counts the context once, a save and load of the REPL's session — and the Orkeon.Scripting package runs a crew.ork.ts inside a .NET application (#224–#229); shell_command runs confined by default — bubblewrap, Seatbelt or an AppContainer (ADR-014) —; the permission gate reads the session's rules and orkeon-repl asks the operator, connects MCP servers, loads plugins and replays a session; RaggableTree indexes JavaScript, Java, C, C++, PHP, Ruby and Bash, and the structural tools serve every grammar; agents reach Google Drive and OneDrive (DRIVE-01..07); the console takes a Claude-Code-like bottom area, Esc Esc interrupts and the split-pane view shows one screen per thread; Orkeon Studio gets one Launch screen with a Trial | Real switch; and a run is a trace, every model call measured once. Many entries below are [breaking]: each one says what a crew, a script or a C# implementer changes.

The public API surface is frozen at this tag: the 2 618 additions and 3 672 removals accumulated since rc.5 move from PublicAPI.Unshipped.txt to PublicAPI.Shipped.txt across the twenty-five projects that carried them, and the ORKCON001 analyzer rule moves to AnalyzerReleases.Shipped.md under ## Release 1.0.0.

Fixed — the Debian smoke starts orkeon-repl with a mount

The deb smoke's repl-start step started orkeon-repl --ui plain with no settings file and no mount, and expected exit 0. Since the REPL refuses a mount it cannot honour at start, as the runners do (GAP-50 to GAP-55, #123), a REPL with no mount at all stops at its start with exit 1 and At least one file system mount must be configured in 'Orkeon:FileSystem:Mounts'. The step was added after rc.5 and first ran on the rc.6 tag, where it failed on amd64 and arm64 and held the Release back. It now mounts its run directory at /workspace, as a user mounts a project (scripts/smoke-onboarding/lib/smoke-common.sh). The REPL itself is unchanged.

Added — CommandResponse.streamed tells a script its answer already streamed (#228)

With Orkeon:Cli:ConsoleStreaming:Enabled, the foreground act streams its answer inline to the console, and a command that then printed the payload printed it twice. CommandResponse (the value of commands.request, the result of completed) and CrewRunOutput (script-host.runCrew) now carry streamed: boolean: true when any turn of the request was written to the console in the foreground (inline, or as whole unprefixed lines when another turn held the inline claim), so the script skips its own print. A background instance (post, runCrewAsync) and a crew task write whole lines prefixed with their ticket or task and report false. The dispatch opens one receipt per agent request and per crew run in that work's async flow, and ConsoleLlmDeltaSink records into it whether each turn was shown; the receipt never goes back to false within a request, so commands running at once each read their own and concurrent turns of one request do not race on it.

Added — budget({ contextTokens }): a token budget that counts the context once (#224)

budget({ tokens }) sums the prompt and the completion of every call, so a turn pays its whole context again at each call. contextTokens, a new key beside it (crewBuilder().budget(...) of a scripted run, the budget option of crew.runAgent and ctx.delegate), counts each call's completion plus, when the provider reports cache hits, the uncached part of its prompt, else what the prompt grew by since the run's previous call: a turn of n calls on a context of c tokens spends about c plus its completions, not n × c. tokens keeps its meaning and stays the default; set alone, contextTokens leaves it uncapped. Its exhaustion is that of tokens — the tokens dimension, the #218 wrap-up with budgetExhausted: true — and its message names the measure: Token budget exhausted: <n> context tokens (...) over <n> calls (limit <limit> contextTokens). A declarative process("autonomous") crew, which counts each finished task's tokens, refuses the key. AgentExecutionBudget gains MaxContextTokens, CurrentContextTokens and RecordTokens(tokens, promptTokens, completionTokens, cacheHitTokens). The refusal of an unknown run-option key now lists contextTokens among the dimensions.

Added — a command saves the REPL's session now, or loads a saved one (#227)

A new session service of *.cmd.ts (ctx.services.get("session"), SessionFacade), served in orkeon-repl while the session is persisted (Orkeon:Cli:Session:Persist, the REPL's default), offers save(path?) and load(path). save() writes the session now to the file and in the shape the REPL writes at exit (<SessionsDirectory>/<project>/last.json) and resolves to its virtual path; save(path) writes it in the same shape to another virtual file instead (a blank path is refused), so load reads it back. load(path) reads a session file the REPL saved, through the virtual file system, and swaps the conversation buffer and the state bag (with the session's id and title) for its own, so the next turn continues the loaded conversation; it resolves to the number of messages loaded. The running command instances are untouched and the session goes on saving to its own file, which the loaded session overwrites at the next save: archive the current one with save(path) before load. A missing file, or one without the shape the REPL writes, is refused whole: the promise rejects and the session stays as it was. A load while another command's turn runs is not supported (the last writer wins). FileSessionBufferService gets SessionFilePath, SaveToAsync(path) and LoadFromAsync(path), which returns the count of messages loaded.

Added — scripted commands read the version of the runtime that runs them (#225)

ctx.services.get("runtime") answers { version, commit, channel }: the release as orkeon doctor prints it (1.0.0-rc.6), the commit sha of its build metadata (null when there is none), and the channel the runtime was installed through, read from the installation's INSTALL-CHANNEL marker (unknown when nothing names one). The key is always present; orkeon-repl registers its own ScriptRuntimeInfo, and a host that registers none answers its entry assembly's version with the channel unknown. orkeon-cli.d.ts declares it (RuntimeInfo), so orkeon typings writes it. The reader of the install channel moved from the orkeon tool to Orkeon.Hosting, where both orkeon doctor and orkeon-repl read it.

Added — the Orkeon.Scripting package runs a crew.ork.ts inside a .NET application (#229)

Orkeon.Scripting is published again, as an opt-in of the NuGet.org lineup (ten packages). Its wrapper (src/packaging/Orkeon.Scripting/) embeds Orkeon.Scripting (the Jint host, the esbuild bundler driver, the DSL typings), Orkeon.Hosting and Orkeon.Constants.Cli, and depends on Orkeon, Orkeon.Tools and Orkeon.Tools.Embeddings.Local; it stays out of the umbrella for that weight. Orkeon.Hosting gains the entry point: services.AddOrkeonScripting(options => ...) registers ICrewScriptRunner, whose RunAsync(path, input, ct) runs a crew definition (a .ork.ts that hands its crew off, a crew.yaml, a crew directory) on the runner bootstrap of orkeon run (RunnerExecution) and returns its CrewOutput; a run that cannot start throws CrewScriptRunException with the line orkeon run would print. CrewScriptRunnerOptions carries the orkeon run options (SettingsPath, Mounts, MountIds, AllowExternalMounts, LlmProfile) plus ConfigureServices, ConfigureLogging and Diagnostics. esbuild is not shipped: it is found as the orkeon tool finds it. Which crews need orkeon-host instead is in docs/architecture/service-host.md §8. scripts/check-package-closure.py now checks a package against everything its lineup dependencies provide, not the umbrella alone.

Added — the session's usage by model and by command for scripts; token_budget by kind of entry (#226)

A *.cmd.ts reads the session's LLM usage through ctx.services.get("usage") (ScriptServiceKeys.Usage, an optional entry of the default whitelist, present when the host keeps an ICostBudgetManager or a CommandInstanceRegistry). report() returns the prompt, completion, cache-hit, cache-write and reasoning tokens of the session, its calls, unpriced calls and cost, one row per model (byModel) and one per command instance (byCommand, a crew launched with runCrewAsync included). The totals count every call, one whose provider named no model included (CostReport.TotalUsage), so they may exceed the sum of byModel. A cost is the vendor's charge, else the registry's price for the model, and null when neither is known; every row and the totals carry unpricedCalls, the calls nobody priced, which the cost counts as 0. The typings declare SessionUsage, SessionUsageReport, ModelUsageRow and CommandUsageRow. To feed it, a command instance keeps the split of its usage (CommandInstance.AddUsage, CommandInstance.Usage, CommandInstanceUsage) instead of a bare total, CostBudgetCheckResult.Cost answers the cost RecordUsage settled (null for a call nobody priced), ModelUsage carries ReasoningTokens, Priced, Calls and UnpricedCalls, CommandInstanceUsage.UnpricedCalls counts an instance's unpriced calls, and CostUsageEvent.ReasoningTokens carries the reasoning tokens a provider reports in its metadata (LlmUsageMetadataKeys.ReasoningTokens, reasoning_tokens: Z.AI, OpenRouter). The token_budget tool keeps its fields and adds used_tokens_by_kind (system, user, assistant, tool, other), which adds up to used_tokens, both read from one snapshot of the buffer. tools.generated.d.ts types a nested record of a tool's result by its members (used_tokens_by_kind, range, filter_stats...) instead of Record<string, unknown>.

Changed — one screen per thread in the split-pane console; ended tasks stay listed

The split-pane console (the TUI's REPL) no longer mixes every task's output into one transcript. main and each task have a screen of their own, and the recipient's screen is the one displayed: selecting a task in the list switches the screen, a line a task writes lands on its own screen, opened at its first line, and a tool-call question shows on the displayed screen and is recorded once in the asking task's screen. The [t1] ticket prefix is gone from the split-pane console (the screen says whose line it is; a crew label stays) and is kept in plain mode, which is unchanged. A task's end line (✓ [t1] …, which names the task) and the output of its command's completed land on main. Ended tasks are no longer dropped at once: they stay listed, after the live tasks, with their outcome and their screen until the host forgets them (retention), and a recipient that ends stays the recipient; @<task> finished · recipient is main is printed only when the host forgets that task. Enter on a task row still prints the task's detail, now on the displayed screen, and sends nothing. The public IThreadedConsole interface and the ConsoleThread ambient of Orkeon.Cli.Abstractions carry the thread to a console that separates threads; a console that does not implement it gets today's output.

Added — scripted commands carry a group, and /help prints one block per group (#214)

defineCommand and defineAsyncCommand take an optional group (^[a-z][a-z0-9-]*$); when it is absent, the group is the folder holding the *.cmd.ts (/cli-commands/session/clear.cmd.ts → session), none at the mount root of the configured directory that found it. /help prints one [<group>] block per group in registration order, (no group) last; the runner's own commands (ps, inspect, result, cancel, help-cmd) are in [runner], and help-cmd <name> names the group on its first line. IInteractiveCommand gains a default member string? Group => null, ValidationFailure gains InvalidGroup.

Changed — a built-in script extension is readable; writes and execution stay refused (#215)

A plain read (FileAccessRights.Read) of .sh, .bash, .ps1, .bat, .cmd, .vbs and .wsf is allowed: file_read, node_read, grep and the index read the project's scripts as they read its sources. Writes, creations, deletions and command targets on them stay refused; binaries (.exe, .dll, …) and the extensions of AdditionalBlockedExtensions still refuse reads. PathSecurity:BlockReadsOfBlockedExtensions: true restores the old refusal. New IPathValidator.ValidatePath(path, requiredRight, workspaceRoot) overload, strict by default for any other implementer.

Fixed — one refused file no longer fails index_codebase (#215)

The discovery skips a file the VFS refuses instead of failing the whole index; the skipped files are reported in filter_stats.excluded_by_policy and excluded_by_policy_paths.

Fixed — shell_command reaches a private git remote through the keyring and the ssh agent (#216)

The shell's environment allow-list passes XDG_RUNTIME_DIR and SSH_AUTH_SOCK on, so the ssh agent works from a command; the process-isolation twin list follows. The session bus (DBUS_SESSION_BUS_ADDRESS, which gh's keyring credential helper needs) reaches an unconfined shell and the code sandbox, but a confined one (Bubblewrap, Seatbelt, AppContainer) only with Orkeon:Tools:Shell:Environment:SessionBus: true, logged as a warning at start: through the bus a command can start a process outside the sandbox and read every keyring secret. Under Bubblewrap this happens only with Confinement:AllowNetwork, and only the socket files themselves are bound (never the whole runtime directory). LLM API keys and every other variable stay dropped; variable names compare case-sensitively except on Windows. The optional Orkeon:Tools:Shell:Environment:Propagate list adds variable names to both lists (shell and code sandbox); a name starting with ORKEON_, containing a secret word (KEY, TOKEN, SECRET, PASSWORD, PASSWD, CREDENTIAL, AUTH, PASS, or PAT as a whole segment, so GITHUB_PAT is dropped while PATH and PYTHONPATH pass), invalid, or whose value carries URL credentials (scheme://user:pass@, user:pass@host without a scheme, a password holding a /; https://host:4873/@scope is refused too) is dropped with a warning that never shows the value, a built-in one is ignored, and under Bubblewrap an added value passes whatever the network while no path it names is bound. The code sandbox reads Propagate from configuration only.

Changed — a spent token budget ends act with a last answer instead of losing the turn (#218)

A spent budget({ tokens }) ends ctx.llm.act with one last call that declares the tools under ToolMode.None (no tool runs once the budget is spent, on the last iteration too) and whose answer resolves with budgetExhausted: true, instead of rejecting and dropping the turn; a failing wrap-up still rejects with BudgetExhaustedError. The budget stays a running sum of prompt plus completion of every call, now documented as such, and its message reads Token budget exhausted: <sum> tokens sent and received over <n> calls (limit <limit>). Each act call logs the running sum next to the limit; a wrap-up that ends past the wall time keeps its answer. ToolMode.None sends the tools with tool_choice: none on Anthropic, and no tools to Ollama. An autonomous crew spends its own budget, set by YAML budget: (tokens, wallTimeSeconds, toolCalls, delegationDepth, spawnedAgents), crewBuilder().budget() or CrewBuilder.Budget — no token or wall-time cap by default; an invalid limit and a budget on another process are refused by all three — and charges its direct executions to it as it does delegated work. Work that finishes keeps its output whatever budget dimension its recording spends (tokens, wall time, tool calls), spawn_agent included, which returns the output and names the exhaustion; a child's tokens count once per budget.

Fixed — github, http_api, rag_eval, web_search and MCP tools declare their access (#219)

IBaseTool.AccessFor(arguments) gives the access class per call, defaulting to Access. The github read actions and http_api's GET, HEAD and OPTIONS are reads, allowed in plan mode, so an outbound GET runs there without a prompt; their writes stay Execute, as does a read method that carries a body or a method-override header (X-HTTP-Method-Override, X-HTTP-Method, X-Method-Override). web_search is a read; rag_eval, which ingests its corpus and writes its reports, is an edit. An MCP tool follows its server's readOnlyHint annotation only when the server's configuration sets TrustAnnotations: true (default false); otherwise, or when the server sends none, it stays Unspecified (fail-closed). github validates owner and repo (^[A-Za-z0-9_.-]+$, never . or ..) and escapes them in the request path. McpToolProvider.ConnectServerAsync(id, transport, trustAnnotations = false, ct) takes the trust flag.

Fixed — trailing dots and spaces no longer hide a blocked extension

PathValidator looked up the extension of run.sh. or tool.exe as is, missing the block list; it now strips trailing dots and spaces first, as Windows does when it opens the file.

Added — the github tool receives a token (#222)

The tool reads its token at registration from Orkeon:Tools:GitHub:Token, then from the variable Orkeon:Tools:GitHub:TokenVariable names (default GITHUB_TOKEN), then GH_TOKEN. The token is masked in results, errors and logs, and set on each request, never on the HTTP client the web tools share; without one, the tool's description says where to set it.

Fixed — an async completed() is typed void | Promise<void> (#220)

The drain of defineAsyncCommand already awaited a returned promise; the typings and the scripting guide now say so, and that a rejection prints Error in completed('<name>'): … and reports a completion failure.

Added — a self-relaunching driver keeps its chain depth (#221)

runCrewAsync(name, input, { chain: "continue" }), called from a command's own completed, keeps the new instance at its parent's depth, so a driver that loops batch after batch is no longer stopped by MaxChainDepth; outside a completed the option has no effect. inspect shows an instance's depth, and the refusal reads chain depth N reached (MaxChainDepth N, /<command>). commands.post now counts in the depth too (one level per post, refused at the limit with the same catchable error), and a command replays only the completions of its own instances: a sibling command of the same file no longer runs another command's completed.

Before After
ScriptHostFacade.runCrewAsync(name, input) runCrewAsync(name, input, options), options optional
CommandDispatchService.postWork(label, target, work) postWork(label, target, work, continueChain = false)
CompletionDrainQueue.DrainAll() removed: DrainFor(name) drains one command's completions
McpToolProvider.ConnectServerAsync(serverId, transport, ct) ConnectServerAsync(serverId, transport, trustAnnotations = false, ct): pass ct: by name
new McpToolAdapter(definition, client) new McpToolAdapter(definition, client, trustAnnotations = false)

Fixed — a mouse selection in the TUI's transcript scrolls when dragged past an edge

Dragging a selection to the top or bottom of the transcript stopped at the visible edge, the rows beyond out of reach. The drag now scrolls one row per mouse report and every tenth of a second while the mouse stays still past the edge, the selection following the edge row; at the transcript's first or last row it reaches its start or end, as before. The transcript usually starts on the screen's first row, where no report can come from above: a drag that reaches that row from below scrolls up the same way, while a selection started or moved along it scrolls nothing.

Fixed — the TUI's copy key copies the transcript's mouse selection

Ctrl+C looked only at the focused view's selection, and the transcript takes no focus: after a mouse selection in the transcript the key printed its hint instead of copying what was visibly selected. The key now falls back to the transcript's selection. Ctrl+Shift+C, the copy shortcut of GNOME terminals, reaches the same handler while the TUI holds the mouse, and the hint names both keys.

Fixed — pasting a long text into the TUI's input no longer freezes the interface

In the TUI, a right-click or Ctrl+V pasted the clipboard through TextView.InsertText, one rune at a time, each insertion rebuilding the field's model and raising its change event: fifty transcript lines froze the interface for twelve seconds, two hundred for minutes. PaneClipboard.PasteInto now recomposes the text around the caret and sets it once, the caret landing after the pasted text, whatever its size.

Fixed — the interactive REPL starts again when stdin is a terminal (#212)

On main after the replay (#206), orkeon-repl hung after its start lines whenever stdin was a terminal, TUI and --ui plain alike (a black screen eating Ctrl-C, every thread idle); stdin redirected (--replay, a pipe) went on. The cause was a cycle in the REPL's services: the console the replay decorates is, on a terminal, the line editor or the TUI, which takes the host's completion, which reads the universal commands, /replay among them, which took the replay console being built. /replay now takes the console at its first execution, and a test resolves the terminal console over the full chain.

Fixed — concurrent acts no longer interleave on the console; their lines carry the act's ticket (#211)

With Orkeon:Cli:ConsoleStreaming:Enabled, two acts streaming at once (two background runAgent sub-runs, the tasks of a parallel crew wave) wrote their deltas into one another character by character. ConsoleLlmDeltaSink now streams the foreground act as it arrives, as before, and renders every other turn one whole line at a time: the turn holds its own line buffer, a line is written once complete, under one lock, the turn's end writes what is left, and a line that arrives while the foreground act is inside a line waits for that line's end. A turn that runs under a command instance (a background command, a runAgent sub-run) prefixes its lines with the instance's ticket, [t2] , as the completion lines are; a crew task adds its id ([t2 task-1] ).

API: ILlmDeltaSink.BeginTurn(label) (default: the sink itself) opens one streamed turn; the scripted act loop and the crews' chat-client loop stream each turn through the sink it returns, the latter labelled with the task id. A sink that records or counts needs no change.

Fixed — the structural tools publish their parameter schema (#210)

edit_batch, node_ensure, node_insert, node_outline and node_replace sent the model an empty parameter schema ({"type":"object","properties":{}}), and node_read published its selector only: the model learnt the arguments from the description alone and guessed (node_outline {"selector": …} without path, edit_batch without operations). Their request records now carry [FieldSchema] on every argument — path required on the node tools, op and position with their enums, operations required on edit_batch with validate (parse | build, default parse) — and a call missing a required argument is refused before the tool runs, with the argument's name (Required parameter 'path' is missing), the items of operations included (Required parameter 'operations[0].path' is missing, Parameter 'operations[0].kind' must be one of: …). A value a schema lists as an enum is now judged as listed: position: "Inside" is refused with the list.

API: ParameterSchema.ItemProperties (Orkeon.Domain) describes the items of an array of objects; the schema generator fills it from the item record (its [FieldSchema] when present, the C# types and nullability otherwise), the OpenAI and Anthropic formatters publish it as the items' properties and required, ToolParameterValidator judges each item by it, and tools.generated.d.ts types the item's members by the same [FieldSchema] (enum, IsRequired). Every tool whose request holds a list of its own records gains the items' shape in its definition.

Added — orkeon-repl --replay <file>: replay a session, line after line

orkeon-repl --replay <file> feeds the lines of a file to the REPL as if typed (blank and # lines skipped, a relative path read against the working directory), waits before each line until no command instance runs — background crews included — or a question asks for the line (a tool-call approval, human_input), and stops at the first error with replay stopped at line N: <cause>. Alone it runs the plain console, echoes each line, writes the logs to stderr and exits 0 (every line passed), 1 (stopped on an error) or 2 (file missing or unreadable); with --interactive it hands the keyboard back. /replay <file> does the same inside a session. One line answers one approval; a session-wide answer (s) also settles the queued approvals of the same tool, so the file carries no line for them. A question still waiting when the file ends stops the replay (replay ended with an approval waiting: <tool>, exit 1), as does a command reading past the end (its read gets the end of the input, under --interactive too); a REPL that throws under --replay alone exits 1 with one line on stderr. The replay concludes only once the command in flight, its background work and their completed() callbacks have ended; a completed() that throws stops the replay at the line that launched it ([t1] <command> completed() failed: <error>), one that only runs long is waited for. Ctrl-C (Esc Esc in the TUI) stops the replay; a second Ctrl-C while it is still stopping ends the process (exit 130). New --log-level <level>, also the starting level of the TUI's logs pane; --replay and --log-level refuse a value that starts with --.

API: CommandResult.Fail(message) and CommandResult.Failed (Orkeon.Cli.Abstractions) mark a command that failed; a scripted command's error, rejection or quota refusal now returns it, as do the usage errors of inspect, result, cancel and help-cmd and an unknown ticket — the message printed is unchanged. InteractiveRunnerBase.OnCommandOutcome and ICommandOutcomeObserver report each command's outcome; IToolApprovalWatch.PendingChanged and PendingToolApproval.Id, CommandInstanceRegistry.InstanceRegistered / InstanceTerminated / WorkSettled / CompletionFailed / HasRunning / BeginWork signal the work in flight (an instance counts until its terminal observers have run, a completed() drain until it ended); DefaultCommandRegistry takes a host's own built-ins.

Changed — file tools accept a relative path; shell_command no longer falls back to the first mount [breaking] (#199, #200)

A file tool (file_read, file_write, edit_file, glob, grep, directory_read, directory_search, count_pattern, node_*, edit_batch, and the data tools csv_reader, docx_reader, docx_writer, xlsx_reader, xlsx_writer, pdf_reader, xml_parser) resolves a relative path against the agent's working root, else the file system's new working directory (IFileSystemService.WorkingDirectory: the one a host designates with Orkeon:FileSystem:WorkingDirectory or FileSystemRegistry.SetWorkingDirectory, else /workspace when mounted; the runners fall back to /output), and echoes the absolute path. The path is made absolute before the mount check and the root guard. An empty path is refused with path is required: the absolute path of the file, e.g. /workspace/src/stats.js, and a path in no mount says a path starts with a mount: /workspace/src/stats.js. node_outline, node_read and directory_search go through the same resolution, and so do structural_search, structural_rewrite (paths), txt_search and mdx_search; every one of them, node_outline and node_read included, now refuses a path outside the agent root before any I/O.

Behaviour change: shell_command without working_directory ran in the first mount granting the rights — a read-only command could land in /session-history. It now runs in the agent's root, else the working directory; with mounts but no working directory it is refused, naming the mounts. A host without /workspace designates its working mount (Orkeon:FileSystem:WorkingDirectory, or SetWorkingDirectory). A relative working_directory is made absolute before the root guard, so ../p2 cannot leave the agent root. Where the working directory is refused for its rights alone (a writing command needs every right on it: read, write, create, delete; a read-only /workspace, as in orkeon forge), the command runs outside any agent root in the new write directory: Orkeon:FileSystem:WriteDirectory (an absolute path without . or .. segments whose effective rights, subtree overrides included, grant Write), else /output when an agent-facing mount grants Write there — never the order of the mounts; any other refusal of the working directory is reported as is; with none it is refused, naming the option, and under an agent root it never moves. The file tools' relative paths still resolve against the working directory only. The orkeon forge trial carries the host's working and write directories forward while it still mounts them.

Added — scripted commands read the pending tool approvals (#198)

A *.cmd.ts command reads the tool approvals waiting for the operator through ctx.services.get("approvals") (ScriptServiceKeys.Approvals, an optional entry of the default whitelist, present when the host registers IToolApprovalWatch, as AddConsoleToolApproval does). It is read-only: list() returns { taskId, command, tool, input } per approval waiting, and an empty list once the operator has answered. input is the call's input as the TUI status line shows it: the summary moves from StatusLineFormatter.ComposeApproval to PendingToolApprovalInput (Orkeon.Cli.Abstractions), which both now call. The typings declare PendingApprovals and PendingApproval, and get("approvals") returns the former without a type argument.

Fixed — the TUI no longer rebuilds a whole pane for each appended line (#196)

While a background crew ran, the Terminal.Gui loop thread spent most of its time rebuilding text: every line written to the REPL transcript (_history.Text += text) or to the logs pane (a join of the whole ring buffer, then TextView.Text) re-parsed and re-wrapped the whole pane, even with the logs pane hidden, so typing lagged and the spinner slowed. Both panes now draw from a line-based, bounded model (TranscriptView, TranscriptBuffer) that wraps only the lines added and drops head lines past the capacity; TextView.InsertText was not usable for this (it refuses a read-only view, records undo history and re-wraps the whole text on every character with word wrap on). Writes are coalesced (AppendCoalescer): a burst costs one Application.Invoke, not one per line. The logs ring buffer is fed on the caller's thread and a hidden logs pane does no UI work; showing it renders the buffer once. The transcript is bounded by the new TerminalGuiOptions.ReplTranscriptCapacity (10000 lines; the empty line after the last newline does not count); LogsBufferCapacity still counts log entries, an entry on several lines (an exception and its stack) being kept or dropped whole. Word wrap (F3), tabs (expanded to the next stop of four columns; with the wrap on, a tab whose stop lies past the row end is cut at that end and the text after it opens the next row), mouse selection with auto-copy, the navigation keys and Ctrl+A / Ctrl+C keep working. Autoscroll is a state: a pane follows its tail while its view is at the end; scrolling up stops it, so new output or log entries leave a reader where they are, and it resumes once the view is back on the last row (a scroll, End, or a taller pane). A pane shown after entries arrived while it was hidden, or cleared, lands on its tail. Double-click word selection and the auto-scroll while dragging a selection are not kept.

Fixed — --llm-log keeps the cache, reasoning and cost counts of a streamed exchange (#197)

The usage of a streamed exchange in llm-exchanges-*.jsonl was rebuilt from three totals (total_tokens, prompt_tokens, completion_tokens), so a run's log could not tell a cache hit from a full-price token. An OpenAI-compatible provider now writes the fields of the stream's usage chunks as the vendor sent them (merged when a vendor splits its usage across chunks, a later value of a field replacing an earlier one): DeepSeek's prompt_cache_hit_tokens and prompt_cache_miss_tokens, prompt_tokens_details.cached_tokens, completion_tokens_details.reasoning_tokens and OpenRouter's cost keep their own names. A total_tokens the vendor did not send is written as prompt_tokens + completion_tokens when both are known, and left absent when they are not (no 0); a chunk that changes prompt_tokens or completion_tokens without a total of its own drops the total of an earlier chunk, which is recomputed the same way (so is the response's TokensUsed, 0 when nothing was counted). Any other field the vendor did not return stays absent, and a stream that reports only the three totals logs the same three fields as before. Ollama and Anthropic streams are unchanged.

Changed — Orkeon Studio: one Launch screen with a Trial | Real switch; shared components and a side assistant

The Test and Run screens of Orkeon Studio merge into one Launch screen (RunScreenViewModel, RunScreenView). A Trial | Real switch picks the launcher on show. Each mode keeps its own launcher, so what the engine receives does not change: a trial records no history and stamps no last run, and both launchers can run at once. The team picker, Check and Launch share the action line of the team card. The trial can now be reached in Novice mode, from the switch, from the « Try out » button of a team card, from « Test it first » after an import, and from the Test group of the status bar. TestTeamViewModel, TestTeamView and the Test entry of the sidebar are removed; MainWindowViewModel.Test becomes MainWindowViewModel.Run (Run.Real, Run.Trial).

The screens share new controls (Alert, Badge, PropertyRow, PageHeader, ActionBar) and button styles (BtnPrimary, BtnSecondary, BtnDanger, with a ButtonSize, and BtnAssistant, a light blue reserved for « Ask the assistant » and « Rephrase », the commands that ask the model). The accent colour is now teal. The assistant moves from the three screens that each embedded it into one side panel, opened with « Ask the assistant » in the title bar. My teams gets card action bars, one banner for refused scheduled runs and an Undo toast after an archive. Create a team shows one step per screen behind a stepper; its Compose step becomes a binder of four tabs (Team, Team folders, Composition instruction, Composition), and « Try the team » waits until no folder is left to choose. Launch becomes a binder of four tabs (Team, Options, Command in Expert, Run) above an action bar that says whether the launch is ready; a launch opens the Run tab, which shows one column per agent, and locks the others until it ends. The French wording follows one lexicon (Équipe, Modèle, Essai, Vérifier, Lancer, real plurals). A guard test refuses a resource dictionary that declares the same key twice: a duplicated icon key stopped Studio at startup.

History becomes a table grouped by day with team and status filters, the team's own name and « < 1 s » under a second. Settings become a tab binder in four groups, drawn as a horizontal bar over the active group's sections, each tab saying its state (an amber dot for something to fix, a green one for a checked file); Models splits into AI model, Document search (RAG, Expert) and API keys, where the Diagnostic's missing-key problem now leads, one card per model with its provider, endpoint, file name, teams and an action bar, and an unsaved-changes bar that guards leaving the screen; the sidebar's settings-file card becomes a dot on the Settings entry and a line of the Diagnostic. The Diagnostic counts the points to fix exactly and gives each problem its own action. An allowed folder's error shows on its own row.

Step 1 of Create a team becomes three vertical tabs (need, team folders, composition instruction). A card the engine waits on is now the one named wait point: the assistant stops its indicator and offers the card's own button, Enter no longer sends, the focus goes to the card and the stepper and the status bar say « Waiting for you: … ». A read folder the definition already places is no longer shown as « no folder chosen », and the « Your brief » card follows every edit of the need.

The assistant's questions move into the side panel: each is a bubble with its answers as buttons, the recommended one first and focused — the options the engine lists under its question, then « I don't know ». The trial's arbitration and « Do you want to put files in the folders? » leave the main column for the panel, which opens itself on a new question. That question now waits for its answer, in the engine too: with folders kept inside the team, orkeon forge waits after brief.ready for folders.filled on stdin (Enter in the terminal; --auto does not wait), then adds what each folder holds to the brief (contents), so the plan is designed for the files the user dropped. Studio sends it on « No » or « Continue », keeps its step and « Try the team » off until then (« Waiting for you: fill the folders »).

Added — RaggableTree indexes JavaScript, Java, C, C++, PHP, Ruby and Bash; every portable grammar is loaded

Seven built-in language adapters join TypeScript, Python, C#, Go and Rust (LanguageAdapterFactory, registered by AddRaggableTree): JavaScriptAdapter (.js, .jsx, .mjs, .cjs), JavaAdapter (.java), CAdapter (.c), CppAdapter (.cpp, .cc, .cxx, .hpp, .hh, .hxx, .h), PhpAdapter (.php), RubyAdapter (.rb) and BashAdapter (.sh, .bash). Each extracts declarations with their kind, parent, modifiers, decorators, doc comment, signature and statements, and feeds the graph its import, call and inheritance edges; a file import edge comes from a relative path only (require_relative, a quoted #include, require/include including __DIR__ . '/x.php', a source or . whose path is a word or a quoted string without a variable). C and C++ resolve in one graph, so a .c file reaches the .h header it includes, parsed as C++; JavaScript and TypeScript share one too, and an extensionless import also finds a .jsx file (DependencyGraphBuilder.GraphGroupOf, RegisterFile(..., adapter)). Discovery detects the packages of these ecosystems (pom.xml, build.gradle, build.gradle.kts, composer.json, Gemfile, CMakeLists.txt), and orkeon doctor checks the new grammar libraries. LanguageRegistry also loads agda, css, embedded-template, haskell, html, jsdoc, json, julia, ql, razor, scala and verilog, parsed on request only, and the publish step no longer prunes these 19 grammars; OCaml (no macOS build) and the Windows-only swift, toml and tsq are still pruned.

A C# new Foo() call is now named after its type, Foo, instead of the new keyword, so it resolves to the class it creates as a TypeScript new does.

Added — the structural tools serve every grammar

node_outline, node_read, node_replace, node_insert, node_ensure, edit_batch, structural_search and structural_rewrite served C#, TypeScript and Markdown (and structural_rewrite accepted, undocumented, the other indexed grammars). They now take a file of any grammar the registry loads: the twelve indexed languages, tsx, and the parse-only agda (.agda), css, embedded-template (.erb, .ejs), haskell (.hs), html (.html, .htm), json, julia (.jl), ql (.ql, .qll), razor (.cshtml, .razor), scala (.scala, .sc) and verilog (.v, .sv, .vh, .svh), whose extensions LanguageRegistry.Parseable lists; discovery and the index still claim the indexed extensions only. The outline names declarations in Python, Go (a method as Type.Method), Rust (an impl block's functions under its type), Java, JavaScript, C and C++ (by declarator, a template under its function), PHP, Ruby, Bash, Scala, Julia and JSON (a key path, a.b); a grammar with no declaration kind (CSS, HTML, Haskell...) is outlined by the tree-sitter paths of its top-level nodes. inside appends after the last member of an indented or end-closed body (Python, Ruby), and gives a Rust or C enum variant and a JSON pair their separating comma. A pattern is parsed in any grammar (a PHP pattern without its <?php tag, a JSON pattern whose metavariables stand for values). A .tsx file is read with the tsx grammar by the node tools; a typescript rule still scans .ts and .tsx, a tsx rule scans .tsx. ensure_import also serves tsx and JavaScript; ensure_using stays C#. A method's receiver (Rust self, Python self or cls) is no longer a parameter of its selector.

Fixed — a tool the act does not offer is refused, not put to the operator (#193)

A model's call to a tool ctx.llm.act does not offer (read when tools: ["file_read"]) reached the permission gate as an unclassified tool, which asks for it as a command: the operator was asked to approve tool 'read' executes commands, and an approval ran into ERROR: tool 'read' is not available to this agent. The call is now answered with that error at once, before the gate and onToolCall; no approval is asked and no tool call is counted.

Fixed — an approval asked by a background task is seen from the main view (#194)

The question did not name the task that asked it, and in the TUI only its lines in the transcript showed it: once other output scrolled them away, the status line read Working… and a line typed got only answer y, s or n. A question now names its task (? [t1] dev-batches: tool 'read' requires approval…, approve read for [t1]?), a line that answers nothing writes the whole question again, the TUI status line shows the waiting question over every other state with the call (? [t1] dev-batches asks to run read… ({"path":"…"} · answer y once · s session · n no · +1 more)), the task's row in the tasks list reads ? waits for approval of read, and its detail (Enter on the row) gives the whole call. The REPL's approval channel is read through the new IToolApprovalWatch (Orkeon.Cli.Abstractions) and TuiIntegration.PendingApprovals.

Fixed — a parser could return to another grammar's pool

TreeSitterParserPool.Return found a parser's pool by its grammar name, and most grammars carry none (TypeScript, Java, C++, Ruby, JSON, Scala...): a parser of one went back to the first nameless grammar's pool, and the next parse in that language ran with the wrong grammar. The pool now records each parser's language when it makes it; a parser it did not make is disposed.

Fixed — the tsx grammar never loaded

LanguageRegistry mapped tsx onto the tree-sitter-typescript library, which has no tree_sitter_tsx entry point: every tsx parse threw. It loads tree-sitter-tsx, the library the publish whitelist already kept.

Fixed — two adapter queries that never compiled

The C# StatementQuery named an else_clause node the grammar does not have, and the Python DocCommentQuery had a structure error; UniversalSemanticMapper dropped both silently. The C# query no longer names it, and Python docstrings stay read by ResolveDocComment. A test now compiles every query of every built-in adapter against its grammar.

Added — a delegated run's budget (#189)

ctx.delegate(agent, input, opts) and crew.runAgent(agent, input, opts) take budget (the keys of crewBuilder().budget(...): toolCalls, tokens, wallTime, delegationDepth, spawnedAgents), applied as a crew run applies the crew's: a spent dimension ends the run with BudgetExhaustedError, and a child it spawns derives its budget from the run's; invalid values are refused when the run opens. charge: "crew" also counts what the run spends against the calling run's budget (AgentExecutionBudget.ChargedTo, experimental ORKEXP002), so runs started at once never exceed the crew's: a call the run's own budget refuses is not charged, and a child the run spawns is charged too, each limit capped by what both budgets have left. ctx.delegate charges its context's budget; crew.runAgent charges the one budget every open agent body runs under and refuses when they differ. The charge is refused when the caller runs under no budget. BudgetSnapshot.Charged carries the charged budget's state. Without either option nothing changes.

Changed — the .NET delegate behind ctx.delegate takes an options argument [breaking] (#189)

JsExecutionContext.delegate is now Func<JsValue, JsValue, JsValue, JsValue> (agent, input, options) instead of Func<JsValue, JsValue, JsValue>. Migration: a .NET caller invoking delegate(target, input) passes JsValue.Undefined as the third argument. Scripts are unaffected.

Added — git in a linked-worktree agent root under shell confinement (#188)

When an agent's working root is a linked git worktree (its .git is a file), shell_command binds the repository's common git dir read-only and, over it, its objects, refs and logs and the worktree's own git dir with the root's rights, read through the VFS: git status, git add and git commit then work under bubblewrap and commit on the worktree's branch, while the main working tree stays unreachable. Nothing is bound unless the layout checks out: the gitdir sits in <common>/worktrees/, its commondir and gitdir back-link name exactly the common dir and the root's .git, and no component of the path is a symlink; a relative gitdir (git worktree add --relative-paths) is bound at its virtual path, an absolute host path only under the mount's physical root. Mount overrides narrow these binds but never widen them, so the common dir's config, hooks, info, modules and the other worktrees stay read-only. Seatbelt and AppContainer grant the same directories. Limits (limitations.md): the agent can rewrite every branch's refs and the shared objects, git on the host follows a link it creates inside objects, refs or logs, and a repository without logs/ records no reflog.

Changed — SonarQube report of 2026-10-24 cleared

The 213 issues and 29 security hotspots of the analysis were fixed in the code, with no suppression. Visible effects:

Before After
The 8 exceptions of Orkeon.Analysis.Core.Editing and .Structural (StaleHashException, AmbiguousSelectorException, ...) were internal public sealed, so a caller can catch them
OAuthException and OAuthFailure (Orkeon.Tools.Abstractions.Auth) were internal public
RunnerHost's silent-base-URL warning logged event id 14, shared with the notice event id 15
orkeon usecases/forge --reference threw UnknownUseCaseException, UseCaseModelUnavailableException KeyNotFoundException, FileNotFoundException; the reported codes and messages are unchanged
scripts/sonar-analyze.* installed the latest SonarScanner, which refuses the 9.9 LTS server pinned to 10.4.1 (SONAR_SCANNER_VERSION overrides it)
LlmRateLimitException, HumanInputRefusedException, ChainDepthExceededException and the 8 exceptions above were not [Serializable]; DomainException had no serialization constructor [Serializable], with the serialization constructor and, where they hold state, a GetObjectData override that keeps it; DomainException gains a protected serialization constructor; these members are obsolete (SYSLIB0051)

TypedDictionaryGenerator emitted struct, unmanaged for an unmanaged type parameter, which does not compile (CS0449): it now emits unmanaged alone. Coverage now measures the WPF ViewModels and the source generator.

Fixed — a Studio button no longer also presses the window's default button

In Orkeon Studio (Config and Run) and the console's find and quit dialogs, an Accept a button left unhandled travelled on to the window's IsDefault button, whose action ran too: Cancel in a picker also confirmed the highlighted choice, Browse in the mount dialog also ran OK, and every button of the run launcher also pressed Run. Each handler now marks its Accept handled (AcceptHandlers.OnAccept, Orkeon.Cli.TerminalGui.Layout).

Added — a script agent takes a working root: agentBuilder().workingRoot(path) (#186)

A script agent of .ork.ts can now be held to a virtual directory, as RT-06's working_root: holds a declared agent. .workingRoot("/workspace/.orkeon/worktrees/a") roots the agent's run scope: file_*, node_*, edit_batch and shell_command resolve a relative path under it, refuse a path outside it and run there, whether the body's ctx.llm.act(...) or its code calls them. A root under no mount, relative or holding .. refuses the agent's run when it starts, with the runtime's own message (AgentWorkingRoot.NormalizeMounted, now shared with AgentExecutionService); on the declarative shape the root reaches AgentConfiguration.WorkingRoot. A child started by spawn_agent or ctx.spawnBackground without a root of its own runs under its parent's, and so does each later crew.send to it. The new ctx.tools calls the host's tools as the body's agent; the global tools namespace follows the open agents' root while they share one and refuses a call when agents with different roots run at once. Hosts hand the mounts through ScriptingHostPorts.FileSystem (wired in orkeon run, the runner, the REPL's scripting commands and Forge); without it every root is refused. No root: nothing changes.

Fixed — drive_search keeps to the root without coming back empty (DRIVE-07)

The first real campaign found two gaps. On Google Drive, a search with a limit came back empty with a next_cursor (G4.5d): the whole-drive query's first hits lay outside the account's root and were all dropped. drive_search now reads further provider pages, up to MaxSearchPages (5), each asked for what is still missing, to fill the page. On OneDrive personal, word searches found no file of the root (O12.a): the root check compared ids case-sensitively, stopped at a search hit without a parent id, and did not recognise the root under another id. It now compares OneDrive ids without regard to case, reads such a hit again, and matches the id Graph gives back for each parent; a dropped item is logged at Debug (Orkeon.Tools.Drive).

Fixed — drive and e-mail traffic no longer lands in the LLM exchange log

AddLlmExchangeLogging wrapped every IHttpClientFactory client: with --llm-log, drive and mailbox calls were logged as LLM exchange custom/unknown, a Google 308 Resume Incomplete as FAILED, the Google upload session address in clear, and file and message bodies in the JSONL. A tool family now registers LlmExchangeLogExclusion(clientName) (Orkeon.Domain.Tools) for its client; the drive and e-mail families do.

Added — a team follows the default model, or pins one, from adoption to the Run screen (STUDIO-73)

A team's companion file carries useDefaultLlm: a team that follows the default runs on the setting elected when the run starts, without --llm-profile, and is skipped when a setting is renamed. Adoption follows the default unless the operator unticks it; each card of My teams says « Model: Default (X) » or « Model: X » and changes it in place; the Run and Test screens choose the model of one run and can remember it for the team, and the launch history keeps the choice for « Replay ». « Used by » and the status bar count the teams that follow the default; a crew whose agents or tasks name their own model is said so on the card and the Run screen. A companion file written before keeps its pinned setting.

Fixed — Studio's run consoles colour by log level and show one time per line

Under --events the CLI writes every log line to stderr, and the Run screen's journal painted them all red. Both the journal and the Test screen's console now read the console logger's level token (CliLogLine): fail/crit red, warn amber, the rest neutral; a stderr line without a level takes the colour of the entry it follows. The logger's own timestamp is dropped: the journal shows the time Studio read the line, on screen and in the copied text. « Show / Hide » works in expert mode, which opens the journal by default.

Changed — an expected tool error is logged without its stack trace; a model answer is a preview at -v 1

An exception marked IExpectedToolError (Orkeon.Tools.Abstractions; EmailToolException, DriveToolException) is logged by ToolBase as Error calling tool <name>: <type>: <message>, without its stack trace, which every other exception keeps; the agent sees the same error as before. The LLM response line is a one-line preview of 300 characters at Information (LoggingDefaults.MaxLlmResponseLogLength) and the whole answer at Debug (-v 2): the run's final answer was printed twice, once in that line and once under === Crew Output ===.

Changed — framework code no longer touches System.Console [breaking]

A new analyzer rule, ORKCON001 (Orkeon.Compliance.Vfs), reports any System.Console reference in src/ as an error, outside the console adapters and the one sink of each executable marked [SuppressConsoleCompliance] (console compliance). Runners and the orkeon CLI read and write through IRunnerConsole (Orkeon.Hosting, RunnerOptionsBase.RunnerConsole), the terminal UI through ITerminalProbe (TerminalGuiOptions.Terminal). The runner host's operator warnings go through the Orkeon.Operator logger category, forced to Warning and written to stderr, instead of a second Console.Error line. The interactive runner loop no longer colours its prompt.

Before After
McpServer.RunStdioAsync(ct) McpServer.RunStdioAsync(reader, writer, ct)
ConsoleHumanInputProvider(logger) (process console) ConsoleHumanInputProvider(logger, input, output) only
RunnerSettings.ResolveSettingsPath(explicit, dir, quiet) RunnerSettings.ResolveSettingsPath(explicit, dir, TextWriter? warnings) (null is quiet)
RegisterGracefulShutdown(cts, logger) RegisterGracefulShutdown(cts, TextWriter error)

Migration: an embedding host passes Console.In/Console.Out (or its own streams) to RunStdioAsync and ConsoleHumanInputProvider, and SystemRunnerConsole.Instance where a runner needs the process console.

Changed — list_mounts returns a typed result with renamed fields [breaking] (RT-27, #162)

list_mounts answers a typed { mounts: [{ virtual_path, access, overrides: [{ virtual_path, access }] }] } (ListMountsTool, Orkeon.Tools.Abstractions) and the generated typings follow.

Before After
mounts[].path mounts[].virtual_path
mounts[].rights mounts[].access
mounts[].overrides[].path / .rights mounts[].overrides[].virtual_path / .access

Migration: a script or a prompt that reads path or rights from the result reads virtual_path and access.

Changed — rag_search and rag_eval take structured parameters only [breaking] (RT-25, RT-24, #155, #154)

rag_search returns a typed { answer, citations[] } and rag_eval a typed { metrics[], cases[], reports }. The legacy raw-string entry of both tools is removed: rag_search takes question, rag_eval takes dataset.

Migration: pass { question: "text" } where a bare string was passed, and read citations[] from the typed result. The rag namespace is now bound in orkeon-repl and in orkeon run as well as in the daemon, through one RagScriptingBackendFactory; an optional service whose activation fails is logged at Debug with its type name, not swallowed. rag.d.ts carries the golden-dataset schema (RagEvalDataset, loaded by RagEvalDatasetYamlLoader from golden.yaml).

Changed — the file-editing tools are asked in ask mode [breaking] (RT-09a, RT-39, RT-40, RT-41, RT-42, RT-43, RT-32, RT-01, #147, #173, #174, #175, #176, #177, #166, #141)

ModePermissionGate now treats these tools as Edit class: file_write, spawn_agent, edit_file, node_replace, node_insert, node_ensure, edit_batch and structural_rewrite. In the default mode they are asked, in acceptEdits they run, in plan and dontAsk they are denied, and a headless host (crew runner, SDK) degrades the ask to a motivated deny.

Migration: a crew or script that ran one of these tools unattended grants the call: bypassPermissions or acceptEdits for the session, an allow rule, or a declared Access = Edit. The github tool keeps Access = Unspecified and stays asked in the default mode, create_pr included.

Changed — the shell tool-result cut goes from 4000 to 10000 characters [breaking] (RT-10, RT-07, #148, #145)

The default cut of a shell_command result in ToolInvocationPipeline is 10000 characters (it was 4000), resolved with every other tool through ToolResultLimitsOptions (Orkeon:Tools:ResultLimits, Limits:<tool>). The cut size is reported in the result. A result a tool already bounded (ToolCallResponse.AlreadyBounded) is no longer cut a second time, so its notice and trailing keys survive.

Migration: a host that relied on the 4000 limit sets Orkeon:Tools:ResultLimits:Limits:shell_command to the old value. Independent read-class calls of one turn now run concurrently (MaxParallelToolCalls, default 4) in the native tool-calling loops; the text-fallback loop and the dispatcher text path do not fan out. No host sets JsExecutionEnvironment.ToolLimits for the script path, so a scripted act always uses the built-in defaults: see limitations.

Fixed — orkeon-repl's qa mode answers with its built-in crew without a /tmp mount

  • Pressing Enter at qa's crew prompt used to write the built-in crew to /tmp/interactive-qa/… and read it back: the REPL mounts no /tmp unless asked, so the mode stopped with No mount found for virtual path and a stack trace. The built-in crew is now loaded from its YAML in memory and writes no file; a crew path you type is read as before.

Added — orkeon-repl writes the LLM exchange log (--llm-log, --llm-log-path)

  • The interactive console takes orkeon run's two flags: every request and response sent to the model as JSONL under ./llm-logs, or the folder --llm-log-path names, which implies --llm-log; the LlmLogging section tunes it, as for orkeon run. A folder outside the working directory needs --allow-external-mounts; without it the REPL refuses to start (exit code 1) with the runner's line. The REPL used to accept neither flag and wrote no exchange log.
  • orkeon run and orkeon-repl resolve, mount and guard the folder with one rule (RunnerLlmLog).
  • Docs: the first-run guide gives the command that follows a run in the terminal and keeps the exchanges in a chosen folder; the CLI reference says -v 1 prints one summary line per exchange, never the bodies, and that --allow-external-mounts covers an --llm-log-path outside the working directory.

Added — an agent confined to a working root, detached shell jobs (RT-06, RT-11, #137, #138)

  • working_root (YAML key; alias workingRoot, C# AgentBuilder.WorkingRoot): a virtual path under a mount that confines the agent's file tools and shell_command to it (AgentRunScope.Root). Default none, so nothing changes for a crew that does not declare it. A run that declares a root no mount holds is refused at start, naming the root; a root containing .. is refused. The sandbox view binds the root with the rights in force there (the deepest containing override, else the mount's default) and keeps the overrides under it and the other mounts.
  • Shell jobs. shell_command takes action: start_job runs an allowlisted command detached with the same confinement and returns a job_id and the output file /output/jobs/<id>.log; job_status reports running or the exit_code; job_tail returns the last tail_lines lines. 16 live jobs per run, ids valid for the run that started them, the end of the run kills the jobs still running. Without action the call is the blocking call it was. Reference: Shell confinement.

Added — file tools for the agent loop: edit_file, ranged file_read, glob, grep (RT-09a, RT-09b, #147)

  • file_read takes offset and limit. edit_file replaces a unique old by new (refused when it matches zero or several times), keeps the file's line endings and encoding (a non-UTF-8 file without a byte-order mark is refused by name), restores the original on any failed write, and with create_backup never overwrites an earlier backup.
  • glob and grep return path:line hits under the agent root (a .. segment is refused) and skip files over 1 MiB (counted in files_skipped).

Added — scripting: spawn, background agents, instances, durable memory, act options (RT-01, RT-02, RT-03, RT-16, RT-04, RT-15, RT-19, RT-18, RT-26, RT-20, #141, #136, #142, #157, #143, #152, #159, #139, #140)

  • Spawn. spawn_agent (SpawnAgentScriptTool) is offered to a script's act; ctx.delegate runs without deadlock under concurrency(n): a child already under a crew permit takes no second one, a background spawn takes its own (GatePermit). ctx.spawnBackground() starts a background agent whose completion reaches the parent's inbox as a message; each act cancels only the children it started.
  • Instances. crew.instances() lists addressable agent instances; they take send and stop, maxInstances (default 32) and ctx.instanceId; an act that ends on maxIterations keeps its transcript, so a later send has its context. Caps: 40 messages and 32k characters per instance.
  • Durable agent memory. ctx.memory.agent persists per project through IScriptAgentMemoryStore (FileScriptAgentMemoryStore, root /workspace/.orkeon/agent-memory, key = agent name). A corrupt file is refused, never overwritten. The root is not configurable yet: see limitations.
  • act options. act({ tools }) narrows the offered tools and throws UnknownToolError before the model is called (case-insensitive); effort on act and AgentBuilder.effort() reaches the provider; onToolCall and onToolResult run before and after every tool call (a verdict that is null, not an object or unparseable is a deny; "ask" with no permission gate fails closed). withAutonomousTool tools are offered in act, gated by their declared access, and an inner tools.* call is not asked twice.
  • runCrewAsync from completed chains a crew; the chain depth is bounded (default 8) and past it the script gets a catchable error while the drain loop goes on.

Added — REPL and sessions: human_input, durable sessions, session-start script (RT-08, RT-14, RT-05, #146, #151, #144)

  • human_input works in orkeon-repl (also under --ui=tui, through the console adapter) with multi and a recommended option; headless, HumanInputOptions.HeadlessPolicy answers the default or refuses, and the JSON-lines provider of orkeon run accepts [a, b] or a comma list for multi.
  • Sessions are durable per project (FileSessionBufferService, last.json), reloaded at start and saved after each command (InteractiveRunnerBase.OnAfterCommandAsync, a new virtual member) and at exit.
  • Orkeon:Cli:Session:StartScript runs once at start; what it printed is prepended to the first turn (ISessionBufferService.SetState(), key session_start_output, cleared before the hook runs).

Added — LLM providers: rate-limit windows and cache tokens (RT-13, RT-12, #150, #149)

  • A 429, or a 529 carrying a reset header, waits for the window instead of the backoff ladder (Retry-After, the Anthropic and OpenAI reset headers, the longest wins), observing the caller's token. The wait is capped by Llm:MaxRateLimitWait (5 minutes by default; the 5xx ladder keeps its 30-second cap); beyond it the call fails at once with LlmRateLimitException (a DomainException).
  • LlmResponse.CacheWriteTokens and the cache read tokens reach CostBudgetManager and session_stats. LlmCacheConfig.Ttl (5m or 1h) is a per-call option (orkeon:cache_ttl); a provider that cannot honour it, Ollama included, logs the structured warning (event 110, cache_ttl).

Added — RAG ingestion: locking, prune, sources on any mount (RT-28, RT-23, RT-22, RT-21, #156, #153, #161, #160)

Concurrent ingests of one collection lose nothing (a per-collection lock, in-process); IngestionRequest.Prune deletes the chunks of manifest sources absent from the requested globs and IngestionReport.SourcesPruned counts them (a failed delete is an error of the report and keeps its manifest entry); sources are globbed on any mount with the virtual path as sourceId; rag-pipeline.md states where collections persist (host-global scope).

Added — RaggableTree: Markdown nodes, selectors, graph kinds and dev-workflow queries (RT-29, RT-35, RT-44, RT-38, RT-30, RT-31, RT-33, RT-34, RT-36, RT-37, #163, #169, #178, #172, #164, #165, #167, #168, #170, #171)

The analysis suite counts 28 tools (AddRaggableTreeTools).

  • Markdown nodes (RT-29). .md and .markdown files give Section, CodeFence, Link and FrontMatter nodes (Markdig, YamlDotNet; front matter that is not a mapping gives a node without key tags, never a failed build) and the markdown search finds them. A link carries target:<raw target> and is never resolved to resolved:<fqn> in a built or reindexed index.
  • Selectors (RT-44, RT-38). node_outline and node_read (text, range, SHA-256, uncut) address a member by readable selector, Markdown heading path (A/Notes[2], ordinal on any segment) or @ts: path; an ambiguous overload lists its candidates; grammars with no handler (.py, .rs) are refused by name.
  • access_cost (RT-35) per member by fqns or changed_files, parity with access-cost.py; lambda bodies stay out of the enclosing member's metrics.
  • structural_search (RT-31): native rule engine (kind, pattern, regex, field, inside, has, not, all, any, stopBy) over C#, TypeScript and Markdown; an unparseable pattern or an unknown key is refused by name; max_files exceeded reports truncated.
  • Graph kinds (RT-33). EdgeKind gains Tests, Documents and ProjectDepends (flags 1<<5 to 1<<7; there is no references kind). edge_kinds and node_kinds of dependency_graph and sub_graph are now arrays of lowercase strings (calls, imports, inherits, tests, documents, project_depends; file, project, namespace, type, member, doc_section, test) where they were arrays of enum values; the legacy enum names (Imports) are still accepted case-insensitively, an unknown name is refused naming it, and responses keep the enum names. ProjectGraphBuilder reads each csproj for project_depends and Contains edges, TestEdgeLinker tags [Fact]/[Theory] methods and links tests edges. Limit: a tests edge to an overloaded member links every overload, and TypeScript tests are tagged without tests edges.
  • Dev-workflow queries (RT-34, RT-36, RT-37). affected_tests (changed_files or base, default the working tree) answers all, test_projects, test_classes, unresolved; batch_anchors (closure, overlap; an unresolved anchor never proves disjointness); documented_in and documents_of over Documents edges built from Markdown code spans, links and headings (DocumentsEdgeLinker; documents_of reads at most 1000 sections).
  • Incremental reindex (RT-30). incremental_reindex and the freshness pass re-parse only the changed files (the discovery filters apply to each path) and patch the store per file, at a cost proportional to the changes. It does not re-resolve dependents: a call from an unchanged file into a newly added symbol, and a test calling a symbol added in another file, wait for a full reindex.

Reference: RaggableTree, limitations.

Added — structural editing: node_replace, node_insert, edit_batch, structural_rewrite, intent operations (RT-39, RT-40, RT-41, RT-32, RT-42, RT-43, #173, #174, #175, #166, #176, #177)

  • node_replace splices one node's bytes, refuses a stale expected_hash (StaleHashException) and any new parse diagnostic, and restores a backup when the write fails. node_insert adds a node inside, before or after an anchor.
  • edit_batch applies node_replace and node_insert over several files as one transaction (EditTransaction): hashes checked on the progressively edited bytes, every file re-parsed before the first write, a journal /output/edit-batch/<id>.journal replayed only while it matches, validate: "build" restores on a red build.
  • structural_rewrite applies a rule's fix (FixTemplate), dry_run by default, a file that does not parse refused alone. Best-effort atomic, not atomic: see limitations.
  • Intent operations ensure_using, ensure_import, ensure_field, ensure_member, ensure_section, insert_under_heading, replace_mermaid, through the node_ensure tool and the op field of edit_batch. A no-op writes nothing and reports applied=false.

Added — github create_pr (RT-17, #158)

github takes action = create_pr with base, head, title and an optional body, and returns the pull-request URL; it needs a token with pull-request write scope.

Changed — tracking issue #179

Every RT item above is traced in the run's plan; the gaps that ship are recorded in docs/reference/limitations.md, and the tool-count claims are brought to the code (#179).

Added — orkeon quickstart writes the README's two-minute crew, no clone needed

orkeon quickstart [--to <dir>] writes crew.yaml and appsettings.json — embedded in the tool byte for byte from examples/quickstart/ — and an empty out/ into ./orkeon-quickstart/ by default, then prints the two runs to make from there: orkeon run crew.yaml --mount ./out:/output:rw, then the same with :ro. It never overwrites: a file or a folder that is not empty at the target is refused with exit 1, as are an unknown option, a word too many and --to without a folder. The README (EN and FR) opens on that block, followed by a second, marked <!-- quickstart-refused:begin/end -->, the read-only run; .github/workflows/quickstart.yml runs both from the README and asserts orkeon-quickstart/out/hello.md, then required Write, effective ReadOnly in the second run's log and the file unchanged. Reference: orkeon quickstart.

Changed — the console's bottom area takes a Claude-Code-like look [breaking]

In the Terminal.Gui console (Orkeon.Cli.TerminalGui), the area under the transcript is redrawn from semantic colour roles on the terminal's own background (the fixed #0d0d0d background is gone; 24-bit colour when COLORTERM is truecolor or 24bit, 16 named colours otherwise):

  • Separators. A dim ─ rule above and below the prompt; the top one ends with ── <task> ─ in the accent while the recipient is not main. It replaces the session chip.
  • Prompt. ❯ accent and bold; the placeholder dim and italic.
  • Status bar. Indented, parts joined by a dim ·: the permission mode as a phrase (⏵⏵ bypass permissions on (shift+tab to cycle), yellow for bypassPermissions, dontAsk and acceptEdits), the hints, ↓ tasks when a task exists; ↑/↓ select · enter view from the list. The recipient left the bar.
  • Tasks list. After a blank line: main first, then creation order (it was newest first); ❯ cursor while the list has focus (never while the keys go to the prompt), ● recipient / ◯ others coloured by state (green while running, red when failed or cancelled, dim otherwise), bold name, phrase cut with …, dim right-aligned <duration> · ↓ <tokens> tokens (the task's total). Widths are terminal columns over graphemes (an emoji or a CJK character counts two); on a narrow pane the phrase gives way, then the name, then the metrics. A resize rebuilds the rows at the new width. It grows to 6 rows, then scrolls instead of dropping rows.
  • Transcript. ● <name>(<intent>) then ⎿ Backgrounded agent (↓ tasks) when a task appears; ● Agent "<name>" finished · <duration>, ✗ … failed · … or ⊘ … cancelled · … when it ends, from the host's ended tasks (TuiIntegration.FinishedAgentRows), so a task that starts and ends between two polls gets both lines, in order; @<task> finished · recipient is main when the recipient ends while the prompt has focus; ⎿ Interrupted · What should Orkeon do instead? on Esc Esc. A poll whose provider throws writes nothing and leaves the rows, the list and the recipient as they were.
  • Glyphs. ◯, ✔, ⏵⏵ and the new ⎿ (GlyphSet.Elbow), ↑ (GlyphSet.Up) and … (GlyphSet.Ellipsis); ASCII > * o v > | * - ^ ..., the hint bar's arrows, the cut phrase, the recipient label, the placeholder and the model witness included.
Removed Replacement
TuiIntegration.ContextChip, ContextChipInfo none: the top rule names the recipient (RuleChipView.SetLabel)
RuleChipView.Bind(TuiIntegration) RuleChipView.SetLabel(string?), Refresh()
SchemeFactory.Chip(), Rule(), Posture() SchemeFactory.Attr(PaletteRole, …), Dim(), Accent(), Alert(), Uniform(Attribute)
AgentsPaneModel.FormatRow(…, nameColumn), NameColumn internal segment formatting; AgentRowInfo.State (TaskRowState) colours the bullet
HintBarModel.LeftSegments internal HintBarModel.Segments
HintBarModel.ComposeLeft none: internal segments

Added: GlyphSet.Up and GlyphSet.Ellipsis (required: a hand-built GlyphSet sets them), and TuiIntegration.FinishedAgentRows (Func<IReadOnlyList<AgentRowInfo>>?: the ended tasks the host retains, oldest first, with their final State; null keeps the rows-only finished line).

Migration: a host drops TuiIntegration.ContextChip (the tasks list gives the recipient); callers of the removed members move to the replacements above; a host that builds its own GlyphSet adds Up and Ellipsis, and one that wants the failed and cancelled lines wires FinishedAgentRows.

Changed — the prompt reads keys in three states: field, history, tasks list [breaking]

In the Terminal.Gui console, ↑/↓ on the prompt walked the history in both directions, and the agents list was reached only with F4. A key is now read in one state, never twice:

  • Field. ↑ on the first visual row enters the history (the typed text is kept as the draft, the newest entry is shown, caret at the end); with no history the caret moves as usual. ↓ on the last visual row focuses the tasks list when it holds a task other than main, and does nothing otherwise. On a long wrapped line ↑/↓ first move through its rows. Home/End reach the line's ends, Ctrl+Home/Ctrl+End the text's.
  • History. ↑ older (nothing on the oldest), ↓ newer, and from the newest the draft back; any edit leaves the history and keeps the text; Enter sends the shown entry and drops the draft. Blank entries and a repeat of the newest are still not recorded.
  • Tasks list. ↓ down without wrapping, ↑ up and back to the prompt from the first row, Esc or F4 back to the prompt (text and caret restored), Home/End first/last row, Enter prints the task's detail and sends nothing, a printable key returns to the prompt with it typed. Tab leaves the list like Esc; Ctrl+V or a right-click leaves it and pastes at the restored caret; Esc Esc from the list interrupts the prompt's turn. The state follows the focus: a click on a row enters the list on that row (a double-click also opens it), and focus reaching the prompt by any other way leaves the list and keeps the current text. The selection is kept by ticket across the list's re-sort; an emptied list gives the focus back to the prompt.
  • Recipient. The selected row is the recipient of the next message: the placeholder reads Message @<task>… and the rule above the prompt ends with ── <task> ─; main is the default. Until a host wires TuiIntegration.SendToTask, Enter to a task prints that sending to a task is not supported yet and keeps the text in the field.
  • Hint bar. f4 agents becomes ↓ tasks in the field and ↑/↓ select · enter view in the list. F4 and the new keys stand down while a modal dialog has focus, as Ctrl+V does.

Migration: ↓ on the prompt's last row no longer walks the history forward from the field: it focuses the tasks list when one runs. Walk the history with ↑, then ↓ back to the draft; leave the list with Esc. See docs/architecture/cli-ts-commands.md and src/cli/Orkeon.Cli.TerminalGui/README.md.

The console's public API moves with it (src/cli/Orkeon.Cli.TerminalGui/PublicAPI.Unshipped.txt):

Before After
HintBarModel.LeftSegments(permissionMode, commandRunning, agentsPaneAvailable) removed (see the bottom-area entry); the f4 agents segment is ↓ tasks
— TuiIntegration.SendToTask (Func<string, string, bool>?: ticket, text, true when delivered); null keeps the text in the field

Changed — the REPL interrupts with Esc Esc, and Ctrl+C only copies [breaking] (CH-02..CH-07)

In the Terminal.Gui console, Ctrl+C cancelled the running command, and a second Ctrl+C quit the application, so a stray double press closed the whole session. The keys now say what they do:

  • Esc Esc interrupts the prompt's turn. The first Esc clears the draft (and arms the pair, on an empty draft too); the second, right after it, cancels the turn submitted from the prompt, whether it runs as a synchronous command or as a dispatched ticket, a retry backoff included (the /ps ticket shows cancelled). The hint bar shows esc esc to interrupt while that turn runs.
  • No key cancels a background crew. A ticket started by anything else (a detached crew, compaction, indexing) keeps running and stays reachable through /cancel <ticket>.
  • Ctrl+C only copies. With a selection it copies it; without one it prints a one-line hint. It never cancels and never quits.
  • In the tasks list (↓ or F4), Esc returns to the prompt and cancels nothing, a turn running or not; a second Esc right after it interrupts the prompt's turn.
  • Ctrl+Q asks before quitting during the prompt's turn, as it already did during a synchronous command.

Migration: interrupt a turn with Esc Esc on the prompt, quit with Ctrl+Q (confirm while a turn runs); a script or a habit that sent Ctrl+C to stop a command, or twice to leave, no longer does either. See docs/architecture/cli-ts-commands.md and src/cli/Orkeon.Cli.TerminalGui/README.md.

The shipped public API of the console moves with it (the owner allowed it; each change is in the projects' PublicAPI.Unshipped.txt):

Before After
HintBarModel.ConfigWitness ("/rc") Removed: the witness is HintBarModel.Witness(ModelWitnessInfo?, GlyphSet), coloured by HintBarModel.WitnessScheme(ModelAvailability), at most HintBarModel.WitnessMaxWidth (24) columns
HintBarView.Bind(runner, integration, agentsAvailable, configUsable, …) configUsable is replaced by Func<ModelWitnessInfo?>? modelWitness, read at each refresh
— TuiIntegration.PromptTurnRunning (Func<bool>?) and TuiIntegration.ModelWitness (Func<ModelWitnessInfo?>?); a null delegate reads as "no turn" / the Llm:Model setting
— ReplPaneView.InterruptRequested (raised by the second Esc); SchemeFactory.Warn() and SchemeFactory.Error()
CommandDispatchService.BeginCommand(name, ct, timeout) BeginCommand(name, ct, timeout, string? promptLine = null); PromptTurnTickets() returns the prompt turn's tickets still running

Added — the console's witness names the selected model, coloured by what its calls did (CH-08)

The right-aligned /rc of the hint bar, which only said whether a config was loaded, is replaced by the name of the selected model, truncated to 24 columns with …. Its colour follows the calls the console has observed, never a probe: green on a final 2xx (and before any call), amber during a retry backoff of that model, red after a final non-2xx, a timeout, or when no model is configured (no model). Only the displayed model's calls colour it, a change of model resets it, and a call ended by the caller leaves it unchanged. The name is the selected_model key of the session state (SessionStateKeys.SelectedModel, beside default_permission_mode); Orkeon Code's /model does not write it yet, so the witness reads Llm:Model meanwhile.

  • ILlmRetryObserver.OnCallSettled(LlmCallSettlement) is new (a default body calls the parameterless OnCallSettled(), so existing observers still compile); LlmCallSettlement carries the effective Model and Succeeded, and LlmRetryEvent.Model names the model of a retry.
  • ModelAvailability (Available, Reconnecting, Unavailable) is new in Orkeon.Cli.Abstractions, and ModelWitnessInfo in Orkeon.Cli.TerminalGui.
  • LlmRetryProgressObserver gains Current, Reset() and OnCallSettled(LlmCallSettlement); a host registering its own ILlmRetryObserver gets a witness that stays green.

Fixed — the script and crew pumps no longer hold a thread-pool worker (GAP-57)

A root pump blocks its thread until the engine's promise settles; started on the thread pool, it held a worker for the whole run, and the Scripting test module hung when the pool was capped at 6 workers. ScriptHost.EvaluateAsync and JsCrew.RunAsync now start theirs on a dedicated thread (RootPump.Start): one thread per script and per crew run driven from C#, with no bound on their number. JsTool.CallAsync stays on the pool: a dedicated thread per tool call cost 145 to 164 µs per spawn against about 10 µs for the call. In the tests, every engine awaited asynchronously waits under HangGuards.EnginePromise (2 minutes) instead of Jint's implicit 10 seconds; the product default is unchanged. See scripting.md.

Fixed — Ctrl+V pastes into the input, and a drag selects in it (CH-09, CH-10)

Ctrl+V did not paste into the input in Windows Terminal and the PowerShell session on WSL, while a right-click did. A global key handler now pastes the clipboard into the input in the runner and in the REPL modes, and stands down while a modal dialog has focus. A mouse drag in the input highlights text and copies it on release, as in the transcript.

Fixed — the banner shows the built version without build metadata (CH-01)

The banner's product line carried the +<sha> build metadata of the informational version. It shows the version of src/Directory.Build.props only (1.0.0-rc.5).

Added — every built-in tool is typed in the shipped typings (#125)

OrkeonTools declared a handful of tools by hand, and three of them did not match the tools: fileRead took encoding where the tool reads max_length, directoryRead recursive where it reads max_results; every other tool fell through the index signature and type-checked only with a cast. Typings/tools.generated.d.ts now declares the input and the result of every built-in tool a run registers (OrkeonBuiltInTools, which OrkeonTools extends), written by BuiltInToolTypings from each tool's request record (its [JsonPropertyName] names, its required members) and response record; an optional member that is nullable takes null (sessionStore({ operation: "set_state", key, value: null }) removes the key), a required one never does (the tool refuses it). BuiltInToolTypingsTests pins the committed file against the tools and type-checks a script that calls them: a parameter renamed on the .NET side, or misspelled in a script, fails tsc. The e-mail and drive families keep their hand-written declarations; the index signature remains for plugin and MCP tools. The hand-written fileRead, fileWrite, directoryRead, webScrape, httpApi, searchTool, databaseQuery, delegateWork and askQuestion are gone: the four names no tool answers to (searchTool, databaseQuery, delegateWork, askQuestion) now fall to the index signature.

Changed — the web and RAG lookups are reads for the permission gate (#126)

web_scrape, scrape_element, rag_search and rag_ingest declared no access, so the gate classified them as writes: every call asked in default and was refused in plan and dontAsk. The first three now declare ToolAccess.Read. rag_ingest declares ToolAccess.Edit: it writes into the knowledge index, not into the workspace, so acceptEdits accepts it, default asks and plan refuses it. BuiltInToolAccessTests lists the built-in tools a run registers that still declare nothing.

Fixed — waiting for the operator no longer spends an agent's wall-time budget (#127)

A crew agent's .budget({ wallTime }) counted the time the permission gate held a tool call for an operator's answer: an approval that took a few minutes ended the agent with Wall time exceeded although the agent itself had not run that long. AgentExecutionBudget.PauseWallClock() stops the budget's clock, and ctx.llm.act holds it while the gate decides, as it already did for the engine's ExecutionTimeout. An agent that runs past its budget on its own is still ended.

Added — a script reads whether the permission gate is on (#128)

Without Orkeon:Security:PermissionGate:Enabled = true no gate is registered: every tool call of ctx.llm.act runs unchecked, and the permissionMode a script posed had no effect, with nothing to tell it so. The state is now read-only for scripts: a crew reads it as ctx.llm.permissionGate.enabled (typed in context.d.ts), a scripted command as ctx.services.get("permissions").enabled (typed in orkeon-cli.d.ts; false, the session's rules and the modes check nothing). An act() call that passes a permissionMode on a host without a gate logs one warning saying the mode checks nothing.

Changed — Shell commands are confined by default [breaking]

shell_command used to run its process on the host, as the user of the host, unless an operator set Orkeon:Tools:Shell:Confinement:Mode = Bubblewrap. Its process is now confined by default (ADR-014):

  • Auto, the new default, picks the backend of the platform: bubblewrap (bwrap) on Linux, Seatbelt (sandbox-exec) on macOS, an AppContainer inside a Job Object on Windows 10 and later. The process sees the agent's mounts (read-only when the VFS grants no Write), the system directories read-only, nothing else of the host, and no network unless Confinement:AllowNetwork.
  • Off in a container. When the host runs in a container (/.dockerenv, /run/.containerenv, DOTNET_RUNNING_IN_CONTAINER=true), the container is the boundary: Auto leaves the shell unconfined and logs it once (shell confinement off: running in a container; set Orkeon:Tools:Shell:Confinement:Mode to force it). The orkeon-runners, console and orkeon-host images also set Orkeon__Tools__Shell__Confinement__Mode=None explicitly.
  • Fail closed. When the backend is unavailable (bwrap missing, user namespaces refused, a mode for another platform), the call fails with the reason and the way out (Orkeon:Tools:Shell:Confinement:Mode = None); the command never runs unconfined.
  • One shell session per agent run. An agent's commands run in one persistent shell, opened at its first command and bound to the run (AgentRunScope): the confined view is built once, and the session and every process it started are killed when the agent ends, fails or is cancelled, and when the host dies (by the kernel under bubblewrap and the Job Object; by a watchdog polling every second under Seatbelt and unconfined on Linux and macOS). A timeout kills the session and the next command opens a new one; on Linux and macOS the timed-out command returns no partial output.
  • Windows commands. In every mode a program is looked up on PATH only (never the working directory), and a cmd.exe built-in runs as cmd.exe /d /v:off /s /c "<built-in> <arguments>", % refused. A batch file (.bat, .cmd) runs with Mode = None only (npm finds npm.cmd after .exe and .com), through cmd.exe and escaped as a built-in, % refused; an AppContainer session refuses it. Each AppContainer session grants its mounts by ACE, which Windows propagates to every file below them, once per session; a hidden sub path, or a read-only one inside a writable mount, gets a protected DACL for the session, written back at its end (an AppContainer's access check skips deny ACEs). cmd's dir, vol, attrib and where /r answer "Access is denied." in a confined session (they query the drive's root).
  • Cancellation kills the command. A caller's cancellation now kills the running command's process tree; it used to keep running after the call returned.
  • The Debian package depends on bubblewrap. On Ubuntu 24.04 and later, AppArmor restricts unprivileged user namespaces; the AppArmor profile for /usr/bin/bwrap lifts the restriction for bubblewrap alone. Where it is missing, the call fails with bwrap's reason.
Before After
Confinement:Mode absent: None, the process ran on the host Absent: Auto, the platform's backend; nothing changes inside a container
Confinement:Mode = None Unchanged: no confinement — now the explicit opt-out
Confinement:Mode = Bubblewrap Unchanged (Linux only)
A toolchain outside the system directories (/opt/node, ~/.dotnet, nvm) was reachable List its folder in Confinement:ReadOnlyPaths, or set Mode = None
The command reached the network It does not, unless Confinement:AllowNetwork = true
A timed-out command returned what it had printed Linux and macOS: no partial output, and the session is reset
ShellConfinementMode had None = 0, Bubblewrap = 1 Adds Auto = 2, Seatbelt = 3, AppContainer = 4; ShellConfinementOptions.Mode defaults to Auto

Added — Google Drive and OneDrive tools for agents (DRIVE-01..06)

  • A new tool family, Orkeon.Tools.Drive — the ninth of the Orkeon.Tools umbrella, and the third motivated exception to the scope freeze, decided by the owner on 2026-10-17 (ADR-013). Eleven tools: drive_accounts, drive_list, drive_search, drive_info, drive_read, drive_download, drive_upload, drive_create_folder, drive_move, drive_delete, drive_share. Built-in tool classes go from 91 to 102.
  • Two providers, plain HTTP, no new package. Google Drive through the Drive API v3 (folders found by name under each parent; Google Docs, Sheets, Slides and Drawings read and downloaded by export) and OneDrive — personal or for work — through Microsoft Graph. Uploads go through a resumable session in 8 MiB chunks (Google) or, above 4 MiB, an upload session in 10 MiB chunks (OneDrive), so that no request outlives the HTTP timeout.
  • Configuration Orkeon:Tools:Drive, validated at first use like the e-mail section: DefaultAccount, CredentialsDirectory, Screening:WithholdRejected, and per account Provider, a mandatory Rights list (Read, Write, Organize, Share, Delete, Purge), Root, Auth (ClientId, ClientSecretEnvVar, Tenant), Share (AllowedRecipients, AllowPublicLinks), MaxUploadMegabytes, TimeoutSeconds.
  • Guard rails that do not rely on the model. An agent names an account, never a client or a token. Root confines an account to a folder: an item outside it is reported as not found, and search results outside it are dropped. Sharing fails closed — an empty Share:AllowedRecipients allows nobody, no notification is sent unless asked, and public links stay off until Share:AllowPublicLinks. An account that only reads asks for a read-only scope. Deletion goes to the trash; permanent needs Purge. drive_read opens with an untrusted-content notice and the prompt-injection verdict. The token is sent to the API host only: never to a OneDrive download link, an upload session or a paging link elsewhere.
  • orkeon drive accounts | login | logout | check: Microsoft's device code for OneDrive, Google's consent page with a loopback redirect — or the pasted address it ends on — for Google Drive. Tokens live in a drive subdirectory of the runner's internal /credentials root, owner-only on Unix, beside the e-mail family's; one credentials directory per run.
  • Wired everywhere the e-mail family is: the runner host (and orkeon-host, orkeon mcp serve), a run refused at start when a drive tool lacks its right on every ready account, orkeon-repl (registered; its accounts are refused there, the REPL keeping no token store), the .ork.ts typings (tools.driveList…), a "Drive" family in Studio's tool list, the settings catalogue and the configuration reference. The forge removes the drive tools from a forged crew: there is no trial drive yet.
  • Not yet campaigned against a real Google Drive or OneDrive (DRIVE-07, the owner's): the family is covered by offline tests against scripted APIs.

Added — a Drive tab in Orkeon Studio's settings (STUDIO-72)

Studio manages drive accounts the way its Mails tab manages e-mail accounts: list, add, edit, rename and remove the accounts of Orkeon:Tools:Drive in place, without losing anything else of the settings file; the Google client secret remembered like a mail secret; each account's readiness; the sign-in (Microsoft's device code with its countdown, or Google's address with the field for the address the browser ends on) and the connection check, driven through drive login and drive check with --events jsonl (DriveEventKinds). Studio's validation agrees with the engine's resolver and writes the binder's keys (oracle and drift tests). The Drive family of the Tools list now sends to the tab. The JSON editing, the duplicate-key check, the reading of the CLI events and the sign-in panel are shared with the Mails tab, whose behaviour is unchanged.

Changed — the OAuth client of the e-mail family is shared (DRIVE-01) [breaking for a C# implementer]

The OAuth 2.0 client, the loopback listener, the secret reader and the interactive sign-in flows move from Orkeon.Tools.Email to Orkeon.Tools.Abstractions/Auth, internal and shared with the drive family. Nothing an agent or an operator sees changes: the e-mail family translates the shared failures into the same EmailToolException codes and messages.

Before After
IEmailLoginInteraction declared its four members They are declared by the new public Orkeon.Tools.Abstractions.Auth.IOAuthLoginInteraction, which IEmailLoginInteraction now inherits with no member of its own. A class implementing IEmailLoginInteraction compiles unchanged; code compiled against the old assembly must be rebuilt.

The standard tool manifest of the example linter (scripts/data/tool-manifest-standard.txt) is regenerated: the drive tools join it, and so do rag_search, rag_ingest and rag_eval, which every runner host registers since GAP-02 and the previous regeneration predated.

Changed — the create-team assistant speaks the interface's language (#119)

The forge's assistant conversed in French whatever Studio's interface said: the interview had no brief yet, and the engine's default was fr. Studio now passes its interface language with every run (orkeon forge … --lang <code>, a new session or a resume), and the assistant converses in it — until the user writes in another language or asks for one, which the brief then records. The team's name, agents and tasks are written in the brief's language, so the folder named after the team follows it. A brief records any of the five interface languages (fr, en, es, de, zh), no longer fr and en only.

Before After
orkeon forge "<need>" interviewed in French It interviews in English; pass --lang fr for French, or write in French
brief.language: fr or en fr, en, es, de or zh

Fixed — a team's name is no longer cut mid-sentence (#118)

A team created from a long request was named after the first 64 characters of it — « Lire les notes déposées dans le dossier input et rédiger à », folder …-et-rediger-a — because the wizard pre-filled the name from the goal sentence once and never took the assistant's short name that replaced it. The name now follows the session's title until the user types one. A name the 64-character cap still cuts drops its trailing stop words and ends with « … »; a folder name the cap cuts drops them too (FolderSlug.IsStopWord). Existing teams keep their name and folder.

Changed — Orkeon Studio: no more action columns (#117)

Four screens of Studio — My teams, the Folders and Compose steps of Create a team, Run — no longer set their actions in a column beside the content. Content takes the card's width (titles wrap, descriptions clamp to two lines, paths stay on one line cut in the middle by the new MiddleEllipsisText), one or two light actions sit on the object's header line, three or more in a footer bar under it, each with its label. Run shows one verdict line (badge and exit code) and the agents as a table. Access rights read « read » / « read, write » everywhere. New shared styles in Themes/Studio.xaml: BtnQuiet, BtnQuietDanger, CardFooter, FooterItem, HSeparator, VSeparator, ObjectTitle, MetaLine, Description2Lines, PathText, SegmentBtnOn, MountChipTemplate and the FocusRing focus style.

Changed — CI installs the .NET SDK that global.json pins

The workflows asked actions/setup-dotnet for 10.0.x, a version written in thirteen places beside the one global.json already pins for every local build (10.0.300, rollForward: latestFeature). Each of them now reads global.json (global-json-file: global.json): the SDK band is written once, and CI, the developers' machines and Orkeon Code — whose own global.json carries the same pin — follow it together. With latestFeature the action installs the newest 10.0 SDK, as 10.0.x did, so the builds are unchanged. The .NET 11 preview job keeps its own 11.0.x.

Fixed — a ${NAME} or %NAME% reference in a setting a host passes as written refuses the start [breaking]

A setting a host hands to a process as written is never expanded: ${NAME} and %NAME% reached the MCP servers, the e-mail accounts and the paths of a run as literal text and failed late, far from their cause. orkeon, the REPL, doctor and orkeon-host now refuse the start, before any MCP server (exit 1; 78 for orkeon-host), with the correction and never the value. $NAME passes. An e-mail or drive account holding one is reported misconfigured (the problem names the field) and is not used. Studio refuses the same values before saving (STUDIO-SETTING-PLACEHOLDER, one error at its path); Llm:ApiKey keeps STUDIO-LLM-APIKEY-PLACEHOLDER and now refuses sk-${X}; the four indirection prefixes go, so env:X and ORKEON_X are judged as values (GAP-55). See docs/reference/configuration.md.

  • Breaking: a settings file carrying a ${NAME} or %NAME% reference in one of these settings no longer starts.
  • Migration: write the value, or set it in the environment (ORKEON_<path>); for the variable of an MCP server, remove the entry.

Fixed — a crew key no model reads refuses the load [breaking]

A crew YAML key that no model reads, a retired key (rag.provider included), a duplicate, a merge key <<: or a wrong shape was ignored silently and the crew ran without the setting. Each now refuses the load, situated at its file and line, with its path and the nearest key ("is not a key Orkeon reads. Did you mean ..."). The .yml files of a one-folder-per-entity layout are read, and anchors: expands with CRLF line ends (GAP-50). See docs/architecture/yaml-schema.md.

  • Breaking: a crew file holding an unknown or retired key, a duplicate, a <<: merge key or a wrongly shaped value no longer loads.
  • Migration: correct or remove the key the message names; rag.provider becomes Orkeon:Rag:Provider in the settings.

Fixed — every orkeon command reads an argument as it is written [breaking]

--option=value is read as written in every command (a value that holds a line break, a space or ends with one included), -- ends the options, and a word no command reads is refused instead of lost. A usage error goes to stderr with a non-zero exit, while help asked for (orkeon <command> --help) prints and exits 0. forge, the typings command and settings follow the same rule; orkeon-host refuses an unread argument, or a repeated --settings or --working-dir, with exit 78; the AppHost writes --settings=<path>, and Studio passes the need after -- (GAP-51). See docs/reference/cli.md.

  • Breaking: an extra word that was ignored is now refused.
  • Migration: a value that begins with - or holds a space goes between quotes or after --; an option that takes no value (takes no value.) is written without one.
  • Migration: forge list ("list takes no argument."), promote and resume ("take the session slug only: no other word.") refuse extra words; drop them.
  • Migration: orkeon-host exits 78 on an unknown argument or a repeated --settings / --working-dir; remove them.
  • Migration: read a usage error on stderr, not stdout.
  • Migration: orkeon <command> --help exits 0; a script that relied on a non-zero help exit must stop doing so.

Changed — one reading of a model address for the run, the CLI and Studio

The run, doctor, the init command and Studio read a model address the same way, from one Domain reading: Ollama on port 11434 at its root, OpenAI-compatible elsewhere; the address alone decides (a gateway to Anthropic says anthropic in its address). An address no run serves (no http://, a vendor /anthropic path) is refused at start; a silent address is reported; LLM resolved: names the provider; doctor names the one the run builds; the init command refuses a preset the address contradicts, without writing; Studio reports it as STUDIO-LLM-ENDPOINT. LlmProviderDetector is removed (GAP-53). See docs/architecture/llm-providers.md.

  • Breaking: localhost outside port 11434 is no longer Ollama, and …:11434/v1 reaches Ollama.
  • Migration: for an Ollama elsewhere, use its /v1 address and "ApiKey": "not-needed"; add http:// to an address that lacks it; drop the /anthropic path of a vendor address.

Fixed — a mount the run would refuse is refused at start [breaking]

A malformed mount, a missing folder or one outside the whitelist was accepted and then unusable. Run and the REPL now refuse it at start (exit 1), orkeon-host with 78 naming the crew. The whitelist opens the inputs of a command without the flag, and a --mount only with --allow-external-mounts or ORKEON_ALLOW_EXTERNAL_MOUNTS; the implicit flags of run, rag, forge and the daemon go, and a linked folder is whitelisted with its target. mcp serve and forge withdraw a root declared twice without a choice, with a warning. A team's run.sh doubles a " in its folders, and Studio's launchers carry --allow-external-mounts when a folder leaves the team (GAP-54). See docs/architecture/vfs-compliance.md.

  • Breaking: a --mount outside the working directory, accepted before without the flag, is refused.
  • Migration: add --allow-external-mounts or set ORKEON_ALLOW_EXTERNAL_MOUNTS; for orkeon-host, an operator --mount outside the working folder asks for the flag, with crews as well; declare each root once.

Fixed — MessagePack is pinned to 2.5.303 (GHSA-qhrr-8q5h-9q3h)

An advisory published on 2026-10-15 (moderate: nested arrays can blow past buffer length limits) flags MessagePack below 2.5.303. Aspire.Hosting reaches it through StreamJsonRpc at 2.5.302, so the restore audit (NU1902) failed every -warnaserror build that touches the Aspire integration: Orkeon.Hosting.Aspire, its NuGet package, its tests and the AppHost example — CI on main included. Central package management pins no transitive version, so Directory.Packages.props declares 2.5.303 and both Orkeon.Hosting.Aspire and its package reference it directly, the pattern of the System.Security.Cryptography.Pkcs pin. The tests and the example get it through their reference to Orkeon.Hosting.Aspire. No API change; the shipped applications do not redistribute MessagePack, so the third-party notices are unchanged.

Documentation — transcribing audio with Whisper through an MCP server

Orkeon ships no speech-to-text tool; since orkeon-repl connects the servers of MCP:Servers (#107), an MCP server is the way to one.

  • docs/guides/whisper-mcp.md (and its French mirror) wires a local faster-whisper behind a transcribe_audio tool: the MCP:Servers and mount settings, a minimal server, the agent side, and why the server is written as it is — it maps the agents' virtual paths onto its own folders, returns text only, writes a transcript longer than the 4000-character cap of a tool result to a file file_read reads, and loads its model on the first call rather than inside the 30 s handshake. Variants (the OpenAI API, a plugin) and troubleshooting close it.
  • docs/architecture/mcp.md no longer says the REPL registers no MCP: the sentence predated #107 and contradicted the paragraph after it.

Fixed — a mount a variable declares meets the guards of a mount the file declares [breaking]

Before any host, every runner refuses in one line (exit 1, 78 for orkeon-host) a root it keeps for itself, a root declared twice, a selection with no answer and a missing folder. The guards read the settings file, and the ORKEON_ variables for some of them, never the variables without a prefix that the host lays under the file since GAP-36; the reserved-root guard read the file alone. A mount declared by a variable, an Aspire AppHost's WithOrkeonSetting("Orkeon:FileSystem:Mounts:0", …) for instance, passed them and the host mounted it: /sandbox failed the load on "Duplicate virtual paths" (exit 2; orkeon-host started), /crew or /script was replaced by the runner's own mount without a word, orkeon rag mounted its own /workspace or /output over a declared one, and a missing folder fell on the registry's exception. The guards now read the layers the host reads, through RunnerSettings.ReadConfiguration — the environment without a prefix, the file, the ORKEON_ environment — and the host and the guards read one list of entries (GAP-49, decision 2). RunnerSettings.ReadDeclaredMounts, ReadDeclaredAgentFacingMounts and ReadDeclaredInternalMounts keep their signatures; their JSON reader of the file is gone. A file they cannot read gives no mounts, as before, and the host build then refuses it, naming it. The runner-settings check of orkeon doctor reads the same layers.

  • Breaking: a /crew or /script declared by a variable, silently replaced until now, is refused before any host; so is a reserved root, a duplicate or a missing folder declared by a variable without a prefix.
  • Migration: give the mount another virtual root, or remove the variable.

Fixed — orkeon-repl places and guards its mounts as the runners do [breaking]

orkeon-repl appended each --mount after the declared mounts, with no guard and no placement by root: a --mount on a declared root (/workspace, /output), a mount on /sandbox or on the root of a --commands-dir or --crews-dir, two --mount on one root, two entries of one root in the global file (Studio writes one per team) killed the console at its start on "Duplicate virtual paths", stack included; a missing folder fell on the registry's exception; /credentials passed; a declared folder outside the working directory was mounted and refused at every access. The REPL now follows orkeon run (GAP-49, decision 3):

  • Its --mount arguments are placed by RunnerHost's own rule, over its layers (the environment, its settings files, its command line): a --mount on a declared root replaces every entry of that root for the session, and the log says mount /x: --mount replaces the settings entry; on a new root it is appended after the last entry.
  • Before any host, the guards of orkeon run, in its order, read those layers and refuse with its lines, exit 1, without opening the console: a root claimed twice on the command line; a root kept by the REPL (/sandbox, the roots of its --commands-dir and --crews-dir) or /credentials; a root declared several times with nothing to choose one; a missing folder, those of --commands-dir and --crews-dir included. Without --commands-dir, --mount <folder>:/cli-commands:ro is accepted.
  • A declared entry in force is readable outside the working directory, as for a runner.
  • Breaking: a mount on /credentials, and the same --mount twice (appended once until now), are refused at the start.
  • Migration: mount the folder under another name; pass one --mount.

Changed — the line of a root declared twice names only what the command offers

The refusal of a root declared several times with nothing selecting one offered every command --mount-id, the crew's mounts: and --mount; only a crew YAML has the three. The line now names what the command offers (GAP-49, decision 3): a script and --list-tools, --mount-id and --mount; orkeon rag and orkeon-repl, --mount; orkeon forge and orkeon mcp serve, nothing — Keep one of them in <settings>. A crew YAML's line is unchanged, word for word.

Fixed — the Microsoft Agent Framework example reads the settings chain it describes

examples/interop/agent-framework said it read examples/appsettings/appsettings.json by default, and passed --settings, or nothing, to RunnerHost.Build: without --settings it ran on the environment alone, so on the echo provider. It now resolves the runners' chain anchored at its binary's folder (RunnerSettings.ResolveSettingsPath(<--settings>, AppContext.BaseDirectory)) and writes Using settings: <file> on stderr, as the CLI does: started from the repository root, it finds examples/appsettings/appsettings.json (Docker Model Runner). The text it has summarised counts sixteen LLM providers, not fourteen (GAP-49, decision 1).

Added — each GitHub Release attaches the script typings

A script project vendors orkeon.d.ts and orkeon-cli.d.ts, and its copy drifts from what orkeon typings writes: nothing named the typings of a release, so nothing could pin or diff them. release.yml now attaches orkeon-typings-<version>.tar.gz, a folder of that name holding the two files, to every Release. They are the output of orkeon typings, run on the orkeon of the linux-x64 staging tree, so the asset is the tool's own embedded copy and not a second build of the sources. The archive is byte-reproducible (sorted names, the commit date as modification time, no gzip header), has its line in SHA256SUMS like the SBOM, and is attested with the other *.tar.gz by the release job; check-release-assets.sh already sees it through its *.tar.gz glob, and its test now has a typings archive in the set. The editor-setup sections of the scripting reference and the guide, the orkeon typings reference and the publication matrix say where the typings come from and how to pin them, EN and FR.

Added — the orkeon Debian package ships orkeon-repl

The *.cmd.ts commands run only in orkeon-repl, and apt install orkeon did not give it: the package was built from the cli app set, the orkeon CLI and the two Studio TUIs. It now installs /usr/bin/orkeon-repl, which execs a self-contained payload under /usr/lib/orkeon-repl and points the scripting toolchain at the esbuild under /usr/lib/orkeon, so the package still holds one copy of the binary and still depends on no dotnet-runtime-* package. cli_set_includes admits orkeon-repl on linux-* only (the MSI and the Homebrew formula keep their trees), and package-deb.sh refuses a staging tree whose REPL is framework-dependent rather than package a launcher that would fail at its first run. run-smoke-deb.sh reads the REPL's runtime in the notices check, looks for its leftovers after apt-get remove, and starts it: orkeon-repl --ui plain with stdin closed prints its banner and exits 0. verify-apt-repo.sh runs the same start on the package apt installs, when that package ships the launcher.

To give the deb a self-contained REPL from the one staging tree release.yml and apt-dev.yml both package from, the orkeon-repl row of package-installers.{sh,ps1} is now self-contained: in the multi-app archives too, the REPL no longer needs the .NET 10 runtime. orkeon-slim is the one framework-dependent launcher left. The .zip carries one more copy of the runtime, the tarballs share it by hard links. A Linux install-from-source.sh installs the REPL with the CLI.

Changed — the orkeon-runners image is built for linux/amd64 and linux/arm64

ghcr.io/orkeon/orkeon-runners was a single-architecture manifest: linux/amd64, so Apple Silicon and every arm64 host ran it under emulation. release.yml now pushes one multi-platform tag, and reads it back with docker manifest inspect to fail the job when either platform is missing. Dockerfile.runners runs its build stage on the build platform (FROM --platform=$BUILDPLATFORM) and maps TARGETARCH to the RID suffix once: both dotnet publish -r linux-<x64|arm64> and the @esbuild/linux-<x64|arm64> fetch (URL and lockfile integrity) use it, so the apps are compiled natively whatever the target. The publish is framework-dependent with ReadyToRun off, so nothing in it needs the target architecture; for linux-arm64 the SDK fetches the arm64 apphost pack from NuGet. The runtime stage's RUN steps do execute in the target architecture, so the job registers QEMU for arm64 (docker/setup-qemu-action) next to docker/setup-buildx-action, which a multi-platform push needs. provenance: false keeps the image unattested, as it was.

The local-llm target stays linux/amd64: the llama.cpp build it embeds is x64, a build of the default target never reaches it, and asking for it on another platform now stops with a message at its first step. On an arm64 machine, docker build --platform linux/amd64 --target local-llm ….

Added — orkeon-repl asks the operator about a tool call

With the permission gate on, a tool call the session's mode asked about was refused in the REPL: the default mode of a coding agent was read-only in practice. The REPL now registers an approval channel (AddConsoleToolApproval). A crew running in the background writes its question in the console, the prompt becomes approve <tool>? [y] once / [s] session / [n] no > , and the operator's next line answers it. y runs the call, s also allows the tool for the rest of the session, n refuses it. A / line still runs its command; any other line asks again. Questions are shown one at a time; cancelling the crew withdraws its question, and leaving the REPL refuses those still waiting. The read loop stays the console's only reader: InteractiveRunnerBase offers each line to an IReplLineInterceptor (Cli.Abstractions) before resolving a command, and shows its prompt while a question waits. A crew launched with runCrew (synchronous) cannot be asked; see limitations.md.

Added — the permission gate reads the session's rules, and runCrew asks the operator

ModePermissionGate decided from the tool, its access class and the mode only, so a product's own rules ("allow shell_command for npm test") could narrow a crew's catalogue but never spare a question. IToolPermissionRules (Application) is the port a host's session rules come through; the gate reads it before the mode. A deny rule refuses a call in every mode; an allow rule lets it run without asking in every mode but plan, which stays read-only, so dontAsk runs what a rule allows and refuses the rest. A rule names a tool, and optionally an argument and a pattern the argument must match whole (* for any run of characters). orkeon-repl keeps the rules of its session, and a command sets them through ctx.services.get("permissions"): allow, deny, clear, list (typings: PermissionRulesFacade). A crew launched with runCrew (synchronous) held the read loop, so its question was never answered until RunCrewTimeout cancelled it: the waiting call now reads the answer from the console itself, and the time taken to answer does not count in the timeout.

Added — an approval channel decides the permission gate's asks

ModePermissionGate answered an ask with a refusal, and nothing in the framework could put the call to an operator. IToolApprovalChannel (Application) is that port: it takes a ToolApprovalRequest (tool, arguments, mode, reason) and returns AllowOnce, AllowForSession or Deny. A gate built with a channel puts every ask to it and returns allow or deny, with … The operator denied the call. on a refusal. AddOrkeonPermissionGate builds the gate with the channel the host registered, if any; without one, nothing changes. Interactive now only concerns a host that resolves asks itself.

Added — orkeon-repl connects MCP servers and loads plugins; scripts reach their tools

A product built on the REPL could add tools only in TypeScript. orkeon-repl now registers MCP:Servers as the runners do and connects the servers before it loads its commands (a server that fails costs one error line), and loads the plugins of a Plugins section (AddOrkeonPlugins; discovery reads the declared mounts behind the registry's checks, since the agents' path validator refuses every .dll). The scripts' catalogue — a command's tools namespace, an agent's .tools([...]), ctx.llm.act — was a snapshot of the container's tools, and an MCP server's tools enter the tool registry only: no .ork.ts script could name one, under orkeon run either. ScriptToolCatalogue (Orkeon.Scripting) is the container's tools then the registry's others, read again for each engine; the REPL, .ork.ts crews under orkeon run and procedural scripts use it, and a procedural script's servers are now connected before it runs. The Plugins section is now read by a shipped binary, so a runner no longer reports it as read by none.

Changed — the script's time limit stops while the permission gate decides

ExecutionTimeout, the engine's wall-clock limit, counted the time a tool call spent in the permission gate. An approval channel can hold a call until an operator answers, and that wait would have spent the script's limit. ctx.llm.act now stops the engine's clock while the gate decides. Otherwise the limit is measured as Jint's TimeoutInterval measured it: one window per reset, no limit when it is zero or infinite, and the same TimeoutException. The clock belongs to the engine, so a pause holds for every agent the engine runs.

Security — shell_command asks every right of the paths a writing command names

ShellCommandTool checked a virtual path on the command line, and the working directory, for read access only, whatever the process would do with it. With interpreters allowed, or a command added to the allowlist, a read-only mount passed the check and the process wrote there: find /docs -name '*.tmp' -delete deleted files of a read-only /docs. A command of the read-only default list (git while its restriction holds) still needs Read. Any other command (an interpreter, an extra or custom command, git once interpreters lift its restriction) now needs every right (read, write, create, delete) on the paths it names and on its working directory, which defaults to the first mount that grants them. The refusal says why and that the mount stays readable through the file tools. Migration: run such a command where it may write; read a read-only mount with file_read or cat. A path the process reaches by itself, inside a script, is still outside the VFS.

Security — System.Security.Cryptography.Pkcs pinned to 10.0.13

Two .NET denial-of-service advisories published on 2026-10-13, GHSA-846f-f764-76mx (high, NU1903) and GHSA-2fmv-rv2c-59x7 (moderate, NU1902), cover System.Security.Cryptography.Pkcs up to 10.0.12 and 9.0.20. Orkeon took it transitively, 10.0.0 through MimeKit and 9.0.18 through Microsoft.Data.SqlClient, so every package and installer carrying the e-mail or data tools shipped a vulnerable version. It is now pinned to 10.0.13 in Directory.Packages.props, through a direct reference in Orkeon.Tools.Data, Orkeon.Tools.Email and the Orkeon.Tools package.

Added — shell_command can run its process in a view built from the VFS

Once shell_command ran an interpreter or a shell, the VFS stopped at the command line: the process worked on physical paths, read and wrote wherever the host's user could, read-only mounts included, and reached the network. Orkeon:Tools:Shell:Confinement:Mode = Bubblewrap (off by default) now runs it under bwrap on Linux: every namespace unshared, each agent-facing mount bound at its virtual path (read-only when it lacks Write, a sub path without rights covered), the system directories and Confinement:ReadOnlyPaths read-only, a fresh /proc, /dev and /tmp, nothing else of the host, and the network off unless Confinement:AllowNetwork. The process sees the virtual paths, so bash /workspace/build.sh finds /workspace and its echo x > /docs/f gets a read-only file system error. When bwrap is absent or cannot create its namespaces (another OS, an unprivileged container), the call fails with the reason and the command does not run. The nightly integration run installs bubblewrap and runs the confinement suite. Limits are in limitations.md.

Removed — public surfaces nothing called, third pass [breaking]

Types and members with no caller left in the framework, the REPL or the examples (GAP-47).

  • Phase 3 services (decision 1): Orkeon.Application.Services.ErrorHandling, Services.Generic and Services.TaskRouting (PatternMatchingErrorHandler, ErrorClassifier, TaskExecutionRouter, TaskExecutorFactory, ResearchTaskExecutor, ResearchFindings...), RetryDefaults, and in Domain TaskClassificationService, TaskCategory, ResearchTask, AnalysisTask, CodeGenerationTask with their contexts. Migration: none was registered; retries and error handling live in the strategies and the resilience policies, and a task is a CrewTask.
  • Mappers, DTOs and value objects of an absent HTTP API (decision 2): CrewMapper, TaskMapper, ExecutionMapper, ToolMapper, the list overloads and ToSummaryDto of AgentMapper, ApiResponse<T> and the other ApiDTOs, ApiMetadata, ToolMetadata, ToolDto, ExecutionResultDto, CollaborationDtos, LlmConfigOverrideDto, LlmThinkingConfigDto, TokenUsageDto, TokenModelUsageDto, MemorySearchFilter, the Application BatchOutput (not the one of ICrewOrchestrationService), MessageDefaults, PaginationDefaults, and Domain AgentCapabilities, CollaborationContext, CommunicationProtocol, PerformanceMetrics, SecurityContext, TaskComplexity. Migration: define the DTOs of your own API in your host; AgentMapper.ToDto(agent) remains. The unused Orkeon.Application.Common.DTOs.MemoryItemDto goes too (the MemoryItemDto of SearchMemoryQuery stays).
  • Read DTO fields no handler fills (decision 3): CrewDto keeps Id, Name, Description, ProcessType, Status, Verbosity, CreatedAt; AgentDto loses Llm, Capabilities, PerformanceMetrics, Metadata, WithStatus, WithPerformanceMetrics; TaskDto keeps Id, Name, Description, ExpectedOutput, AssignedAgent, Status, Priority, CreatedAt. LlmDto, AgentCapabilitiesDto, PerformanceMetricsDto, TaskComplexityDto, TaskOutputDto, MemoryConfigurationDto, CrewDefaults.DefaultEstimatedTaskDuration and Domain OrchestrationDefaults go with them; the REPL no longer prompts for a task context. Migration: read the crew, its agents and its tasks through their own queries.
  • Interface types nothing used (decision 8): IMemoryScopeFactory, EncryptionResult, DataClassification. Migration: none.
  • Template engine (decision 4): ITemplateEngine, TemplateValidation, Infrastructure/Templating/, TemplateParameters and the Domain Agent/Composition types CompositionResult, CompositionTypes, TemplateParameter. Migration: remove any registration of ITemplateEngine; nothing in a run resolved it.
  • Task delegator (decision 5): ITaskDelegator, the Domain Delegation/ types, DelegationStrategy, DelegationParameters, DelegationDecision and NullTaskDelegator. Migration: remove any registration of ITaskDelegator; delegation goes through the IAgentChannel (Autonomous mode) and the delegate_work_to_coworker / ask_question_to_coworker tools.
  • Mutators of the aggregates (decisions 6 and 7): Agent.SetAgentSelectionStrategy, UpdateGoal, UpdateBackstory, UpdateToolAccessPolicy, ExecuteTaskAsync, ShouldDelegateAsync; Crew.RemoveAgent, RemoveTask, UpdateGoal, ChangeProcessType, SetManagerAgent; AgentMemoryStore.Restore, RetrieveRelevantMemoriesAsync, BuildContext, UpdateEntityMemory, AddEpisodicMemory, ClearShortTermMemory, UpdateCapacities, EntityMemory, EpisodicMemory, with the types EntityMemory, EpisodicMemory, MemoryContext, EpisodicMemoryMetadata, EpisodeEventData and the seven events AgentLeftCrewEvent, TaskRemovedFromCrewEvent, CrewGoalUpdatedEvent, CrewProcessTypeChangedEvent, EntityMemoryUpdatedEvent, EpisodicMemoryAddedEvent, MemoryClearedEvent (30 domain events become 23). Migration: set the process type, the goal and the manager at construction (CrewBuilder, YAML); build the agent with its backstory instead of UpdateBackstory; a crew no longer loses an agent or a task once built.
  • Training subsystem (decision 9): AddOrkeonTraining, TrainingExtensions and the Application, Infrastructure and Domain Training/ folders. Migration: remove any call to AddOrkeonTraining; Evaluation (IEvaluationSuite, the evaluators, the Evaluation section, IBenchmarkRunner) stays.
  • Call override of the LLM cascade (decision 10): the cascade stops at the task. LlmProviderExtensions (GenerateAsync / ChatAsync with a LlmConfigOverride), LlmConfigOverride.ForResponseFormat and the callOverride parameter are removed; LlmConfigResolver.Resolve takes two arguments. Migration: a call passes its own LlmConfig, starting from provider.BaseConfig ((provider.BaseConfig ?? LlmConfig.OnProfile()) with { ResponseFormat = ... }); Resolve(baseConfig, taskOverride); new LlmConfigOverride { ResponseFormat = ... } instead of ForResponseFormat(...).
  • TaskStatus.Blocked: the value no transition reached. Migration: use Pending for a task that waits on its dependencies.

Fixed — crews, tasks, tool calls and security events are measured where they happen

The crew, task, tool and security instruments of the meter Orkeon are now fed (GAP-46). The run registry counts every crew and every task once, at its end, with its outcome (completed, failed, cancelled) and its duration in seconds, and keeps orkeon.crew.active and orkeon.task.active balanced, with or without a span listener. The tool pipeline counts every call with its outcome (success, failure, blocked, cancelled) and its duration, with or without an audit logger. The Guardian counts one orkeon.security.events per blocked call and per warning, and the tool pipeline one per tool result where an injection pattern is detected. No attribute carries an id. The metrics dashboard now reads non-zero crew, task and tool figures after a run.

Fixed — every model call is measured once on the meter Orkeon [breaking]

Every model call is now measured once on the meter Orkeon (OrkeonMeter, Application), succeeded, failed or streamed, with or without a usage sink (GAP-46). Telemetry exports that meter and the dashboard listens to it by name. The crew, task, tool and security instruments are declared there with their names, units and kinds; their durations are in seconds (s). orkeon.cost.total_usd is the process-wide total of the USD costs reported since the process started.

  • Breaking: OrkeonMetrics (Orkeon.Infrastructure.Telemetry) is removed, with its three DI registrations: nothing fed it.
  • Migration: the meter keeps its name Orkeon: subscribe by name, or use OrkeonMeter.Name and OrkeonMeter.Meter.

Fixed — a max_tokens of 0 or less is refused [breaking]

A token cap is a positive integer (GAP-48). A max_tokens of 0 or less is now refused: at YAML crew load (an agent's llm, the crew's llm, naming the crew, and a task's llm_override; it was accepted, and 0 meant the documented maximum or was ignored); by .ork.ts LlmConfig.with, llm.model and llm.profile (maxTokens must be an integer from 1 to 2147483647, no more truncation); and in C# by Agent.Create and CrewTaskBase.SetLlmOverride, which throw ArgumentOutOfRangeException.

  • Breaking: a cap of 0 or less no longer loads or builds.
  • Migration: remove the key to keep the inherited cap, or write a positive integer.

Fixed — a task's llm_override is merged once

ChatOptionsComposer no longer merges a task's llm_override field by field a second time: the configuration LlmConfigResolver merges once is translated onto the chat options, and each field reaches the provider as written on both loops (GAP-48).

Fixed — sampling values reach the vendor as written [breaking]

A temperature, a top_p and penalties written by an agent, a task, the planner (0.3) or the cognitive memory analysis (0.1) now reach the vendor's JSON as written (0.7, never 0.699999988079071), under any current culture (GAP-48).

  • Breaking: PlanningDefaults.Temperature (Domain) and CognitiveMemoryOptions.AnalysisTemperature (Infrastructure) are now double.
  • Migration: read them as double.

Fixed — a task's llm_override: cache: is read, sent and exported

A task's llm_override: cache: block was silently dropped at loading and export. It is now read and sent (cache_control at Anthropic); a block holding no breakpoint turns the agent's cache off for that task; the task's cache is exported and read back. A cache-only override reaches a provider without base configuration, and the MAF bridge warns about the cache only when it requests a breakpoint (GAP-48).

Added — a version directive tsc accepts: // @orkeon-script 1.0

The only directive form, /// <reference orkeon-script="1.0" />, is a TS1084 error for tsc, which then skips its semantic pass: every project that type-checks its .ork.ts scripts had to strip the line first. The runtime also reads // @orkeon-script 1.0, a plain line comment, with the same validation; when a script carries both, the reference form wins. orkeon forge generates the new form. Existing scripts keep working unchanged.

Added — SessionStateKeys.DefaultPermissionMode, the session key the console shares with scripted commands

The console read and cycled the permission mode under a private constant, and a product's /mode command wrote it under its own copy of the string: renaming either side broke Shift+Tab with no error. SessionStateKeys (Orkeon.Constants.Cli) names the key, the console uses it, a test pins it with the cycle, and the scripted-commands page documents it as a contract. The --crews-dir bootstrapper, which a product relies on to resolve runCrew("<name>"), gets its tests.

Fixed — the dontAsk permission mode denies what it does not allow, never asks

ModePermissionGate did not know dontAsk and read it as default: a write or a command became an Ask, which a gate with Orkeon:Security:PermissionGate:Interactive = true would have turned into a prompt, the opposite of the mode. dontAsk now allows reads and denies everything else with a message naming the mode, whether or not an approval channel exists. ActOptions.permissionMode lists it.

Added — orkeon-repl reads mounts outside its working directory (GAP-49, decision 3, in part)

orkeon-repl mounted a --mount, --commands-dir or --crews-dir folder outside its working directory, then refused every access to it ("Path is outside the allowed workspace directory"): a product whose commands live in their own checkout had to start the REPL from a common parent. The REPL now follows the runners:

  • --allow-external-mounts (or ORKEON_ALLOW_EXTERNAL_MOUNTS=1) makes a --mount outside the working directory readable; without it, such a mount stays mounted and refused at access, as for orkeon run.
  • The --commands-dir and --crews-dir folders are entries of the REPL, like the script of orkeon run: readable wherever they are.

The rest of GAP-49's decision 3 (one placement and the runners' guards for the REPL's mounts, declared entries in force included) is the entry "orkeon-repl places and guards its mounts as the runners do", above.

Changed — scripted commands load up to 200 files by default

Orkeon:Cli:ScriptCommands:MaxScripts defaulted to 50: a commands folder past it lost its last files, in path order, with one warning in the start-up log, and the user found out when a command was unknown. The default is now 200, above a real command set; the description says what the cap does (the files the loader keeps), not engines kept in cache.

Fixed — ctx.llm.act calls tools on every provider, all the calls of a turn

act read tool calls in the OpenAI shape only, ran the first call of a turn and sent its result back as a user turn cut at 4 000 characters. With the Anthropic provider no call was ever found, so the model's first answer was the final one; the other calls of a turn were dropped without a word; and a file_read result lost all but 4 000 of its 32 000 characters.

  • The calls are read with the framework's parsers, from the Anthropic Messages body or the OpenAI body, buffered or rebuilt after a stream; a call the parser cannot read is the final answer, where a call without its function used to throw.
  • Every call runs, in order, each through the permission gate and the tool-call budget, and the turn is replayed in the provider's tool protocol: the assistant turn with its calls, then one tool message per call.
  • A result is cut once, at AgentDefaults.ResolveMaxToolResultLength, with the framework's notice; a failed provider turn resolves output to <undefined-llm:<error>>, as complete.
  • NativeToolCallTranscript (Application) holds the assistant turn and the bound, shared by the C# agent loop and act.

Fixed — Verify what you install is measured on v1.0.0-rc.5 and says who signs what

The guide printed v1.0.0-rc.3 outputs and said GitHub's Sigstore instance signs the build provenance: it is signed with a certificate Sigstore's public instance issues to the workflow, and entered in its transparency log (Rekor). The publication matrix said the same and is fixed.

  • Every command was run again on the published v1.0.0-rc.5 artefacts.
  • Immutable Releases join the mechanisms: GitHub's own release/v0.2 statement covers the tag and every asset, both SHA256SUMS manifests included.
  • The token-free API query decodes the statements with jq and prints the builder and the commit; the Release's SBOM and publish.yml's are told apart; a table opens the page with the check for each kind of file.

Fixed — a run is a trace [breaking]

A run now emits one trace: crew.run for the crew, task.run per task, memory.recall and memory.store under their task, the agent turns (invoke_agent) under their task. A failure or a cancellation ends the span in error. The Orkeon.Scripting source is listed in OrkeonActivitySources.AllNames, so the spans of a procedural script are exported. TaskResult gains EndedAt (Application).

Every call to the host's model and every embedding now has a span: the providers' entrance opens chat {model} for a call made outside an agent turn (the manager, the planner, a host's own call), with orkeon.llm.operation, never a second one inside a current chat; the registered IEmbeddingProvider opens embeddings {model} (GenAiAttributes.OperationEmbeddings, Constants.Llm) for each call to the embedding model, none for a cache hit.

  • Breaking: TracingInstrumentation and OrkeonTelemetryChatClient (Orkeon.Infrastructure.Telemetry) are removed: nothing in production called them.
  • Migration: wrap the chat client with Microsoft.Extensions.AI's UseOpenTelemetry() on the chat client builder; the run's own spans need no call.

Changed — the turn lines of a verbose agent move to category Orkeon.Verbose

The tool calls, tool results, model responses and the wait for its MaxRpm turn of a verbose agent (every agent of a verbose crew) are logged at Information under Orkeon.Verbose. The runner shows that category without -v and at -v 1, unless Logging:LogLevel names Orkeon.Verbose or Default. A host that filters by category must let Orkeon.Verbose through; a host passing configureLogging sets its logging alone, the runner adds nothing.

Changed — an agent's PromptTemplate now wraps the task's prompt [breaking]

PromptTemplate was copied onto the agent and nothing read it: it now wraps the first prompt of each task the agent runs, every {{ .Prompt }} replaced by the prompt composed as before (AgentDefaults.PromptTemplateMark). Retries, corrections, tool messages and the manager's prompts are not wrapped; an agent without a template sends the same prompt, byte for byte.

  • Breaking: a non-empty PromptTemplate without {{ .Prompt }} refuses the construction of the agent (Agent.Create, AgentBuilder.Build(), the YAML load); an empty one counts as none.
  • Migration: put {{ .Prompt }} where the task's prompt goes in each PromptTemplate, or remove the template: it had no effect.

Changed — an agent's MaxExecutionTime is now enforced [breaking]

maxExecutionTime (max_execution_time, whole seconds) in YAML and maxExecutionTime(seconds) in .ork.ts reach the agent as a TimeSpan; a refused value fails the load or the script's build().

  • Breaking: a task longer than its agent's MaxExecutionTime now fails (ExecutionTimeExceeded).
  • Breaking: AgentDto.MaxExecutionTime is now int? (null without a limit, was 300).

Changed — the attributes nothing read are gone [breaking]

CacheEnabled, MaxRetryLimit, ShareCrew, OutputLogFile, Language and FullOutput were set by the builders and stored on Agent and Crew, and nothing read them: they are removed, with LanguageCode and CrewDefaults.DefaultLanguage. AgentDefaults.MaxRetryLimit stays, for the retries of a communication or a training run.

  • Breaking: the six properties of Agent and Crew, their builder methods (AgentBuilder, CrewBuilder, AgentSpawnRequestBuilder), their AgentCreateOptions / CrewCreateOptions members and their arguments of Agent.Create, Crew.Create and AgentSpawnRequest are removed.
  • Migration: remove the calls to CacheEnabled, MaxRetryLimit, ShareCrew, OutputLogFile, Language and FullOutput, and their Agent.Create, Crew.Create and AgentSpawnRequest arguments: none had an effect. Ask for a language in the task or the backstory; keep a run's log with orkeon run --events jsonl or KickoffStreamingAsync.

Fixed — the apt pre-push check no longer counts the docs a minimised Ubuntu image drops

The apt-publish job of v1.0.0-rc.5 pushed nothing: its pre-push client, ubuntu:24.04, reported dpkg -V orkeon differences — the three files under /usr/share/doc/orkeon/ (THIRD-PARTY-NOTICES.md and the .NET runtime pack's licences) that the image's /etc/dpkg/dpkg.cfg.d/excludes tells dpkg never to unpack. The package was right; the check read the image's choice as a defect.

  • scripts/apt/verify-apt-repo.sh reads the image's path-exclude / path-include rules as dpkg applies them (the last matching pattern decides) and leaves out the missing lines they explain, counting them in the PASS line. A changed file, or a missing one the rules do not explain, still fails. The same script serves verify-apt after publication, which would have failed the same way on Ubuntu 22.04, 24.04 and 26.04.
  • apt-index.yml runs the publication bench a second time with the release's pinned ubuntu:24.04 as client: its bench packages ship a file under /usr/share/doc.
  • The guide Verify what you install says which missing lines a minimised image prints.
  • scripts/apt/check-apt-branch.sh empties the fake GitHub's request log once its readiness probe has answered. Run on the runner, as apt-publish and apt-maintenance run it, the probe's own 404 127.0.0.1 / stayed in the log and failed "no request answered 404" on every run; the bench serves from a container, where the probe does not exist.

rc.5 reaches the apt rc channel through apt-maintenance.yml seed v1.0.0-rc.5 once this is on main.

1.0.0-rc.5 - 2026-10-12

The release candidate of e-mail and settings. Since 1.0.0-rc.4: agents read and send mail natively — IMAP, POP3, SMTP and Microsoft Graph, Gmail and Outlook presets, OAuth2 sign-in, orkeon email login, Studio's E-mail tab and the Atelier forging crews that send mail (MAIL-01..07, FORGE-10); every setting is catalogued with its type, default and reader, orkeon settings lists them offline and a section no binary reads is reported at start; Orkeon installs with apt on Debian and Ubuntu, from a double-clicked Windows zip or from a clone in one command, and orkeon doctor names the channel; orkeon-host serves its crews over A2A and its tools over MCP; a run keeps what its crew declares — manager, planning, async tasks, memory, rate limits, LLM profiles per agent — and the Flows subsystem is removed; streamed, tool-calling and reasoning LLM calls fail loudly instead of silently (LLM-08, LLM-13, LLM-14); Studio counts every model call live and manages a team's whole life — rename, archive, schedule, import a use case (STUDIO-24..71); and a SonarQube campaign closes 196 of the 200 issues of October.

The public API surface is frozen at this tag: the 1 408 additions and 4 481 removals accumulated since rc.4 move from PublicAPI.Unshipped.txt to PublicAPI.Shipped.txt across the twenty-three projects that carried them.

Fixed — the coverage figure measures Orkeon's own assemblies only

coverage.yml and scripts/sonar-analyze.{sh,ps1} now pass dotnet-coverage.settings.xml to dotnet-coverage, which keeps Orkeon.*, orkeon and orkeon-host and leaves out the test assemblies. Packages that ship their PDB — Aspire.Hosting, StackExchange.Redis, RESPite — were instrumented too: some 126,000 lines that only Orkeon's code exercises pulled the published figure from about 84 % down to about 61 %.

Fixed — an agent that spends its iterations on tool calls still gets its final answer, and the Atelier plans mail tasks that run

An agent whose every iteration went to tool calls now always gets the tool-free turn that asks for its final answer. The text a model writes next to its last tool call ("Mail sent. Now the log:") was taken for that answer: the task failed with MaxIterationsReached and the crew output was the preamble, although the work was done. The loop logs spent its N iterations on tool calls; asking once more, without tools, for the final answer.

The Atelier's plan check refuses a task whose agent holds a mail tool and whose text names a client:// address — internal messaging, which an agent passed as its e-mail account — and its design prompt asks for recipients by e-mail address with no account named. A plan's maxIterations below 6 is raised to 6 in the written crew (ForgeBlueprintAgent.MinIterations); a plan that sets none keeps the engine's default (20).

Changed — the Atelier forges crews that send mail (FORGE-10)

orkeon forge and Studio's Create a team now offer the twelve mailbox tools to the crews they design; only shell_command and code_interpreter stay out of the catalogue. A try never touches a real mailbox: the bench runs it inside a mail trial (Orkeon.Tools.Email.Trial.EmailTrial) over a fictitious mailbox — a shipped sample plus up to five mails drawn from the need — and every send, draft or change is recorded as a simulated action. The actions are saved in runs/<n>/run.json (mailActions), carried by run.finished, printed on the terminal, listed under Studio's verdict and read by the judge, which fails a crew that hands a mail to internal messaging. The configured account's rights, allow-list and caps already judge the try; with no account, a trial account trial allows everything. See docs/guides/email.md, "Forged crews".

A run whose mail tools need a right no ready account grants is now refused at crew load, before any model call (EmailRightsCheck): orkeon run — so every Studio and scheduled launch — exits with code 2 and an ERROR: message holding one line per tool, naming the right and where to add it; --validate fails (exit code 1) with the same lines; orkeon-host fails the run and keeps the lines in its log. See docs/guides/email.md, "A run whose mail tools lack a right is refused at start".

Before After
IForgeJudge.JudgeAsync(brief, output, ct) (internal) JudgeAsync(brief, output, mailActions, ct)
ForgeSandbox.DeniedTools holds the 12 mailbox tools holds shell_command and code_interpreter only

Added — Studio's status bar counts every model call live, estimated then exact, with its call mode (STUDIO-71)

Every model call of a run, a forge or a rephrase now writes llm.call.started, llm.call.progress (at most every 250 ms) and llm.call.finished on the --events stream, with its call mode and its estimated then counted tokens (docs/architecture/run-event-bus.md). Studio's status bar shows the tokens with « ~ » while an estimate is part of them, the mode of the current or last call (« Buffer (repli) » after a fallback), and switches between the Studio session and the execution shown.

Added — every LLM setting has a call mode, Auto by default, and a stream is logged as it arrives (STUDIO-71)

A setting's CallMode (Llm:CallMode, Llm:Profiles:<name>:CallMode: Auto, Buffer, Stream) decides how each of its calls reaches the model, whoever makes it. Auto streams on the wire when the provider streams natively and returns the same answer, tool calls and usage as a buffered call; a clear refusal of streaming before any event falls back to Buffer for the rest of the run, with one warning. Studio's settings screen offers the mode. A streamed exchange now reaches the caller as it arrives through LlmLoggingDelegatingHandler, and is logged as its rebuilt answer once it ends. See docs/architecture/llm-providers.md, "Call mode".

Migration:

Before After
LlmProviderFactory returns the vendor provider under the limiter and the meter one more decorator, CallModeLlmProvider, sits under them: inspect the vendor type through MeteredLlmProvider.Unwrap
a buffered caller of a factory-built provider sends a buffered request under Auto (the default) it streams on the wire when the provider streams natively; set CallMode to Buffer to keep the former request
nothing LlmCallMode (Domain), LlmConfig.CallMode, IStreamingLlmProvider.StreamsNatively (default false), LlmCallModeScope (Application)

Fixed — a Gemini tool call is replayed with its thought signature (LLM-14)

A crew on Gemini 3 through the chat-client loop failed on its second turn: the tool call fed back to the model was rebuilt from id, type and function, and Gemini refused it without the extra_content.google.thought_signature it had sent. A tool call is now replayed with every property the provider sent, buffered or streamed, each call with its own; a provider whose calls carry nothing else receives the same body as before. See docs/architecture/llm-providers.md.

Fixed — a tool with a free or dictionary parameter no longer sends an invalid schema (LLM-13)

The EventHub tools post_message, publish_event, send_request, reply_to and wait_for_event declared their free or dictionary parameters with "type":"any", or emitted a dictionary as an array; strict providers such as Z.AI GLM-5.3 refused the request. A free parameter now carries no type, a dictionary is {"type":"object","additionalProperties":{…}}, and a [{"key":…,"value":…}] array sent by the model is read as the dictionary. See docs/tools/new-tool-pattern.md.

Migration:

Before After
ParameterSchema.Type is string string? (absent for a free parameter)
ParameterSchema(…, Example) one more positional member, Values (ParameterSchema?, default null): Deconstruct takes one more element
ToolSchemaGenerator.InferSchemaType returns string returns string?
FieldSchema.Type with any value outside the seven JSON Schema names and "any", it throws at registration
nothing new public ParameterSchema.IsMap, ReadAsMap, IsKeyValueArray, ToValueDocument

Fixed — a streamed LLM call that does not end is a failed call, never an empty answer

A Studio run streams every agent turn, and a streamed request is sent with ResponseHeadersRead: HttpClient.Timeout stopped counting once the headers were in, so a GLM or Kimi model that thinks for minutes before its first token hung the run past any Llm:TimeoutSeconds, and a stream the provider closed without an answer came back as an empty answer that the agent loop blamed on Llm:MaxTokens and retried without tools — the very misreading LLM-11 removed from the buffered path (LLM-12).

  • Llm:TimeoutSeconds bounds a streamed call whole, headers and body, on every streaming path (the OpenAI dialect, Azure, Anthropic, Ollama; chat and text streams). An elapsed bound ends the chat stream with the failure in its final response (error naming the setting, error_type TaskCanceledException), the partial content kept and no RawResponseBody; the text stream throws the same sentence. The caller's own cancellation still propagates as such.
  • Llm:StreamIdleSeconds (new, unset by default, per profile too) bounds the silence between two streamed chunks: error_type StreamIdleTimeout, a sentence naming the setting and the ways out. Studio's profile editor and the configuration TUI carry the field.
  • A stream closed without its finish marker (finish_reason or [DONE], message_stop, done: true) is a failed call when no answer text and no tool call arrived (error_type StreamTruncated, the sentence saying how much reasoning was streamed); with some answer it is served as it came, flagged stream_truncated in its metadata. Anthropic's mid-stream error event is read as the OpenAI dialect's root-level error already was.
  • The chat-client adapter fails a streamed turn on any error, partial content or not: a timeout in the middle of an answer is not an answer. The legacy text loop's adapter (IBasicLlmProvider) throws the provider's reason too instead of returning an empty string.
  • The headers phase of a stream re-sends an elapsed HttpClient.Timeout once (LlmTimeoutRetries), as the buffered path does, instead of up to Llm:MaxRetries times; the OpenAI dialect's ChatAsync reports an answer without choices or usage as a sanitized failure instead of letting the parser's exception escape.

Changed — Studio's E-mail tab: the form of an account is four tabs

The form of the selected account was one column of four cards — the account, its rights, its sign-in, its servers — that scrolled well past the window. It is now four tabs, Account, Rights, Sign-in and Servers, under a head that stays whichever shows: the name, the state, the test and sign-in buttons, and what the run will say of the account. The Servers tab exists only while the hosts show, and the form folds back to Account when a preset takes them over. The expert's card of the two settings of the section — the screening switch, the token folder — moves under the list of accounts, since it is about none of them, folded until opened. The capture campaign photographs the Rights and Sign-in tabs, and the servers shot opens its tab.

The expert's Sign-in tab showed every key whatever the account: the password variable under OAuth2, the Microsoft tenant on a Gmail account. Each of the three — the password variable, the client-secret variable, the tenant — now shows when the method or the provider calls for it, or when the file already holds it. And the list of methods of an Outlook account no longer offers « Password », which Outlook.com and Microsoft 365 refuse from a mail client, unless the file still holds it.

Changed — a refused connection test says what to do from Studio

orkeon email check takes --events jsonl: its verdict is then one event line — email.check.completed with the counts and the printed sentence, or error with the e-mail error code. Studio runs the check that way and reads the code: a test refused for want of an OAuth sign-in is headed « Sign in first » and points at the « Sign in » button of the row, one refused for want of a password is headed « Store the password first » and points at the field of the Sign-in tab — the engine's sentence, which sends to a terminal, stays under it as printed. An older CLI that prints a sentence is read as before.

Fixed — Studio's E-mail tab no longer shows the form of nobody on a machine with no account

With no e-mail account declared, the tab said so and then showed, under that sentence, the whole form of an account that did not exist — every one of its conditional panels open at once: the sign-in in flight with its three contradictory ends (« signed in », « the code expired », « the sign-in failed »), the rename editor, the removal and sign-out questions, the problems list, the recipients block, fields shrunk to squares and empty lists. One cause: the form is a ContentControl with an explicit ContentTemplate, which WPF instantiates even over a null Content; every Visibility binding of the form then failed on the null context and kept its default. The control is now gated on HasSelectedAccount (the T-30 rule the mounts editor already followed), and the capture campaign photographs the tab of the pristine machine (reglages-mails-vide), asserting the gate false, so the state cannot regress unseen.

The fields of the box that adds an account — and every empty field of an account's form — were squares the size of a character: a TextBox has no width of its own, and left-aligned under a MaxWidth alone it measures to its text. They carry a Width now, as the other fields of the tab already did (the MCP server id too), and a conformity test holds every left-aligned editable TextBox of the views to it.

Documentation — the environment variables Orkeon reads, in one table

A variable that carries a setting had its rule, well explained. A variable a binary reads by its own name had no list: seventeen names scattered over the documentation, eleven of them absent from the configuration reference and three written nowhere.

  • docs/reference/configuration.md gains "Environment variables" (and its French mirror), after the categories, in three tables: the variables that carry a setting (ORKEON_<Section>__<Key>, the same without the prefix, ORKEON_<NAME> for a secret); the ones a binary reads by their name, each with who reads it, the value it takes and what it does; the settings keys that name a variable (Llm:ApiKeyEnvVar, …) and where that variable is read. One paragraph says what is only passed on to a child process.
  • Three variables come out of the shadow: TUI_DRIVER (windows, dotnet or ansi) and TUI_DIAG (1), the diagnosis switches of the text interfaces, and OLLAMA_BASE_URL, the address the Ollama provider takes when it is given none.
  • orkeon settings env prints the same three lists in the terminal, offline, and --json hands them to a program. env is that list and not the word: what the word names among the settings follows it.
  • Each name is written once, in EnvironmentVariableNames (Orkeon.Constants.Configuration), with the row the page and the verb read. A test holds both pages to it: a variable added without its row fails, and so does a row for a variable the code does not know.
  • orkeon email and orkeon rag read ORKEON_DEBUG as every other verb does — 1, true or yes — where they took 1 alone.
  • docs/reference/cli.md: each variable it names links to the table.

Tests — the settings files, the documentation's blocks and its quoted defaults are held to the code

Nothing tied what the repository says of a setting to what the code reads: a template of the examples, a json block of a page or a default quoted in a sentence could name a key that does not exist, and stay.

  • A settings file of the repository writes only keys of the settings catalogue — the 17 files of examples/, the .json.example templates among them, the sample of an installation, the fixture of the release smokes and the settings Orkeon Studio's screenshots are taken on: each key is known, the names an operator chooses aside, each value is one its key can take, and a retired key fails with its migration. The failure names the file, the key and the closest one. The capture campaign's settings wrote RateLimiting:RequestsPerMinute, RateLimiting:MaxConcurrent and Llm:Provider, which nothing reads: they are GlobalRequestsPerMinute, MaxConcurrentRequests and Llm:BaseUrl now.
  • A json block of the documentation (English and French, the READMEs of the examples included) that writes a section Orkeon reads writes only its keys. A block that is no settings text is not judged; one that shows on purpose what a host refuses carries <!-- settings-check:off --> on the line above its fence.
  • A default quoted beside a key — `Llm:MaxRetries` (10 by default), a row of a table with a "Default" column — is the one of the code, in every page, units and separators set aside. The RAG page gave Orkeon:Rag:Retrieval:CandidateK 50; under the default profile it is 5, and the page says so.
  • The reference page: a table that is no longer the one the catalogue produces fails by the name of its section, with the command that writes it again.
  • The catalogue's sentences keep the space before a name that opens with a dot: "the .NET stack", where Logging, Logging:Console and Orkeon:Scripting:Limits:RecursionLimit read "the.NET".
  • The settings files and the pages are listed from what git knows, so a clone that keeps other projects under examples/others does not walk them: the tests of the examples' settings, which did not end there, run in seconds.
  • CONTRIBUTING (EN, FR): "Adding a setting" — the property and its comment, its category, the French sentence, and the commands that produce the catalogue, the tables and the sample again.

Changed — the sample settings file of an install lists every setting at its default

appsettings.sample.json, at the root of every installation, was a copy of the examples' default file: twelve keys, at the values of a local model. It is produced from the settings catalogue now.

  • Every key a shipped binary reads — 56 sections, 305 keys —, by category, each section under a line that says who reads it. RateLimiting is there at 60, 30, 20, 0 and 5.
  • It can be copied: put in place of the settings file as it is, no host refuses it, none reports it, and each host binds what it binds without a file. It writes a key only when that key is a single value at a constant default (163 of them); everything else is shown as a comment to uncomment — a key without a default, a secret, a list, an entry under a name or an index, a key a RAG profile sets, and the whole Llm section, since one of its keys written gives the host a default model and hides the warning that none is configured.
  • JSON with // comments and a comma after every member, which .NET's configuration, the runners and Orkeon Studio read. A strict JSON parser does not.
  • package-installers.sh and .ps1 ship scripts/installer-assets/appsettings.sample.json; a test holds that file to what the catalogue produces. examples/appsettings/appsettings.json, the default of every example, is unchanged.
  • Docs (EN, FR): configuration.md says where the file of an installation is and what copying it does; the README of an archive too.

Fixed — a settings section no shipped binary reads is reported at start

ToolRateLimiting, TokenBudget, Orkeon:Dlp and eight other sections are read by a host written in C# only. Written in the settings of orkeon run, orkeon-host or orkeon-repl, they were read by nothing and nobody was told: the run started without the limit, the budget or the screening its operator had written.

  • Each shipped host says it at its start, once per section and per process, on stderr and on its logger, then starts — the exit code is the run's: WARNING: ToolRateLimiting is read by no component of this host: a C# host reads it through AddOrkeonToolRateLimiting(). The calls to the model are limited by RateLimiting, which this host reads. orkeon-repl writes it as orkeon-repl: warning: … before its console opens.
  • The list is computed from the settings catalogue — a section present in the configuration, the file or the ORKEON_ environment, that no shipped binary reads and this composition does not read either. Eleven today: ToolRateLimiting, TokenBudget, Orkeon:Dlp, Orkeon:Monitoring, Orkeon:CognitiveMemory, Orkeon:MultiModal, Plugins, Evaluation, Orkeon:VectorSearch, Orkeon:Checkpointing, Orkeon:ExecutionState:Persistence.
  • Not reported: a section another shipped binary reads (Orkeon:Host in a file orkeon run shares with the daemon), a root section Orkeon does not know, a single value at the path of a section, and a section a C# host reads because it registered what reads it.
  • orkeon doctor: one runner-settings line at warn per section, beside the fail lines; the exit code is unchanged.
  • The refusal of an unknown key ends on the command that lists the keys of its section: `orkeon settings Orkeon:Guardian` lists its keys.
  • Docs (EN, FR): opt-in-subsystems.md says at the head of each subsystem that no shipped binary activates it; configuration.md gains "When a setting is only reported"; cli.md says what runner-settings warns of.

Nothing that was refused becomes a notice, and nothing that was accepted is refused.

Added — orkeon settings lists every setting by category, offline

The CLI's help named its verbs and an address; whoever installed Orkeon without the repository had nothing that said what a settings file may hold.

  • orkeon settings answers from the catalogue the tool carries: the eleven categories with the sections of each, then orkeon settings <category>, <section> (every key with its type, its default, the values a closed list accepts and its meaning), <key>, or <word> — what is named or described with it, looked for where a word starts (rate finds RateLimiting and ToolRateLimiting, not FallbackStrategy). A name the operator chose stands where the catalogue writes <name>: Llm:Profiles:fast:Model is found. A name that designates nothing exits 1 and names the closest one.
  • Who reads a section is said for each: the shipped binaries, or a C# host only — AddOrkeonToolRateLimiting() for a section no shipped binary reads. --host run|host|repl narrows every listing to what one binary reads.
  • --all lists everything by category; --json writes the catalogue itself — one object, sections and settings, the same bytes on every machine —, documented as a contract in the CLI reference. It follows a name and --host.
  • The verb opens no settings file, builds no host and reaches no network: it answers the same where the settings file is refused or the folder cannot be written, and no output carries a secret — a key that holds one is marked secret and has no default. It shows what a key is worth when nothing sets it, not what the machine has set: orkeon doctor stays the verb that judges a file. The listing holds in 100 columns.
  • orkeon --help names the verb and now ends on the documentation site and the configuration reference, instead of the repository's address. orkeon settings stays the verb in a folder that holds a settings/ directory.
  • The README of an archive names the verb in "First run".

Documentation — every setting has a line: its type, its default, who reads it

The configuration reference named almost every setting and defined almost none: two keys out of three were a name in a sentence, filed by spelling ("Sections outside the Orkeon: prefix"), and nothing said which binary reads a section.

  • docs/reference/configuration.md, by category (and its French mirror): after "Where settings are read from" and "When a setting is refused", which do not move, a part "Find a setting" — the eleven categories, each section linked — then one part per category and, in it, one sub-part per section: what it does, who reads it, and a table with one row per key — key, type, default, allowed values, meaning. 67 sections, 351 keys.
  • The tables are produced from the settings catalogue, between two markers (<!-- settings:RateLimiting --> … <!-- /settings -->); the prose around them stays written. A test holds both pages to the code: a key added to the engine, a default that changes or a comment that is reworded fails it until the tables are written again (UPDATE_PRODUCED_FILES=1, on SettingsReferencePageTests).
  • Rate and budgets sets RateLimiting (the calls to the model, in every host) beside ToolRateLimiting and TokenBudget (a host written in C# only), and says the difference in its first sentence. The eleven sections no shipped binary reads say so, with the registration that reads them.
  • Llm is a table followed by its three cautions, each under a title: the timeout and the models that think, MaxTokens as a pin, Grammar.
  • The French meanings are kept by hand in docs/fr/reference/configuration.settings.json, one sentence per key; the same test refuses a key without a sentence and a sentence without a key.
  • A key's sentence reads as a key: the catalogue drops the "Gets or sets" of a property comment, names a neighbouring key by its own name, a constant by its value and an enumeration value by its name; a few summaries too long for a table keep their detail in remarks.
  • README, the documentation index, security.md, studio.md, yaml-schema.md and local-models.md link to the section they cite; security.md no longer copies the defaults of RateLimiting.

Added — the settings a host reads can be listed

Orkeon knew the exact list of its settings — it refuses a key that is not on it — and nobody could read that list: each help surface kept a partial copy by hand. Nothing an operator sees yet; the reference page and a CLI verb are built on it.

  • A settings catalogue, internal to Orkeon.Hosting (SettingsCatalog): 67 sections and 351 keys — every section one of the three shipped binaries reads, and every section a public registration reads in a host written in C#. Each key has its type, its default, its allowed values when they are a closed list, and a sentence: the summary of the XML comment of the property it is read into. A secret is marked and never carries a value; a default that depends on the moment is said in words.
  • Eleven categories, by use (SettingsCategories, in Orkeon.Constants.Configuration): models, rate and budgets, memory and vectors, RAG, files and sandbox, security, tools, orchestration and persistence, scripts and console, service host and A2A, observability. A section belongs to one; a test refuses a section the table does not file.
  • Who reads what is computed from what each composition declares: orkeon reads 46 sections, orkeon-host 52, orkeon-repl 41. Eleven sections (46 keys) are read by no shipped binary, only by a C# host that calls their registration: ToolRateLimiting, TokenBudget, Orkeon:Dlp, Orkeon:Monitoring, Orkeon:CognitiveMemory, Orkeon:MultiModal, Plugins, Evaluation, Orkeon:VectorSearch, Orkeon:Checkpointing and Orkeon:ExecutionState:Persistence.
  • The catalogue is embedded in Orkeon.Hosting — four produced files under Settings/Catalog —, so it answers without a container, a settings file or the repository. A test in each binary's project holds its file to what that binary declares, and fails with the command that writes it again.
  • The sections read raw — Llm, LlmLogging, RaggableTree, Orkeon:CrewFactory, Orkeon:Security:PermissionGate, Orkeon:Cli:ConsoleStreaming, Orkeon:Cli:Tui — gained a comment per key and a default named once, where its reader applies it.

The start validation refuses exactly what it refused.

Added — install from a clone with one command

Installing the orkeon built from a clone took seven lines nobody had written down: read the version out of the props, count commits, call the packager with it, find the staging tree, run its installer.

  • scripts/install-from-source.ps1 (Windows, PowerShell 7) and scripts/install-from-source.sh (Linux, macOS): from the clone, one command builds the tree of the CLI archive for the machine and installs it with the archive's own installer. orkeon --version answers the version of the checkout — 1.0.0-rc.4.local.<commit date> off a tag — and orkeon doctor names the channel source. Run again after a git pull, it replaces the installation.
  • Every missing prerequisite is named before anything is compiled, all of them in one run, each with where to get it: a .NET SDK that satisfies global.json (told apart from no SDK at all), git, Python 3, tar — and curl and openssl on Linux and macOS. The script installs none of it. Started from Windows PowerShell 5.1, the Windows one says that the build needs PowerShell 7 and where to get it.
  • Options: the app set (-AppSet full / --app-set full), the destination (-InstallDir / --prefix), a dry run (-WhatIf / --dry-run) and the uninstall (-Uninstall / --uninstall, which builds nothing).
  • package-installers.sh --no-archive / package-installers.ps1 -NoArchive prepare the staging tree and stop there: no archive, no SHA256SUMS. The scripts above pass it; CI never does.
  • orkeon doctor tells a source installation to git pull and run the script again.
  • Docs (EN, FR): Install what you just cloned in three ways to run Orkeon, referred to by the prerequisites table, the update table, the README and CONTRIBUTING.md.

Added — the Windows zip installs by double-click, on the PowerShell Windows ships

Installing orkeon-cli-<version>-win-x64.zip took a PowerShell window, a policy to lift (Set-ExecutionPolicy, or the -ExecutionPolicy Bypass command the page gave) and, as far as any release had proven, PowerShell 7. Installing a second time over a first could stop half-way.

  • install.cmd, beside install.ps1 in both Windows archives: it starts the script on Windows PowerShell 5.1 — the one installed with Windows — under an execution policy that holds for that one command, and changes no setting of the machine. Double-clicked, its window stays open on the result; from a terminal it returns at once, with the script's exit code. Its arguments go through (install.cmd -Uninstall, -InstallDir <folder>). It travels into the install directory with install.ps1; neither is in the MSI.
  • A reinstall that cannot run is refused before it changes anything. install.ps1 lists the processes started from the install directory — Orkeon Studio left open, a crew still running — and, if there is one, names it and stops: the installation in place is intact. Until now the delete of the previous tree failed on the first locked file and left neither the old installation nor the new one. -Uninstall refuses the same way.
  • Proven under both PowerShell editions. smoke-windows runs the whole Windows smoke twice, under pwsh and under powershell, and the smoke gains three passes: an install through install.cmd; a second install over the first (the same tree, one PATH entry, the same Installed apps version); an install and an uninstall attempted while Orkeon Studio runs, both refused with its name. The MSI smoke asserts neither file is installed.
  • install.ps1 declares #Requires -Version 5.1; package-installers.ps1, build-msi.ps1 and build-msi-service.ps1 declare #Requires -Version 7.0, so Windows PowerShell says which version they need instead of failing on a parameter.
  • orkeon doctor tells a zip installation to run install.cmd to update.
  • Docs (EN, FR): the README, three ways to run Orkeon, the publication matrix and the README of every archive present install.cmd first; Before you start is reduced to what remains true — a file from the Internet may be confirmed, and a policy set by an organization (Group Policy) overrules the launcher: only a signed script runs there.

Added — orkeon doctor names the channel Orkeon was installed through

There are eight ways to install Orkeon and as many to update it; nothing in an installation said which one had been used.

  • A marker, INSTALL-CHANNEL, one word at the root of what each packaging installs: zip, tarball, msi, msi-host, deb, homebrew, source. It is written by whoever packs — package-installers, the two MSI builds, package-deb.sh, the Homebrew formula — and carried by install.ps1 and install.sh. An MSI is harvested from the zip's tree and installs its own marker in place of the zip's.
  • orkeon doctor gains install-channel, after dotnet-runtime: the channel, the version that runs and the command that updates that channel. It never fails: an installation older than the marker, or a build tree, answers unknown and stays ok; a marker that names no channel is a warning. The dotnet tool carries no marker and is known by its path. A Debian package answers deb and gives both commands — the apt repository's and the downloaded package's —, since nothing in it tells the two apart. doctor --json therefore lists one more check.
  • orkeon --version --verbose adds a channel: <channel> line under the version line, which orkeon --version alone still prints unchanged.
  • The channel names are constants of Orkeon.Constants.FileSystem (InstallChannels).
  • Every installer smoke asserts the channel of what it installed: the Windows zip, both MSIs, the Debian package, the macOS and Linux tarballs.

Documentation — what a Windows machine needs before installing

The install pages said "self-contained, no .NET needed" and then .\install.ps1, without a word on what Windows asks of a script or of an unsigned installer.

  • Before you start, in three ways to run Orkeon and, shorter, in the README: which PowerShell runs install.ps1 and under which one each release proves it; the command to use when Windows answers "running scripts is disabled on this system" — powershell -ExecutionPolicy Bypass -File .\install.ps1, which changes no setting of the machine —; Unblock-File for a zip a browser downloaded; what a policy set by an organization does to all of that.
  • Both MSIs are described as not code-signed, the service host's included (it was said of the per-user one alone), with the SmartScreen screen to expect and the checks to run first.
  • From source: a table of what it takes to run an example (the .NET 10 SDK, git) and what it takes to build an installer archive (Python 3, tar, PowerShell 7 on Windows, access to nuget.org and registry.npmjs.org).
  • The publication matrix gains What the machine needs for the Windows artifacts; the README embedded in every archive carries the same commands.
  • Stale texts: the archive README no longer says the CLI archive holds orkeon alone (the Windows and Linux ones carry Orkeon Studio), nor counts the checks of orkeon doctor — no page does any more; a sentence cut in half on the French page is whole again.

Fixed — a build off a tag no longer takes the release's version

scripts/package-installers.sh and .ps1, run without a version on a commit that is no release, named their archives after the newest v* tag: a zip built from main was called orkeon-cli-1.0.0-rc.4-win-x64.zip and its orkeon --version answered 1.0.0-rc.4, like the release. The version of such a build was also computed in three places.

  • One calculation, scripts/resolve-version.sh, with a PowerShell twin (scripts/resolve-version.ps1, Windows PowerShell 5.1 included) held to the same answers by scripts/test-resolve-version.sh. publish.yml, the apt dev channel and both package-installers scripts read it.
  • A build made from a checkout is <props version>.local.<stamp>, <stamp> being the commit's date, YYYYMMDDHHMM in UTC — 1.0.0-rc.4.local.202610080430. It sorts above the dev builds of the same props version and below the next one, and a shallow clone gives the same answer. On the commit a v* tag points to, the version is still the tag's.
  • The dev versions do not change: <props version>.dev.<CI run> for the NuGet and the apt dev builds of one CI run.
  • A manual run of release.yml therefore produces artifacts in the local form. Passing --version (-Version) still decides, as before.

Fixed — a Mistral model that reasons no longer breaks a stream, and the fleet is campaigned again with its two aggregators (LLM-08)

The campaign of 2026-10-07 ran the protocol against the fourteen cloud providers — OpenRouter and Mammouth AI for the first time — and read each provider's own model catalogue.

  • A stream whose content deltas are arrays is read. mistral-large-4 reasons by default and streams delta.content as an array of typed chunks, the shape the buffered path has read since 2026-08-30. The text stream (GenerateStreamingAsync) threw InvalidOperationException on the first one; the chat stream (ChatStreamingAsync) dropped them — the reasoning trace, and the first words of the answer, which arrive inside the chunk that closes the thinking. Both read the two shapes now, on every OpenAI-compatible provider.
  • OpenRouter and Mammouth AI have an archived campaign: 11/1 and 10/0/2 on the fleet's Gemini default. No declared capability changes; what each proxy lets through is recorded in the provider comparison.
  • llmproviders-test/lib/served-models.json is the dated list of what each provider serves — 1 442 identifiers, with the options its catalogue endpoint publishes per model — and the comparison page gains Models served and their default options. Twelve more models have their mandatory values recorded (requiredParams): the GPT-5.6 and GPT-6 tiers, four Claude models, two Mistral models, kimi-k2.7-code.

Known and not fixed here: an Anthropic refusal (stop_reason: "refusal", HTTP 200, empty content) is returned as an empty answer; a 429 that says the account is out of credit is retried like a rate limit; Kimi's retry on a mandated temperature covers buffered calls only, a stream surfaces the refusal; orkeon llm models -p anthropic cannot send the workspace header an identity-linked key requires.

Changed — the e-mail tools read a password variable from the Windows user scope too

The variable an account names for its password (Auth:PasswordEnvVar) or its OAuth client secret (Auth:ClientSecretEnvVar) was read in the process environment alone. A password stored for the user — by setx, or by Orkeon Studio — reached a program started afterwards by inheritance, and neither a terminal opened before it nor a scheduled task (STUDIO-68).

  • The process environment, then the user's. On Windows the e-mail tools now read the variable in the process environment, then in the user's persistent scope (HKCU\Environment), as an LLM key's variable is read. The first non-empty value wins, the process first.
  • Read, never copied. A secret found in the user scope is not written into the process: what a run starts — a shell tool, a stdio MCP server — inherits no secret it did not have.
  • A user scope that cannot be read is an absent variable (a service account without a profile): the call fails as it does without a password, and nothing else does.
  • The failure says where it looked. On Windows: « … is read from the environment variable X, which is set neither in the process environment nor in the user's. » On Linux and macOS, which have no user scope, nothing changes: the process environment alone, and the sentence keeps its form (« …, which is not set. »).
  • orkeon email accounts and orkeon email check follow, and so does orkeon-repl: they read through the same seam, so an account ready for a run is ready for the verb.

Docs: the e-mail guide (EN and FR) gains « Where a secret variable is read » and its troubleshooting entry tells the two sentences apart; the configuration reference aligns the e-mail secrets on ApiKeyEnvVar.

Added — orkeon email login --events jsonl

orkeon email login spoke to a person: a sentence with an address and a code, or an address to open and an invitation to paste the one the browser ends on. A program could not read either safely. With --events jsonl the verb writes each step of the sign-in as one JSON event on standard output — and nothing else there —, in the envelope of the run stream, under five kinds declared once in Orkeon.Constants.Protocol.EmailEventKinds: email.login.device_code (verification_uri, user_code, expires_in), email.login.authorization_url (authorization_uri), email.login.redirect_rejected (message), email.login.completed (account) and error (code, the e-mail error code; message; recoverable), which replaces the line on stderr. The exit codes did not move (STUDIO-70).

  • Standard input is the driver's hold on the verb. A line written to it is the address the browser ended on — the fallback of the Google flow when the browser cannot reach this machine. Closing it aborts the sign-in with exit code 130, in the device flow too: the loopback wait has no deadline, and a driver that goes away must not leave the verb listening on its port. No deadline was added to the verb.
  • Without the option nothing changed: the same sentences, on the same streams.
  • IEmailLoginInteraction.ShowDeviceCodeAsync takes the lifetime of the code (expiresIn), as the provider granted it: a C# host that implements the interface adds the parameter.
  • A pasted line that is not the browser's address is said, no longer swallowed. The sign-in set it aside in silence and went on waiting; it still waits — a rejected line is not a failed sign-in, and an empty one is still ignored —, but says why first, in one sentence that never repeats the line (it may hold an authorization code): not an address, the address to open, not the redirect address of this sign-in, or no authorization code. With --events jsonl that is email.login.redirect_rejected (message); at a terminal, a sentence on standard output that asks for the complete address — a sign-in where nothing is rejected prints what it printed. IEmailLoginInteraction gains ShowRedirectRejectedAsync(account, reason, …): a C# host that implements the interface adds the method.

Docs: the CLI reference and the e-mail guide (EN and FR) describe the option and its five kinds.

Added — Studio: an E-mail settings tab

The mail tools read their accounts from Orkeon:Tools:Email, and Studio sent whoever wanted one to the settings file and to a command line. Settings has an eighth tab, E-mail (« Mails » in French), in both modes, where the accounts are declared, renamed and removed in a form (STUDIO-65, STUDIO-67).

  • The settings document reads and writes the section (STUDIO-65). AppSettingsDocument.Email lists, reads, writes, renames and removes the accounts and carries DefaultAccount, Screening:WithholdRejected and CredentialsDirectory. A key Studio does not model stays where it was, a value the user did not change keeps the spelling the file had, and nothing is written as an empty string, an empty object or an empty list.
  • The novice declares an account without reading a key name. A small box asks for the name, the provider and the address and writes only once validated; the form then shows the provider, the address, the name shown to recipients, the six rights as six sentences, the sign-in method — the OAuth client ID once it is OAuth2 —, the allowed recipients as soon as « Send » is ticked, and the two server names of an account no preset fills. Every edit saves the file.
  • The expert sees every key. The protocols, ports and securities of both sides, the user name, the names of the two secret variables, the Microsoft tenant, the sending quotas, the timeout, the copy of sent mail, and the two settings of the section, each with its configuration key as a tooltip. No key is reachable through the raw file alone.
  • A field left empty says what it is worth. The watermark is what the engine will use — imap.gmail.com, port 993, OAuth2 for Outlook — and changing the provider moves it without rewriting what was typed.
  • Each account says what the run will say of it, as the file holds it: an unknown key, a value the engine cannot read, a missing right. They are warnings — an incomplete account stops no save, of the account or of any other setting.
  • Renaming and removing ask first, and say what they leave. An account that signs in with OAuth2 must sign in again under its new name, since its token file carries the old one; the password stays in its environment variable; removing an account leaves that variable and the tokens on the machine. DefaultAccount follows a rename and goes with its account.
  • The tab says which file it writes. A run reads one settings file: a team launched on another one does not see these accounts, and Studio lays nothing over a launch to give them.
  • The Tools tab sends to it. The line of the twelve mailbox tools reads « needs an e-mail account, declared in Settings › E-mail », in the five languages, and names neither the file nor a command.
  • The password is typed in the form, and a run finds it (STUDIO-68). An account that signs in with a password has a masked field and a state — « Stored on this machine, outside any file » or « Not stored yet », never the value. Studio hands the value to the store of the model keys, under the variable the file names, else under one derived from the account (EMAIL_<ACCOUNT>_PASSWORD; a _2 when another account already names it, never an ORKEON_ prefix), and the first value kept writes that name into the file. A name the file holds is never rewritten: neither a new password nor a renamed account moves the variable. A Gmail account that signs in with OAuth2 has the same field for its client secret. No file — settings, launcher or history — carries the value, and since the engine reads the user scope (above), a launch from Studio, a terminal opened before the password was typed and a scheduled team all find it; the launchers and the scheduled-run check did not change.
  • Each account says whether it is ready, and a button tests the connection (STUDIO-69). The state — « Ready », « Not ready » with the engine's sentence, « Set aside », or « Unknown » with the reason when the CLI is missing or failed — is what orkeon email accounts --json answers for the file as saved, read at once on arrival on the tab, then once the saves pause — one reading for a burst of novice keystrokes, one for a password stored, never one process per key; unsaved edits mark it « As of the saved file » and disable the test. « Test the connection » runs orkeon email check: reachable with the number of folders, to fix on this machine (exit code 1) or the server or the network (exit code 2), over the sentence the command prints, shown as is; an edit or a rename of the account stops its test and clears the verdict. Both always pass --settings, through the new EmailCliClient of Studio.Core; the test never runs on its own, and leaving the tab, the settings screen or Studio stops it.
  • An OAuth account signs in and out from its row (STUDIO-70). « Sign in » runs orkeon email login --events jsonl (above) on the file as saved — Studio runs no OAuth flow and holds no token — and a panel under the account says what to do while the command waits: Microsoft's page and the code, in large, counted down, then « The code expired — start again » (offered too when the command's own refusal of the expired code lands first); Google's address, and a field for the one the browser ended on, which keeps an address the command no longer reads and says it was not sent, and takes back an address the command rejects — cut short, another address, plain text — under « That is not the address the browser ended on: » and the command's sentence, while the panel goes on waiting. Studio opens nothing by itself: the address shows in clear, with « Copy the link » and « Open in the browser », a click that only ever opens an absolute https address. A sign-in that ends well reads the states again and the account turns « Ready »; a refusal of the command — no refresh token, a client secret that is not stored — shows as printed and is never tried again. « Sign out » asks first, then runs orkeon email logout. « Cancel », the code's expiry, another tab, another screen and closing Studio each stop the command — its standard input is closed on the spot, which the command reads as its driver leaving. A device code is shown in the panel and kept nowhere else.

The tab opens no connection on its own: the test and the sign-in are clicks. Docs: the Studio page (EN and FR) describes the tab, and the e-mail guide and the mailbox tutorial point to it.

Added — Studio's settings check judges the e-mail accounts as the run will

An e-mail account declared wrong stops no run: the engine sets it aside, and says why when a tool or orkeon email names it. Studio said nothing of Orkeon:Tools:Email, so a misspelt right or a missing host was first heard of at a tool call (STUDIO-66).

  • The settings check reads each account as the engine does. A name the engine refuses, a key no account carries, a value its binder cannot read, a missing address or right, servers that do not hold together, a sign-in that does not fit the provider, a recipient pattern or a quota it refuses, the right to send without an outgoing server, a DefaultAccount that names no account, a Screening:WithholdRejected that is neither true nor false: each is said in the engine's own sentence, at the key that fixes it (STUDIO-MAIL-NAME, -KEY, -VALUE, -ADDRESS, -RIGHTS, -SERVER, -AUTH, -SEND, -DEFAULT, -SCREENING), with its plain-language line in the five languages. The file is judged as it is written: an empty Incoming:Host blocks the preset's host, and an unreadable value is all the engine says of the account that holds it.
  • Every finding is a warning, and the file saves. The run does not refuse to start on a broken account, so Studio does not refuse to save one. The one error is STUDIO-MAIL-DUPLICATE: two account names equal but for the case whose objects set one same key — the JSON configuration refuses a key written twice, and no run can read the file. When the two share no key the run reads one account made of both, and the finding is a warning.
  • Two keys equal but for the case in one object are said too. Provider and provider in an account, Host and host under Incoming, DefaultAccount and defaultaccount in the section: the JSON configuration refuses the second, no run starts, and the check said nothing. STUDIO-MAIL-TWIN names both spellings at the key, alone on the account that carries them — an error when both set one same configuration key, a warning when they are objects the configuration merges, of which Studio reads and edits one only. The severity is held to the configuration a run composes, which also corrects STUDIO-MAIL-DUPLICATE on an empty account followed by a twin name that holds a value: refused by the run, and now an error.
  • A field left blank has a value Studio can show. EmailAccountEffective.Of gives what the engine resolves from the provider preset — protocols, hosts, ports, securities, the sign-in method, the login name, the tenant, whether a sent copy is kept, whether the account can send — without writing any of it.
  • Held to the engine. Studio Core does not reference Orkeon.Tools.Email, so EmailAccountRules spells its rules again; EmailValidationOracleTests hands every row — accounts Studio writes and accounts written by hand — to the engine's binder, registry and resolver, and the verdict, the problems of each family and the effective values must agree. Two rules differ on purpose: a PasswordEnvVar or ClientSecretEnvVar that cannot be a variable's name is a warning of Studio's own, its value never repeated; and the address is read more loosely than by the engine, which parses it with MimeKit.

The findings show in the validation list of the Settings screen; no screen edits an account yet.

Changed — the release smokes check the notices of every payload, and the runner image says what its build context holds (GAP-52)

Since GAP-45 every published payload carries its license, THIRD-PARTY-NOTICES.md and, for each .NET runtime it bundles, a licenses/<pack>/ folder. Nothing checked that they arrived: a packaging script, an installer, a WiX file or package-deb.sh could stop copying them and the release left green.

  • Every release smoke fails, naming what is missing, when a payload lacks its notices. The license (copyright in the Debian package), THIRD-PARTY-NOTICES.md and a non-empty licenses/<pack>/ per bundled runtime are asserted on the tree the user keeps: the CLI archive and what install.ps1 or install.sh makes of it, the two MSIs once installed, the full Windows archive, the .deb. No smoke lists the folders it expects: each *.runtimeconfig.json of the payload names the frameworks its application bundles, and the pack is <framework>.Runtime.<rid>. A payload with no *.runtimeconfig.json is a failure, never an empty pass. Two twin functions hold the rule, smoke_assert_notices (lib/smoke-common.sh) and Invoke-OrkeonNoticesAssertions (lib/notices-windows.ps1), both proved in CI on throwaway trees.
  • release-verify.yml replays the smokes of the tag it verifies. Run by hand, its two smoke jobs checked out the branch the run started from; they now check the tag out, so an older Release is asked what its own smokes asked of it.
  • .dockerignore and Dockerfile.runners say what Docker does. *.md drops the Markdown of the repository root only, and the comments claimed it dropped every Markdown file but the READMEs — a rule that, once "fixed" to match them, would have removed the RAG demo's corpus and every example README from the published image. The comments now point at .dockerignore, which says why deeper Markdown stays and why packages/ is kept in the context; !src/*/*/README.md, which re-included nothing, is gone; the image's banner no longer counts its examples. The build context is the same, file for file.

No .NET project changes, and nothing changes in what an archive, a package or an image holds.

Fixed — the e-mail tools say what the live Gmail campaign could not read from them (MAIL-07)

The owner's live campaign ran the whole cycle — search, read, draft, send to oneself, move to archive, trash — against a real Gmail account, with an app password on 2026-10-04 and with OAuth2 on 2026-10-05. The cycle passes; what follows is what the campaign could not prove, or had to work around, because of what a tool returned.

  • email_delete returns the ids it deleted. A new messages list holds each id and, for a move to the trash, the new_id the message has there (IMAP with UIDPLUS, Graph); a message deleted for good has none. A delete was provable by a counter and an absence only.
  • email_search returns total, and says what count and limit are. count is the size of the page; total is the number of messages of the folder matching the criteria, every page counted (IMAP, not with has_attachments). limit is a ceiling: a page is cut to what the agent loop keeps of a tool result, about ten messages, so a page shorter than limit is not the end of a folder — next_cursor alone is. Nothing changes in what a page holds; the schema, the tool description and the guide now say it.
  • email_folders shows where archive goes on Gmail. No Gmail folder carries the role archive, which email_move accepts and sends to All Mail: that folder (role all) now lists it under also_roles. The tool description and the folder argument name all too.
  • Three refusals say what to do. A cursor the account did not issue names the form of its cursors and the two ways out (the previous page's next_cursor, or none); a failed connection says whether it failed while opening the session (nothing changed; a repeat is a setting) or in the middle of one (call again, and search first when the call was changing the mailbox); a recipient that is not an address says that an account name is not one and that email_accounts gives the address.
  • The guide documents Gmail as campaigned (EN and FR), with what the campaign established and what it left open — the page of 50, Gmail labels, which no tool returns, and a search whose count moved on a mailbox believed unchanged. Hotmail and Outlook.com through Microsoft Graph, and Outlook over IMAP and SMTP, stay campaign-pending.

Breaking for a caller that compared a refusal's text: the three messages above changed.

Fixed — studio-team.json is written back as it was found, plus what changed

A fix of an existing surface (STUDIO-58): the studio-team.json sidecar of a team folder, which Studio writes at adoption and after every run, and orkeon forge rename retitles. A card another tool wrote — Orkeon Workshop writes one with its own keys, its accents as letters and a final newline, in a folder it versions — came back from every launch from Studio rebuilt: its unknown keys lost, "profile": null and "schedule": null added, é written \u00E9, no final newline. A git diff of the whole card at every run.

  • Every key Studio does not model is kept. StudioTeamMetadata carries the keys this build does not know (Extra, [JsonExtensionData]) and writes them back after its own, in the order read; every writer — adoption, « Change the folders », archive and restore, duplicate, import, export, the stamp of a run — keeps them without naming them, and a duplicate or an import copies them with the card. The keys Studio owns keep the order of its model; the card's original order is not promised.
  • No key for a null. A field the card does not set is not written as null: a card of another tool gains lastRunAt after a run and nothing else.
  • Non-ASCII text as the letters themselves, a final newline. The sidecar is written with two spaces, LF line breaks on every platform (the serializer's default is the platform's: CR LF on Windows), UTF-8 without BOM, no escape sequence for an accent or a dash, and ends with a newline — a second run changes no byte. A character outside the Basic Multilingual Plane, an emoji, is still written as its \uD83D\uDCCA pair: the serializer's relaxed encoder stops at the plane. orkeon forge rename, which already kept the unknown keys, writes the same way.
  • The read stays strict. A card with a comment or a trailing comma is still a card « without metadata », as before: the other tool validates it with strict parsers, and a card Studio alone would accept would hide a defect.

Migration: a card written before loses its null lines and gains its final newline at the first write — once, with nothing to do.

Fixed — a team's writable folders exist before the run starts, a missing read-only one refuses the launch (STUDIO-60)

  • The launch prepares the team's own folders, as the workshop's launchers do. A team whose sidecar declares ./output:/output:rw without the folder failed its first run from Studio: orkeon run refuses a mount whose folder does not exist, and Studio created the folders only when it wrote the sidecar — after that run, in RecordRun. Before a launch — Run, Run with --validate, Replay — the Launch tab now examines every well-formed ./x entry of the team: a missing writable folder (rw, rwnd) is created, and the journal names it; a missing read-only one refuses the launch before any process starts, naming the folder and its mount point — an empty input is an error to show, not a folder to invent; a creation the disk refuses stops the launch with the disk's reason. Nothing is created outside the team: an absolute entry, a copy, a settings declaration, an unknown id, an unreadable entry and a ./../x are left alone. The rule is the one run.sh/run.cmd apply (TeamFolderPreparation in Studio.Core, pure over IDirectoryProbe); the creation at the sidecar's write is unchanged and still creates every folder, ro included. No .gitkeep, no sidecar write, no history entry before the run.

Migration: a read-only folder of a team deleted by hand is now refused by Studio, before the run and with its own line naming the folder and its mount point, where orkeon run refused it at start with its own; a dry run creates the team's missing writable folders, as a real run does.

Fixed — the teams folder is chosen by ORKEON_STUDIO_TEAMS_ROOT, --teams-root or Settings › Studio, and nothing of it reaches appsettings.json

  • The teams root was a fixed path (STUDIO-61). Studio listed, created, imported, duplicated and launched its teams under %USERPROFILE%\Orkeon\teams with no variable, no option and no setting, so an Orkeon Workshop folder could only be Studio's catalogue by being that folder. TeamsRootLocator (Studio.Core) now chooses the root once at startup: the ORKEON_STUDIO_TEAMS_ROOT variable, then the --teams-root <folder> option of the WPF app, then the preference of Settings › Studio, then the default. An absolute path only, its ending separator trimmed, the folder not required to exist; a relative or blank value is skipped and the next source applies.
  • Every screen reads the same catalogue. The window resolved the root for the Launch tab alone; the creation assistant, the import, the trial and My teams fell back to the fixed path on their own. The root is resolved before the window is built and handed to the five screens.
  • A « Teams folder » card in Settings › Studio says the path in force and which of the four sources holds it — « set by ORKEON_STUDIO_TEAMS_ROOT », « set by --teams-root », « chosen here », « default » —, names a value that was ignored with its reason, and its « Change… » opens the folder dialog and writes the preference into Studio's own ui-preferences.json (TeamsRoot in its Studio section, merged like every key of that file), for the next start; the button is off while the variable or the option holds the root.
  • The run TUI stamps a team's last run as the WPF Launch tab does. orkeon-studio-run reads the variable alone — it parses no startup option and has no preferences file — and hands the root to its RunSession, which recorded no last run before.
  • No Orkeon:Studio key. The settings file is the one orkeon run reads, and the host refuses at start any Orkeon:* section it does not know (GAP-54): the preference lives in Studio's file, and a test against the real runner host keeps it that way. The variable the child orkeon process inherits lands as the root-level key STUDIO_TEAMS_ROOT, neither read nor refused.
  • WorkshopLayout (Studio.Core) reads the Orkeon Workshop folder around a teams root — whether it is one (settings/ and workbooks/ beside the teams root), the team's settings file settings/<slug>/appsettings.json, and the team's trees that exist, mounts.<name> included — for the lots that follow.
  • Migration: nothing set, the same path — %USERPROFILE%\Orkeon\teams. One difference, and a welcome one: a run from orkeon-studio-run now stamps its team's lastRunAt, as the Run screen does.

Fixed — Studio writes a team's launchers again only when it wrote them

A fix to an existing surface (STUDIO-63): Studio wrote a team's run.sh and run.cmd again from its card — at adoption, at « Change the folders », whenever a model setting the card names was created, renamed or removed, at an import, before a schedule was installed — by the shape of the folder alone (crew/ and a launcher), never by the text of the launchers. A launcher another tool wrote — Orkeon Workshop generates both from its own mounts.json, with its environment, its settings file and the creation of the team's folders — was replaced whole at the first of those gestures, and the file then said that a hand edit is lost, after replacing one that was not its own.

  • The header is the signature. forge promote and Studio write the same second line, Generated by Orkeon Forge for the team '…'.; it now lives in the Domain beside the composer (TeamLauncherScript.HeaderMarker, TeamLauncherScript.CarriesHeader — one of the first three lines, after rem , REM or # ; BOM, CR LF and LF tolerated). The header of the releases up to 1.0.0-rc.4, Generated by Orkeon Forge (session '…')., still counts: a team promoted then has launchers Orkeon wrote, and Studio keeps writing them again.
  • Both launchers are kept, never merged. When a launcher present lacks the header, neither is written: TeamLaunchers.Regenerate and WritePortable answer the new TeamLaunchersOutcome.ForeignKept, TeamLaunchers.WritesLaunchersOf(teamDirectory) says it beforehand, and a folder without any launcher is still not written. Studio launches the team from its card as before: it never reads the launchers to launch.
  • The screen says it. After « Change the folders » on such a team, « My teams » says the folders are saved and the launchers were left as they are (TeamMountsDialogViewModel.Open's onSaved now receives the TeamLaunchersResult?; TeamsViewModel.Announce). The settings hook stays silent, and the adoption line never sees ForeignKept: the launchers the engine just wrote carry the header.
  • A scheduled team with such launchers runs them. Without Studio's --llm-profile, on the settings file they name: its card shows the one notice ScheduledRunIssue.ForeignLaunchers (ScheduledRunCheck.Of/First take foreignLaunchers) in place of the notices about the setting and the folders, which those launchers do not carry, and « Install the schedule » saves nothing for them. Installing and stopping the schedule are unchanged: forge schedule registers the launcher by its path.

Migration: a launcher whose second line was removed by hand used to be written over whole at the next change of the team's setting or folders; it is now another tool's — kept with its edit, and the screen says so. To hand it back to Studio, put the header line back, or re-adopt the team.

Fixed — a workshop team launched from Studio runs on its own settings file

  • Studio never read a workshop team's settings file (STUDIO-62). An Orkeon Workshop keeps a team's model and RateLimiting in <workshop>/settings/<slug>/appsettings.json, which its run.sh/run.cmd pass as --settings; launched from Studio, the same team ran on the machine's file unless the user pinned the team's in Expert mode, at every session, for every team. The Launch tab now resolves a third source under the pin (TeamSettingsFile, Studio.Core): for a target whose team folder sits right under the teams root — the root Studio resolved, STUDIO-61 — and whose settings/<slug>/appsettings.json exists beside that root, the file is passed as --settings=<absolute path>. The slug is the folder's name; nothing is read inside the team; Studio never writes this file.
  • The pin wins, the file is shown. Precedence « Expert pin > the team's file > the CLI's own chain » (LaunchOptionsModel.TeamSettingsPath, ResolvedSettingsPath). The file in force is in the command-line preview and on one line beside it, outside the « Advanced » fold; a history entry records it as it records a pin, and replaying such an entry keeps the form automatic. The effective-mount table reads the file the run will read; the refusal of undeclared folders stays on the machine's file; the saves before a launch (STUDIO-52) skip a launch on the team file as they skip a pin. The Test screen's trial reads the team's file too — it stamps no last run, but it rehearses the model and limits the real run will use. The line says the team's file only while nothing is pinned. The run TUI does the same from ORKEON_STUDIO_TEAMS_ROOT, its label reading « Settings: auto (team file: …) ».
  • The ORKEON_Llm__* overlay is unchanged. A card without profile lays Studio's ORKEON_Llm__Profiles__<id>__* only, and the team file's Llm section and RateLimiting apply as they are; a card naming a setting of this machine lays that setting's ORKEON_Llm__* too, key by key — the card's explicit instruction, said on the line — so the model's precedence is « the card's setting > the team's file > Studio's default ». Known edge, not corrected: a profile id defined both in the team file's Llm:Profiles and in Studio's settings merges field by field, Studio's Profiles__<id>__* winning key by key.
  • Migration: a plain catalogue has no <root>/../settings/<slug>/: nothing changes — no --settings for a team without the file, a team outside the root, or a folder picked by hand.

Fixed — a team folder's crew/ is the crew, whatever the root holds (STUDIO-59)

  • Studio and orkeon run read a multi-file team folder one way. A workshop team keeps its crew under crew/ and one folder per mount point at its root; a mount point named agents/ or tasks/ — or a scripting entry point (*.ork.ts) — made the root the crew in Studio, and the run failed on config.yaml (or crew.yaml) not found. The CLI read the root the same way and never looked into crew/. Both now probe crew/ first: when it holds a crew, it is the definition — Studio runs it from the team folder, orkeon run <folder> loads it (CrewDirectoryLayout designates it as CrewDirectoryInspection.CrewRoot). One step down, never crew/crew/; a crew/ holding no crew leaves the root under its old rules. The CLI's rule is the narrower one: orkeon run <folder> descends into a crew/ that holds agents/, tasks/ or the flat triplet, where Studio also resolves a crew/ holding a single-file crew or a script — for those, point orkeon run at the file.
  • What the root carried is said, never taken for the crew. The detection carries a notice (STUDIO-TARGET-ROOT-SHADOWED) naming the folders and scripts it set aside; the launch validation shows it as an information line, in the five languages. The CLI's « no recognized crew layout » diagnostic now names the crew/ sub-folder among what it searched.
  • Migration: a folder without crew/ gives the same result as before. A promoted team with a clean root now runs from orkeon run <folder> — it was refused with « no recognized crew layout » — and its settings are looked up from crew/: crew/appsettings.json, then an appsettings/ or _shared/ folder above it; an appsettings.json at the team folder's root is not found any more, pass --settings. A folder whose root is itself a multi-file crew and holds a crew/ that is one now runs crew/, in Studio with the line above and silently in the CLI; rename the nested folder to keep the root in charge. orkeon-host loads a directory crew as given and does not look into crew/.

Fixed — in a workshop, Rename, Delete and Duplicate follow the team's trees

  • Rename left four orphans (STUDIO-64, a fix to an existing surface). In an Orkeon Workshop folder, everything that goes with a team is indexed by its folder name: workbooks/<slug>, tests/<slug>, settings/<slug>/appsettings.json — read by its launchers as settings/$(basename "$DIR") — and each mounts.<name>/<slug>. Rename in My teams moved teams/<slug> alone, so the renamed team ran on the machine's model in silence. Once the engine has moved the team folder, WorkshopSiblings.FollowRename (Studio.Core) now moves the sibling trees that exist, and the line says « Its workbook, tests, settings and mount sets followed it ». A destination already taken refuses the rename in the editor, before the engine is asked, naming it. A move the disk refuses after the engine succeeded puts back the trees already moved, and the team stays renamed: the line names the trees that stayed under the former slug — also when a destination was taken after the check, a file in its place, which stops every move. The launch history follows settings/<slug> as it follows the folder, so « Relaunch » after a rename replays on the file where it now is.
  • Delete erased without return. archive/ exists in a workshop for the teams taken out, the workbook holds the decisions and approvals of paid runs that Studio never shows, and a mount set is outside git. In a workshop, Delete now moves the team folder first, then its trees, under archive/<slug>/<kind>/ — archive/<slug>-2/ when the name is taken, by the free-suffix rule every folder Orkeon names follows (TeamCatalog.FreeSibling); a mounts.<name> keeps its whole name. The banner asks « Move the team and what goes with it to the workshop's archive? », its session box stays, the schedule is stopped first as before, and the linked session goes only once the archive succeeded. A refusal on the team folder has moved nothing; a later one puts everything back; both say the disk refused. The line says « Moved to archive/. ».
  • Duplicate copied a team without its setting. settings/<slug>-copy did not exist, so the copy ran on the machine's model where the original ran on its own. In a workshop, Duplicate now copies settings/<slug> to settings/<slug>-copy and nothing else — a workbook and tests are the original's story, a mount set an environment built on purpose. A settings folder already under the copy's name is left alone; a copy of the settings the disk refused is said on the line, the copy of the team never undone.
  • A plain catalogue is untouched. Without settings/ and workbooks/ beside the teams root there is no workshop (WorkshopLayout.IsWorkshop, STUDIO-61): the three gestures do byte for byte what they did, a folder named like a tree stays where it is, and explicit tests hold it. TeamCatalog.Delete and Duplicate keep their signatures; CopyTree is now internal.
  • Migration: in a workshop, Delete archives instead of erasing — a team taken out sits whole under archive/<slug>/, to delete by hand or with orkeon-bench team remove; the fallback that kept erasing the team folder was not taken. Outside a workshop, no change.

Fixed — the Folders step proposes what the request calls for, says when it is the standard proposal, and lets the user fill the folders kept inside the team before the trial (STUDIO-57)

  • A folder to read is proposed only when the team reads files. A request such as « summarize the article at this URL » named no folder, so the forge proposed its defaults — and /workspace to read came with them whenever the brief had any input, a URL included. The brief now carries readsFiles (brief_submit), which the assistant sets: false drops the folder to read even with an input, true proposes it even with none; when the assistant did not say, the old reading (something comes in) stands. A default folder's purpose is said in the brief's language, not always in English.
  • The proposal says it is the defaults. folders.proposed carries defaults: true when the request named no folder; the wizard's Folders step then reads « Your request names no folder: this is the standard proposal » instead of « Read from your request », and shows the defaults' purposes in the user's language.
  • « Inside the team » is a state, not a button that greys out once pressed. On a Folders row it is a checkable chip, accent-filled when it is the answer: unchecking an input hands it back to the disk picker, an output stays checked until a disk folder answers it. A greyed-out button after one click read as « cannot choose ».
  • The fill step. brief.ready now carries heldFolders — every confirmed folder kept inside the team, with the session directory the engine creates for it at the confirmation (folders/<name>). When there is one, the wizard asks whether to put files or sub-folders in the folders set up: « No » lets the construction go on, « Yes » shows « Open » behind each such folder (the file explorer) and « Continue » below; the terminal prints the directories. The engine composes meanwhile.
  • A /workspace kept inside the team is read from the session. Its trial used to read the working directory — under Studio, the forge's own — so files dropped in the session folder went unread until the adoption. Once a list is confirmed, every input bound to no directory reads the session's folders/<name>, /workspace included; --read still answers the first such input; a session that never confirmed a list keeps the old reading.
  • A folder the request describes is a folder the assistant lists. « Two folders of PDFs, one with the instructions, the other with the documents to attach » used to yield the defaults: the prompt asked for the folders the request names, and forbade inventing one. The assistant now lists every folder named or described, naming a described one from what it holds (/instructions, /documents), plus one output folder with a purpose that means something for the team — the record of the mails sent, when the result is no file. It is also asked to write light Markdown at most.
  • The chat bubble renders Markdown and can be copied. **Entrée** showed with its stars, and nothing in a bubble could be selected. The engine's and the user's words now go through a read-only rich text that renders bold, italic, inline code, bullet and numbered lists, headings and fenced code (MarkdownLite, Studio Core; MarkdownText, the control), and a sentence or the whole answer can be selected and copied; plain text renders as typed.
  • A folder can be added, taken off, flipped and annotated on the Folders step. Each row has a note — what the folder holds and how the team must use it, sent as its purpose and followed by the assistant when it designs the tasks —, a chip that flips read and written, and a cross; « Add a folder » adds one. A list with no output folder, or none at all, is valid in the engine and in Studio: a team that sends mails from what it reads writes no file, no task has a deliverable, and a confirmed empty list is a team with no folder, never the folders its plan would imply. The assistant no longer has to propose an output folder nobody needs.
  • « Rephrase » on step 1. orkeon forge rephrase <request> asks the assistant's LLM to rewrite the request as a clear brief, adding nothing, and answers with one need.rephrased line; Studio's « Rephrase » runs it under the assistant's profile and takes the text as the need, « Back to my words » restores what was typed.
  • The pinned brief card is selectable, and its « Edit » is gone. The pencil only went back to step 1, which « Start over » does; the text can now be selected and copied.
  • The status line follows the Folders row. « x allowed and bound as /y » stayed on screen after the row went back to « inside the team »; it now goes when the row no longer holds that folder.
  • « Settings › Authorized folders » no longer demands a folder. Saving the settings file with no authorized folder was refused — « Not saved yet: authorize at least one folder » — on the claim that the runtime refuses to start without one. It does not: the runner builds no file system when nothing is mounted and runs the crew all the same, so a team that reads a mail and answers a mail needs no folder, and a team's own folders travel in its sidecar and launcher, never in that file. STUDIO-MOUNT-EMPTY is now a warning in every scope, in Studio and in the orkeon-studio-config TUI alike, and its text says what it means: the agents see no folder of yours; the novice empty state says the same.

Added — Orkeon is an apt package on Debian and Ubuntu: add the signed source once, then apt install orkeon and apt upgrade, on amd64 and arm64

  • A signed apt repository, served by this GitHub repository. The packages stay the Release assets release.yml already builds, smokes and attests; the signed index lives on the orphan apt branch. The source is a deb822 file (installers/apt/orkeon.sources) with Signed-By: pointing at /usr/share/keyrings/orkeon-archive-keyring.gpg — no apt-key, nothing trusted system-wide. Nothing adds it for you: neither the .deb nor install.sh. The block to copy, the channels, going back to a version, removal, Docker builds and troubleshooting are in Install with apt.
  • Three channels. stable carries final versions only and stays empty until one is published; rc carries every tagged release; dev carries the orkeon package of every green main (1.0.0~rc.4.dev.<n>), unstable and unsupported, the three latest builds only, never published to NuGet.org. Switching is one Suites: line. Every version still attached to a Release stays in its channel: sudo apt install orkeon=<version> goes back to it.
  • apt-dev.yml feeds dev after every green CI run on main: both .deb on the fixed-tag prerelease apt-dev, a dropped build's assets deleted only once the pushed index no longer lists them; the README's newest-tag one-liner and git describe now read v* tags only.
  • A .deb for arm64. orkeon_<version>_arm64.deb ships with every release next to the amd64 one (Raspberry Pi 5, AWS Graviton, Ampere, ARM virtual machines): same content and layout, built from the same publish as the linux-arm64 archive, smoke-tested on a real ARM runner (smoke-deb is a matrix, each entry checking dpkg --print-architecture), attested and listed in SHA256SUMS. linux-arm64 users no longer need the multi-app archive and install.sh.
  • orkeon-archive-keyring, a package (orkeon-archive-keyring_<YYYY.MM.DD>_all.deb) that owns the repository's public key, so a new signing subkey reaches every machine through apt upgrade. orkeon recommends it; the setup block installs it explicitly, since --no-install-recommends would skip it. The key's fingerprint, the keyring's SHA-256 and the key policy (an offline primary key, a two-year signing subkey extended at least six months ahead, rotation, revocation) are in SECURITY.md.
  • install.sh points at the apt repository on Debian, Ubuntu and their derivatives — it reads /etc/os-release and prints the guide's address, nothing more: it writes nothing under /etc and never calls sudo.

Changed — the .deb file name carries the tag's version, every published asset is checked against its manifests after publication, and the Debian package installs on Ubuntu 26.04, verifies once installed and builds reproducibly

  • orkeon_1.0.0-rc.4_amd64.deb, not orkeon_1.0.0~rc.4_amd64.deb. GitHub rewrites ~ in an uploaded asset name, so the published file never matched its SHA256SUMS line. The file name now follows the tag; the package's Version: field keeps the ~ (1.0.0~rc.4), which sorts a pre-release before its final version. The 1.0.0-rc.3 and 1.0.0-rc.4 Releases are left as published (rewriting them would break their attestations): their .deb is named orkeon_1.0.0.rc.N_amd64.deb while their SHA256SUMS names it with ~ — the digest is the same, only the name differs: check that file by hand.
  • release.yml refuses an asset GitHub would rename (any character outside [A-Za-z0-9._-]), an asset without a SHA256SUMS line and a line without its asset (scripts/check-release-assets.sh, in the installers job and in the release job before publishing).
  • The post-publication verification runs. release-verify.yml was triggered by release: published, which never fires for a Release created with the workflow's GITHUB_TOKEN: release.yml now calls it in its verify-published job, right after release; it can still be run by hand for a tag. It no longer skips a manifest line whose file is missing (--ignore-missing removed): every published asset must have its manifest line, and every line its asset; it replays the smoke of both .deb. Run by hand on v1.0.0-rc.3 or v1.0.0-rc.4, it fails by design, naming the gap above. Verify what you install and the publication matrix said it ran on every Release; they now say how it does.
  • The Debian package installs on Ubuntu 26.04: its Depends accepts libicu78 and libicu77 besides libicu76 down to libicu70 (Ubuntu 26.04 ships only libicu78).
  • Recommends: orkeon-archive-keyring — not Depends, so a local sudo apt install ./orkeon_<version>_amd64.deb without the repository keeps working.
  • Homepage points at the repository, https://github.com/Orkeon/orkeon.
  • The package ships md5sums: dpkg -V orkeon / debsums orkeon check the installed files, and the Debian smoke asserts dpkg -V orkeon is silent.
  • Reproducible: two builds of the same commit give the same bytes (release.yml sets SOURCE_DATE_EPOCH to the tagged commit's date).
  • package-deb.sh --arch amd64|arm64, refusing a staging tree whose executables are of the other architecture.
  • lintian runs in the installers job as a non-blocking report in the job summary; the expected tags of a self-contained package are listed with their reason in scripts/package-deb.lintian-overrides.

Fixed — the Studio TUI presents the key under every spelling a run reads, the open model-setting editor follows the language, and a refused write of the model settings is said

Three defects of Studio's model settings (STUDIO-56):

  • The orkeon-studio-config « Test connection » now finds the key under every spelling a run reads. The .NET configuration compares the ORKEON_ prefix and the keys without case and reads : like __, so a run reads ORKEON_LLM__APIKEY, orkeon_llm__apikey or ORKEON_Llm:ApiKey as Llm:ApiKey. Under Linux and macOS the TUI looked for the exact name: it said « API key missing », or tested another key than the one the run sends. It now reads the process block as the configuration does (IEnvironmentVariables.ReadAll, LlmApiKeyResolver). When two spellings in the layer that decides hold different values, a run reads either one: the TUI sends no request and names the variables, never their values (« API key ambiguous — … Keep one. »). The variable Llm:ApiKeyEnvVar names is still read by its exact name, as the run reads it. LlmApiKeyResolver.Resolve returns an LlmApiKeyResolution (the key, none, or the conflict); its overloads over a function and over the machine without a seam, and LlmForm.ToProbeRequest(Func), are removed — pass an IEnvironmentVariables (SystemEnvironmentVariables.Instance).
  • The open model-setting editor follows a language switch. Its cards, its three thinking choices and every line it computes — the key block, the hints, the host id, the test's verdict, the balance — stayed in the previous language until it was reopened. The tab relays the switch; the editor rebuilds its catalogue and its choices, finds its card again by name, keeps what was typed, and keeps each verdict as a state, formed as it is read. The key rows of the Models and Tools tabs and the tab's error lines follow it too.
  • A refused write of studio-model-profiles.json is said, and no longer kills the writes that follow. Every change wrote the file after the previous write; a write that threw (an infinite temperature) made every later one fail with it until the end of the session, silently, and the store swallowed a read-only or locked file. Each write now answers for itself, the Models tab says the failure on a line of its own (« The model profiles file could not be written — … »), the next change writes the whole set again and clears it, and the file is written beside then moved over the original: replaced whole or not at all.

Fixed — Studio refuses before saving what the run will refuse, says each refusal in the language of the screen, and neither keeps nor erases in silence a value it cannot read [breaking]

The model-setting editor took « NaN », « Infinity » or 1e400 as a temperature: « Save » threw, the settings document kept the value, and every later save of the session failed with it. The check before saving took 600.0 or 0.5 where the run reads an integer, looked at no entry of Llm:Profiles, and let through an ApiKey written ${NAME} and an entry named default — all of which the run refuses at start. orkeon-studio-config loaded an unreadable value empty and erased it at the next save, a tri-state switch included; a studio-model-profiles.json holding "Temperature": 1e400 loaded as an infinity, after which no change of the model settings reached that file and every launch passed Infinity to the run; and eleven refusals stayed in English in every language (STUDIO-55).

  • A temperature is a finite number. The editor (ParsedTemperature) and the TUI (FieldText.TryReadDouble) refuse NaN, ±∞ and 1e400 like any unreadable text: « Save » stays inactive, the TUI says the field. The store refuses a file whose setting holds a non-finite temperature like one it cannot convert — the empty set and a reason naming the setting and the field, shown on the settings screen. The editor also refuses an address that is not an absolute http(s) URL.
  • The check judges as the run reads. AppSettingsValidator judges Llm and each Llm:Profiles:<id> entry by the run's rules: strings, a finite temperature, MaxTokens, TimeoutSeconds and MaxRetries whole numbers that fit an int — like every other integer field (RateLimiting, LlmLogging:MaxBodyLengthChars, Orkeon:Rag:Corrective:MaxIterations), « must be a whole number » —, Thinking:Enabled and Grammar booleans, BaseUrl an absolute http(s) URL, ApiKeyEnvVar a variable's name; Llm:Profiles and each entry objects. An ApiKey written ${NAME} is the error STUDIO-LLM-APIKEY-PLACEHOLDER, giving the run's remedy ("ApiKeyEnvVar": "NAME"), and an entry named default the error STUDIO-LLM-PROFILE-NAME. The rules are Studio.Core functions (LlmSection.IsKeyPlaceholder, IsVariableName, IsAbsoluteHttpUrl), held to the real runner host by a test.
  • The TUI shows what it cannot read. Its fields load as the file writes them (AppSettingsDocument.GetWritten): an unreadable number or switch is shown and refused when applied, never erased. A tri-state switch whose key is no boolean ("yes", 1) keeps that text, says it in its caption, and is refused until it changes state.
  • Every refusal in the language of the screen. The thirteen codes without a plain-language explanation — the two above, STUDIO-LAUNCH-MOUNT-DASH, STUDIO-LAUNCH-MOUNT-ID, STUDIO-LAUNCH-DIRECTORY, the six STUDIO-TARGET-*, STUDIO-MOUNT-ID, STUDIO-MOUNT-SHARED — have theirs, in the five languages, and a test requires one of every STUDIO-* or WIN-* code of Studio.Core. The target's status line says the explanation of its code; the line under the shape chooser shows only when it names the scripts to move.

Migration: a settings file Studio saved before may now be refused at its next save, at the path the line names — the run refuses it at start already (GAP-40). Write a whole number where an integer is read, a finite temperature, an absolute http(s) address; move an ApiKey written ${NAME} to "ApiKeyEnvVar": "NAME"; rename an entry Llm:Profiles:default. A studio-model-profiles.json holding a non-finite temperature is reported unreadable: correct the temperature it names.

Fixed — a team keeps its model setting and its folders: a renamed setting carries its teams, Studio says when a scheduled run cannot follow, and a team that changes machine carries nothing of the one it leaves [breaking]

Since STUDIO-50 a team's run.cmd/run.sh carry its model setting (--llm-profile) and its folders, so the run the operating system schedules is the one Studio launches. Five situations undid that without a word (STUDIO-52): a setting renamed in Studio detached its teams — launched on the default, their launchers without --llm-profile, their card still naming the former name; a team on « no model » or on a setting named without an ASCII letter ran on its setting from Studio and on the default once scheduled, and a setting absent from the machine was shown as in force; an imported team kept the other machine's settings file, setting and folders in its launchers, an exported one carried this machine's — user name included — and FORGE.md and forge.json the absolute path of the team; a setting created without saving the settings was named by the launchers before the file had it, and the next scheduled run was refused; a declaration the settings editor gave an id when it read the file was linked to a team under an id the file never held, refused at launch and lost at the next start.

  • A renamed setting carries its teams. The editor rewrites the profile of every companion file naming the former name — archived teams included — and the wizard's choice, before the change is mirrored and the launchers written (TeamCatalog.RenameSetting, ModelProfilesViewModel's followRename, CreateTeamViewModel.FollowRenamedSetting).
  • What a run outside Studio cannot take is said, never refused. TeamSettingStanding (None, Offered, NotOffered, Missing) serves the card, the schedule offer, the Run and Test screens and TeamLaunchers.Describe: a scheduled team on a setting offered to no crew reads « Scheduled, this team runs on the default setting, not on “X” » and why; a setting absent from the machine reads « X — absent from this machine: the default setting runs in its place » with the same words on the card and the Run screens.
  • The settings file as saved is checked, and saved when a gesture depends on it. ScheduledRunCheck compares what a scheduled team's launchers name with the file as saved — a profile it does not define or a folder id it does not declare (« will be refused »), the default, an entry older than the setting (its key judged by KeyAgrees) — and the card shows the first. « Install the schedule » (card and offer), saving « Change the folders », an adoption and a launch from the Run or Test screen save the settings when the file lacks what they name and the screen's document has it; a launch whose save is refused does not start and says why (Studio.Run.SettingsNotSaved). A launch pinning another settings file saves nothing. ConfigTabViewModel.Saved is raised after each save and load.
  • A team that changes machine. An import writes the team's launchers for this machine at once; « Install the schedule » writes them just before forge schedule; nothing is written at startup. « Export » writes the copy's launchers without the settings file, the model setting or a folder of the disk (TeamLaunchers.WritePortable), and an export or an import leaves schedule/ behind.
  • The engine writes nothing of the machine into FORGE.md or forge.json. The card's schedule section keeps orkeon forge schedule . and loses « By hand, on this machine » and its command, which rides the promoted event and a refusal's error only; forge rename retitles the card's title line alone. What forge schedule installed is recorded in schedule/installed.json (ConventionalNames.ScheduleDirectory, ConventionalNames.ScheduleInstallationFile), beside the artifacts, no longer in forge.json's schedule.installed; same fields, same rule for a copy made by hand; a re-adoption and a regeneration of the artifacts keep it.
  • Seven strings in the five languages. The screenshot world declares its folders under stable ids, and the in-flight run shot waits for the scripted run to be parked.

Migration: a team detached by a rename made before this version stays detached — its card says « absent », and « Modify » chooses it a setting. A team linked to an id the file never held (« declaration … is missing ») is repaired by « Change the folders ». A schedule installed before this version is recorded in forge.json, which nothing reads any more: the card's « Install the schedule » installs it again under the same names and records it in schedule/installed.json. A FORGE.md written before keeps its command.

Fixed — every setting a host cannot honour is refused at its start, naming its key, and orkeon doctor judges the file as a run does [breaking]

GAP-35 gave a refused setting one line and one exit code, but only some settings were judged at start (GAP-40). About thirty sections were read by the first service that needed them: with "Orkeon": { "Guardian": { "Enabled": "oui" } }, --validate answered VALIDATION OK, orkeon run loaded the crew then exited 2 on the binder's sentence, and orkeon-host declared itself ready and failed every run; a mistake in Orkeon:Rag or Orkeon:CrewMemory waited for the first run that used it, sometimes after model calls. Other values were swallowed, keys and section names written wrong were read as absent, names were checked at first use or never, and orkeon doctor judged the Llm section alone.

  • Every setting a shipped host reads is judged at its start, whether the run uses it or not. Each section is registered once — bound, validated with ValidateOnStart, its shape declared: the new AddOrkeonSettings<T>(path) (Orkeon.Infrastructure.DependencyInjection), or DeclareSettings(path) on an OptionsBuilder<T>, ValidateSettings(...) for a rule worded by its key, and DeclareSettingsShape(path, type) for a section read raw (SettingsDeclaration, Orkeon.Application.Configuration). RunnerHost.Build runs one start validation before anything else — no warning printed, no telemetry started —, which the REPL and orkeon doctor share: every declared section's options are created (the binder, the rules, the names they hold), then the section names, then the keys, then Orkeon:Rag:LlmProfile; the first refusal is the RunnerSettingsException. Nothing is built but options and the named factories: no store, provider, model or connection. PathSecurity, Orkeon:Sandbox, RateLimiting, Orkeon:Guardian, Security:*, Orkeon:Tools:Shell (ShellToolOptions — --list-tools crashed on its AllowInterpreters), Orkeon:Rag and its Ingestion, QueryRouting, Retrieval:Hybrid and WebFallback, Orkeon:CrewMemory, Memory, the five memory providers' sections, Orkeon:Consensus, Orkeon:CodeSandbox, Orkeon:CostTracking, Orkeon:TokenCounter, Orkeon:Encryption, Orkeon:Embeddings, Orkeon:EmbeddingCache, Orkeon:Scripting:Limits and :Toolchain, Orkeon:Cli:Session: all refuse the start now. The effective RagOptions are validated options too (the Orkeon:Rag:Profile preset with the section bound over it).
  • No value is swallowed. The default Llm section is read as strictly as its profiles — a TimeoutSeconds of "600s" ran on 30 s —, Thinking:Enabled and Grammar are true or false everywhere, and a Temperature is a finite number, in the default section and every profile: "NaN", "Infinity" or 1e400 (read as infinity) passed the strict read, then every request failed to serialise. So is every number a section reads as a float or a double — the binder took NaN and the infinities without a word: an Orkeon:Rag:Generation:Temperature failed every RAG answer, an Orkeon:CrewMemory:MinScore recalled nothing. RaggableTree:Embedding:Provider is one of its five names (a number is refused), Dimensions and MaxTextChars are whole numbers; LlmLogging is read strictly under --llm-log; a flat Orkeon:Rag:Retrieval:Hybrid is a boolean; Orkeon:Cli:Session:ContextWindowTokens is a number above zero, which token_budget reads from the session options (CliSessionOptions); Orkeon:Checkpointing is bound by the binder.
  • No key is ignored. A key a section the host reads does not carry is refused against the shape its readers declare — the readers of one section together, a sub-section another reader declares included: Orkeon:Guardian:Enabeld, Llm:Provider (the provider follows from BaseUrl and the model). The keys GAP-08 removed — Memory:ConnectionString, Orkeon:Rag:ConnectionString, Orkeon:Rag:ProviderOptions, Orkeon:Pinecone:Environment — are refused with their migration. A section name under Orkeon: and under Orkeon:Cli, Orkeon:Tools, Orkeon:Scripting, Orkeon:Security and Security is one of SettingsSections.Known (Orkeon.Constants.Configuration), the closest proposed (Orkeon:Guardain → Orkeon:Guardian). The root, Logging beyond its levels, Secrets, the keys of a dictionary and the keys of a section another host reads stay open. An e-mail account carrying a key no account carries is set aside and reported when named, like an account whose value cannot be read: the e-mail section stays the one exception.
  • Names are checked against the host's lists. Memory:Provider and Orkeon:Rag:Provider, with what the named provider needs (Orkeon:LanceDb:Endpoint; Orkeon:Pinecone:ApiKey and IndexName, or Host); the Rerank:Kind, QueryTransform:Mode, Context:Ordering and Ingestion:DefaultChunkingStrategy of the effective RAG options, against the factories this host builds — a C# host without the ONNX reranker refuses balanced and quality at its start, naming onnx; Orkeon:Rag:QueryRouting:Classifier; Orkeon:Embeddings:Provider, openai or ollama — another name took the OpenAI branch; the rule of Orkeon:Sqlite:TableName. MemoryProviderFactory no longer falls back on the volatile provider: an unknown type, or lancedb without its endpoint, is refused where it is reached, and a YAML crew's memoryProvider: that names no provider fails its load, like an unknown tool (MemoryProviderTypes, Orkeon.Application.Memory, is the one list).
  • Logging is judged before the logger is built. A level is one of the seven, any case; the console options are bound under the barrier. A level written wrong made the build throw a sentence without the key, past every barrier — orkeon-host, restarted by systemd every ten seconds.
  • orkeon-repl starts behind the same barrier (ReplStartup): its registrations, Logging, the start validation — one line, orkeon-repl: <reason>, exit 1, no console; a --settings file it cannot read is named with the line and the position. It opened on a file orkeon run refused.
  • orkeon doctor judges the file as orkeon run does. A runner-settings check, after llm-profiles, applies the run's guards to the mounts the file declares, then builds the host orkeon run builds — the ONNX reranker the CLI adds included, no crew, no MCP connection — and runs its start validation: one fail row per refusal, each naming its key, or one ok row; skipped when the Llm section is already refused. The --json schema is unchanged; one check name is added.
  • The settings files the repository hands out pass that validation, and a test holds every one of them (ExampleSettingsTests: the examples' appsettings*.json, the *.json.example templates, the smoke fixtures). The orkeon-host example named its DeepSeek key under Llm:ApiKeyEnvironmentVariable, which nothing reads — the daemon started without its key and every run failed on "API key is required" —: it writes ApiKeyEnvVar, and it and the streaming demo lose Llm:Provider. The release smokes' RAG fixture wrote its database under Orkeon:Rag:ConnectionString, so it stayed in memory and the search process found nothing the ingestion process wrote: it writes Orkeon:Sqlite:ConnectionString. The porting guide's Memory:ConnectionString is Orkeon:Redis:ConnectionString.

Documented in Configuration, CLI, Service host, E-mail and the porting example.

Breaking: a value that cannot be read, a key no section carries or a name the host does not know, in a setting a host reads, refuses its start — exit 1 for orkeon and orkeon-repl, 78 for orkeon-host, an exception out of StartAsync for a C# host (values and names) — whether the run uses the setting or not; the default Llm section is read as strictly as the profiles; an unknown Memory:Provider, or lancedb without its endpoint, no longer runs on the volatile in-memory provider, and IMemoryProviderFactory.GetProvider throws on such a type; Orkeon:Embeddings:Provider accepts openai and ollama only; orkeon doctor judges the file as orkeon run does, and may exit 1 on a file it called green; TokenBudgetTool takes the session options in place of the configuration key it read.

Migration: fix the value, the key or the name the line names. Move a key GAP-08 removed to the section its refusal names. A C# host whose profile reranks with onnx registers AddOrkeonOnnxReranker(), or names another profile.

Fixed — a crew exported to YAML reads back the same: everything the loader reads, under its author's keys [breaking]

YamlCrewExporter — the export AddOrkeonYaml() registers for a C# host — wrote another crew than the one it was given, without a word (GAP-39). Reloaded, the crew answered without its knowledge and its guardrails, the framework no longer wrote its deliverables, its EventHub door followed the host's policy instead of what it declared, and every agent and task had been renamed.

  • Everything the loader reads is written. The crew's memoryProvider, graphConfig, rag (collections, their sources as written, their chunking, defaults.profile) and links — an empty links: [] stays a closed door, an absent block stays absent —, an agent's guardrails and knowledge (the short form for an attachment that only names its collection), a task's deliverable and guardrails: each was lost. What the loader transformed is written as the configuration carries it: a guardrails preset: as the header, rules and tool rules it brought, the crew's llm: under each agent, anchors: as their text. ExportToDirectoryAsync writes the crew keys from the same mapping as ExportToString, where it kept a copy of its own.
  • Under the author's keys. AgentConfiguration.Key and TaskConfiguration.Key keep the key an agent or a task has in its crew file — the mapping key, or the file name in the per-entity layout; the YAML loader sets them, a configuration built in code or by a .ork.ts script has none. The export writes each entry, and each agent:, dependencies: and managerAgent:, under that key, where it wrote a fresh identifier (01J9…) nobody could read; a configuration without keys keeps its identifiers. Two entries under one name, or a reference that names no entry, fail the export with an InvalidOperationException naming them: the loader would refuse the file.
  • No key nobody set. YamlDotNetSerializer.Serialize no longer writes a null property as an empty key: line — an exported crew of three agents carried dozens —, the form the forge already used through SerializeWithoutNulls, which is gone. A value set to its default, false or 0, is still written.
  • The validator names an agent or a task by its key. Invalid crew configuration: Agent 'researcher' must have a goal., where orkeon run named Agent '01J9…', an identifier the author never wrote; a configuration built in code is named by its identifier, as before.

The round trip is proven on a canonical projection of the configuration, by two witness crews that set every key the YAML models read — a key added to a model fails the test until a witness sets it, and the round trip then makes the export write it —, and by every crew of examples/. The second export of a reloaded crew is the first, byte for byte.

Documented in YAML schema.

Breaking: YamlDotNetSerializer.SerializeWithoutNulls is removed and Serialize omits null properties; the export writes agents and tasks under their keys; the validator's messages name a loaded crew's entries by their keys.

Migration: call Serialize where you called SerializeWithoutNulls.

Removed — public surfaces nothing called, continued: a task state machine and queue, aggregate restores and mutators, an agent stop switch, two ports nothing resolved; AddOrkeonApplication(o => …) no longer resets a setting [breaking]

Public types and members that no run, host or REPL called are deleted rather than kept (GAP-37, after GAP-26). Only a C# host could see them: the CLI, orkeon-host, the REPL and Studio behave as before.

  • Application options. AddOrkeonApplication(o => …) registers the lambda as is (services.Configure(configure)). It applied it to a fresh instance and copied ten fields back: EnableDebugLogging and DefaultTimeout were lost, and a strategy a services.Configure<OrkeonApplicationOptions>(…) had set before it was reset to FirstFit. The two routes the documentation gives now compose, in either order. OrkeonApplicationOptions keeps AgentSelectionStrategy, the only setting anything read; CrewRepositoryType (with the RepositoryType enum), CrewsPath, DefaultMaxIterations, EmbeddingDimension, EmbeddingProvider, OpenAIApiKey, OpenAIEmbeddingModel, AzureOpenAIEndpoint, AzureOpenAIDeploymentName, EnableDebugLogging and DefaultTimeout are removed — no section bound them, nothing read them —, with the constants only they used (PathDefaults, EmbeddingDefaults.FallbackProvider and DefaultOpenAIModel).
  • A task state machine and a task queue no mode runs. TaskStateManager (Orkeon.Application.Services.StateManagement, with StateTransitionResult<TState>, TaskStateEvent, TaskReadinessFlags, TaskStatusFlags, TaskAction, PriorityAdjustment and a second TaskExecutionContext — Orkeon.Domain.Agent.TaskExecutionContext stays) and what it alone used (RetryPolicy, ExecutionTimePolicy, three delays of TaskDefaults): a run moves its tasks through their lifecycle itself (GAP-21). AsyncTaskPipeline<T>, CrewTaskPipeline, ITaskQueue<T> and WorkItem<T>: no mode queued a task through them.
  • Aggregate restores. CrewTask.Restore (both overloads), CrewTaskSnapshot, the restore constructors of CrewTask and CrewTaskBase<TContext>, and Crew.Restore had no caller — no repository persists the aggregates —, and the snapshot lost a task's deliverable, LLM override and guardrails, as AgentSnapshot lost an agent's LlmConfig (GAP-26).
  • The crew export. CrewConfigurationMapper.ToConfiguration, the class's last method, ran only in its tests. CrewConfiguration.ExecutionConfig and CrewConfiguration.Metadata, set by no loader (YAML, .ork.ts) and read by no run, go with it, and so do the ExecutionConfig record and TaskDefaults.DefaultOperationTimeout. ManagerLlm.Describe, which the export called, stays: the manager's resolver names the manager's LLM with it.
  • Settings DTOs and an execution history. Orkeon.Application.Common.DTOs.CrewSettingsDto, with CallbackConfigDto, MemoryConfigDto, MemoryLimitsDto, MemoryCleanupDto, VectorConfigDto, RetryConfigDto and TimeoutConfigDto, had no user; CrewDto.ExecutionHistory (ExecutionHistoryDto) was filled by nothing.
  • Aggregate mutators. Agent.UpdateConfiguration, Crew.UpdateConfiguration (both overloads, with CrewConfigurationUpdate) and CrewTaskBase<TContext>.UpdateConfiguration had no caller, and every new rule had to be copied into them (GAP-30, GAP-31, GAP-33, GAP-34) or they bypassed it. The rules stay where a crew, an agent and a task are built: a memory provider needs memory, a planning provider needs planning, an agent whose provider runs its own tools is refused delegation.
  • The agent stop switch. IAgentLifecycleManager with AgentLifecycleState and AgentLifecycleManager — registered by AddOrkeonInfrastructure(), resolved by nothing since GAP-26 —, Agent.RegisterCancellation, Agent.StopAsync, AgentKilledEvent (30 domain events remain), Crew.SetKillAllStrategy and Crew.StopAllAgentsAsync. A run stops through its cancellation token (orkeon run, orkeon-host's /stop).
  • Two ports nothing resolved. IYamlDiffService and ITemplateInstantiator, their stubs (NullYamlDiffService, NullTemplateInstantiator) and their registrations: the documentation invited a host to replace them, but nothing called them, so a host's own implementation never ran. The types only they used go too: ConfigurationDiff, ConfigurationChange, ChangeType, ConfigurationVersion, RollbackOptions, RollbackResult and ConfigurationVersionId; InstantiationValidation, TemplateType, InstantiationPreview, AgentTemplateDefinition, TaskTemplateDefinition, CrewTemplate, AgentTemplate, TaskTemplate and their ids (AgentTemplateId, TaskTemplateId, CrewTemplateId), InvalidTemplateParameters, ResolvedTemplateParameters and TemplateConfiguration. TemplateInstantiationParameters and TemplateParameterValue, which ITemplateEngine uses, stay.
  • A package reference nothing used. Orkeon.Tools.Abstractions no longer references Microsoft.Extensions.AI: the nine tool families, Orkeon.Interop.AgentFramework, four test projects and the local-embeddings example no longer restore it through it. Orkeon.Infrastructure keeps it, so the binaries and the Orkeon package — the only one Orkeon.Tools.Abstractions ships in — still carry it.

Documented in Default behaviors, Events, CQRS and Observability, EventHub & Crew Lifecycle and ADR-010.

Breaking: every type and member listed above is removed. AddOrkeonApplication(Action<OrkeonApplicationOptions>) keeps its signature; a strategy configured before it is no longer reset.

Migration: remove the assignments of the removed settings (they had no effect); build a crew through the loaders (YAML, .ork.ts) or the builders (CrewBuilder, AgentBuilder, CrewTaskBuilder), its settings given at construction, without Restore or UpdateConfiguration; stop a run through its cancellation token; remove any registration of IYamlDiffService or ITemplateInstantiator (nothing called them).

Fixed — every published artefact carries the notices of what it redistributes, and the Studio TUIs ship the pinned package versions

THIRD-PARTY-NOTICES.md covered every package the shipped applications redistribute, and travelled with the tool packages, the archives, the .deb and both MSIs — but not with the container images, not for the .NET runtime the self-contained installers bundle, and not for the esbuild binary (GAP-45). The two Studio TUIs, meanwhile, shipped older package versions than the CLI, the REPL and the host.

  • The images carry the license and the notices. Dockerfile.runners (the published ghcr.io/orkeon/orkeon-runners and its local-llm variant), deploy/Dockerfile.host and the root Dockerfile copy LICENSE.md and THIRD-PARTY-NOTICES.md to /usr/share/doc/orkeon/, the Debian package's path, and .dockerignore no longer keeps them out of the build context. An image's .NET runtime is its Microsoft base image's, which carries its own notices.
  • The bundled .NET runtime ships with its own notices. After each self-contained publish — orkeon, orkeon-host, the Orkeon Studio applications —, scripts/package-installers.sh and its .ps1 mirror run python3 scripts/third-party-notices.py --runtime-notices <publish> --project <csproj> --to <payload>/licenses, which copies byte for byte the license and the third-party notices of the runtime packs the publish's deps.json names, found where the inventory looks: licenses/Microsoft.NETCore.App.Runtime.<rid>/, plus licenses/Microsoft.WindowsDesktop.App.Runtime.win-x64/ beside Studio on Windows. A pack missing, or without its notices, stops the packaging; a framework-dependent publish has none to copy. The .deb installs them under /usr/share/doc/orkeon/licenses/, the service MSI under licenses\ (its build script requires the folder), the CLI MSI with the rest of the tree, and the archives' install.sh and install.ps1 copy them with THIRD-PARTY-NOTICES.md into the installed tree — they copied LICENSE.md alone. The packaging scripts need Python 3.
  • esbuild has its section. Section 12 gives the MIT license of the TypeScript transpiler the archives, the .deb, the CLI MSI and the orkeon-runners image ship, at the version tools/scripting-esbuild/package-lock.json locks.
  • The Studio TUIs ship the pinned versions. orkeon-studio-config and orkeon-studio-run got Markdig and ten Microsoft.Extensions.* packages from Terminal.Gui alone, at its minimums (1.3.2 and 10.0.11), while Directory.Packages.props pins 1.4.0 and 10.0.12: central management pins direct references only. Orkeon.Cli.TerminalGui now references the five Terminal.Gui asks for — Markdig, Microsoft.Extensions.Configuration, .Configuration.Binder (10.0.12, a new central pin), .Configuration.Json and .Options —, their dependencies follow, and the inventory loses its eleven older rows: 151 versions, one per package.
  • --check keeps it so. It also fails now when a Dockerfile that publishes an application does not copy both files into the image it produces (a copy in a stage the image does not inherit does not count), when the build's ignore file keeps either out of the context, and when a shipped package resolves below the version Directory.Packages.props pins, naming the applications and both versions. scripts/test-third-party-notices.py proves the new rules and the new mode on throw-away trees.

Documented in Three ways to run Orkeon, the service host, the archives' README.md and CONTRIBUTING.md.

Fixed — a YAML agent's guardrails: reach its prompt, before its task's, and an unknown preset fails the load [breaking]

The guardrails a YAML agent declares — a preset, rules, toolRules — were read onto the crew's configuration and never handed to the agent CrewFactory built (GAP-42): the system prompt carried its tasks' guardrails alone, for every crew loaded from YAML — orkeon run on a file or a directory, orkeon-host, the REPL — in every mode. Example 102-ts-codebase-documentation ran without its rules against invented files.

  • An agent's guardrails reach its prompt. CrewFactory passes them to the agent, and the one prompt composer renders them before the task's, as the documentation said: the preset's header and rules, then the agent's own, then its tool rules for the tools it holds. A crew that declares agent guardrails sees its prompts change — that is the fix.
  • An unknown preset fails the load. A preset: the domain does not know — analysys — gave no guardrails at all, on an agent as on a task, or kept the block's own rules alone, without a word. The load fails now, in one line naming the agent or the task by its key, the preset as written and the three known ones (analysis, strict, creative). A blank preset is no preset.
  • A tool written twice in toolRules fails the load. file_write and File_Write name one tool — a tool name ignores case — and the load threw a raw "An item with the same key has already been added". It names the agent or the task and the tool's spellings now. A tool written without rules adds none, where the load failed with a raw "Value cannot be null".
  • The templates of a configuration built in code reach the agent. CrewFactory passes an AgentConfiguration's SystemTemplate, PromptTemplate and ResponseTemplate to the agent it builds: a host that built or adjusted a configuration in C# (config with { … }) lost them without a word. No YAML key is added, and nothing reads PromptTemplate yet.

Documented in YAML schema and YAML and builders.

Breaking: a guardrails preset: other than analysis, strict or creative, and a tool written under two keys of toolRules, no longer load; the system prompt of an agent that declares guardrails now carries them, before its task's.

Migration: write analysis, strict or creative — or remove the preset; keep one key per tool in toolRules.

Fixed — a team's launchers hand the run its path and its inputs as they are: one composer for forge promote and Studio

cmd reads a team's run.cmd first and orkeon splits what it hands over second; both writers of the launchers — forge promote and Studio (STUDIO-50) — wrote for one of those readings, and neither told cmd the file is UTF-8 (STUDIO-51). A Windows profile with an accent (C:\Users\Zoé) turned --settings into C:\Users\Zo├®\… and the run went on without its settings file; French sample inputs arrived as ├ëconomie; written without Studio, seuil=10% lost its %; a team folder in a OneDrive « R&D » folder cut the command; and a sample input holding a quote then & — text the forge's model writes — ran what followed as a command at each scheduled run.

  • One composer writes both launchers (TeamLauncherScript, Orkeon.Domain.FileSystem): the writers say what to launch, it writes the text, and forge rename still finds the header (TeamLauncherScript.Header replaces ForgePromoter.LauncherHeader and TeamLaunchers.Header). Each value is written for the runner first, then for cmd — every % doubled; a value without a quote between cmd's quotes end to end; a value with one outside them, each quote and operator escaped; the stretch carrying %~dp0 always between quotes —: every value reaches the run as written, whatever the team's path holds. A line break is a space in run.cmd — a comment line says so — and is kept in run.sh.
  • run.cmd's frame: UTF-8 without a BOM, named so by both writers; ASCII up to chcp 65001, the caller's code page captured and given back before orkeon starts; setlocal EnableExtensions DisableDelayedExpansion whatever the registry says; the command in a block ended by exit /b, which keeps orkeon's exit code and never lets cmd read the file again — a launcher written again during a run is not read from the middle.
  • Beyond 8 191 characters once expanded, run.cmd launches nothing: it prints the length, the bound and the longest option on stderr, and exits 1; run.sh stays complete. forge promote says so with a warning (FORGE-LAUNCHER-TOO-LONG) and succeeds. Studio's adoption line says it — TeamLaunchers.Regenerate returns a TeamLaunchersResult (written, unchanged, no team, disk refused, and the Windows launcher's refusal) instead of a bool — and says the engine's last warning in the sentence of its code: FORGE-SCHEDULE-STILL-INSTALLED no longer reads as a session folder not renamed.
  • orkeon run --option=value takes any value. An initial context starting with - — a bullet list — had the run refused as an unknown option, and written --initial-context=… it was refused as soon as it held a line break or started with a space: CommandLineParser 2.9.1 reads an attached value only when it matches ^([^=]+)=([^ ].*)$. orkeon run now reads an attached value as written, cut at the first = — several lines, a leading dash or space included (RunnerArguments, Orkeon.Hosting) —, and what parsed before parses the same. The launchers and Studio's RunArgumentsBuilder write every single-value option that way; Studio refuses a variable name or a mount starting with - before the launch (STUDIO-LAUNCH-VAR, STUDIO-LAUNCH-MOUNT-DASH).
  • The scheduled task runs cmd.exe /d /v:off /s /c ""<team>\run.cmd"", a quoting that does not depend on what the path holds; systemd's ExecStart escapes the path (\\, \", %%, $$) and the cron line puts it between single quotes (\% for a %). forge schedule --check reads a task of the former form stale (reason outdated), and an install writes former artifacts again first.
  • The command line Studio shows and copies — the preview, « Copy the command », the history, a failure report — is a line for cmd under Windows, each argument written by the composer: pasted, it launches what Studio launches. PowerShell is not covered.

Migration: a team scheduled on Windows before this version reads « Schedule to reinstall » once — the card's « Install the schedule » (forge schedule) sets it right. The launchers of a team adopted before take the new form at the next change of its setting or its folders, or at the next forge promote. TeamLaunchers.Regenerate returns TeamLaunchersResult — read its Outcome; ForgePromoter.LauncherHeader is TeamLauncherScript.Header.

Fixed — Studio keeps a setting's key and presents it as the run reads it: its card recognised in every language, the run's order in the TUI, a missing key said missing, Docker Model Runner's placeholder key

A model setting created on « Other OpenAI-compatible » or « None / offline » opened without a card once the interface switched language: the editor recognised a card by its title, translated. Saved so, the setting lost the variable holding its key — in studio-model-profiles.json and in its Llm:Profiles:<id> entry —, and its runs, Studio's included, ran without a key. The orkeon-studio-config « Test » presented another key than a run, the status bar said « key refused » for a key never remembered, and a Docker Model Runner setting passed its « Test » and failed every run (STUDIO-54).

  • A setting keeps its card's name. ModelProfile.Provider holds the card's stable name (deepseek, custom, none), never its title; the list, the creation assistant's step 4 and the status bar show the title in the language of the moment, said again when it switches. A value that is no card name — a title an older Studio wrote, in any language, a provider the default blanked, a hand edit — is recognised as the store reads it (LlmPresets.CardOf: the name, then the English title, then the endpoint; an endpoint no card carries is « Other OpenAI-compatible », neither endpoint nor model « None / offline »): a setting always opens on a card, with that card's key variable. The name reaches the file with the next gesture on the settings, never at startup.
  • The TUI presents the run's key. Its « Test » read the file's key before ORKEON_Llm__ApiKey; a run does the reverse. It now follows the run's order — ORKEON_Llm__ApiKey, the file's ApiKey, Llm__ApiKey, then the variable Llm:ApiKeyEnvVar names, process then user scope —, a parity test holding it against the runtime's own reader. Without any key it refuses, at once and without a request, every endpoint but Ollama's, as a run refuses it: « API key missing — name the variable that holds it (API key variable), or set ORKEON_Llm__ApiKey ».
  • A missing key is said missing. The balance probe answers a new ProviderBalanceStatus.KeyMissing for an account whose variable holds no key, without a request; « key refused » is a provider's 401 or 403 alone. The bar says « DeepSeek · key missing », quietly like a refusal, in the five languages.
  • Docker Model Runner gets its placeholder key. The run reads that server as OpenAI, whose dialect refuses to call without a key: orkeon init and the TUI write "ApiKey": "not-needed", Studio's card wrote nothing. A setting of that card now writes it in its entry, and in Llm when elected — the one ApiKey Studio writes, where none is set —, lays it on its launches and presents it to « Test »; electing another card takes exactly that value out of Llm, where it would pass before the elected setting's ApiKeyEnvVar. One rule judges a section's key (LlmProfilesSection.KeyAgrees), and an entry or an Llm that disagrees is written again at the next gesture, once. The validator reports not-needed beside an Llm:ApiKeyEnvVar (a hand edit). DockerModelRunnerDefaults.DefaultModel and .ApiKeyPlaceholder are aliases of the Orkeon.Constants.Llm values Studio reads, as BaseUrl already was.

Migration: a setting the default damaged finds its card again when Studio opens; if its key was in ORKEON_Llm__ApiKey (an « Other OpenAI-compatible » setting from before STUDIO-49), remember it again in the editor — the card keeps its key in ORKEON_CUSTOM_LLM_API_KEY. A Docker Model Runner setting runs at once from Studio, and outside Studio after the first gesture on the model settings.

Fixed — a stopped A2A server no longer binds its port again, the test suites hold under load, the examples restore offline, and CI's NuGet cache keeps the packages

Under Linux and macOS, A2AServer.StopAsync called HttpListener.Close() on the listener Stop() had just stopped. Close() goes back through the listener's prefixes and, finding nobody listening on the port any more, binds it for an instant to remove them: a port another process had taken in between made the stop throw « Address already in use », and a free one was held again, for that instant, under whatever started next on it (GAP-41).

  • The stop releases the listener with Abort(), which marks a stopped listener closed without going back through its prefixes; under Windows it frees the HTTP.sys configuration, as Close() does.
  • A test server takes its port through LoopbackPorts (Orkeon.Tests.Shared.Network). Thirteen copies of one probe — a port asked of the system, given back, bound later by the server — left it to whoever took it in between, and the A2A suites failed on « Address already in use » when passes ran at once. StartAsync and StartListener start the server and, when the port turns out to be taken, dispose it and start again on another one — ten attempts, then the last conflict; any other refusal still fails at once. Servers listen, and clients call, on 127.0.0.1 (localhost under Windows): HttpListener binds the first address its host name resolves to — ::1 for localhost on a machine that ranks it first, a port the probe never looked at. Refusing() holds a port nobody listens on, for the tests that need a refused connection (an LLM endpoint probe, an IMAP mailbox) and used to count on a port given back staying free. The three HTTP doubles stop their listener with Close() alone.
  • A span test reads an ActivityRecorder (Orkeon.Tests.Shared.Telemetry), which adds each activity under a lock and hands out copies; the test keeps to the trace of a root it starts. Three tests walked a list a process-wide listener kept filling from their neighbours' threads — one of the two Orkeon.Application.Tests failures that came one pass in three.
  • A delay a test must not reach is a hang guard, and no unit test bounds a duration. Eight receptions of messages already sent (budgets of 100 ms to 1 s), five more of 1 s, and a 200 ms token racing the EventHub's own 100 ms timeout now allow 10 s and end on what they wait for. Three assertions that measured the machine — a token count under 100 ms, 10,000 tasks created under 1 s, a kickoff under 5 s — are gone, and what those tests check otherwise stays; a timestamp is checked between two readings of the clock, never within a window of it, and a duration a test builds comes from one reading — two put the time between them into a duration expected to the millisecond.
  • A test that orders two concurrent ends forces that order. The sequential asyncExecution test expecting the hook to hear the synchronous task before the launched one only made the launched task wait for the other to start: under load, its own end reached the hook first. It now waits until the hook has heard the other's end. The hook is unchanged — it hears each task as it ends.
  • The examples restore offline. Microsoft.Agents.AI 1.20.0 brings an edge to Microsoft.Extensions.AI.Abstractions (>= 10.8.2), a version nuget.org never published: every restore of examples/interop/agent-framework whose graph changed asked nuget.org for the version list, and failed without a network. The example references the package directly, at its central version (10.10.0, the one already resolved): a direct reference eclipses the transitive edge, which NuGet no longer resolves. The resolved graph is unchanged.
  • CI's NuGet cache keeps the packages. Under Linux a restore fills <repository>/packages (RestorePackagesPath, Directory.Build.props), but the eight actions/cache steps kept ~/.nuget/packages: every run downloaded the whole closure again — TreeSitter and the two ONNX Runtimes alone weigh 1.3 GB. They cache both folders now, keys unchanged.

Nothing breaks.

Fixed — model requests are bounded as declared: an agent's and a crew's maxRpm, the host's RateLimiting on every call [breaking]

An author writes maxRpm: 5 on a YAML agent, .MaxRpm(5) in C# or CrewBuilder.MaxRpm(30) to stay under a provider's quota, and the docs promised a limit: nothing applied it, and the host's own limit did not do what it said (GAP-38).

  • maxRpm is applied, as CrewAI's max_rpm. An agent's bounds the model requests it makes per minute — each turn of its loop, the tool-free retry, the correction round, a ballot, a delegated colleague's turn (counted for that colleague); a crew's bounds those of all its agents and its manager together, parallel waves, vote candidates and ballots included. Each object that declares one has a sliding window of 60 s: the request of too many waits its turn — it never fails the task —, follows the run's token (Ctrl+C, RunTimeout, /stop) and counts nothing when cancelled, and one Information line says who waited, how long and under which limit. A crew run from a task counts in its own window. No default: Agent.MaxRpm and Crew.MaxRpm are int?, the 10 and 100 that applied nowhere are gone, and a run that declares nothing waits for nothing.
  • Every surface declares both levels. YAML gains the crew's maxRpm: (max_rpm: accepted — a crew ported from CrewAI lost it without a word), .ork.ts gains agentBuilder().maxRpm(n) and crewBuilder().maxRpm(n), in YAML parity; the procedural shape, whose ctx.llm calls are no agent turns, applies neither and warns once. A maxRpm of 0 or less fails the load naming the agent or the crew — it became 10 —, and so does a maxIter of 0 or less — it became 15.
  • maxIter is 20 everywhere. AgentDefaults.MaxIterations goes from 15 to 20 — CrewAI's max_iter — and is the one default: YAML, AgentConfiguration and the DSL read it, and a C# agent without MaxIterations takes 20 turns too. ExecutionOrchestrator.MaxIterations and the loops' default iteration count never applied — Agent.Create refuses zero — and are removed: the number of turns is set on the agent.
  • The host's per-agent cap is each agent's. RateLimiting:AgentRequestsPerMinute was a bucket per role, in a singleton, created once: two teams of orkeon-host with a "Researcher" each shared it, from one run to the next. It now bounds each agent instance's own window, with its maxRpm, the stricter winning, and a request over it waits instead of failing after the queue.
  • The global and per-provider caps hold on every call, once. GlobalRequestsPerMinute counted agent turns only: the manager, the planner, the RAG pipeline, the judges and the cognitive memory called the model past it. The limiter now sits at the entrance of each provider, around the token meter — the factory, AddOrkeonLlmProvider and AddOrkeonLlmProfile, the profile registry's ForProvider, the manager's resolver, a C# crew's planner —: every model call of the host takes one lease, the scripts' ctx.llm included, and orkeon run no longer wraps their provider in a limiter of its own. A provider passed through two entrances takes one lease, a call made inside another limited call takes none (MaxConcurrentRequests: 1 no longer waits on itself), and a provider that runs its own tools (the Microsoft Agent Framework bridge) is not limited itself: what it calls of Orkeon's model is. A refusal is retried five times on its RetryAfter, then the turn fails as a failed call, with the limiter's reason.
  • The manager's review stops with its run. It went out under CancellationToken.None: Ctrl+C, RunTimeout and /stop waited for it. IManagerAgent.ReviewOutputAsync takes the run's token, and a cancelled review is no longer an approval by default.

Documented in YAML schema, YAML and builders, Security, Configuration, LLM providers, Opt-in subsystems, Scripting DSL, Process types and Agent Framework interop.

Breaking: a declared maxRpm makes requests wait; Agent.MaxRpm, Crew.MaxRpm, AgentCreateOptions.MaxRpm, CrewCreateOptions.MaxRpm and AgentSpawnRequest.MaxRpm are int?, null by default, AgentConfiguration.MaxRPM is int? MaxRpm and CrewConfiguration gains MaxRpm; AgentDefaults.MaxRequestsPerMinute and CrewDefaults.DefaultMaxRpm are removed; a maxRpm or maxIter of 0 or less fails the load; maxIter is 20 in C# too; the host's per-agent cap holds per agent and waits; every model call of the host counts against RateLimiting, the manager, the planner and RAG included; ILlmRateLimiter.AcquireAsync loses its agentRole parameter; the ExecutionOrchestrator constructors lose their rate limiter and MaxIterations is gone; RateLimitingOptions moves to Orkeon.Application.Configuration; RateLimitedLlmProvider is built by RateLimitedLlmProvider.Wrap and loses AgentBucketCount and DefaultMaxAcquireRetries; IManagerAgent.ReviewOutputAsync takes a CancellationToken; CrewConfigurationMapper exports a crew's rate as CrewConfiguration.MaxRpm, no longer ExecutionConfig.MaxRPM.

Migration: remove maxRpm, or raise it, where a crew must not wait; read Agent.MaxRpm and Crew.MaxRpm as int? (null: no limit of its own) and omit maxRpm instead of writing 0. Set MaxIterations(15) where a C# agent relied on 15, on the agent: ExecutionOrchestrator.MaxIterations never applied and is gone. Raise RateLimiting:GlobalRequestsPerMinute if the manager, the planner or RAG now make a busy host wait. Call AcquireAsync(provider, ct); build ExecutionOrchestrator without a rate limiter; import RateLimitingOptions from Orkeon.Application.Configuration; a custom IManagerAgent takes the token its review is given.

Fixed — the third-party notices list every package the shipped binaries redistribute, generated from the restore and checked by CI

THIRD-PARTY-NOTICES.md promised an entry for whatever the packages and the installers redistribute, and had one for 11 of the 162 package versions the shipped applications carry: CommandLineParser, which both tools and every installer ship, had none (GAP-36, decision 6). It also said OpenTelemetry and Gremlin.Net "intentionally get no entry", being "only referenced" — the orkeon tool ships both.

  • A generated inventory closes the file. scripts/third-party-notices.py reads the restored project.assets.json of the six applications the tool packages, the installers and the container images publish — orkeon, orkeon-repl, orkeon-host and the three Orkeon Studio applications the installers add — and the .nuspec files of the local NuGet cache: the assets file's packageFolders, a Windows path there also tried at its WSL mount, then NUGET_PACKAGES, then ~/.nuget/packages, never the network. It lists every package whose restored target puts a file in the build output (a managed, satellite, native or RID-specific asset; compilers, analyzers and meta-packages put none and are left out): 162 versions of 151 packages, each with its license — the SPDX expression, or the file the package names —, its copyright, its project URL, the applications that ship it and the texts it carries. Sorted, and dated nowhere: the same restore writes the same file.
  • The texts travel with the binaries. Every license file and every notice the packages ship is copied verbatim (line endings normalised, the NUL that ends an RTF file dropped), each distinct text once: 10 license texts and 10 notices — Gremlin.Net's Apache-2.0 NOTICE, propagated as §4(d) requires, and the third-party notices of ONNX Runtime, OpenTelemetry, the .NET libraries, Roslyn, ML.Tokenizers and Onigwrap. The file grows from 39 KB to 749 KB; the tool packages, the archives, the .deb and both MSIs already ship it.
  • The criterion says what ships. Criterion (a) states that the tools and the installers redistribute the whole runtime closure of their binaries, and the OpenTelemetry/Gremlin.Net sentence is corrected: both are in the inventory, with their texts. The hand-written sections stay — provenance, decisions, Apache.Arrow's NOTICE —, and a package one of them covers points to it.
  • CI keeps it true. ci.yml runs python3 scripts/third-party-notices.py --check after its restore. It fails, package by package, when the closure changed without regeneration; when a version a hand-written section states is no longer the shipped one — it found two, Jint (4.16.1 stated, 4.16.3 shipped) and Microsoft.Extensions.AI.Abstractions (10.9.0, 10.10.0), both corrected —; and when an installer table, a PackAsTool project or a Dockerfile publishes a project the script does not read. A package bump, Dependabot's included, therefore needs the script run and the file committed (CONTRIBUTING says so). scripts/test-third-party-notices.py proves the rules on a throw-away tree, before any restore.

Fixed — Studio's « Test connection » and balance read present the setting's own key, never the default's

A model setting with no key remembered was tested with the key of Studio's own process in ORKEON_Llm__ApiKey — the default's key —, sent to the setting's address: a « Z.AI » setting without its key sent the default's DeepSeek key to Z.AI, and a Docker Model Runner setting carried it too. The balance read did the same for an account whose variable held no key — and for a setting that names no variable at all (GAP-36).

  • The setting's key, and it alone. « Test connection » and the balance — the editor's « Read the balance », the profile rows and the status bar — present the key typed and not yet remembered, else the one remembered under the setting's variable. ORKEON_Llm__ApiKey serves only a setting whose variable it is (an « Other OpenAI-compatible » setting created before STUDIO-49). A setting that needs a key and has none is refused without a request, with the existing « API key missing — remember it first »; a setting that needs none — Ollama, Docker Model Runner — presents none, not even a key typed for another card; an account whose setting names no variable presents none.
  • The run of the elected default still reads ORKEON_Llm__ApiKey first when it is set (STUDIO-49): the test checks the setting's key, and orkeon doctor's llm-config row and the run's startup line say where the default's key really comes from.
  • ProviderBalanceAccount.RequestWith loses its fallback, and ProviderBalanceAccount.For gives a setting that names no variable an account with none (KeyVariable empty) where it named ORKEON_Llm__ApiKey. The documentation of LlmProbeRequest.ApiKey says whose key it is.
  • Nothing changes on screen otherwise. LlmSectionViewModel keeps what the settings screen calls — the election, the mirror of the settings into Llm:Profiles, the healing of a default, the RAG's profile, the entries written by hand, the check of a name — and loses a form of the Llm section and a connection test that no view displayed, with its probe and dispatcher, and three strings no screen showed (Studio.Settings.NoBaseUrl, Studio.Settings.CustomProvider, Studio.Settings.ApiKeyRecommendation, in the five languages).

Documented in Orkeon Studio.

Fixed — orkeon init's probe presents the key a run presents, a run reads no settings file but the one it resolved, and orkeon-host names only the profiles it offers [breaking]

Three tools said something other than what a run does (GAP-36, decisions 3, 5 and 7).

  • orkeon init's probe presents the run's key. It read the variable -k names, in its own process alone — before ORKEON_Llm__ApiKey, the key a run takes first, and never in the Windows user scope, where Orkeon Studio remembers a key: a key Studio remembered failed the probe that the run then passed, and with both set the probe tested a key the run would not send. It now reads the file it has just written as orkeon doctor does (RunnerSettings.ReadConfiguration, then LlmSettings.ReadDefault): the key the configuration resolves, else the variable Llm:ApiKeyEnvVar names, in the process then in the user scope, presented to the endpoint the run calls. It says where the key comes from (Probing <endpoint> — API key from the variable named by Llm:ApiKeyEnvVar (user environment)), never the key; a reference that resolves nothing is warned about first, in the runners' words (OperatorMessages.LlmApiKeyReferenceUnresolved); and a section a run would refuse — a reference that is no variable's name, an ApiKey written ${NAME}, a BaseUrl that is no address — fails the probe with the reader's message and exit 1, the file written.
  • A run reads the settings file it resolved, and no other. The runner hosts were the default .NET host plus the resolved file and the ORKEON_ layer: under the file lay the appsettings.json and appsettings.{Environment}.json of the current directory — since .NET 10, <binary>.settings.json and its environment twin too — and, in Development, the user secrets. The folder a terminal happened to be in could add profiles, MCP servers or mounts to a run, and orkeon doctor, which read the file and ORKEON_ alone, never saw them; the REPL did the same, its --settings files under the bare variables. Every host now composes the same layers, in one place (RunnerSettings.ComposeSources): the environment variables without a prefix — the lowest layer, kept because the OpenTelemetry exporter reads the OTEL_EXPORTER_OTLP_ENDPOINT a .NET Aspire AppHost sets through it, which OpenTelemetryIntegrationTests now proves —, the resolved file (for the REPL, its --settings files, else the global file), then ORKEON_; the REPL's command line stays last. RunnerSettings.ReadConfiguration — orkeon doctor, orkeon forge, the --llm-profile guard, init's probe — composes the same layers: a bare Llm__ApiKey that changed the run changes the verdict too. orkeon-host reads ./appsettings.json as its settings file when --settings names none, as its help says — by resolution now, which its reserved-root guard reads too —, never under the file --settings names. No source watches its file: the default host's watcher over the current directory's tree went with its files. The REPL project's own appsettings.json, never shipped, is deleted. Migration: a setting that came from an appsettings.json of the current directory moves into the settings file the run resolves (the appsettings row of orkeon doctor names it) or the one --settings names; orkeon-host --settings <file> no longer reads ./appsettings.json beside it; a bare variable that overrode a REPL settings file (Llm__Model) takes the ORKEON_ prefix (ORKEON_Llm__Model), which wins over the file in every host.
  • orkeon-host names the profiles it offers. Under its allow-list (Orkeon:Host:LlmProfiles), the startup line LLM profiles offered to crews besides the default listed every profile of the file, and a hidden profile whose key reference resolved nothing was warned about, on the log and on stderr, although no crew can name it. The lines now follow the registry (ILlmProfileRegistry.Names, the list applied): the profiles offered, each with where its key comes from, a warning for those alone, and one Information line naming the hidden ones (LLM profiles hidden from crews by the host's allow-list: …). Without a list — orkeon run, the REPL — nothing changes.

Fixed — Studio saves the settings it has just written: an integer a screen writes is a number to the validator

Electing a model setting that pins a timeout — the 600 s Studio prefills for DeepSeek, Kimi, Z.AI and MiniMax — made the settings screen impossible to save: the validator reported « 'Llm:TimeoutSeconds' must be a number » and refused every save, the novice's automatic one included, until Studio read the file again. orkeon-studio-config refused at every save any file holding an integer — a token budget, a timeout, a rate limit, the shipped sample's among them. The file was right (600); the settings document was not: a node a screen writes holds the CLR value it was given, which System.Text.Json converts to no other type, so the document's number reader found no double in the int an election had just written (STUDIO-53).

  • A number reads as its JSON text, whatever created its node — as the file will, once read again. AppSettingsDocument.GetDouble reads any JSON number, the integers the screens write included (Llm:MaxTokens and TimeoutSeconds, the RateLimiting fields, LlmLogging:MaxBodyLengthChars, Orkeon:Rag:Corrective:MaxIterations); GetInt32 reads one whose text is an integer within int — a double 600 included, never 0.5, 600.0 or a value beyond int, which the configuration binder refuses for an integer too. A number written as a string still reads, as the binder reads it. What the screens write and what the validator checks are unchanged.
  • NaN and the infinities read as no number, where their text — JSON has none — would have thrown: a document holding one cannot be written, and the validator refuses it by the field's name.
  • ui-preferences.json follows the same rule: Settings › Studio's minutes and days, written as integers, read back as « not set » from the document that had just written them. Studio reads the file again before each use, so nothing showed.

Fixed — a temperature or a top_p a crew declares reaches the model whatever its value, one nothing sets is not sent, and what a dialect cannot send is said [breaking]

The engine took a temperature of 0.7 and a top_p of 1.0 for "not set" (GAP-36, decisions 1 and 8). An agent writing temperature: 0.7 on a profile configured at 0.2 ran at 0.2, in YAML, .ork.ts and C# alike; a top_p: 1.0 never left; and a host that set no temperature sent 0.7 on every call — a value the default models of OpenAI (gpt-5.6-sol) and Anthropic (claude-sonnet-5) refuse, which orkeon init --provider openai and Studio's OpenAI and Anthropic cards choose without writing a temperature.

  • What nothing sets is not sent. LlmConfig.Temperature and LlmConfig.TopP are double?: null when nothing sets them — not the call, not the agent, not the task, not the profile —, and then no payload carries them: the model applies its own default (often 1; the Modelfile's on Ollama). No producer writes the engine's 0.7 and 1.0 any more — the YAML loader, LlmSettings (an Llm section or a profile without Temperature), LlmConfig.OnProfile() and Create, CreateValidated (double? temperature = null, double? topP = null, ranges checked when set) —, and every payload writer omits what is unset: the OpenAI dialect's two builders, Anthropic, Ollama's three, Azure's stream. Mistral still writes top_p: 1 when nothing sets one (AlwaysEmitTopP, measured); Kimi re-sends its mandated temperature only for a value that was set and refused. The runners' startup line says temperature=(not set: the model's own).
  • What is set is sent, whatever its value. The composer forwards an agent's temperature and top_p when they are set — it compared them with 0.7 and 1.0 —, and a call's configuration that sets neither runs on its provider's (LlmConfig.InheritFrom), like its output cap and its timeout. The penalties keep no unset value: 0, every vendor's default.
  • The export writes what is set. YamlCrewExporter writes an agent's temperature at 0.7 like any other, its topP, thinking, responseFormat and responseSchema, cache and profile, and a task's llmOverride — what the loader reads back.
  • What a dialect cannot send is said (decision 8). Ollama writes top_p, seed and stop in its options — it dropped a top_p a YAML crew declared —, through OllamaRequestOptions.Builder, whose AddTemperature, AddTopP and AddSeed take nullable values, with AddStop. A frequency_penalty or a presence_penalty, on every dialect, and a seed, everywhere but Ollama, is answered with the structured warning (event 110) naming it — they were dropped in silence. The penalties, the seed and the stop sequences of an agent's LlmConfig reach the call (the tool-free retry keeps them, and the agent's model, which it lost); both MEAI adapters carry the stop sequences, and an IChatClient wrapped as a provider no longer receives a temperature, a top_p or a zero penalty nobody set. The Microsoft Agent Framework bridge announces a temperature or a top_p whatever its value.
  • LlmParameters, which nothing used and whose 0.7 and 1.0 contradicted the rule, is deleted, with LlmDefaults.DefaultTemperature; LlmDto.Temperature is nullable. Studio's hint under the temperature field says what an empty one now means, in the five languages.

Documented in LLM providers, the provider comparison, Configuration and the YAML schema.

Breaking: a host or a crew that sets no temperature runs on the model's default (often 1) instead of 0.7, and one that sets no top_p sends none; LlmConfig.Temperature and TopP are double?; LlmConfig.CreateValidated takes double? temperature = null and double? topP = null; LlmParameters and LlmDefaults.DefaultTemperature are removed; LlmDto.Temperature is double?; OllamaRequestOptions.Builder.AddTemperature, AddTopP and AddSeed take nullable values.

Migration: write Llm:Temperature: 0.7 — and Temperature in each Llm:Profiles:<name> — to keep the former sampling; read LlmConfig.Temperature and TopP as nullable; build an LlmConfig where an LlmParameters was built.

Fixed — a scheduled team runs as Studio launches it: on its model setting, with its folders

A team Studio scheduled (STUDIO-27) is run by the operating system through its run.cmd or run.sh, and forge promote writes those launchers with the folders inside the team and nothing else. A team adopted on « Z.AI », with a folder of the user's bound in Studio, ran fine from Studio and, scheduled, on the default profile without that folder — and Studio never saw it: a run the system starts is in no history. orkeon run had no option naming a profile (STUDIO-50).

  • orkeon run --llm-profile <id> elects one of the host's profiles — Llm:Profiles:<id>, which Studio writes for each model setting (STUDIO-48) — as the run's default: the Llm section becomes that profile, whole, for the run. Every field it pins is taken, one it leaves unset stays unset, and its key is its own (ApiKey, or the variable its ApiKeyEnvVar names), never the default's. Every call that names no profile of its own runs on it — agents, tasks, the hierarchical manager, the planner, the RAG without Orkeon:Rag:LlmProfile, a script's llm.default_ —, the endpoint probe before a kickoff and the startup line included (LLM profile <id> elected as the run's default (--llm-profile), its key's source told by the profile's own path). The profiles stay offered by name, default elects nothing, and the id is matched without regard to case. An id the settings and the ORKEON_ environment do not define is refused in one line with exit 1 before any host, listing the ones they do — as a crew naming an unknown profile fails its load — on the YAML and crew-directory paths, a declarative or procedural .ork.ts, --validate and --list-tools (RunnerExecution.EnsureLlmProfileIsKnown); a host built without that guard refuses it too (RunnerHost.Build(…, llmProfile)). The name is RunOptionNames.LlmProfile (Orkeon.Constants.Cli), which the runners declare and Studio writes.
  • Studio writes a team's launchers again from its companion file (TeamLaunchers): the team's setting as --llm-profile — its host profile; a team on no setting, on one renamed or removed since, or on one offered to no crew runs on the default, as Studio launches it —, its folders as a Studio launch passes them — a settings declaration by --mount-id, the team's own folders by --mount anchored to the launcher's folder —, the settings file the settings screen writes as --settings, the brief's sample inputs and the engine's header (forge rename reads it). At adoption, at each save of « Change the folders », and when a setting a team names is created, renamed, removed or offered to crews no more. Never a key. An edit made by hand in a launcher is written over at the next of those changes, and its second line says so. The launcher names are ConventionalNames.WindowsTeamLauncher and PosixTeamLauncher (Orkeon.Constants.FileSystem), shared by both writers.
  • Installed schedules keep working. The registration the operating system holds runs the launcher by its path and passes it nothing (the task's Command, the unit's ExecStart, the cron line): a launcher written again is what the next scheduled run executes, and nothing is reinstalled. A team adopted before this version keeps the launchers the engine wrote until one of those changes, or its next re-adoption. The scheduled run reads the settings file as saved: save the settings screen after creating a setting a team runs on.

Fixed — hosts: a stopping orkeon-host starts no run, a refused setting is one line and an exit code everywhere, sendSubscribe streams a run's progress, and stdout carries the protocol alone [breaking]

orkeon-host and orkeon went wrong at three moments their user does not choose (GAP-35): while the host stops, when it refuses a setting at start, and when a program reads their output.

  • A stopping host starts nothing. The drain admitted what arrived during its grace period: a chat message or an A2A task loaded a crew and called the model, the drain waited for it, then stopped it — "The run was stopped." about work that should never have begun, and a stop that lasted the whole grace. CrewHostService now closes admission first: from then on a run asked for is refused with "The host is stopping: this run was not started. Send it again once the host is back." — the chat answers it with no acknowledgement and no Stop button, an A2A peer reads it as Failed. The runs admitted before keep their grace, /status and /stop still answer, and the channel and the A2A server still stop after the drain.
  • A refused setting is one line and an exit code. RunnerHost.Build raises one type, RunnerSettingsException (Orkeon.Hosting, an InvalidOperationException), for every setting it refuses: a retired key, an invalid Llm:Profiles, an unknown Orkeon:Rag:LlmProfile, MCP:EnableServer, mounts it cannot honour, a value the configuration binder cannot convert (the MCP:Servers entries are now bound at build too), a settings file it cannot read — named, with the line and the position —, and a RaggableTree:Embedding:BaseUrl or Telemetry:OtlpEndpoint that is no http(s) address, refused by its key instead of a bare UriFormatException. A host already built is disposed first. orkeon run — YAML, crew directory, declarative .ork.ts —, --validate, --list-tools and orkeon mcp serve answer it with ERROR: <reason> as the last stderr line and exit 1 (an --events jsonl run closes its stream on run.finished, exit code 1); a procedural .ork.ts with orkeon run: <reason> and orkeon forge with orkeon forge: <reason>, exit 1 both — they were exit 2. Most of these ended on an unhandled exception, a stack and a core dump (exit 134). ORKEON_DEBUG=1 prints the exception before the line.
  • orkeon-host refuses before it starts. Its whole pre-start sequence runs under the exit-78 barrier: the configuration it boots from, its sections — Orkeon:Host with its A2A, Orkeon:Host:Discord, and the A2A section —, now read once, at start (a RunTimeout or a Discord:ProgressInterval of "abc" refuses the start by its key; bound lazily, they crashed it once it built its services), and the runner host. A refusal is one line on stderr and in the Windows event log, and systemd does not restart on it.
  • A2A under the Windows service. HTTP.sys lets NT SERVICE\Orkeon listen only on a URL reserved for it, and its refusal crashed the service, restarted twice in silence. It is now a refused configuration — exit 78 — that names the prefix and, for an access denied, the command to run once as an administrator (netsh http add urlacl url=<prefix> user="<account>"). install-service.ps1 -A2AUrlPrefix <prefix> makes that reservation when it registers the service, records it under the service key, and -Uninstall removes it; the service MSI reserves nothing — it installs before any configuration — and its closing screen gives the step.
  • sendSubscribe streams a run's progress. A peer following a task read Working, then nothing until the final state, while a chat thread watching the same run read a line per finished task. IA2ATaskRouter.RouteTaskAsync takes an IProgress<string>: the server passes one for sendSubscribe only, and each line becomes a Working update carrying it in A2ATaskUpdate.Message (message, omitted when null; partialOutput stays the output). One writer drains one queue, so no line follows the final state. orkeon-host reports the lines a thread reads; the agent router reports none.
  • Stdout carries the protocol alone. Telemetry:ExportToConsole attached OpenTelemetry's console exporter, which writes on stdout — into --events jsonl, the --list-tools manifest, orkeon mcp serve, orkeon forge --events jsonl and orkeon email accounts --json. It is removed, with Telemetry:PrometheusEndpoint, which nothing read, and the OpenTelemetry.Exporter.Console package; a section that still writes either key, whatever its value, is refused, naming the OTLP collector that replaces it.
  • orkeon mcp serve never starts under itself. Settings declaring orkeon mcp serve under their own MCP:Servers made each server start another before answering, until the first gave up after 30 s. A serve now sets ORKEON_MCP_SERVE in its environment before it connects its servers, and one that finds it set refuses to start: exit 1, one line. The stderr of a stdio MCP server is read as it is written — to the log at Debug, under the server's id — so a talkative server no longer blocks, and the last line of a server that stops is joined to the connection error, with its exit code.
  • docs/tools/inventory.md said the rag_* tools were neither registered nor attachable for a YAML crew: every runner host and the REPL register them, and an agent that lists one receives it.

Documented in Service host, A2A conformance, CLI, MCP integration, Hosting, Configuration, Opt-in subsystems and Tool inventory; the service-host example follows a task with sendSubscribe.

Breaking: IA2ATaskRouter.RouteTaskAsync takes an IProgress<string>? progress before its token, with no overload left; RunnerHost.Build raises RunnerSettingsException — still an InvalidOperationException — for a refused setting, and now for an unreadable settings file and an address that is none; TelemetryOptions loses ExportToConsole and PrometheusEndpoint, and both keys are refused; Orkeon.Infrastructure and the Orkeon package no longer depend on OpenTelemetry.Exporter.Console; a procedural .ork.ts and orkeon forge exit 1, no longer 2, on a refused setting; orkeon mcp serve refuses to start under another one; the configuration constructor of StdioMcpTransport takes an optional serverId.

Migration: a router of your own takes the progress parameter and reports its steps to it, or ignores it; a caller passes progress: null before its token. Remove Telemetry:ExportToConsole and Telemetry:PrometheusEndpoint from the settings and point Telemetry:OtlpEndpoint (or OTEL_EXPORTER_OTLP_ENDPOINT) at a collector; a C# host that wants the console exporter references OpenTelemetry.Exporter.Console itself and adds it to its own AddOpenTelemetry(). A script that read exit 2 as a refused setting reads 1. Under the Windows service with A2A, register with -A2AUrlPrefix, or run the netsh http add urlacl the refusal names. Remove an orkeon mcp serve entry from the MCP:Servers of the settings that same serve reads.

Removed — public surfaces nothing called: a tool adapter that skipped the guard, per-crew Guardian policies, the request DTOs and per-agent planning; a crew's request rate is exported under its own key [breaking]

Public types and members that no shipped code called — several of them wrong — are deleted rather than kept (GAP-26):

  • A tool adapter that skipped the guard. BaseToolToAIFunctionAdapter (Orkeon.Tools.Abstractions) turned an IBaseTool into an AIFunction that called the tool directly: past the Guardian, the truncation, the result sanitizer and the audit every tool call crosses since GAP-09. Nothing called it.
  • One Guardian policy per host. GuardianPolicyEngine.SetCrewPolicy and SetAgentPolicy had no caller, so the per-crew and per-agent policies were always empty. They are gone, and GetPolicy(crewId, agentId) is the Policy property: the host's Orkeon:Guardian:DefaultPolicy, as the documentation already said.
  • The request DTOs. No API receives them, and the CQRS commands carry their own records: CreateCrewRequest, UpdateCrewRequest, CrewAgentRequest, CrewTaskRequest and the settings records beside them (Orkeon.Application.Crew.DTOs.CrewSettingsDto, CrewRetryConfigDto, CrewMemoryConfigDto, CrewCallbackConfigDto), CreateAgentRequest, UpdateAgentRequest, AgentSettingsDto, AgentMemorySettingsDto, CreateTaskRequest, UpdateTaskRequest, TaskSettingsDto, TaskRetryConfigDto, LlmConfigDto; their mapping methods (CrewMapper.FromCreateRequest, CrewMapper.UpdateFromRequest — which ignored Process —, AgentMapper.CreateFromRequest, TaskMapper.CreateFromRequest); and the DTO enums ProcessType, CrewStatus, TaskStatus and TaskPriority (the read DTOs carry those as strings). One ProcessType remains: the value object.
  • Per-agent planning. IAgentExecutionService.PlanTaskExecutionAsync and IExecutionOrchestrator.PlanExecutionAsync (with TaskExecutionPlan and PlannedStep) asked a stub planner for the same fixed plan, and nothing asked them: the planner (IAgentPlanner, AgentPlannerService, TaskPlan, PlanStep, PlanFeedback, PlanValidationResult, and the Application PlanningContext, PlanningStep, PlanningResult) is gone, and so are the second ExecutionPlan (Orkeon.Domain.SharedKernel.ValueObjects, with ExecutionStep and ExecutionStrategy) and ExecutionPlanDto (TaskDto.ExecutionPlan, never filled). A crew's planning: true is the orchestrator's (GAP-31). ExecutionOrchestrator's constructors lose their planner parameter.
  • Other dead surfaces. OrkeonApplicationOptions.MaxShortTermMemoryItems, EnablePersistence, EnableRAG, MemoryDatabasePath and DefaultMemoryProvider (copied, never read — the REPL's appsettings.json loses its Orkeon:DefaultMemoryProvider key); ShortTermMemory, LongTermMemory, EntityMemory and ContextualMemory (Orkeon.Infrastructure.Memory: the memory service has its own); StateTransitionManager, which described crew transitions the aggregate does not follow; Orkeon.Application.Validation.CrewValidator (a crew is validated at load by CrewDefinitionValidator); CrewConfigurationMapper.ToDomainCrew, which re-created the agents under new ids and never set the manager (the loaders build crews through CrewFactory); Agent.Restore and AgentSnapshot, which lost the agent's LlmConfig; Agent.ValidateForExecution ("Agent has no tools assigned" — an agent without tools is valid) with ExecutionValidationResult, IExecutionOrchestrator.ValidateExecutionAsync and IAgentExecutionService.CanExecuteTaskAsync; IExecutionOrchestrator.MapExecutionContext with SimpleTaskExecutionContext and AgentMemory; ExecutionStatus.Cancelled (no run reached it: a cancelled run ends Failed, GAP-32; the other values keep their numbers); ExecutionConfig.EnableAsyncExecution; and the constants and ids only these used (MemoryDefaults.DefaultMaxShortTermItems, PathDefaults.DefaultMemoryDatabasePath, PlanningDefaults of Orkeon.Application.Constants.Execution, three StatusDefaults plan statuses, MemoryId, TaskPlanId, PlanStepId).
  • A crew's request rate is exported under its own key. CrewConfigurationMapper.ToConfiguration wrote Crew.MaxRpm into ExecutionConfig.MaxConcurrentTasks, a task concurrency nothing reads (and ToDomainCrew read it back as the request rate). The export writes ExecutionConfig.MaxRPM, and MaxConcurrentTasks is removed: no mode bounds how many tasks run at once.

Documented in Default behaviors, Bootstrap, State machine and Limits.

Breaking: every type and member listed above is removed; GuardianPolicyEngine.GetPolicy(crewId, agentId) is the Policy property; ExecutionOrchestrator's constructors no longer take a planner; ExecutionConfig.Create no longer takes maxConcurrentTasks or enableAsyncExecution; IAgentExecutionService keeps its two ExecuteTaskAsync overloads and IExecutionOrchestrator its ExecuteTaskCoreAsync alone.

Migration: run a tool through IToolInvocationPipeline.InvokeAsync (registered by AddOrkeonApplication()), never tool.CallAsync behind an AIFunction; read the Guardian policy from GuardianPolicyEngine.Policy and set it per host (Orkeon:Guardian:DefaultPolicy); build crews from YAML or .ork.ts through the loaders, or in C# with CrewBuilder/AgentBuilder/CrewTaskBuilder, instead of the request DTOs and ToDomainCrew; drop the planner argument of new ExecutionOrchestrator(…) and any IAgentPlanner registration; read a crew's exported request rate from ExecutionConfig.MaxRPM.

Added — orkeon-host exposes its crews to other agents over A2A: one skill per crew, and a task is a run of that crew [breaking]

An A2A peer could not reach a crew orkeon-host hosts: no shipped binary called AddOrkeonA2A, and a C# host that did served a router running agents found by id in a directory the daemon never fills — it loads a fresh crew for every message — so its card had no skill (GAP-23).

  • One skill per exposed crew. Orkeon:Host:A2A — Enabled (off by default), Host (http://localhost), Port (5002) and Crews, the crews other agents may run (none by default: exposing is a choice per crew, like a chat route) — turns the A2A server on. The card lists one skill per exposed crew — its id and name the crew's Name, its description the crew's new Description key —, built from the configuration without loading a crew; a crew left out is absent from it.
  • A task is a run of the crew, exactly what a chat message is: POST /a2a/tasks/send (or sendSubscribe) on a published id — compared exactly — runs that crew through CrewRunner on the task's input, its metadata as the run's variables: under the crew's mounts, inside its MaxConcurrentRuns — chat conversations and A2A tasks counted together, a task over the bound answering Failed, never queued —, under RunTimeout, logged with its origin a2a:<task id>. Completed carries the crew's answer; a failed run answers Failed with the sentence a chat thread gets (the run id; the detail stays in the host log); DELETE /a2a/tasks/{id} stops the run (Cancelled); a skill id the card does not publish answers Failed, naming the published ones.
  • Refused at start (exit 78): an enabled section that exposes no crew, or a crew Orkeon:Host:Crews does not declare; a malformed Host or Port; a listener beyond the loopback while A2A:Security declares neither an authentication scheme nor mutual TLS; and the C# hosts' A2A:EnableServer, A2A:Host and A2A:Port, which the daemon does not read. A server refusing its A2A:Security (a scheme without its validator) is a refused configuration too, not a crash to restart on. The rest of the A2A section — the card's identity, A2A:Security and its bearer validators — applies as written. The server starts after the MCP servers are connected and before the chat channel, so it stops after the drain: a run in flight still answers the peer that asked.
  • The card publishes what the router answers. IA2ATaskRouter gains GetSkillsAsync, and A2AServer builds the card from it rather than from the agent directory: a host that routes differently — the daemon routes crews — publishes exactly the ids its router compares. A2ATaskRouter lists one skill per available agent, as the card did. AddOrkeonA2A registers its agent router — and the process-wide agent directory that router reads — only when no router is registered yet: a host with its own router keeps its own per-scope IAgentRepository (the daemon's runs would otherwise have shared their agents with each other, one entry per run, forever). A wildcard listener (http://+) no longer makes the card endpoint throw: the card advertises the address the peer reached it at.

Documented in Service host, A2A conformance, Configuration, Opt-in subsystems and Limitations; the service-host example exposes its crew on the loopback.

Breaking: IA2ATaskRouter declares GetSkillsAsync; the two A2AServer constructors no longer take an IServiceScopeFactory; after a router of the host's, AddOrkeonA2A no longer registers the agent directory (IAgentRegistrationStore) nor swaps the host's IAgentRepository for SharedStoreAgentRepository; orkeon-host refuses A2A:EnableServer, A2A:Host and A2A:Port, which it ignored.

Migration: implement GetSkillsAsync on a router of your own — the skills its RouteTaskAsync answers, keyed by the id it compares; drop the scope factory from new A2AServer(...); a host router that reads the agents other scopes register adds IAgentRegistrationStore and SharedStoreAgentRepository itself; in orkeon-host's settings, write the listener under Orkeon:Host:A2A.

Added — orkeon mcp serve serves the host's tools to an MCP client, each call through the guard, and MCP:EnableServer is refused [breaking]

Orkeon's MCP server was reachable from C# alone (GAP-24): MCP:EnableServer registered McpServer, no binary ever resolved it, and a user who wrote the key got nothing; and a server a C# host did start called each tool itself, past the guard every agent turn crosses.

  • A verb serves. orkeon mcp serve [--settings <file>] [--tools a,b,…] serves over stdio, the transport by which MCP clients — Claude Desktop, editors — launch a local server: one JSON-RPC message per line in on stdin, the answers out on stdout, until the client closes stdin. It builds the host orkeon run --list-tools reports — the settings resolved from the current directory, their mounts, the built-in tools, the MCP servers they declare, connected first — and serves its registry, every tool but human_input, which answers for the operator of a run (an MCP client has a human of its own). --tools serves the named tools only, and a name the host does not have refuses the start. Stdout carries the protocol and nothing else: logs, warnings, --help and usage errors go to stderr. --list-tools and the verb build their host with one method, which answers a setting the host refuses, or a settings mount whose folder does not exist, with one ERROR: line and exit 1 — --list-tools ended there on an unhandled exception and a core dump.
  • Each call is guarded. McpServer takes the IToolInvocationPipeline and calls every tool through it, under the caller mcp: the guardian's tool phase, the call, the one truncation rule, the result sanitizer and a ToolExecution audit event. The client reads what a crew agent's model reads: a blocked call answers isError: true with Error: Blocked by Guardian (ToolExecution): … and never reaches the tool, a result arrives truncated and tagged as data, a failure reads Error: …. RunStdioAsync no longer disposes the process's console streams when the client leaves.
  • The verb is the switch. MCP:EnableServer and McpOptions.EnableServer are removed: AddOrkeonMcp registers the client only, and AddOrkeonMcpServer(configuration) registers the server, its McpServerOptions bound from MCP:Server (Name, Version). A section that still carries the key, true or false, is refused at startup — by both extensions and by every runner built on RunnerHost, servers declared or not — with a message naming orkeon mcp serve.

Documented in MCP integration — which no longer says that a crew agent cannot use an MCP tool —, CLI, Configuration, Security, Hosting, Experimental APIs and Limitations.

Breaking: a settings file or configuration that carries MCP:EnableServer no longer starts; McpOptions.EnableServer is removed; AddOrkeonMcp no longer registers McpServer; both McpServer constructors take an IToolInvocationPipeline after the registry; a failed tools/call reads Error: <reason>.

Migration: remove MCP:EnableServer from the settings and serve the tools with orkeon mcp serve; in a C# host, call AddOrkeonMcpServer(configuration) next to AddOrkeonInfrastructure() and AddOrkeonApplication(), then resolve McpServer and run RunStdioAsync(); a McpServer built by hand takes the container's IToolInvocationPipeline, or ToolInvocationPipeline.Unguarded for the bare call and truncation.

Fixed — an agent backed by a Microsoft Agent Framework agent answers through it, counted once, and is refused the Orkeon tools it could never call [breaking]

WithAgentFrameworkAgent(agent) set a field nothing read (GAP-34):

  • The MAF agent answers. AgentBuilder.WithLlm — which WithAgentFrameworkAgent calls — set Agent.FunctionCallingLlm, and no runtime path read it: the agent's tasks ran on the host's default model, or its profile, with its Orkeon tools, and the MAF agent heard nothing, although ADR-010, the README and the reference promised that every prompt of the agent is a run of the MAF agent. The field is Agent.Llm (AgentCreateOptions.Llm, AgentSnapshot.Llm, the llm parameter of Agent.Create) — the provider the agent's turns run on, CrewAI's llm given as an object — and the run honours it: the orchestrator builds a client over it once per provider instance (ILlmProfileRegistry.ForProvider, named provider:<name>), metered as the agent's work, and runs on it the agent's turns, their correction round and its ballot. The order is GAP-17's, the provider in the agent's place: the profile a task's llm_override names (default included), else the agent's own provider, else its profile, else the default. An orchestrator built by hand, without the host's profile registry, fails such a task naming the agent. A hierarchical manager agent carrying its own provider assigns and reviews on it (ManagerLlmResolver, after Crew.ManagerLlm; provider:<name> in the run's log and the export).
  • Its own provider or a host profile, not both. Agent.Create and AgentBuilder.Build() refuse an own provider with an LlmConfig that names a profile, naming both.
  • No Orkeon tool on an agent that runs its own. A MAF agent calls the tools it carries: Orkeon's were listed in its prompt, and a [TOOL_CALL] it wrote would have become its answer. LlmProviderCapabilities.RunsOwnTools, declared by AIAgentLlmProvider and relayed by the meter, makes Agent.Create, AgentBuilder.Build(), AddTool and UpdateConfiguration(allowDelegation: true) refuse tools and delegation on such an agent; a task that falls on such a provider — the agent's own, a profile's (AddOrkeonLlmProfile) or the host's default — with tools to hold (its tools:, human_input, the delegation tools of an agent that allows delegation — a YAML agent does unless it writes allowDelegation: false) fails before any call. The message names the tools and the two remedies: the tool on the MAF agent itself, or the MAF agent as a tool of an Orkeon agent (WithAgentFrameworkTool) — and, for the delegation tools, delegation switched off.
  • One MAF session, each message once, one call at a time. The agent loop sends the whole conversation every turn, and the MAF session already held it: a resumed turn showed the model the conversation twice, and two tasks of the same agent wrote to the session at once. AIAgentLlmProvider now sends a call that extends the conversation the session holds only what is new, any other call — a new task, the session keeping the previous one — whole, and one call at a time: the tasks of one MAF agent run one after another, even in a parallel wave.
  • Counted once. A provider answering through another metered provider — a MAF agent built over Orkeon's own model, as the example builds its reviewer — would have been counted twice. MeteredLlmProvider counts a call once, by the meter nearest the model: an outer call during which an inner meter counted reports nothing, so the event names the real provider and model; a MAF agent on a client Orkeon does not meter is counted under agent-framework:<name>. The metering guard declares LlmProfileRegistry an entrance of the metered path, and the bridge's exemption says where it is metered.
  • What the bridge does not send, it says. Each option a call's LlmConfig declares (model, temperature, max tokens, response format, thinking…) is a structured warning of AIAgentLlmProvider — event 110, the HTTP providers' wording —, once per crew run and option, through the logger WithAgentFrameworkAgent(agent, logger) takes, else the logger factory the MAF agent exposes.
  • examples/interop/agent-framework/ has a third section: the MAF reviewer answering for an Orkeon auditor, metered once under the configured model.

Streaming is unchanged: a streamed turn receives the MAF answer as one fragment.

Documented in Microsoft Agent Framework interop, ADR-010 (amendment of 2026-10-03), Configuration, Process types and YAML and builders.

Breaking: Agent.FunctionCallingLlm, AgentCreateOptions.FunctionCallingLlm and AgentSnapshot.FunctionCallingLlm are renamed Llm, and the functionCallingLlm parameter of Agent.Create is llm; ILlmProfileRegistry gains ForProvider; AIAgentLlmProvider and WithAgentFrameworkAgent take an optional logger; an agent with its own provider and a host profile, and an agent whose own provider runs its own tools with tools or delegation, no longer build; a task holding tools fails on a provider that runs its own.

Migration: rename FunctionCallingLlm to Llm; an ILlmProfileRegistry of your own implements ForProvider (build and meter the provider's client once per instance, as LlmProfileRegistry does); keep the agent's provider or its profile, not both; give a MAF agent's tool to the MAF agent itself, or hand the MAF agent to an Orkeon agent as a tool (WithAgentFrameworkTool).

Fixed — outside Studio, a run finds the key of its setting: the settings file names the variable, never the key [breaking]

Studio remembered a setting's key under the provider's variable (ZAI_API_KEY, DEEPSEEK_API_KEY), in the user scope (STUDIO-44), and the runtime never read those names: it read Llm:ApiKey — ORKEON_Llm__ApiKey — and, for a profile, ORKEON_Llm__Profiles__<id>__ApiKey, which only a Studio launch set. A terminal orkeon run, an orkeon-host started by the user, orkeon-repl and above all a team Studio scheduled (STUDIO-27) ran without a key: every call answered "API key is required", and the run exited 2 (STUDIO-49).

  • The file names the variable. Every section of the Llm shape — Llm and each Llm:Profiles:<id> — gains ApiKeyEnvVar: the name of the environment variable that holds its key, never the key. LlmSettings reads it when the configuration resolves no ApiKey (the file's, ORKEON_Llm__ApiKey, ORKEON_Llm__Profiles__<id>__ApiKey, a Studio launch's — they still win, so no existing installation changes): in the process environment, then, on Windows, in the user scope where Studio remembers keys — read, never copied into the process, so what a run starts inherits no key it did not have; a user scope that cannot be read counts as an absent variable. A reference that cannot be a variable's name (an =, a space, a line break) refuses the host start, naming its path and never its value. ConfigurationKeys.LlmApiKeyEnvVar (Orkeon.Constants.Configuration, ADR-009) spells it for the runtime, doctor, init and Studio.
  • Where each key came from, never the key. The runner host's LLM resolved: line ends with apiKey=<source> — from configuration (Llm:ApiKey), from the variable named by Llm:ApiKeyEnvVar (process environment) or (user environment), none —, one LLM profile <id>: apiKey=… line follows per profile, and a reference to a variable set nowhere is warned about once per host build, by its configuration path, on the logger and on stderr (OperatorMessages.LlmApiKeyReferenceUnresolved). No message repeats the value of ApiKeyEnvVar: it may be a key pasted in the wrong field. LlmSettings.DescribeApiKey and LlmSettings.UnresolvedApiKeyReferences are the public surface.
  • Blank reads as absent. A value left blank in a section of the Llm shape — Thinking:Effort included — reads as absent, and a section whose every value is blank configures no default: the echo provider, with the WIN-01 warning.
  • Studio writes the reference, and the default whole. Each Llm:Profiles:<id> entry Studio owns names the setting's variable (none for a setting without a key). The election writes the elected setting into Llm whole — BaseUrl, Model, ApiKeyEnvVar, Temperature, TimeoutSeconds, MaxTokens, Thinking, a field it leaves unset removing its key — where it wrote the model and the endpoint alone: a team scheduled on DeepSeek ran on the engine's 30 s, not on the 600 s Studio pre-fills. ApiKey, MaxRetries, Grammar, AvailableModels and Profiles stay. A team launched on another setting than the default lays every modeled ORKEON_Llm__* field over its child, its value or blank, ORKEON_Llm__ApiKeyEnvVar included: a team on Z.AI whose key is not remembered fails without a key instead of sending the default's DeepSeek key to Z.AI. The editor's expert line names the setting's own variable (ModelProfile.HostKeyVariable is gone).
  • « Other OpenAI-compatible » gets a variable of its own. A setting created from that card keeps its key in ORKEON_CUSTOM_LLM_API_KEY (LlmPresets.CustomApiKeyEnv). It used ORKEON_Llm__ApiKey, the runtime's own key of the default, which — remembered in the user scope — became the default key of every run of the user and went to another vendor's address. A setting created before keeps its variable, and its card says, in expert mode, what that variable is and how to take it back; nothing migrates on its own.
  • orkeon init and orkeon-studio-config write it too. orkeon init --api-key-env <name> writes Llm:ApiKeyEnvVar: <name> — nothing for ORKEON_Llm__ApiKey, which the runtime reads natively — where it printed that the name was "only used by the probes". The TUI's presets write it, a preset without a key removes it, its LLM form edits it, and its read-only list of profiles shows each one's variable (key: ZAI_API_KEY).
  • The REPL reads what the runners read. orkeon-repl composed the default .NET host alone: neither ORKEON_Llm__ApiKey — it read Llm__ApiKey — nor the global file orkeon init writes reached it. It now reads the --settings files — else the global file, which a named file replaces as for orkeon run —, then the ORKEON_ variables, prefix removed, before the command line, and logs once where each key comes from, with the runner's warning. Orkeon.ConsoleApp now references Orkeon.Hosting for that path (RunnerSettings.GetGlobalSettingsPath, code that stays with the runners rather than a copy): the orkeon-repl tool package carries four more assemblies — Orkeon.Hosting, Orkeon.Tools.EventHub, Orkeon.Constants.Cli and CommandLineParser (MIT), all of which the orkeon tool already ships.
  • orkeon doctor reads the key a run would. llm-config says where the default's key comes from, warns when its reference resolves nothing and fails when the section cannot be read; a new llm-profiles row covers the profiles, one llm-profile-key row warns per profile whose reference resolves nothing, and llm-reachability queries the catalogue with the resolved key.
  • The ten examples/appsettings/*.local.json.example templates name their variable ("ApiKeyEnvVar": "DEEPSEEK_API_KEY") instead of carrying "ApiKey": "${DEEPSEEK_API_KEY}", which nothing ever expanded.

Documented in Configuration, API keys: the variable per provider, CLI, Orkeon Studio, The service host, Security and Limitations.

Breaking: an ApiKey written as a ${NAME} placeholder — the old templates' shape, which went out as the key and came back a 401 — refuses the start, naming the fix, and so does an ApiKeyEnvVar that cannot be a variable's name; a blank value in a section of the Llm shape reads as absent, and a section whose every value is blank configures no default; a Studio launch on another setting than the default blanks every default field its setting does not set; orkeon doctor reports ten checks, plus one row per unresolved profile reference; new « Other OpenAI-compatible » settings keep their key in ORKEON_CUSTOM_LLM_API_KEY.

Migration: replace "ApiKey": "${NAME}" with "ApiKeyEnvVar": "NAME". A file Studio wrote before heals at one gesture: edit then save a model setting — its entries, and the Llm section of the elected one, are written again with their references. A « Compatible OpenAI » setting that keeps ORKEON_Llm__ApiKey is created again from its card — its key then goes to ORKEON_CUSTOM_LLM_API_KEY — and ORKEON_Llm__ApiKey removed from the user environment. On Linux and macOS, a scheduled team reads the variable from ~/.config/environment.d/*.conf (the systemd user manager) or from a line at the top of the crontab — never from the shell profile.

Fixed — a crew's manager applies where its mode uses one and is refused elsewhere, the planner's provider is metered, and a reference that names nothing fails the load [breaking]

What a crew wrote about its manager, its planner and its tasks' references was read, then dropped without a word (GAP-33):

  • A manager where the mode uses one. A manager agent means something in two modes: Hierarchical — it assigns each task and reviews its output — and Consensual — it arbitrates the vote under the ManagerDecision fallback. On a sequential, parallel, graph or autonomous crew, managerAgent: (.manager(agent) in .ork.ts; .WithManager(agent), .WithManagerId(id) or .Hierarchical(agent) in C#) was kept, then ignored: the agent ran tasks like any other. In C#, .WithManagerLlm(provider) on a sequential, parallel, graph or consensual crew was never called. Both are refused now — by the YAML loader, the .ork.ts adapter, CrewDefinitionValidator, CrewBuilder.Build() and Crew.Create(CrewCreateOptions) — with a message that names the key and the mode and says what to do: remove the manager, or use hierarchical or consensual (an autonomous crew's manager is an LLM: the default profile, or WithManagerLlm in C#). Two predicates of the ProcessType value object carry the rule, AcceptsManagerAgent and AcceptsManagerLlm, and the domain keeps it: Crew.SetManagerAgent accepts a consensual crew (it refused every mode but Hierarchical); ChangeProcessType sets the agent passed in a mode with a manager agent, drops the crew's manager — still a member, hence a worker — when it turns to a mode without one, refuses an agent passed with such a mode, and refuses to turn a crew with a manager LLM to a mode that never calls it; Validate checks that a consensual crew's manager is a member, and a consensual crew whose manager leaves has no arbiter left. Examples 86 and 100 declared a manager their mode ignored: it is gone, and the agent keeps its tasks.
  • A manager or a task reference that names nothing fails the load. A managerAgent: that named no agent — a typo — was erased: a hierarchical crew was told it "requires a manager agent", a consensual crew lost its arbiter. A task's agent: or dependency that named nothing was erased the same way: the task ran on another agent, or without waiting for what it cited. Each fails the YAML load now, naming what was written and listing the crew's agents or tasks, every faulty reference at once. In .ork.ts, a task whose .agent(...) or .withContext(...) is not in the crew, and a .manager(...) another crew holds, fail the adaptation the same way. The forge checks its plan's manager — its key and the mode — and each task's agent and dependencies before it compiles (ForgeBlueprint.Validate): the loader's refusals come back to the assistant as repairable errors (blueprint_submit, the validate stage, an edited plan) instead of ending the session, and its manager field says "hierarchical or consensual".
  • A consensual manager says when it decides nothing. The manager of a consensual crew neither answers nor votes: it arbitrates only when the host's fallback is ManagerDecision, and the default is AcceptBestScore. Under any other fallback the run now warns at its start, naming the agent and the host's fallback, with the two remedies — Orkeon:Consensus:FallbackStrategy: ManagerDecision, or no managerAgent: so that the agent answers and votes. Example 17's README says when its moderator decides.
  • The planner's provider is metered. The provider C# gives the planner (CrewBuilder.WithPlanningLlm) was called as it was: its tokens reached neither cost.updated nor run.finished, although the documentation said "metered as operation: planning". SequentialCrewOrchestrator now meters it where the run resolves it, under the planning attribution — a provider already metered is read once per call —, through a new optional last constructor parameter, ILlmUsageSink? usageSink, which the container fills; the metering guard declares it the fourth entrance of the metered path. A planning provider without .Planning() was lost without a word: Crew.Create refuses it — from CrewBuilder.Build() and CrewCreateOptions alike —, and UpdateConfiguration(planning: false) refuses to switch off a crew that carries one.

Documented in Process types, Autonomous, YAML schema, YAML and builders, Scripting DSL, Configuration and Limitations.

Breaking: a manager agent on a sequential, parallel, graph or autonomous crew, a manager LLM on a sequential, parallel, graph or consensual crew, a managerAgent:, task agent: or dependency that names nothing, a .ork.ts task whose agent or context task is not in its crew, and WithPlanningLlm without Planning no longer load or build; Crew.SetManagerAgent, Crew.ChangeProcessType and Crew.UpdateConfiguration follow the same rules.

Migration: remove a manager the mode does not use — the agent keeps its tasks — or turn the crew hierarchical or consensual; fix the key a reference names — the message lists the crew's agents or tasks; add the agent or task a .ork.ts reference cites to the crew (withAgent, withTask); call .Planning() on a crew given WithPlanningLlm, or remove the provider.

Added — Studio's model settings are the host's LLM profiles: a crew names one with profile:

Since named profiles (GAP-17), a crew can write llm: { profile: claude } — provided the host's settings define Llm:Profiles:claude, which nothing in Studio wrote: a Studio user who created a « Claude » setting and named it in a crew saw the load fail, the error listing default alone (STUDIO-48).

  • Each setting is a host profile. Every model setting that names a provider is written into the settings file as Llm:Profiles:<id> — its id the name through the teams' folder-name rule (« Claude » → claude, « Z.AI » → z-ai), its fields (BaseUrl, Model, Temperature, TimeoutSeconds, MaxTokens, Thinking), never its key — and the entry follows the setting through an edit, a rename (the keys Studio does not model travel with it) and a deletion. The card and the editor show what a crew writes (profile: claude); the editor refuses default, a name another setting already answers to and one an entry written by hand holds, warns that a renamed setting's old name stops loading, and names, in expert mode, the variable a terminal run reads the key from. A setting without a model, or whose name keeps no ASCII letter or digit, is offered to no crew.
  • Keys through the environment. Every launch from Studio — a run, a trial, the creation assistant — carries every setting as ORKEON_Llm__Profiles__<id>__*, the key resolved through the key store (STUDIO-44), so it never depends on the file having been saved; orkeon run in a terminal reads the same file and needs only ORKEON_Llm__Profiles__<id>__ApiKey.
  • Entries written by hand stay as written. An entry of Llm:Profiles no setting owns is listed read-only under the settings, never rewritten nor removed. Choosing « no model » for the default — in Studio or in orkeon-studio-config — removed the whole Llm section, profiles included; it now clears the default provider and keeps them, and a section holding profiles alone raises the WIN-01 warning, as the runtime reads it.
  • The RAG's profile on the same screen. An expert card of the AI-model tab chooses Orkeon:Rag:LlmProfile (GAP-19) among the profiles; it follows its setting through a rename and falls back to the default when the setting is deleted. The validation warns about a RAG profile the file does not define (STUDIO-RAG-LLM-PROFILE), in the five languages.
  • orkeon-studio-config shows Llm:Profiles and the RAG's profile, read-only.
  • Orkeon.Constants.Llm gains LlmProfileNames.Default (ADR-009): the reserved name the runtime refuses for a profile, which Studio refuses too; LlmProfiles.Default reads it.

Documented in Configuration, Orkeon Studio and YAML and builders.

Fixed — a crew's manager runs on the LLM the crew gives it, the RAG subsystem on the profile the host names, a .ork.ts task changes profile, and an address is no glob [breaking]

Since named profiles, each agent ran on its own; the rest did not follow (GAP-19):

  • The manager runs on the LLM the crew gives it. A hierarchical crew whose managerAgent carried llm: { profile: claude } had its tasks assigned and reviewed on the host's default profile: the manager agent's llm: block was read, set on the agent and ignored. In C#, CrewBuilder.WithManagerLlm(provider) was validated — it spares a crew its manager agent — then never read; worse, Crew.AddAgent made the first agent of such a crew its manager, taking it out of the workers. The manager now runs, resolved once per run by ManagerLlmResolver, on Crew.ManagerLlm when C# set one (CrewAI's manager_llm, metered like a provider the host registers), else on its manager agent's llm: block — profile and model, a model left unset being the profile's own —, else on the default profile, and the run logs which (provider:<name>, profile:<name>). A crew given a manager LLM needs no manager agent: every agent works, and Crew.Validate, StartExecution and ChangeProcessType accept it. An autonomous crew hands its tasks out on Crew.ManagerLlm too. The export's ExecutorSettings["ManagerLlm"] names that LLM (it carried a CLR type name), the unused ExecutionConfig.ManagerLlm string is gone, and a YAML or .ork.ts hierarchical crew without managerAgent fails its load naming the key — it was announced to "use the first agent as manager", then refused by the builder, asking for a manager LLM a configuration cannot carry.
  • The RAG subsystem runs on Orkeon:Rag:LlmProfile. Grounded generation, the query transformers (multi-query, rag-fusion, hyde), the listwise reranker, the corrective graph's evaluator and groundedness checker, the llm classifier and the evaluation judge all took the container's chat client — the default profile. They now call the host profile Orkeon:Rag:LlmProfile names (RagOptions.LlmProfile; unset, the default), resolved at the first RAG call that needs a model. A name the host does not offer — orkeon-host's Orkeon:Host:LlmProfiles allow-list included — refuses the start of the runner hosts and the REPL, listing the known ones (RagLlm.EnsureProfileIsKnown); orkeon rag eval --offline ignores the key, its stub answering in place of every model.
  • A .ork.ts task changes profile like a YAML task. taskBuilder().withProfile(name) sets the task's llm_override profile (alongside withResponseFormat when both are given); a name the host does not offer fails the load, listing the known ones. task.d.ts declares it.
  • An address is not a glob. SourceGlobExpander took the ? of a query string, or a *, in an http(s):// source for a wildcard: rag_ingest and rag.ingest walked the virtual file system for it and failed ("No mount for virtual path '/https:/…'"), and orkeon rag ingest --source turned it into /workspace/https://…. An absolute http(s) address now reaches the web loader as written, on every surface — the crew rag: block included, which shares the rule (SourceGlobExpander.IsWebAddress).

The planner and the Guardian stay on the default profile: they are host services, not crew roles (CrewBuilder.WithPlanningLlm keeps the hand in C#).

Documented in Configuration, Process types, Autonomous, RAG pipeline, Scripting DSL, YAML and builders, YAML schema, Service host, CLI and LLM response format.

Breaking: IManagerAgent.AssignTaskAsync and ReviewOutputAsync take the crew's ManagerLlm, and LlmBasedManager has no model of its own (constructor (ILogger)); HierarchicalProcessStrategy and AutonomousProcessStrategy take a ManagerLlmResolver; IProcessStrategy.ExecuteHierarchicalAsync takes a nullable manager agent id; ExecutionConfig.ManagerLlm and the managerLlm parameter of ExecutionConfig.Create are removed; a hierarchical configuration without managerAgent fails its validation.

Migration: an IManagerAgent of your own sends its prompts to llm.ChatClient, on llm.Model when it is set; a strategy built by hand takes new ManagerLlmResolver(defaultChatClient, profiles, usageSink) — AddOrkeonInfrastructure() registers one; a crew that relied on its first agent managing names it with managerAgent:; instead of ExecutionConfig.ManagerLlm, give the manager agent an llm: block, or a C# crew WithManagerLlm.

Fixed — what a crew writes is what runs: an unknown tool fails act, CrewResult declares what it serves, rag: sources expand, and a forge trial reads the folders and profiles it is given [breaking]

Four things a user wrote were ignored without a word, plus a fifth found since (GAP-27):

  • ctx.llm.act refuses an unknown tool. A procedural .ork.ts agent whose .tools([...]) names a tool the host does not offer — web_serch for web_search — ran act without that tool, silently, where the declarative shape fails its load on the same name (StrictTools). act now rejects, before any model call, with the declared UnknownToolError (new in errors.d.ts, planted as a global like the others: agentName, toolNames, availableTools); an onError handler reads it as validation, and a C# host calling JsCrew.RunAsync gets the typed UnknownToolException (Orkeon.Scripting.Exceptions). Names still match case-insensitively, and a body that never calls act is not concerned.
  • CrewResult declares what crew.run() serves. The typings promised output: TOut and artifacts: ReadonlyMap<string, unknown>; the runtime served a string and a CLR dictionary that was always empty, so result.artifacts.get("x") compiled and threw. CrewResult is now { output: string; tasks: readonly TaskResult[] }, TaskResult.output is unknown, the type parameters of CrewResult, TaskResult and Crew.run are gone, and so is JsCrewResult.artifacts. TypingsRuntimeParityTests pairs both shapes with their CLR types and compares each property's type, not only its name.
  • A crew's rag: sources mean what they say. The schema documented "file globs or directories" and showed sources: ["./data/catalogue/**/*.pdf"] and ["./docs/procedures/"]: both failed at ingestion ("No document loader can handle source"), the sources reaching the pipeline verbatim. RagCollectionsBootstrapper now expands a glob through SourceGlobExpander, as rag_ingest, orkeon rag ingest, rag.ingest and the eval harness do; a directory stands for every file below it; a path without a leading / resolves against the crew's folder (RagCrewConfig.CrewDirectory, recorded by the YAML loader — /crew under orkeon run crew.yaml); an http(s) address and a plain file reach the loaders as written, and a file two entries name is ingested once. A pattern or a directory that yields no file, a glob outside every mount and a relative source of a crew read from a string are load warnings naming the collection. Both examples of the schema page now ingest what they show, checked by a test that reads them from the page.
  • A forge folder outside the working directory is refused where the trial could not read it. A JSONL client that confirmed, in a run trying the team in the same process, an input bound to a directory outside the working directory had it mounted for the trial and refused on every read: the path validator keeps the directories its host started with. In such a run folders.confirmed now refuses it — a recoverable FORGE-FOLDERS-INVALID saying to confirm the folders in a run that stops before its trial (orkeon forge resume <slug> --dry) and to try the team with orkeon forge resume <slug>, whose host mounts and allows them from its start. The validator is unchanged, and Studio, which confirms the folders in a --dry run, is not concerned.
  • A forge trial knows the host's LLM profiles. It loaded a forged .ork.ts crew without them: a crew naming a host profile (llm.profile("fast")) failed its trial with "Known profiles: default." and ran once promoted. The trial now loads it with LlmProfiles, like orkeon run and the forge's assistant; a name the host does not define still fails, listing the ones it does.

Documented in Scripting DSL, Write a crew in TypeScript, YAML schema, RAG pipeline, CLI and Forge a team from a need; the namespace entry of Known limitations says how the forge keeps its trial clear of the validator's refusal.

Breaking: ctx.llm.act rejects an agent whose .tools([...]) names a tool the host does not offer; CrewResult has no artifacts and no type parameter, TaskResult and crew.run() take none, and JsCrewResult.artifacts is removed; RagCollectionsBootstrapper takes the IFileSystemService its sources are expanded against.

Migration: correct or drop the names an UnknownToolError lists (toolNames; availableTools says what the host offers); drop the type argument of crew.run<T>() and narrow result.tasks[i].output yourself; remove any read of result.artifacts — it was always empty; a C# host that builds RagCollectionsBootstrapper itself passes its IFileSystemService.

Fixed — the streaming kickoff runs the crew and says what happens as it goes, a failed run fails the crew, and KickoffForEachAsync runs each input in turn [breaking]

ICrewOrchestrationService.KickoffStreamingAsync — the documented C# equivalent of CrewAI's stream=True — did not run the crew: for each task id it ran a fake task whose description was the GUID, on the crew's agents taken in turn, ignoring the declared agent, the dependencies, the mode, the memory, the knowledge and the plan; the crew was never started nor ended; the stream said neither the output nor whether the run succeeded; and its per-token service could call no tool through the shipped chat client. A run whose task failed raised CrewExecutionCompletedEvent (FailedTasks = 1, the execution PartialSuccess, the crew back to Idle) while orkeon run exited 2; a run that failed before its strategy — a memory that cannot work, a plan whose provider failed — never reached the execution hook, so orkeon run --events ended without its error; --stream never streamed a crew's turns; and KickoffForEachAsync started every input at once on the same crew, all but the first failing with "Crew is already executing" (GAP-32):

  • The streaming kickoff is the crew's run. KickoffStreamingAsync runs exactly what KickoffAsync runs — one kickoff core: load, memory, validation, start, the strategy of the crew's mode (all six), the lifecycle of its tasks and agents, its memory, knowledge and plan, the terminal transition, the checkpoints and the domain events — and yields what happens while it runs.
  • CrewExecutionEvent speaks the run's wire vocabulary. Its Kind is a RunEventKinds constant: task.started and task.completed for each task (task id, agent role; success, skip, duration, tokens, tool calls), tool.called and tool.returned for each tool call (the tool's name, success and duration — never an argument's value nor the result), llm.delta for the model's text as it arrives (with the task and agent of the call), and run.finished, always last, whose Output is the run's CrewOutput — after an error (Code crew_failed or crew_cancelled, new RunEventErrorCodes in Orkeon.Constants.Protocol, and the run's reason) when the run failed. A task's events come in order; the events of tasks that run at once interleave. A crew run from inside a task — a tool that kicks another crew off — never writes into its caller's stream (CrewStreamScope, one per run). Leaving the stream cancels the run, and the iterator waits for its end: the crew fails by cancellation, its running task is cancelled, its events are dispatched.
  • The model's text streams through the real agent loop. The chat-client loop streams a turn when someone reads it — a streamed run, or a host's ILlmDeltaSink — and folds the updates into the turn it reads as before; otherwise the call stays buffered, byte for byte. The chat client adapter's streaming path is built like its buffered one — same messages, roles, tools and options — and reads the provider's chat stream: the text as it arrives, then one last update with the tool calls (native or of the text protocol), the provider's usage, the finish reason, the model, the vendor's cost and the reasoning to replay. A streamed turn calls its tools and is metered once, with the provider's own figures — it was flattened into one prompt, sent no tool, and counted as an estimate. The providers' streams now say what their buffered answers say: Anthropic assembles the tool_use blocks it streams; MiniMax splits its leading <think> block out of the content deltas (LeadingReasoningTag); and on the native protocol the OpenAI dialect and Anthropic give a streamed answer the body their buffered answer carries, so the text-protocol fallback reads a call the model wrote as text. The native and text loops (no IChatClient) stream every event but the text.
  • orkeon run --stream streams a crew's turns. The run observer's delta sink now reaches the agent loop (ExecutionOrchestrator.DeltaSink, set by AddOrkeonApplication from the registered ILlmDeltaSink): a YAML crew, a crew directory and a declarative .ork.ts crew write llm.delta events, where only ctx.llm.* calls did. The observer registers the sink only under --stream, so a run with --events alone keeps every call buffered. The REPL's console sink (Orkeon:Cli:ConsoleStreaming:Enabled) renders the crew's turns too.
  • A failed run fails the crew. A strategy that returns a failed output — the rule of every mode since GAP-03 — makes the orchestrator call Crew.FailExecution with the output's error (a readable sentence when it has none): CrewExecutionFailedEvent with that Reason, naming each failed or skipped task, and no Exception; the crew and its execution stay Failed. Only a run whose every task succeeded completes it — one terminal transition per run. A cancelled run is a failed run whose Exception is the OperationCanceledException, and a task the cancellation caught running is Cancelled (it was failed with "Operation was cancelled").
  • A task counts once, by its final outcome. CrewExecutionCompletedEvent.CompletedTasks and CrewExecution.CompletedTasks count each task the run completed once: a graph task that failed and succeeded on its retry made a successful run report a failed task and a PartialSuccess execution. CrewExecutionCompletedHandler logs "N tasks".
  • A run that fails before its strategy reaches the execution hook, once, from the orchestrator (which takes an optional ICrewExecutionHook): a memory that cannot work, a plan whose provider failed, a crew not found or refused by ValidateCanKickoff. AUTO_SUMMARY.md is written, orkeon-host hears it, and orkeon run --events jsonl says error (crew_failed, the cause) before run.finished — as the run event bus promised. A failure a strategy reported is never reported twice.
  • KickoffForEachAsync runs each input in sequence, as its contract says and like CrewAI's kickoff_for_each: each input is a full run, the next one starts once the previous one has returned, and the results keep the inputs' order.
  • StepNotifyingToolInvocationPipeline.Wrap always wraps — without callbacks it notifies the stream of a streamed run alone —, so an ExecutionOrchestrator built by hand streams its tool calls too.
  • The Orkeon package embeds Orkeon.Constants.Protocol, which Orkeon.Application now references: the core closure is twelve assemblies.

Breaking: CrewExecutionEvent is a record with Kind, Timestamp, TaskId, AgentRole, Text, ToolName, Success, Duration, Skipped, SkipReason, Tokens, ToolCalls, Code, Message and Output (its TaskDescription and Thought are gone); AgentThought (with ThoughtType), IStreamingAgentExecutionService and StreamingAgentExecutionService are removed, and AddOrkeonInfrastructure() registers no streaming service; SequentialCrewOrchestrator loses its streamingService parameter and gains an optional ICrewExecutionHook executionHook; Crew.CompleteExecution(int completedTasks) and the internal CrewExecution.Complete(int) lose their failedTasks parameter; CrewExecutionCompletedEvent.FailedTasks, ExecutionStatus.PartialSuccess (Failed is now 2, Cancelled 3), CrewExecution.FailedTasks, CrewExecution.SuccessRate and the internal CrewExecution.UpdateProgress are removed; a run with a failed task raises CrewExecutionFailedEvent instead of CrewExecutionCompletedEvent and leaves the crew Failed; KickoffForEachAsync no longer runs its inputs at once; orkeon run --events without --stream registers no ILlmDeltaSink, so ctx.llm.act stays buffered there.

Migration: read a streamed run's events by Kind (RunEventKinds.TaskStarted, LlmDelta, RunFinished, …) and its result from the run.finished event's Output; drop IStreamingAgentExecutionService and call KickoffStreamingAsync on a crew; drop the streamingService argument of a hand-built SequentialCrewOrchestrator (pass executionHook: to have it report failures before the strategy); call CompleteExecution(completed); move a handler of CrewExecutionCompletedEvent that inspected FailedTasks to CrewExecutionFailedEvent, whose Reason names each task that did not succeed; replace ExecutionStatus.PartialSuccess with Failed. A batch that relied on its inputs running at once builds one crew per input.

Fixed — planning: true earns its call: the planner reads the crew and each task reads its own plan, in every mode [breaking]

planning: true made one call before the first task (GAP-29) and little else came of it: the planner was shown the crew's goal and the ids of its agents and tasks — no description, no expected output, no dependency, no tool — so all it could decide was an order; the instructions, agent assignments and parallel groups it returned were parsed and dropped; its order, followed under the dependencies, decided the crew's output, the context a task read and Parallel's round-robin, and a task it cited twice ran twice; Hierarchical and Autonomous made the plan and ignored it; on the echo provider every planning: true crew failed, each task "missing from the plan"; and .ork.ts had no switch (GAP-31):

  • The planner reads the crew. Its goal, a line on how the mode orders the tasks and picks their agents, the run's variables (initial_context included), and each task by number, in the order the run takes them: its description and expected output with the variables in them, as its agent reads them; its dependencies, by number; and its agent's role, goal and tool names where the mode runs a task on the agent it names — elsewhere what the mode does instead, with the crew's agents listed once. Never an id. Bounded by PlanningDefaults: a description to 1,500 characters, an expected output to 500, an agent's goal to 300, 15 tool names per agent, the variables to 2,000.
  • It writes one step-by-step plan per task — {"plans": [{"task": 1, "plan": "1. …"}]}, at most 8 numbered steps naming the tools to use —, the reply constrained as far as the provider can (json_schema, else json_object) and read tolerantly (a fence or a sentence around it). The call takes the run's token: cancelling the run cancels it.
  • Each task reads its own plan in its prompt, in all six modes, after the task and before the context variables, under Plan for this task, from the crew's planner — follow it where it helps; the task above prevails:, cut at 2,000 characters — the worker and each revision in Hierarchical, every candidate in Consensual (not a ballot), each attempt in Graph, the agent that claims a task and the peer it is handed to in Autonomous. The run holds its plan in a scope of its own (CrewPlanScope), read where every mode's executions compose their prompt: no strategy carries it, the task's own description is never changed, and two runs of one crew never read each other's plan. Each task's plan is logged at Information.
  • The plan changes neither the order nor the agents. With or without a plan, a crew runs the same tasks, in the same order, on the same agents.
  • An unreadable plan no longer fails the run. It is asked for once more, with what could not be read, then the crew runs without a plan, with a warning — which says so when the reply stopped at the profile's MaxTokens; a task the plan leaves out runs without one, a number given twice keeps its first plan, an unknown number is ignored, each with a warning. A provider that fails still fails the run, before its first task, with its reason.
  • The echo provider skips planning with a warning (planning skipped — the echo provider cannot plan, and orkeon init): LlmProviderCapabilities.ReplaysPrompt, declared by UndefinedLlmProvider alone, and passed through by MeteredLlmProvider and — now — RateLimitedLlmProvider, whose Capabilities hid the wrapped provider's. A keyless orkeon run of a planning: true crew exits 0.
  • .ork.ts: crewBuilder().planning(value = true), YAML's planning: true, on the host's default profile; the procedural shape warns that it plans nothing.
  • A streamed run (KickoffStreamingAsync) did not plan, and warned once — until the streaming kickoff became the crew's own run (above).
  • Removed: IPlanningStrategy and DefaultPlanningStrategy (no caller); the plan's order, agent assignments, parallel groups and dependencies (ExecutionPlan.Assignments, WithTask, WithAgentAssignment, GetAssignedAgent, GetTasksInOrder, GetParallelGroups, PlannedTask.ExecutionOrder, ParallelGroup, Dependencies, PlannedTask.Create) and the planner's cycle check; the plan parameter of IProcessStrategy.ExecuteSequentialAsync and ExecuteParallelAsync and of ConsensualProcessStrategy.ExecuteConsensualAsync; IExecutionPlanParser.ParseAsync and ParserName, and the text fallback of ExecutionPlanParser.

Breaking: ExecutionPlan is one plan per task (ExecutionPlan.Create(IEnumerable<PlannedTask>), ExecutionPlan.Empty, InstructionsFor(TaskId), new PlannedTask(TaskId, string)); CrewPlanner.Create(provider, parser) takes no strategy and CreatePlanAsync(PlanningContext, CancellationToken) returns a CrewPlanningOutcome (the plan and its warnings), its PlanningContext built of PlanningTask and PlanningAgent sheets; IExecutionPlanParser.Read(reply, numberedTasks) returns an ExecutionPlanReading; IProcessStrategy implementations lose their plan parameter; SequentialCrewOrchestrator takes an optional ITaskRepository, and a hand-built orchestrator needs it and its IAgentRepository to plan.

Migration: drop the plan argument of a strategy call (strategy.ExecuteSequentialAsync(crew, variables, token)); a custom IProcessStrategy removes the parameter, and a custom IExecutionPlanParser implements Read. A crew that relied on the plan's order declares it in dependencies: — the order a crew runs in is its own now, with or without a plan. Nothing changes for a YAML crew: planning: true keeps its meaning and gains its effect.

Fixed — asyncExecution: true runs a task alongside the next ones in a sequential crew, and is refused where the mode orders its tasks itself [breaking]

A task's asyncExecution: true (CrewAI's async_execution) was read, mapped and stored on the task, and no mode read it: the two research tasks a sequential pipeline marked asynchronous ran one after the other, and taskBuilder().asyncExecution() promised a concurrency nothing delivered (GAP-22):

  • Sequential honours it, with CrewAI's semantics. The task is launched without being waited for and the next task starts at once; a task that depends on it (dependencies:, CrewAI's context) waits for it, then reads its output — and is skipped if it failed; the crew waits for every task it launched before it reports, and its output stays the last declared task's. A failure fails the crew, as in every mode, and the tasks already running go to their end. The task starts when it is launched and ends when the run waits for it (its lifecycle events); the hooks hear each task as it finishes, so AUTO_SUMMARY.md and orkeon run --events follow the order the tasks finish in. It runs through the same execution service as a task of a parallel wave, and a coworker it delegates to works in its context.
  • What a task reads never depends on timing. An asynchronous output enters the context of the next tasks once a task has waited for it, in declared order. Each task's context now holds its own copy of the outputs so far: every task shared one list the run kept appending to, so a context captured during a task — by a handler, a test double — kept growing after it.
  • Parallel accepts it without an effect of its own: a wave already runs at once.
  • Hierarchical, Consensual, Graph and Autonomous refuse it at load — their manager, vote, graph or budget order the tasks — naming every task that sets it and proposing process: sequential or parallel: in YAML (YamlCrewMapper), in a .ork.ts crew when the run adapts it (JsCrewConfigurationAdapter), in a configuration built in code (CrewDefinitionValidator), and in C# (CrewBuilder.Build() throws BuilderValidationException). asyncExecution: false, the default, loads everywhere; ProcessType.AcceptsAsyncExecution says which modes accept the flag.

The three hierarchical examples that set it (87 fleet management, 95 crisis management, 101 crew of crews) no longer do — it never had an effect there —, and 100 civilization simulator declares its three faction strategies together, so they run at once. The limitation that said the flag was honoured by no mode is gone from Known limitations.

Breaking: a crew with asyncExecution: true outside process: sequential and process: parallel no longer loads, and CrewBuilder.Build() refuses a task built with .Async() in those modes.

Migration: remove asyncExecution: true from the tasks of a hierarchical, consensual, graph or autonomous crew — it never ran them concurrently —, or move the crew to process: sequential, declaring in dependencies: the asynchronous tasks a task needs (a task that does not depend on them starts without their output), or to process: parallel.

Fixed — a run moves its tasks and agents through their lifecycle and raises their events as it goes, and a delegation runs in the context of the task it serves [breaking]

A run raised the crew's domain events and nothing else: no mode moved a CrewTask or an Agent through its lifecycle, so TaskStartedEvent, AgentCompletedTaskEvent and their siblings never went out, the shipped AgentCompletedTaskHandler / AgentFailedTaskHandler never logged, and a task read back from its repository after a run was still Pending, without a date (GAP-21):

  • Every mode drives the lifecycle, as the run goes. The outcome the six modes share (CrewRunOutcome) records each start, success, failure, skip, task never reached and interruption, and TaskLifecycle applies the transition — the task assigned to the agent that runs it, started, then completed or failed; the agent given the task, started, then completed or failed —, saves both in the run's repositories, then dispatches their events through IDomainEventDispatcher, before the crew's own at the end of the kickoff. A handler that throws is logged, as for the crew's events; a transition the aggregate refuses is a warning, never a failed run.
  • What each mode adds. Parallel starts a task as it launches it and ends a wave's tasks once the wave has joined, an agent running two tasks of a wave at once. Graph starts a task once and keeps it running through its retries. In Hierarchical the agent the manager assigns starts the task — re-assigned from a declared one — and ends it once, its revisions included. A consensual task starts once, under no single agent; every agent that answers starts it and ends it with its own answer, and the task completes under the author of the retained one. In Autonomous a task handed to a peer is failed by the agent that claimed it and completed by the peer.
  • A task that does not run is cancelled, saying why: skipped behind a dependency that did not succeed (neither started nor ended), never reached by an exhausted budget, or caught by a cancellation (the run was cancelled); a run that stops on an exception fails the task it was running. After a run the repository holds Completed, Failed or Cancelled, with the dates; a crew kicked off again without being reloaded reopens its tasks (CrewTask.Reopen).
  • StepsExecuted is real. TaskCompletionInfo.StepsExecuted, handed to every ICallbackHandler and logged by LoggingCallbackHandler, is the number of turns the agent loop ran (TaskResult.IterationsUsed); it was 1 whatever the loop did.
  • A delegation runs in the context of the task it serves. delegate_work_to_coworker derives the coworker's context from the delegating task's with with — the crew's id, the memory scope, the outputs so far and the parent's settings, so it recalls when the parent does — and turns StoreResultInMemory off: under memory: true a coworker's sub-answer was stored as a task result, and the parent's settings were lost. Without the context of a crew run, a synchronous delegation is refused rather than run under a fresh crew id. A crew kicked off again keeps its agents: their delegation tools are now replaced, so they read the new run's context — the second run of a Sequential or Graph crew whose agents may delegate failed at its start ("Tool delegate_work_to_coworker already exists").
  • An Autonomous takeover is the task. The peer runs the failed task itself — not a copy built from its description — in the failed attempt's context, derived under the crew's id, with the run's inputs and the outputs so far: it recalls the crew's memory, and its output, when it succeeds, is stored once, under it. It ran under a fresh crew id: nothing stored, nothing recalled. A delegate request naming no task of the run is refused.

Breaking: the dead surfaces of the agent aggregate are removed — Agent.UpdateMemory and AgentMemoryUpdatedEvent, with Agent.Memories, AgentSnapshot.Memories and AgentDefaults.MaxMemories (a crew's memory is the memory coordinator's), and Agent.CollaborateWith and AgentCollaborationStartedEvent, with CollaborationId (agents collaborate through delegation); 31 domain events remain. An agent runs several tasks at once: Agent.CurrentTask becomes CurrentTasks (AgentSnapshot.CurrentTask too), CompleteTask and FailTask take the task's id, and AssignTask accepts a busy agent. CrewTask.AssignTo re-assigns a pending or running task (the same agent changes nothing), Start no longer blocks a task that has dependencies — the run decides when it starts —, Start() starts a task no single agent runs and TaskStartedEvent.AgentId is nullable for it, Fail records CompletedAt, GetExecutionTime counts from StartedAt only, and Reopen is new. CrewStrategyDependencies, ParallelProcessStrategy and HierarchicalProcessStrategy take an optional IDomainEventDispatcher, which the container fills. DelegateWorkTool refuses wait_for_result: true when its context supplier supplies no context. The limitation that said a run raised the crew's events only is gone from Known limitations.

Migration: call CompleteTask(taskId, output) / FailTask(taskId, reason) and read CurrentTasks; expect a null AgentId on the TaskStartedEvent of a consensual task; register an IDomainEventHandler<T> for the task and agent events to follow a run task by task; remove calls to UpdateMemory and CollaborateWith — store and recall through IMemoryCoordinator, collaborate through the delegation tools; give a DelegateWorkTool built by hand a context supplier for synchronous delegation.

Fixed — a crew with memory: true recalls its earlier work before each task, and a memory that fails no longer fails the task [breaking]

Every crew stored each successful output, whatever its memory: said, and nothing in a run read the memory back into a prompt (GAP-30, the four findings left by GAP-20):

  • memory: is the switch. With memory: true (.memory(true) in .ork.ts, CrewBuilder.EnableMemory() in C#) a run stores the result of each task and, before each task, recalls the crew's closest memories into its prompt; with memory: false, or no memory:, nothing is stored or recalled and no memory system is materialized. The default is unchanged: off. memoryProvider: without memory: true is refused, the remedy in the message — at load, and by Crew.Create (so CrewBuilder.Build()) and Crew.UpdateConfiguration.
  • A named crew that names no provider lives in the host's default store (Memory:Provider, In-Memory when unset), scoped by its name, as the aggregate's contract said. It lived in a store of its own that did not outlast the run, so an .ork.ts crew — the DSL has no memoryProvider — never kept anything. orkeon-host now remembers from one message to the next; orkeon run from one process to the next only with a durable store (memoryProvider: sqlite, or a durable Memory:Provider). An unnamed C# crew keeps a store of its own.
  • The recall is a vector search in the crew's scope. AgentExecutionService asks IMemoryCoordinator.RecallAsync for the memories closest to the task — on the query of the knowledge retrieval: description, expected output, variables — leaving out those the prompt already carries as previous outputs. The user prompt renders them after the previous outputs and before the retrieved knowledge, under PromptDefaults.MemoriesHeader, one --- date · role · task --- line before each; the Guardian screens them with the rest of the prompt. The new Orkeon:CrewMemory section (CrewMemoryOptions, bound by AddOrkeonInfrastructure()) bounds it: RecallLimit 5, MinScore 0.6 (cosine, measured on the local model), MaxChars 4,000. A consensual candidate and a hierarchical attempt recall — they answer the task; a ballot does not (SimpleExecutionContext.RecallFromMemory, turned off by AgentBallotCollector).
  • Every memory is embedded, and the embedder is checked at kickoff. A memory is embedded on its task and its output by the host's IEmbeddingProvider, the port of the RAG. Before its first LLM call, a crew with memory: true embeds a probe and searches its memory once (IMemoryCoordinator.EnsureReadyAsync): a missing embedder, a refused key, an unreachable store or a vector of the wrong dimension fails the run, naming the crew, the cause and the remedies.
  • A memory that fails during a run is a warning. A store or a recall that fails is logged as a Warning — the crew, the task, the agent, the store, the cause — and the task keeps its output; a failed recall leaves it without memories. A failed store used to fail the task, its output lost, and since GAP-03 the crew: on Pinecone and ChromaDB, every task. ConsensualProcessStrategy no longer fails a retained answer it cannot store.
  • Hierarchical stores the accepted output only, once, under the assigned agent: every attempt runs with StoreResultInMemory off — a task stored up to three outputs, all rejected when the manager rejected them all. The revision contexts are derived (with), so their settings travel.
  • Pinecone and ChromaDB stop faking. Their StoreAsync refuses an item without an embedding before any request (ArgumentException), as their collection paths did — they sent no vector, which a real server rejects. Pinecone's SearchAsync throws NotSupportedException: it has no text search, and sent an empty vector with an exact match on the content. ChromaDB's sends POST …/get with where_document: {"$contains": query} and the filter as where — case-sensitive, as the server matches; an empty query sends the filter alone — where it sent query_texts, which only the clients serve. The memory_provider health check reads an absent key, which every provider serves, where it searched by text.
  • The cognitive memory works in the crew's memory (AddOrkeonCognitiveMemory): it stores what it remembers once — it stored it twice — stamped like the run's memories (CrewMemoryScope, now public), so a crew has one memory. Recall, contradiction candidates and consolidation search it by similarity within the crew's scope — the recall searched every crew's memories and the RAG chunks; a conflict is resolved, and a consolidation merges and prunes, in the store the memories came from; a merged memory is embedded.
  • A forge trial runs without memory, whatever the plan says: the promoted crew would recall the trial's outputs as its earlier runs. The streaming kickoff (KickoffStreamingAsync) neither recalled nor stored, and said so in a warning — until it became the crew's own run (above).

Breaking: a crew without memory: true stores nothing, one that names a memoryProvider: without it is refused, and one with it needs an embedder at kickoff. IMemoryCoordinator is reduced to EnsureReadyAsync, RecallAsync (which replaces RetrieveRelevantMemoriesAsync) and StoreTaskResultAsync — StoreAgentExperienceAsync and UpdateWorkingMemoryAsync, which nothing called, are removed; MemoryCoordinator requires the registry and takes the embedder and IOptions<CrewMemoryOptions>. CrewMemoryProviderRegistry.Record takes memoryEnabled, with IsMemoryEnabled and GetName. ILongTermMemory gains SearchSimilarAsync and RemoveAsync. HierarchicalProcessStrategy requires an IMemoryCoordinator; SequentialCrewOrchestrator takes an optional one, and MemoryService the application's IMemoryProvider. CognitiveMemoryService no longer takes an IMemoryProvider; MemoryConsolidator takes an IEmbeddingProvider in its place, and ConsolidateAsync the memories found (ScoredMemoryItem) with the memory they came from. Known limitations now say what the crew's memory does not do: no retention or reset, recall by vector only, durable only in a durable store.

Migration: add memory: true to a crew that names a memoryProvider:, or drop the provider; give a host that runs a crew with memory an embedder — AddOrkeonLocalEmbeddings() or the Orkeon:Embeddings section; orkeon run and orkeon-host register the local model unless RaggableTree:Enabled: false, the REPL always — whose dimension is the store's (the local model gives 384, LanceDB defaults to 1,536); store items with their embedding in Pinecone and ChromaDB, and search Pinecone with SearchSimilarAsync; implement the two new members in a custom ILongTermMemory; call RecallAsync where RetrieveRelevantMemoriesAsync was called; tune the recall in Orkeon:CrewMemory — MinScore is on the embedder's scale.

Fixed — a call's configuration completes its provider's, planning: true plans, and the REPL's chat client has a key [breaking]

A configuration passed with one LLM call replaced the provider's whole (config ?? Config), and every caller outside the chat client builds one to set its temperature (GAP-29):

  • Calls lost the key, the endpoint and the timeout of their provider. On a real vendor, the crew planner, the cognitive memory's analyses (MemoryAnalyzer, ContradictionDetector, MemoryConsolidator), the context-window summary (OpenAIContextWindowManager), the RaggableTree node summarizer (LlmNodeSummarizer), the text and native agent loops and the output-validation correction round answered "API key is required" — or left for the vendor's default URL, on a 30 s timeout whatever Llm:TimeoutSeconds said, without the provider's Thinking nor Azure's API version — and fell back without a word: a plan "missing" its tasks, a default analysis, a truncation, no summary. A call's configuration now completes the provider's (LlmConfig.InheritFrom, applied by HttpLlmProviderBase.EffectiveConfig in the sixteen providers): every field the call leaves unset is the provider's, every field it sets wins, custom parameters merge. The sampling settings that cannot be unset — Temperature, TopP, the penalties, the tool mode — stay the caller's. The chat client adapter registered without a base configuration starts from the provider's own.
  • LlmConfig.TimeoutSeconds is nullable. It defaulted to 30, so a call could not tell "not set" from "30": null now inherits the provider's timeout, else LlmDefaults.DefaultTimeoutSeconds (30 s, LlmConfig.ResolveTimeoutSeconds()).
  • planning: true plans. The orchestrator planned only when the crew carried a planning provider, which only C#'s WithPlanningLlm sets: a YAML crew, or a C# one calling .Planning(true) alone, planned nothing while the documentation said it did (the .ork.ts DSL has no planning switch). It plans now, before the first task, on the crew's planning provider, else on the host's default profile. The plan's order is followed wherever the declared dependencies allow it — the planner sees task ids, not their dependencies, and a plan taken as is could run a task before one it depends on. A plan that fails says why: the planner read a failed call's empty content and reported every task "missing from the plan".
  • orkeon-repl serves a chat client on its Llm section. It registered its provider without one, so its IChatClient — agent turns, RAG answers, judges — was the infrastructure's fallback, a second provider with no key on OpenAI's endpoint. It registers its provider the way orkeon run does — one instance on the three surfaces, the chat client on the section's configuration, the section read by the runners' LlmSettings — and the echo provider, with the runner's warning, without an Llm section.
  • The RaggableTree summarizer names no model by default: SummarizerOptions.Model and LlmNodeSummarizerOptions.Model were claude-haiku-4-5 on whatever vendor the host runs; the provider's own model now.
  • Removed: AddOrkeonInfrastructure()'s model fallbacks — the keyless IBasicLlmProvider and IChatClient it registered when the host had none (a container without a model fails at its first LLM resolution, naming what to register); and the planning settings nothing read: Orkeon.Domain.Crew.Planning.PlanningConfiguration, Orkeon.Application.Agent.PlanningConfiguration, OrkeonApplicationOptions.EnablePlanning and PlanningLlmModel, LlmDefaults.DefaultPlanningModel.

Breaking: LlmConfig.TimeoutSeconds is an int?, and so is CreateValidated's timeoutSeconds; a call can no longer erase a provider setting by leaving it null — it overrides it (Thinking = { Enabled = false }, LlmResponseFormat.Text()). A container that registers no model fails where it got a keyless OpenAI provider. A crew with planning: true makes its planning call now — on the echo provider (no Llm section), which replays the prompt, it fails at its plan. SequentialCrewOrchestrator takes an optional ILlmProfileRegistry. Known limitations say what planning does not do yet: the planner sees ids only, and Hierarchical and Autonomous make the plan without using it.

Migration: read ResolveTimeoutSeconds() for the timeout a request runs on; a provider deriving from HttpLlmProviderBase that reads a call's configuration takes EffectiveConfig(config) instead of config ?? Config; a host registers its model with AddOrkeonLlmProvider(…), which serves the three surfaces — one that registered ILlmProvider and an IChatClient by hand registers IBasicLlmProvider too (new LlmProviderAdapter(provider)), which the keyless fallback used to fake; drop the planning options — planning: true (.Planning(true)) is the switch, WithPlanningLlm the C# provider.

Fixed — a crew's memory is its own: scoped by its name, without RAG chunks, without ballots [breaking]

A crew that names a memory provider (memoryProvider:) keeps its long-term memory in that type's provider, the one instance every crew of that type shares — with the RAG store of that type too when Orkeon:Rag:Provider is unset (GAP-08). What it stored and what it read did not account for that (GAP-20):

  • A crew read every crew's memory. Entries were stored under a bare id and a search scanned the whole store: the "legal watch" crew could get the "customer follow-up" crew's outputs, and any RAG chunk — or chunk manifest — whose text held the query. Each entry now carries kind = crew-memory and crew = <the crew's name>, and the crew's searches ask the provider for both. The name — the name: of the YAML file, crew directory or .ork.ts crew, CrewBuilder.Name in C# — is the same from one run to the next, so a crew still reads what its earlier runs stored, and only that. A crew without a name is scoped by its id, for one run. MemoryCoordinator also tags each memory crew:<name>.
  • A consensual task stored every candidate and every ballot. Each agent's answer and each {"ranking": …} ballot ran through the execution service, which stores a successful result: the crew's memory held the answers the vote rejected, and the ballots, as task outputs. A new SimpleExecutionContext.StoreResultInMemory (on by default) is off for the candidates and the ballots — AgentBallotCollector turns it off for any ballot it casts — and the strategy stores the retained answer once, under the agent that wrote it. A store that fails fails the task, as in the other modes.
  • The providers' text search had no filter. IMemoryProvider.SearchAsync takes the filter of SearchSimilarAsync (source, tag/tags, any other key an equality on a custom property), and every provider applies it before its limit: in memory for In-Memory, Redis and SQLite, as ChromaDB's where, Pinecone's metadata filter and LanceDB's prefiltered predicate. On the way: ChromaDB refused a filter of two keys (they go under one $and now); SQLite's and LanceDB's filters matched a custom property by substring — of the whole custom-properties JSON for SQLite, of the value for LanceDB — so crew = "legal" found "legal ops", and they compare the property now (LanceDB its "key":"value" pair, spelled as the stored JSON spells it); ChromaDB and Pinecone dropped an item's custom properties in their default collection/namespace, where a filter on one found nothing — they keep and restore them, as the named ones did.

Breaking: IMemoryProvider.SearchAsync(query, limit, filter, cancellationToken) and MemoryProviderBase.SearchAsync take the filter before the token — an implementation adds the parameter, a call that passed the token by position names it (cancellationToken:). CrewMemoryProviderRegistry.SetProvider(crewId, type) becomes Record(crewId, type, crewName), with GetScope(crewId); MemoryCoordinator takes the registry, ConsensualProcessStrategy an IMemoryCoordinator; Crew.Name, CrewCreateOptions.Name and CrewBuilder.Name(name) are new. A crew no longer reads what other crews stored in a shared provider, nor entries stored before this version (they carry no crew). Give a C# crew a name (CrewBuilder.Name) to keep its memory from one run to the next. Known limitations now say what a run does with a crew's memory: it writes it, and nothing in a shipped run reads it back into a prompt.

Fixed — a model left unset is the profile's own, on every path [breaking]

GAP-17 made a crew's llm: block that names no model run on its profile's model; other paths still pinned OpenAI's default model (LlmDefaults.DefaultModelName) on whatever vendor served the call, and fifteen of the sixteen providers refuse it ("model not found") (GAP-18):

  • A C# agent's sugar. AgentBuilder.Thinking() and .MaxOutputTokens(n) seeded LlmConfig.Create(LlmDefaults.DefaultModelName): on a DeepSeek or Anthropic host, such an agent sent OpenAI's model. They start from LlmConfig.OnProfile() now, and the agent runs on the host's model.
  • llm.default_ on a host whose provider configures no model returned — and an agent configured with it pinned — OpenAI's model. It reads an empty model now, and the call carries the provider's own.
  • The calls outside the chat client. The text and native agent loops, the output-validation correction round and the crew planner called with LlmConfig.Default(); they name no model now (the planner keeps its temperature 0.3). So do the forge's judge and ctx.llm's call-time overrides on a provider that declares no configuration, the context-window summarizer, the cognitive memory's analysis calls without AnalysisModel (documented as "the default provider model"), the chat client registered without a base configuration (AddOrkeonLlmProvider(provider)), and orkeon llm probe on a provider without a default of its own (Azure).
  • The providers resolve an empty model. A call's configuration replaces the provider's, and the providers fell back with config.Model ?? default, which an empty string defeats: such a call went out with "model": "". HttpLlmProviderBase.ResolveModel(config) is the one rule now — the call's model, else the model the provider is configured with (its profile's), else its DefaultModel — for the payload, the response's Model (what the meter records), the output-cap lookup and the error hints, in the OpenAI-compatible family, Anthropic, Azure OpenAI (whose deployment no longer falls back to OpenAI's model before the configured one) and Ollama (whose six hard-coded "llama2" fallbacks become its documented default, llama3.2). The adapters over an IChatClient leave ModelId unset instead of empty, and the meter attributes a stream that named no model to the provider's.
  • An Llm section — or a profile — without Model runs on the inferred provider's own default model: the settings reader, and the REPL's, filled in OpenAI's, which a DeepSeek endpoint inferred from BaseUrl refused. With no model to read, the vendor inference also reaches the API-key shape it documents (xai- → Grok, hf_ → HuggingFace), which the filled-in OpenAI model always pre-empted.
  • Removed: LlmConfig.Default() — a name that says "default" and pins one vendor's model was the trap. LlmConfig.Model is empty by default, and LlmConfig.OnProfile() is the configuration that names no model. DefaultModel moved from OpenAICompatibleProviderBase to HttpLlmProviderBase (abstract): Anthropic and Ollama declare theirs.

Migration: replace LlmConfig.Default() with LlmConfig.OnProfile() — the same settings, on the model of the provider the call reaches — or with LlmConfig.Create(model) to pin one (LlmConfig.WithDefaultModel() still names OpenAI's default model, explicitly). A provider that derives from HttpLlmProviderBase directly overrides DefaultModel.

Fixed — balanced and quality work in orkeon-host and the REPL; runs resolve scoped services in their own scope

The balanced and quality RAG profiles (and adaptive, whose SingleShot route delegates to balanced) rerank with the ONNX cross-encoder, and only the orkeon CLI registered it: a hosted crew whose knowledge: asked for either profile, or rag_search in orkeon-repl, failed its first retrieval with "Unknown reranker 'onnx'" (GAP-25). orkeon-host and orkeon-repl now reference Orkeon.Rag.Onnx + Orkeon.Rag.Onnx.Model and call AddOrkeonOnnxReranker(), as the CLI does — and the CLI now does in orkeon forge too, whose trials run the crew orkeon run will run once promoted: a forged crew's rag_search on a host set to balanced failed its trial and worked after promotion. Orkeon.Hosting (a NuGet package) stays free of ONNX. Each of the two binaries gains 23.4 MB, 16.5 MB once compressed in an archive (the embedded int8 weights; ONNX Runtime was already there for the local embeddings). The daemon's own registrations moved from Program.cs to HostServiceRegistration.AddHostServices, so a test builds the very host it runs. The weights' Apache-2.0 notice travels with them: THIRD-PARTY-NOTICES.md lists the three binaries that carry them, and the orkeon-host service MSI now installs that file next to LICENSE.md (it shipped the BGE-micro-v2 embedding weights without it).

orkeon run (and --validate) resolved the crew factory, the orchestrator and the agent repository — all scoped — from the root provider, and so did each orkeon forge trial; the load and the kickoff now run in one scope, as orkeon-host does per run, and the runner host and the daemon are tested with scope validation on (a Development host's default). The Agent Framework bridge had the same defect, in its public API:

  • Breaking — ICrewAgentFactory was a singleton holding the root-resolved orchestrator, so every CrewAgent of a host shared it (and its repositories) for the life of the process, and a host validating scopes refused to resolve it. It now holds the IServiceScopeFactory, and Create(loadCrew, name, description?) replaces Create(crewId, name?, description?) and Create(crew): each turn opens a scope, loadCrew registers the crew in it and returns its id, the scope's orchestrator runs it. new CrewAgent(scopeFactory, loadCrew, name, description?) is the same form without the factory; CrewAgent.CrewId is now CrewId? (null for that form). Migration: move the code that adds the crew's agents, tasks and crew to the repositories (or loads it through ICrewFactory) into the loader, resolving the repositories from the provider it receives, and return the crew's id — see examples/interop/agent-framework/ and ADR-010's amendment. new CrewAgent(orchestrator, crewId|crew) is unchanged.

Fixed — check-doc-claims.py reads what git publishes, not the ignored trees of a working clone

The documentation-claims gate walked the file system, so on a working clone it also read the git-ignored third-party checkouts under examples/others/ (~34,000 files): more than ten minutes and some 361,000 false reports, locally only — a CI clone has no such folder (GAP-28). Its three walks (the counted files, the private-pointer scan, the .md files a citation resolves against) now go through one git_files() helper on git ls-files --cached --others --exclude-standard: tracked files and new ones not yet staged, never an ignored path, never a private submodule's content. scripts/test-check-doc-claims.py proves it on a scratch repository and runs in CI. validate-all-examples.sh lists the example crews the same way. The Studio test that still expected image_generation's retired "key given at the call" wording (red since the Guardian lot) now expects the stored key ORKEON_OPENAI_API_KEY the catalogue declares.

Added — files and folders can be dropped on the need of the wizard's step 1

Studio's « What work do you want to give this team? » now takes files and folders dragged from the explorer, several at once (STUDIO-47). Each path that exists is inserted at the caret, between quotes and separated by a space; a path that does not exist is ignored. A dropped folder — or a dropped file's own folder — reaches the Folders step (STUDIO-46) already bound to that real folder: it answers the row the request gave its name, else the default input /workspace, else it joins the list as an input named after the folder (My PDFs → /my-pdfs), and it is declared in « Settings › Authorized folders » the way a disk pick is. A hint under the field says so, in the five languages. The forge protocol is unchanged: the candidates are merged on the Studio side.

Changed — the forge proposes the team's folders from the need, and they are used everywhere (breaking: forge protocol)

« Where are your folders? » always offered workspace/ and output/, never the folders the need named, and « Create inside the team » pointed at a folder that existed only after the adoption (STUDIO-46). The folders now come from the request, are confirmed once, and are the team's folders from the plan to the adopted team.

  • ForgeBrief.folders[] (path, role input|output, purpose): the forge assistant lists the folders the request names — « …PDFs in /inpdf, the Markdown in /outmd » — and when it names none the forge proposes /workspace to read (only when something comes in) and /output to write. A folder is one absolute segment; /forge and the runner's roots are refused; at least one output.
  • Forge protocol — a new event and a new answer between the brief and the plan: folders.proposed (folders) out, folders.confirmed (folders, each with an optional dir, the real directory bound behind it) in. brief.ready now follows the confirmation and carries the confirmed list. A list that breaks the rules is a recoverable FORGE-FOLDERS-INVALID. The terminal and --auto take the proposal as it is and print it. Migration: a client of orkeon forge --events jsonl must answer folders.proposed with folders.confirmed (sending the proposal back unchanged is a valid answer) — the engine waits for it.
  • The confirmed list is used everywhere: kept in the session's folders.json (with the bound directories) and in the brief (without them); the plan prompt lists it and a deliverable must land in a confirmed output folder (any one, no longer /output only); the crew's mounts: block, the trial bench's mounts (through a VFS scope, so a list confirmed mid-run reaches the trial), the deliverable check (runs/<n>/folders/<name>/), forge promote's folders and launchers and forge reopen's rebuilt session all follow it. /workspace and /output are no longer added by default — the trial drops them unless the list holds them.
  • « Inside the team » works before the adoption: such a folder lives in the session (.orkeon/forge/<slug>/folders/<name>), readable by the trial, and forge promote moves it into the team.
  • --read <dir> now answers the first input folder the confirmed list binds to no directory (/workspace when the need named none).
  • Studio: the step-1 folders card is gone; a Folders step above the conversation shows the proposal — each name editable, its role, « Choose a folder… » (the disk picker, declared on the way) or « Inside the team » (an output's default) — and « Confirm the folders » sends the list. The Composer rows, the tool chips and the sidecar follow the confirmed list (ForgeSessionModel.Folders, hydrated from folders.json on a resume). Studio.Core gains ForgeEventKinds.FoldersProposed/FoldersConfirmed, ForgeFolder, ForgeClient.SendFolders, ForgeSessionModel.ProposedFolders/FoldersPending/Folders/ AcknowledgeFolders. Removed, no shim: FolderPolicy, CreateTeamViewModel.FolderPolicy, FolderPolicyChoices, StepOneRows, HasStepOneRows, NewRootName, NewRootIsReadWrite, AddNamedRootCommand, CanAddNamedRoot, NamedRoots, and the strings Studio.Create.QFolders/FoldersExisting/FoldersInside/FoldersLater/ReadRootTitle/WriteRootTitle/ FoldersPolicyHint/AddRootHint/AddRootWrite/AddRoot/PrecisionsTitle/PrecisionsSub in the five languages; the capture stops etape1-dossiers-existants/-equipe became dossiers-proposes.

Changed — the team-creation wizard's step 1 asks for the need only

Step 1 asked four things before « Compose the team » woke up: how often, where the information lives, what the team must produce, and « describe that result » (STUDIO-45). The frequency only ever reached the brief's text — the adoption step schedules — and the other two are what the assistant's conversation exists to settle.

  • Step 1 is the need (and, until STUDIO-46 just above, where the folders live). « Compose » is live as soon as the need is typed; the brief the engine receives is the need plus the standing instruction, and the session is named after it.
  • The forge asks only what the need leaves unsaid (forge-assistant.ork.js): a question about what comes in or what comes out only when the request does not say it, zero questions is a good result, and never a question about frequency. « Three to five questions is the norm » is gone.
  • The recap reads the validated brief. « What comes in » and « What comes out » come from the forge's brief (inputs, expectedOutput, now read by ForgeSessionModel.BriefInputs / BriefOutput); the « Rhythm » row is gone.
  • Removed, no shim: CreateTeamViewModel.FrequencyChoices, SourceChoices, OutputChoices, Outcome, OutcomeRequired, and their strings (Studio.Create.QFreq/QSource/QOutput, Outcome*, Freq*, Source*, Output*, BriefFrequency/Source/Output/Shape, HintOutcome, Studio.Chat.FactRhythm) in the five languages. Studio.Create.HintAnswers became HintAssistant — with the need typed, only the assistant's model can still be missing.

Fixed — a remembered API key is recognised by Studio the first time, and a failed write shows

« Remember the key », then « Save », then back to the profile: the screen said « no key detected » and the gesture had to be repeated (STUDIO-44). The key was in the user scope (HKCU\Environment), but Studio read only its own process environment — stale whenever Studio was started by a terminal, an IDE or a launcher older than the key; and a user-scope write that threw left the process unwritten, with the error swallowed.

  • Read: the process, then the user scope. EnvironmentApiKeyStore.Peek falls back to the user scope and copies a key found there into the process, so every child Studio spawns inherits it.
  • Write: the process first, the user scope off the interface thread. IApiKeyStore.Save is now SaveAsync: the key is in place for the session when it returns, and the task faults if the user scope refuses it. The editor, the key row and the profile list say so, in the five languages (Studio.Settings.KeyPersistFailed); the session keeps its key.
  • Launches resolve the key through the store. A team run and the creation assistant lay ORKEON_Llm__ApiKey from ModelProfilesViewModel.LaunchEnvironmentOf, no longer from Studio's process block alone.
  • The scope access sits behind a new port, IEnvironmentVariables (SystemEnvironmentVariables).

Fixed — Studio's connection test waits 30 s, exercises the profile, and says why it failed

The « Test connection » button of a model profile gave up after 5 s with « no answer within 5s », and only asked the host for its model list: a Z.AI profile failed on a slow first request, and looked as if « Thinking: off » were to blame when the setting never reached the request (STUDIO-43).

  • 30 s, or the profile's timeout when it is shorter (LlmProbeRequest.TimeoutFor).
  • Two steps. After GET /models, a minimal completion (max_tokens 16, one « ping ») on the profile's model with its thinking switch, written per dialect from each provider's declared thinking level (LlmProbeDialect, pinned against the real providers). A model that does not exist, or refuses « Thinking: off », now fails the test at that step. It costs a few tokens.
  • A diagnostic. The verdict is a structured LlmProbeResult (Stage, Url, Elapsed, StatusCode, Detail, Failure) worded in the interface's five languages by LlmProbeText: the step, the URL called, the time waited, the HTTP status and the start of the body, or the exception down to its innermost cause. The key never appears, not even in the URL.
  • The screen follows. « Testing the connection… » and a disabled button while it runs; changing the thinking switch, the model or the URL clears the previous verdict instead of leaving it under the new setting until the editor is reopened. The Llm section and the orkeon-studio-config TUI run the same two steps.

Added — one LLM provider per agent: named profiles in the host configuration [breaking]

A host talked to one provider, the one its Llm section described; every agent of every crew went through it, and a crew mixing a Claude planner and DeepSeek writers needed two hosts or an aggregator (GAP-17).

  • Named profiles. Each child of Llm:Profiles:<name> is a provider described with the keys of the Llm section (BaseUrl, ApiKey, Model, Temperature, MaxTokens, TimeoutSeconds, MaxRetries, Thinking, Grammar); the Llm section stays the default profile. orkeon run, orkeon-host and the REPL read them (AddOrkeonLlmProfiles(configuration); AddOrkeonLlmProfile(name, provider, baseConfig) registers one over a provider the factory does not build). Each profile's provider is built once, on first use, metered like the default one. The profiles are validated at startup: default is reserved, an invalid BaseUrl or a value that is not a number fails the start naming the key.
  • A crew names a profile, never a key or an endpoint. YAML: llm: { profile: claude, model: … } at crew level, on an agent, or in a task's llm_override (that task only; profile: default returns to the default). .ork.ts: agentBuilder().llm(llm.profile("claude", overrides?)); a procedural agent configured with it has ctx.llm talk to that profile's provider. A response_format or a thinking block is checked against the agent's own provider.
  • An unknown profile fails the crew load, like an unknown tool, and the message lists the profiles the host offers. orkeon-host decides which profiles its third-party crews may name: Orkeon:Host:LlmProfiles is an allow-list (unset offers them all, ["default"] the default alone; an entry naming an undefined profile refuses the start with exit code 78).
  • The meter follows the provider. Each cost.updated reading already named its call's provider; Studio's status bar now breaks the run's tokens down per provider when there are several. The hierarchical manager, the planner, the Guardian, the RAG pipelines and the LLM judges stay on the default profile.
  • Fixed: an agent's llm: block reaches the agent. CrewFactory built every agent without the LlmConfig the YAML or .ork.ts mapping had produced, so a per-agent model, temperature, token cap, thinking block, response format or cache request never reached the wire under orkeon run — every agent ran on the host's settings. A block that names no model now runs on its profile's own model (LlmConfig.OnProfile, empty Model) instead of pinning the framework's default model on whatever vendor the host runs; CrewValidator accepts an empty model.
  • Removed: the provider pre-validation of CrewConfigurationMapper.ToDomainCrew, which built a provider per agent and threw it away; its ILlmProviderFactory parameter is now ILlmProfileRegistry? llmProfiles, and the mapper checks the profile names instead.

Migration: a caller of CrewConfigurationMapper.ToDomainCrew(toolResolver, llmProviderFactory, …) passes the host's ILlmProfileRegistry (or null) in place of the factory. A crew whose agents declared an llm: block now runs with it: check the models those blocks name — they reach the provider for the first time. A crew that mixed providers by running one host per provider moves the providers into Llm:Profiles and names them per agent.

Fixed — small corrections: the planner warning, ORKVFS005, WithOrkeonSetting, the Sonar scripts; three dead surfaces removed [breaking]

A handful of messages, comments, scripts and tests taught something the code does not do (GAP-16).

  • The stub-planner warning advises the order that works. It said to register your own IAgentPlanner before AddOrkeonApplication; that registration loses, because AddOrkeonApplication adds the stub without TryAdd and the last registration wins. It now says after, as default-behaviors.md already did.
  • ORKVFS005 names a service that exists. Its message sent you to "IVirtualFileSystemWatcher via IFileSystemService", which exposes no watcher; it now says to inject IVirtualFileSystemWatcher and consume WatchAsync. The rule id is unchanged. Both copies of SuppressVfsComplianceAttribute document the seven rules (ORKVFS001..007) and the ratified reason categories; a test now refuses a [SuppressVfsCompliance] reason in src/ that does not start with EXCEPTION-BOOTSTRAP, EXCEPTION-WATCHER-BRIDGE or OUT-OF-SCOPE (four Studio capture reasons had none).
  • WithOrkeonSetting takes the full configuration path. Its documentation and the Aspire test now say so: orkeon-host's run timeout is WithOrkeonSetting("Orkeon:Host:RunTimeout", …) (ORKEON_Orkeon__Host__RunTimeout). The test used "Host:RunTimeout", a key the host never reads. The method itself is unchanged — Llm:* stays at the root.
  • scripts/sonar-analyze.sh and .ps1 run the unit and fast suites only, with the filter of coverage.yml (Category!=Integration&Category!=Slow). They used to run the whole solution, Testcontainers included — Docker and gigabytes of images on a local analysis — and swallow the failures; the local coverage figure now has the same scope as the published one (quality-gate.md §7).
  • Contributors: the pull-request template asks for dotnet build Orkeon.sln -warnaserror, the command CI runs; examples/INDEX.md lists the six folders it missed (quickstart/, crew-multifile/, appsettings/, aspire/, interop/, forge/).
  • Removed (no caller): Orkeon.Application.Interfaces.IConsensualProcessStrategy — nothing resolved it; ConsensualProcessStrategy.ExecuteConsensualAsync stays on the class, and ProcessStrategyFactory keeps routing ProcessType.Consensual through IProcessStrategy; Orkeon.Application.Configuration.ConfigurationVersionMetadata, used by its tests alone; the internal AggregateEventHelper.
  • Docs: the long-form rag: example of the YAML schema page (EN and FR) no longer shows provider:, the key GAP-02 removed.

Migration: a host that resolved IConsensualProcessStrategy resolves ConsensualProcessStrategy instead (same scoped instance as before); one that used ConfigurationVersionMetadata declares its own record.

Changed — Evaluation:EnableLlmJudge is read; the Resilience section and the dead RaggableTree keys are gone [breaking]

Three configuration sections were bound, sometimes documented, and acted on nothing (GAP-15). "Resilience": { "LlmMaxRetries": 1 } left LLM calls retrying ten times; "Evaluation": { "EnableLlmJudge": true } with AddOrkeonInfrastructure(configuration) left the judges out of the suite — and calling AddOrkeonEvaluation(configuration) as the docs advised did not help either (the unconfigured call had already registered a closed IOptions) while it registered every evaluator a second time; "RaggableTree": { "Exclude": ["vendor"] } still indexed vendor/, because every index_codebase call sets its own exclusions.

  • Evaluation is wired. AddOrkeonInfrastructure(configuration) binds the section, and EnableLlmJudge = true puts the coherence, fluency and groundedness judges in the default IEvaluationSuite, over the registered IChatClient (none registered: resolving the suite fails, naming the setting, instead of leaving the judges out). AddOrkeonEvaluation is idempotent — a second call binds the configuration and registers no evaluator twice. The judges no longer appear as IEvaluator registrations; the placeholder evaluators that stood in for them when disabled are gone. Removed: EvaluationOptions.DefaultRunsPerCase and RegressionThreshold, which nothing read.
  • Resilience is removed. ResilienceOptions and its binding are gone, with the ResiliencePolicies helpers no component called — GetRetryPolicy, GetCircuitBreakerPolicy, GetTimeoutPolicy, GetCombinedPolicy, GetDatabaseRetryPolicy. The LLM policy (GetLlmApiPolicy, budget Llm:MaxRetries, timeout Llm:TimeoutSeconds) and the Redis policy (GetRedisRetryPolicy, three attempts) stay.
  • RaggableTree carries Enabled and Embedding, nothing else. The runner refuses to start on any other key of the section, naming it. Removed from RaggableTreeOptions: Languages, Exclude, RootAlias, IndexMode, EnrichWithLlm, IncludeStatements, VectorStore, Cache, with the types RaggableTreeIndexMode, VectorStoreKind, VectorStoreOptions and CacheOptions. A Summarizer.Provider other than None now registers the LLM summarizer on its own; each call still chooses with enrich_with_llm.
  • index_codebase declares what the build reads. include_statements, summarizer_model, summarizer_max_tokens and summarizer_concurrency are removed from IndexCodebaseRequest: statements were always extracted, and the summarizer settings were never read. An agent that still sends one is not refused — the argument is ignored.
  • Docs: the configuration reference, the security page's Resilience section, the RaggableTree architecture page, the opt-in catalog (EN and FR) and the RaggableTree crew-YAML example say what is read; the limitations bullet about the Resilience section is gone.

Migration: replace Resilience:LlmMaxRetries/LlmTimeoutSeconds with Llm:MaxRetries/ Llm:TimeoutSeconds, and delete the other Resilience keys; a host that used the removed ResiliencePolicies helpers builds the same Polly policies itself. Delete Evaluation:DefaultRunsPerCase/RegressionThreshold. Move RaggableTree:Exclude/RootAlias into the agent's index_codebase arguments (exclude, root_alias) and delete IndexMode, EnrichWithLlm and IncludeStatements from the section; C# hosts drop the removed RaggableTreeOptions members and set Summarizer alone to enable enrichment.

Removed — the Flows subsystem (FlowEngine, flow steps, flow YAML) [breaking]

Nothing ran a flow: orkeon run treats every YAML file as a crew, and no host, CLI or .ork.ts binding reached IFlowEngine. The C# API itself misbehaved — a crew step given a crew's id launched a random one and reported a failed crew as a success, a flow's timeout_seconds cut nothing, a backward NextStep looped forever, and GetFlowMetrics(name) compared the name with the id (GAP-05). The executable surfaces already cover the need: a .ork.ts script chains crews, LLM calls, tools and conditions in real code under orkeon run (with --events), and the Graph process mode runs bounded cycles behind a circuit breaker. The flows are removed rather than mended.

  • Removed: the Orkeon.Domain.Flows namespace (IFlow, IFlowStep, IFlowDefinition, FlowStep, FlowState, FlowStepParameters, FlowConfigurationSettings, FlowResult, FlowStepResult, FlowExecutionResult, the [Flow]/[Start]/[Listen]/[Router] marker attributes, the flow event types…), FlowId, FlowStepId and FlowEventId; IFlowEngine with FlowValidationResult and FlowMetrics, IFlowStepExecutor, FlowDefinitionBuilder/FlowStepBuilder (Orkeon.Application.Flow); the whole Orkeon.Infrastructure.Flows namespace — FlowEngine, DefinitionBasedFlow, FlowStepExecutor, YamlFlowDefinitionLoader, InMemoryFlowDefinition, FlowStepBase<TInput, TOutput>, the six steps (CrewFlowStep, LlmFlowStep, ToolFlowStep, ConditionalFlowStep, HumanInputFlowStep, DelayFlowStep), FlowExecutionTracker and FlowGraphSerializer; AddOrkeonFlows() and AddOrkeonFlowVisualization(), which AddOrkeonInfrastructure() no longer calls; OrkeonApplicationOptions.EnableFlowPersistence (read by nothing).
  • The flow usage operation is gone. LlmUsageOperations.Flow and its Studio mirror RunCostOperations.Flow are removed: a cost.updated reading never carries operation: "flow".
  • Examples no longer claim FlowEngine. 26, 29, 59, 61, 76, 83, 90 and 100 said a flow engine drove their cycles, and 60, 96 and 98 listed IFlowEngine as a key feature; they are sequential crews (97 consensual), and their titles, goals, backstories and READMEs now say what one run does.
  • Docs: the Flows page (EN and FR) and its entries in the table of contents, the index, the process-types guide, the opt-in catalog and the limitations page are removed.

Migration: a flow becomes a .ork.ts script — each step a crew.run(), ctx.llm.* or tool call, conditions and loops in plain code — run by orkeon run; a cyclic crew uses process: graph. Delete calls to AddOrkeonFlows()/AddOrkeonFlowVisualization() and any EnableFlowPersistence setting. A cost report grouping by operation drops its flow bucket.

Changed — orkeon-host connects its MCP servers and routes chat by room; the tool registry ships in Orkeon [breaking]

The same MCP:Servers gave orkeon run the servers' tools and orkeon-host none; every chat message reached the first hosted crew; a host built on the Orkeon package resolved no YAML tool name, because the DI-backed registry lived in the unpublished Orkeon.Hosting; and the EventHub tools swallowed metadata and returned identifiers they made up (GAP-11).

  • orkeon-host connects the MCP:Servers at startup, through the runners' own step, from its first hosted service (McpConnectionService): the servers' tools are in the registry before the channel can deliver a message, and the servers disconnect after the drain. An unreachable server costs one error line, and the daemon starts without it.
  • Chat is routed by room. Orkeon:Host:Discord:Routes maps a Discord channel id to a hosted crew: a thread opened in that channel starts that crew, and any other thread starts Orkeon:Host:Discord:DefaultCrew — the first declared crew when unset. One thread is still one run. A route to an undeclared crew, a route key that is not a channel id, an unknown DefaultCrew, or two hosted crews with one name refuse the start (exit 78); a crew no room reaches is named by a startup warning.
  • ToolRegistry (Orkeon.Infrastructure.Tools) is the default IToolRegistry that AddOrkeonInfrastructure() registers: seeded from every IBaseTool in DI, concurrent, a duplicate DI name fails its construction with both types named, and RegisterToolAsync still refuses a name another tool holds. The runners use it as they are; ServiceProviderToolRegistry (Orkeon.Hosting) and the empty InMemoryToolRegistry stub are removed.
  • An agent's own tool instance wins over a registered tool of the same name (TaskToolbelt.Compose): an agent built in C# with its own rag_search calls it, not the host's. The registered tools still supply human_input.
  • EventHub: nothing given is swallowed, no identifier is invented. post_message and send_request deliver their metadata into the envelope the recipient reads; IEventHub.PostAsync and SendAsync take a MailboxOptions (with Metadata) before the CancellationToken. PublishAsync and PostAsync return the message's MessageId, which publish_event's event_id and post_message's message_id now are; send_request no longer returns a correlation_id. The run event bus's hub.message gains messageId? and metadata?. post_message and MailboxAddress document the fourth scheme, client://.
  • Removed, never answering: IToolRegistry.GetToolsByTagsAsync and GetToolsByCapabilityAsync (always empty — no tool carries tags or capabilities), and McpServerOptions.ExposeResources/ExposePrompts (read by nothing; the MCP server exposes tools only).

Migration: delete services.AddSingleton<IToolRegistry, ServiceProviderToolRegistry>() — and any loop feeding the registry from GetServices<IBaseTool>() — AddOrkeonInfrastructure() covers it. Callers of IEventHub.PostAsync/SendAsync pass options: null (or a MailboxOptions) before the token; an IEventHub implementation returns the MessageId from PublishAsync/PostAsync. Drop MCP:Server:ExposeResources/ExposePrompts from settings, and any call to the two registry lookups (filter GetAllToolsAsync() yourself). A Discord deployment hosting several crews adds Routes (and, if the first crew should not be the default, DefaultCrew).

Changed — a run dispatches the crew's domain events, and ICallbackHandler sees every tool call [breaking]

An IDomainEventHandler<CrewExecutionCompletedEvent> registered in DI was never called by a kickoff, the domain callbacks were never invoked, and ICallbackHandler received task notifications only (GAP-06).

  • The end of a kickoff dispatches the crew's domain events through IDomainEventDispatcher — on success, failure and cancellation — then empties the aggregate, so a second kickoff never dispatches them again. KickoffForEachAsync, KickoffAsyncNoWait and both paths of KickoffStreamingAsync go through the same point. A run delivers the construction events still queued (CrewCreatedEvent, …), then CrewExecutionStartedEvent, then CrewExecutionCompletedEvent or CrewExecutionFailedEvent. A handler that throws is logged and skipped: the CrewOutput and the run's error are unchanged. SequentialCrewOrchestrator takes an IDomainEventDispatcher after its IExecutionPlanParser. DomainEventDispatcher is now scoped, so the scoped handlers resolve from the run's scope rather than the root provider.
  • ICallbackHandler receives a step per tool call. OnStepStartedAsync before each call of the agent loops (chat-client, native, text, streaming), OnStepCompletedAsync after it, with the tool's raw result and Success = false when the tool failed, threw or was blocked by the guardian. StepNotifyingToolInvocationPipeline wraps the tool-invocation point; ExecutionOrchestrator.Callbacks (set by AddOrkeonApplication()) and an optional ICallbackOrchestrator on StreamingAgentExecutionService feed it. ICallbackOrchestrator gains NotifyStepStartedAsync / NotifyStepCompletedAsync.
  • Removed, never raised: AgentSpawnedEvent, CrewCompletedEvent, TaskBlockedEvent, TaskUnblockedEvent, TaskDelegatedEvent, DelegationCompletedEvent (with its Orkeon.Domain.Delegation.Events.DelegationOutcome), DelegationQueuedEvent, AgentRegisteredForDelegationEvent, AgentUnregisteredFromDelegationEvent, HumanInputRequestedEvent, and TaskContextUpdatedEvent with TypedTaskContext<T>.GetEvents() / ClearEvents(). 33 domain events remain, each raised by its aggregate.
  • Removed, never invoked: IStepCallback, ITaskCallback, IStepProgressHandler and StepProgressContext; Agent.StepCallback, Crew.StepCallback/TaskCallback, CrewTaskBase.Callback, their *CreateOptions/*Snapshot/TaskOutputOptions members and the matching parameters of Agent.Create, Crew.Create and CrewTask.Create; AgentBuilder.WithStepCallback, CrewBuilder.WithStepCallback/WithTaskCallback, CrewTaskBuilder.WithCallback; NullStepCallback, NullStepProgressHandler, NullTaskCallback. From ICallbackHandler: OnTaskProgressAsync, OnFlowStepStartedAsync, OnFlowStepCompletedAsync and their TaskProgressContext, FlowStepStartedContext, FlowStepIdentity, FlowStepCompletedContext. From ICallbackOrchestrator: the CallbackHandlers parameter (always null) and class, NotifyStepProgressAsync with StepProgressInfo; CallbackOrchestrator.NotifyToolUsedAsync/NotifyDelegationAsync; TaskCallbacks and CallbackExamples (with CustomWorkflowCallbackHandler).

Migration: an IStepCallback or ITaskCallback becomes an ICallbackHandler (derive from BaseCallbackHandler) registered in DI — OnStepStartedAsync/OnStepCompletedAsync per tool call, OnTaskStartedAsync/OnTaskCompletedAsync per task — or an ICrewExecutionHook for task and crew outcomes; drop the With*Callback builder calls. Code constructing SequentialCrewOrchestrator by hand passes an IDomainEventDispatcher. A handler of a removed event has nothing to handle and is deleted.

Changed — a task's tools: reach its agent; the task state machine and circuitBreaker: are gone [breaking]

Three task YAML fields were read, validated and dropped, and two families of types had no consumer (GAP-07).

  • A task's tools: add to its agent's tools, for that task only. They never replace them. CrewFactory resolves them like an agent's — same registry, same StrictTools check, so an unknown name now fails the load — and the task carries them (CrewTask.Tools, CrewTaskBuilder.WithTool(s)). One composition, TaskToolbelt.Compose (agent ∪ task, one tool per name, then human_input when the task asks for it), feeds the three agent loops, the streaming path, the prompt's tool list and the guardrails' tool rules, so human_input now reaches the native and text loops too. The .ork.ts taskBuilder().tools([...]) takes the same path. CrewConfigurationMapper exports a task's tools.
  • circuitBreaker: is removed and refused at load, at the crew root and on a task, with a message naming graphConfig. The task block configured TaskExecutionStateMachine, which no execution path ran; its three guard limits were read by nothing; the crew block was read by Graph alone, where graphConfig carries the same settings. A task is bounded by its agent loop (maxIter, the stop on identical tool errors, the output-validation retries). Removed: TaskExecutionStateMachine, TaskExecutionState/TaskExecutionEvent, TaskExecutionGuardContext, CircuitBreakerConfig, CircuitBreakerYamlConfig, Crew.CircuitBreaker, CrewBuilder.WithCircuitBreaker, the CircuitBreaker members of CrewConfiguration/TaskConfiguration/CrewCreateOptions/CrewMappingSettings, and CircuitBreakerPolicyFactory.Resolve/CreateTaskFsm/CreateGuardContext; ResolveGraph(graphConfig, fallback) lost its crewDefault. The generic StateMachine<,> engine and CircuitBreakerPolicy stay (forge, Graph, the corrective RAG graph). Example 103, which existed for the task FSM, is deleted; 102 covers its scenario.
  • Dead duplicates removed. Orkeon.Application.Configuration's second configuration model (ImmutableConfigurations.cs: CrewConfiguration, AgentConfiguration, TaskConfiguration, LlmConfiguration, MemoryConfiguration, RetryConfiguration, ValidationResult, a four-value ProcessType, VerbosityLevel, AgentType, TaskPriority) and its builders (ConfigurationBuilder.cs) had no consumer. Orkeon.Application.Execution.MemoryType and Orkeon.Domain.Agent.MemoryType are gone: AgentMemory.Type is Orkeon.Domain.Memory.MemoryType, the one enum left. TaskConfiguration.TimeoutSeconds, which nothing set or read, is removed, and TaskConfiguration.RequiredTools is renamed Tools.
  • C#: CrewTaskBase.RequiredTools/AddRequiredTool(ToolId), CrewTaskBuilder.RequiresTool and CrewTaskSnapshot.RequiredTools (opaque ids nothing filled) become Tools/AddTool(IBaseTool), WithTool/WithTools and CrewTaskSnapshot.Tools. GuardrailsPromptRenderer.AppendAgentAndTaskGuardrails takes the task's toolbelt.

Migration: delete every circuitBreaker: block; on a process: graph crew, move preset, maxTransitions, maxStateVisits and maxTotalDurationSeconds into graphConfig (circuitBreakerPreset, same names for the rest). A crew that listed a tool on a task and also on its agent to make it work can drop the agent's copy. Code using the removed configuration builders builds Orkeon.Domain.Configuration.CrewConfiguration (or uses CrewBuilder).

Changed — the scripting toolchain: Orkeon:Scripting:Toolchain is read, the typings ship with the tool [breaking]

Four defects of the DSL tooling (GAP-13), all between what the docs promised and what ran.

  • Orkeon:Scripting:Toolchain is read. No host bound it: EsbuildPath was the first place the lookup claimed to search (the error message cited it) and EsbuildTimeout could not be changed. Every host now builds its transpiler with EsbuildTranspiler.Create(configuration) (ScriptingToolchainOptions.FromConfiguration): orkeon run, the shared runner, orkeon doctor, orkeon forge (its esbuild probe and its trial) and the REPL's *.cmd.ts loader. RunnerSettings.ReadConfiguration(settingsPath) gives a CLI path the settings file plus the ORKEON_* variables before a host exists.
  • orkeon typings writes the editor typings. orkeon.d.ts (the DSL) is embedded in Orkeon.Scripting by its build and orkeon-cli.d.ts in the orkeon tool; the new verb writes both into ./.orkeon/ (--out <dir>), overwriting what is there. A dotnet tool install user had neither. The pack item of the non-packable Orkeon.Scripting and the orkeon-cli.d.ts resource of Orkeon.Cli.Commands.Scripting, which nothing read, are gone. The dotnet tool still does not ship esbuild — the docs and orkeon doctor now say so and say how to get it (npm install -g esbuild, ORKEON_ESBUILD_PATH or EsbuildPath).
  • orkeon forge --events no longer swallows the need. The option takes a value only when it is jsonl: orkeon forge --events veille des prix forges "veille des prix" (it used to send "des prix"). Studio's --events jsonl is unchanged.
  • ctx.command.rawInput is the line the user typed (/deploy prod --force), not the command's name; a completed replay reads the line that launched its ticket.
  • orkeon-cli.d.ts declares what the runtime serves. runCrew returns CrewRunOutput (not a Promise — .then on it threw), "configuration" is no longer listed as a service key, services.get("commands") / get("script-host") are typed, and an args schema gives the handler typed arguments (they were unknown). scripts/check-scripting-typings.sh now typechecks every examples/**/*.cmd.ts against it.
  • C#: ScriptServiceKeys.Configuration (reserved, never served) is removed.

Migration: replace runCrew(...).then(f) with f(runCrew(...)) (an await keeps working). A host that used ScriptServiceKeys.Configuration to add a filtered view writes the key "configuration" itself. A script that read the command name in ctx.command.rawInput reads ctx.command.name. Run orkeon typings instead of copying the .d.ts files from a clone.

Changed — the .ork.ts typings and the runtime describe one DSL [breaking]

The declarations in Typings/*.d.ts and the Jint runtime had drifted apart in three ways (GAP-12): code typed correctly failed (err instanceof ReceiveTimeoutError threw a ReferenceError, ctx.send("writer", m) was refused, agent.role was undefined), code typed correctly was ignored without a word (.llm("gpt-4o"), { temperature: 0 } on a ctx.llm call, crew.run({ inputs }), withTask(b => …), withTaskTool), and code that worked was refused by the typechecker (withResponseFormat, withResponseSchema, crew.findById, ctx.crew). ctx.llm.act did not offer the agent's withAutonomousTool instances to the model, which example 09 and the guide asked it to call.

  • One honest llm surface. llm.default_ is the host's provider on its configured model; llm.model(name, overrides?) is the same provider on another model. The eight per-vendor factories (llm.openai() … llm.mammouth()) are removed: an agent always talks to the host's provider, and llm.anthropic() on an OpenAI host sent claude-haiku-4-5 to OpenAI. Orkeon:DefaultLlmProvider, which only renamed that provider, is removed with them, and so is the llm.default alias. LlmConfig.with(...) applies model, temperature, maxTokens and responseFormat and refuses any other key (baseUrl, which nothing applied, included).
  • Nothing a script passes is dropped any more: it is applied or refused at the call. .llm(...) refuses anything but an LlmConfig; withAgent(s) / withTask(s) refuse a builder callback or a plain object; withAutonomousTool(s) refuses anything but a toolBuilder() tool.
  • act runs the agent's tool instances. ctx.llm.act offers the withAutonomousTool instances next to the .tools([...]) built-ins; the loop posts each call to a JS pump in the act trampoline, which runs the tool's execute on the engine's thread and hands the result back — through the permission gate and the host's tool-invocation pipeline like any tool.
  • The error classes are real. errors.d.ts's classes are planted as globals and a host error is an instance of its class, with its fields (agentName, timeoutMs, dimension…), plus clrType and clr — including a rejection from queue.pop, ctx.receive and act. BudgetExhaustedException is declared as BudgetExhaustedError.
  • By name. ctx.send, ctx.delegate, crew.remove and crew.has take an agent or its name. ctx.delegate now runs exactly as crew.runAgent: the delegated body gets its own context, its semaphore and its onError policy (it used to receive no ctx).
  • Smaller fixes. agent.role; ctx.log.info(message, ...args) writes every argument; withTaskTool is removed (nothing read it).
  • The typings say what the runtime does: ErrorCode lists the codes the mapper produces (ErrorCodeMapper.CodeToolError, CodeLlmError and CodeLockTimeout, never produced, are removed), ErrorContext is { code, message, exception, attempt, agent }, LlmCallOptions is { responseFormat, llm: { model } }, ChatResponse is { content, tokensUsed, model }, act resolves to { output, iterations }, runStream emits agent.start / agent.stop, CrewRunOptions has no inputs, PublishedEvent has no publisher and EventTopicOptions no maxHandlers; withResponseFormat, withResponseSchema, crew.agents, crew.findById, ctx.crew, ctx.stateWith and receive({ timeout }) are declared.
  • Two gates. TypingsRuntimeParityTests compares each declared interface with its runtime type, member by member; scripts/check-scripting-typings.sh now typechecks every .ork.ts under examples/, not only examples/scripting/.
  • C#: JsEngineFactory and LlmNamespaceBinding.Register lose their IConfiguration parameter; JsCrewBuilder.withAgent, JsExecutionContext.delegate/send/receive and JsEventQueue.pop change shape (JS-facing).

Migration: replace llm.openai({ model: "x" }) (and its siblings) with llm.model("x"), and llm.default with llm.default_; delete Orkeon:DefaultLlmProvider from configuration — choose the provider with the host's Llm section. Replace .llm("x") and .llm({ provider, model }) with .llm(llm.model("x")). Build agents and tasks before withAgent / withTask; pass withAutonomousTool a toolBuilder() tool and built-in names to .tools([...]). Replace withTaskTool(t) with .tools([t]). Read act's answer on .output; an onError handler reads err.message and err.agent.name (not err.error / err.agentName). Catch BudgetExhaustedError, not BudgetExhaustedException. A C# host drops the configuration argument of new JsEngineFactory(...).

Changed — grammar reaches only an endpoint configured for it, and Ollama refuses audio [breaking]

A structured_output deliverable put a GBNF grammar field on every request to the OpenAI-compatible providers — a field no vendor API documents — without a word, while Ollama sent it on /api/generate and silently left it off /api/chat. On a cloud provider nothing constrained the output: the only guard was the JSON parse after the fact. Ollama also dropped audio and file parts and sent the text alone, where OpenAI and Anthropic refuse them (GAP-14):

  • grammar is a capability the configuration switches on. LlmProviderCapabilities.GbnfGrammar is declared by no provider; Llm:Grammar: true (LlmConfig.GrammarEnabled, read by the runner host and the REPL) turns it on for a llama.cpp-compatible server — Docker Model Runner, llama-server — behind the OpenAI-compatible providers or Ollama. Without it, both payload builders of OpenAICompatibleProviderBase, both Ollama endpoints and Anthropic drop the grammar with a structured warning (event id 110) naming the key. Anthropic never takes it.
  • structured_output uses json_schema on a provider that declares it. The deliverable's schema now also travels as a non-strict json_schema response format (LlmChatOptionsKeys.StructuredOutput); the chat-client adapter sends the grammar to an endpoint configured for it, the schema to a provider whose ResponseFormat is JsonSchema, never both, and a response format the crew set itself still wins. StructuredOutputResolver keeps parsing the answer.
  • Ollama refuses audio and file parts. ContentConverter.ToOllamaMessage throws NotSupportedException, like the OpenAI and Anthropic converters, and any non-text part routes the conversation to /api/chat (buffered or streamed), so nothing is flattened away on /api/generate first.
  • Removed: MultiModalOptions.AutoResizeImages and MaxImageDimension (nothing resized an image) and LlmLoggingExtensions.AddLlmExchangeFileLogging (no caller, and it registered neither LlmLoggingOptions nor the options singleton the RaggableTree embedding client reads).
  • A provider declares its capabilities by overriding HttpLlmProviderBase.DeclaredCapabilities; Capabilities is no longer virtual — it is the declaration plus the configured grammar switch.

Migration: a setup that relied on grammar against a llama.cpp server sets "Llm": { "Grammar": true }. A message with an audio or file part sent to Ollama now fails: send text and images only. Delete Orkeon:MultiModal:AutoResizeImages and MaxImageDimension from configuration; replace AddLlmExchangeFileLogging(dir) with AddLlmExchangeLogging(dir, options). A custom provider deriving from HttpLlmProviderBase renames its Capabilities override to protected override LlmProviderCapabilities DeclaredCapabilities.

Fixed — an A2A task runs the agent it names, and the server starts with the host [breaking]

An A2A task submitted to an Orkeon server came back Completed with Task routed to agent 'Researcher' with input: … — no model call, no tool. The router matched the request's skillId against agent roles, substring included (writer picked Ghostwriter), while the agent card publishes the agent id as the skill id, so a peer that followed the card got Failed. Nothing started the server either: a host had to resolve IA2AServer and call StartAsync itself. A2A:Enabled and A2A:RemoteAgents were bound and read by nothing (GAP-10):

  • The router runs the agent. A2ATaskRouter picks the agent whose id equals the skillId exactly — the id of a skill on /.well-known/agent.json — and runs an ad hoc task built from input (its metadata become the task variables) through IAgentExecutionService, resolved in the request's scope. Completed carries the agent's output, Failed its error; a host without AddOrkeonApplication() gets Failed saying so, never a pretend success.
  • Cancellation reaches the agent. The server serves requests concurrently and runs each task under its own token: DELETE /a2a/tasks/{id} cancels a task the agent is still working on (the submitting request answers Cancelled, the record ends Cancelled), answers 409 for a finished task — whose record keeps its state — and 404 for an unknown one, store or not.
  • The server is hosted. AddOrkeonA2A with EnableServer registers a hosted service: a generic host starts the server with itself and stops it on shutdown. A start failure (a declared scheme without a validator, mutual TLS without a trust anchor) fails the host's start. Calling AddOrkeonA2A twice registers one server.
  • The client authenticates. A2A:Security:ClientAuthScheme (Bearer or ApiKey) and ClientCredentialSecretName make A2AClient send Authorization on every task call, the secret read through ISecretProvider (new optional secretProvider constructor parameter); a credential that cannot be read fails the call before anything is sent.
  • Removed: A2AOptions.Enabled (calling AddOrkeonA2A is the switch) and A2AOptions.RemoteAgents (no agent tool calls a peer; IA2AClient and IA2AAgentDiscovery remain for C# hosts).

No shipped binary enables A2A yet; exposing it in orkeon-host is a follow-up.

Migration: a peer sends the agent's id (the skill id from the agent card) as skillId, not its role. A host serving A2A also calls AddOrkeonApplication(), and drops its own IA2AServer.StartAsync/StopAsync calls when it runs the generic host. Delete A2A:Enabled and A2A:RemoteAgents from configuration. A client calling a server that declares AllowedAuthSchemes sets ClientAuthScheme and ClientCredentialSecretName.

Security — every agent turn runs through the Guardian, A2A tokens are validated, and no tool takes a key as an argument [breaking]

Six security surfaces were registered, configured — and called by nothing. Setting Orkeon:Guardian:DefaultPolicy:BlockedTools did not stop a call; a web page saying "ignore previous instructions" reached the model as it was; Security:ToolResults changed nothing; Orkeon:Auth:AzureAD authenticated nothing; the audit trail stayed empty, and the NIST report read it empty. image_generation took the OpenAI key as a call argument, so it travelled through the conversation, the tool-call log and the usage record. And A2A:Security:AllowedAuthSchemes = ["Bearer"] let Authorization: Bearer anything submit a task (GAP-09):

  • One invocation point for every tool call. IToolInvocationPipeline (ToolInvocationPipeline, registered by AddOrkeonApplication()) is called by the chat-client, native, text and streaming loops, the automatic-function-invocation path and ctx.llm.act. It chains the Guardian's tool phase (ToolGuard: path traversal, SSRF targets, SQL injection outside the *_query tools) — or, for delegate_work_to_coworker / ask_question_to_coworker, the delegation phase (DelegationGuard: depth, self-delegation, a target already in the chain of synchronous delegations) — then the call, the one truncation rule (AgentDefaults.ResolveMaxToolResultLength), the result sanitizer, and a ToolExecution audit event. A blocked call never runs; the model reads Error: Blocked by Guardian (…): <reason>.
  • The input phase screens the composed prompt — task, previous outputs, retrieved knowledge — before the first provider call. Under the default Security:Prompt:Policy, now Block, a High or Critical pattern fails the task with AgentExitReason.GuardianBlocked and the pattern named; a lower one is a logged, audited warning.
  • Tool results are tagged, never rewritten. Security:ToolResults:Policy (default Warn) is now read: the result reaches the model between DATA CONTEXT - NOT INSTRUCTIONS markers and each injection pattern leaves a SecurityEvent; Block withholds a High/Critical result and says so. The email_* tools are trusted by default — they screen what they read themselves (ADR-012).
  • The Guardian is on by default and never rewrites silently. Orkeon:Guardian:Enabled is the real switch. The Strip policy, which cut matched phrases out of what the model read, is gone: content passes unchanged, tagged, or is refused as a whole. The detection is tightened where it blocked honest prompts: "forget" followed by anything no longer matches (only forgetting the instructions does), "you are now going to…" no longer reads as an identity override, and the exfiltration phrases are Medium (reported, not blocked).
  • The audit trail is fed: a ToolExecution event per call (never the arguments) and a SecurityEvent per Guardian block or warning and per injection pattern in a result.
  • A2A credentials are validated. Bearer tokens go to the registered IAuthenticationProviders — AzureAdAuthProvider (A2A:Security:AzureAD, signing keys now read from the tenant's OpenID configuration) and OidcAuthProvider (A2A:Security:Oidc), registered by AddOrkeonA2A(configuration) for each filled section; ApiKey keys are read through ISecretProvider from A2A:Security:ApiKeySecretNames and compared in constant time. A rejected credential is a 401; a server that declares a scheme without a validator refuses to start. The validation is A2ACredentialValidator, public for other inbound surfaces.
  • image_generation reads OPENAI_API_KEY through ISecretProvider (ORKEON_OPENAI_API_KEY by default); a missing key fails naming the secret. web_search sends its Tavily key as an Authorization header instead of in the request body. No tool takes a secret as an argument any more — the rule is in New tool pattern.
  • Removed: OutputGuard (a second run of the output validation pipeline), PromptShieldBuilder (a second prompt composer), GuardianPipeline.AutoKillOnCritical, AuthenticationGuard, AddOrkeonAuth() and its call in AddOrkeonInfrastructure(), IAuthorizationPolicy with ClaimsAuthorizationPolicy and RoleBasedAuthorizationPolicy, ToolAccessGuard and its ToolAccessPolicyExtensions, GuardianPolicy.AllowedTools/BlockedTools/OutputGuardEnabled (tool access is ToolAccessPolicy), GuardianOptions.AuditEnabled/LogViolations, GuardPhase.Output, GuardAction.Modify, SanitizationPolicy.Strip, ToolResultSecurityOptions.MaxToolResultLength, A2AServer.IsAuthSchemeAllowed, the audit builders nothing called (LlmCall, FileAccess, HttpRequest, CrewLifecycle, LlmCallAuditInfo), ImageGenerationRequest.ApiKey, and Studio's "key given at the call" requirement (image_generation now lists ORKEON_OPENAI_API_KEY among the tool keys).

Migration: move Orkeon:Auth:AzureAD/Orkeon:Auth:OIDC to A2A:Security:AzureAD/A2A:Security:Oidc. Put the OpenAI key of image_generation in ORKEON_OPENAI_API_KEY (or Secrets:OPENAI_API_KEY) and stop passing api_key. Replace Security:Prompt:Policy/Security:ToolResults:Policy = Strip with Warn or Block, and Security:ToolResults:MaxToolResultLength with nothing (one rule bounds results). A server declaring AllowedAuthSchemes needs a validator: a bearer section or an IAuthenticationProvider, or ApiKeySecretNames. To block a tool, use ToolAccessPolicy rather than GuardianPolicy.BlockedTools. new ImageGenerationTool(fileSystem, …) takes an ISecretProvider second. GuardContext.TargetAgentId is TargetAgentRole, DelegationDepth is derived from DelegationChain. Where the default Block input policy refuses a legitimate task, set Security:Prompt:Policy to Warn.

Changed — memory providers connect from one host section each, and Redis works on first use [breaking]

No path to a remote memory provider produced one that worked. A crew with memoryProvider: "Redis" (seven examples) failed its first successful task: storing the result threw "Redis provider not initialized. Call InitializeAsync first.", and the task was reported failed. Memory:Provider = redis and AddOrkeonRedisMemory did the same, and so did Orkeon:Rag:Provider = redis. A crew's memoryProvider: carried the type alone, so "SQLite" (nine examples) was a :memory: database lost at the end of the run and "ChromaDb" targeted localhost:8000. The Orkeon:ChromaDb/Orkeon:Pinecone sections reached two concrete singletons nothing resolved, never the memory. Pinecone built an index host of the legacy {index}-{environment} form that no index has (GAP-08):

  • One host section per provider, and a type everywhere else. Orkeon:Redis (ConnectionString, KeyPrefix), Orkeon:Sqlite, Orkeon:ChromaDb, Orkeon:Pinecone and Orkeon:LanceDb are bound by AddOrkeonInfrastructure(). Memory:Provider, a crew's memoryProvider: and Orkeon:Rag:Provider only name the type; the connection is that provider's section, whichever path selects it. Secrets stay out of crew files.
  • Redis connects on first use. RedisMemoryProvider takes RedisMemoryOptions and opens its one ConnectionMultiplexer at the first call, safely under concurrent callers; an unreachable server is a RedisConnectionException on that call, retried on the next. AddOrkeonRedisMemory binds Orkeon:Redis. The connection log shows the endpoints, no longer the connection string (which may hold a password).
  • One instance per type, owned by the factory. IMemoryProviderFactory.GetProvider(type) hands every caller asking for a type the same provider — the application-wide one, every crew of that type, the RAG store (both of its resolutions) — and disposes it with the container. Two crews no longer open two connections, and a released crew no longer leaks one. Clearing a crew's provider-backed memory deletes only the entries it stored. SupportedTypes lists the aliases; the RAG store validates Orkeon:Rag:Provider against it instead of a copy.
  • ChromaDB, Pinecone and LanceDB take their client from IHttpClientFactory (a named client per provider). AddOrkeonChromaDb/AddOrkeonPinecone/AddOrkeonLanceDb expose the shared instance by its class.
  • Pinecone reaches the real index host: Orkeon:Pinecone:Host when set, otherwise the host returned by one describe_index call (GET https://api.pinecone.io/indexes/{IndexName}) made on first use.
  • Removed: Memory:ConnectionString; Orkeon:Rag:ConnectionString and Orkeon:Rag:ProviderOptions (RagStoreOptions keeps Provider), and the Studio field that edited the former; PineconeOptions.Environment; IMemoryProviderFactory.Create and CreateAndInitializeAsync, MemoryProviderConfigDto and MemoryProviderConfigDefaults; MemoryProviderBase.InitializeAsync, Configuration and ValidateConfiguration, and the Domain MemoryProviderConfig they carried (its RetentionPeriod and MaxItems were read by nothing). MemoryService no longer takes an ILoggerFactory.

Migration: move Memory:ConnectionString to the section of the provider it was for (Orkeon:Redis:ConnectionString, Orkeon:Sqlite:ConnectionString, Orkeon:ChromaDb:BaseUrl, Orkeon:LanceDb:Endpoint), and Orkeon:Rag:ConnectionString/ProviderOptions:* likewise. Replace Orkeon:Pinecone:Environment with Host (the host the Pinecone console shows), or drop it and let the provider look it up. Remove every InitializeAsync call on a memory provider. factory.Create(new MemoryProviderConfigDto(type, …)) becomes factory.GetProvider(type) — and the caller no longer disposes the result. new RedisMemoryProvider(logger) becomes new RedisMemoryProvider(Options.Create(new RedisMemoryOptions { … }), logger); new MemoryProviderFactory(fileSystem) takes an IHttpClientFactory and, optionally, the MemoryProviderSettings and an ILoggerFactory.

Changed — RAG runs under orkeon run crew.yaml, and knowledge attachments use their profile [breaking]

A YAML crew's rag: and knowledge: blocks did nothing under orkeon run: loading logged "declares a rag: block but the RAG subsystem is not registered", ingested nothing, and the agent answered without a single excerpt — nothing said so. The same held for a crew directory, --events, a declarative .ork.ts crew and orkeon-host. Even where the subsystem was registered, an attachment's profile, rag.defaults.profile, rag.provider and Orkeon:Rag:Collection were read and then ignored (GAP-02):

  • Every runner host registers the RAG subsystem and its tools. RunnerHost calls AddOrkeonRag + AddOrkeonRagTools, so orkeon run in all its forms and orkeon-host ingest a crew's rag: collections when it loads, inject its agents' knowledge: into their prompts, and let an agent list rag_search, rag_ingest or rag_eval in tools:. The CLI adds the ONNX reranker on every path (balanced/quality), not only for scripts. --validate still ingests nothing. The txt_search/mdx_search/pdf_search/ directory_search tools, which failed at every call in the runners for want of the subsystem, now search.
  • Nothing is resolved until a crew uses it. The bootstrapper, the knowledge augmenter, the three tools and the ephemeral search engine resolve the store, its provider and the embeddings at their first use: a crew without rag:/knowledge: loads no model for them, and an unknown Orkeon:Rag:Provider fails the first ingestion or retrieval, no longer every crew.
  • An attachment retrieves through its profile: its profile, else rag.defaults.profile (copied onto it at crew load), else Orkeon:Rag:Profile. The augmenter runs that pipeline's retrieval half (IRagRetrievalCapable) — hybrid and rerank as the profile says, never a nested generation. corrective and adaptive cannot retrieve alone and fail the task with a message saying so. min_score now filters on the score the profile reports (the cross-encoder's under a reranking profile).
  • Orkeon:Rag:Collection is the collection rag_search queries when the agent names none (else default), and the one rag_eval evaluates for a dataset that names no collection and brings no corpus (RagEvalRunRequest.DefaultCollection) — a corpus is never ingested into it.
  • An agent with knowledge: on a host without the subsystem gets a load-time warning, as a rag: block already did.
  • rag.provider is removed (RagCrewConfig.Provider, RagYamlConfig.Provider): the store is the host's (Orkeon:Rag:Provider). A crew that still writes it gets a warning at load.
  • KnowledgeContextAugmenter is built over an IRagProfileResolver and a default profile, and Citation.Content carries the full cited passage. AddOrkeonRagTools is idempotent.

Migration: delete rag.provider from your crews and set Orkeon:Rag:Provider in the settings instead. A host that called AddOrkeonRag/AddOrkeonRagTools in a RunnerHost configureServices can drop the calls; a double registered there still wins (last registration). new KnowledgeContextAugmenter(store, embeddings) becomes new KnowledgeContextAugmenter(profileResolver, defaultProfile). A crew whose attachments (or Orkeon:Rag:Profile) name corrective or adaptive must pick fast, balanced or quality for its knowledge.

Changed — the consensual vote weighs the answers [breaking]

A consensual crew's vote did not read what its agents wrote: every agent cast one ballot for itself. Three agents that gave the same answer never reached Majority, SuperMajority or Unanimity; BordaCount handed the task to the first agent declared, failed or not; and the AcceptBestScore and ManagerDecision fallbacks both re-ran the first agent, under a crew id that did not exist. The vote is now a vote on the answers (GAP-04):

  • Peer ballots: once every agent has answered, every agent ranks the other agents' answers, anonymised under labels A, B, … shuffled per task and round. It casts its ballot through its own execution (its LLM configuration, its tokens counted), as a JSON object. A reply that cannot be read counts as an abstention and never fails the task. The port is IBallotCollector (Orkeon.Application.Interfaces, default AgentBallotCollector); a host can register its own.
  • No vote for oneself, and a share is counted among the ballots that could name the answer (Vote.OwnChoice): three agents that agree reach every consensus type in round one. A tie at the top is no consensus, so two agents, who can only name each other, never decide by vote.
  • A failed execution is never a candidate. A lone successful answer is kept without a ballot; a round where every execution failed fails the task with the agents' error, without another round.
  • AcceptBestScore keeps the last count's leader and re-runs nothing. ManagerDecision asks the crew's manager agent (managerAgent, now kept on consensual crews) to rank the last round's answers; a crew without one is refused at kickoff, before any agent runs. A declared manager neither answers nor votes.
  • QuorumPercent and AllowAbstention are enforced: the quorum is the share of expressed ballots; with AllowAbstention: false an abstention counts against every answer. The dead copy VotingOptions.MaxVotingRounds is removed — Orkeon:Consensus:MaxVotingRounds is the one that counts.
  • The crew's input variables reach every execution and ballot; IConsensualProcessStrategy.ExecuteConsensualAsync takes them.
  • Cost: a round is N executions + N ballots; a task that agrees in round one costs 2N calls, one that never agrees MaxVotingRounds × 2N (+ one manager ballot).

Migration: remove Orkeon:Consensus:VotingOptions:MaxVotingRounds from your settings. With FallbackStrategy: ManagerDecision, declare a managerAgent. A consensual crew of two agents now always reaches the fallback: give it a third. new ConsensualProcessStrategy(...) takes an IBallotCollector after the voting strategy, and a positional CancellationToken passed to ExecuteConsensualAsync is now named (ct:).

Changed — a failed task fails the crew in all six modes [breaking]

Sequential was the only mode that failed a crew with a failed task (STUDIO-12 C5a, LLM-11). The five others reported success whatever their tasks did, so orkeon run exited 0, the run.finished event said success: true and AUTO_SUMMARY.md said completed over a half-wrong deliverable. The rule is now one type shared by the six strategies:

  • A failed task fails the crew: CrewOutput.Success is false, Error names every task that did not succeed and why, the execution hook hears Failed with that same reason, and orkeon run exits 2 with it as the last stderr line. The outputs and the tokens the crew did produce are kept.
  • A task whose dependency failed is skipped, as in Sequential: no agent runs it on a context that says Task failed: …, it shows ⊘ skipped, and it counts as a failure. The tasks that do not depend on it still run.
  • Hierarchical: a task the manager rejected three times ([NEEDS REVISION]), a worker that failed, and a task assigned to an agent the crew does not carry each fail the crew.
  • Parallel: a failed task no longer feeds its failure message to the next wave; its dependants are skipped.
  • Graph: a task still failing after its retries fails the crew — only the circuit breaker did. A failed task is now retried before the next task runs (it waited for the end of the queue), so a dependant only sees a dependency that succeeded or gave up.
  • Autonomous: an exhausted budget fails the crew, its error opening with Execution budget exhausted: <dimension> and naming every task it never reached; the hook hears Failed, no longer Canceled, which stays for an actual cancellation. A failed task with no peer to delegate to fails the crew instead of throwing No delegation candidates available. out of the strategy, and no longer spends a delegation level first.
  • Consensual: a retained result that failed fails the crew. The Fail fallback fails its task and skips its dependants instead of stopping the crew on the spot; the error still reads Consensus could not be reached for task ….
  • An agent that fails without a word (no final answer) no longer makes the hierarchical, autonomous and consensual modes throw info.RawOutput cannot be empty: its output reads Task failed: <cause>, as in the other three.

Migration: a pipeline that read Success (or the exit code) and then inspected each task's result keeps working; one that relied on these modes always reporting success must treat exit code 2, or Success == false, as the run's failure.

Changed — Graph sizes its circuit breaker from the crew

The Graph mode took its bounds from the Strict preset: five visits of the task node, so a healthy crew of six tasks was cut short. Without an explicit graphConfig.maxStateVisits / maxTransitions, they are now computed from the crew — tasks × (1 + maxRetryCycles) visits and twice that plus one transitions — so the breaker still stops a real loop without capping the size of a crew. An explicit value wins. MaxTotalDuration keeps the preset's (10 minutes under Strict), a cost bound maxTotalDurationSeconds overrides. GraphProcessStrategy.CircuitPolicy is now nullable and null by default (computed); a C# caller that sets it keeps a fixed policy.

Before After
a graph crew with more than five task attempts: maxStateVisits to raise by hand nothing to declare
strategy.CircuitPolicy (Strict by default) null by default: bounds computed from the crew

Fixed — MCP and rag_* tools reach the crew agents that name them; an MCP tool no longer replaces a built-in

  • A crew agent receives every tool the registry resolves. CrewFactory kept a resolved tool only when it implemented the empty ITool marker, which the three RAG tools and McpToolAdapter did not. A crew listing rag_search (in a host that calls AddOrkeonRagTools()) or a tool of a connected MCP server failed to load under StrictTools with an unknown tool(s) line whose available tools named that same tool, and lost the tool silently without it. AgentMapper.CreateFromRequest and CrewConfigurationMapper.ToDomainCrew dropped such tools without a word. All three now attach any IBaseTool.
  • A tool name belongs to one tool. IToolRegistry.RegisterToolAsync returns false when another instance already holds the name, and leaves that tool in place; registering the same instance again is an idempotent success. Both registries follow the contract: ServiceProviderToolRegistry and InMemoryToolRegistry used to overwrite.
  • An MCP tool named like a registered tool is refused. Before, a server exposing file_read replaced the built-in silently, and disconnecting the server unregistered the name, so the built-in was gone for the rest of the process. Now the MCP tool is not registered, one error line names the server and the tool, on the log and on stderr (McpServerStatus.RejectedToolNames lists them), the rest of the server's tools are registered, and the built-in survives the disconnection. Two servers exposing one name behave the same way: the first keeps it. Both McpToolProvider.ConnectServerAsync overloads now log alike.
  • Two DI tools with one name stop the host with an error that names them. ServiceProviderToolRegistry threw a bare "An item with the same key has already been added"; the InvalidOperationException now names the tool and both types.
  • The refusal of a .ork.ts script tool that shadows a registered tool is unchanged; it now rests on the registry's answer rather than on a lookup made beforehand.

Changed — ITool is removed; IBaseTool is the one tool contract [breaking]

Orkeon.Domain.Common.ITool was an empty interface over IBaseTool, and the filter on it is what kept the tools above from the agents. It is deleted, with no shim, and every signature that took or returned it takes or returns IBaseTool: Agent.Tools, Agent.AddTool, Agent.Create, AgentBuilder.WithTool/WithTools, AgentCreateOptions.Tools, AgentSnapshot.Tools, AgentSpawnRequest and its builder, and IToolDecorator.Decorate. IToolRegistry.GetToolsAsync(IEnumerable<ITool>), which nothing called, is removed with its two implementations.

Before After
ITool (Orkeon.Domain.Common) IBaseTool (Orkeon.Domain.Tools)
registry.GetToolsAsync(tools) GetToolByNameAsync(name) for each name

Added — e-mail is a chapter of its own, with a tutorial

  • A new getting-started tutorial, Give your agents a mailbox, EN and FR (docs/getting-started/give-your-agents-a-mailbox.md). It walks through the examples/scripting/13-email-triage example: a Gmail app password, the Orkeon:Tools:Email block, orkeon email accounts and check, the run, then how to adapt it (folders, the Send right behind Send:AllowedRecipients, a YAML crew instead of a script), with links into the guide for Outlook.com through Microsoft Graph, Gmail OAuth2 and a server of your own.
  • The e-mail guide is no longer one line among the Guides.
    • An E-mail section in the documentation index, EN and FR, holds the tutorial, the guide, the orkeon email commands and ADR-012, with a reading path of its own.
    • A top-level E-mail node sits in the site navigation.
    • The site home page, the README's documentation table, the overview, Run your first example, the tool inventory and the examples catalog point to the tutorial.
  • 13-email-triage.appsettings.json raises Orkeon:Scripting:Limits:ExecutionTimeout to ten minutes. A script's default is 30 s of wall-clock time for the whole run, awaited IMAP reads and model calls included, and one triage takes longer. The guide's troubleshooting section says so too.

Fixed — the documentation matches the code again

Every page under docs/ and the root community pages were reviewed against the code, topic by topic, EN and FR together.

  • New pages:
    • Flows (FlowEngine) (docs/orchestration/flows.md). It documents the C# flow engine and says plainly that no CLI, host or script runs a flow yet.
    • Microsoft Agent Framework interop (docs/reference/agent-framework-interop.md). It gives usage for both directions of the bridge, which only ADR-010 described.
    • docs/reference/hosting.md gains the .NET Aspire integration (AddOrkeonHost, AddOrkeonCrewRun) and a telemetry section.
  • Seventeen AddOrkeon* extensions that no page named are documented, each where a reader looks for it:
    • Auth, Guardian, YAML, flows, flow visualization, training, memory migration, consensus;
    • the six RAG building blocks that AddOrkeonRag already calls;
    • the CLI and Terminal.Gui REPL hosts;
    • the Agent Framework bridge.
  • What ships but is not wired is said, not implied. Known limitations are now on the pages and in docs/reference/limitations.md:
    • rag_* and MCP tools cannot be attached to a crew agent: they implement only IBaseTool.
    • orkeon run crew.yaml registers no RAG, so rag: and knowledge: are inert there.
    • The task FSM and a task-level circuitBreaker: are not applied at run time.
    • The shipped A2A router does not run the agent.
    • orkeon-host connects no MCP server.
    • 10 of the 44 domain events are never raised, and those raised during a kickoff are never dispatched.
  • Orchestration pages rewritten to what the strategies do:
    • Graph has three breaker mechanisms, not four, and its YAML mode has a fixed topology.
    • Autonomous: the manager assigns tasks, a failed task goes to a peer, and spawning is provided by the host.
    • Parallel runs in dependency waves.
    • Hierarchical and Consensual behave as documented, with their caveats.
    • The ProcessType blueprint lists the steps a seventh mode really takes; it was a copy of the FSM guide.
  • Reference pages completed:
    • The CLI reference covers every command, option and exit code, and the orkeon-repl options.
    • The configuration reference gives the real keys of about 45 sections.
    • The .ork.ts reference has a corrected per-shape table and twelve more known gaps.
    • The run-event protocol table matches RunEventKinds.
    • The LLM pages cover provider resolution, dialect seams, decorators and exchange logging, json_schema, and vision on every provider.
  • Samples that did not work are fixed:
    • The README TypeScript crew ended with crew.run(), which ignores the tasks.
    • The bootstrap host could not load a YAML crew (no model, no VFS, an empty tool registry).
    • The tool inventory's call examples used parameter names the tools do not take.
    • Loader and porting samples used disk paths instead of virtual paths.
    • A test sample in CONTRIBUTING did not compile.
  • Smaller fixes:
    • index.md said 14 providers, not 16.
    • studio.md EN and FR are reconciled.
    • The publication matrix's discontinued list, the SBOM verification command, and dated notes on ADR-002/005/006/008/009 are corrected.
  • Examples whose comments promised what the code does not do are corrected:
    • rag/crew-yaml: the stock CLI only validates it.
    • scripting/09-tools-and-act: act does not see withAutonomousTool instances.
    • The cli-ts-commands transcripts gain their leading /.
    • 97-multi-party-negotiation does ship one reference file under data/.

Added — a dev channel: the latest main is installable between two tags

  • publish.yml gains a publish-dev job. Once CI is green on a push to main, every packable is packed as <props version>.dev.<CI run number> — 1.0.1-dev.<n> after a stable 1.0.0, which 1.0.0-dev.<n> would sort below — and pushed to GitHub Packages only: never NuGet.org, which cannot delete a version. The new scripts/prune-dev-packages.sh then deletes the older dev builds, so the feed keeps each tagged release plus the latest main. Tagged versions are never touched and dev builds are not attested. dotnet tool install -g Orkeon.Scripting.Cli --prerelease against that feed installs the latest main; the steps are in Update Orkeon (docs/getting-started/three-ways-to-run-orkeon.md), the mechanism in docs/reference/publication-matrix.md.
  • scripts/test-prune-dev-packages.sh proves the retention rules in CI against a fake gh — no network, no token: tags are never deleted, nor the kept build, a newer one or a package's last version; a 404 from an overlapping run is not a failure, a 403 is.
  • The Orkeon.ConsoleApp and Orkeon.Generators READMEs pin a release with --version. On the GitHub feed, --prerelease now resolves the dev channel.
  • An Update Orkeon section in Three ways to run Orkeon, EN and FR. The update of every channel in one table, then the dev channel step by step: the token, the feed in bash and PowerShell, install then update, orkeon --version to check, the PATH and Studio traps when a package already installed orkeon, floating versions in a project, and the way back to the releases. The README, index.md, the documentation index and the CLI reference point to it. The publication matrix and the Homebrew formula no longer say that orkeon --version exits 1: it prints the version and exits 0.

Added — native e-mail tools: IMAP, POP3, SMTP and Microsoft Graph, Gmail and Outlook presets, OAuth2 sign-in (MAIL-01..06)

  • A new tool family, Orkeon.Tools.Email — the eighth of the Orkeon.Tools umbrella, and the second motivated exception to the scope freeze, decided by the owner on 2026-09-26 (an .ork.ts script cannot open a socket, and a plugin would not put e-mail in Orkeon itself; ADR-012). Thirteen tools: email_accounts, email_folders, email_search, email_read, email_save_attachment, email_create_folder, email_rename_folder, email_move, email_mark, email_delete, email_draft, email_send, and email_parser, rebuilt (below). Built-in tool classes go from 79 to 91.
  • Three backends, one message model. MailKit 4.18.0 and MimeKit 4.18.1 (MIT) for IMAP, POP3 and SMTP; Microsoft Graph over plain HTTP — no SDK — for Outlook.com, Hotmail and Microsoft 365, read and written as MIME, with ids that survive a move. Presets: Gmail (imap.gmail.com:993 or pop.gmail.com:995, smtp.gmail.com:465), Outlook (Graph by default; an IMAP/POP3 + SMTP variant exists and inherits Microsoft's consumer IMAP OAuth regression of 2026-09-24), Custom (explicit hosts, password only). TLS only; None towards a loopback test server only.
  • Configuration Orkeon:Tools:Email, validated at first use with every problem reported at once — a value the binder cannot even read sets its one account aside instead of failing the host: DefaultAccount, CredentialsDirectory, Screening:WithholdRejected, and per account Provider, Address, DisplayName, a mandatory Rights list (Read, Organize, Draft, Send, Delete, Purge), Incoming, Outgoing, Auth, Send, TimeoutSeconds, SaveSentCopy. Secrets are only ever the names of environment variables.
  • Guard rails that do not rely on the model. An agent names an account, never a server or a credential. Sending fails closed: Send:AllowedRecipients (address, *@domain, *) empty means nobody; the SMTP envelope is the checked list, passed explicitly; From is forced; MaxRecipients / MaxPerHour cap the volume; email_draft is the human-review path. Every read result opens with an untrusted-content notice and carries the verdict of the RAG prompt-injection detector, run on the rendered text; HTML-hidden text is left out and flagged. Each tool declares its ToolAccess, and orkeon forge keeps the twelve mailbox tools out of forged crews. Results fit the agent loop's 4000-character cap: a search page is cut after a whole message and a body slice where its rendering ends, and next_cursor / next_offset resume exactly there.
  • OAuth2, written by hand, and orkeon email. Device code for Microsoft, authorization code with PKCE on a 127.0.0.1 listener for Google — with a paste-the-address fallback for WSL, containers and SSH — and refresh with rotation; no MSAL, no Google SDK. The new verb orkeon email accounts | login | logout | check lists the accounts and their readiness without network, signs an account in, forgets its tokens, checks a connection. The tools never sign in themselves.
  • Tokens in a new internal VFS root, /credentials (RunnerVirtualRoots.Credentials), mounted by the runner host only when an OAuth account is declared and written through PrivilegedFileSystemAccess; physically <per-user settings directory>/credentials/email/, or the email subdirectory of CredentialsDirectory for a service, owner-only on Unix. A user mount claiming /credentials is refused by every command, whatever the accounts. The files are plain JSON — out of reach of the VFS tools, not of a shell or code tool running as the same user.
  • Everywhere a tool family shows up. AddOrkeonEmailTools(configuration) is called by the runner host (orkeon run, scripts, orkeon-host) and by orkeon-repl, where OAuth accounts are refused for want of a token store; the Orkeon.Tools umbrella embeds the assembly; Studio lists the family, twelve of its tools with a new "e-mail account" requirement, in its five languages; the scripting typings declare tools.email* — arguments and results keep the tools' own snake_case keys (unread_only, reply_to_id, new_name) — with examples/scripting/13-email-triage.ork.ts. Documentation: the e-mail guide, the tool inventory, security, configuration, CLI, limitations and VFS pages, ADR-012 and the SECURITY.md threat model, EN and FR. THIRD-PARTY-NOTICES.md gains MailKit, MimeKit and BouncyCastle.Cryptography, now redistributed inside the orkeon and orkeon-repl tools and the installers.
  • Campaign-pending. Nothing has run against a real Gmail or Hotmail account yet: the live campaign is the owner's (MAIL-07).

Changed — email_parser moves to Orkeon.Tools.Email, rebuilt on MimeKit [breaking]

  • Registration. AddOrkeonFileSystemTools() no longer registers email_parser; AddOrkeonEmailTools(configuration) does, and both shipped runners call it — a crew listing email_parser under orkeon run or orkeon-repl needs no change. A host of your own adds the call. The public types Orkeon.Tools.FileSystem.EmailParserTool, EmailParserRequest, EmailParserResponse and EmailAttachmentInfo are removed, no shim.
  • Parameters. path (the virtual path of the .eml file), offset and max_chars (the body comes in slices of 200 to 3000 characters, 2500 by default; next_offset continues). extract_attachments and parse_html are gone: attachments are always listed and HTML is always rendered as text.
  • Output. The shape of email_read: notice, security (the prompt-injection verdict), message_id, from, reply_to, to, cc, date, subject, attachments (index, file_name, content_type, size_bytes, inline), text_offset, text_length, next_offset, text — with folder set to the file's path. Migration: read text where body was; headers and priority have no successor; an attachment's filename becomes file_name and its encoded_size / estimated_size become one size_bytes.
  • .msg is no longer supported. It was never parsed — the old tool returned a placeholder for it. Save an Outlook message as .eml before handing it to email_parser.

Fixed — a whole number from an .ork.ts script passes an integer tool parameter (MAIL-05)

  • Scripts could not pass an integer to a typed tool. Every number a script passes reaches the tool as a double — Jint maps each JavaScript number to System.Double — and ToolParameterValidator accepted only int and long for an integer parameter, so tools.emailSearch({ limit: 20 }), like a script call to any typed tool with an integer parameter, was refused with "invalid type. Expected: integer". A finite whole number now passes whatever carries it — a double, a float, a decimal or a smaller integer type — which is JSON Schema's own definition of an integer; the typed deserializer already turned 20.0 into 20. Found while typing the e-mail tools for scripts.

Fixed — the third-party notices cover HtmlAgilityPack and read the AngleSharp version actually pinned

  • HtmlAgilityPack gets its entry (section 11). The parser behind the RAG HTML loader, web_scrape, the infrastructure's HTML parsing and the e-mail family's text rendering rides inside the orkeon and orkeon-repl tools and the installers, which is the file's own criterion (a), yet had no notice. The package ships no license text and the upstream LICENSE carries no copyright line: the notice is the package's own (Copyright © ZZZ Projects Inc.), with the MIT text reproduced verbatim from upstream.
  • AngleSharp reads 1.8.2, the version Directory.Packages.props pins, instead of the 1.7.2 it replaced. Its license text is re-sourced from the commit the 1.8.2 package was built from (unchanged), and its dependency note is re-checked against that nuspec.

Fixed — Studio finds the CLI it was installed with on Windows

  • The zip and MSI installs no longer leave Studio without an engine. Studio lives in libexec\orkeon-studio\ and the CLI in libexec\orkeon\orkeon.exe, a directory the lookup never probed; bin\ on PATH holds only .cmd wrappers, which the Windows lookup (orkeon.exe only) rejects. Studio therefore reported « the orkeon command-line tool was not located », or silently drove an older orkeon.exe found on PATH (a global dotnet tool). OrkeonBinaryLocator now probes the libexec/orkeon sibling right after the install directories.

Added — My teams stays readable with many teams: search, order, the Archives view, an undo banner, the archive suggestion (STUDIO-32)

  • A view over the cards, in memory. The screen gains:

    • a search on the name and the need: every word typed must start a word of them, accents and case aside — the gallery's rule;
    • an order, by last activity (the default) or by name;
    • an « Archives (N) » toggle, which closes by itself once the last archive leaves.

    None of these reads the disk again. The sidebar counts the active teams whatever the screen shows (TeamsViewModel.ActiveCount, formerly Count). The empty screen now tells apart no team at all, every team archived (« Open the archives ») and a search that found nothing.

  • « Archive » asks no question. It is a labelled button in novice mode and an icon in expert mode. An undo banner then holds the top of the screen for a few seconds, on a timer of its own (StudioServices.UndoDelay). An archived card offers only « Restore » and « Delete ». Undoing « Stop the schedule and archive » says so on the banner and brings the team back without its schedule: the card shows « Schedule not installed » with « Install the schedule », and nothing is reinstalled.

  • The archive suggestion. A banner asks « N teams not launched for 60 days — archive them? ».

    • It never lists a scheduled team, nor one whose activity is unknown, and it waits until the launch history has been read.
    • Accepting archives exactly the teams it names, each read again at the click, with one undo for all of them. « Not now » puts it away for the session.
    • Its switch and threshold are a new card in Settings › Studio, merged into ui-preferences.json (ArchiveSuggestion, ArchiveSuggestionDays).
  • Archiving holds even when Studio did not do it. The Run and Test screens read a team's archived state again right before a launch, so a team archived behind their back is refused. A copy's arrival counts as activity: a duplicate or an import forgets the copied lastRunAt and stamps addedAt in studio-team.json (in a minimal sidecar when the copy came without one), and the last activity now reads four dates.

  • Fixes and API changes.

    • A card's last run falls back on the sidecar's lastRunAt once the history has forgotten it.
    • The Test screen's team picker now resolves the team it picks; it used to set only the path, which left the trial's buttons disabled.
    • TeamCatalog.Duplicate, TeamCatalog.Import and UseCaseImporter.ImportAsync take the arrival date.
    • ArchiveChanged now carries every folder one gesture moved (ArchiveChangedEventArgs.Paths).

Added — renaming a team: its folder, session, titles and schedule follow, all or nothing (STUDIO-28)

  • orkeon forge rename <team-folder> --name <name> renames a promoted team, all of it or nothing:

    • the folder takes the name's folder (the one folder rule); the session rule R links to it follows (suffixed -2 past another session's name);
    • session.json, forge.json, Studio's studio-team.json (its name only — every other field kept), the title and install command of FORGE.md and the launchers' header take the new name; schedule/ is regenerated for the new path;
    • a schedule the system runs is reinstalled under the new name, the former registration removed.

    Every step is journaled: a failed one — the disk, the system's scheduler — puts everything back and the verb exits 1 (FORGE-RENAME-FAILED, or FORGE-SCHEDULE-REFUSED). A taken name is refused with what holds it (FORGE-RENAME-TAKEN); a folder that holds no team is never moved (FORGE-TEAM-UNREADABLE). New event team.renamed; --name is no longer reserved to promote, and --reference is now refused on schedule / unschedule as on the other folder verbs.

  • In Studio, « Rename » on every team card, in both modes, opens an editor in place of the action row:

    • refused while the team runs on the Run or Test screen or is open in the assistant; a taken name is said before the engine is asked;
    • the launch history follows the folder — target, working directory, settings file and arguments — so the card keeps its last run and « Relaunch » replays where the team is; a launcher aimed at the former folder follows it;
    • an allowed folder declared inside the former folder is reported, never rewritten.
  • « Modify » still changes the title only; step 4 now says the folder is renamed from My teams.

  • The "busy team" hook (TeamsDependencies.ActivityOf, LaunchTabViewModel.RunningTarget) is shared with archiving (STUDIO-31). examples/forge/promote-demo's session now carries an id, like every session this build creates.

  • Archiving is a flag in studio-team.json (archived, archivedAt); the folder does not move, so its path, session link, scheduled task and history hold. TeamCatalog.List takes a filter (active by default, archived, all) and never lists a dot folder, nor a hidden or system folder on Windows. A duplicate or an import that fails halfway leaves no partial folder.
  • The sidecar is merged, never rebuilt: a « Modify » re-adoption keeps the archive flag and the last run. A duplicate or an import lands active; an export carries the flag.
  • Last activity: a real run from the Run screen — never a trial, never --validate — stamps lastRunAt into its team; a team's last activity is the most recent of that date, its latest history entry and forge.json promotedAt.
  • Nothing relaunches an archived team by mistake: the Run and Test screens refuse it under « Archived team — restore it? » with « Restore »; « Replay » in the History checks the entry's own team and offers the restore instead of running; the Test picker lists active teams only.
  • Rules: a scheduled team is archived only by stopping its schedule first; archive and restore are refused while the team runs on Run or Test, or is open in the assistant — the launchers now name the run they have in flight (TeamActivity), a seam forge rename shares (STUDIO-28). « Used by » still counts archived teams, Settings › Team folders marks them « (archived) », and the balance covers the active teams. Archiving is Studio's notion: orkeon run and the terminal launcher ignore it.

Added — import a use case as it is: orkeon usecases export and the gallery's expert action (STUDIO-41)

  • orkeon usecases export <id> --to <folder> [--lang <code>] writes one use case as a team folder:
    • crew/config.yaml (the example's crew, byte for byte) and its data/;
    • a folder behind each of the manifest's mounts (output/ for every crew that writes files);
    • studio-team.json: the title and the problem in --lang as the team's name and description, and the manifest's mounts relative to the folder (./data:/data:ro, ./output:/output:rw).
    • No forge.json: forge reopen rebuilds a session from crew/ (checked on the 90 importable examples). Only the manifest's mounts are recorded.
    • A reference-only case is refused with USECASES-NOT-IMPORTABLE, a folder that is not empty with USECASES-DESTINATION-NOT-EMPTY. --events jsonl answers with usecases.exported.
  • Studio, expert mode: every gallery card that is not reference-only offers « Import as is ».
    • The name is the title in the UI language. When it is taken, the adoption's banner offers the free name (« Import as “… (2)” »), and nothing is exported until the name is free.
    • Studio exports into a staging folder and brings it in through the existing import. The team lands in My teams with its name, its description and its data mounted, and « Modify » is active.
    • The banner ends on « Team “…” is saved in My teams » and the Import screen's report on the folders.
  • ConventionalNames.TeamSidecarFile and UseCaseEventKinds.Exported join the shared constant satellites (ADR-009).

Added — Studio installs and removes a team's schedule; deleting a team leaves nothing behind (STUDIO-27)

  • The operating system runs a scheduled team; Orkeon still has no scheduler of its own.

  • orkeon forge schedule <team-folder> registers the schedule for the current user, without elevation and never through a shell:

    • a Windows task Orkeon <team>, which now runs on battery and catches up a missed run;
    • a systemd user timer orkeon-<team>.timer;
    • or a crontab line marked # orkeon:<team>.

    --check answers installed, absent or stale. orkeon forge unschedule removes the registration and schedule/.

  • What was installed is recorded in forge.json (schedule.installed). Check and removal act only on those recorded names, so a copy never touches its original's task.

    • An OS refusal is FORGE-SCHEDULE-REFUSED, carrying the command to run by hand.
    • A new event, schedule.state, reports the state.
  • In Studio:

    • adopting a scheduled team asks « Install the schedule (every day at 08:00)? »;
    • the team card shows the real state (Scheduled, Not installed, To reinstall) with Install and Stop actions;
    • the assistant's answers that promised this are now true.
  • Deleting a team stops its schedule first (a refusal keeps the team). By default it also deletes the workshop session that rule R links to it — never the original's, for a copy. The Diagnostic lists orphan sessions and cleans each one after confirmation.

Added — orkeon forge --reference <id>: compose a team on the model of a use case (STUDIO-40)

  • A new session can start from a use case of the catalogue. The assistant that designs the team sees its crew's STRUCTURE: agents with role, goal and tools; tasks with agent, order and output; the process.
    • It is shown as a model, not content to copy, in the blueprint phase only, right after the tool catalogue.
    • Tools the sandbox lacks are removed.
    • Each text is bounded at 200 characters and the whole outline at 4,000. Measured on the real catalogue, it adds 590 to 1,290 estimated tokens per team-design call (median 800, on about 3,000).
  • The session records the reference (session.json reference, announced on session.started), and a resume or a forge reopen composes with it again.
  • The promotion traces it: « Inspiré de : <title> (<id>) » in FORGE.md, and reference in forge.json.
  • An unknown id is refused with USECASES-UNKNOWN-ID, before any session or model call.
  • Orkeon Studio passes the use case chosen in the gallery, and reads it back on resume and on « Modify ».

Added — Studio: the provider balance, where you work (STUDIO-35)

  • The status bar's Balance segment says what the provider accounts behind the default profile, the assistant's profile and the teams' profiles have left.
    • One entry per account (provider + endpoint host + key variable), in the currency the provider returns, with the time of each read on hover.
    • Two profiles on one account cost one request.
  • When it reads: at startup, at the end of each run, trial or composition, and on a click.
    • There is no polling unless Settings › Studio turns on the automatic reading, which is off by default.
    • Only DeepSeek, Kimi and OpenRouter accounts ever cost a request; the other providers are answered from their documentation.
  • On the bar: a click on a provider that does not expose its balance opens its console, and an optional threshold per provider turns the amount orange.
  • In the profiles: each model profile row shows its account's balance once read, and the profile editor gains a « Read the balance » line.
  • Nothing read is written to disk, and no key is ever shown.
  • New Settings tab « Studio », holding the automatic reading and the thresholds. ui-preferences.json is now written by merging, so a theme, language or mode change no longer erases other settings.

Changed — the status bar marks estimated tokens and names the model the agents work on (STUDIO-30 follow-up)

  • cost.updated gains an optional operation: the kind of work the engine attributed the call to — agent, manager, planning, rag, memory, flow, judge, or a script's ctx.llm.* method. It is omitted for a call no scope claimed, and the envelope stays v: 2.
  • Studio's RunCost.Model / Provider follow the agents' own calls only, a script's ctx.llm.* included. A judge's, a RAG pipeline's or the manager's reading no longer renames the model on the status bar or on the Launch card.
  • RunCost.EstimatedTokens and RunProgressModel.FinalEstimatedTokens carry the estimated part of the meter. The Run and Test groups mark ↑ / ↓ with « ≈ » while part of them is an estimate.

Changed — every LLM call of a run feeds the token counter (STUDIO-42)

  • One measuring point. MeteredLlmProvider wraps every provider that LlmProviderFactory builds, and every hand-made provider registered through the new AddOrkeonLlmProvider(...). It reports each call, buffered or streamed, to ILlmUsageSink. With no sink registered, providers stay bare.
    • The live cost.updated and the final run.finished.tokens now count calls they used to miss: the hierarchical manager, planning, agent-loop retries and fallbacks, the RAG pipelines, flows, memory and LLM judges.
  • Attribution. LlmUsageScope, an AsyncLocal, names crew, agent, task and operation (agent, manager, planning, rag, memory, flow, judge, ctx.llm.*). A call no scope claims is counted as unattributed. CostUsageEvent gains TaskId.
  • No double count. The agent loop's and the scripting facade's own reports are removed.
  • Estimates. A response without usage is estimated and marked, never priced. cost.updated and run.finished gain estimatedTokens, omitted when nothing was estimated.
  • A two-part architecture guard:
    • a source scan (providers built only by the factory or through AddOrkeonLlmProvider);
    • a behavioural check (every LLM surface the runner host hands out reports its usage).
  • Embedding calls are not generation calls: they stay out of the counter, a limit documented in Known limitations.

Added — Studio: the 105 use cases in the creation wizard, suggested as you type (STUDIO-39)

  • Step 1 of « Create a team » keeps its four quick examples first and adds « Browse the use cases (N) ». It opens a side panel over the catalogue that orkeon usecases list answers:
    • a search box and nine category chips;
    • filters by process, without web access, and without a third-party key;
    • cards with the title and the problem in the UI language, a process badge, and « Reference only » on the cases that cannot be imported as they are.
  • Choosing a case fills the need with its problem in the UI language, Chinese included. It also attaches the case as the creation's reference: a removable « Inspired by: … » chip (ReferenceUseCaseId).
  • After a pause in the typing, the wizard asks one orkeon usecases search session and shows « N close use cases ». A case counts only when it shares a distinctive term with the need; matches by meaning alone never count.
  • Without the CLI, the panel shows the wizard's « engine not found » card; there is no Studio-side fallback.

Added — Studio: a status bar with one group per running activity (STUDIO-34)

  • A third row at the bottom of the window; the seven overlays now span the three rows.
  • One group per activity that is running — Run, Test and « Create a team » (the Atelier). Each shows only while its activity runs, and a click opens its screen.
  • Run and Test groups read the run's progress model:
    • team, state (running, waiting for an answer, succeeded, failed), current task, duration;
    • ↑ / ↓, cache and real cost;
    • tools at work (count and first name, the list on hover) and delegations;
    • the provider and model reported by cost.updated.
  • The Atelier group shows its stage, ↑ / ↓ (≈ when estimated) and the remaining budget.
  • At rest, and in expert mode only, the bar shows the default profile's provider · model.
  • Modes: novice sees each group's state and ↑ / ↓; expert sees everything. Nothing unmeasured is shown as zero.
  • Duration refreshes on a one-second ticker that only runs while a run is shown. A Balance slot is reserved for STUDIO-35.

Changed — adoption names the team, and the session folder follows it (STUDIO-26)

  • forge promote --name <team> hands the engine the team's name, which titles FORGE.md, forge.json and the session. The value is taken as written, a leading dash included, and Orkeon Studio always passes it.
  • The session folder follows its team. Once the promotion is written, .orkeon/forge/<slug>/ takes the destination folder's name as it is.
    • When another session already has that name, a -2, -3… suffix is added; nothing is ever overwritten.
    • session.json and forge.json take the new slug.
    • The new event session.renamed {from, to, dir, suffixed} announces it, and Studio follows it.
  • A rename the disk refuses is a warning, not a failure. The promotion still exits 0, and a new warning {code, message} event carries FORGE-SESSION-NOT-RENAMED. The session id keeps the link.
  • Generated files carry the team folder's name, not the session slug: orkeon-<team>.service / .timer, the task Orkeon <team>, the install command, the launchers' header, and FORGE.md's fallback title.
  • A taken name never reaches the engine. Before promoting a new team, the Studio wizard checks its folder:
    • it says what holds the name: a team, a folder or a file;
    • it proposes a free name (« Ma veille (2) » → ma-veille-2);
    • when a team holds the name, it offers to open it.
  • Breaking (no shim): ForgeArgumentsBuilder.BuildPromote and ForgeClient.PromoteAsync take the team name.

Added — Studio: the progress model holds everything in flight (STUDIO-30)

  • RunProgressModel now exposes:
    • every tool at work with its start (ActiveTools; ActiveToolName derives from it) and the call tally (ToolCallCount, SucceededToolCalls, FailedToolCalls);
    • the delegations under way (ActiveDelegations, from delegation.started until its tool.returned) and the spawned agents (SpawnedAgents);
    • IsWaitingForAnswer;
    • StartedAt and Elapsed, with an injectable TimeProvider, frozen at the run's own duration once it ends.
  • A call still open at run.finished moves to UnfinishedTools / UnfinishedDelegations and is never counted as a success.
  • Changed becomes EventHandler<RunProgressChangedEventArgs>. Its Kind names the event that changed the state, so a screen can skip per-token llm.delta.

Added — orkeon usecases: the example catalogue in the tool, searched offline in five languages (STUDIO-38)

  • orkeon usecases search "<need>" ranks the 105 example use cases against a need written in French, English, Spanish, German or Simplified Chinese — no LLM, no network, no file read.
    • By terms (BM25): each sheet's title and problem in the five languages, its tags, tools, category and id words. The query and the sheets are normalized the same way: lowercase, accents folded, Chinese split into character bigrams.
    • By meaning: the local BGE-micro-v2 model (English) embeds each sheet's English text at the first search that needs it. Its ranking is fused by RRF only for the languages where the golden set shows a gain.
    • Without the model, the search runs by terms and every answer says why.
  • Each result gives its id, score, reason (terms, meaning, terms+meaning) and matched terms. The answer gives the mode and the language: --lang, or read from the text.
  • Session mode. --events jsonl without a text opens a session: usecases.ready, then one usecases.results per usecases.query line on stdin, correlated by correlationId. The model loads once, and closing stdin exits 0. The kinds are declared in Orkeon.Constants.Protocol.UseCaseEventKinds.
  • list filters by category, process and tag. show <id> prints a sheet and its files, plus its crew file with --crew. An unknown id is USECASES-UNKNOWN-ID. Both also answer in --events jsonl.
  • Embedded in the tool: examples/usecases.json, each example's crew file and its data/ folder, about 217 KB compressed. The finance examples stay reference only: their shared _tools/ is not embedded.
  • Golden set: examples/usecases.golden.yaml holds 22 queries in the five languages, and UseCaseGoldenSetTests (Slow) reports recall@5 and MRR per language and per mode.
  • A team's link to its session no longer rests on an absolute path.
    • A forge session gets an id (GUID) at creation. It is written to session.json, announced on session.started, and copied by forge promote into the team's forge.json.
    • A rebuilt session gets a new id.
  • Rule R decides the link. It is written once, in Orkeon.Domain.FileSystem.TeamSessionLink. Take the session that carries the folder's id:
    • it is linked when its promotedTo designates the folder;
    • it is also linked when that folder is gone or no longer carries the id: the team was moved or renamed;
    • when promotedTo designates another existing folder carrying the same id, the folder is a copy and is linked to nothing;
    • no id, or an id no session carries, links nothing (no shim).
  • forge reopen applies rule R.
    • A moved team resumes its session: promotedTo is re-pointed, and there is no more -2 duplicate.
    • A copy, or a folder without a known id, gets a rebuilt session whose id is written into its forge.json. A copy thus becomes independent, and its session is named after its own folder.
  • forge promote --to updates the linked folder in place, a moved one included, and refuses a copy with the reason.
  • Studio « Modifier » always runs forge reopen. A duplicated team can no longer open its original's session.
    • Removed, without a shim: TeamsViewModel.FindSessionFor, ForgeSessionCatalog.FindByPromotedTo, ForgeSession.FindPromotedTo and IsSameDirectory.
    • New: ForgeSessionCatalog.FindById / ReadTeamSessionId, TeamSummary.ForgeSessionId, ForgeSessionModel.SessionId.

Added — the 105 use cases state the user's problem in five languages (STUDIO-37, draft)

  • Every usecase.yaml now carries a title and a one-line problem in fr, en, es, de and zh-Hans, plus two to four search tags.
    • Each problem answers the team wizard's question in the voice of Studio's four example chips.
    • Each follows what the crew's config really does, not what its README claims.
  • lint-example-configs.py now requires the five languages on every sheet.
  • The texts are a reviewed first draft: a fluent human review per language is still due.

Added — every numbered example carries a use-case sheet, gathered in examples/usecases.json (STUDIO-36)

  • Each of the 105 numbered examples has a usecase.yaml beside its crew. It holds the hand-written fields:
    • title and problem in fr, en, es, de and zh-Hans, empty until STUDIO-37;
    • tags;
    • the mounts the example needs (./data:/data:ro, ./output:/output:rw);
    • importable, false for the 15 finance scripts, which depend on _tools/.
  • scripts/generate_examples_index.py also writes the deterministic manifest examples/usecases.json, adding the derived fields:
    • format, process, agent and task counts, tools;
    • hasSampleData (a data/ folder exists);
    • requiresNetwork, from an explicit tool table that stops on an unknown tool;
    • requiresKeys, the third-party key variables beyond the LLM, e.g. ORKEON_TAVILY_API_KEY.
  • has_data now means "a data/ folder exists", so examples/INDEX.md does not change when the new sheets are added.
  • lint-example-configs.py checks each sheet's format and three consistency rules, and fails on a missing sheet, a duplicated id or a stale manifest. The five-language requirement waits behind --require-texts.
  • The examples CI checks that the manifest is fresh. scripts/test-examples-catalog.py (23 tests) covers the generator and the lint.

Added — Studio can read what is left on a provider account (STUDIO-33)

  • IProviderBalanceProbe / HttpProviderBalanceProbe (Studio.Core) return a typed result for every provider, never an exception and never a silence:
    • DeepSeek, Kimi (USD on the .ai host, CNY on the .cn one) and OpenRouter (what the key may still spend under its limit) are read with the profile's own key and host;
    • x.AI and Qwen keep the balance behind an administrative credential;
    • the other cloud providers expose none — their admin APIs report spend, not what is left;
    • local endpoints have no account.
  • No detail quotes the provider's answer or the key, and the probe never runs by itself: its caller decides when a read is worth a request.
  • LlmPresetInfo.KeyConsoleUri and LlmPresets.KeyConsoleFor give the https link of the vendor console, from the existing KeyConsoleUrl text.
  • Every verdict is sourced from vendor documentation read on 2026-09-24 (provider comparison, "Account balance"). The three readers still await a check with a real key.

Changed — one folder-name rule for the CLI and Studio (STUDIO-24)

  • A name gives one folder, whichever side computes it. The CLI named a forge session with its own slugifier (40 characters cut mid-word, forge-<timestamp> when nothing usable remained) and Studio named a team folder with another (64 characters cut at a word, equipe, an exception on a blank name). Both now go through FolderSlug, public in Orkeon.Domain.FileSystem: lowercase ASCII, accents dropped, one dash between words, 64 characters cut at a word — and null when no ASCII letter or digit remains, each caller keeping its own fallback (FolderSlug.TeamFallback, equipe, for a team folder or an agent key; the timestamp for a session). A session named from a long need now keeps up to 64 characters cut at a word instead of 40 cut mid-word.
  • TeamCatalog.Slugify and TeamCatalog.MaxSlugLength are removed, without a shim; TeamCatalog.MaxNameLength is FolderSlug.MaxLength. A new agent whose name holds only spaces previews the key agent, as an empty name did, instead of throwing from the slug rule.
  • FolderSlugDriftTests fails when a slug implementation reappears in the CLI or Studio sources, and one corpus of names (FolderSlugCorpus) is checked by the Domain, CLI and Studio suites alike.

Changed — cost.updated carries the ↑/↓ split and the vendor's real cost while the run goes (STUDIO-29)

  • The split no longer waits for the end. Every cost.updated of orkeon run --events jsonl now carries the run's cumulative promptTokens and completionTokens, and the cache pair cacheHitTokens / cacheMissTokens once a provider measured it — the fields run.finished already had. The event names the provider on the YAML path too, and its envelope carries the crewId (the agent's role stays agentId). The envelope keeps v: 2: the fields are additive, and run-event-bus.md now writes that rule down.
  • The vendor's real charge reaches the wire, and nothing else does. OpenRouter bills in its answer (usage.cost): the provider base already read it into the cost metadata, and it died at the chat client adapter. It now travels as billed — the provider states its currency beside it (cost_currency, USD for OpenRouter's dollar credits), the adapter carries both onto the ChatResponse (buffered and streamed fallback), the agent loop and the scripting facade put them on the usage event, and cost.updated relays cost, currency and costSource: "vendor". A free model bills 0, relayed as 0; a vendor that bills nothing in its answer leaves no price on the wire at all — the framework's price registry never estimates one there (DD-1).
  • CostUsageEvent.Cost is decimal? (breaking): null means unknown, and CostBudgetManager prices from its registry only a null — a vendor's 0 used to be read as "not provided" and charged at the registry price. The event also gains CostCurrency, and the agent loop now fills Provider, CrewId and OperationType (agent).
  • LlmResponse.Cost is removed (breaking): nothing read or wrote it; the charge travels in the metadata and is read with LlmVendorCost.TryRead.
  • Studio's RunProgressModel folds the new fields into RunCost (PromptTokens, CompletionTokens, the cache pair, Amount, Currency, Source); a field a line leaves out stays null. The screens that show them are STUDIO-30 and STUDIO-34.

Fixed — Orkeon.Compliance.Vfs is compiled against Roslyn 4.8.0 again

  • The 2026-09-21 dependency bump raised the analyzer's Microsoft.CodeAnalysis.CSharp reference from 4.8.0 back to 5.9.0 — the repository's own compiler — and 1.0.0-rc.4 of the package went out that way. Outside this repository that is the rc.3 defect over again: a stock .NET 10 SDK (compiler 5.6.0) refuses the analyzer with CS9057 and skips it silently, so a consumer project with a File.ReadAllText call builds clean. The VersionOverride is back on 4.8.0, as the comment above it in the csproj has said since rc.3, and the packed README names both inert versions instead of one.

1.0.0-rc.4 - 2026-09-21

The release candidate of the Studio. Since 1.0.0-rc.3: Orkeon Studio takes the team journey end to end on a real crew — the wizard, the folders that travel with a team (STUDIO-14, VFS-90: every settings mount carries a ULID, a crew names the entries it uses, --mount-id selects one), the Tools and MCP tabs, the Run screen that shows the task in progress, and « Modify » on any team, session or not (FORGE-09 forge reopen); the provider fleet reaches 16 with the two aggregators OpenRouter and Mammouth AI (LLM-09); the output cap follows each model's documented maximum instead of 4096 (LLM-10); a timed-out call is a failed call and the sequential mode skips what depended on it (LLM-11); the scripting runtime runs its loops in JavaScript (SCR-25); Orkeon.Hosting.Aspire (ADR-011) and Orkeon.Interop.AgentFramework (ADR-010) join the lineup, and a run speaks the OpenTelemetry GenAI conventions; the README's quickstart is executed by CI, the provenance chain is documented and closed with an SBOM; and a second full SonarQube campaign closes the 87 issues the fortnight had accumulated — 0 bug, 0 code smell, 0 hotspot to review, debt back to zero.

The public API surface is frozen at this tag: the 335 additions and 19 removals accumulated since rc.3 move from PublicAPI.Unshipped.txt to PublicAPI.Shipped.txt across the twelve projects that carried them.

Fixed — a host without an Llm section runs on the echo provider again

  • The fallback the warning announces is the fallback the run gets. Since LLM-11 a call the provider refuses fails the task with the provider's own sentence — the right thing for a timed-out cloud model, and the wrong thing for a host with no Llm section at all: its provider was the infrastructure's keyless OpenAI default, so "No Llm section configured — falling back to the echo provider" was followed by "OpenAI API key is required" and exit code 2. The bundled scripting demos and the offline E2E run had stopped running. RunnerHost now registers the echo provider itself (UndefinedLlmProvider, the one the scripting facade answers <undefined-llm> with) as IBasicLlmProvider and IChatClient when the section is absent; the crew runs, its answers replay the prompts, and the warning stays the one line that says it is not a real model (RunnerHostLlmFallbackWarningTests.MissingLlmSection_RunsOnTheEchoProvider).

Changed — the SonarQube campaign of 2026-09-21 (87 issues, 2 hotspots)

  • Every issue the analysis raised on the code written since the 5 September campaign is closed: the two S2583 bugs of ToolCallTextParser (the JSON block scanner is now an explicit BlockScan state with one method per transition), the sixteen methods above the cognitive-complexity ceiling (MountSelection.Resolve, RunnerHost configuration, SequentialProcessStrategy, ChatClientAgentLoop, CrewHandoffDetector, TeamCatalog, the Studio view models, …), and the rest. Behaviour is unchanged except for one real defect the analysis caught: the shell refreshed the mounts editor's team references on every card added to the My-teams list instead of once per rebuild.
  • MountSelectionPlan.WithdrawnIndices, TeamSummary.UnknownMountIds and TeamTarget.UnknownMountIds are methods now — a property must not copy a collection. ImportTeamViewModel takes an ImportTeamDependencies record, like the other Studio screens. McpToolProvider is sealed. Every false-positive arbitration lives in the code, as a [SuppressMessage] or #pragma with its justification (13 × S3604 on primary constructors, 2 × S1168 third-state nulls, the JS-called members of JsLlmFacade, the YamlDotNet-populated probe, the vendors' key-console URLs).

Fixed — Studio: My teams and the wizard — a discarded session resets the wizard, « Modify » reaches it at the first click

  • A session deleted under « Sessions in progress » no longer lives on in the wizard. « Modify » on a team card parks its session in that list, « Resume » opens the wizard on it, and deleting the row there left the wizard exactly where it was — a Composer over a directory that no longer existed, every gesture on it bound to fail. The My-teams screen now announces which session went (TeamsViewModel.SessionDeleted, not raised for a delete the disk refused), the shell relays it, and the wizard open on that directory goes back to the blank step 1 of « Restart », a running engine stopped first (CreateTeamViewModel.ForgetSession). A session the wizard is not open on leaves it untouched; paths are compared the catalog's way (full, trailing-separator-blind, case-blind on Windows).
  • « Modify » brings the wizard forward on the first click. With no session pointing at the team (imported, or its session deleted), the engine rebuilds one first (FORGE-09), and the screen only came forward once it had — a second or two of nothing, so the button got clicked again, and the second click landed on the busy engine and vanished. The wizard now takes the screen on the click and the rebuild shows as the engine working. A click on « Modify » or « Resume » while the engine is busy on another creation is refused in words on the wizard's status line (Studio.Create.EngineBusy, five languages), the creation under way untouched, instead of being dropped.
  • « Modify » no longer lands on step 1 with the rebuilt session sitting on disk. The real cause of the second click: WPF resumes an await begun in an input handler at Send priority — every window message is dispatched through an Invoke at Send — above the Normal priority the reader thread's posts travel at, so the rebuild read the session off a model the engine's events had not reached yet, found nothing, and stayed on step 1 while the session it had just written waited on disk for the next click. A forge run's task now completes only once its epilogue has landed on the UI thread, and with it every event posted before (CreateTeamViewModel.PostAndAwaitAsync, the adoption's promote too). The disk is the fallback when the stream announces nothing, a failure card says so when neither has it, and a resume or reopen that throws anything lands on the wizard's status line instead of a discarded task.

Fixed — Together's context window is no longer sent as the output cap (LLM-10, campaign of 2026-09-21)

  • TogetherAiLlmProvider sends the 4096 fallback again, not the model's window. LLM-10 named the window as the cap on Together (131 072 on Llama-3.3-70B-Instruct-Turbo, up to 1 048 575 on GLM-5.3-Flash) on the assumption that context_length_exceeded_behavior: truncate clamps it to window − prompt. The campaign of 2026-09-21 measured otherwise: only one of Together's serverless engines honours the flag, and on the buffered path only — every other call was refused (inputs tokens + max_new_tokens must be <= 131073, context_length_exceeded), and the default model fell from 9/1/2 to 2/9/1 for two days. The four together: entries are withdrawn from LlmModelOutputLimits; the flag stays, it costs nothing and helps where it is honoured. Omitting the field would be worse: Together then stops at 2048 tokens (finish_reason: length, measured the same day).
  • The catalogue-cap retry net knows Together's wordings. A 400/422 naming max_new_tokens, context_length_exceeded or "maximum context length" now counts as the cap being refused, so a long prompt on the fallback is retried once without the field instead of failing (OpenAICompatibleProviderBase.TryDropCatalogueOutputCap).
  • Campaign kit. gpt-6-astra is pinned to temperature: 1 in llmproviders-test/lib/catalog.json (Only the default (1) value is supported) and, unlike Sol, has no reasoning_effort: none (Supported values are: 'low', 'medium', 'high', and 'xhigh'): function tools stay refused on chat/completions (use /v1/responses). Both facts are in docs/reference/llm-providers-comparison.md, per-model table.

Added — « Modify » without a session: orkeon forge reopen <team-folder> rebuilds one from the team's files (FORGE-09)

  • A promoted team no longer needs its forge session to be modified. orkeon forge reopen <team-folder> (offline, --events its only option) names the session whose promotedTo is the folder when one exists, and otherwise rebuilds one from the folder itself: the plan is read back from crew/ (per-entity or single-file YAML) into a blueprint, the brief comes from the new forge.json, the crew is copied verbatim, and the session lands at the --dry pause with promotedTo set — resume --edit --dry, resume, resume --adopt and a promote --to onto the same folder follow as usual (ForgeSessionRebuilder, ForgeTeamReader, ForgeTrigger.Rebuilt, event team.reopened {slug, dir, path, state, rebuilt, brief}). A folder with no readable YAML crew is refused with FORGE-TEAM-UNREADABLE and the reasons.
  • forge promote writes forge.json next to FORGE.md: the session's slug, title, format, promotion instant and the brief — the machine-readable twin of the card, nothing secret in it. Without it (teams promoted earlier, imported crews) the rebuild derives a minimal brief from the plan and says brief: derived.
  • Orkeon Studio. « Modify » on a team card is enabled for every team whose crew/ holds a YAML definition (TeamSummary.HasYamlCrew), session or not; without a session the wizard runs forge reopen on the folder, reads the rebuilt session off the stream and opens the Composer at the dry pause (agents editable, « Try the team » / « Adopt without trying », adoption fields seeded from the sidecar, re-adoption pinned to the folder). The tooltip says whether the reopen goes through the session or a rebuilt one; only a team with no YAML crew keeps the button disabled, with the reason (Studio.Teams.ModifyRebuild, Studio.Teams.ModifyNoSession reworded, five cultures).

Added — the Launch screen's command can be copied, and « Open the result » opens every writable folder

  • Orkeon Studio's COMMANDE well is selectable and « Copy the command » puts the exact orkeon run … line on the clipboard, ULID and all; the button reads « Command copied » until the command changes. Reproducing a Studio launch in a terminal no longer means retyping it.
  • « Open the result » opens one Explorer window per folder the run could write to — the team's own folders first, then the declared entries kept for the run — and reads « Open the N result folders » when there are several. It reads the effective mounts, so a settings entry withdrawn for the run (its root went to the entry the team names) is never opened; the history cards resolve a --mount-id against the declared list the same way.

Added — every settings mount carries a ULID; a crew names the entries it uses (mounts:), two entries may share a root, and --mount-id selects one for the run (VFS-90)

  • A mount has an identity. An entry of Orkeon:FileSystem:Mounts may carry a 26-character ULID before a | — 01J9Z3K4M5N6P7Q8R9S0T1V2W3|C:\data:/output:rw (FileSystemMount.Id, MountId, strict Crockford validation ahead of the lenient Ulid.Parse). Two entries may declare one virtual root when both carry an id; a root declared twice with an entry that has none, or one id on two entries, is refused before any host (RunnerExecution.EnsureVirtualRootsAreUnique, MountSelection.ValidateDeclared).
  • A crew names the roots it uses. config.yaml/crew.yaml gain a mounts: block — /output, or <ulid>|/output to pin one settings entry (CrewConfiguration.Mounts, MountReference); forge promote writes it. The block selects and validates, it never restricts (D-05): orkeon run crew/ resolves it against the settings with no --mount, and refuses in one line a root nothing provides or an id no entry carries.
  • --mount-id <ulid> (orkeon run, both dialects; several after one flag) keeps the entry named among several entries of one root. Precedence (D-10): --mount on the root replaces every entry of that root, else --mount-id, else the crew's mounts:, else a unique root is mounted as it is; with nothing selecting one, the run is refused naming every id (D-04). An entry not kept is withdrawn for the run — written to null at its own index, not whitelisted, its folder not probed. RunnerHost applies the same MountSelection.Resolve while composing the configuration, so a host built without the guards (the daemon, rag, forge, tests) throws the same text instead of "Duplicate virtual paths".
  • Orkeon Studio: every authorized folder shows its id (copy button, « used by » the teams naming it, a confirmation before removing one a team depends on); a save gives an id to an entry that has none. The chooser opened for a mount point offers only the entries declared under that root and records the pick verbatim; the disk pick declares the folder under the row's root — a second /output, told apart by its id — instead of renaming it /docs. The sidecar keeps <ulid>|<copy>, the ids travel with a duplicated, exported or imported team, a team naming a declaration missing on this machine is refused and the import review offers « Authorize them as recorded »; the launch lays --mount-id for a declaration and --mount only for the team's own folders; the effective-mounts table says which entry of a shared root is kept. The two folder modals (« Add an allowed folder », « Folders of … ») show the whole disk path, a one-word rights pill with the full label as tooltip, and the tail of each entry's id, so two /output rows are told apart.

Changed

  • | at the head of a mount string is reserved for the id prefix; a physical path that really starts with a bare token and a | is quoted ("a|b":/x:ro). list_mounts and the access-denied messages never show an id (D-08).
  • The settings half of the duplicate-root guard reads Orkeon:FileSystem:Mounts with its indices (RunnerSettings.ReadDeclaredAgentFacingMounts); EnsureMountSourcesExist skips the entries a selection withdrew; the runners pre-read the crew's mounts: block from disk (CrewMountDeclarations, an EXCEPTION-BOOTSTRAP) so the refusal comes in one line before "Using settings".
  • The orkeon-host daemon stays out of the selection (D-11): per-crew roots, an id prefix on an operator --mount parses, no crew block is read. A studio-team.json written with ids is not read by an Orkeon Studio from before this change (same version, no migration needed the other way: a sidecar without ids resolves by folder, root and rights and is upgraded on its next save).
  • Dependencies (2026-09-21): the Microsoft.Extensions.* family and its System.* companions to 10.0.12, Microsoft.Extensions.AI to 10.10.0, Microsoft.Agents.AI.Abstractions to 1.22.0, Aspire.Hosting to 13.5.4, Microsoft.Data.SqlClient 7.1.0, MongoDB.Driver 3.12.0, Gremlin.Net 3.8.2, StackExchange.Redis 3.3.0, AngleSharp 1.8.2, Polly 8.8.0, Markdig 1.4.0, the IdentityModel trio 8.23.0, Azure.Security.KeyVault.Secrets 4.11.1, AWSSDK.SecretsManager 4.0.100.14, OpenTelemetry 1.19.0, Microsoft.ML.OnnxRuntime 1.30.0, Terminal.Gui 2.5.0, Jint 4.16.3; on the test side Microsoft.NET.Test.Sdk 18.10.1, xunit.v3 4.0.1 and Testcontainers 4.15.0. Orkeon.Compliance.Vfs is built against Roslyn 5.9.0, the compiler the repo runs, instead of 4.8.0; Orkeon.Host references Microsoft.CodeAnalysis.CSharp directly. Both solutions build warning-free on the new pins and the unit and fast suites are green.

Fixed — a timed-out LLM call is a failed call, not an empty answer; the sequential mode skips the dependents of a failed task; Studio pins the thinking switch and a reasoning-model timeout (LLM-11)

  • A call the provider never answered fails the task with the provider's reason. On the owner's run of 2026-09-20 (kimi-k2.6, Llm:TimeoutSeconds 180), the scorer's call timed out, the chat-client adapter mapped the refusal to an empty message, the agent loop diagnosed "a reasoning model out of budget — raise Llm:MaxTokens" and retried once without tools, for a second full timeout: six minutes, zero tokens, wrong advice. Now the provider's failure travels as LlmResponse.Error (LlmResponseMetadataKeys), the buffered LlmProviderToChatClientAdapter path throws it the way the streaming path already did, and the loops exit AgentExitReason.LlmCallFailed at once — no tool-free retry — with the provider's sentence as the task's error, the summary line and the runner's last stderr line.
  • An elapsed timeout says which setting elapsed and the ways out. In place of HttpClient's wording, every provider (HttpLlmProviderBase.DescribeCallFailure) answers "{Provider} did not answer within Llm:TimeoutSeconds = 180 s … raise Llm:TimeoutSeconds (600 s is a safe value for a reasoning model), or turn thinking off", naming the settings key, the crew llm.thinking.enabled block and the Studio switch.
  • An HttpClient timeout is retried — once. The retry clause written as !ex.CancellationToken.IsCancellationRequested never fired on a real timeout (HttpClient cancels its own linked token), so every timeout failed on its first attempt whatever Llm:MaxRetries said. ResiliencePolicies.IsHttpClientTimeout recognises the shape (a nested TimeoutException); the LLM policy retries it once (ResilienceDefaults.LlmTimeoutRetries — every attempt costs the whole timeout, the ordinary budget is for failures that come back in seconds), never when MaxRetries is 0, never on a caller's cancellation; the generic HTTP policies retry it like any transient failure.
  • The sequential mode skips the dependents of a task that did not succeed. The writer used to run on a context saying "Task failed: …" where the scored JSON should have been, and improvised a deliverable from the cleaner's prose. A task whose declared dependency failed or was skipped is now skipped in its turn — no agent asked, no token spent — recorded as ⊘ skipped in AUTO_SUMMARY.md (with a Skipped count), as task.completed with skipped: true on the event stream (RunTaskProgress.Skipped in Studio), and in the crew's failure reason; the tasks that do not depend on it still run.
  • Studio: the profile pins the thinking switch, and a reasoning provider brings its timeout. The knob existed in the crew YAML (llm.thinking.enabled) and the settings file (Llm:Thinking:Enabled) but had no place in Studio. ModelProfile.ThinkingEnabled / ThinkingEffort travel as ORKEON_Llm__Thinking__{Enabled,Effort}; the profile editor offers provider default / on / off and the effort hint; LlmSection reads and writes the same keys, the validator types them, and the TUI form has a Thinking field. Picking Kimi, DeepSeek, Z.AI or MiniMax — whose default model reasons before it answers — pre-fills the timeout with LlmPresets.ReasoningTimeoutSeconds (600 s, the settings templates' value) and the hint says why; a typed value is never overwritten, and the seed leaves with the card that brought it.

Fixed — Studio: the limits tab shows the engine's defaults as watermarks, and its switches take one click (STUDIO-22)

  • Every empty field of « Settings › Limits & index » now names the engine's default as a watermark — the four per-minute budgets and the queue limit (RateLimitingOptions: 60, 30, 20, 5), the concurrency bound and the log body length as « unlimited » (their engine default is 0, meaning no bound), the RAG profile (fast) and the corrective iteration bound (3). The defaults are copies in Studio Core, pinned against the engine's option classes by EngineDefaultsDriftTests. The watermark is a theme feature: any Input text box or ComboBox shows its Tag while empty. Owner review 2026-09-20: nothing said what an empty field meant.
  • A switch bound to an absent key took two clicks — a check box over a nullable boolean starts indeterminate and the first click only turns it to false. The five switches of the tab (the two LLM-logging captures, on by default; the three RAG opt-ins, off by default) are plain booleans resolving an absent key to the engine's default; setting a switch back to its default removes the key. A guard refuses any nullable boolean on a section form.

Added — Studio: Tools and MCP settings tabs; orkeon run connects the MCP servers the settings declare (STUDIO-21)

  • orkeon run honours the MCP section. Until now the section was bound by nobody: the runners built their host without configuration, so an MCP server written in the settings changed nothing. RunnerHost now calls AddOrkeonMcp when MCP:Servers declares at least one server and MCP:Enabled is not false, and an explicit startup step (McpStartup) connects every server before the crew loads — and before --validate judges it and --list-tools prints the manifest. A server that cannot be connected (missing command, silent endpoint, handshake pending after 30 s) costs one error line naming it, on the log and on stderr, and the run goes on; a crew naming one of its tools then fails at load under StrictTools. McpToolProvider also implements IDisposable so a host disposed synchronously releases the child processes. ConfigurationKeys.McpSection spells the section once for the infrastructure, the runners and Studio.
  • Settings › Tools (both modes). The keys the tools need — the Tavily key of web_search (ORKEON_TAVILY_API_KEY) and the Brave key of brave_search (BRAVE_API_KEY) — on the same rows and the same store as the API keys of the model tab; the catalogue of every tool a run exposes, by family, each tool that needs something saying what (a key above, a key or the connection parameters given at the call by the agent, an expert setting below); and, for the expert, the shell_command allow-list (Orkeon:Tools:Shell), never written as an empty array. The catalogue lives in Core (ToolCatalog) and a test pins it against docs/tools/inventory.md. Owner request 2026-09-20: the settings had no place for a tool key, and nothing listed the tools or what they need.
  • Settings › MCP (expert). The MCP section as cards: the switch and one card per server (identifier, transport, command, arguments, environment, URL), written in place through the new McpSection so unknown keys survive, with the row's own problem said the way the validator refuses the save (STUDIO-MCP-ID, -TRANSPORT, -COMMAND, -URL, and -ENV-SECRET at information level for a secret written in clear). SecretRowViewModel is its own file, public, shared by the two key cards; six settings tabs, two new capture stops, fifty strings in five languages.

Changed — Studio: editable fields look editable, multi-line fields are five lines (T-31, T-32)

  • A field says «you can type here» (T-31). Every input — text box, password box, combo box, check box, radio dot — now sits on its own surface (FieldBrush, FieldLineBrush, FieldShadowBrush in both theme dictionaries: white with a franker line in light, a well deeper than the surface in dark, an inset hairline under the top edge) instead of the sunk paper the read-only wells keep (YAML, raw JSON, journal, code). A read-only text box goes back to the well recipe. Owner design review: nothing distinguished a field from a block of text, and the user could not see where to write.
  • The API key is masked while it is typed — the two key fields (profile editor, API keys card) are PasswordBoxes on the new InputPassword style, bound through PasswordBinding.Text (WPF keeps Password out of bindings on purpose; the attached property carries it both ways, so the field still empties itself once the key is stored).
  • A multi-line field is five lines high, with a scrollbar from the sixth (T-32). Two styles, InputMultiline and InputMultilineMono, on MinLines/MaxLines rather than a height — the box follows the font and the theme, never grows the card, never pushes the layout. Six fields wear them: the step-1 brief and «what the result must contain», the per-step instruction, the agent editor's «what it does», the trial's sample inputs (mono) and the conversation composer, whose Enter-sends / Shift+Enter-breaks contract is unchanged. The hard MinHeight/MaxHeight those fields carried are gone with the change.

Changed — Studio: adopting a team ends the wizard at a blank step 1; the saved card is gone (STUDIO-20)

  • « Save to my teams » ends the tunnel. On a successful promotion the wizard goes back to a blank step 1 — the same slate as « Start over »: step-1 folders and policy, projection, name, profile, schedule, mounts, conversation, notes — and one status line stays: « Team “X” is saved in My teams » (Studio.Create.AdoptedLine, five languages). Owner review 2026-09-20: the wizard used to stay parked on step 4 with a « Team saved » card. A refused promotion is unchanged: step 4, the failure card.
  • The session leaves « Sessions in progress ». The engine writes the session Promoted before it emits promoted, and the shell re-reads the catalogs on TeamAdopted; the two saved-card buttons that resumed the session right after an adoption (« Modify the team », « Run the trial again ») are gone with the card, so nothing puts it back. « Modify » on the team card (reverse lookup by promotedTo) stays the way to reopen an adopted team, and the reopened arbitration offers retry. Nothing is deleted on disk.
  • Deleted with the card: IsSaved/NotSaved, SavedPath, InstallCommand, ReopenComposeCommand, RetryTrialCommand, ReopenAdoptedAsync and the auto-retry flag, the card's markup, eight Studio.Create.* strings in five languages. The expert-only scheduling hint (install of the promoted event) is no longer displayed: the schedule lives in the sidecar, on the team card and in the team's schedule/ folder.

Changed — Studio: « Allow a folder » opens the OS folder dialog directly; the in-app picker modal is gone (STUDIO-19)

  • The « Allow a folder » modal is deleted — path field and Browse, the one-level tree with its « already allowed » notes, the two rights rows, the expert mount-string preview (FolderPickerViewModel, its overlay in MainWindow.xaml, the modale-declarer-dossier capture stop, eleven Studio.Settings.* strings in five languages). Owner review 2026-09-19: a relic of an earlier design that the Windows folder dialog replaces outright.
  • Settings › Authorized folders: the novice card's button calls the OS folder dialog (IPathPicker.PickFolder, OpenFolderDialog); the pick lands read-only under a virtual name derived from the folder's own name — MountDefinition.SuggestVirtualPath, one derivation in Core for both doors, first free suggestion when the name is taken, reserved or unusable. The card's rights badge is now a toggle, read-only ↔ read-and-write (rwnd narrows to read-only); the novice auto-save hears it like any edit.
  • The wizard's « Existing folders » door (CreateTeam.PickFolderRequested): the same OS dialog, opened on the reopened team's folder when there is one; the pick is declared in the settings under the ROW's rights, saved, and bound behind the row — the five steps of STUDIO-14 D-10 unchanged. A cancelled dialog does nothing and says nothing.
  • IDirectoryProbe.ListSubdirectories and the LeftIndent converter leave with their only consumer, the tree.

Fixed — Studio opens on the per-user settings file (STUDIO-18)

  • The window loads %APPDATA%\Orkeon\appsettings.json at startup ($XDG_CONFIG_HOME/Orkeon/appsettings.json elsewhere) — the file orkeon init writes and the last step of the CLI's resolution chain. « Settings › Authorized folders » used to open empty on a file declaring two folders: the editor started on an empty document, and only the expert's Load button ever read the file. The location stays Global (the same file under its own name); a machine without the file starts empty with no message; an unreadable file is reported on the status line and nothing is saved over it (ConfigTabViewModel.InitializeAsync).
  • A novice edit no longer clobbers the file. The auto-save wrote the empty document plus the one edited key over a file that also held the Llm section, dropping it; the loaded document keeps every key Studio does not model, as the expert's Load/Save cycle always did.
  • Declaring a folder reaches every verdict at once. The team cards' red chips and the Run screen's refusal were computed on an adoption, a target pick or a restart only; every edit of the declared list now refreshes them, and the cards built before the file was read are rebuilt once it is.
  • The screenshot campaign no longer loads the settings file itself (CaptureShellBuilder.PrepareAsync): the shell does, as the real window does.

Changed — the output cap defaults to the model's documented maximum, not 4096 (LLM-10)

  • LlmConfig.MaxTokens is a pin, nullable, null by default. Nothing pinned means the request carries the model's documented maximum output from the new Orkeon.Constants.Llm.LlmModelOutputLimits catalogue (each entry with its vendor page and the date it was read, 2026-09-19): 128 000 on gpt-5.6-sol / gpt-6-astra and the Claude 5 generation, 393 216 on deepseek-flash, 131 072 on kimi-k3 (the vendor's own default), the GLM-5 and Qwen 3.7/3.8 families and MiniMax-M2, 65 536 on Gemini 3.x Flash, 128 000 on grok-4.6; no cap at all where the vendor documents none (Mistral: prompt plus max_tokens may not exceed the window, so the field is left out; Ollama: num_predict is left out, the runtime generates to its context); the window itself on Together, whose provider now sends context_length_exceeded_behavior: truncate; and 4096 only for a model the catalogue does not know — the value the engine used to send for every model, which a reasoning model spent thinking and answered empty (owner recette 2026-09-19, kimi-k3: two green runs, one deliverable). A pinned value — Llm:MaxTokens, ORKEON_Llm__MaxTokens, a Studio profile, a crew's max_tokens — always wins, including an explicit 4096, which the old != 4096 sentinels could not tell from "unset". Resolution lives in one place, LlmConfig.ResolveMaxTokens(provider, defaultModel). Unverified figures stay out: MiniMax-M3 (no vendor figure), HuggingFace's router (per routed provider).
  • A catalogue cap the endpoint refuses is retried once without the field, with a warning naming the model (OpenAICompatibleProviderBase.TryDropCatalogueOutputCap, matched on the field's name in the vendor's own wording); a pinned value's rejection surfaces unchanged. TryAdaptRejectedPayload now receives the effective config; Kimi's temperature self-heal defers to it.
  • Studio's profile editor says what an empty « Maximum response » means for the chosen model — the documented maximum, no cap, a local runtime, or « not in the catalogue: 4096, pin it » — and follows the model and provider as they are edited (four keys in the five resx replace the static hint). orkeon init writes no MaxTokens; the example settings templates drop theirs where the model is in the catalogue.
  • Breaking in the public API: LlmConfig.MaxTokens is int?, CreateValidated(maxTokens) takes int? (null = unpinned), OllamaRequestOptions.Builder.AddNumPredict(int?), and the YAML exporter writes maxTokens only when pinned.

Added — Studio: the Run screen shows the task in progress, pulses while it runs, stamps its journal and starts each launch clean (STUDIO-17)

  • task.started joins the run event stream (orkeon run --events jsonl): every orchestration mode announces a task the moment its agent is chosen, through a new ICrewExecutionHook.OnTaskStartedAsync (TaskStartSnapshot: task, agent role, start time) dispatched by CrewHookDispatcher like the completions. The payload is deliberately thin — nothing has been measured yet. The envelope stays at v: 2: an older client ignores the kind, and a client must not refuse a task.completed it never saw started. The hierarchical mode's task.completed now carries the agent's role under agentRole, as every other mode does, instead of the agent's GUID.
  • The Run screen shows what is running now. RunProgressModel folds task.started / task.completed into an in-flight list and tool.called / tool.returned into the tool at work; the card gets a row per running task — agent, turning glyph, « since HH:mm:ss » from the run's own clock — an activity line naming the tool, a summary that says « N finished, M in progress », and the number of tool calls on every finished row. The « running » badge pulses while the child process lives (a Style-scoped storyboard with no TargetName; CapturePose holds it at full opacity for the screenshot campaign).
  • Every launch starts clean. The journal and the previous run's verdict — exit badge, result row, « Open the result » — are cleared once per click, so a « validate first » launch keeps both passes in one journal. « Clear the journal » stays; « Copy » is how a journal survives.
  • The technical journal is timestamped. Each line shows the local time Studio read it, and the copied text leads every line with it. The CLI's own log lines keep their millisecond prefix.
  • The engine names the cause of an empty first turn. The warning « produced empty final message after N iterations » now carries the request's max_tokens and says that the tool-free retry cannot call tools and that a reasoning model needs Llm:MaxTokens 16384 or more. Owner recette 2026-09-19: a kimi-k3 profile without MaxTokens (engine default 4096) spent the budget reasoning, answered empty, and the tool-free retry narrated the .docx instead of writing it — a green run with no file. The remedy is the profile's Max tokens field; the journal now says so at the moment it happens.

Changed — the DeepSeek default follows the vendor's rename, vendor prices refreshed, catalogues reviewed (2026-09-19)

  • LlmProviderDefaultModels.DeepSeek is deepseek-flash. DeepSeek retired V4 Flash and V4 Flash Vision Exp on 2026-09-10 with the V4.1 Flash release: deepseek-v4-flash and deepseek-v4-flash-vision-exp are legacy names the API "temporarily" routes to V4.1 Flash, and deepseek-flash is the vendor's own id for the Flash tier — 1M context, 384K output, thinking on by default, native vision. Every DeepSeek configuration that names no model follows; the campaign kit, the orkeon init template, the Studio DeepSeek card, the examples and the guides name the new id, and the kit's visionModel companion is gone (the default sees). The 2026-09-07 campaign measured V4 Flash under the old name and is to be replayed. This is the only default that changes: every other default is served today, and the newer models found are recorded as candidates pending a campaign — the Mistral lesson.
  • ModelPricingRegistry follows the vendors' pricing pages (read 2026-09-19). OpenAI: gpt-5.6-sol 4 / 20 $/M (promotional through 2026-11-21; was 5 / 30), gpt-5.6-terra 2 / 12, gpt-5.6-luna 0.20 / 1.20, gpt-6-astra 10 / 50 added (its 2× billing above 272K input tokens is not expressible in a flat registry). Anthropic: claude-sonnet-5 2 / 10 (the rise to 3 / 15 was cancelled), claude-fable-5-1 and claude-fable-5 10 / 50, claude-haiku-4-5 1 / 5 added.
  • Catalogue review of the 16 providers. docs/reference/llm-providers-comparison.md gains a "Defaults and newer models" section (EN/FR) and the LlmProviderDefaultModels comments carry the dated findings: gpt-6-astra (no none effort, so the function-tools workaround cannot follow it), claude-fable-5-1, gemini-3.8-flash (GA 2026-09-02, same price until 2026-12-31), the glm-5.3 family (thinking cannot be disabled), qwen3.8-max / qwen3.8-flash (no qwen3.8-plus), kimi-k3 (fixed sampling, always reasons), MiniMax-M3, Together's zai-org/GLM-5.3-Flash, HuggingFace's Qwen/Qwen3.5-9B (the current default has tool support on one routed provider out of four), Ollama's small tools + thinking models. Nothing new for chat at Mistral and xAI.

Added — team folders travel with the team, and the forge trial reads where the documents are (STUDIO-14, lots 0 and 1)

  • orkeon forge … --read <dir> (new session and resume): the trial mounts <dir> as /workspace, read-only, in place of the working directory — which keeps every other role: the session still lives under its .orkeon/forge/<slug>/, the settings still resolve next to it. A folder that does not exist is refused before any session is created (--read names no directory, exit 1); promote refuses the option, since it mounts nothing. A read folder outside the process working directory is whitelisted for the file tools the way orkeon run whitelists its script directory — the forge's mounts are its own three roots. This is the engine hook Orkeon Studio's wizard uses to try a team on the folder chosen at its first step.
  • Studio's team sidecar (studio-team.json) records a team's own folders relative to the team: a physical segment starting with ./ (./input:/workspace:ro, ./output:/output:rw) is a folder inside the team folder, so a team copied, exported or moved keeps writing into its own folder without a rebase step. TeamCatalog resolves the entries once, at its boundary (Describe, DescribeTarget and List return absolute paths; the raw entries stay on Metadata.Mounts), relativizes on every save (SaveMetadata, SaveMounts) and creates each relative folder there — the single point where an in-team folder is materialised. Duplicate, export and import copy the entries verbatim and rewrite an older absolute in-team path relative on the way; TeamCatalog.RebaseMounts is removed. DeclaredMounts.IsInsideTeam is public and vouches for a ./ entry before the team folder exists; MountValidator.Validate takes an optional teamDirectory and skips the existence check of a relative entry until one is known. TeamMountPaths (Studio.Core) is the one helper for the convention, and FolderPolicy names the step-1 choice the wizard asks (Later / InsideTeam / ExistingFolders — the wizard entry below).

Fixed — the forge trial no longer refuses a settings file that names /output or /workspace (STUDIO-14, owner recette)

  • orkeon forge refused any settings file whose Orkeon:FileSystem:Mounts named /workspace, /forge or /output (ERROR: '/output' is a virtual root reserved by the runner…, exit 1). That guard predates STUDIO-15: since a --mount is placed by virtual root, the forge's own three mounts replace such an entry for the trial, and the Duplicate virtual paths crash the guard pre-empted cannot happen. Studio's wizard hit it on its first real team — the folder associated at step 1 is declared in the allowed folders as /output, the Studio convention for a team's write folder, and the trial refused to start. The forge now reserves /sandbox alone (the one root it does not mount itself); a settings entry on /workspace, /forge or /output is replaced for the trial and logged as mount /output: --mount replaces the settings entry, a line the forge now lets through to stderr. RunnerVirtualRoots.ForgeReserved is removed.

Added — Studio: Settings › Authorized folders lists each team's own folders, read-only (STUDIO-14, lot 6)

  • A team's own folders (./input, ./output…) are vouched for by living inside the team and are never written to the global Orkeon:FileSystem:Mounts — that would duplicate the sidecar in a file every team shares and put one team's private folders in the list every other team picks from. The settings screen now shows them all the same: the folders tab ends, in both modes, with a read-only « Team folders » section (TeamFoldersViewModel, SettingsScreenViewModel.TeamFolders) — one line per in-team folder of each adopted team, « Veille concurrentielle · /output → output » with the one-word rights badge, read from the sidecars (team-relative entries, and the absolute-under-the-team spelling of an older sidecar), never a disk path. No command, nothing written; the hint says these folders are changed from « My teams ». The section follows every change to the team list (adoption, import, deletion, duplication, the folders modal) and re-reads the sidecars when the tab opens. Keys Studio.Settings.TeamFolders{Title,Intro,Empty,Row} in the five cultures; the capture seed gives rapport-hebdo an in-team ./output:/output:rw, photographed by reglages-dossiers.

Added — Studio wizard: where the folders live, asked at step 1; « Create inside the team »; the trial reads the chosen folder; « Open the folder » (STUDIO-14, lots 2–5 and 8)

  • Step 1 « Describe » gains a fourth question, « Where are your folders? », with three chips and no obligation — composing never waits for it. « Existing folders » shows the two rows a team can address before it has a blueprint (« Your documents » /workspace read, « The results » /output written); « Choose the folder… » on either opens the disk picker on the row's rights (read-and-write for the results), and the pick is declared in Settings › Authorized folders unless already held, saved, then bound behind the row under the row's rights — one gesture, the status line says which happened, a refused save still binds. A folder picked inside the reopened team is bound and never declared. « Created inside the team » answers both rows team-relative on the spot (./input:/workspace:ro, ./output:/output:rw), read « inside the team: input / output », nothing created before the adoption. « Later » behaves as before. The chips move the two canonical roots only; composing keeps them; « Restart », a resume and « Modify » forget them, policy included.
  • The two rows are a start, not a limit (owner review of 2026-09-19): « Add the folder » names as many further mount points as the need calls for — a name the agents will use, read or written — each a row answered the same two ways (« Created inside the team » answers a new one on the spot), shown on the Composer step next to the blueprint's roots, kept across compositions, created inside the team at adoption when left unanswered; a folder added at step 1 through the picker counts as one of them. A reserved or already-used name cannot be added. Keys Studio.Create.AddRoot, AddRootWrite, AddRootHint in the five languages; the etape1-dossiers-existants stop photographs a third, user-named row.
  • Step 2 « Compose » re-shows the step-1 answers, editable as before, and gains « Create every folder inside the team » beside « Allow a folder » plus a per-row « Create inside the team ». Under the inside-the-team policy a root a later blueprint adds is answered the same way as it appears, unless dropped. A row inside the team shows a label, never a disk path, and never reads red: DeclaredMounts.IsVouchedFor (declared, or the team's own) is now the rule of the wizard's rows and of the "My teams" cards, as it already was of the launcher — a team's own /output no longer reads red on its card. The input/ warning stays for a read root answered inside the team: that input/ is created just as empty.
  • The adoption records team-relative entries for every in-team answer and every root the blueprint addresses that nothing answered (CreateTeamViewModel.SidecarMounts(), replacing WithDerivedWriteMounts(teamDirectory) — no team directory needed any more; the save creates the folders). « Modify » on a card seeds the rows from the sidecar's own spelling, so ./output reads « inside the team » and is written back as it is.
  • The trial reads where the documents are: every engine invocation of the wizard carries --read <dir> (ForgeStartRequest.ReadDirectory, ForgeArgumentsBuilder) with the folder bound behind /workspace — a real folder as it is, a reopened team's own input/ resolved under the team — and nothing before the team exists, where the argv is unchanged and step 3 says the trial runs on an empty folder. An engine that predates --read meets it only when a folder is known, and then refuses it on the failure card (STUDIO-13).
  • The Run screen turns --allow-external-mounts on by itself when a team folder is a real folder outside the team, and off when every team folder resolves under it — the launch's working directory needs no flag (STUDIO-12 C4, Studio half); the expert checkbox stays for the per-launch mounts.
  • « Open the folder » in the wizard's header, in both modes at every step: the working session — which holds the generated crew/ — before the adoption, the adopted (or reopened) team afterwards, the tooltip says which; present whenever a shell opener is wired, like the team cards' button (CreateTeamDependencies.ShellOpener).
  • FolderPickerViewModel.Open takes an initialRights; three capture stops (etape1-dossiers-existants, etape1-dossiers-equipe, etape2-dossiers-dans-equipe); fourteen new Studio.Create.* strings in the five languages.

Fixed — Studio: team cards bounded, the rights badge in one word, the closed rights list says its label (STUDIO-16)

  • A team created from a long brief — a README pasted into the name field — filled the Run screen's team card and the "My teams" card with the whole page: a WPF TextBlock renders line breaks even without wrapping and has no MaxLines. The name is now one line everywhere it is displayed (run card, team card and its tooltip, launch history) through TeamCatalog.NormalizeName — first line, Markdown stripped, cut at a word under 64 characters, the slug's cap, never empty — and adoption writes that normal form into the sidecar for every name, typed or proposed; the "Team name" field shows it live; import normalizes the name of the sidecar it copies. ShortName (48 characters, applied only to a proposed title) is gone, replaced by the Core rule.
  • The Run screen's meta line appended the whole description after the agent count and the folders — the actual text of the owner's capture, a README in the muted 12 px of the meta line, not the bold headline — and the "My teams" card showed it unbounded. Both now read TeamSummary.Summary / TargetDescription.Summary: the first paragraph without markup, cut at a word under 240 characters (TeamCatalog.Summarize), derived at read time and never stored — the sidecar keeps the whole need. On "My teams" the block is folded to three lines with a "Show more" / "Show less" link shown only when the folded card hides something; unfolded, it shows the whole need.
  • In Settings › Authorized folders, the rights badge of a mount row carried the full 52-character label and pushed the virtual name out of the list; the selected writable row was seven lines tall with the badge floating in its middle — the badge measured first took the whole row, the name was measured at width zero and, wrapping (MonoText), broke /output into one character per line. The row now puts the name first, never shrunk, and the badge last in one word (MountEditorViewModel.RightsBadge, MountRightsTokens.GetBadge, keys Studio.Settings.RightsBadgeRo/Rw/Rwnd in the five cultures) with the full label as its tooltip.
  • The three DisplayMemberPath drop-downs (the two rights lists, the trial screen's team picker) showed MountRightsChoice { Rights = ReadWrite, … } once closed: the global ComboBox template bound SelectionBoxItemTemplate but not the item template selector DisplayMemberPath goes through. The template now binds ContentTemplateSelector and ContentStringFormat like the stock one; a XAML guard (ComboBoxTemplateConformityTests) pins the four bindings.
  • The capture seed gains a team whose sidecar is a pasted README (multi-line name, forty-line need), photographed by executer-carte-equipe and equipes-liste; reglages-dossiers-selection now selects the writable mount.

Added — OpenRouter and Mammouth AI, the fifteenth and sixteenth providers — two aggregators, the one exception to the scope freeze (LLM-09)

The scope freeze said "no 15th provider — point Orkeon:Llm:BaseUrl at the endpoint", and that fallback works today for both. What it cannot do is what the owner lifted the freeze for on 2026-09-18: declare capabilities (the fallback inherits OpenAI's, so an option the aggregator ignores is a silent drop), read what the aggregator writes, and be recognised by Studio, orkeon doctor and the campaign kit. Both arrive documentation-first, the MiniMax way: every declaration is sourced from the vendor's documentation and from cold calls dated 2026-09-18, marked campaign-pending in the code, the comparison table (two † rows) and the campaign catalogue — the compiled defaults are claims until a live M1 is archived. OpenRouterLlmProvider (openrouter.ai/api/v1, key openrouter, OPENROUTER_API_KEY, default google/gemini-3.7-flash — the fleet's Gemini default under the marketplace's mandatory vendor/model id, so a red behind the aggregator with a green in direct is a fact about the transport; openrouter/auto refused as a default because it drifts) declares JsonSchema / Budget / vision, reads its reasoning field, writes the thinking controls as the reasoning request object (enabled / effort / max_tokens, the base's thinking block and first-level reasoning_effort removed so one intention is not sent twice), exposes usage.cost and its breakdown (upstream_inference_cost, is_byok, cache_write_tokens, reasoning_tokens) and the served model as served_model, and sends the two constant attribution headers HTTP-Referer (spelled as the vendor documents it) and X-OpenRouter-Title. MammouthLlmProvider (api.mammouth.ai/v1, key mammouth, MAMMOUTH_API_KEY, default gemini-3.7-flash — the same model under the bare id the proxy serves) declares nothing the vendor does not document (response_format and thinking stay None with the structured warning, vision follows the vendor's text, image list) and overrides no behaviour. Routing is by host or explicit key for both, plus the unambiguous openrouter/ model prefix; a vendor/model id alone is not an OpenRouter claim (HuggingFace and Together use the shape), a bare Mammouth id is the vendor's own string, and the pre-existing vendor-prefix inference that ignores the / is pinned as is — eight routing rows, negative pins included. The sk-or-v1- key prefix is documented by secondary sources only, so the factory does not infer from it until the first key confirms it. Full fleet integration otherwise: satellite constants and both PublicAPI.Unshipped.txt, factory, llm.openrouter / llm.mammouth in the scripting DSL (with Orkeon:DefaultLlmProvider resolving their own models rather than the platform default), doctor, orkeon llm probe|models, Studio cards and detection in five locales, the campaign catalogue with the questions each first campaign must settle, example settings, and the counts 14 → 16 under the claims gate. The scope freeze is rewritten in CONTRIBUTING.md, CONTRIBUTING.fr.md and docs/reference/limitations.md (EN/FR): sixteen providers, two of them aggregators, no 17th — the rule stands for everything else.

Changed — the OpenAI-compatible base reads what an aggregator writes, and never ends a failed stream cleanly (LLM-09)

Three changes on OpenAICompatibleProviderBase, all generic. The reasoning field is a dialect hook: ReasoningFieldName (default reasoning_content) names the field the buffered parser and the stream accumulator read the trace from, and an overload ExtractReasoningContent(JsonElement, Builder, string fieldName) joins the frozen two-argument one, which delegates to it — DeepSeek, Z.AI and MiniMax parse exactly as before, their tests untouched; the Orkeon metadata key stays reasoning_content whatever the vendor calls the field. usage.cost becomes the cost metadata (double) on the buffered path and from the final usage chunk of a stream — exposed, not accounted for: CostBudgetManager keeps estimating from the pricing registry. And a chunk carrying a root-level error after the HTTP 200 — OpenRouter's documented mid-stream failure shape, and the shape any compatible vendor writes — used to be skipped as "no choices": the chat stream completed cleanly with truncated content, and the token stream ended normally. Each path now ends the way its pre-stream refusal does: ChatStreamingAsync completes with the error / error_type metadata over the content received so far (no reassembled tool calls), GenerateStreamingAsync throws the HttpRequestException StreamingRejectionAsync throws, carrying the vendor's code as the status when it is an HTTP one. Secrets in the vendor's message are redacted; a "error": null on a healthy chunk is not an error.

Changed — a --mount is placed by virtual root against the settings (STUDIO-15, STUDIO-12 C3/C4)

  • RunnerHost places every --mount by virtual root. On a root the declared Orkeon:FileSystem:Mounts array (settings file and ORKEON_ environment) already holds, the --mount is written at that entry's index and replaces it for the run — logged as mount /x: --mount replaces the settings entry; on a new root it is appended after the highest declared index. A settings entry and a --mount naming the same root used to reach FileSystemRegistry as two mounts and fail every such run at kickoff with Duplicate virtual paths out of a DI factory — which is exactly what Studio's team flow produced by design, since a team associates a folder the settings already declare, verbatim. InternalMounts keep appending. Only a case that failed changes outcome.
  • RunnerExecution.EnsureVirtualRootsAreUnique (public, wired in the YAML runner's TryBuildHost and in orkeon run's script path): two --mount on one root, or a settings file declaring one root twice, exit 1 with one actionable line (ERROR: '/x' is mounted twice on the command line: <a> and <b>. Keep one. / … declared twice in <settings>) before any host is built. Using settings: … is now printed once every mount guard has passed, so a refusal never reads as a run that started.
  • A DI-factory failure at kickoff ends stderr with ERROR: <message> as the last line (the sentence exit code 2 promises); the Crew execution failed log entry carries the message only, and the exception with its stack trace moves to a Debug entry (--verbose 2, or ORKEON_DEBUG=1 on stderr).
  • A mount declared in the settings is always whitelisted for PathValidator (STUDIO-12 C4): its base path joins PathSecurity:AdditionalAllowedDirectories without any flag — a declared folder is the machine owner's explicit intent. Until now such a folder outside the process working directory was mounted and every access refused as "outside the allowed workspace directory", and --allow-external-mounts could not rescue it since it only whitelists --mount arguments — which it still does, and only that.
  • Studio predicts the by-root rule (MountOverrideSemantics.ComputeEffectiveMounts, the Studio.Settings.Explanation / ThisLaunch / EffectiveReplaced strings in the five languages): the effective-mounts table shows one row per root, the settings entries in place, --mount (replaces «…») on a replacement, and the runner's own /crew mount appended after the declared entries — instead of the index-0 masking that never happened. An empty --mount entry is reported against the --mount option rather than a configuration key the arguments alone cannot know.
  • Studio never lays a settings entry twice (LaunchMountPlan.WithoutSettingsDuplicates): a team folder the settings already hold — same folder, same name, same rights — stays off the command line; the same folder under another name, or with other rights, is laid and shown as the replacement it is. The Run screen's settings-mounts list now follows the settings the run will find: the pinned --settings file, or « Settings › Authorized folders » in automatic mode.

Added — Studio: a failed « Composer l'équipe » is said, with the technical part copyable (STUDIO-13)

In novice mode the creation wizard kept its promise of a screen without machinery right up to the first failure, where it showed nothing at all: no orkeon binary, an appsettings.json the engine refuses, a non-zero exit — a click, a spinner, then step 1 again, with the reason on a grey one-line status (truncated, untranslated) or nowhere, and the whole stderr in a technical journal only the expert mode displays.

  • CreateTeamViewModel carries one failure model, WizardFailure (Kind, Headline, Detail, CommandLine, ExitCode, Stderr, EngineError, Journal), exposed as Failure / HasFailure, with BuildFailureReport(), CanCopyFailureReport and FailureReportCopied on the diagnostic screen's pattern. Five families, classified on the run outcome, the engine's error event and the exit code: EngineMissing (the locator found no binary — NotStarted), ConfigRefused (an error event with recoverable: false, a FORGE-* code), EngineStopped (non-zero exit, with or without stderr — and a session that reported failed), Unknown (an exception out of the launch, which used to reach a MessageBox at best — RunEngineAsync now catches it, cancellation excepted) and PromoteRefused (step 4, no promoted event). « Arrêter » never produces one.
  • The report is the orkeon forge command line, the exit code, the engine's code and message, the detail the card shows and the whole journal — the WHOLE stderr, where the status line only ever kept the last line.
  • CreateTeamView shows the card under the status line in both modes, bordered in the danger colour on the assistant gate card's pattern: the novice sentence of the family (localized, five cultures), the engine's own text in mono (wrapped, bounded, scrollable, never translated), and « Copier le rapport » (« Copié ! » for 1.6 s), « Réessayer » (the compose at step 1, the save at step 4) and, by family, « Ouvrir le diagnostic » (the doctor re-runs on arrival) or « Ouvrir les réglages ». It clears on the next composition and at the start of every run; the status line, the expert journal and the fault MessageBox of the other commands are untouched. Studio.Create.StatusFailed now says where the detail is («the detail is in the card below»), true in both modes.
  • Capture campaign: a stop etape1-echec-moteur (both modes, both themes, language sweep) photographs the card by taking the CLI away from the seeded machine and clicking — the owner's own recipe, through the real locator; with the three STUDIO-14 stops the catalogue is pinned at 52 stops, 282 shots.
  • Tests: A_missing_engine_is_said_on_step_1_with_a_copyable_report, A_non_zero_exit_without_stderr_still_shows_a_failure_card, An_unrecoverable_engine_error_names_its_code_and_message, The_failure_report_carries_the_command_line_the_exit_code_and_the_whole_stderr, A_new_compose_clears_the_previous_failure, A_refused_promotion_uses_the_same_failure_card, An_exception_during_the_launch_becomes_a_failure_card_rather_than_a_fault, Stopping_the_engine_raises_no_failure_card.

Fixed — the team journey on a real crew: order, empty answers, single-file teams (STUDIO-12)

  • Task order follows dependencies, in every layout. Without a plan, the sequential strategy — and the hierarchical, consensual, graph and autonomous modes, which hand their tasks out one after another — now runs the crew's tasks in a stable topological order on their declared dependencies (TaskExecutionOrder in the Domain, CrewTaskSequencer in Infrastructure): a task runs after every task it depends on, and the declared order is kept wherever the dependencies allow it. The multi-file layout lists tasks in the ordinal order of their file names, so consolidate.yaml ran before the extract.yaml it depends on — silently, with a green run. An unknown dependency is ignored; a cycle keeps the declared order for the tasks caught in it and logs a warning. The orchestrator no longer synthesises a "plan" from crew.Tasks when planning is off.
  • An empty final answer is never a green run. A model that answers with empty text — and empty text again on the tool-free retry — exits AgentExitReason.EmptyFinalAnswer (new member) in the three agent loops, including on the very first turn, which used to pass as Completed; the task fails with the reason in TaskResult.Error (a failed exit used to leave it null), a sequential crew with a failed task reports failure with the reason (CrewOutput.Error, new; CrewHookStatus.Failed → AUTO_SUMMARY.md and the error run event), and the one-shot runner exits 2 with ERROR: <reason> as its last stderr line — it returned 0 for every crew failure, so run.finished said success:true over an empty output mount. The reason names Llm:MaxTokens, the setting that usually explains it for a reasoning model.
  • Studio: MaxTokens on the model profile. ModelProfile.MaxTokens (null = the engine default, 4096), emitted as ORKEON_Llm__MaxTokens, round-tripped by the store and editable in the profile editor next to temperature and timeout, with a hint that a reasoning model needs 16384 or more.
  • Studio: the profile store reads case-insensitively and says when a file is unreadable. A hand-written camelCase studio-model-profiles.json loaded zero profiles, silently; a file that fails to parse was indistinguishable from an empty one. LoadAsync now returns a ModelProfileLoadResult whose Error the settings screen shows.
  • Studio: a folder holding a single-file crew is a team. The target detector resolves a folder with no layout marker and no script but one *.yaml/*.yml file as that file (RunTargetKind.SingleFileCrewDirectory: run path = the file, selected path = the folder, at the root or under the promoted crew/ nesting); several YAML files resolve to crew.yaml then config.yaml, else are offered as candidates. TeamCatalog.Import runs the detector before copying and refuses, with the detector's message, a source it cannot resolve — it used to copy any folder verbatim into a team nothing could run.

Changed — the scripting runtime runs its loops in JavaScript (SCR-25)

A Jint engine has one event loop and one drainer at a time, and the runtime kept re-entering it from the wrong side: C# loops that invoked script functions after an await, or blocked on a promise from inside one of the engine's own jobs. Measured through ScriptHost against a provider that really suspends (Task.Delay(3), the shape of every HTTP provider): a crew run placed after any top-level await hung — a file read or a tool call before crew.run() was enough, and the second of two sequential runs hung too; a state graph whose nodes suspend timed out at 10 s from a body, and hung outright when run() followed an await; five concurrent ctx.state.with crashed the engine or timed out; a topic handler that awaits so much as a microtask timed out when publish() came after the body's first await — and was delivered when it came before; FSM onEntry/onExit that await the model timed out; an async onAgentStart reached through ctx.spawn timed out; an async onCrewStart never returned; act's onDelta ran on a pool thread while the body was drained on another; and for await over runStream threw The value is not iterable. The fifteen reproducers of EngineThreadingContractTests pin the family; all of them run.

The fix is one rule, applied everywhere: every loop that calls back into script code lives in JavaScript. crew.run/runAgent/runStream, stateGraph.run/runStream, stateMachine.send, ctx.state.with, topic.publish, the event's lock and ctx.llm.act are async functions (generators for the streams) built from a JavaScript factory; the CLR hands them synchronous helpers and Tasks to await, and never re-enters the engine from a continuation. A helper that fails throws in JavaScript (JsHostError: an Error carrying the CLR exception on clr), so the script's catch/finally run and the typed exception comes back out. The CLR drives the engine at three root pumps only — ScriptHost for the script, JsCrew.RunAsync for the globalThis.crew handoff, JsTool.CallAsync for a script tool the orchestrator calls — each on an engine at rest, under the per-engine gate, one thread for the whole evaluation, bounded by its cancellation token: the three 30-minute promise ceilings (BodyPromiseTimeout, ToolPromiseTimeout, LoadPromiseTimeout) are gone. The model is written up in docs/architecture/scripting.md (EN + FR).

Breaking for C# callers. JsCrew.run, runAgent and runStream, JsStateGraph.run and runStream, JsStateMachine.send, JsAgentContext.stateWith, JsEventTopic.publish, JsPublishedEvent.lock and JsLlmFacade.act are JsValue properties now — the JS functions themselves, not CLR methods. A host runs a crew through JsCrew.RunAsync(options, ct); the script surface is unchanged, and so are the typings but for one correction: onCrewError's second argument is declared string — the displayed message the runtime has always passed — where crew.d.ts promised an Error no script could read .message off. What one loop doing the work of several changes for scripts:

  • An onCrewStart that throws fails the run and reaches onCrewError (it ran outside the error path before); a run started on an already-cancelled signal skips onCrewStart, and onCrewError still runs (a C# caller with a cancelled token gets OperationCanceledException before any hook). An onCrewError that throws itself is logged and the original error is what the caller receives — it used to replace it.
  • Cancellation bypasses onError: a cancelled run rethrows without consulting the policy (it used to consult it with code unknown, then throw at the next step anyway). And err.code for a failure that arrived as a faulted Task maps from the innermost CLR exception (receive_timeout for a ctx.receive({ timeout }) that expired, …) instead of unknown for the wrapper.
  • An async onAgentStart/onAgentStop that rejects is logged as a warning; it no longer throws out of crew.add, ctx.spawn or crew.remove, which stay synchronous and never drain the hook.
  • crew.runAgent runs its target under the instance semaphore, with an AgentContext and the agent's own onError policy; it accepts a name or an Agent, honours opts (signal, timeout), and throws RecursiveAgentInvocationException when called on the agent whose body is executing instead of deadlocking on the semaphore that body holds. It used to invoke body(input, undefined) bare.
  • A run opened from a body — crew.runAgent, await sub.run() on another crew — without { signal: ctx.signal } is a child of the run that opened it: cancelling the outer run cancels it, and its semaphores come back inside the outer run's own unwind. It used to run on with no token of its own, and a sub-crew whose body never settled kept its semaphore for good. The link is best-effort under runs interleaved on one event loop (it reads the most recently opened attempt still open); the explicit signal remains the exact form. And a cancellation the loop meets on a Task it awaits itself — the instance semaphore, a retry delay — rejects the script with the same bridged OperationCanceledException (clrType, message) as a raced body await, not Jint's raw cancelled-task object.
  • crew.runStream is the run, observed as a stream: same semaphore, contexts, hooks and spans as run; at is epoch milliseconds (Date.now()) instead of .NET ticks; break out of the for await ends the run without firing onCrewComplete or onCrewError.
  • ExecutionTimeout and MemoryLimitBytes (Orkeon:Scripting:Limits, 30 s and 100 MB by default) span a whole CLR-driven run — the globalThis.crew handoff through ScriptHost.RunAsync, JsCrew.RunAsync — as they already spanned a whole script; both used to re-arm per agent body (Jint resets its constraints at each non-nested entry, and the run is one entry now). A host driving a longer run, or a many-agent one that allocates, raises the limits, as a long script already required.
  • ScriptHost.RunAsync and JsTool.CallAsync propagate cancellation as OperationCanceledException — a 30-minute wait that ignored the token, and a failed ToolCallResponse, before.

Fixed — the quickstart's first CI run failed, and three things came out of it

The first run of quickstart.yml on a GitHub runner did everything the README says — pinned Ollama, the tool installed from the checkout, the settings found next to the crew — and wrote no file: llama3.2:1b under Ollama 0.34.0 answered the file_write call as text, the whole JSON envelope with a broken string inside ("content": "create_backup": "False"), the loop took that text for the final answer, and the run "succeeded" with the envelope as its deliverable. Reproduced here byte for byte with the same Ollama build (four runs out of four, 550 tokens each; under 0.12.3 the same model makes a real tool call — the server's template and parser changed between the two).

  1. A JSON envelope written as text is a tool call. ToolCallTextParser gains the third shape next to [TOOL_CALL] and <invoke>: {"name", "parameters"|"arguments"}, {"type":"function","function":{…}}, {"type":"function","function":"<name>", …}, a tool_calls array, fenced or not, with raw line breaks inside strings repaired before parsing.
  2. An answer shaped like a tool call that cannot be executed is not a final answer. The loop hands it back with the fix the model needs (call the tool, or write one valid JSON object), twice at most, then lets it stand — LooksLikeToolCallAttempt requires the envelope vocabulary and one of the agent's tool names, so a JSON deliverable is never mistaken for one.
  3. The quickstart model is qwen2.5:1.5b. Smaller (986 MB against 1.3 GB) and it calls the tool the way a tool is called: measured 5/5 under Ollama 0.34.0 and 3/3 under 0.12.3, before and after the two guards above; llama3.2:1b still fails 3/3 after them (it repeats the same broken string). README, quickstart, Aspire example and workflow cache key follow.

Added — Orkeon.Hosting.Aspire, and runners that export OpenTelemetry by the standard contract (ADR-011)

The runners built their host with the parameterless AddOrkeonInfrastructure() (no telemetry), never started it (OpenTelemetry's hosted service never created the providers) and ignored OTEL_EXPORTER_OTLP_ENDPOINT: a run launched from .NET Aspire produced spans that went nowhere. RunnerHost now registers telemetry from the settings, honours the standard OTLP environment for traces, metrics and logs, and resolves the providers itself after the build. Measured with a two-line OTLP sink and the quickstart crew: v1/traces with invoke_agent Scribe, chat llama3.2:1b and execute_tool file_write (gen_ai.* attributes), v1/metrics, and v1/logs at verbosity 1 — with nothing but the environment variable set.

Orkeon.Hosting.Aspire (ninth id of the lineup, PUB-25 wrapper on Orkeon + Aspire.Hosting 13.5) adds AddOrkeonHost (the orkeon-host daemon) and AddOrkeonCrewRun (one orkeon run, with its /output mount created by the AppHost) as executable resources, WithOrkeonSetting / WithOrkeonModel for the ORKEON_ environment, and .WithOtlpExporter() applied. Three launch-free tests evaluate the arguments and environment Aspire would hand the process (the OTLP endpoint included); examples/aspire/AppHost/ ran the quickstart crew as a resource on this machine — out/hello.md written, dashboard up. The decision that goes with it: the Aspire dashboard is the cross-platform observability surface, and no web Studio will be built.

Added — Orkeon.Interop.AgentFramework: Microsoft Agent Framework, in both directions (ADR-010)

A developer with Microsoft Agent Framework code can try Orkeon without giving anything up, and an Orkeon crew can be one more agent in a MAF workflow. One package, depending on Orkeon and Microsoft.Agents.AI.Abstractions 1.20 only, eighth id of the NuGet lineup: CrewAgent : AIAgent (a crew as a MAF agent — one kickoff per RunAsync, the conversation as initial context, the final output as the assistant message, token telemetry as Usage, stateless sessions that still serialise), AIAgentLlmProvider : ILlmProvider (a MAF agent as the model of an Orkeon agent — AgentBuilder.WithAgentFrameworkAgent, one MAF session for the provider's lifetime) and AIAgentTool (a MAF agent as a tool of an Orkeon agent — WithAgentFrameworkTool, the mirror of MAF's AsAIFunction()). AddOrkeonAgentFramework() registers an ICrewAgentFactory. Eleven tests with hand-written doubles; examples/interop/agent-framework/ runs both directions on the configured model — verified on llama3.2:1b via Ollama.

Fixed — the initial context of a kickoff reaches the agents

CrewInput.InitialContext was mapped into the domain input and read by nothing: orkeon run --initial-context, Studio's field and every programmatic CrewInput.Empty("…") reached no prompt — a crew asked to "summarise the text given as initial context" answered "what text?". The orchestrator now exposes it as the initial_context prompt variable (listed under Context Variables and available to {initial_context} templates); a caller-supplied variable of that name wins.

Changed — a run now produces spans, and they speak the OpenTelemetry GenAI conventions

The telemetry plumbing was complete and unused: TracingInstrumentation, OrkeonMetrics and the seven ActivitySources were called by one IChatClient decorator that only the tests instantiated, so a real crew execution emitted no span at all — and the attribute names were Orkeon's own (orkeon.llm.model), which no backend recognises. The ActivitySources move to the Application layer (OrkeonActivitySources, same names; Infrastructure's OrkeonDiagnostics re-exposes the same instances) and the execution path emits on them: invoke_agent {agent} around each agent turn, chat {model} (kind Client) around each model call with the request/response/usage attributes, execute_tool {tool} around each tool call with the model's own call id — children of the agent span, error.type and an error status on failure. The names and attributes are the generative-AI semantic conventions, declared once in Orkeon.Constants.Llm.GenAiAttributes (ADR-009 satellite) and used by the loop, the tracing helpers and the scripting runtime alike. OrkeonDiagnosticTags keeps its member names but its LLM/agent/tool/error values are now the convention's (gen_ai.provider.name, gen_ai.request.model, gen_ai.usage.input_tokens…); OrkeonMetrics records gen_ai.client.token.usage (per token type) and gen_ai.client.operation.duration (seconds) instead of orkeon.llm.tokens / orkeon.llm.duration. The Terminal.Gui tool aggregator identifies tool spans by gen_ai.operation.name rather than by a span name. Documented in opt-in-subsystems.md (EN + FR).

Added — a Contributor License Agreement template, and the check that asks for it

Zero external contributors, zero Signed-off-by, and the intent to hand the project to a foundation one day: the only cheap moment to put a licence frame in place is before the first outside pull request. CLA.md / CLA.fr.md are an individual CLA template, marked on their first line as awaiting counsel's validation — the licence is granted to the current maintainer and any successor entity, so the transfer needs no second round of signatures. cla.yml (contributor-assistant/github-action, pinned by SHA, signatures on this repository's cla-signatures branch, no external service, no PAT) posts the one sentence to reply with and stays red until it is posted; the maintainer account and dependabot are allowlisted. CONTRIBUTING (both languages), the pull-request template and the docs-parity gate know about it.

Changed — .NET 11 readiness, without moving the target

ci.yml gains a non-blocking job that restores, builds and tests Orkeon.sln with the .NET 11 SDK (preview channel until GA on 2026-11-10), widening global.json's roll-forward on the runner only. Verified locally with 11.0.100-rc.1 — and that build was red: the 11 SDK ships three analyzer rules the 10 SDK does not, all fixed so the job starts green. CA2027 (a Task.Delay that lost a WhenAny race keeps its timer alive) in the Studio process launcher, the capture settle and context, and the Terminal.Gui shutdown grace period, now WaitAsync(timeout); CA2026 (JsonDocument.Parse(...).RootElement leaks the document) at 55 sites in MCP and the tests, now JsonElement.Parse; CA1860 (Any() on a collection with a Count) at 3 sites in test doubles. Both dotnet tools (orkeon, orkeon-repl) now declare RollForward=Major: a machine whose only runtime is .NET 11 runs them instead of printing "You must install .NET". The target framework, global.json and the container base images do not move before GA.

Changed — the pre-release upstream of Orkeon.Tools.Embeddings.Local is assumed, in writing

SmartComponents.LocalEmbeddings has one version, a pre-release, and an archived upstream. Rather than vendoring its inference wrapper, the packaging project of the opt-in silences NU5104 — the only project that ever carries the dependency — and the decision is recorded where it is read: one line in the README's installation table, a paragraph in limitations.md. Verified: dotnet pack Orkeon.sln -p:VersionSuffix= -warnaserror produces the nine 1.0.0 packages, the opt-in depending on the pre-release as declared.

Changed — the README opens on the problem, then on a command that runs without a key

The front page used to open on one crew, three ways and a YAML block — a pitch to someone who had already decided, on the one promise Microsoft Agent Framework has also kept since July. It now opens on the problem: a coding agent let loose on a repository writes where it should not, because nothing is there to stop it. Then on what Orkeon puts in front of the model — the virtual file system and its declared mounts, the sandbox, the execution budget, and Orkeon.Compliance.Vfs as a standalone analyzer for the reader's own code — and on a three-line block that runs a crew on llama3.2:1b with no API key: examples/quickstart/ (one agent, one file_write, one rw mount, its own appsettings.json pointing at Ollama). Measured on 2026-09-11: the crew writes out/hello.md in 14 s; the same crew asked to write /etc/hello.md is refused by the file-system service before any byte lands (No mount found for virtual path). orkeon forge gets its own section — the brief → blueprint → render → validate → test → diagnose → verdict cycle, the four commands, the FORGE-LLM-UNAVAILABLE door. Quick Start — one crew, three ways moves down, unchanged. The compliance vocabulary — NIST, DLP, memory encryption, key rotation — leaves the README and the docfx landing page; every subsystem stays in the code and in the reference pages (opt-in-subsystems.md, security.md). index.md / index.fr.md open the same way.

Added — the README's quickstart block is executed by CI, literally

quickstart.yml cuts the fenced block between the <!-- quickstart:begin --> / <!-- quickstart:end --> markers out of README.md, checks that README.fr.md carries the identical block, and runs it on a GitHub runner: a pinned Ollama release checked against its published digest (no curl | sh), the orkeon tool installed by the block's own dotnet tool install line — resolved to a pack of the checkout under test through a nuget.config that names that pack as the only source — then out/hello.md must exist and say hello. Change the README, the job runs the new README; break it, the build is red.

Fixed — a tool-call envelope inside the arguments no longer trips the circuit breaker

llama3.2:1b answers a file_write call with the whole envelope as the arguments — {"type":"function","function":"file_write","parameters":{"path":…,"content":…}}. The dispatcher passed it through, the tool saw no path, said so, and the model repeated the identical envelope until the circuit breaker tripped after three iterations. When every key of the arguments belongs to that envelope (type, function, name, parameters, arguments) and the payload is an object — or a JSON-encoded one — ChatToolDispatcher now unwraps it. Anything else is left exactly as it was.

Changed — coverage is measured in public, and the README quotes no number for it

The README stated 82.7 % line coverage from a SonarQube pass on one machine whose report the repository does not track. A new coverage.yml workflow runs the unit and fast suites under a pinned dotnet-coverage on every push to main and weekly, refuses an empty measurement, writes the summary on the run page and keeps the Cobertura file plus an HTML report as an artefact. The README's status section links to the workflow and quotes neither the coverage nor the SonarQube figures any more; quality-gate.md explains where the checkable number comes from and what it covers.

Changed — the numbers on the front page are counted by one rule, printed with it, and exact

Three sources gave three tool counts: 75+ in the README, 79 in CLAUDE.md, 73 from a grep by base class. All three were "true" under their own rule; none published it. The rule is now one — a *Tool.cs file under src/ is a built-in tool (the grep undercounted: the four relational-database tools, the two file-search tools and the code interpreter derive from intermediate bases) — and the number is 79 on every page, exact: the N+ floor check-doc-claims.py used to accept is rejected as a number nobody can check. The example count is measured on disk (examples/NN-*/NNN-*/ holding a config.yaml or a main.ork.ts, 105) and examples/INDEX.md is checked against it, rather than the other way round. The memory-store count (6, classes deriving MemoryProviderBase) joins the gate. scripts/count-surface.sh — check-doc-claims.py --surface — prints every front-page number next to the rule that produced it, JSON on request. The walks are pruned at the directory level: the gate took four minutes on this tree, it takes seventy seconds.

Added — the provenance chain is documented, verified on rc.3, and closed with an SBOM

The CI already did what almost no .NET open-source project does — Trusted Publishing by OIDC, actions/attest-build-provenance on every package and every release asset, ContinuousIntegrationBuild at pack time, SHA256SUMS per channel — and said so in one line of one reference page. Verify what you install (EN + FR) now gives the exact gestures, each run against the published v1.0.0-rc.3 artefacts before being written down, and states what the chain does not prove.

Two measurements shaped the page. A release asset verifies as downloaded: the GitHub attestation API returns one SLSA v1 statement for orkeon-cli-1.0.0-rc.3-osx-arm64.tar.gz, builder release.yml@refs/tags/v1.0.0-rc.3, eleven subjects. A package downloaded from nuget.org does not: nuget.org repository-signs every package by appending a .signature.p7s entry, so its digest is no longer the attested one. The signature is always the last entry, so scripts/nupkg-unsign.py (standard library, no re-zipping) recovers the original bytes exactly — measured digest 5800062e…cbb8e7 for Orkeon.1.0.0-rc.3.nupkg, which the API resolves to the publish.yml statement with its nine subjects. SECURITY.md gains a Verifying what you install section and the README installation table a Verify what you download row.

The one missing piece of the chain was the cheapest: both publish.yml and release.yml now generate a CycloneDX SBOM of Orkeon.sln (CycloneDX dotnet tool 6.2.0, pinned; 199 components on rc.3) right after the build and cover it with the same attestation — a release asset with its SHA256SUMS line, and a sbom run artefact for the package push.

Fixed — Orkeon.Compliance.Vfs reaches NuGet.org, and works once it gets there

The analyzer was IsPackable, packed at every tag, and never pushed to nuget.org: the publish lineup was a fixed list of six ids in two places. It is the seventh now, in all seven hand-maintained copies check-doc-claims.py compares.

Pushing rc.3 would have shipped an inert package. Built against the repository's pinned Roslyn 5.9.0, it was refused by the compiler of a stock .NET 10 SDK (10.0.301 ships 5.6.0) with CS9057 — a warning, after which the analyzer is silently skipped. A fresh project with a File.ReadAllText call built clean. The package is now compiled against Roslyn 4.8.0 (the .NET 8.0.100 compiler; VersionOverride on the one reference), and the same fresh project reports ORKVFS001 and ORKVFS002 as errors. Its README is rewritten for a consumer who has never heard of IFileSystemService: the seven rules, the path exemptions, the name-matched suppression attribute to declare locally, .editorconfig severities.

Changed — the front page stops asserting what git tag already says, and says who answers

The README and CLAUDE.md claimed "the latest tag is v1.0.0-rc.2" two days after v1.0.0-rc.3 was tagged and its six packages were on NuGet.org. Tag state is no longer asserted in prose anywhere: scripts/check-doc-claims.py rejects the sentence shapes that rotted (not yet tagged, latest tag is, and their French forms) and, when the clone carries tags, fails the build if a v* tag newer than the props version exists — the version bump that follows a release can no longer be forgotten silently. ci.yml checks out with tags for that purpose.

.github/CODEOWNERS routed every review to @Orkeon/maintainers, a team that does not exist — which GitHub treats as no owner at all. It now names the maintainer account.

SUPPORT.md gains an If the project stops section: MIT, a build reproducible from a public clone, every action and base image pinned, no private infrastructure on the path — so a fork that keeps the tests green is a full replacement. The README links to it.

CONTRIBUTING.md opens its Areas for Contribution with a scope freeze: no 15th LLM provider, no new built-in tool, memory store, language adapter or orchestration mode until real users ask — one maintainer carries the whole surface. The former wish list (Cohere, Vertex AI, Qdrant, a web UI, calendar tools…) is gone; interoperability, observability, tests, docs and bugs are what remains open. limitations.md records the rule and the issue chooser links to it before a proposal is typed.

1.0.0-rc.3 - 2026-09-07

The release candidate that opens the repository. Since 1.0.0-rc.2: the NuGet distribution collapses from a per-layer lineup into a single Orkeon package plus Orkeon.Tools and the opt-ins (PUB-25); the example catalogue drops its dedicated C# trading runner and speaks TypeScript end to end; MiniMax and Grok bring the provider fleet to 14 (Groq removed, no shims); the VFS boundary is enforced everywhere by its own analyzer, and virtual paths became the only currency an agent is paid in (ADR-008); constants shared by two projects moved to zero-dependency satellites (ADR-009); and a full SonarQube campaign closed every issue above INFO — 0 bug, 0 vulnerability, 0 hotspot, technical debt down from 1 762 minutes to zero, A on all four ratings.

The public API surface is frozen at this tag: the 328 additions and 203 removals accumulated since rc.2 move from PublicAPI.Unshipped.txt to PublicAPI.Shipped.txt across the twelve projects that carried them, and the seven ORKVFS analyzer rules ship with them.

Changed — the scripting DSL stops dropping half of what a script declares in silence

A .ork.ts file picks one of two engines by how it ends, and each engine honours what the other ignores. A crew that declares tasks and ends with await crew.run() ran its agents and never looked at the tasks; a crew that declares .body() and hands itself off with globalThis.crew = crew ran its tasks and never invoked a body. Both produced a run that succeeded, printed a plausible result, and said nothing about the half it had thrown away.

Both halves now warn, symmetrically and by name. JsCrew.RunAsync reports the tasks it will not read (with the count), a manager it will not use, and a process(...) that reaches only a telemetry tag. JsCrewConfigurationAdapter.CollectIgnoredFeatures reports .body(), .withState, .onError, .onAgentStart/.onAgentStop, budget() and the crew hooks — each naming the agent it was written on, because "a body was dropped" in a six-agent crew is a second search. The runner logs them; orkeon run also warns on stderr when --inputs, --inputs-file or --memory-limit-mb is passed to a script that hands its crew off, since those options have no equivalent on that path and globalThis.inputs is never planted.

.concurrency(n > 1) is deliberately not in that list: JsAgentBuilder.build() already throws on it, so no crew carrying one can reach the adapter. A warning for an impossible state is noise.

Removed — crewBuilder().graph(), a method whose argument no engine ever read

.graph(stateGraph) stored its argument in a private field that reached neither JsCrewDefinition nor JsCrew nor the declarative adapter — and process("graph") refused to build without it. The one crew mode that needed the method was gated behind a method that discarded what it was given, and no file in the repository ever called it.

The two facilities share a word and nothing else. process("graph") runs the crew on the domain's graph strategy — a fixed agent_execute → route_decision loop with a circuit breaker, tuned by GraphConfig. stateGraph({ nodes, edges }) is the topology the script draws, and it runs on .run() from an agent .body(). Removing the method unblocks the mode: process("graph") now builds on its own. Same treatment as when() earlier in this release, and for the same reason — nothing is released at rc.3, and this repository takes no compatibility shims.

Fixed — the ONNX crash CI had been tolerating was a call into a disposed session

LocalEmbeddingProvider, shipped in the Orkeon.Tools.Embeddings.Local package, set a _disposed flag in Dispose() and never read it again. EmbedBatchAsync and Dimensions went on to use the LocalEmbedder whose native ONNX session had just been freed. Both now throw ObjectDisposedException, so a disposed provider refuses the call instead of dereferencing freed memory — which for a library means it can no longer take its host process down at shutdown.

The visible symptom was a test suite that killed its own process. Dispose_Releases_Embedder asserted that a disposed provider "raises any exception", an assertion written over undefined behaviour. On a warm heap the freed session returned nonsense (OnnxRuntimeException: input name cannot be empty); on a dirty one it was a SIGSEGV. Measured: the class crashed 5 runs out of 5, while each of its tests run alone crashed 0 out of 3 — the crash needed the earlier tests to dirty the heap first. After the fix, 17 consecutive runs exit 0 with all 11 tests green. The test now asserts ObjectDisposedException exactly, and a second one covers Dimensions.

That crash had been recorded as an ONNX Runtime teardown artefact (PUB-17 / SONAR-14). ci.yml and publish.yml each carried a step tolerating exit 139 whenever "every discovered test was accounted for" — but the accounting came from the crashed process itself, so a truncated run always matched, and a crash landing before the first result reported zero tests and failed the step anyway, which is how the CI run of 2026-09-07 went red. Both steps are plain dotnet test runs again, integration.yml no longer excludes the project from the nightly sweep, and docs/reference/limitations.md (EN+FR) now records what the crash was instead of what it was taken for.

Fixed — the final pre-publication review: what eleven reviewers found in the tree they were about to make public

Security. Web tools no longer share the host's ambient HttpClient: AddOrkeonWebTools registers its own named client (WebToolExtensions.HttpClientName) with AllowAutoRedirect = false, closing an SSRF-by-redirect hole where a validated first hop could redirect a request to a metadata endpoint the guard never saw. The RAG WebPageLoader gained the guard it never had: it validates through IUrlValidator before any fetch and fails closed when no validator is registered, so rag_ingest can no longer be pointed at 169.254.169.254. Both SSRF guards learned the IPv6 addresses they were letting through -- ::, ff00::/8 multicast, the 64:ff9b::/96 NAT64 prefix, and IPv4-compatible ::x.y.z.w forms judged against the IPv4 table -- and a new test pins the two tables against each other so they cannot drift. http_api now runs LLM-supplied headers through the header sanitizer instead of forwarding them verbatim, with a default sanitizer backing every construction shape, so a model can no longer set Host or Cookie or smuggle a CRLF. The shell tool clears the child's environment down to a named allowlist rather than handing it every variable the host process holds, and its read-only git guarantee inspects every token instead of the subcommand alone (git log --output=/tmp/x was a write). LogSanitizer learned the key shapes this repository actually ships -- underscores inside keys, xai-, hf_, tgp_v1_, tvly-, xox[abp]-, AIza, and the dotted DashScope form -- and the two sk- patterns became one, which also fixed a case where the narrower pattern matched first and left the tail of a key in the log.

Contracts that lied. SandboxOptions.RequireHumanApproval and PreferredSandbox were public, documented, bound from configuration and read by nothing; an option that promises a human gate and does nothing is worse than no option, so both are removed. LlmConfig.ApiKey stopped being [Obsolete]: it steered every caller to ApiKeySecretName, which the framework never resolves, so following the compiler produced an unconfigured provider -- ApiKeySecretName is now documented as reserved and the limitation is recorded. Azure OpenAI's direct streaming path threw instead of ending on silence, joining what the other providers already did; and the three buffered streaming fallbacks (RateLimitedLlmProvider, HttpLlmProviderBase's default, the IChatClient adapter) stopped swallowing a provider's refusal and re-emitting it as an empty stream.

Distribution. Both tool packages redistribute ONNX model weights, and neither carried THIRD-PARTY-NOTICES.md; the notices now travel with them, in the two nupkgs, the installer archives and the Debian package. The package-closure gate walks the whole transitive ProjectReference tree, so an assembly that ships in no lineup package fails the gate instead of reaching a consumer as a FileNotFoundException.

Command line. orkeon --help, orkeon help and a bare orkeon print a usage page listing every verb and exit 0, instead of listing nothing and exiting 1; an unknown first token is rejected by name rather than falling through to run.

Studio. Three English catalogue values still named French buttons; the orphan-key drift gate filtered on a key prefix no key carries, so it checked nothing; and a resumed forge session dropped most of the metrics last-run.json carries.

Documentation. The pages stopped describing a repository that does not exist: the install lines carry --prerelease, the phantom --config flag became the positional <config> the CLI really takes, examples/README.md names the environment variable the runtime actually reads, the release pipeline is drawn from release.yml's own job graph, the quality-gate policy dates its measurements against the September report, SECURITY.md admits that shell_command ships registered, the runner logging default is Warning and says so, the English Studio page quotes the English catalogue, and the documentation site has a published address. Every src project has a README.

Two more guards, caught by the same pass. The Guardian's own SSRF check was the third guard on this surface and had kept a hand-written IPv4 regex while the other two were hardened; it now judges through UrlValidator's tables, so [::1], [::], the IPv4-mapped and NAT64 forms of the metadata endpoint and 100.64.0.0/10 are refused where they used to pass. And DockerSandbox — the boundary SECURITY.md points at for untrusted code — started its container as root with the daemon's default capability set; the run line now always carries --cap-drop=ALL, --security-opt=no-new-privileges and --pids-limit.

Three more, on the same security surface. The URL validator logged the credentials it had just refused: an embedded-credentials denial wrote the password into a Warning line, and the scheme and port denials logged the query string. Log lines now carry scheme, host and port only. The VFS analyzer could not see using static System.IO.File; ReadAllText(p) nor FileStream fs = new(path, …), so both shapes escaped ORKVFS001-006; it now judges invocations on the resolved symbol and registers the target-typed creation form. And the sandbox's Roslyn denylist ignored Environment.Exit, Environment.GetEnvironmentVariable (the environment holds every API key the host resolved), AppDomain.CurrentDomain.Load(bytes), the target-typed Process p = new(); and unsafe used as a method modifier — all five are now flagged.

Gates. check-doc-claims.py compares the CONTRIBUTING copies of the NuGet lineup (six copies now, not four) and checks the push order in each; check-comment-accents.py reaches unaccented French in C# comments, which is how twenty-seven comments quoting French UI labels had survived the catalogue rewrite.

Fixed — a provider that cannot stream now says so, and the clocks stop deciding tests

  • ILlmProvider.SupportsStreaming follows IsConfigured instead of being an unconditional true on all 14 providers. An unconfigured provider used to declare streaming, the caller took the SSE branch, and the branch ended without a single chunk — a script's for await completed on a silence indistinguishable from a model with nothing to say, while the very same provider's buffered path said "API key is required" out loud. A direct streaming call on an unconfigured provider now fails in the open, and the streaming and buffered paths render the same marker. Consumers that branch on the declaration (LlmProviderToChatClientAdapter, RateLimitedLlmProvider, the scripting llm facade) see it change with the configuration.
  • AgentWorkloadTracker and TaskExecutionRouter take an injected TimeProvider. Five test classes stop measuring wall-clock time — three of them were assertion bugs rather than timing ones.
  • Publishing hardening: both release workflows attach build provenance attestations, the container base images are pinned by digest (Ollama stops floating on :latest), NuGetAudit is declared rather than inherited as a side effect of -warnaserror, and a tag carrying a prerelease suffix now publishes as a prerelease instead of becoming Latest by omission.
  • The secret-scan allowlist stops masking whole files and names the individual values it accepts, so a real credential added to an allowlisted file is still caught.
  • Two tests stopped depending on the machine: the Retry-After policy test reads a monotonic Stopwatch instead of DateTime.UtcNow, and the crew-host start/stop test waits for the hosted loop to announce itself instead of racing it.
  • The strict docfx build (--warningsAsErrors) is green again — the API landing page is reachable from the table of contents, and the generated SonarQube reports joined the site's content set instead of dangling as broken links.
  • The LLM campaign kit (llmproviders-test/) generates its reports and its regenerated index in English; reports dated before 2026-09-06 stay French, and the index says so.

Fixed — SonarQube campaign: 186 issues resolved, BLOCKER through MINOR [breaking — constructor shapes]

A full analysis (SonarQube 9.9.8, scanner .NET 11.2.1, Sonar way C# profile) on the renamed Orkeon project reported 186 issues in the BLOCKER..MINOR band across 119 files, plus 17 security hotspots left TO_REVIEW. All 186 are now closed and every hotspot is reviewed: 0 bug, 0 vulnerability, 0 hotspot, 0 issue above INFO, technical debt 1 762 min to 0, and reliability / security / maintainability / security-review all rated A. Coverage (82.7 %) and duplication (1.6 %) are unchanged — this campaign moved no test and added no dead code.

  • 11 BLOCKER S2699 — tests that asserted nothing now assert what they claim to verify (Orkeon.Host.Tests, Orkeon.Infrastructure.Tests EventHub, Callback, Analysis hybrid search, Studio.Core).
  • 42 S3776 — cognitive complexity brought under 15 by extraction, not by splitting: ForgeCommandOptions.Parse (58), ForgePromote.WriteCard (50), ForgeEngine.RunAsync (30), RagNamespaceBinding (26), RunnerExecution (21), LlmProviderFactory (19), OpenAICompatibleProviderBase (19), and 35 more.
  • 35 S3358 nested ternaries, 18 S107 over-long parameter lists, 11 S125 commented-out code, 7 S3267 loops replaced by LINQ, 5 S1168 null collections, and the mechanical tail (S927, S1186, S1144, S2365, S2479, S1854, S3264, S3871, S2223, S1751, S3903, ...).
  • 20 findings arbitrated as false positives, each carrying an in-code [SuppressMessage] (or a local #pragma) that states why: S101 on I18n (the rule proposes 18N), S3604 on Lock _gate = new() fields of primary- constructor types, S107 on [LoggerMessage] partials, S1168 where null is a third state the caller reads (ICrewLinkProvider.LinksFor, the shell-tool allowlist), S2737 on catch clauses that exist to carry an exception filter, S3925 on the EventHub exceptions, S3871 on an executable-internal exception.
  • 17 security hotspots reviewed SAFE: 13 x S2077 (the only interpolated fragment is an allowlist-validated, quoted SQL identifier — SQLite cannot parameterize identifiers in DDL/PRAGMA; every caller value is a command parameter), 2 x S4792 (the framework's own logging wiring), 2 x S5443 (/tmp is a virtual VFS path, not the shared OS temp directory).

Breaking (source): four constructors that took more than seven dependencies now take a single grouped dependency object — a sealed record for the three RAG ones, a sealed class for CrewStrategyDependencies. No shim is provided — call sites move with them.

  • Orkeon.Infrastructure.Crew.Strategies.CrewStrategyDependencies (new) replaces the (taskRepository, agentRepository, executionService, memoryScope) quadruple in SequentialProcessStrategy, GraphProcessStrategy, AutonomousProcessStrategy and ConsensualProcessStrategy.
  • Orkeon.Rag.Pipeline.StagedRagPipelineDependencies and Orkeon.Rag.Pipeline.IngestionPipelineDependencies (new) replace the optional collaborator tails of StagedRagPipeline, CorrectiveRagPipeline and DefaultIngestionPipeline.
  • The remaining S107 sites in Orkeon.Scripting and Orkeon.Hosting follow the same shape; every move is declared in the affected projects' PublicAPI.Shipped.txt (the Unshipped files stay header-only, as the release-readiness gate requires).

Out of band and left as-is: 406 INFO issues, 404 of them xUnit2033 (use the value Assert.Single returns instead of re-indexing) plus two SYSLIB hints.

Changed — the example catalogue speaks TypeScript, and the trading assembly retires [breaking — one package removed]

The numbered catalogue had two ways to run: the orkeon CLI for most of it, and a dedicated C# runner for the fifteen finance crews, dragging a 14 000-line assembly and its own package behind it. It now has one.

  • The fifteen finance crews are main.ork.ts — every process type (hierarchical with managers, parallel fan-outs, sequential, consensual), memory, the three humanInput reviews, dependency DAGs, built-ins by name, and their tools attached as instances. All validated end to end through the same strict pipeline as YAML. The catalogue holds at 105 examples.
  • A shared _tools TypeScript module replaces Orkeon.Trading.Tools: 27 tools over seven category files plus a small financial-math core (correlation and covariance matrices, Acklam's normal inverse CDF, a seeded mulberry32 PRNG). Every tool is deterministic — same input, same output — which the Random-based C# originals never were. Simplifications where the C# leaned on MathNet are documented in place (grid-scan mean-variance, convex-blend Black-Litterman, midpoint-bisection HRP); everything else is a faithful port, Wilder's full ADX included. The seventeen tools no finance config ever referenced were not ported.
  • Removed: Orkeon.Trading.Tools (162 files), the trading runner, the two interactive example runners and the examples/_shared library — from both solutions and from the disk. publish.yml no longer packs Orkeon.Runners.Shared: that package is discontinued. MathNet.Numerics and YahooFinanceApi leave the package versions with no consumer left, the container image drops its trading publish stage and banner line, and the installers drop the orkeon-trading launcher.
  • A declarative .ork.ts now runs through the real pipeline. A bare orkeon run crew.ork.ts used to execute a flat loop over agent bodies that ignored tasks, process, manager, humanInput and deliverables — the full orchestration was reachable only behind --config. run now routes to the shared one-shot runner whenever the script declares the globalThis.crew handoff, so the script is evaluated exactly once, by the pipeline. Procedural scripts keep the script path untouched.
  • Every surface that discovers, validates, lints, indexes or launches the catalogue accepts main.ork.ts beside config.yaml: run-example, test-all-examples, validate-all-examples, the config linter (which grew a TypeScript lint checking every quoted tool name against the manifest and the shared module), the index generator, and the container's orkeon-example dispatch. The guides say one CLI, EN and FR.
  • Incidental: a Cyrillic-homoglyph agent id the 36 finance YAML files had carried since birth is ASCII at last, and the catalogue-wide CA5394 waiver lifts — the seeded-PRNG TypeScript successors made it moot.

Changed — one Orkeon package instead of a per-layer NuGet lineup (PUB-25) [breaking — packaging only]

The Domain/Application/Infrastructure split is an internal discipline, not a distribution contract — and shipping it as three packages had already produced one real incident (rc.1/rc.2 published on NuGet.org with five unrestorable Orkeon.* dependencies). Distribution is now consolidated; the 39-project source layout, namespaces, and per-assembly PublicAPI freeze are untouched, so consumer code compiles as-is — only the install line changes.

  • Orkeon (new): the whole framework in one package — eleven embedded assemblies (Orkeon.Domain, Orkeon.Application, Orkeon.Infrastructure, Orkeon.Rag(.Abstractions), Orkeon.Analysis(.Abstractions), Orkeon.Tools.Abstractions, and the three constants satellites of the core graph). Migration: uninstall the per-layer packages, dotnet add package Orkeon --prerelease.
  • Orkeon.Tools (new): the seven built-in tool families in one package, separate from Orkeon only for dependency weight (database drivers, PDF and spreadsheet libraries live here). Depends on Orkeon.
  • Orkeon.Rag.Onnx and Orkeon.Tools.Embeddings.Local now depend on the Orkeon package instead of the discontinued per-layer ones.
  • The per-layer, per-family and deferred-library packages (Orkeon.Domain, Orkeon.Application, Orkeon.Infrastructure, Orkeon.Constants.*, Orkeon.Tools.<family>, Orkeon.Cli.*, Orkeon.Scripting, Orkeon.Hosting, Orkeon.Plugins) are no longer packed; the published rc.1/rc.2 of the three core packages are to be unlisted on NuGet.org.
  • publish.yml pushes the new lineup (Orkeon, Orkeon.Tools, the ONNX reranker pair, the local-embeddings tool package, and the orkeon dotnet tool) and a new gate — scripts/check-package-closure.py — fails the workflow if a lineup package depends on an Orkeon.* id outside the lineup or if an umbrella's hand-declared external dependencies drift from its embedded projects.

Fixed — publishing hygiene ahead of the public opening

  • Release builds emit embedded portable PDBs again (DebugSymbols=false had silently disabled emission, shipping non-debuggable packages with no SourceLink attachment point); EmbedUntrackedSources is on.
  • The orkeon dotnet tool package no longer bundles the iOS/Android onnxruntime natives a CLI tool can never load: 262.5 MB → 137.6 MB, back under the nuget.org size limit.
  • The docfx API reference now covers the five Orkeon.Constants.* assemblies, and namespaceLayout: flattened removes the 26 dead breadcrumb links the nested layout generated.
  • A missing --mount source directory now fails with a clean actionable ERROR: line and exit 1 — in the YAML runner, --validate, --list-tools and orkeon run alike — instead of a raw dependency-injection stack trace.
  • CrewConfigurationMapper reports skipped tools and failed LLM-provider resolution through an optional ILogger (source-generated warnings) instead of writing to the console from the Application layer; the ExampleCallbacks demo handlers moved out of the published Orkeon.Application assembly into the test suite that was their only consumer.
  • Supply-chain hardening: a root nuget.config pins nuget.org as the only package source (with wildcard source mapping); esbuild moves to ^0.25.12 (GHSA-67mh-4wv8-2f99) and every packaging-time esbuild tarball download now verifies the sha512 integrity recorded in the lockfile; Dependabot watches the Docker base images (root + deploy).

Changed — the screenshot campaign photographs an application in use, not an empty one

orkeon-studio --capture-screens <dir> existed to be the fidelity reference against the v3 mock, and could not be: it built the window over CreateForCurrentMachine, so on a clean machine every shot was an empty card — no team, no history, no session, a wizard frozen on step 1. Twenty-two images over roughly a hundred visual states, one theme out of the two the v3 remediation promised, and no test at all beyond argument parsing.

The campaign now builds the window over a seeded scenario in a throwaway temp directory and walks every screen and every gated state of it, in both modes and both themes, plus a language sweep over the densest screens.

  • Two worlds, never one mutated into the other. A populated machine (three adopted teams — one of which names a folder nobody declared —, seven past runs, four forge sessions, four model profiles, a declared folder that genuinely does not exist on disk, a doctor with one warning and one failure) and a first-run machine with nothing on it and no CLI installed. "Empty versus populated" is a thing a stop declares rather than a teardown that must un-populate a list.
  • The real loaders, over seeded files. TeamCatalog, ForgeSessionCatalog, the file-backed history and profile stores, the physical settings, directory and target probes — all of them, pointed at the sandbox. Only the process boundary is doubled, because it has no other seam. ForgeSessionHydrator rebuilds a whole wizard session from five JSON files, so the Composer, the mount rows and both verdicts are photographable with no child process anywhere.
  • The catalogue is data, and it is asserted. Each stop declares where it stands, what it arranges, why that state is worth a pixel, and which ViewModel gates it claims to light up. The whole campaign is replayed headless on the Linux runner and every claim is checked — so a stop that stops reaching its state fails the build instead of writing a confident picture of the wrong screen. Writing those assertions immediately caught four wrong claims, including a stacked-modal state this application does not have.
  • Conformity guards, in the idiom of the suite's existing ones: every sidebar entry maps to a capture screen, every scrim modal is opened by some stop, every endless storyboard has a pose, every guided-tour step names an element that exists.
  • Output that cannot lie. Per-stop fault barrier; geometry, non-uniformity, expected-panel and binding-error checks; a differs-from-the-previous-shot digest that catches the likeliest failure of all, a stop that changed nothing; atomic writes; failed shots quarantined under failed/; and a manifest.json carrying each image's reason, its SHA-256 — so re-running the campaign after a UI change and diffing two manifests names the exact screens that moved.

Fixed — five defects the campaign was hiding

Found while making the collection trustworthy; each produced, or was about to produce, an image that looked like evidence.

  • The startup plate would have bled into every shot. SkipSplashForCapture ran a zero-duration animation and set Visibility from its Completed handler — and a zero duration is not a synchronous completion: BeginAnimation attaches the clock and the media context ticks it on the next render pass. It worked only because the settle slept 120 ms afterwards. Replaced by a direct pose/hide pair, alongside a PoseSplashForCapture that photographs a plate a user could actually have seen instead of five pixels of progress bar.
  • The theme button contradicted its own window in dark mode. The icon and tooltip were refreshed only from the toggle handler, so applying the theme any other way left a moon in the title bar — the first place a reviewer looks. ApplyThemeForCapture does both, and deliberately does not touch the operator's stored preferences.
  • The language menu could never appear. It is the app's only Popup, hosted in its own HwndSource and therefore invisible to RenderTargetBitmap: its shot would have been a chevron rotated to 180° above nothing. Popups are now composited into the window's image, with the computed placement asserted inside the window's bounds rather than trusted.
  • The settle proved nothing. WPF orders Loaded below Render, so the second dispatcher fence returned immediately and Task.Delay(120) was the only thing creating slack. Replaced by a bindings drain, a layout loop that repeats until layout stops dirtying itself, bounded composition ticks and an idle drain — with an unstable layout recorded rather than ignored.
  • A failed shot was invisible and inflated the count. Save returned silently on a zero-size window after the index had been incremented, and the count printed on stdout was the stop count, not the file count.

Also: the collection is captured at 1440×900 rather than 1024×768. At the old size the content column is 752 DIP and the panels declare maximum widths of 880, 1000 and 1080 — so none of them ever bound, and every image ever produced showed the narrowest layout the app can make, which is not the one the mock was drawn for. captures/ joins .gitignore.

Fixed — the pre-push audit: what forty-one reviewers found in the campaign season's own commits

A six-dimension adversarial audit of the fifteen unpushed commits (token/cache accounting, multimodal, dialect hooks, fleet coherence, documentation, commit hygiene) confirmed no accounting defect and no payload defect — and a crop of real gaps at the edges, each fixed test-first:

  • MiniMax, truncated mid-thought: a reply cut by max_tokens inside the <think> block never reaches the closing tag, and the split hook shipped the whole raw trace as visible content — the exact failure the hook exists to prevent, on the exact path where the model is most verbose. An unterminated leading block now yields empty content with the partial trace in reasoning_content. The hook's edges are pinned while at it: a mid-content <think> survives (quoting is content), an empty block records nothing, and the stream-final scrub is now a test, not a hope.
  • The streaming chat path dropped images silently: ChatStreamingAsync built the same payload as the buffered path without calling WarnOnUnsendableAttachments, so a non-vision provider streaming a multimodal conversation lost the image without a word — the guarantee depended on which transport the caller picked. Both paths warn now.
  • Ollama's URL-only images: the converter documents that an image referenced only by URL is "reported as skipped rather than silently dropped" (the server never fetches URLs), but nothing reported it. BuildChatPayload now emits the structured warning with the remedy (inline the bytes).
  • The None warnings claimed too much: "this API has no response-format field" is factually wrong for MiniMax — the only provider that triggers it — whose API accepts the field and ignores it; same for "no reasoning pass" on a model that always reasons. Both texts now state the honest diagnosis (not honoured / no control), and MiniMax's two uniquely reachable warning branches are under test.
  • Studio called the mainland MiniMax "custom": the detector mapped only api.minimax.io; api.minimaxi.com — a constant this very range introduced, routed by the runtime factory — now detects as minimax, the Kimi twin pattern.
  • llm.minimax: the scripting namespace gained the accessor (binding, provider-name switch, typings, PublicAPI), as llm.grok had — a first-class provider should not be reachable everywhere but from a script. llm.grok gets its first pin alongside.
  • The registry's promise is now kept in print: "the report header prints the values actually used" was false for the M7 effort (mistral-medium-2604 probes at high, the header said nothing) — the probe report (markdown + JSON) and both kit report writers now print the base and M7 efforts whenever a run departed from the default, and --thinking-effort is a real flag of both campaign scripts (explicit beats catalogue), as their options table already claimed.
  • Documentation swept against the code at HEAD: the fleet is 14 everywhere (eight pages EN+FR still said 13, one said twelve); the response-format matrix lost its stale contradictory Gemini | None row and gained the missing MiniMax row; the vision table no longer lists DeepSeek as both having and lacking the capability and counts all 14; the opt-in page's "12 of the 13 declare it (only DeepSeek does not)" was wrong on both halves; every "campaign pending / non campagné / NOT yet campaign-verified" left over from MiniMax's documentation-first landing now states the campaign; --m7-effort reached the CLI reference; the Grok custom-endpoint report's paste-ready journal line named a path that does not exist; and this file's own max_completion_tokens entry claimed Groq passed a campaign two sections after recording that Groq never ran one.
  • Pins the audit found missing: Gemini joins the fleet capability table (its declaration was the only one unpinned), and the xai- key-prefix inference — the last routing arm — gets the test that distinguishes it from a deleted one.

Added — MiniMax, the fourteenth provider — the first documentation-first integration

Unlike Grok, which arrived preceded by its own live campaign, MiniMax arrives with no key and says so everywhere: MiniMaxLlmProvider (OpenAI-compatible, api.minimax.io/v1 international with the api.minimaxi.com mainland twin named, the Kimi pattern), canonical key minimax, default model MiniMax-M2 — every declaration sourced from the vendor's platform documentation dated 2026-08-30 and marked campaign-pending in the code, the comparison table (a † row), and the campaign catalogue. response_format and thinking stay undeclared (capability warning, never a silent drop — the Gemini precedent, upgradeable the day a key arrives); vision follows the documented VL family per D-03. The catalogue entry records the three questions the first campaign must settle: DeepSeek-style reasoning replay, cache breakdown, and whether response_format works despite being undocumented. Full fleet integration otherwise: factory routing (key, both regional hosts, minimax-* model prefix), Studio card and detection, doctor, orkeon llm probe|models, example settings, counts 13 -> 14 under the claims gate.

Fixed — MiniMax speaks its mind out loud, and the dialect now separates the two

The first MiniMax campaign (same day as the integration — 7/2/3 on MiniMax-M2, once the right key arrived: sk-cp- keys are coding-plan quotas, sk-api- is the API) settled all three recorded questions and found one real integration defect. MiniMax ships its reasoning INLINE: every reply opens with a <think>...</think> block inside content, no separate field — a one-line hello came back as 158 characters, and an agent built on it would speak its private reasoning out loud. The dialect now splits the block into reasoning_content (a SplitReasoningFromContent hook on the compatible base — the MiniMax twin of the Mistral chunked-content fix) and re-inlines it verbatim when replaying an assistant turn, because the vendor documents that history must keep the think blocks. Post-fix re-campaign: a 24-character hello. The other two answers: response_format is accepted but NON-BINDING (a schema is ignored, json_object arrives fenced in markdown — the None declaration graduates from caution to measurement), and the implicit cache reports no breakdown at an 8k prefix. The standing reds are the model's: system message ignored on both shapes, and "I'm unable to view the image" — text-only per model (D-03), with the VL family absent from the platform's /models listing, so no vision companion is declarable yet.

Removed — Groq, superseded by Grok (breaking, no shims)

Groq was never the intended provider: the near-homograph had stood in for Grok since the provider list was first drawn. With Grok landed and Groq never campaigned (no key ever supplied, no archived proof), the fleet drops it outright per the pre-release rule - the new state replaces the old one everywhere, no aliases, no shims. Gone: GroqLlmProvider, the satellite constants (endpoint, key, default model), factory routing (key, groq.com host, mixtral/groq model inference), the Studio card and detection, the scripting DSL factory (llm.groq becomes llm.grok, which also retires its stale hardcoded llama-3.1 default), the doctor mapping, the campaign-kit entry and the docs rows. The HuggingFace :groq routing suffix stays - that is HF's partner vocabulary, not Orkeon's provider key. Provider count returns to 13; the claims gate re-derived it and named every count to fix.

Added — Grok (x.AI), preceded by its own proof

The key supplied for "Groq" turned out to be an x.AI key (xai- prefix, refused by api.groq.com, served by api.x.ai) — and the user's intent turned out to be Grok all along. Before the provider existed, a full 12-mode campaign had already passed against api.x.ai through the generic OpenAI dialect with nothing but a base-url (archived under llmproviders-test/custom-endpoints/), so GrokLlmProvider is that measurement written down: OpenAI-compatible transport on api.x.ai/v1, json_schema honoured, effort-only thinking with the trace replayed, vision, implicit cache on the standard cached_tokens. Canonical key grok (alias xai), default model grok-4.6 (verified live), endpoint and key and default in the Orkeon.Constants.Llm satellite, factory routing by key, by api.x.ai host, by grok-* model prefix and by the xai- key prefix — the grok/groq near-homograph is exactly the confusion that last inference absorbs. Studio gains the provider card and endpoint detection; orkeon llm probe|models accept it; the campaign kit carries its catalogue entry; docs and counts follow everywhere the claims gate checks.

Fixed — what the first real campaigns against six vendors found (2026-08-30)

The first full campaigns ever run against api.openai.com, the Gemini compat surface and an identity-linked Anthropic key — plus re-runs of DeepSeek, Kimi, Z.AI and Ollama on rc.2 — turned five findings into fixes. Each one is dated and pinned by an offline test:

  • OpenAI: max_tokens is retired on current models. The campaign failed ten modes out of twelve on gpt-5.6-sol over that one field ("Unsupported parameter: 'max_tokens' ... Use 'max_completion_tokens' instead"). The OpenAI dialect now writes max_completion_tokens — verified live to be accepted by the older generations too (gpt-4o-mini) — through a MaxTokensFieldName hook on OpenAICompatibleProviderBase that only OpenAIProvider overrides: DeepSeek and the rest of the compatible family still document and expect max_tokens, and every provider campaigned that day passed with it.
  • Gemini: response_format works and was being refused. Declared None when the compat surface left it undocumented (2026-08-18), so every JSON request got a capability warning instead of being sent. Measured live: the surface accepts json_object and json_schema and enforces the schema server-side (additionalProperties included). The declaration is now JsonSchema.
  • DeepSeek: vision arrived, per model. deepseek-v4-flash-vision-exp reads a base64 image (measured live); DeepSeek was the one provider in the fleet with no vision model and its images silently degraded to text. Vision = true now, with the same per-provider declaration / per-model reality the fleet already lives with (D-03): the text-only default model answers an image with the vendor's own error.
  • Anthropic: identity-linked API keys were unusable. They refuse every request without an anthropic-workspace-id header — Messages API and /v1/models alike — and Orkeon had no way to send one. LlmConfig.WorkspaceId (a scoping identifier, not a secret, same family as ApiVersion) now travels as that header when set; classic keys change nothing. Wired through orkeon llm probe --workspace-id and the campaign kit (workspaceId per provider).
  • Ollama: every buffered completion was accounted as free. The buffered /api/generate parse hard-coded TokensUsed = 0 behind a comment claiming Ollama provides no count in that format — while the live server returns prompt_eval_count and eval_count right beside the durations the same parse was already reading. Zero fed the token dimension of AgentExecutionBudget and the crew accounting. Found by the M1 probe archiving tokens=0 on a priced exchange; the same gap left M10's diagnostic line reading "prompt tokens: unreported" for Ollama, because a tool-less conversation flattens onto that very path. Both now report (tokens=35, prompt tokens: 2052 then 2052 on the re-run).
  • The probe harness accused the framework twice, wrongly. M5 rebuilt the assistant tool-call turn from parsed calls while the real agent loop replays the vendor's raw tool_calls fragment verbatim — Gemini rejects a replay that lost its per-call thought_signature, so the probe failed M5 for a defect the product does not have; it now replays the raw fragment whenever the body is OpenAI-shaped (the canonical rebuild remains for Anthropic's dialect). And M3/M4 asked for five numbers, which fits in a single event on a coarse-chunking stream (Gemini emits ~13-character chunks), reading a genuine stream as a buffered fallback; the probe now demands a hundred — thirty sufficed for Gemini, then claude-sonnet-5 coalesced the whole count-to-thirty into a single delta the same day.

The Mistral default model was broken and nothing could have said so offline: LlmProviderDefaultModels.Mistral carried mistral-medium-3-5-26-04, an identifier the API never served (Invalid model, measured 2026-08-30) — it reads like a concatenation of the alias mistral-medium-3-5 and the vintage 2604, the two forms Mistral really serves. Any configuration naming the provider without a model got a guaranteed 400. Now mistral-medium-2604, the dated snapshot, verified live; same class as the retired defaults LLM-01 fixed (G-01..G-04), found the same way — by the first real call.

The mandatory values some models dictate are now a per-model registry, not folklore: requiredParams in the campaign catalogue (kimi-k2.6, gpt-5.6-sol and claude-sonnet-5 all refuse any temperature but 1; gpt-5.6-sol additionally demands reasoning_effort: "none" with function tools), resolved per model by both campaign scripts — per model and not per provider, because gpt-4o-mini rejects reasoning_effort outright and a provider-level pin would break it. Human-readable twin: the "Per-model mandatory parameter values" section of docs/reference/llm-providers-comparison.md (mirrored in French), vendor wording and measurement date included.

Mistral, first campaign ever (the key arrived last), peeled four findings in a row before settling at 11/1 on mistral-medium-2604, with the G-14 proof in the header (api.mistral.ai, not localhost, no base-url passed):

  • The compiled default was the broken identifier above — first finding, fixed first.
  • The model restricts reasoning_effort to ['high', 'none'], so M7's hard-coded "low" was refused: the probe's effort is now a per-model registry value (m7Effort, CLI --m7-effort).
  • Orkeon's omit-top_p-when-1 was a silent drop there. Mistral's reasoning mode runs an internal top_p default of its own and validates greedy sampling against the EXPLICIT field, so temperature: 0 + reasoning with no top_p is refused ("top_p must be 1 when using greedy sampling.") while the same request with an explicit top_p: 1 passes. The Mistral dialect now always writes the configured value (AlwaysEmitTopP hook — the base keeps omitting: OpenAI's reasoning models reject the explicit field, the same assumption broken in the other direction).
  • Reasoning replies were parsed as empty. With reasoning_effort on, Mistral answers message.content as an ARRAY of typed chunks (thinking + text) and the string-only read dropped both: M7 archived accepted, no reasoning trace returned, tokens=243 — 243 tokens billed, nothing kept. The shared parse now walks the text parts (the OpenAI multi-part standard) and surfaces the thinking chunks as reasoning_content; the re-run archives reasoning trace returned.

The one standing red is the vendor's: prompt_tokens_details.cached_tokens stays 0 on an identical 5812-token prefix called twice (three measurements) — the field exists, the implicit cache never hits.

Qwen, first campaign (an international key: dashscope-intl base URL, G-12 closed by the report header): 12/12 — including the fleet's only Thinking = Budget wire (enable_thinking + thinking_budget) validated live. Its M10 exposed a harness artefact, not a vendor gap: DashScope's implicit cache hits nothing below a high threshold (0 cached tokens at the probe's historical ~2050-token prefix, three runs; cached_tokens: 4352 at 5809), so a working cache read as broken. The M10 prefix now carries ~8200 tokens — the clean run archives 6528 cached, ratio 0.81; Mistral's zero stayed zero at the long prefix too, which settles its verdict as the vendor's. And the OpenAI-dialect fallback for custom compatible endpoints — the path Docker Model Runner, vLLM and LM Studio ride — got its first real proof: a full 12/12 campaign against api.x.ai (grok-4.6), archived under llmproviders-test/custom-endpoints/. The key supplied as "Groq" was an x.AI key (xai- prefix, refused by api.groq.com, served by api.x.ai) — measured, not assumed.

Together and HuggingFace, first campaigns (the last two keys): 9/1/2 and 8/2/2 — no Orkeon defect on either. The one harness defect was found before the campaigns could even start: Together answers GET /models with a bare JSON array, no data envelope, and the first real call crashed orkeon llm models with an unhandled InvalidOperationException — the parser now reads both shapes and the command's catch treats a malformed body as a typed error (red test first, on the vendor's verbatim shape). The oldest suspicion of the effort is settled by measurement: HuggingFace's compiled default meta-llama/Llama-3.1-8B-Instruct, long flagged unreachable through the router, answers M1 alive — the campaign catalogue realigns on it. Both M9 reds are the D-03 pattern; HuggingFace's vision companion (Qwen3-VL-30B-A3B-Instruct) reads the image, while Together's four vision candidates are all non-serverless on the measured tier (dedicated-endpoint only, failure archived as proof).

Campaign verdicts, same day: Kimi's open M3 "stream refused" of August did not reproduce (4/4 green, replays included); Z.AI's implicit context cache missed once in-campaign (0 cached tokens) and hit on both replays (1984 tokens, ratio 0.97) — server behaviour, not a defect. Reports under llmproviders-test/.

Fixed — dotnet test runs again, and the tests it skipped are back

The .NET 10 SDK stopped honouring the VSTest target for Microsoft.Testing.Platform test projects. Every dotnet test in this repo answered "Testing with VSTest target is no longer supported by Microsoft.Testing.Platform on .NET 10 SDK and later" and ran nothing — CI, the release pipeline, the nightly and the SonarQube script alike. global.json now opts into the new runner ("test": { "runner": "Microsoft.Testing.Platform" }), which is the only supported answer; the per-project TestingPlatformDotnetTestSupport property no longer does it.

Three things follow from the new runner, and each was a live defect rather than a rename:

  • A filter matching zero tests in a module is an error there (exit 8), not an empty success. CI excluded Orkeon.Tools.Embeddings.Local.Tests by name from a solution-wide filter, which under MTP means "load that module, match nothing, fail". The exclusion is gone: measurement showed the SIGSEGV that motivated it comes from that assembly's 8 Category=Slow tests — the ones that boot the real ONNX model — and from those alone (3/3 crash with only them, 5/5 clean without them). Its other 28 tests now run with everyone else's instead of being skipped, and the 8 get a step whose guard reads the runner's own accounting: the crash is tolerated only when every discovered test was accounted for and none failed, so a run that dies mid-suite stays red. The previous guard accepted that case.
  • The nightly needs the opposite tolerance. Selecting one category across the whole solution leaves most modules empty by construction, so it passes --ignore-exit-code 8 — plus an explicit check that the run executed something, because tolerating "zero tests" per module must not let "zero tests anywhere" look green. Its VSTest-only --logger argument is gone.
  • Coverage was measured by a collector the runner does not implement. --collect:"XPlat Code Coverage" is refused outright (exit 5), scripts/sonar-analyze.* swallowed the failure with || log_warn, and the analysis went on to import a report nothing had written — a Quality Gate evaluating coverage conditions against 0% and reading as a measurement. Collection moves to dotnet-coverage (Cobertura → SonarQube generic via ReportGenerator, in both the shell and PowerShell scripts), and a report holding no class now aborts the analysis instead of being imported.

One flaky test surfaced with the new scheduler and is fixed rather than tolerated: OtelTests.llm_call_emits_a_span_with_method_and_prompt_length_tags took the first LLM-call span it saw from a process-global ActivityListener, so under a parallel run it asserted on a concurrent act() loop's span. Its three neighbours already discriminated by a unique tag; it now does too.

Fixed — BM25: the guard the code index never had, and two comments that promised too much

Bm25CodeIndex (Analysis) accepted any k1/b through its public constructor. A negative k1 inverts the term-frequency saturation and a b outside [0, 1] turns length normalization into an unbounded multiplier: the index kept answering, with scores no caller could interpret and no error to notice. It now validates exactly as its prose twin Bm25Index (Rag) always did.

The two implementations' doc comments claimed they were kept in step — "same k1/b defaults", "Same k, same semantics". Nothing enforced it, and on the fusion constant it was already false: the RAG side is operator-tunable through Orkeon:Rag:Retrieval:Hybrid:RrfK while code search exposes no such knob. The comments now say what is true — the values come from the literature, the two indexes never score the same corpus, and retuning one must not propagate. ADR-009 records why these are not satellite candidates: a shared spelling is not a shared value.

The one real duplication there was internal to RAG. ReciprocalRankFusion.DefaultK and RagDefaults.RrfK were two declarations of the same product default, backing two option classes bound to the same configuration section (Orkeon:Rag:Retrieval:Hybrid) from two projects — so changing the default would have moved one fusion and not the other. Orkeon.Rag already references the Domain that holds it; the copy is now a reference, and the published value is unchanged.

Added — satellites for the constants two projects must agree on (ADR-009)

Orkeon.Studio.Core may not reference Orkeon.Infrastructure or Orkeon.Hosting, and the reason is measured rather than doctrinal: doing so "dragged the whole runtime — ONNX runtimes, tree-sitter grammars, the local embedding model — into every published app, for roughly 230 MB each". So Studio copied the values it needed by hand, and ConstantDriftTests existed to stop the copies diverging.

Five new packages hold them instead, each with no runtime dependency, which is what lets both sides reference one declaration: Orkeon.Constants.Llm (provider endpoints, default models, provider keys), Orkeon.Constants.FileSystem (the virtual roots a runner mounts for itself, and the conventional file names one component writes and another looks for), Orkeon.Constants.Configuration (Orkeon:* keys and shared operator wording), Orkeon.Constants.Protocol (the run event kinds a runner emits and Studio reads) and Orkeon.Constants.Cli (the run option names the runners accept and Studio predicts).

Two of those closed drift that had already happened rather than drift that might: Studio's copy of the run event vocabulary was missing four kinds the runner emits, and an unknown kind is ignored rather than reported — so tool activity and delegations simply never reached the screen.

Orkeon.Domain gains its first runtime project reference, to Orkeon.Constants.Llm — its default model name is the same string as OpenAI's provider default. A project that depends on nothing inverts no layer and drags nothing in behind it; ADR-009 records the argument.

Nothing published changes shape: LlmEndpoints, ProviderDefaults and LlmDefaults are frozen surfaces, so their names stay and only their value moves — a const initialised from another assembly's const is inlined at compile time. Only RunnerMounts, which was unshipped, is removed; its four roots are now RunnerVirtualRoots.

ConstantDriftTests goes from 12 facts to 5. The five that remain never guarded duplication: they ask the endpoint detector to recognise each endpoint, pin the Docker Model Runner defaults against the committed appsettings.json template, and check the declared minimum CLI version.

Publication order matters now: .github/workflows/publish.yml pushes the satellites before Orkeon.Domain, or Domain would ship with a dependency that cannot be restored.

Changed — build toolchain

  • Roslyn pinned to 5.9.0 repo-wide. The analyzer and the source generator reference Microsoft.CodeAnalysis 5.9.0, and a Roslyn component that references a newer compiler than the one running it is silently refused — a warning (CS9057), not an error, after which analysis and generation simply do not happen. Microsoft.Net.Compilers.Toolset now replaces the SDK's csc so both are actually loaded. It is PrivateAssets="all", so it never flows into a package; a consumer on an older SDK still gets the CS9057 behaviour, which is why the components declare the floor they need rather than the newest compiler available.
  • xunit v3 → v4. Test projects move to Microsoft.Testing.Platform. dotnet test in its VSTest mode no longer drives them.
  • Jint interop pinned to ArrayConversionMode.Copy. Jint 4.14 changed the default for CLR arrays to LiveView, under which Array.isArray on a returned array is false. The scripting DSL's typings promise readonly number[][] from llm.embed(), so a script branching on Array.isArray silently took the wrong path. The pin restores the behaviour the typings describe. Note the scope honestly: this governs CLR arrays, so a binding returning IReadOnlyList<T> is host-wrapped under either mode and Array.isArray stays false for it.

Fixed — a team associates a folder, it does not declare one

In Orkeon Studio, « Autoriser un dossier » on a team opened the folder picker: a disk tree, a physical path, a rights choice. That is the declaration screen, and it belongs to « Réglages › Dossiers autorisés » — nowhere else. Wired onto the two team screens, it made every team re-declare its mounts from scratch, next to a settings list that already held them.

The defect was two lines of shell wiring, not the picker: MainWindowViewModel had all three callers subscribed to the same modal. The two team gestures — the creation wizard's « Dossiers de cette équipe » block, and « Autoriser un autre dossier… » on an adopted team — now open a chooser over the folders the settings declare. Ticked entries are carried over verbatim, rights included: the settings are the one place a folder and its rights are decided, and a team able to widen them would make that declaration a suggestion. A folder the team already carries, or whose virtual root another folder already spends, says so and cannot be picked — two mounts on one root is not a merge the runtime performs, it is one it drops.

Declaring stays the settings' gesture, and « Déclarer un nouveau dossier… » is one door to it: the modal closes and the app lands on « Réglages › Dossiers autorisés », on that tab and not merely on that screen. One door, so a folder cannot be declared from two places and drift between them.

A team folder the settings do not declare now reads red — on the wizard's chips, the "Mes équipes" cards and the team-mounts modal alike. It is not an error: a team's /output and /input are created inside the team at adoption and are never declared. It is the one thing a row cannot say by naming a virtual path, and a team reaching outside the machine's authorized folders should not have to be discovered by reading a sidecar.

A team reaching outside the settings no longer launches. « Exécuter » refuses a team carrying a folder that no settings entry allows: the run button is disabled and the card names the folders and the two ways out, with a button onto « Réglages › Dossiers autorisés ». Discovering that refusal from a run that failed halfway, its reason buried in a log, is what this replaces. The rule lives in Orkeon.Studio.Core (DeclaredMounts.BlockingFolders), not in the WPF screens, so the TUI launcher cannot answer it differently. A team's own /output and /input never block it: they are created inside the team at adoption and are its own plumbing, and counting them would make every adopted team unlaunchable.

The folders the blueprint implies became removable like any other. They were informative chips with no ✕ — "edit an agent to change them" — which left a team carrying a root its owner did not want with no way to say so. Dropping one now sticks: WithDerivedWriteMounts no longer re-adds it, the same silent undo that method exists to prevent. The screen warns and names the dropped roots, because nothing will be bound to them and the agents writing there will fail; a single « Rétablir » is the way back from a wrong ✕.

Fixed — Virtual paths are the only currency agents are paid in (ADR-008)

The owner found absolute disk folders in Orkeon Studio where only VFS mount points belong. The leak was in the engine, not the UI.

Runners used to mount their own directories 1:1 (C:\x:C:\x:ro) so the absolute paths framework code had already computed resolved unchanged, and FileSystemMount.IsValidVirtualPath had been widened to accept a Windows drive path as a virtual path to let those strings parse. Mounts parsed from a mount string are agent-facing, so list_mounts, ShellCommandTool's path checks and every access-denied message — which names the available mounts — handed agents the operator's disk layout; redaction was explicitly disarmed for exactly those mounts. The crew directory is now /crew, a hosted daemon's crews /crews, /crews-1, …, and the loader receives the virtual spelling, so it asks the VFS whether its target is a directory instead of probing the disk.

Orkeon:FileSystem:InternalMounts is new: mounts registered with MountVisibility.Internal — reachable by the VFS, absent from GetAvailableMounts(). The --llm-log directory moves there; it holds full prompts and API payloads and was being advertised to every agent as a writable mount. As a result, turning --llm-log on no longer shifts Orkeon:FileSystem:Mounts:{i}.

A denial message is read by the LLM, so it is an agent-facing surface like list_mounts: FileSystemRegistry now builds its "Available mounts" and "Mounts granting Write" lists from the agent-facing mounts only. It used to enumerate every mount, which named /llm-logs to any agent that touched an unmounted path — and annotated it (writable).

In Studio, the agent editor's « Sur quel dossier » line and the Composer's folder chips now name mounts the way agents address them (/output (lecture, écriture)) instead of joining raw physical:virtual:rights strings. Expert surfaces — the effective-mounts table, the picker's preview — still show the exact command line.

An adopted team now writes where its own agents write. The trial bench mounts /output and refuses a run that did not produce its promised deliverable; nothing carried that mount further, so the same team launched from its own folder was denied /output, logged a warning and reported success with nothing written. forge promote derives the write roots from the blueprint, creates their folders, and spells them in both launchers; Studio binds the same roots into the sidecar at adoption. A deliverable root the runner reserves — /crew, /script, /llm-logs — and the traversal spellings /.. and /. are skipped rather than mounted.

And the promoted launchers now run from the team's own folder. Neither run.sh nor run.cmd changed directory, while both address the crew by an absolute anchored path: the runner refuses to read a crew outside the working directory without --allow-external-mounts, and the security whitelist is rooted on the working directory too. Launched from anywhere else — which is every scheduled run the generated schedule/ artifacts install, since a service starts in the system directory — the team was refused outright, or ran and wrote nothing. Both launchers now cd into their folder first. In the same file, --var was spelled once per sample variable, which the CLI's parser rejects as a repeated option: several values now go space-separated after one flag, the rule --mount already followed.

Breaking: --mount no longer accepts a drive-letter virtual path, and a --mount claiming a root a runner reserves for itself — /crew and /llm-logs on the YAML path, /script and /llm-logs on the scripting path, /crews* on the orkeon-host daemon (exit 78) — is refused with an actionable line. RunnerHost.Build's llmLogPath parameter becomes llmLogVirtualPath and takes a virtual path; a new optional internalMounts parameter follows it. RunnerExecution.LoadCrewAsync keeps its signature but changes contract: its configPath is now a virtual path, so a host passing a physical one is denied by the VFS instead of loading. RunnerExecution.EnsureReservedRootsAreFree is public, for hosts that inject mounts of their own.

A mount string can quote its physical path. Three call sites split a spec on : with three different heuristics, and the one in CliWorkspaceMountBootstrapper had none: on Windows it read C:\src:/workspace:ro as the physical path "C", resolved it against the working directory and emitted a corrupt mount string. The split now lives once, in the domain type — FileSystemMount.TryGetBasePath, WithBasePath and Quote are new, and both duplicate heuristics are gone.

A path the bare form cannot carry — one holding a : or a ;, or ending with a backslash — is quoted: "/data/odd:name":/data:ro, "C:\src\":/workspace:ro. Quoting rather than backslash-escaping, because a backslash escape would collide with the Windows path separator, which is exactly what has to survive here. Backslashes are ordinary characters, so every existing mount string is unchanged, and two folders that had no spelling at all now have one: a drive root ("C:\":/workspace:ro) and any path ending in a separator. Those quotes belong to the mount grammar, so a shell must be told to leave them alone — the CLI reference spells the bash and PowerShell forms.

Every producer goes through FileSystemMount.Quote, not just the parsers through the split: the runners' own crew / script / exchange-log mounts, the daemon's crew mounts, the two orkeon-repl bootstrappers and Studio's MountDefinition.ToMountString. A folder whose name holds a ; is legal on every OS Studio's picker browses, and each of those sites used to emit a spec its own parser then refused.

And an adopted team can be launched from its own card again. Studio's target detector looked for a crew definition at the root of the folder it was handed, while forge promote keeps it in crew/ — so « Lancer » on a team card answered "holds no crew definition… pick a file inside it instead", and picking crew/ by hand found no sidecar beside it, so the team's mounts never reached the command line. The detector now descends into crew/: the run path goes to the definition, the selected path stays the team folder, which is what puts the sidecar in view and the team's own /output inside the security root.

Two more Studio screens stopped showing folders: the « Importer une équipe » recognition report joined the sidecar's raw mount strings — read by whoever received the team, so it disclosed the exporter's disk layout — and the team-mounts modal fell back to the raw string in a field documented as "the virtual spelling the agents see". All four renderers now share one MountLabels.

Also fixed: two hosted crews sharing a Name resolved to different definitions (the plan kept the last, CrewHostRegistry.Find answers with the first); examples/service-host/appsettings.host.json declared its mounts as objects, a shape FileSystemOptions.Mounts cannot bind; the RaggableTree pages documented a mount syntax that does not exist; and the --mount / --var help text said "Repeatable." of options the parser refuses to see twice.

Fixed — the VFS boundary, asked the same question everywhere

A sweep over the code the ADR-008 diff did not touch, looking for the same shapes it had just corrected.

One containment predicate. "Is this path inside that directory?" was answered in three places with three rules. PathValidator's was boundary-safe; the runners' --allow-external-mounts guard was a bare StartsWith, and the two disagreed exactly where it hurts: a crew in a sibling folder whose name extends the working directory's (~/proj vs ~/proj-old) read as inside, so the opt-in was never demanded, its base path never whitelisted, and the boundary-safe validator then refused every file the crew touched — never naming the flag that would have fixed it. PhysicalPathContainment now holds the rule, including the part about case: Windows paths are the same path in any casing.

ToVirtualPath answered with the wrong mount. The registry orders its mounts by virtual path length, which is what the virtual→physical direction needs; coming back, it returned the first mount whose base path matched. With nested mounts the two orderings disagree, and a file was handed back under a parent mount's spelling — a name that re-resolves with different rights. The most specific physical base now wins.

/sandbox existed in one host out of all of them. The mount the code sandboxes write under was provisioned by an IHostedService, and the runners build a host they never start — so every shipped CLI registered ICodeSandbox, DockerSandbox and SecureCodeInterpreterTool over a virtual root that did not exist. It is now built with the registry, in every host, started or not. Breaking: AddSandboxMount is removed; AddOrkeonFileSystem does it.

shell_command could not use its own default. working_directory declared "." — and since ADR-008 a virtual path starts with /, so no registry can resolve it and every call that omitted the field, the shape a model writes for an optional one, was refused. It now runs in the first readable mount, or in the parent's directory when nothing is mounted.

Every promoted team was dead on arrival on Windows. The launcher built its --mount by concatenation, so the physical segment inherited whatever the anchor expanded to — and %~dp0 is always C:\…. Four segments, a grammar error naming a path the user never typed. The generated spec now carries the grammar's own quotes, and a test runs a real shell against a folder whose name holds the separator. The forge trial bench and Studio's mount prediction went through the same concatenation; both now go through FileSystemMount.Quote.

The daemon read its crew list from a file it never told anyone about. orkeon-host resolved a relative appsettings.json against the executable's directory, while --help promises ./appsettings.json and the host built moments later reads the working directory — so the mounts came from one file and everything else from another. It also accepted a malformed --mount at startup, logged READY, and then failed every message; that is now a configuration error with exit 78, and --help states the grammar the parser enforces (three segments, ro|rw|rwnd, quoting).

--allow-external-mounts overwrote the operator's whitelist. It wrote PathSecurity:AdditionalAllowedDirectories:0, replacing the entry an appsettings.json declares there, while its own documentation says it additionally whitelists. It now appends.

Fixed — configuration that decided nothing

process: parallel now honours dependencies:. The mode ignored them: every task started at once, so a final synthesis task ran against an empty context and reported success on the nothing it had. The documentation said to use Sequential or Graph instead — and 23 of the 30 shipped parallel examples declare dependencies anyway, which is the clearest possible statement of what the mode is for. Tasks are now grouped into waves: everything whose dependencies are satisfied runs concurrently, the next wave starts when they are done and reads their outputs. A crew declaring no dependency is one wave — the previous behaviour, unchanged. A cycle is refused, naming the tasks caught in it.

AgentSelectionStrategy now selects something. The option, its two real strategies, StrategyAgentSelectionService and their DI wiring all existed — and IAgentSelectionService.SelectBestAgentAsync had no caller anywhere in src/, so setting Embedding changed nothing at runtime. TaskAgentSelector is that call site: consulted for a task declaring no agent:, never overriding one that does, degrading to round-robin with a warning when the embedding backend fails. FirstFit — the default — keeps round-robin exactly as before.

An unknown process: is refused instead of guessed. A hand-rolled switch fell through to Sequential, so process: graf ran a pipeline the author never asked for. Both the YAML and the scripting paths now use ProcessType.TryFrom and name the valid values. Breaking: a crew file with a typo'd process: now fails to load instead of running as Sequential.

A Graph or Autonomous crew is no longer reported as Sequential. Three hand-written MapProcessType switches restated the six-mode value object with four arms each and mapped every other mode to "Sequential". They are gone; the DTOs carry the value object's own spelling.

LogStreamingExchanges is honoured. It was bound from configuration, offered as a checkbox in both Studio surfaces, pinned by Studio's settings validator — and read by no code, so turning it off still captured every streaming exchange.

Removed: OrkeonConfig and OrkeonFeatureFlags. Four documentation pages presented them as the framework's predefined configurations (Default, Development, Production); no production code read either, and no DI entry point accepted one. A host composes its settings through AddOrkeonInfrastructure / AddOrkeonApplication and its appsettings.json.

Also: the five DLP interceptors' summaries read as descriptions of what the framework does ("ensure PII never appears in logs") when nothing invokes them — they are an opt-in toolkit a host applies, as docs/reference/opt-in-subsystems.md already said, and each class now says so too. And asyncExecution: is documented for what it is: recorded on the task, honoured by no orchestration mode.

Fixed — Studio, and the team it hands over

An adopted team can now read, too. The trial bench mounts /workspace and the Composer shows the chip; nothing carried it into adoption, so a team whose agents use file_read passed its trial and could then read nothing — the exact mirror of the missing /output. forge promote and Studio now bind it to an input/ folder inside the team, and FORGE.md says to drop the readable files there. Not the team's own root: --with-settings puts an appsettings.json holding API keys at that root, and a read mount over it would hand them to any agent with a file tool.

One chip per virtual root. A root the user allowed a folder for was rendered twice — once as a removable chip, once as an informative derived one — and removing the removable one changed nothing at save, because the derived binding silently took its place. The derived list now shows only the roots no explicit choice claims, so removing a chip brings the derived one visibly back: the screen says what the save will do. The DerivedMounts documentation claimed "the sidecar never records them", which was false and was the root of the confusion.

Studio's TUI launcher started the CLI in the wrong folder. It derived the working directory from RunPath, correct only while that path's parent was the folder the user picked — and the ADR-008 detector change made RunPath descend into a promoted team's crew/. The fix had landed in the WPF launcher alone. Both now read RunTarget.WorkingDirectory.

Studio reported "custom" for Gemini — the endpoint its own preset catalogue writes. The drift test guarding the pair asserted the constant had been copied, not that the detector recognised it; it now asks the detector.

Studio's blueprint→mount derivation gained the guards the CLI's copy has. A deliverable naming a reserved root (/crew, /script, /llm-logs) or a traversal segment reached an adopted team's sidecar through Studio and nowhere else, producing a team Studio could launch and the runner refused at start. ForgeDerivedMountTests pins the pair.

Fixed — an internal mount is a boundary now, not a hiding place

ADR-008 introduced MountVisibility.Internal and said the limitation out loud: the mount is withheld from every listing and stays resolvable, so an agent that knows the name can address it. The names are documented. /llm-logs holds every prompt and every API response of the run — one file_read /llm-logs/llm-exchanges-….jsonl was the whole exchange history.

FileSystemRegistry now refuses an Internal mount by default, in both directions: ToVirtualPath will not name one either, so a tool's physical→virtual output rewrite cannot leak it. A refused internal mount is reported exactly like a path that does not exist, and a nested one does not fall back to its agent-facing parent.

The two components that legitimately write to an internal root — the LLM exchange logger and the code sandboxes — ask for the new PrivilegedFileSystemAccess by name. A distinct DI registration rather than a flag on the interface everyone already holds: a tool cannot obtain it by accident, and every holder is findable by searching for the type. A host that wires its own IFileSystemService instead of calling AddOrkeonFileSystem keeps exactly the behaviour it had.

Breaking: FileSystemRegistry.ResolveAndCheckRights and ToVirtualPath take an optional includeInternal (default false), and FileSystemService's constructor an optional internalAccess (default false).

Fixed — what the tests were not asking

The shipped scripting typings did not parse. tools.d.ts declared an index signature as const [name: string]: …, which a TypeScript namespace cannot carry and which is not a declaration at all — so the tools namespace this package advertises was unavailable to every editor that loaded it. The only guard over the typings asserted that certain substrings were present in the rolled-up bundle, which cannot fail for that. Every .d.ts is now handed to esbuild, the same front end that reads user scripts. llm.d.ts went with it: it typed llm.openai/anthropic/ollama/azureOpenai/groq as non-callable objects with a name property, while the runtime exposes them as factories returning a config whose field is provider — every script typed against those declarations got an error on the correct code.

docker build . failed at restore. The Dockerfile restated Orkeon.ConsoleApp's project graph as a hand-written COPY list that had drifted to 10 of its 22 projects, plus one it no longer references. The list is gone; the graph is read from the tree.

Two runs started in the same second shared one exchange-log file. The run id was a UTC timestamp truncated to the second, against a class claiming "each logger instance creates a unique file scoped to that run" — and its per-file lock serializes writers inside one process, never across two.

The embedding port blew up at startup instead of saying what was missing. AddOrkeonVectorSearch — which AddOrkeonInfrastructure(configuration) calls unconditionally — registered OpenAIEmbeddingProvider by type, and its constructor needs an M.E.AI IEmbeddingGenerator<string, Embedding<float>> that only a host choosing local embeddings ever registers. MS.DI throws when a registered service's own dependencies cannot be resolved, so GetService<OpenAIEmbeddingProvider>() threw rather than returning null — which put both graceful fallbacks (this one and DefaultEmbeddingProviderResolver's) behind an exception naming an interface no operator has heard of, at container build rather than at first embed. UnconfiguredEmbeddingProvider exists precisely to give an actionable message deferred to first use; it is now reachable. The provider is built from the generator when one is present and absent otherwise.

orkeon doctor's onnx-reranker check now looks. It was a hard-coded ok with a hard-coded detail, on the reasoning that the weights are embedded resources of a package the CLI always references — true, and still not a check: a trimmed publish or a renamed resource leaves the reranker broken and the doctor cheerful. It opens the streams and reports the size.

Removed: ImageHelper (Orkeon.Tools.Abstractions) — no production caller, and where it disagreed with the live ContentConverter it was the wrong one: it declared SVG a supported image type, which no vision API accepts. CliFileSystemService (orkeon) — no production instantiation, a ResolveAndValidate that ignored its requiredRight argument entirely, and prefix compares with no separator boundary.

Also: AgentMapper hardcoded Status = "Active" while the two handlers that actually map an agent read agent.Status and never called it — it reports the real status now, and the handlers go through it. The Orkeon.Tools.FileSystem layering guard was a denylist of two names under a doc describing an allowlist that was already false; it is an allowlist. Four *_ShouldHandleEvent tests whose only assertion was Assert.True(true) are gone — their siblings assert what the handlers produce. And the forge sandbox's stated write boundary now matches its mounts (the session directory, not the /output folder inside it), asyncExecution: and the crew rag: block say what they do, and the CLI reference carries the caveat both getting-started pages already had about orkeon run <dir>/crew.

Fixed — the adversarial pass, turned on the sweep's own work

The sweep that produced the sections above was reviewed by agents briefed to refute it rather than confirm it. The deletions held: nothing removed was reachable, and the database security policy the removal was accused of dropping was in fact the weaker of two copies — the surviving Orkeon.Tools.Data.Relational.DefaultDatabaseSecurityPolicy blocks stacked DDL after a benign SELECT, neutralises comment prefixes and gates UPDATE without a WHERE, none of which the deleted one did. What did not hold was the work around the deletions.

An encrypted memory item kept its content and lost its identity. The decorator rebuilt every item through MemoryItem.Create, which mints a fresh MemoryItemId and stamps CreatedAt = UtcNow, AccessCount = 0, LastAccessedAt = null — fields no caller can pass. SqliteMemoryRecord restores exactly those from storage on purpose; wrapping that provider in EncryptedMemoryProviderDecorator threw the work away again, so an encrypted long-term memory reported the moment it was decrypted as its creation time and never accumulated an access count. Ageing and recency-ordering read wrong values, and only with encryption switched on. The rebuild goes through MemoryItem.Restore now, which carries identity and metadata over whole rather than enumerating fields that can be forgotten. Consolidating the six inline rebuilds into one place had fixed the two dropped metadata fields and asserted completeness without checking identity.

Removed: FeatureFlags (Orkeon.Application.Configuration). Its twin OrkeonFeatureFlags was removed above for having no production reader; this one sat in the same folder with the same profile, and was the more misleading of the two — ShouldUseForAgent / ShouldUseForCrew implement hash-bucketed gradual rollout over TrafficPercentage, so its public surface offers to canary a percentage of crews onto UseSequentialCrewOrchestrator. Nothing called it. Its only consumer was its own test file.

Removed (breaking, packages): Orkeon.Application.Abstractions.Data (DatabaseQueryOptions, IDatabaseProviderFactory, IDatabaseSecurityPolicy) and Orkeon.Infrastructure.Data (DatabaseProviderFactory, DefaultDatabaseSecurityPolicy) — recorded in the public-API files but not here. The migration is a namespace change, not a rewrite: the surviving types carry the same names under Orkeon.Tools.Abstractions.Data and Orkeon.Tools.Data.Relational, so a consumer sees "type or namespace not found" and needs one using changed. docs/architecture/security.md names the namespace now instead of the bare interface.

Orkeon.Infrastructure no longer drags in two database drivers it does not use. Microsoft.Data.SqlClient (with its Azure.Identity / Microsoft.Identity.Client chain) and MySqlConnector were referenced for the removed DatabaseProviderFactory alone. Orkeon.Tools.Data references them and is where they belong; every consumer of the Infrastructure package was carrying their restore weight and CVE surface for code that no longer exists. Npgsql stays — Checkpointing/PostgresStateStore uses it.

A promoted team could not write the deliverable it was built to produce. The read mount is derived first, so a deliverable landing under /workspace met a read-only entry and was skipped on the name alone: the launcher spelled /workspace:ro, the deliverable resolver logged a warning, and the run reported that it had finished. Studio's sibling derivation deduped the other way and left a read-only /workspace beside a read-write one — two chips for one root, the one promising a write being the one silently dropped. Both hold the same rule now: one root, one mount, and a write requirement wins over a read one.

A deliverable folder named with a : or a ; produced a launcher that died at every start. Those are the mount grammar's own separators — the launcher quotes the physical segment and spells the virtual one bare — so --mount "…/rapports:2026":/rapports:2026:rw reached FileSystemMount.Parse as four parts, after ForgePromoter had already created the folder, so the team looked complete. ForgeBlueprint.Validate refuses the root at submit time, where a repair turn can rename the folder, and the derivation refuses it again.

FORGE.md recommended the command the docs warn about. The card said "the folder is ordinary: orkeon run <dir>/crew launches it too" — which is true, and launches it without the --mount arguments the launchers supply, so a team with deliverables writes nothing and reports success. Both getting-started pages and the CLI reference carry that caveat; the card is what the colleague receiving the folder reads, and it was the last surface still giving the bare command.

The launcher followed a symlink to the wrong folder. dirname "$0" on a symlink gives the link's directory, so symlinking "run this team" onto PATH — normal for a folder the card calls ordinary — made the launcher mount ~/bin/output and die naming folders the user never created. It resolves the link chain first, with plain readlink rather than GNU's -f, and the cd now carries || exit 1.

An appsettings.json mount was silently dropped on every single run. The runner writes its own mounts into Orkeon:FileSystem:Mounts:0, :1, … from an in-memory source added last — which wins on an identical key. So index 0 did not add a mount, it replaced the operator's first one; and cliMounts is never empty in a real run, since the crew mount is inserted at index 0 before this code sees it. Every tool touching that mount then failed "no mount found", with nothing anywhere saying a mount had been dropped, and orkeon-host lost one per hosted crew directory. The overwrite had already been found and fixed for the sibling key PathSecurity:AdditionalAllowedDirectories — in the same pass that left it standing here, and then copied its shape into the brand-new InternalMounts key. All three append now, and the regression test asserts it on the merged registry rather than on the mount strings, which is what the existing suites looked at.

docker build . did not build. src/Directory.Build.props imports the file above it with an unconditional <Import>, so with the root Directory.Build.props absent the expression evaluates to "" and MSBuild refuses it (MSB4020) — restore tolerates the empty import, publish does not, which is why the layer that fails is not the layer that looks wrong. Replacing the hand-written project list with COPY src/ did not fix the Dockerfile, and nothing in CI builds this file, so the claimed fix was never executed once. It is copied now, and the image builds.

crew.process was validated where nothing could recover from it. Unknown values are refused rather than silently becoming Sequential — but ForgeBlueprint.Validate never checked the field, so blueprint_submit accepted process: pipeline and answered "Blueprint submitted", and the throw landed in ForgeBlueprintCompiler.Compile, called un-guarded from the validate stage, the render stage and ValidateEditedBlueprint. None of them turns it into a validation error, so it never reached the two-attempt repair loop built for exactly this: the session died at the CLI boundary with the interview and blueprint turns already paid for, and forge resume reloaded the same artifact and died at the same point. The check now runs at submit time, where the model can act on it.

An internal mount was a boundary in the virtual namespace only. The commit above refuses the name /llm-logs; it refused nothing to the bytes. With the log directory nested inside an agent-facing mount — the ordinary arrangement, since --llm-log ./logs needs no --allow-external-mounts precisely because it stays under the working directory, and the working directory is what gets mounted for the agents — /workspace/logs/llm-exchanges-….jsonl returned the very file that /llm-logs/llm-exchanges-….jsonl was refused for, and ToVirtualPath handed that address out. Both directions enforce physical containment now. Its own test suite mounted the two directories as siblings.

/sandbox was mounted in every host and usable in none. Resolving a virtual path is two steps: the registry answers where, then IPathValidator answers whether. Moving the sandbox mount into the registry fixed the first and left the second denying it — the session directory lives under the temp directory while the validator's workspace root defaults to the current one — so the first call of every code execution kept failing, saying "Path is outside the allowed workspace directory" instead of "No mount found". No flag rescued it: --allow-external-mounts whitelists the CLI and internal mount lists, and the sandbox root is in neither, because it is injected rather than configured. The session root is registered as an allowed directory, and the test exercises the real validator instead of stubbing it.

The sandbox janitor deleted directories it had not created. It swept every subdirectory of EphemeralRoot older than the threshold, recursively, checking neither the name nor whether the owning process was alive — and it now runs in every process that builds a VFS rather than only in a started host. A directory's mtime freezes once its direct children exist, so a daemon idle past the threshold looked exactly like an orphan and a CLI invocation would delete its sandbox mid-run; and since EphemeralRoot is a free-form string whose directory this code creates, pointing it at an existing folder made the sweep a recursive delete of user data. Both guards are in place. Runner flows also dispose their host now, so the session directory goes at the end of the run rather than waiting for a later sweep, and /sandbox joins the reserved virtual roots — a user --mount claiming it was crashing a DI factory instead of printing the one-line refusal.

A stalled embedding endpoint killed the crew and blamed the user. TaskAgentSelector rethrew every OperationCanceledException, but an HTTP timeout inside the embedding backend surfaces as one too — and definitionally is not the crew's token, since the adapter passes CancellationToken.None down. It went straight past the degrade-to-round-robin path the class exists for, and the terminal event reported a cancellation nobody requested. The guard is conditioned on the caller's token.

The scripting typings did not compile, in a new way. tools.d.ts traded an index signature a namespace cannot carry for a namespace tools beside a const tools, which do not merge (TS2300/TS2395); llm.d.ts introduced a second LlmConfig colliding with the one in agent.d.ts (TS2687 on all six members, TS2717 on model) — a net-new break in a file that pass never opened. Both passed the new typings test, because it runs esbuild: a transpiler strips types and reports neither. tools is one interface with one const now, LlmConfig is declared once, and the suite gained a check for the duplicate-declaration shapes a transpiler structurally cannot see. The removed agent.d.ts copy also documented a literal the runtime discards — ExtractLlmConfig returns null for anything that is not a JsLlmConfig.

The inbound process-type map still collapsed unlisted modes into Sequential, and the DTO enum stopped four modes short of the six the domain carries, so a crew created through CrewMapper could not be Graph or Autonomous at all and asking for one produced a Sequential crew that ran to completion. The enum carries all six; an out-of-range value is an argument error. The test that asserted the fallback asserted it by name.

A command that is not installed put a disk path in front of the model. ShellCommandTool now hands ProcessStartInfo a resolved physical working directory, and process.Start() sat outside the outbound rewrite — so any allowlisted-but-missing binary returned "…with working directory '/tmp/…'" to the LLM. The start is redacted like every other outbound string.

Two containment copies survived the pass that claimed to unify them. The registry's own anti-traversal check — inside the very method the boundary suite exercises — and both guards in Studio's TeamCatalog hardcoded Ordinal and knew nothing of AltDirectorySeparatorChar. All five call sites route through PhysicalPathContainment now, and the type's own doc says five rather than three.

The VFS exception table pointed at a file that was deleted in the same pass. docs/architecture/vfs-compliance.md and its French mirror still listed Scripting.Cli/CliFileSystemService.cs as a ratified permanent exception — doubly wrong, since that file was never in the analyzer's allowlist to begin with; it carried an inline suppression. The neighbouring bootstrap row was updated for SandboxSession in the same edit, so the row was read and left.

1.0.0-rc.2 - 2026-08-25

Added — Remediation v3: what a run costs, and adoption that is no longer a one-way door

The owner's third design pass (RC2-FEAT-06) lands two engine-backed features and a conformity sweep of the wizard.

Usage metrics on the wire (W-08). The cache dimension joins the token telemetry end to end: TokenUsage carries the prompt-cache hit/miss pair (a partition of the prompt tokens, never an addition) with a computed hit ratio; every orchestration strategy stamps tokens+cache on its per-task snapshots; the CostUsageEvent sink channel carries the same pair. orkeon run's run.finished now says what the run cost (durationMs, prompt/completion split, cache pair), and the forge trial's run.finished and verdict.ready carry the trial's own figures — distinct from the session-cumulative cost.updated. Studio shows them as one chip recipe («12 840 tokens» · «cache 62 % · 7 980 tokens» · «59 s») on the verdict card, the launcher's finish line and the history entries (tolerant schema). Not measured = no chip, never a zero.

Modify, re-try, re-adopt (W-09). forge resume of a promoted session (or an abandoned one that reached a verdict) reopens it at the arbitration — the stored verdict re-announced first; a new retry decision re-runs the trial as-is (zero compose tokens, one budget iteration, refused recoverably on an exhausted budget); forge promote to the session's own promotedTo updates the team folder in place (generated files regenerated, user files preserved, a dropped schedule removed) — any other non-empty destination stays refused. In Studio, « Modifier » on a team card reopens the wizard at Composer with the stepper fully reachable and the adoption fields seeded from the sidecar; re-adoption is pinned to the original folder; the saved card offers « Modifier l'équipe » and « Refaire un essai ». The blueprint's crew.name must now be a short display name (≤ 60 chars, repairable error) — it becomes the team's folder name.

Edit at the dry pause (W-10). forge resume <slug> --edit amends the blueprint of a session paused before its trial: the amended JSON travels as the channel's first inbound line, is validated in full (parse, compile, tool catalogue), re-announced blueprint.ready on the current iteration — no charge: that iteration's trial has not run yet — then re-rendered deterministically; with --dry the session pauses again at the same boundary, and an invalid edit leaves it exactly where it was (recoverable FORGE-BLUEPRINT-INVALID). This wires Studio's « Modifier » on the Composer step's agent cards, which was greyed out at the pause: the agent editor now applies through a resume --edit --dry child run and the Composer repaints with the amended team. At the arbitration, the edit decision remains the path.

Conformity (mock v3 volets): the stepper pills centre number and label; the verdict buttons live in the verdict card (accept primary); one shared chip recipe (ToolChip/ChipAction) across every tool, mount and metric chip; card headers align title and mono meta; the « Définition générée » card shows the rendered YAML itself with a Copy action; the Adopt step's model setting is a profile card with unfoldable radio rows (no ComboBox); the Composer folder row shows the mounts the agents imply (deliverable roots + the sandbox read mount). Also fixed: a cold resume of the Composer pause left « Essayer l'équipe » dead (the hydrator now restores the session identity from session.json).

True half-circle pills (W-11). WPF, unlike CSS, does not clamp CornerRadius to half the element's height — the 999 reflex deformed every chip's ends into ogives. Every pill now carries a fixed height with a radius of exactly half of it: ToolChip 22/11, new MetricChip 20/10 (tokens, cache, wall time), BadgeBase 20/10 (plus BadgeNeutral/BadgeSky variants), and no chip border hard-codes a radius in a view any more. Action buttons are not pills: ChipAction drops from 12.5 to the 10 cap. A conformity test sweeps the XAML (no oversized radius anywhere) and pins radius == height/2 on the pill styles.

Added — Remediation v2: team folders end to end, and the blueprint edited by hand

The owner's second design pass (RC2-FEAT-05) closes the gap between the v3 mock and the app around one idea: a team's folders are part of the team. The adopted team's sidecar now records its mounts; the "Mes équipes" cards show them as chips with a three-tone badge (scheduled / to try / on demand), the agent count, the last run from the launch history and the model setting; « Changer les dossiers » opens the team-mounts modal, and every folder choice goes through the shared « Autoriser un dossier » picker (path + browse, one-level tree, rights in two radio rows, expert mount-string preview). Studio lays those mounts on each launch as --mount arguments — the chips and the command cannot disagree.

The forge protocol's reserved edit arbitration is implemented: interactive mode now arbitrates every verdict (accepting a conforming one costs one click), and decision.made {edit} followed by blueprint.edited {blueprint} re-renders deterministically — zero LLM tokens — then re-earns its verdict through the unchanged validate/test/diagnose path. The wizard's Composer step shows one card per blueprint agent (its own goal and tools) with « Modifier » opening the agent editor (name ↔ role, one-sentence goal, togglable capability chips), plus « Ajouter un agent » and the « Dossiers de cette équipe » block written into the sidecar at adoption. A novice help rail explains each step in plain words.

Also: « Validation à blanc d'abord » on the Exécuter screen (a failed dry pass stops the launch), the import report's folders row, the expert TRIAL COMMAND card, « Copier le rapport » in the Diagnostic header with its « Copié ! » feedback, the plain-words novice title on the checks card, the Limites cards' descriptions under their titles, the export action on team cards (never copies appsettings.json), and the removal of the settings validation card (the status line reports instead).

Fixed — Kimi's server-mandated temperature self-heals instead of killing the run

Moonshot rejects some models' requests with 400 invalid temperature: only 1 is allowed for this model — and which models mandate it is decided server-side. KimiLlmProvider now reads the constraint from the API's own rejection and re-sends the request once with the mandated value, logging a structured warning (never a silent substitution). The seam is a new overridable on OpenAICompatibleProviderBase (TryAdaptRejectedPayload — one adaptive retry on a 4xx, non-streaming paths only), available to any provider with a server-stated constraint. Before this, a Studio wizard run on a Kimi profile died at the brief stage after three identical rejections.

Changed — The WPF screens remediated against the v3 mock (audit T-01…T-13, screens 01–22)

A full-screen audit against the design mock (the mock is the source of truth) drove a six-lot remediation of orkeon-studio:

  • Foundations — the logo's rings rotate as one group (they were skewed by double rotation origins); MODE and EN/FR are real segmented controls; implicit styles for TextBox/ComboBox/CheckBox/RadioButton/ScrollBar erase the native Windows chrome; every raw CornerRadius="999" outside badges is bounded to height/2; the splash mascot PNG is re-flattened so its corners land exactly on the plate colour. The window holds a 1024×768 minimum.
  • Run — rebuilt as the mock's vertical cards: a sidecar-backed team card, a plain-language progress card (state title, tone badge, "Ouvrir le résultat" on the first writable mount) and a technical journal folded by default in novice; COMMANDE and the option rows are expert-only; a localized banner replaces the raw locator message when the CLI is missing.
  • Language — every user-visible French string says « équipe » (pinned by a resx test); mode-dependent subtitles carry the mock's wording; validator findings and doctor checks show a per-code plain-language overlay first, the raw CLI-grade line staying as expert detail; the Limits cards are titled in plain language.
  • Screens — History becomes a card list with per-run duration (LaunchHistoryEntry.DurationSeconds, tolerant migration) and per-card Replay/Open-result; Test is two columns with a full-height console and a sample-inputs field; Import gains a drop zone, a single Browse, a recognition report and an expert "Test it first" hop; the mounts form no longer opens in an error state and novice gets one card per folder plus an "Allow a folder" picker; Diagnostic opens on a verdict card fed by a silent first doctor run; the Create gate is a radio list.
  • Startup & secrets — the window opens at the mock's 1024×768 baseline (still resizable up); the Réglages model tab gains an "API keys" card: one row per environment variable the profiles resolve (status chip, paste field, "Mémoriser la clé"), storing through the same IApiKeyStore as the profile editor — the value lands in a user environment variable and the field empties once stored; no key ever enters a file.
  • Polish — novice Settings auto-saves on every edit (Save/Validate stay expert; the validation card is expert-only, keeping the copyable report); profile cards carry "Utilisé par" team chips; Limits cards say when the engine's defaults apply; the raw-JSON viewer is bounded; the teams counter is a quiet right-aligned figure; History/Test/Run have empty-state phrases; team cards gain an "Ouvrir le dossier" explorer action.

Added — Every provider one click away, the API key novice-proof, and a screenshot campaign

The model-profile editor (design v3, "volets" rev. 2) now carries the full provider catalogue: the two local runtimes (Ollama, Docker Model Runner — free, keyless), one card per cloud the framework ships a provider for (OpenAI, Anthropic, DeepSeek, Mistral, Gemini, Groq, Together AI, Qwen, Kimi, HuggingFace, Z.AI — endpoint, default model and key variable pre-filled from the drift-pinned runtime constants; Azure OpenAI stays a "Compatible OpenAI" entry by design), the OpenAI-compatible catch-all and the echo fallback, grouped as the mock groups them. A novice clicks a card and pastes the API key in the editor: "Mémoriser la clé" stores it in a user environment variable (the vendor's conventional name — DEEPSEEK_API_KEY, ANTHROPIC_API_KEY, …), the status chip says whether one is in place, the vendor's key console is named, and the connection test refuses to probe into a guaranteed 401 when the key is missing. The profile store only ever carries the name of the variable (ModelProfile.KeyEnvName — the round-trip test forbids the ApiKey substring in the file as a tripwire); launches resolve it and lay the value over the child process as ORKEON_Llm__ApiKey (Run, Test, history replays, and the wizard's assistant alike).

orkeon-studio --capture-screens <dir> walks every screen in both modes (plus the profile-editor and About overlays) and writes one PNG per stop — the fidelity-remediation reference collection against the design mock, one command on a Windows machine.

The Diagnostic screen gains "Copier le rapport": WPF text blocks are not selectable, so the whole orkeon doctor result (verdict, every check verbatim, parse error if any) is now one click away from the clipboard.

The Settings screen's validation card gains the same copy affordance as the diagnostic ("Copier le rapport"): summary line plus every finding with its severity, verbatim.

OrkeonBinaryLocator learns the development-checkout layout: when Studio runs from its own bin/ inside a clone (detected by walking up to Orkeon.sln), it probes src/scripting/Orkeon.Scripting.Cli/bin/<Configuration>/<tfm>/ — same configuration first, the sibling second — so F5-from-the-IDE finds the CLI the repo just built instead of reporting it missing. The not-found message now names the dev gesture (dotnet build src/scripting/Orkeon.Scripting.Cli) — and the whole lookup is now operator-steerable, in order: the --cli-dir <dir> argument (WPF app), next to the executable, the ORKEON_CLI_DIR environment variable, PATH, then the development checkout. The not-found message lists that exact order.

Changed — Full documentation audit against the implementation (DOC-04)

A five-domain adversarial audit (getting-started/README, architecture, RAG/RaggableTree/ EventHub/ADRs, reference, orchestration/guides) verified every factual claim in the docs against the code and fixed ~140 confirmed discrepancies, in both languages. The heaviest classes: phantom APIs (AddOrkeonRuntime, CodeSecurityAnalyzer/CodeSandbox/ SensitiveDataDetector/ComplianceChecker/RetryPolicy-family types, the ValidateServerCertificate opt-out, manager_llm/autonomous_budget/state_timeout/ json_search/csv_search YAML keys, the raggableTree: crew-YAML section, the Exp07CommandSurfaceTests suite, Orkeon.Examples.Runner); YAML samples teaching a shape the loader silently loads as an empty crew (a crew: root wrapper and sequence-form agents:/tasks: — the schema is flat-rooted with id-keyed mappings, now taught correctly in process-types/autonomous/blueprint); stale capability matrices (response-format and vision are capability-driven across the 13 providers — not "DeepSeek only"/"Anthropic+OpenAI only"; Anthropic thinking is toggle, adaptive is its wire value); wiring claims corrected to what composition roots actually do (the AddOrkeonInfrastructure overload capability table, MCP being effectively library-only, the empty InMemoryToolRegistry stub vs ServiceProviderToolRegistry in both tool-authoring guides, StrictTools lenient library default, EventHub telemetry/ metrics marked designed-not-built, the autonomous YAML budget being Permissive not Default); plus the settings-resolution chain, the complete orkeon run flag table, yaml-schema.md gaining the six shipped blocks it omitted (llm: full surface, links:, task tools:/deliverable:/llm_override:), [ToolContract] added to the new-tool guide, VFS diagnostic help-link anchors, and ADR-002/005 amendments recording their drifted counts.

Four code fixes rode along: RunArgumentsBuilder now emits a single --mount/-V flag with space-separated values (the CLI parser rejects a repeated option — multi-mount and multi-variable Studio launches were broken); AddOrkeonApplication(Action<…>) no longer silently drops AgentSelectionStrategy from the options copy; the three examples/runners packables are re-aligned on 1.0.0-rc.2; and the plugins CA2000 suppression justification now states the real ownership contract.

Changed — The tool inventory rebuilt against the implementation, and gated (DOC-03)

docs/tools/inventory.md (and its French mirror) claimed 43 tool names out of the 79 built-in tool classes, listed two tools that do not exist (bing_search, google_search), used registry names the code never had (delegate_work and ask_question — the real names are delegate_work_to_coworker and ask_question_to_coworker), and flatly denied XLSX support while xlsx_reader and xlsx_writer ship in AddOrkeonDataTools(). The page is rebuilt as the reference catalogue: every one of the 79 tools with its exact agent-visible name, class, owning DI extension and secrets policy; an availability matrix per composition root (orkeon run vs the REPL — they do not register the same suites); the complete alphabetical YAML mapping; an "outside the catalogue" section (forge-internal tools, McpToolAdapter, test doubles); and the counting rule stated so the number is true by definition. Secondary surfaces follow: autonomous.md no longer implies spawn_agent is wired (no shipped root registers it — now a documented limitation) and its YAML example stops citing the nonexistent json_search/csv_search; bootstrap.md's suite comments match what each extension actually registers; the porting guide and the READMEs mention Office (DOCX & XLSX) explicitly.

scripts/check-doc-claims.py gains the gate that makes the regression class impossible: it extracts every agent-visible tool name from the code (the [ToolContract("…")] positional or the Name => "…" literal of each counted file) and fails the build if a shipped tool is missing from the inventory (either language), if the inventory tables a name no tool bears, or if the summary total drifts.

Changed — Orkeon Studio v3 "volets": the WPF app becomes a team-lifecycle product

The Claude Design v3 handoff is implemented end to end. The window's sidebar now follows the life of a team — Agent teams (Create a team, My teams, Import), Work (Test, Run, History), Environment (Settings, Diagnostic) — under a global Novice/Expert switch persisted with the theme and language: Novice explains each step and shows contextual help, Expert shows the machinery (command lines, raw JSON, technical journal, the Test screen). The window opens on a startup screen (Kama, the mascot — click to skip) and carries an About overlay; the guided tour is rewritten to the five v3 stops.

  • Settings, unified: the former Start/Sections/Mounts/Raw screens fold into one "Réglages" entry with four inner tabs (AI model, authorized folders, expert-only limits & logs, expert-only raw file with its location and resolution chain). The model tab introduces named model profiles (studio-model-profiles.json, next to studio-history.json): reusable settings, a default election mirrored into the Llm section through the ordinary save cycle, per-profile ORKEON_Llm__* environment overrides, and the profile Studio's own assistant runs on. The API key never enters the store. The preset picker retires; the profile editor offers the same orkeon init catalogue with a live connection probe. The Diagnostic sidebar entry gains a warning dot.
  • The creation wizard replaces the Atelier UI (breaking for the screen, not the engine): "Créer une équipe" walks Décrire ▸ Composer ▸ Essayer ▸ Adopter over the same orkeon forge --events jsonl child — the stepper projects the engine's milestones, the per-step "consigne + questions" blocks travel down user.message, arbitration buttons come from decision.needed's own options, "Fix and retry" carries the trial consigne, and the wizard is gated until the assistant has a model profile (handed to the engine as environment overrides). ForgeClient, the session model and the protocol are unchanged.
  • My teams: adoption promotes straight into ~/Orkeon/teams/<slug> with the engine's real schedule grammar (on demand, daily@HH:mm, hourly) and writes a studio-team.json sidecar (name, need, profile, displayed schedule — never a key). The sidecar's profile rides every launch of the team — Run, Test, and history replays — as ORKEON_Llm__* environment overrides resolved against the profile store. Team folders are listed as cards (launch, duplicate, delete), next to the wizard sessions still underway, resumable where they stopped.
  • Import and Test: "Importer" recognizes a shared team with the launcher's own detector, warns loudly when a definition carries a pasted secret, and copies into the teams root only on confirmation, under a never-overwriting slug. The expert "Tester" screen runs blank-run validations and real trials over a dedicated launcher with no history store. In Novice, the run screen hides the options machinery entirely.

The two Terminal.Gui apps (orkeon-studio-config, orkeon-studio-run) keep their current surface. Nothing is deployed, so the old WPF screens are removed without shims; the resx pair moves to 395 keys per language, still pinned by the drift and parity tests.

Added — Studio staffs the client://studio seat: agent requests answered on screen

An agent's send_request to the watching client no longer dies of a 30-second timeout: the Launch screen shows the request and a human answers it.

  • Protocol: hub.message gains an expectsReply: true field, emitted only on an agent's send. The peer must not have to guess which correlated lines are questions — a topic relay can carry a correlationId too, and the answer to the peer's own send pairs by correlation as well. The field is additive; readers that ignore it lose nothing.
  • Studio Core: RunProgressModel folds marked sends into a PendingAgentRequest queue (dedupe by correlation id, cleared at run.finished, ReplyAccepted() mirroring AnswerAccepted()), alongside the untouched HubMessages journal.
  • Studio WPF: a request panel — asking agent's hub address, raw JSON payload, reply box — in the Launch screen's progress card. The typed reply goes down stdin as the {"kind":"reply",…} line the bridge requires; text that parses as JSON travels as that JSON (an agent may await a shape), anything else as a plain JSON string. A refused write keeps the request on screen. Hub posts are now listed in a compact panel instead of being parsed and shown nowhere. Silence past the agent's own timeout remains a refusal — the screen just gives the human a chance to speak before it.

Added — Real Discord slash commands: /status and /stop, registered and gated

The host's two commands stop being text parsing and become what Discord users expect: registered slash commands, autocompleted by the client, answered ephemerally — a status poke or a refusal is the invoker's business, not one more line in everyone's thread.

  • Registration at connect: globally when Discord:GuildIds is empty (zero configuration, Discord caches global commands up to ~1 h), or per named guild for immediate availability (the dev loop). A registration hiccup logs a warning and leaves the message channel alive — it never kills the daemon. An unparseable guild id refuses the start (exit 78).
  • The text parsing is removed (nothing is deployed, no dual path): the platform's client intercepts the slash, and a literal /stop arriving as plain message content is a prompt like any other.
  • Security fix along the way: the Stop button used to bypass the allow list entirely — component.User was never read, so anyone who could see the thread could kill a run while typing /stop was gated. Button and slash commands now converge on one CommandInvocation path checked against AllowedUserIds; an unauthorized click gets an ephemeral refusal instead of a silent stop.
  • The privileged MessageContent intent stays: runs are started by plain thread messages, which slash commands do not replace.

Added — The Atelier: orkeon forge, from a need in plain words to a deployable crew (FORGE-01→08)

The missing step between "I have a problem" and a running agent team. orkeon forge "summarize my supplier's new offers every morning" opens a short interview, captures a structured brief — goal, inputs, acceptance criteria, a sample input — plans a team, renders it as ordinary crew files, validates it, tries it in a sandbox on that sample, and judges the result against the criteria the user stated. Not conforming? The diagnosis feeds a refine loop, bounded by a hard three-dimension budget (iterations, tokens, wall time). orkeon forge promote <slug> --to <dir> then ships the crew as an ordinary folder.

The spine is deterministic — a StateMachine<ForgeState, ForgeTrigger> with 11 states, checkpointed after every step — and only schema-validated brief_submit / blueprint_submit submissions advance it: the conversation is carried by an embedded crew (the scripting DSL running under Jint, ctx.llm.act() reached natively), but it never steers the cycle. Sessions live under .orkeon/forge/<slug>/ — resumable (forge resume), diffable between attempts, auditable — and every run emits a versioned JSONL event protocol (--events jsonl), golden-pinned on both sides of the wire.

  • Two formats, one generation. The assistant produces a single schema-constrained blueprint; two deterministic renderers derive from it — the per-entity YAML layout (default) or an editable crew.ork.ts (--format script, needs esbuild; absent, a new session falls back to YAML with FORGE-ESBUILD-MISSING). Both converge on the same CrewDefinitionValidator, and the sandboxed try loads the crew from the rendered files — what was written is what runs.
  • The sandbox restricts by removing tools from the catalogue, not by hoping the model abstains: shell_command and code_interpreter are gone from the list that feeds both the blueprint prompt and the validation, and writes are confined to the session's /output mount, snapshotted per run.
  • The verdict is recomputed, never trusted: score ≥ 0.7 and no blocking finding, with a missed must criterion blocking regardless of score. With no judge available, the verdict announces itself as deterministic and leans on mechanical checks — it never invents a passing score. Accepting a non-conforming result on sight stays legitimate.
  • Promotion is honest about its limits: the folder carries crew/, run.sh/run.cmd composed against the CLI's own orkeon run grammar with the sample inputs pre-filled, and FORGE.md — the crew's identity card, written in the interview's language. With --schedule daily@HH:mm|hourly, the Windows task XML, systemd timer and cron line are generated and the install command is displayed, never executed: Orkeon has no scheduler, and pretending otherwise would promise supervision it cannot give.

In Orkeon Studio, the same engine drives a new Solve screen (WPF): a conversation on the left, one card at a time on the right — success criteria, the proposal in plain words, the live try, the ✔/✘ checklist quoting those criteria verbatim, then "what now?". Studio spawns orkeon forge --events jsonl as a child process and answers over stdin; it never touches an LLM itself, and a capability absent from the event stream exists on no screen. Orkeon.Studio.Core gains a Forge/ client (tolerant parser pinned against the CLI's golden lines, session projection, catalogue, resume hydrator) without a single new dependency. RunSession/RunLaunchRequest/TargetSelectionModel/LaunchOptionsModel were promoted into Orkeon.Studio.Core.Launch along the way, so the launch lifecycle now exists once instead of twice.

Docs: Forge a team from a need (EN/FR), the orkeon forge section of the CLI reference, and examples/forge/promote-demo/ — a bundled ready session whose list/promote half runs with no LLM at all.

Added — Watch a run, talk to it, host it: the event bus, the hub pipeline, the service host (BUS, HUB, GATE)

Three chantiers that share one goal: a crew you can see, answer and reach from outside the process it runs in.

orkeon run --events jsonl speaks a versioned protocol instead of printing for a person — one JSON document per line out, one per line back. Task completions in all six orchestration modes — terminal events included: a cancelled or failed run still says so, in every mode — cost with model and provider (no invented price: the framework has no price table), generation deltas under --stream, tool calls, delegations, and runtime agent spawns when a spawn_agent tool is attached. Tool events come from a single decorator applied where tools enter the process — the DI registrations, and through the IToolDecorator port the per-agent delegation pair — so the agent loops and the scripting facade are covered at once, .ork.ts targets included. Contract: The run event bus, plus a ~90-line dependency-free reader in examples/run-events/ with a recorded stream to try offline.

  • Silence is not consent. Without the protocol, a task declared humanInput: true was auto-approved behind the user's back. Asking for the stream replaces that provider: the question goes out and the run waits. No answer — closed channel, cancelled run — is a refusal, never an approval.
  • Studio's Launch screen stopped being a terminal. It shows finished tasks, cost and the run's question on screen; the raw log is demoted, not removed. A silent run says "nothing reported yet" rather than implying progress, and a question with no correlation id is not shown as pending, because answering needs an address.

The EventHub's middleware pipeline ships complete: logging, telemetry, ACL, idempotency and validation, on both the publish and the receive path. The links: YAML grammar lets a crew declare who it may talk to, and client://{name} lets an external process be named — without it, a watching peer would escape the ACL by simply not being modelled. Idempotency guards point-to-point delivery only: deduplicating a topic message by identifier would starve every subscriber but the first. Its memory does not survive the process, which is stated rather than implied.

orkeon-host hosts crews as a daemon — systemd unit, Windows service or container, same binary, and runnable in a terminal because a daemon you cannot run in the foreground is one you cannot debug. One dependency-injection scope per run, which is what keeps one conversation's memory from reaching another's. A Discord channel gives the first place people can reach a crew from: allow-list authorization checked before routing, thread-is-run mapping, an immediate acknowledgement carrying a Stop button, throttled progress, /status and /stop. An empty allow list denies everyone and refuses to start.

It hosts crews; it does not schedule them. rc.2 ships no scheduler, and neither the docs nor the systemd unit implies otherwise. Docs: The service host and the chat gateway (EN/FR), examples/service-host/, and deploy/ for the unit, the SCM script and the Dockerfile.

Changed — EventHub API surface, and the crew configuration

CrewLink and CrewLinkDirection live in Orkeon.Domain.EventHub: a link is what a crew declares, not a transport detail — and it names its target by the crew's name:, the only identity a YAML author has (ICrewLinkRegistry.Register records the id ↔ name mapping for every crew, links or not). CrewConfiguration gained a nullable Links (never-declared and declared-empty are different answers to the ACL). MailboxAddress gained the client:// scheme. Message.NoDeclaredSchemaId is "_none" — a sentinel that cannot collide with a real schema id. CrewOutput gained Succeeded, because KickoffAsync never throws and a host has to tell an answer from an apology. IMemoryService gained ReleaseMemorySystem, the daemon-side counterpart of loading a crew per message. The forge stream shares the run envelope and speaks protocol v2 (was v1); its reserved-name set grew from four to eight. Several constructors gained an optional trailing parameter — the orchestration strategies (ICrewExecutionHook), InMemoryEventHub (middlewares), CrewFactory (the link registry), AgentDelegationToolsProvider (the tool decorator) and RunnerHost.Build (a builder hook). Source-compatible; recompile.

Fixed — Two harness defects that were reporting success

TraceExplorerService listened to every process-wide Orkeon activity source, so a test asserting "no traces" was really asserting that no other test emitted one — true by luck, and less true as the suite grew. Trace capture is now scopeable via MonitoringOptions.TraceSourcePrefix.

The E2E CLI tests rebuilt the CLI on every invocation, and two classes doing that concurrently made MSBuild write its diagnostics onto the stream under assertion. The CLI is now built once per assembly and run with --no-build.

1.0.0-rc.1 - 2026-08-18

Orkeon's first release candidate — the version that goes to NuGet.org. Everything accumulated since 0.9.2-beta ships here: the RAG subsystem with its five profiles and the corrective CRAG graph, declared LLM capabilities across all 13 providers (Google Gemini joining as the 13th), the dual-era MCP client and server, A2A task persistence, Orkeon Studio with full localization, the Windows/Debian/macOS install channels, the TypeScript CLI command layer, the complete API reference site — and a mechanically frozen public API surface (29 235 declared APIs, [Experimental] markers on the four unstable areas) with the versioning policy to match. Breaking changes below are called out in their own entries (RAG namespace extraction, API-shape conformance, Orkeon.Cli.Commands.Scripting rename).

Fixed — orkeon llm probe|models now know Gemini (PUB-15 leftover)

LlmProviderFactory accepted gemini/google since PUB-15, but the CLI's LlmCatalogClient had no default base URL for it and did not treat it as OpenAI-catalog-compatible — orkeon llm models -p gemini failed without an explicit -u, and the probe help text stopped at 12 providers. Both wired; surfaced by the DOC-02 review of the new CLI reference page.

Changed — Documentation trued up against the code, end to end (DOC-02)

A three-pass audit (docs/ tree, root/examples/OSS surface, facts vs code) followed by full remediation. Highlights: the quality-gate page no longer claims a blocking Sonar CI gate that does not exist; the fictional autonomousBudget YAML block is marked not-implemented; two lifted limitations rewritten (uniform streaming, runtime plugins); every count trued (79 tool classes, 44 domain events, 13 providers, 33+33 projects); 17 dead maintainer-side references and 4 failing copy-paste commands fixed; ~350 French fragments in EN docs translated; docs/arkeon/ retired; CLAUDE.md no longer rendered on the docs site; docs/fr/toc.yml created (51 FR pages were orphans) and the ADR register joined the site nav. New pages (EN + FR): reference/cli.md, reference/configuration.md, architecture/mcp.md, architecture/studio.md. New guards in CI: scripts/check-doc-claims.py (counts checked against the code), a category-README completeness check, and an informational EN/FR drift report. New community files: SUPPORT (EN/FR), NOTICE, CODEOWNERS, dependabot, CodeQL, a documentation issue form.

Fixed — ExecutionPlanParser no longer throws on non-string JSON values

ExecutionPlanParser parses untrusted LLM planning output, yet "task": 42, "instructions": 42, "agent": 42 or a number/null inside "dependencies" escaped the JsonException net as an InvalidOperationException from JsonElement.GetString() and took the whole planning pass down. Every string-position read is now guarded by a ValueKind check: malformed entries degrade the same way unknown ids always have (entry skipped, dependency dropped, agent unassigned) instead of throwing. Surfaced by the SONAR-14 coverage pass on the parser.

Added — Studio i18n: the whole below-the-view layer follows the language switch (STUDIO-11 tranche 2)

Completes the sweep opened by PUB-19: the IStudioStrings registry grows from 4 to 89 keys covering every string Core and the WPF ViewModels fabricate — the orkeon init preset catalogue (labels, guidance, plan errors, via LlmPresets.CatalogFor), the settings resolution chain (SettingsLocations.ResolutionChainFor), the mount-rights labels (MountRightsTokens.ChoicesFor/GetLabel(rights, strings)), the directory-run notice, the --mount override semantics, and all ViewModel statuses, summaries, dialog titles and filters. Every long-lived ViewModel takes the port (optional, English default — TUIs unchanged) and re-emits its bindings on CultureChanged; transient rows (mounts, overrides, effective-mount table) are refreshed by their owners. 89 keys mirrored EN/FR in the WPF resx; a new drift test pins resx-EN ≡ EnglishStudioStrings so the two English surfaces cannot diverge. Deliberately untranslated (CLI-contract policy, like VALIDATION OK/FAILED): orkeon doctor check names/details, validator message bodies, target-detector remediations, LLM probe results, and exit-code descriptions.

Added — Studio localization port: strings below the view layer follow the language switch (PUB-19 tranche 1)

Foundation for STUDIO-11 ("switching to French leaves some strings in English"): Orkeon.Studio.Core gains a localization port (IStudioStrings, key registry, English defaults) consumed by the shared formatters — ValidationMessageFormatter and LaunchOutcomeFormatter first — through additive overloads (the TUIs keep the English default, no regression). The WPF front bridges the port onto its resx-backed I18n (I18nStudioStrings, hot language switch relayed via CultureChanged), with the new keys mirrored EN/FR under the existing resx-parity test. CLI verdict words (VALIDATION OK/FAILED) deliberately stay untranslated. The ViewModel sweep continues on this pattern (tracked in STUDIO-11).

Added — Test pyramid rebalanced: offline E2E per orchestration mode, nightly integration, no swallowed SIGSEGV (PUB-17)

  • E2E grows from 17 to 43 executed facts, all offline: a new suite drives the full DI stack (Application + Infrastructure) through ICrewOrchestrationService.KickoffAsync for each of the six orchestration modes (sequential, hierarchical, parallel, consensual, graph, autonomous) with a scripted LLM — per mode: the kickoff completes, produces exactly one output per declared task, and demonstrably drives the LLM (no silent no-op path). Two Category=Slow facts spawn the real orkeon CLI from source and --validate a single-YAML example and a multi-file crew directory end-to-end.
  • integration.yml: the Integration/Slow suites (Testcontainers databases) now run nightly (02:17 UTC, also dispatchable). A red run opens or comments a tracking issue — failures are visible, not buried in a log.
  • The blanket continue-on-error on Embeddings.Local is gone (ci.yml and publish.yml): the step now inspects the results — a genuine test failure fails the build; only the known ONNX teardown crash (exit 139 after a clean "Passed!" summary) is tolerated, explicitly and with a warning annotation.

Changed — Global zero-warning ratchet: full analyzer set on, CI builds -warnaserror (PUB-18)

The warning-debt story reaches its terminal state. The audit found the "frozen ~2 283 warnings" note in the build props was stale — the 2026-06-15 zero-warning campaign had already resorbed the debt; a fresh full-analysis inventory (AnalysisMode=All, AnalysisLevel=latest-all) surfaced only four stragglers solution-wide, all fixed (unused TUI palette field, DefaultDllImportSearchPaths on the libc kill P/Invoke, two per-call JsonSerializerOptions allocations). The complete analyzer rule set is now enabled permanently in the root build props, and CI compiles with -warnaserror — any new compiler, analyzer, or NuGet-audit warning fails the build (audit advisories breaking CI is deliberate; see the SSH.NET precedent). The .editorconfig ledger remains the record of the deliberate per-scope arbitrations.

Changed — DI default stand-ins fully documented; the stub planner now warns (PUB-23)

The deliberately-minimal DI defaults follow the house rule — never a silent drop — and the last gap is closed: AgentPlannerService (the fixed 4-step stub planner, the most misleading stand-in since it emits a plausible "plan" every run) now announces itself with a one-time Warning naming the replacement gesture, like the Infrastructure stubs already did (previously Debug-only, invisible under default logging). New page docs/getting-started/default-behaviors.md (EN + FR) inventories every default — the six that warn, the six that are silent by design and why — with the exact replacement snippet for each; linked from limitations and the Autonomous orchestration guide. No functional behavior change.

Added — Google Gemini provider: 13th LLM provider (PUB-15)

GeminiLlmProvider joins the family through Google's OpenAI-compatible endpoint (generativelanguage.googleapis.com/v1beta/openai, Bearer auth with the Gemini API key). Capabilities verified against the compatibility documentation (2026-08-18): effort-only thinking (reasoning_effort mapping to Gemini's thinking_level), vision via image_url data URIs; response_format is undocumented on the compat surface and therefore stays undeclared — a JSON-format request triggers the structured capability warning instead of a silent drop. Factory auto-detection by host (generativelanguage.googleapis.com) and model prefix (gemini-*); default model gemini-3.7-flash; appsettings.gemini.local.json.example template added; provider docs, comparison matrices and counts updated EN/FR. Vertex AI and AWS Bedrock remain out of scope (OAuth/SigV4 SDK stacks conflict with the simple-HTTP provider principle — recorded in the PUB-15 fiche).

Added — A2A task persistence lifts the 501; conformance matrix published (PUB-08)

  • GET /a2a/tasks/{id} is real now — opt-in: register a checkpointing state store (AddOrkeonCheckpointing / SQLite / Postgres) plus the new AddOrkeonA2ATaskPersistence(), and the A2A server records every task lifecycle transition (IA2ATaskStore port over the existing IStateStore, best-effort — a store outage never fails the task exchange). The endpoint answers 200 with the recorded state and 404 for unknown ids; DELETE /a2a/tasks/{id} now records the cancellation and answers 404 for unknown ids instead of fabricating an acknowledgement (cancellation stays advisory). Without the opt-in, the explicit 501 remains — never invented state.
  • A2A conformance matrix (docs/reference/a2a-conformance.md, EN + FR): the honest inventory of the 0.x-era surface against the A2A v1.0 specification — operations, data model (5 vs 9 task states), bindings (own REST dialect; none of the three canonical bindings), security. Includes the PUB-08 certificate-revocation decision: short-lived certificates over CRL/OCSP for the private-CA mTLS model.
  • 6 new persistence tests (adapter round-trip + end-to-end HTTP 200/404/501/cancel).

Changed — MCP unpinned from 2024-11-05: dual-era client and server (PUB-07)

The MCP integration no longer hardcodes the first protocol revision. Both sides now speak the modern stateless lineage (2026-07-28) and fall back to the legacy initialize-handshake revisions, per the specification's backward-compatibility rules:

  • Client (McpClient.ConnectAsync): probes with server/discover; a modern answer selects the newest mutually supported revision (renegotiating on UnsupportedProtocolVersionError, including mid-flight), anything else falls back to the legacy initialize handshake — which now really negotiates (2025-11-25, 2025-06-18, 2024-11-05) instead of pinning 2024-11-05, and finally sends the required notifications/initialized (it never did). Modern requests carry per-request _meta (protocol version, client info/capabilities); input_required interim results (MRTR) are surfaced as explicit tool errors rather than partial data.
  • Server (McpServer): dual-era on the same endpoint — implements the mandatory server/discover, validates the per-request declared version (-32022 UnsupportedProtocolVersionError with the supported list), answers legacy initialize with real version negotiation, no longer replies to notifications, returns tools/list in deterministic order with the required resultType/ttlMs/cacheScope fields plus server identity in result _meta.
  • Wire: JSON-RPC ids are no longer int-only (string ids from external clients now round-trip; stdio correlation is id-agnostic); the HTTP transport sends the Streamable HTTP headers (MCP-Protocol-Version, Mcp-Method, Mcp-Name) and unwraps SSE-framed response bodies.
  • 13 new dual-era tests (104 MCP tests total). Remaining gaps are documented in docs/reference/limitations.md: no subscriptions/listen, no MRTR, no MCP OAuth, JSON-response mode only on HTTP, and 2025-03-26 excluded (mandatory batching).

Added — Full API reference site and community templates (PUB-10, PUB-12)

  • docfx now covers every published library (25 assemblies — 2 916 generated API pages, nested-namespace navigation) instead of core + Tools.Abstractions only. Metadata is generated from the compiled Release assemblies, so source-generated members are included. The never-finished navigation is real now (toc.yml, docs/toc.yml, api/index.md), and the new docs.yml workflow builds the site strictly (--warningsAsErrors) on every PR touching sources or docs, and deploys it to GitHub Pages on each v* tag.
  • The strict build flushed out 31 broken documentation links — including two references to the maintainers' private repository and four to a spec folder that no longer exists in the public tree — all fixed; ADR index pages (EN/FR) added.
  • Community templates: structured issue forms (bug report with install-channel and reproduction fields, feature request), contact links routing questions to Discussions and security reports to SECURITY.md, and a pull-request template whose checklist mirrors what CI actually enforces (API freeze declaration, FR parity gate, CHANGELOG entry, executable bits, VFS-only I/O).
  • 25 public entry-point types that had no XML <summary> (RaggableTree contracts, scripting JS builders, BuilderValidationException…) are now documented.

Changed — Documentation debt cleared; FR/EN parity is now a CI gate (PUB-09)

  • The examples catalog (docs/reference/examples-catalog.md + FR) is now editorial only: the generated, CI-checked examples/INDEX.md is the authoritative inventory, so the page no longer maintains counts or paths by hand (the old page announced 104 examples with a table summing to 101 and folder casings that did not exist). It now also covers the RAG, RaggableTree, scripting, CLI-commands, local-embeddings and multi-file showcases.
  • The last four missing French mirrors are delivered (run-your-first-example, example-data-policy, hosting, the example README template): docs/ parity is green for the first time, and scripts/check-docs-parity.sh now runs in ci.yml on every push and PR — a missing mirror fails the build. CONTRIBUTING (EN/FR) states the CI-gate wording again.

Security — Testcontainers 4.13.0 → 4.14.0 (test infrastructure only)

Clears the last build warning, NU1903: Testcontainers 4.13.0 pulled SSH.NET 2025.1.0 transitively, which carries a known high-severity advisory (GHSA-q939-rpr3-3284); 4.14.0 depends on the fixed SSH.NET 2026.0.0. Test-only dependency — nothing shipped in the NuGet packages or installers was affected.

Added — The public API surface is frozen and enforced (PUB-05)

Ahead of the first public release, the API contract is now mechanical, not aspirational:

  • PublicAPI baselines — every packable library carries PublicAPI.Shipped.txt (29 235 declared public APIs across 28 projects, source-generated members included) and an empty PublicAPI.Unshipped.txt, checked by Microsoft.CodeAnalysis.PublicApiAnalyzers. An undeclared public API addition or removal is a build error (RS0016/RS0017 promoted via WarningsAsErrors). Executables (src/apps/) opt out — an app's surface is not a contract.
  • [Experimental] on the unstable surfaces — 71 types now carry ExperimentalAttribute with stable diagnostic IDs, documented in docs/reference/experimental-apis.md (EN + FR): ORKEXP001 A2A (pre-v1.0.1 implementation), ORKEXP002 Autonomous orchestration (budget, A2A channel, spawn), ORKEXP003 corrective RAG (CRAG contracts), ORKEXP004 MCP (pinned to 2024-11-05 until the protocol upgrade). Referencing them from outside the repository is a compile error to suppress explicitly; src/, tests/ and examples/ suppress the four IDs centrally because the framework wires its own experimental surfaces.
  • Versioning policy — CONTRIBUTING (EN + FR) now states the contract: SemVer, a breaking change is any edit to PublicAPI.Shipped.txt, [Obsolete] ships at least one minor version before any removal, and no breaking change to a stable shipped API within the 1.x window.
  • The 47 InternalsVisibleTo declarations were inventoried: 36 target test projects; the 11 production-to-production grants all belong to shared-kernel pairs already documented by ADR-002/003/006 (abstractions → implementation, Domain → Application/ Infrastructure, Cli.Abstractions → Cli) plus two grants to the orkeon tool executable — kept, documented in the PUB-05 closure note.

Changed — Complete NuGet package metadata (PUB-04)

Every one of the 28 packable projects now ships presentation-grade metadata:

  • Package icon per family — assets/nuget/ holds one 128 px icon per src/ zone (core, cli, scripting, analyzers, tools, rag, analysis, generators, hosting, plugins); a per-zone Directory.Build.props declares the family and the central props pack it as icon.png, so every .nupkg carries its zone's icon with a single <PackageIcon>.
  • A dedicated README per package — each project directory now has a short README.md (role, install, doc links) packed via PackageReadmeFile; the five projects that already had a rich developer README ship that one. The shared generic nuget/README.md that seven packages used to duplicate is removed.
  • PackageReleaseNotes — centralized in src/Directory.Build.props, pointing at this CHANGELOG.
  • LICENSE.md — copyright aligned with the build props (2024-2026).

Changed — NuGet.org publication wired for real (PUB-03)

publish.yml now pushes the three core packages (Orkeon.Domain, Orkeon.Application, Orkeon.Infrastructure — the v1 set of docs/reference/publication-matrix.md) to NuGet.org on a v* tag. Authentication is Trusted Publishing (OIDC): a nuget.org policy for Orkeon/orkeon + publish.yml lets NuGet/login exchange the job's OIDC token for a short-lived key — no long-lived API secret exists anywhere. The steps are gated on the NUGET_USER repository variable: until the owner finishes the nuget.org setup, they warn and no-op instead of failing the release. The workflow also refuses a tag that does not match the src/Directory.Build.props version — the guard that makes the 0.9.1-beta silent-skip incident (rc tags re-packing an unchanged version, --skip-duplicate skipping every push) structurally impossible. The README NuGet badge, which pointed at a package that does not exist on nuget.org yet, is replaced by a GitHub release badge until the first real push restores it.

Changed — Orkeon.Cli.Scripting renamed to Orkeon.Cli.Commands.Scripting (ADR-007, decision D3)

The library of TypeScript-scripted interactive CLI commands loses its near-anagram name (Orkeon.Cli.Scripting vs Orkeon.Scripting.Cli): project, PackageId, assembly, root namespace and test project are now Orkeon.Cli.Commands.Scripting(.Tests). The orkeon dotnet tool (Orkeon.Scripting.Cli) keeps its name — its PackageId is the install command. No published package carried the old name, so nothing breaks outside this repository; in-repo consumers were updated in the same change. This supersedes ADR-004 and lifts the D3 gate in docs/reference/publication-matrix.md. Entries below in this Unreleased block use the new name even where the work predates the rename.

Added — Orkeon Studio: a graphical way in, on Windows and Linux

Configuring Orkeon and launching a crew no longer requires a terminal. Orkeon Studio ships as three applications over one shared core (Orkeon.Studio.Core, which holds the appsettings model, the target detection and the orkeon run argument building — a feature absent from the core exists in no UI):

  • orkeon-studio — a WPF desktop app for Windows, two tabs (settings editor, crew launcher);
  • orkeon-studio-config — a full-screen Terminal.Gui editor for the settings file: provider presets, model and endpoint, and the VFS mount table, saved in the exact form FileSystemMount.Parse reads back;
  • orkeon-studio-run — the crew launcher in the terminal: pick a config.yaml, a crew directory or a .ork.ts script, set the options (--validate included), follow the output live, and cancel a run — the process is terminated and the exit code (130 on cancellation) is reported, with the UI still alive.

None of them is a second product: they edit the same appsettings.json orkeon init writes, and they launch crews by executing the co-installed orkeon binary, so the CLI and Studio are interchangeable on the same machine at any point.

Distribution follows the platform, not the wish list. The win-x64 zip and the MSI carry orkeon-studio (the MSI adds an "Orkeon Studio" Start-menu shortcut, its only MSI-specific authoring); the Debian package and the Linux archives carry orkeon-studio-config and orkeon-studio-run (/usr/bin/orkeon-studio-{config,run} on the .deb, launcher symlinks in <prefix>/bin from a tarball); the macOS onboarding channel — the orkeon-cli-*-osx-* tarballs and Homebrew — stays CLI-only in V1 (the multi-app orkeon-*-osx-* archives carry the two TUIs like every other RID, untested there). Linux archives and the .deb hardlink-deduplicate their payload at staging time (scripts/hardlink-dedup.sh — tar and dpkg both preserve hard links, and gzip alone cannot deduplicate across files): the byte-identical .NET runtime and shared Orkeon assemblies of the self-contained apps are stored once instead of once per app, cutting the cli linux tarball from 176 MB to 104 MB with strictly identical extracted content. Every Studio app is published self-contained like the CLI itself, which keeps the .deb's Depends free of any dotnet-runtime-* — the onboarding channel's invariant. The app table in package-installers.sh / .ps1 gained a RID-filter column for this (WPF cannot target non-Windows RIDs), and SHA256SUMS is unchanged in shape: same archive names, richer contents.

The release smokes assert all of that on real runners rather than at packaging time: orkeon-studio --smoke-exit opens the WPF window, lets it render and exits 0 on windows-latest (both channels — zip and MSI — through one shared assertion file); the .deb and linux tarball smokes require both TUI launchers and run --version on each with no terminal at all (stdin from /dev/null, both streams redirected), which is the contract that keeps them scriptable; and the macOS smoke asserts the absence of anything named orkeon-studio*, so the day the RID filter regresses, CI fails instead of a Mac user.

Added — orkeon run <directory>: multi-file crews are a first-class target

A crew no longer has to be a single file. orkeon run (and every runner's -c/--config) now accepts a directory: config.yaml for the crew settings, one agent per file under agents/, one task per file under tasks/, each file-name stem being the entity id — the layout YamlCrewDefinitionLoader.LoadFromDirectoryAsync already understood, which until now no CLI could reach because the dispatch was by file extension only. The legacy flat triplet (crew.yaml + agents.yaml + tasks.yaml) is accepted from a directory too, and every option behaves identically on a directory and on a file (--settings, -V/--var, --initial-context, --mount, --validate, --verbose, --llm-log). A .yaml path passed directly follows exactly the path it always did.

The classification is explicit rather than convenient: a directory holding both a YAML layout and a scripting entry point — any *.ork.ts or *.ork.js sitting directly in it, whatever the file is called — is refused with both candidates named, and a directory with no recognized layout is refused with the list of what was searched — no silent precedence, and a lone script is never executed just because it was the only thing in the folder. The directory is mounted read-only in the VFS as itself, not as its parent, so a crew directory opens no wider a surface than a crew file. examples/crew-multifile/ is the runnable reference (orkeon run examples/crew-multifile --validate).

Added — macOS channel: osx CLI tarballs, Gatekeeper handling, Homebrew formula

macOS joins Windows and Debian as a first-class install target. The release now carries orkeon-cli-<version>-osx-arm64.tar.gz and -osx-x64.tar.gz — the orkeon CLI alone, self-contained and tree-sitter-pruned like every other CLI package, cross-published from the Linux runner (the apphosts ship in the SDK packs, the natives come from NuGet, and esbuild is fetched per-RID as @esbuild/darwin-{arm64,x64}). No .NET install is required on the Mac.

install.sh gained a Darwin-only block that removes the two ways an unsigned binary fails on macOS. It clears com.apple.quarantine from the installed tree — a browser download tags every extracted file with it, which is what produces "cannot be opened because the developer cannot be verified", and running the installer is the user's own act of trust. It then runs codesign -v over the bundled Mach-O files and ad-hoc re-signs only those that fail, because Apple Silicon refuses to load an unsigned Mach-O while a valid publisher signature (onnxruntime's, for instance) must never be replaced by an ad-hoc one. Both halves degrade quietly when xattr or codesign is unavailable, no individual failure aborts the install, and the block is skipped outright off Darwin — Linux behaviour is unchanged. A new blocking smoke-macos job (macos-latest, Apple silicon) installs the osx-arm64 tarball on a real Mac and walks init → doctor → run → rag → uninstall on it, which is what actually proves the signing story: a native library killed at load time fails there instead of in a user's terminal.

A Homebrew formula ships in the repository at installers/homebrew/orkeon.rb: a binary formula that fetches the tarball for the machine's architecture (on_arm / on_intel), installs the payload under the Cellar's libexec, and writes a bin/orkeon wrapper pointing ORKEON_ESBUILD_PATH at the bundled esbuild. Its test do runs orkeon doctor, not orkeon --version (which exits 1). scripts/update-homebrew-formula.sh regenerates the version and both url/sha256 pairs from a release's SHA256SUMS — idempotent, and it refuses to write when the formula's structure no longer matches what it knows how to rewrite. The Orkeon/homebrew-tap repository is not published yet, so brew install orkeon does not resolve; until it is, the two sha256 values are explicit placeholders that fail verification rather than fetch anything unverified.

Added — orkeon init and orkeon doctor

Two new verbs make the first ten minutes on a fresh machine self-service. orkeon init is a wizard over five providers — ollama, docker-model-runner, openai, custom, none — that writes an appsettings.json at the global per-user path (below), then probes the endpoint to confirm it answers. Every prompt has a flag, so it scripts end to end: --provider, --base-url, --model, --api-key-env (the recommended way to carry a key), --api-key (inline, discouraged), --path, --force, --no-probe. With a non-interactive stdin and no --provider, it refuses rather than hanging. orkeon doctor runs nine checks — dotnet-runtime, appsettings, llm-config, llm-reachability, esbuild, local-embeddings, onnx-reranker, tree-sitter, workspace-write — prints them as a ✅/⚠️/❌ table, exits 1 as soon as one fails (warnings stay green), and emits a [{check, status, detail}] array under --json for CI.

Added — global per-user configuration path in the settings resolution

Settings resolution gains a fourth step: after the local appsettings.json and the walk up the parent directories, and before the env-vars-only fallback, the CLI now reads %APPDATA%\Orkeon\appsettings.json on Windows and ~/.config/Orkeon/appsettings.json on Linux/macOS — the file orkeon init writes. An installed orkeon therefore works from any working directory, and configuration never lives in the install directory, which every (re)install deletes outright.

Changed — an unconfigured LLM warns instead of silently echoing

Building a runner host with no Llm section still falls back to the echo provider, but it now says so once on stderr — "No Llm section configured — falling back to the echo provider (<undefined-llm>). Run orkeon init to create a configuration, or set ORKEON_Llm__BaseUrl / ORKEON_Llm__Model." The fallback itself is unchanged (it is what makes the scripting demos runnable with no key and no server); what changes is that a crew replaying its own prompts can no longer be mistaken for a crew talking to a model.

Changed — every publish prunes the unused tree-sitter grammars

Behaviour change. TreeSitter.DotNet ships one native library per supported grammar (31, ~69 MB on win-x64) while Orkeon only loads the seven declared in LanguageRegistry. A PruneUnusedTreeSitterGrammars target in src/Directory.Build.targets — imported wholesale by examples/Directory.Build.targets — now drops the rest from ResolvedFileToPublish, so every dotnet publish under src/ and examples/ emits 7 grammars instead of 31, not just the release archives. dotnet build is untouched. Opt out with -p:OrkeonPruneTreeSitterGrammars=false (useful when diagnosing a grammar-loading problem). Safe by construction — LanguageRegistry.Create throws for any language outside the registry — and the whitelist ↔ registry agreement is pinned by TreeSitterGrammarPruningTests.

Added — Windows and Debian install channels; hardened install.ps1; runtime detection in install.sh

Three new release artifacts sit next to the existing multi-app archives, all self-contained: orkeon-cli-<version>-win-x64.zip (the orkeon CLI alone, with install.ps1), orkeon_<version>_amd64.deb (installable with sudo apt install ./orkeon_*.deb; depends on system libraries only, through libicu/libssl alternations covering Debian 12/13 and Ubuntu 22.04→26.04, never on dotnet-runtime-*), and orkeon-<version>-win-x64.msi (WiX, per-user, no administrator rights — one Windows channel at a time, the MSI refuses to install over a zip install). release.yml is restructured into installers → {smoke-windows, smoke-deb, msi} → release, so nothing reaches the Release until it has been installed and exercised on a real Windows runner and a stock Ubuntu image — the msi job carries its own msiexec /i /qn → orkeon doctor --json → msiexec /x /qn smoke — and it now also runs on workflow_dispatch (everything except the publication).

install.ps1 gained an "Apps & features" entry (with a working UninstallString), rescues an appsettings.json left in a previous install directory into %APPDATA%\Orkeon before the delete-and-replace, preserves the RegistryValueKind of the user PATH instead of flattening REG_EXPAND_SZ to REG_SZ, and only checks for a .NET runtime when the payload actually needs one (keyed on hostfxr.dll). install.sh gained the POSIX mirror of that check: it looks for a framework-dependent app under libexec/ (no libhostfxr.so/.dylib), then for a Microsoft.NETCore.App 10.x runtime on the PATH or under DOTNET_ROOT, and when it finds none prints the exact commands per distribution — sudo apt install dotnet-runtime-10.0 on Ubuntu 25.10+, the packages.microsoft.com repository registration on Debian and Ubuntu LTS, dotnet-install.sh --runtime dotnet --channel 10.0 under $HOME without sudo — and repeats the reminder at the end. It never installs a runtime, adds a repository or calls sudo on the user's behalf, and the warning never blocks the install.

Fixed — package-installers.sh aborted at the checksum step with a single --rids

The final ls *.tar.gz *.zip *.deb | xargs sha256sum left one glob unmatched whenever the run targeted a single RID; under set -o pipefail the failing ls took the whole pipeline down and set -e aborted the script — after every archive had already been built. The ls is now wrapped in { …; || true; }, and *.deb is part of the glob so SHA256SUMS stays complete when package-deb.sh has dropped its package in the same output directory.

Added — shell_command: bidirectional VFS path rewriting

shell_command now speaks virtual paths in both directions, so a coding agent can run dotnet build /workspace/App.sln instead of failing on a path that only exists in the VFS. Inbound, every argument that names a mount-prefixed virtual path — including the embedded --out=/workspace/dist form (split at the first =) — is resolved virtual→physical through IFileSystemService.ResolveAndValidate before the process starts, with a path-boundary check (/workspaces never matches mount /workspace); a denied path fails the call with the redacted denial reason instead of reaching the process verbatim. Outbound, stdout/stderr are rewritten physical→virtual before truncation (success and timeout paths alike) using a per-call table built by resolving each mount root — longest physical base first, backslashes normalized to / inside the rewritten path token — so the model only ever sees virtual paths and stops leaking physical host paths into its own follow-up file_read calls. Scope: AgentFacing mounts, ordinal matching (re-cased Windows output is a documented limitation); with no mounts configured both passes are exact no-ops.

Added — shell_command: configurable allowlist

Two new config keys shape the executable allowlist without code changes: Orkeon:Tools:Shell:ExtraAllowedCommands (string array) is ADDITIVE on top of the default allowlist — the recommended way to allow make/cargo/etc. for a trusted coding-agent host; it composes with AllowInterpreters (new extraAllowedCommands ctor parameter, unioned after the base list is built). Orkeon:Tools:Shell:AllowedCommands (string array) is a full verbatim REPLACEMENT mapping to the existing allowedCommands ctor parameter — per that contract it cancels AllowInterpreters and re-enables the git read-only subcommand restriction. An absent or empty section binds to null, never to an empty array (which would block every command), so defaults are unreachable by accident.

Added — configurable LLM retry budget (default 10) + visible reconnection feedback

Llm:MaxRetries (the dormant LlmConfig.MaxRetries, never consumed until now) drives BOTH HTTP paths: the buffered Polly policy (GetLlmApiPolicy, previously hardcoded at 5) and the streaming connect-phase loop (previously hardcoded at 3 attempts). Default raised from 3/5 to 10 (LlmDefaults.DefaultMaxRetries) with every wait capped at 30 s (ResiliencePolicies.LlmRetryDelay — linear ×1/×2, then ×3 exponential, capped), so the ladder degrades to a bounded cadence instead of 3⁸ seconds. Both config-binding hosts read the key (ConfiguredLlmProviderBootstrapper for the ConsoleApp REPL, RunnerHost for runner hosts), clamped at 0; the cap is applied before the TimeSpan conversion (an arbitrarily large configured budget never overflows mid-retry) and a server Retry-After is now capped at the same 30 s on the buffered path, matching the streaming path.

What makes a 10-retry budget acceptable on an interactive turn is that it is now VISIBLE: a new ILlmRetryObserver port (Application) receives every scheduled retry wait and the final settle; HttpLlmProviderBase.RetryObserver fires it from both paths (never on mid-stream failures, which are still not retried). The CLI implements it with LlmRetryProgressObserver: the status line shows ✳ Reconnecting to api.moonshot.ai… retry 4/10 in 8s — <reason> through the existing ProgressBroker, and the ambient CommandInstance gets the same line for ps/inspect/the agents pane. Settling clears only the banner the observer raised (label-guarded) — never a crew's own progress. No observer registered = behaviour unchanged (retries only logged).

Fixed — transcript errors: one actionable line, never a stringified stack

A crew failure travels as PromiseRejectedException(ObjectWrapper(AggregateException(HttpRequestException(SocketException)))) and its Message embeds the full stringified stack — which the REPL used to dump verbatim into the transcript (the live /analyze incident: ~40 lines of .NET frames for one DNS hiccup). New ConciseErrors helper (Orkeon.Cli.Commands.Scripting) unwraps the wrapper layers (JS rejection → carried CLR exception, AggregateException flatten, TargetInvocationException) and keeps the first line of the root cause — ✗ analyze failed: Resource temporarily unavailable (api.moonshot.ai:443). Applied at every transcript-facing site (ScriptHostFacade crew failures, ScriptCommand dispatch/completed rejections, CommandDispatchService instance failures); the full exception still goes to the logs at each site.

Added — LLM streaming: connect-phase retry for transient failures

The buffered HTTP path runs under the Polly GetLlmApiPolicy, but SendStreamingRequestAsync was a single bare SendAsync — one transient socket failure killed the whole turn. It now retries the CONNECT/headers phase itself (3 attempts, 0.5 s/1 s backoff, Retry-After honoured capped at 30 s) on transport errors, client-side connect timeouts, and retriable statuses (408/429/5xx). Once headers are handed to the caller, a mid-stream failure is never retried — replaying a partially-consumed stream is the caller's decision. Non-transient statuses (401…) return immediately, unretried.

Fixed — TUI: a line typed before the runner's first read was silently dropped

The split-pane input field is live from the first frame, but the scripted-commands runner only starts reading after its startup script load (57 commands ≈ 30–60 s of discovery → esbuild → evaluate). A line submitted in that window was echoed to the transcript and then discarded — the live "que fait-on ?" incident: the free-text request looked accepted and nothing ever happened. ReplPaneView now buffers type-ahead submissions in a FIFO queue and delivers them to subsequent ReadLineAsync calls — the same type-ahead semantics a plain terminal gives for free. Pinned by three ReplPaneViewTests (buffered delivery, FIFO order, live read still wins).

Fixed — scripted commands: async dispatch / async completed now awaited deterministically

ScriptCommand unwrapped an async dispatch's promise with the synchronous UnwrapIfPromise (blocking the engine-lock thread until settlement) and the completed drain did the same. Both now await UnwrapIfPromiseAsync — same pattern as the sync-handler path — and surface a rejected dispatch/completed promise as the same Error: … console line as a thrown one, instead of relying on Jint's blocking unwrap semantics. Pinned by a dispatch-with-pending-promise integration test (the /assistant shape since B-5: await session state, then post).

Added — end-to-end progress channel for long CLI operations

A ProgressBroker singleton (Orkeon.Cli.Commands.Scripting.Progress, registered by AddScriptCommands) now carries a live {label, step/total | percent, message} snapshot from whoever is doing long work to whoever renders it. Three publishers: ctx.progress(...) handles from command scripts (which also stamp the ambient CommandInstance.ReportProgress — the field ps/inspect exposed since design §6 but nothing ever wrote); a new host tool progress_report so CREW scripts — which have no ctx.progress — can report through the tools global (Tools.progressReport); and an optional IProgress<IndexBuildProgress> hook on RaggableEnrichmentServices notified by RaggableTreeBuilder per phase and per parsed file (null by default — zero cost when unwired; the ConsoleApp routes it to the broker as "Indexing codebase"). The TUI status line renders the snapshot as ✳ Compacting conversation… ▰▰▰▱▱▱▱▱▱▱ 34% (12s) (indeterminate operations show elapsed + message instead of a bar), including for background crews that run detached from the REPL's own turn; the agents pane swaps a running row's intent for its live progress. ProgressAmbient (AsyncLocal) links detached post/postWork flows to their instance; completion clears the broker slot by ticket so one instance can never erase a newer operation's bar.

Added — spinnerVerbs: configurable status-line verbs + spinner animation

The status line's verb rotation ("thinking verbs" in the tweakcc vocabulary) is now configurable: TerminalGuiOptions.SpinnerVerbs seeds a boot-time list (bound from Orkeon:Cli:Tui:SpinnerVerbs in the ConsoleApp), and the live TuiIntegration.SpinnerVerbs delegate — wired by the ConsoleApp to the scripted /config layers (config_map session state over /workspace/.orkeon/config.json) — wins over it without a restart. The verb re-draws every fifteen seconds on long turns (StatusLineFormatter.VerbFor), the leading glyph animates through spinner frames (✢ ✳ ✶ ✻, ASCII | / - \) at four steps per second (SpinnerFrame), and the status-line timer tightened from 1 s to 250 ms accordingly. Defaults unchanged: the six Orkeon gerunds.

Fixed — agents pane: live work only, finished agents leave immediately

TuiFidelityWiring.BuildAgentRows collapsed every non-running instance to idle, so a finished crew was indistinguishable from a stuck one (the exact confusion of the 2026-08-06 captures). Per the user ruling that followed — idle means waiting, not finished — the pane now shows LIVE work only: a finished agent's row disappears at once (no retention window, no terminal badges; ps/inspect stay the audit trail), and idle never renders at all. ● main (filled bullet, no metrics) appears only while at least one delegated agent runs — with nothing delegated the pane collapses, matching the reference. Delegated rows render hollow (○) with the live elapsed · ↓ tokens pair.

Added — ILlmUsageSink: per-call LLM usage events, per-agent token attribution

New Application port ILlmUsageSink (mirror of ILlmDeltaSink, same plumbing chain JsEngineFactory → crewBuilder → JsCrew → JsLlmFacade): every ctx.llm.* path — complete, chat, extract, decide, stream (both variants), and each act iteration (buffered or streamed, counted exactly once) — reports a CostUsageEvent carrying crew/agent/provider/model and the token split (a total-only response lands on CompletionTokens so Prompt + Completion == TokensUsed — the pricing registry then prices that total at the output rate, a deliberate upper bound: conservative for budgets, an overestimate for cost reporting on split-less providers; a response with no usage at all reports nothing — "no usage" ≠ "zero tokens"). extract reports before its JSON parse, so a prose reply that throws still counts the paid tokens. Nothing fed ICostBudgetManager before this: the REPL's session token readout summed an event stream no one produced. AddScriptCommands registers InstanceAttributingUsageSink, which forwards to the cost manager (fixing that readout and /cost) AND credits the CommandInstance ambient at call time (ProgressAmbient, the progress channel's AsyncLocal) — so the agents pane's ↓ NN.Nk tokens is now that agent's real usage (— only when truly unattributable). CommandInstanceView gains tokens (visible to ps/inspect and the F4 detail; typed in orkeon-cli.d.ts). A sink that throws degrades to unobserved usage, never to a failed LLM call.

Added — agents pane: keyboard + mouse selection (F4)

The pane stays non-focusable at rest (its first live launch proved a focusable read-only pane steals the prompt focus), but F4 now enters an explicit selection mode: ↑/↓ move a chevron cursor, Enter prints the instance's detail into the transcript (state, intent, elapsed, progress, result/error — via the new TuiIntegration.DescribeAgent delegate over dispatch.get(ticket)), Esc hands focus back to the prompt. A mouse click selects a row without stealing focus; a double-click opens the same detail. The hint bar advertises f4 agents only while the pane has rows. (F4, not Ctrl+A: the focused panes' select-all already owns Ctrl+A and global bindings fire before view dispatch.)

Added — ActOptions.system: a real system prompt for scripted act() agents

ctx.llm.act(prompt, { system }) now seeds a role:"system" message as the first message of the tool-calling conversation (re-sent on every loop iteration). Until now act() always sent a single user message, so a scripted agent could not have a system prompt at all — identity and tool policy travelled inside the user turn with user-level authority (the same authority as tool results, which also come back as user turns), and the providers' native system handling (Anthropic top-level system, cache_control; PrependConfiguredSystemMessage on the OpenAI-compatible providers) never fired. The conversation-level message wins over LlmConfig.SystemMessage on every provider; the option omitted keeps the historical single-user-message shape byte for byte. (JsLlmFacade.ResolveSystem, Typings/context.d.ts.)

Added — hybrid code search + edit↔search freshness in the RaggableTree (RAG×Tree)

codebase_search (and IRaggableStore.SemanticSearchAsync) fuses an embedding cosine ranking with a code-aware BM25 (camelCase/snake_case sub-tokens + whole identifier) via Reciprocal Rank Fusion — SemanticQuery.Mode (Hybrid default / Vector / Lexical), SearchHit.MatchOrigin. Pure vector missed getUserById when the query said "fetch user", and an exact identifier could rank below prose; each half now covers the other's blind side. With no embedder wired, Hybrid degrades to Lexical instead of the historical silent empty (explicit Vector keeps that contract). The BM25/RRF implementations are Analysis-native twins of the RAG's (Bm25CodeIndex, RankFusion) — the dependency must keep pointing Rag → Analysis, never back.

Freshness (an agent that EDITS files invalidates its own index): FileWriteTool gains an optional IIndexInvalidation hook (dirty-marking, O(1), same precedent as the citation validator); IndexFreshnessService reindexes the dirty set ∪ the git working-tree changes (shell edits) BEFORE a read tool answers — grouped, single-flight, 2 s clean-probe debounce, failure degrades to the stale index and keeps the debt. codebase_search reports refreshed_files; index_status reports dirty_count/ dirty_paths. InMemoryRaggableStore gains a ReaderWriterLockSlim: a search running DURING an incremental reindex no longer risks InvalidOperationException on the mutated dictionaries. The freshness pass is the first real producer on IRaggableTreeEventBus; IGitDiffProvider (never registered before — incremental_reindex's commit-range path could not resolve it) and the bus are now registered by AddRaggableTree, and IGitDiffProvider gains GetWorkingTreeChangesAsync.

Orkeon.ConsoleApp wires AddOrkeonRag + AddOrkeonRagTools: rag_search/rag_ingest/ rag_eval are available to the scripted REPL, and rag_search's raggable-tree collection inherits the hybrid + freshness path. Live-validated end to end (an internal probe crew, 8/8): exact identifier ranks hybrid, write→search round-trip reports refreshed_files: 1, RAG routing serves the code index.

Changed — ctx.llm.stream now asks for usage and carries the reasoning channel (SCR-24)

stream went through GenerateStreamingAsync; it now goes through ChatStreamingAsync. Both read the same SSE stream, and the difference is what they ask for: the chat path sends stream_options: { include_usage: true }, without which most providers emit no usage chunk at all — so a streamed call had no token accounting. Measured on a live run whose two streamed requests were {"model":…,"stream":true} with no stream_options; they carried usage only because Moonshot volunteers it, and the same round on OpenAI would have reported nothing. The calls that stream are the long, expensive ones.

The plain path also dropped delta.reasoning_content, so a thinking model's stream is silent for as long as it thinks — round-41's deliverable 13 spent 22 673 of its 32 627 completion tokens reasoning, most of a nine-minute call in which "no chunk yet" and "the stream died" were the same observation.

  • stream(prompt) keeps yielding strings — no contract change. What the chunks cannot carry is exposed on the returned object: usage ({ promptTokens, completionTokens, tokensUsed, cacheHitTokens, model }, null while the stream runs and null for good when the provider reported nothing) and reasoningChunks. Read them after the loop.
  • Deliberately NOT callbacks. A callback has to be invoked from the stream's own thread, and Jint's Engine is single-threaded: the first cut of this did exactly that, and a measured run — seven area writers streaming concurrently — died of a NullReferenceException inside ScriptFunction.Call, with all seven writers falling back to a placeholder and the script stopping silently after assembling its document. CLR state read through interop runs on the engine's own thread.
  • Reasoning progress is logged by the facade through the host logger every 200 deltas: a script cannot log it for itself, because while the model reasons its loop body never runs.
  • usage is populated on the non-streaming fallback too, so "this provider does not stream" and "this provider reported no usage" stay distinguishable.

Added — rag.retrieve / IRagRetrievalCapable: retrieval without the generation nobody asked for (SCR-24)

A caller that wants the retrieved passages rather than prose was still charged for a full grounded generation, because IRagPipeline exposed only QueryAsync. Measured on the 2026-08-04 gap round: seven rag.query calls whose generated answers were discarded by design cost 14 748 completion tokens — 68 % of them reasoning tokens — and 394 s of wall time, on top of retrieval that had already produced every citation the caller used. The generation stage is the expensive half of a RAG call and it is optional far more often than the API shape suggested.

  • IRagRetrievalCapable (Orkeon.Rag.Abstractions) — opt-in capability, same shape as IHybridSearchCapable: RetrieveAsync runs transform → retrieve → fuse → rerank → assemble and stops. Declared as a separate interface rather than added to IRagPipeline because not every executor can honour it — the corrective graph interleaves evaluation with generation, so "retrieval only" is not a prefix of its run — and a caller must be able to ask instead of discovering the answer through an exception.
  • StagedRagPipeline implements it; QueryAsync and RetrieveAsync now share one RetrieveCoreAsync, so the two cannot drift. The returned RagAnswer keeps the same shape (empty Text, populated Citations) and the trace carries a generate step saying the stage was skipped on purpose — an absent step would read as a trace from an older pipeline.
  • rag.retrieve(question, options) in the scripting DSL, same signature as rag.query. On a pipeline that is not retrieval-capable it throws rather than falling back to QueryAsync: a silent fallback would charge exactly what the caller asked to avoid, with no way to tell.

Fixed — the system role was flattened into the user message on every OpenAI-compatible provider (SCR-24)

HttpLlmProviderBase.ChatAsync flattens messages into one prompt shaped "{role}: {content}" per line, and OpenAICompatibleProviderBase took the structured chat path only when tools, tool-call metadata or a vision payload were present. A plain system + user conversation — the shape of the entire RAG generation stage, and of every LLM judge, retrieval evaluator and groundedness checker in this repository, none of which declares a tool — therefore reached the provider as a single user message whose text began with system: . A multi-turn history was concatenated the same way, so an assistant turn arrived as something the user claimed the assistant had said. Evidence: the run's exchange log, all seven RAG generations sent as messages: [{ role: "user", content: "system: You are a retrieval-augmented assistant…" }].

  • Every ChatAsync call with at least one message now takes the structured path. A lone user message was affected too (it went out as "user: Hello."), so no case is left on the flattening path; an empty or null array still delegates to the base, which turns it into an empty single prompt.
  • grammar (GBNF) was emitted only by the single-prompt builder and is now written by both, so an option cannot appear or vanish with the number of messages sent.
  • Around 400 mocked provider tests missed this: they assert on the response, and a mocked handler answers whatever it is sent. The new OpenAICompatibleProviderBaseRoleFidelityTests read the outgoing payload on the cases with no tool and no image, which was the remaining blind spot.

Added — Declared provider capabilities, structured outputs and thinking on all 12 providers (LLM-02, LLM-03, LLM-04)

The audit's central finding was not that the wiring was missing but that its absence was invisible: LlmResponseFormat and LlmThinkingConfig cascaded correctly from crew → agent → task → script → call-site, yet only DeepSeek wrote response_format and only DeepSeek and Z.AI wrote thinking. On the ten other providers a YAML declaration was silently dropped. Closes G-15, G-16 and G-19.

  • LlmProviderCapabilities (Domain) — each provider declares what its API really supports: ResponseFormat (None | JsonObject | JsonSchema), Thinking (None | EffortOnly | Toggle | Budget), Vision, ExplicitPromptCaching, RequiresJsonKeywordInPrompt, ReplaysReasoningContent. Exposed on ILlmProvider as a default-implemented member (like BaseConfig), so third-party providers and test doubles keep compiling, and a provider that declares nothing gets nothing written on its behalf.
  • The end of silent drops — an option the caller declared that the provider cannot honour now produces an actionable warning naming the option, the provider and the remedy. This is the actual fix for G-15/G-16; the wiring below is the easy half.
  • The OpenAI dialect is written once. OpenAICompatibleProviderBase.ApplyProviderSpecificOptions went from a no-op hook to a capability-driven implementation. DeepSeek and Z.AI held two near-identical copies of the thinking translation and two of the reasoning_content extraction; both were refactored onto the base and shrank to what is genuinely theirs (DeepSeek's cache counters, Z.AI's reasoning_tokens). Their 33 + 15 existing tests pass unmodified.
  • Structured outputs on all 12 providers (G-15) — LlmResponseFormat gains an optional Schema (LlmJsonSchema { Name, Schema, Strict }) and a JsonSchema(...) factory; Type is untouched, so existing configurations behave identically. Dialects: response_format (OpenAI-compatible family, with json_schema where the vendor validates it), output_config.format (Anthropic), format (Ollama, which also accepts a full schema). A schema handed to a provider that only guarantees well-formed JSON is downgraded to json_object with a warning, never in silence.
  • ⚠️ Anthropic has no schema-less JSON mode. output_config.format takes exactly type (always json_schema) and schema — there is no equivalent of json_object, and name/strict do not belong there (strict exists, but on individual tools). A json_object request on Anthropic is therefore reported, not sent in a shape the API would reject. Supply a schema, or state the shape in the prompt.
  • ⚠️ The YAML allow-list is lifted. YamlCrewMapper accepted only text and json_object and downgraded everything else to null — which would have discarded json_schema before it reached any provider. Unknown values now travel to the provider with a warning: a new vendor value works without a framework release, and a typo surfaces as a provider error rather than as nothing at all. Declare a schema with a response_schema: block (name, schema, strict) next to response_format: json_schema; a response_schema: on its own implies json_schema. The scripting DSL gains withResponseSchema(name, schema, strict?) on both the agent and task builders.
  • Thinking on all 12 providers (G-16, G-19) — four dialects: reasoning_effort (+ the thinking block where the API has an explicit toggle) on the OpenAI-compatible family, thinking: {type: "adaptive"} + output_config.effort on Anthropic, think (boolean or effort level) on Ollama, enable_thinking + thinking_budget on Qwen's DashScope dialect. LlmThinkingConfig gains BudgetTokens, mapped only to Qwen — the budget_tokens shape found in many older sources is rejected with an HTTP 400 by the current Claude generation, so it is reported rather than sent.
  • reasoning_content extraction is generic; its replay stays DeepSeek-only, driven by ReplaysReasoningContent — it is an API constraint of theirs (HTTP 400 without it), not a property of reasoning models, and Z.AI documents the opposite.
  • Ollama's format and think are wired on the current /api/generate path: contrary to what the audit reported, both are accepted there, and only native tool calling actually requires the /api/chat migration.

Added — orkeon llm probe, the provider campaign harness (LLM-08/C1)

Roughly 400 unit tests cover the LLM providers and every one of them speaks to a mocked HTTP handler. A mock proves the framework sends what we believe it sends; it cannot prove the vendor accepts it. Before this, only DeepSeek had archived real-execution traces.

  • orkeon llm probe --provider <name> [--model …] [--base-url …] [--modes M1,M8] [--archive <dir>] runs the matrix's protocol modes against a live provider and prints a report ready to paste into the matrix journal, evidence level included. Currently exercises M1 (single prompt), M2 (multi-turn + system), M3 (text streaming), M4 (chat streaming), M7 (thinking), M8 (response format), M12 (typed error on an invalid model) and M13 (cancellation). M5/M6 (tool calling), M9 (vision), M10 (cache) and M11 (long context) need per-provider assets or a deliberately expensive call and are not covered yet — the harness names what it does not run rather than implying full coverage.
  • The API key is never a command-line argument: it is read from an environment variable (--api-key-env, default ORKEON_LLM_API_KEY) and never appears in the report or the archive.
  • A mode that a provider's declared capabilities make inapplicable is reported as such, not as a failure; a mode that throws is recorded as a finding rather than aborting the campaign, since the framework's contract is a typed error response, never a throw. A campaign with any failed mode exits non-zero.
  • The campaigns themselves are not run here. They consume real credits on real accounts, so the decision to spend belongs to whoever owns them; the remaining LLM-08 work (running the campaigns, replaying experiment 08, filling the matrix) is unblocked but outstanding.

Added — Azure v1 GA API and native Ollama tool calling (LLM-07)

The two gaps that needed a pipeline migration rather than a payload field. Closes G-06, G-10 and G-25.

  • Azure v1 GA API (G-06, G-25) — BuildEndpoint was hardcoded to the dated, deployment-based shape (/openai/deployments/{deployment}/chat/completions?api-version=2024-02-01). Azure has served a v1 GA surface since August 2025 — {endpoint}/openai/v1/chat/completions, no api-version — which is the only path to the Responses API and to the non-OpenAI models Azure resells (DeepSeek, Grok); all of it was unreachable. Select it with api_version: v1 (typed property or custom parameter). The dated shape stays the default on purpose: switching it would silently change the URL of every existing deployment-based configuration.
  • ⚠️ Ollama tool calling is now native (G-10) — the provider targeted /api/generate, which has no tool support, so tool calling went through the text-fallback protocol. It now reaches /api/chat whenever the conversation declares tools, replays tool calls, or carries an image, and LlmProviderFactory wires it with the native OpenAI strategy. The response is reshaped once — Ollama returns message.tool_calls with arguments as a JSON object and no choices array, which is precisely why the framework's single parser could not read it — into the OpenAI body (arguments as a JSON string, positional call ids since Ollama issues none). Everything else keeps /api/generate, so NDJSON streaming and GBNF grammar are untouched and the text fallback remains in charge for models without tool support.
  • Ollama vision — images travel in a bare base64 images array rather than as OpenAI content parts. Remote image URLs cannot be forwarded (the server never fetches them), so an image referenced only by URL is skipped rather than silently dropped.
  • docs/reference/limitations.md no longer describes a limit that has been lifted; its Ollama entry now states what actually remains (no /api/chat streaming, bytes-only images, text fallback for tool-less models).

Added — Anthropic parity, vision exposure and HuggingFace routing (LLM-05, LLM-06)

  • Native SSE chat streaming on Anthropic (G-20) — ChatStreamingAsync used to fall back to the base class's buffered emulation, which waits for the whole answer before emitting anything: no token ever arrived early on Claude. It now parses the Messages API event stream directly, emitting ContentDelta, ReasoningDelta (extended thinking) and a terminal Completed whose response is indistinguishable from the buffered one.
  • Anthropic cache metrics (G-21) — cache_creation_input_tokens and cache_read_input_tokens feed the typed CacheHitTokens / CacheMissTokens, so CacheHitRatio is finally computable on Claude. The three input counters do not overlap, so PromptTokens is their sum; absent counters stay null (unmeasured, not zero).
  • Explicit prompt caching (G-17) — new LlmCacheConfig value object, cascaded like LlmThinkingConfig (crew → agent → task → call-site, cache: block in YAML). Anthropic's cache is explicit: without a cache_control breakpoint nothing is cached, so a long system prompt is re-billed in full on every turn — Orkeon read the metrics but never placed a breakpoint. Off by default, since a breakpoint changes what the vendor stores and how the call is billed. Marking the system prompt promotes it to the content-block form the API requires; the tools breakpoint lands on the last tool, which covers the whole catalogue.
  • Vision exposed on the 8 remaining capable providers (G-18) — Azure, Groq, Together, Mistral, Qwen, Kimi, Z.AI and HuggingFace declare the capability and inherit the image_url composition from the base; no per-provider override. Text-only calls emit exactly the payload they did before (asserted). Ollama stays out on purpose — it takes a base64 images array rather than OpenAI content parts, which belongs with the rest of its request-shape work. DeepSeek has no vision model and degrades an image message to its text fallback.
  • HuggingFace provider-selection suffixes (G-23) — :fastest / :cheapest / :preferred and partner pinning (:groq) are the only cost and latency lever on Inference Providers. The suffix already travelled to the wire; what was missing was any way to know it was wrong. Added WithRoutingPolicy / WithPartner helpers and validation that reports an unrecognised suffix while still forwarding it — the partner list moves faster than this framework releases.
  • Guard on DeepSeek's Anthropic-dialect endpoint (G-22) — api.deepseek.com/anthropic speaks the Messages API, but host inference matched deepseek.com and routed it to the OpenAI-compatible provider, producing malformed requests whose error surfaced far from its cause. It now fails immediately with a message naming the cause and the fix.
  • G-24 (Groq server-side tools) is ruled out with a motive, not left pending. browser_search and code_interpreter execute on Groq's side, so they pass through neither IBaseTool, nor the agent loop, nor the framework's validation, rate limiting and telemetry. Exposing them is a tooling-architecture decision — how they coexist with Orkeon's tool registry and what gets traced — not a provider-support gap. The same reasoning covers the other vendors' server-side tools.

Changed — LLM provider defaults, host routing and the Azure config guard (LLM-01)

First sheet of the LLM provider remediation plan, closing gaps G-01→G-05, G-07→G-09, G-11, G-12, G-14 and defect D-01 of the 2026-07-27 audit. Four providers out of twelve failed with their out-of-the-box configuration; four more targeted a superseded generation.

  • ⚠️ Default models changed — this changes the behaviour of every configuration that does not specify a model. Each identifier was confirmed on the vendor's official documentation on 2026-07-27: OpenAI gpt-4 → gpt-5.6-sol (gpt-4 reaches end of life 2026-10-23 and caps context at 8 192 tokens), Anthropic claude-3-5-sonnet-20241022 → claude-sonnet-5 (retired 2025-10-28), DeepSeek deepseek-chat → deepseek-v4-flash (retired 2026-07-24), Kimi moonshot-v1-8k → kimi-k2.6 (the moonshot-v1-* series sunsets 2026-08-31), Qwen qwen-turbo → qwen3.7-plus (absent from the catalogue), Mistral mistral-large-latest → mistral-medium-3-5-26-04. LlmDefaults.DefaultModelName — the fallback of LlmConfig.Model itself — moves with the OpenAI default. Pin a model explicitly to keep the previous behaviour.
  • ⚠️ Default endpoints changed — HuggingFace api-inference.huggingface.co → router.huggingface.co (the old host is gone, so the provider could not work at all), Kimi api.moonshot.cn → api.moonshot.ai (the mainland host was the default for every account, including international ones; set BaseUrl explicitly for a mainland account).
  • Every default now lives in ProviderDefaults — Groq and HuggingFace held theirs inline — and a pinning test asserts the model and endpoint of all twelve providers, read from live instances rather than from constants. Drift becomes a failing test, not a silent change.
  • International hosts are routed to their dedicated provider instead of falling back to the generic OpenAI one: api.moonshot.ai (G-11), dashscope-intl.aliyuncs.com and the per-workspace *.maas.aliyuncs.com hosts (G-12). router.huggingface.co was already matched by the existing huggingface.co rule — the audit's G-13 was a false positive, and is now pinned by a test.
  • Mistral routing trap fixed (G-14) — InferFromModel routed every mistral* model to Ollama, so a cloud identifier such as mistral-medium-3-5-26-04 was sent to localhost:11434. Only the bare mistral and its Ollama tags (mistral:7b) stay local; versioned identifiers, including ministral-*, now reach the Mistral cloud. Setting BaseUrl still wins over model-name inference.
  • Azure configuration guard aligned across all four entry points (D-01) — ChatStreamingAsync was not overridden, so with a missing BaseUrl it reached BuildEndpoint and threw a NullReferenceException where the other paths returned a typed error. It now emits the standard Completed event carrying that same error. GenerateStreamingAsync still ends in an empty stream — IAsyncEnumerable<string> has no error channel — but logs it instead of failing silently.
  • Cost tracking follows — gpt-5.6-sol / -terra / -luna and claude-opus-5 / claude-sonnet-5 registered in ModelPricingRegistry; gpt-4 keeps its own entry so configurations that pin it still produce a real cost.
  • LlmConfig.Gpt4() → LlmConfig.WithDefaultModel() (and Gpt4WithSecret → WithDefaultModelSecret). These factories have always returned the platform default model, not literally gpt-4; with the default moved, the old names became actively misleading. The former names remain as [Obsolete] forwarders with identical behaviour — pass "gpt-4" to LlmConfig.Create if you really want that model.

Fixed — post-RAG coherence audit (2026-07-26)

  • LlmProviderToChatClientAdapter honors the standard ChatOptions.ResponseFormat — the adapter only read the LlmChatOptionsKeys.ResponseFormat AdditionalProperties key stashed by the orchestrator, so callers built on plain Microsoft.Extensions.AI options (RAG retrieval evaluator, groundedness checker, query complexity classifier setting ChatResponseFormat.Json) never reached providers wiring response_format (e.g. DeepSeek json_object). The adapter now falls back to ChatOptions.ResponseFormat when the key is absent (the explicit key keeps priority) — the JSON constraint was already enforced by strict prompts + tolerant parsing, this makes the API-level guarantee real on the providers that support it.
  • The corrective mechanism test now locks the rank-1 claim — CorrectiveRagMechanismSlowTests asserted only that notes-power.md was cited; it now also asserts it is the first citation, matching the wording in the RAG-06 task sheet and the eval README.
  • Documentation drift cleanup: version references aligned on src/Directory.Build.props (0.9.2-beta) across README(.fr).md, CLAUDE.md, limitations.md, publication-matrix.md; publication-matrix.md workflow narrative matched to reality (all NuGet pack/push lives in publish.yml → GitHub Packages; nothing on NuGet.org); CONTRIBUTING(.fr).md no longer claims a CI parity gate that was never wired; ADR-006 amended with the RAG-06 decisions (CRAG on StateGraph, web-fallback policy/transport split, corrective preset, no separate rag-adr.md); docs/INDEX.md links rag-pipeline.md; limitations.md + opt-in-subsystems.md document the ONNX requirement (balanced/quality/adaptive) and the double-opt-in web fallback; French mirror docs/fr/architecture/rag-pipeline.md added; eval README header corrected to 9 cases / 12 documents; Orkeon.Tools.Rag NuGet description lists its three tools; stale "lands with RAG-0x" comments rewritten in delivered code.

Added — Corrective RAG & vitrine (RAG-06): CRAG graph on StateGraph, corrective profile, opt-in web fallback, examples

The showcase piece of the RAG plan (guide §8): Corrective RAG built on Orkeon's own Graph orchestration mode — the corrective engine is a Domain StateGraph, RAG demonstrates the Graph mode and vice versa — plus the vitrine layer (docs, three runnable examples, final all-profile evaluation).

  • CRAG graph pipeline (C1) — CorrectiveRagPipeline (Orkeon.Rag.Corrective), an IRagPipeline whose execution is a StateGraph<RagGraphState> (immutable record state) with conditional edges and controlled cycles: retrieve → evaluate (IRetrievalEvaluator → RetrievalVerdict Correct | Incorrect | Ambiguous) → per verdict generate / refine (decompose-then-recompose, never empties the working set) / rewrite_query (vocabulary-gap rewrite, loops back to retrieve) → generate (original question, same [n] rank-based markers, token budget and edges layout as the staged pipeline) → check_groundedness (IGroundednessChecker; ungrounded → re-loop). Every node run is traced as corrective:<node> with the iteration ordinal; verdicts, rewritten probes and loop count land in RagTrace.Verdicts / QueryVariants / Iterations. Evaluator and checker are LLM-backed when an IChatClient is registered (LlmRetrievalEvaluator / LlmGroundednessChecker, constrained via LlmResponseFormat — json_object where wired, e.g. DeepSeek — tolerant JSON parsing elsewhere), deterministic heuristics with a warning otherwise. AddOrkeonCorrectiveRag(configuration) (idempotent TryAdd, called by AddOrkeonRag).
  • Double loop bound (C1) — Orkeon:Rag:Corrective:MaxIterations (default 3) bounds both the rewrite cycle and the groundedness re-loop, and the graph engine's own CircuitBreakerPolicy is explicitly derived from that budget as a second, independent layer. Exhaustion → best-effort generation with the best available chunks, traced; a tripped breaker is caught, traced (corrective:circuit_breaker) and degraded — the pipeline never throws for a loop condition and can never loop forever (circuit-breaker test included).
  • Opt-in web fallback + anti-injection (C1 security, 6C) — after rewriting is exhausted the graph may fire web_fallback, gated by two separate off-by-default switches: Orkeon:Rag:Corrective:WebFallback (pipeline policy, Abstractions) and Orkeon:Rag:WebFallback (transport — WebSearchDocumentRetriever, SearxNG-compatible JSON search, ApiKeyEnvVar only, AddOrkeonRagWebFallback). Every downloaded page passes PromptInjectionDocumentValidator (deterministic heuristics — model-addressed directives EN+FR, chat-template control tokens, hidden HTML, exfiltration vectors; verdict Clean | Suspicious | Rejected): Rejected never leaves the retriever, Suspicious is flagged or discarded per SuspiciousAction, content is never rewritten. Threat model + honest limits (pattern-based, evadable) in docs/architecture/security.md. Web chunks carry ScoreOrigin = "web".
  • corrective profile + Adaptive lift (C2, 6D) — RagProfile.Corrective / corrective in RagProfilePresets and the resolver (same IRagPipeline façade; the profile selects the executor). Preset: hybrid BM25 + RRF (rewritten probes need the lexical leg), no linear rerank stage (the graph corrects by looping — no ONNX package needed), Groundedness.Enabled = false on purpose (the graph runs its native check_groundedness node whenever a checker is registered). The adaptive profile's Iterative route now delegates to the memoized corrective pipeline — the RAG-05 documented fallback to quality is lifted (route step traces delegate=corrective).
  • Vitrine (C3, 6B) — docs/architecture/rag-pipeline.md completed (CRAG topology, verdicts, double bound, web fallback, ADR pointers); three new runnable offline examples examples/rag/hybrid-retrieval (BM25+RRF vs vector-only), examples/rag/custom-reranker (host IReranker via IRerankerRegistrar), examples/rag/crew-yaml (crew rag:/knowledge: blocks) + scripting variant examples/scripting/08-rag.ork.ts; all four examples/rag/* projects in Orkeon.Examples.sln; examples/INDEX.md regenerated.
  • Final evaluation, published honestly (C3) — orkeon rag eval --compare fast,balanced,quality,corrective,adaptive (2026-07-26, offline): fast/balanced/quality/adaptive at 0.89 recall@5 / 0.89 MRR; corrective at 0.78 / 0.64 — worse than quality offline, and documented as such: the extractive stub degrades the graph's LLM nodes (pseudo-random verdicts from the tolerant parser, degenerate rewrite probe shared by all cases), so the offline row measures the loop's guard rails, not rewrite quality — full per-case analysis in examples/rag/eval/README.md. The causal end-to-end proof of the mechanism (verdict Incorrect → rewrite → notes-power.md cited on the seeded q-007 case that quality misses, same store and embeddings) is CorrectiveRagMechanismSlowTests (scripted LLM for the two roles CI cannot provide, labelled). CI gate unchanged (balanced, correctif cases excluded, gated aggregates 1.00/1.00).

Added — RAG query translation & adaptive routing (RAG-05): transformers, MMR, classifier, Adaptive profile

Stage 1 of the pipeline (query transformation, guide §6) plus Adaptive-RAG routing (guide §8.4), measured with the RAG-04 harness.

  • Query transformers (C1) — IQueryTransformer { Name, Kind, TransformAsync } with retrieval semantics per QueryTransformKind: MultiQueryTransformer (multi-query, Union — one LLM call produces N phrasings, retrieval runs per query, rankings merged by chunk-id union keeping the original store scores, max on duplicates), RagFusionTransformer (rag-fusion, Fusion — same variants, per-query rankings fused by Reciprocal Rank Fusion, same k as the hybrid stage), HydeTransformer (hyde, Replacement — a hypothetical document is embedded as the retrieval probe INSTEAD of the question; generation and citations always use the ORIGINAL user question), IdentityQueryTransformer (none). Factory pre-populated via AddOrkeonQueryTransforms() (chat client resolved lazily; unknown names fail loudly); options Orkeon:Rag:QueryTransform (Mode default none, VariantCount default 3). Unusable/failing LLM responses degrade to [original] with a warning — never an exception.
  • Pipeline integration (5D) — the StagedRagPipeline transform stage resolves the configured transformer and wires retrieve/fuse per Kind (union / rrf / replacement probe). The transform step traces transformer, kind, variants (count) and the truncated variant_n texts; RagTrace.QueryVariants carries the full produced texts (original excluded); the fuse step traces its method (union / rrf / dedup).
  • MMR diversification (C2, opt-in) — MaximalMarginalRelevance.Select applied after fusion/dedup and before rerank when Orkeon:Rag:Retrieval:Mmr:Enabled is set (Lambda default 0.7): re-orders the fused candidates by λ·relevance − (1−λ)·redundancy. Candidate embeddings are not recomputed — the documented lexical (Jaccard) fallback with min-max-normalised scores is the pipeline path; the embedding overload exists for callers that already hold them. Traced on the fuse step (mmr, mmr_lambda, mmr_in/mmr_out).
  • Query-complexity classifier (C3) — IQueryComplexityClassifier.ClassifyAsync(query) → QueryRoute { NoRetrieval, SingleShot, Iterative }: HeuristicQueryComplexityClassifier (default — deterministic rules, zero LLM) and LlmQueryComplexityClassifier (constrained JSON, tolerant parsing, SingleShot fallback with warning). AddOrkeonQueryRouting(configuration), options Orkeon:Rag:QueryRouting:Classifier (heuristic | llm; llm without a chat client falls back to heuristic with a warning).
  • Adaptive profile (C3/5D) — RagProfile.Adaptive / adaptive in RagProfilePresets and the resolver: the AdaptiveRagPipeline classifies first, then NoRetrieval → direct LLM answer (no retrieval, empty citations), SingleShot → delegates to the memoized balanced pipeline, Iterative → documented fallback to quality until the corrective/iterative engine ships with RAG-06. The decision is always traced: RagTrace.Route + a first route step (route, classifier, delegate, fallback detail). Orkeon:Rag:Profile=adaptive routes the default pipeline through the resolver.
  • Measured comparison (golden dataset, offline, heuristic judge, 2026-07-26): fast / balanced / quality / adaptive all at 0.89 recall@5 / 0.89 MRR (4 / 217 / 166 / 141 ms/case). Adaptive equals balanced on this dataset by construction: the heuristic classifier routes all 9 golden questions to SingleShot → balanced (each has exactly one interrogative word, a single ?, and fewer than 25 words); the ms/case delta is a warm-ONNX-session artifact of run order, not a quality gain. Offline honesty: --offline swaps in a deterministic extractive chat client, so the LLM-backed transformers (multi-query / rag-fusion / hyde) and the llm classifier have no real LLM to call — the measured path is Mode=none + heuristic routing; the transformer/MMR levers are wired and unit-tested, their quality delta will be measured with a real IChatClient and/or the RAG-06 corpus growth.

Added — RAG quality phase (RAG-04): evaluation harness, hybrid retrieval, reranking, profiles

Measured before proclaimed — the whole phase is driven by an offline CI-runnable evaluation harness (local BGE embeddings, embedded ONNX cross-encoder, deterministic extractive generation, labelled judge — zero network, zero API key).

  • Evaluation harness (C1, plan §9) — versioned golden dataset examples/rag/eval/golden.yaml (7 cases over a 10-document corpus, incl. the seeded hard-retrieval case q-007 tagged correctif), deterministic retrieval metrics (recall@k, precision@k, MRR), generation metrics via LLM-judge with deterministic heuristic fallback (the mode used is always labelled), IRagEvaluator/IRagEvalHarness, agent tool rag_eval, CLI orkeon rag eval --dataset … [--profile|--compare] [--offline] [--min-recall --min-mrr], dedicated workflow .github/workflows/rag-eval.yml.
  • Hybrid retrieval (C2, plan §5) — in-process Bm25Index + ReciprocalRankFusion (RRF k=60) behind the HybridSearchDocumentStore decorator (works over all 6 memory providers; in-process index memory documented), native provider hybrid preferred via the new IHybridSearchCapable Domain capability (LanceDB), native scores via IScoredVectorSearch (ChromaDB/Pinecone/LanceDB).
  • Reranking (C3, plan §7) — opt-in packages Orkeon.Rag.Onnx (cross-encoder runtime, ms-marco-MiniLM-L-6-v2, Apache-2.0) + Orkeon.Rag.Onnx.Model (int8 weights embedded — guaranteed offline, no download ever) registered with AddOrkeonOnnxReranker(); LlmListwiseReranker (universal fallback over the 12 providers) and NoopReranker; default cascade CandidateK 50 → TopN 5.
  • Staged pipeline + profiles (C4, plan §5.1–5.2) — StagedRagPipeline replaces LinearRagPipeline (breaking rename, beta window): transform (hook none, RAG-05) → retrieve (CandidateK, per-query hybrid) → fuse (RRF/dedup) → rerank (named, RerankerFactory) → assemble (token budget + anti-Lost-in-the-Middle edges ordering: ranks 1, 3, 5… open the context, …6, 4, 2 close it — best two chunks at the extremities, rank-stable [n] markers) → cited generation → optional groundedness hook (checker ships with RAG-06); every stage traced in RagAnswer.Trace. RagProfile { Fast, Balanced, Quality } + RagProfilePresets → RagOptions v2 bound on Orkeon:Rag (profile = preset, configuration = per-key override; defaults in Orkeon.Domain.Constants.Rag.RagDefaults); ProfileRagPipelineResolver builds and memoizes one pipeline per profile (unknown names fail loudly listing fast, balanced, quality, default). Default profile is fast (deviation from plan §5.2's balanced: balanced requires the opt-in ONNX package; opt in with one key Orkeon:Rag:Profile=balanced). The store is now always wrapped in the hybrid decorator (ingestion feeds BM25; disabled default mode = strict passthrough); RetrievalQuery.Hybrid toggles fusion per query.
  • Measured comparison (golden dataset, offline, heuristic judge, 2026-07-26): fast 0.89 recall@5 / 0.89 MRR / 3 ms/case; balanced 0.89 / 0.89 / 139 ms/case; quality 0.89 / 0.89 / 105 ms/case (9 cases, incl. two exact-identifier lookups q-008/q-009 that vector-only also resolves at this corpus scale). The three profiles tie on this dataset by construction: the eight regular cases are saturated by plain vector retrieval (1.00/1.00 each, correctif excluded ⇒ gated aggregates 1.00/1.00 for all profiles), and the seeded q-007 defeats the cross-encoder too (measured score of the relevant notes-power.md: 0.0000, dead last; decoy faq-battery.md: 0.9997) — vocabulary bridging is exactly the RAG-05/RAG-06 lever (plan §9.1: correctif must fail until Corrective). The CI gate runs on the balanced profile and the fast/balanced/quality table is published in the workflow step summary.

Changed — BREAKING: RAG subsystem extraction (RAG-02, no shims)

The RAG feature set is promoted to a first-rank subsystem (src/rag/ — Orkeon.Rag.Abstractions contracts + Orkeon.Rag implementations, agent tools in src/tools/Orkeon.Tools.Rag; see ADR-006). The legacy namespaces Orkeon.Application.Interfaces.Rag.*, Orkeon.Application.Rag.*, Orkeon.Application.Interfaces.Knowledge.* and Orkeon.Infrastructure.Knowledge.* are removed without [Obsolete] shims (assumed break, decision 2026-07-25, 0.9.x-beta window).

Opt-in wiring: services.AddOrkeonRag(configuration) (namespace Orkeon.Rag.DependencyInjection, self-sufficient TryAdd*, default IDocumentStore = MemoryProviderDocumentStore over the ambient IMemoryProvider) + services.AddOrkeonRagTools() (Orkeon.Tools.Rag.DependencyInjection, registers rag_search). Neither is called by AddOrkeonInfrastructure().

Migration table (old type → new type):

Old (removed) New
Orkeon.Infrastructure.Knowledge.RagTool (rag_search) Orkeon.Tools.Rag.RagSearchTool (rag_search — same name, schema question/top_k/collection, and output format answer + Sources: block; collection = "raggable-tree" still routes to IRaggableStore)
AddOrkeonRag (Infrastructure RagServiceExtensions) + AddOrkeonKnowledge + AddOrkeonRagValidation AddOrkeonRag(configuration) (Orkeon.Rag.DependencyInjection.RagServiceCollectionExtensions — loaders + ingestion validation + pipelines + factories) + AddOrkeonRagTools()
Orkeon.Application.Interfaces.Rag.IRagPipeline (ExecuteAsync(question, RagOptions) → RagResult) Orkeon.Rag.Abstractions.Interfaces.IRagPipeline (QueryAsync(RagQuery) → RagAnswer with citations + trace)
Orkeon.Application.Rag.RagPipeline + ChatClientResponseGenerator Orkeon.Rag.Pipeline.StagedRagPipeline (named LinearRagPipeline until RAG-04/C4)
KnowledgeService (ingestion side) Orkeon.Rag.Pipeline.DefaultIngestionPipeline (IIngestionPipeline)
IKnowledgeService (Application port) Orkeon.Rag.Abstractions.Interfaces.IDocumentStore (storage/search) + IIngestionPipeline (ingestion) + IRagPipeline (query)
TextFileLoader / CsvDocumentLoader / HtmlDocumentLoader / PdfDocumentLoader / DocumentLoaderFactory (Infrastructure.Knowledge.Loaders) Orkeon.Rag.Loaders.* (same names, IDocumentLoader over SourceDescriptor → RagDocument)
WebPageLoader (Infrastructure.Knowledge.Loaders) Orkeon.Rag.Loaders.WebPageLoader (typed HttpClient, kinds url/web)
RecursiveTextChunker / SentenceChunker (+ tool-local chunker copies) Orkeon.Rag.Chunking.* — IChunkingStrategy implementations recursive, sentence, structural, semantic
ContentIntegrityValidator / PromptInjectionDocumentValidator / DataValidationPipeline / ProvenanceTracker / IQuarantineStore + InMemoryQuarantineStore (Infrastructure.Knowledge.Validation) Orkeon.Rag.Validation.* (same names — validation stays on the ingestion path)
AnalysisEmbeddingProviderAdapter (Infrastructure.LLMs.Embeddings) Orkeon.Rag.Embeddings.AnalysisEmbeddingProviderAdapter
SimpleEmbeddingService (hash-based, [Obsolete]) Removed without replacement. The default IEmbeddingService now adapts the IEmbeddingProvider port (EmbeddingProviderServiceAdapter): local BGE → remote Orkeon:Embeddings → fail-fast at first use. Semantic agent selection inherits the real chain.
HybridScorer (Infrastructure.Knowledge.Retrieval, dead code) Removed without replacement (hybrid search capability lives in Orkeon.Domain.Memory.IHybridSearchCapable)
FileKnowledgeSource / DirectoryKnowledgeSource / WebKnowledgeSource / DatabaseKnowledgeSource (Infrastructure.Knowledge.Sources) Removed without replacement — describe sources with SourceDescriptor and run them through IIngestionPipeline (IngestionRequest). The Domain contract Orkeon.Domain.Knowledge.IKnowledgeSource remains (no framework implementations).
RagOptions / RagPipelineOptions / RagDefaults / KnowledgeContext / KnowledgeItem / RagTypes (RagResult, RetrievalOptions…) Orkeon.Rag.Abstractions.Models.* (RagQuery, RagAnswer, Citation, ScoredChunk, RetrievalQuery…) + Orkeon.Rag.Abstractions.Options.RagOptions v2 (section Orkeon:Rag, RAG-04/C4) / RagIngestionOptions (section Orkeon:Rag:Ingestion); defaults in Orkeon.Domain.Constants.Rag.RagDefaults
ResearchFindings (was in Orkeon.Application.Rag) Kept (not RAG) — moved to Orkeon.Application.Services.Generic

0.9.2-beta - 2026-07-24

First version actually published to GitHub Packages since 0.9.1-beta (2026-07-04): the intermediate v0.9.1-beta.rc* tags re-packed the unchanged 0.9.1-beta version from Directory.Build.props, so --skip-duplicate silently skipped every push. This release bumps the props version so the feed picks up everything below.

Added

  • IFileSystemScope (Orkeon.Domain.FileSystem) — ambient per-scope mount override for the VFS.
  • ILlmDeltaSink (Orkeon.Application.Interfaces.Ports) — streaming delta sink port for LLM output.

Security

  • A2A mTLS server now authenticates the client certificate instead of merely checking its dates (SEC-012, R9.1). With RequireMutualTls = true, an incoming certificate must chain to one of A2ASecurityOptions.TrustedCertificateAuthorities (X509 CustomRootTrust chain — also covers validity dates, removing the last DateTime.Now in src/) or match the new TrustedClientCertificateThumbprints pin list; unpinned self-signed certificates are rejected (403). Starting the server with RequireMutualTls and no trust anchor now throws (fail-closed) — previously any date-valid certificate passed the guard. Revocation is not checked (private CAs without CRL/OCSP assumed).
  • A2A client-side CA pinning no longer bypasses host-name validation (SEC-011, R9.1). A2ASecurityHandlerFactory only vouches for RemoteCertificateChainErrors (private CA unknown to the OS store); RemoteCertificateNameMismatch/RemoteCertificateNotAvailable are never accepted. The explicit ValidateServerCertificate = false opt-out now logs a security warning (local development only).
  • A2A mTLS handler is built once and cached instead of per call (ANT-018, R9.2). On every A2A call (send, sendSubscribe, cancel, status) the client used to re-read the PFX through the VFS, re-import the X509Certificate2 (never disposed) and create a fresh handler+client — a full mTLS handshake per call. A2ASecurityHandlerFactory now returns a pooled SocketsHttpHandler (SslOptions.ClientCertificates, PooledConnectionLifetime 2 min) cached lazily by A2AClient; per-call clients wrap it with disposeHandler: false. A2AClient is now IDisposable and disposes the handler and the imported certificate exactly once. Certificate rotation requires a new client instance (options snapshot at construction).

Changed

  • Public API reshaped to .NET design-guideline conformance; 8 API-shape rules frozen as build errors (R11.7 / maintainer decision D1 = "fix everything", breaking, 0.9.0-beta). The API-shape analyzer family was driven to zero across all src/ with no severity = none carve-out:

    • Exposed collections are read-only (CA1002/CA2227/CA1819): List<T>/T[] properties and returns become IReadOnlyList<T>; settable collection properties become init/get-only. Deserialization-safe by construction — IConfiguration-bound options use Collection<T> get-only, YamlDotNet DTOs keep a settable Collection<T>?, System.Text.Json DTOs use IReadOnlyList<T> init; graph/builder state keeps a private mutable backing field exposed read-only.
    • URLs are System.Uri (CA1054/CA1056): string URL parameters and properties across IHttpClient, IA2AClient, LlmConfig.BaseUrl, options and tool DTOs now use System.Uri.
    • Cross-language-safe naming (CA1716): interface/virtual parameters and members renamed off reserved keywords (ISpecification<T>.And/Or/Not → AndWith/OrWith/Negate, IAgentRegistrationStore.Get → GetById), and the Orkeon.Domain.Shared namespace renamed to Orkeon.Domain.SharedKernel solution-wide (it collided with the VB Shared keyword).
    • Getters and nesting (CA1024/CA1034): getter methods (GetX()) become properties; public nested types are un-nested (with a qualifying rename where the bare name was generic, e.g. OrkeonDiagnostics.Tags → OrkeonDiagnosticTags) or made internal when they are implementation details.

    All changes are behaviour-preserving (order, JSON wire format, and config/YAML binding verified empirically per layer). dotnet build Orkeon.sln stays at 0 warning / 0 error. Note: this is a deliberate breaking change to the public surface, taken inside the 0.9.0-beta window before the first NuGet tag; some test assertions (URL equality, null-argument exception types, read-only collections) are updated accordingly and validated on the Windows test run.

  • Redundant default-value initializers removed and System.Random audited across src/; CA1805 + CA5394 frozen as build errors (R11.5, zero-warning campaign hygiene wave). The 89 src fields/auto-properties explicitly initialized to their default value (= 0/false/null/default/new()) had the redundant initializer removed (CA1805, mechanical, no behaviour change). The 3 src System.Random uses flagged by CA5394 are all provably non-security (a SHA256-seeded deterministic pseudo-embedding fallback, retry-backoff jitter, and a simulated research-confidence score) and now carry a tight justified #pragma warning disable CA5394; the rule is frozen as error so any new Random use trips the build and gets a security review. CA1822 (mark members static) was intentionally deferred — several flagged members are exposed to JS scripts via Jint instance reflection and making them static would break the scripting API. dotnet build Orkeon.sln stays at 0 warning / 0 error.

  • Logging converted to the LoggerMessage source generator across all src/; CA1848 + CA1873 frozen as build errors (R11.3, zero-warning campaign wave B3). The 113 src ILogger.Log* call sites flagged by CA1848 (use the LoggerMessage delegates) are now [LoggerMessage] source-generated partial methods (per-class EventIds, message templates and structured placeholder names preserved verbatim, exceptions passed as method arguments), and the 34 CA1873 sites (arguments evaluated even when the level is disabled) are fixed by that conversion or by hoisting the expensive expression into a local inside an IsEnabled guard. The single dynamic-level audit sink uses cached LoggerMessage.Define delegates. Both rules are locked as error for src/**. Behaviour is unchanged (same levels, templates, args, exceptions); tests and examples/ keep their occurrences and are not frozen. dotnet build Orkeon.sln stays at 0 warning / 0 error.

  • Externally-visible method parameters are null-guarded across all src/ and CA1062 frozen as a build error (R11.2, zero-warning campaign wave B2). Every externally-visible method that dereferenced a reference parameter without checking it for null now guards it — 605 unique src sites get ArgumentNullException.ThrowIfNull(param) as their first statement (the netstandard2.0 analyzer project uses the classic if (x is null) throw form), and CA1062 is locked as error for src/** so no public entry point can ship unguarded. Body-only edits, no signature/behaviour change: expression-bodied methods became block bodies, constructor-initializer dereferences use (param ?? throw …), and the contractually-nullable null-tolerant JS-facing logging shims coalesce (?? JsValue.Undefined) instead of throwing (a throw there would have regressed their documented null-tolerance). Tests and examples/ (separate solution / test doubles) keep their occurrences and are not frozen. dotnet build Orkeon.sln stays at 0 warning / 0 error.

  • Globalisation analyzer family resorbed to zero across all src/ and frozen as build errors (R11.1, zero-warning campaign wave B1). The culture-sensitive string-operation rules CA1307/CA1310 (StringComparison), CA1305/CA1304 (IFormatProvider/CultureInfo), CA1311 (culture-aware case) and CA1308 (ToLower) are fixed at 363 unique sites and locked as error for src/** in .editorconfig, so framework code can never silently reintroduce one. Arbitrage "Ordinal default + protect ToLower": comparisons → StringComparison.Ordinal (OrdinalIgnoreCase for identifier/key matching), formatting → CultureInfo.InvariantCulture, and the 91 ToLowerInvariant() sites that produce a wire/storage/switch value keep their lowercase form under a tight justified #pragma warning disable CA1308 (6 comparison-only sites rewritten to ordinal-ignore-case). The same six rules are neutralised (severity = none) in tests/.editorconfig — test assertions compare literal values where ordinal is already the default — a documented arbitrage, not a suppression. These rules are outside the default analysis set, so enabling them as errors enforces them in the normal build without AnalysisMode=All; dotnet build Orkeon.sln stays at 0 warning / 0 error.

  • Pinned Terminal.Gui to 2.0.1 (was 2.1.0). v2.1.0 shipped 2026-05-08 with a major API redesign + rendering bugs (gray-on-gray default scheme, focus on read-only widgets, missing FakeDriver for tests). 2.0.1 is the last stable release before that redesign. Same code compiles unchanged (API surface compatible). The xUnit ModuleInitializer crash (TUI-12) exists in both versions, so view-touching tests stay skipped.

Fixed

  • Null-argument contracts reconciled with the R11.2 guards across Domain/Application/Scripting tests (R11.2 follow-up, surfaced by the full Windows test run). Six tests and one value object that still encoded pre-guard behaviour are aligned with the ArgumentNullException.ThrowIfNull guards added in R11.2: ValidationResult.Combine, TypedTaskContext.Transform, AgentMapper.ToDto/CreateFromRequest and SequentialCrewOrchestrator.KickoffAsync now correctly reject null (the orchestrator's CrewInput has no empty form, so a null input is genuinely invalid — the test that expected "graceful" handling now expects the throw). TaskDescription.From is the one behavioural fix: the R11.2 ThrowIfNull had fragmented its validation so a null value surfaced ArgumentNullException ("Value cannot be null") instead of the value object's unified ArgumentException ("… cannot be null or whitespace") used for empty/whitespace — it now validates null/empty/whitespace uniformly in one guard (still CA1062-clean). A telemetry test (OtelTests.tool_call_emits_a_span_with_tool_name_tag) was also made robust against the process-global ActivityListener picking up a concurrent test's tool-call span, by filtering on the unique tool.name tag like the sibling crew/agent span tests already do. dotnet build Orkeon.sln stays at 0 warning / 0 error.
  • Tool URL parameters typed as System.Uri no longer break the agent tool contract (R11.7-D1 follow-up). The D1 API-shape wave (CA1054/CA1056) converted tool request/response URL properties to System.Uri, but the typed-tool schema generator mapped Uri to JSON type "object" — so every tool call carrying a string URL was rejected before execution with Parameter 'url' has invalid type. Expected: object (≈30 direct failures cascading across web_scrape, scrape_element, http_api, cache_search and arcadedb_query). Fixed at a single point rather than reverting the DTOs: ToolSchemaGenerator now maps Uri to "string" (format uri) like Guid/DateTime, and a new tolerant UriTolerantConverter (registered only in the component pipeline's options) round-trips Uri↔string — empty/whitespace maps to null (so a tool's own "URL cannot be empty" validation reports a friendly error instead of an opaque JSON failure), relative values are accepted (UriKind.RelativeOrAbsolute, e.g. a host-substring filter), and writes use OriginalString to preserve the exact URL with no trailing-slash canonicalisation. The Uri typing (and the frozen CA1054/CA1056 errors) are kept. The same string→Uri? conversion had also silently flipped the required url parameter of web_scrape/scrape_element/http_api to optional in the generated schema (a non-nullable string infers required; a nullable Uri? infers optional); those three inputs are marked [FieldSchema(IsRequired = true)] to restore the pre-D1 schema while keeping the property nullable for the tool's own emptiness check (cache_search's URL substring filter stays optional; arcadedb_query's bolt_uri was already required). Also corrected three test concerns surfaced by the same Windows run: the MockHttpMessageHandler/TestHttpMessageHandler doubles now capture a buffered clone of each request so post-send body assertions survive the provider's R10.2 content disposal (was ObjectDisposedException ×27), the IUrlValidator SSRF stub records OriginalString instead of the canonicalised form, and three LlmBasedManager null-argument tests now expect the ArgumentNullException the R11.2 guards correctly throw (was NullReferenceException). dotnet build Orkeon.sln stays at 0 warning / 0 error; the test suite is re-run on Windows.
  • Conversation roles are matched case-insensitively everywhere (SML-009, R12.5). The HTTP providers compared msg.Role == "assistant" (case-sensitive) while ConversationPolicy used OrdinalIgnoreCase, so a mixed-case role like "Assistant" was serialized one way and policy-matched another. A new LlmRoles (canonical lowercase wire values + a single Is/IsX helper) now routes every comparison and message construction in the Anthropic/OpenAI-compatible providers, ConversationPolicy, and the LlmMessage factories. This fixes a real bug where a mixed-case "Tool" orphan survived history trimming and produced the orphan tool_result the trim exists to prevent. The scripting default models (LlmNamespaceBinding) were de-duplicated (they were defined twice in the same file); reconciling them with ProviderDefaults is a maintainer product decision (the values differ).
  • release.yml and ci.yml no longer publish divergent NuGet perimeters (OSS-011, R8.3). release.yml was missing Orkeon.Infrastructure even though the README documents installing it; both workflows now pack the same three core libraries. The published set is documented in docs/reference/publication-matrix.md (promotion of the tools family / orkeon tool is held until decision D3 so the scripting twins' names are not locked into NuGet before a possible rename). Stale metadata fixed: the CONTRIBUTING clone/upstream URLs (Orkeon/orkeon), the Orkeon.ConsoleApp local 1.0.0 version override (now inherits 0.9.0-beta), and the obsolete +orkeon coverage-filter comment.
  • HttpRequestMessage/HttpResponseMessage are disposed on the LLM request path (ANT-006, R10.2). The 20 per-call CA2000 leaks in the Anthropic/OpenAI-compatible/Ollama providers and HttpClientAdapter are fixed by real lifetime: using var for non-streaming request/response, dispose-after-send for the streaming request (the response escapes but the request body is already transmitted), and the previously-leaked cloned retry request in ExecuteHttpRequestAsync. The 11 LlmProviderFactory sites are ownership transfers (the provider is wrapped in the returned adapter; its Dispose is a no-op) — collapsed into one generic Adapt<T> helper carrying a single justified suppression.
  • Semantic memory recall no longer silently returns empty on the default configuration (MAT-017, R10.1). IMemoryProvider.SearchSimilarAsync was a default interface method returning empty, and InMemoryProvider's real cosine implementation was unreachable through the interface (C# does not re-map derived members onto a base-implemented interface). SearchSimilarAsync is now an abstract member of MemoryProviderBase (compiler-enforced for every provider), the four affected providers re-list the interface, and Redis/ChromaDB/Pinecone — which had no implementation at all — gained real vector searches (server-side query for Chroma/Pinecone, client-side cosine for Redis). A reflection test locks the interface map for future providers.
  • ICodeSandbox resolution no longer launches a docker version process under the DI singleton lock (ORG-012, R10.3). The availability probe lives in a memoized lazy decorator (LazyProbingCodeSandbox) and runs at the first ExecuteAsync (async, cancellable); the probe process is now killed on timeout/cancellation. Fail-closed semantics of the sandbox gate are preserved byte-for-byte. An architecture test bans GetAwaiter().GetResult()/.Result in src/ DI factories (single documented exemption: plugins).
  • Script command loading no longer blocks the DI thread (ANT-002, R10.3). ScriptCommandRegistry resolution is pure wiring; discovery + esbuild transpilation + Jint evaluation are deferred to a memoized task awaited at runner startup (failures are not memoized — next call retries).
  • Script ctx.services.get("tools") no longer materializes a new set of transient disposable tools per call (ANT-005, R10.4). The whitelist resolves the tool set once (thread-safe lazy) and serves a fresh shallow copy of the same instances — unbounded memory growth in long REPL sessions is gone.
  • MemoryProviderFactory no longer creates bare HttpClients (ANT-013, R10.5). Chroma/Pinecone/LanceDB clients use SocketsHttpHandler with PooledConnectionLifetime (2 min) so rotating cloud endpoints are re-resolved; ChromaDB and Pinecone providers gained the missing Dispose (the client was never released) and all three providers are now IDisposable.
  • CrewOutput.TokensUsed is real telemetry for all 6 process types (MAT-004, R10.8). Parallel/Hierarchical/Consensual/Autonomous now record token usage (new thread-safe TokenUsageTally), Graph propagates its existing internal count (success and circuit-breaker paths), and the prompt/completion split is extracted from UsageDetails instead of being discarded. Breaking (0.9.0-beta): TokensUsed is now nullable — null means "not measured", never a fabricated TokenUsage(0,0,0); the persisted checkpoint projection records TokensMeasured so the distinction survives round-trips.
  • Application placeholders implemented or removed (MAT-018, R10.9). CrewConfigurationMapper.ToConfiguration exports agents and tasks for real (round-trip tested; breaking: the caller now provides the materialized entities); CrewValidator validates LLM configs (model + canonical numeric bounds); CrewPlanner consumes its previously-ignored strategy parameter; the stub AgentPlannerService is explicitly documented and logs at use. Removed: IMemoryCoordinator.ClearTemporaryMemoriesAsync (no production caller, no "temporary" marker in the model — the no-op could not be made honest).
  • AddOrkeonA2A()/AddOrkeonInfrastructure() call order no longer matters for the A2A agent directory (ANT-019, R9.3). IAgentRepository is now registered with TryAddScoped by the infrastructure: when A2A ran first, its SharedStoreAgentRepository upgrade used to be silently won back by the later AddScoped (per-scope empty directory — ANT-001's failure mode, no crash). Side effect: a host repository registered before the Orkeon extensions is no longer shadowed by the in-memory default; hosts that override IAgentRepository after AddOrkeonInfrastructure() without Replace keep the last-wins behaviour as before.
  • Ctrl+C in TUI cancels the current command instead of being intercepted as SIGINT (TUI-20) — Console.TreatControlCAsInput = true is set after Application.Init so Ctrl+C reaches Terminal.Gui's input loop. The .NET runtime's Console.CancelKeyPress hook is skipped in TUI mode (would race with the keystroke path). A global Application.KeyDown handler in TerminalGuiHost is the source of truth: 1×Ctrl+C requests IInteractiveRunner.RequestCommandCancellation (with REPL-pane feedback ⏹ Cancellation requested...); 2×Ctrl+C within 2s force-quits the TUI as an escape hatch. RunOneShotAsync now accepts an externalCt parameter so VerifyCommand propagates the per-command CT into the inner crew kickoff.
  • Ctrl+Q during a running command shows a confirmation dialog — uses MessageBox.Query (Terminal.Gui's idiomatic modal). The previous custom QuitConfirmDialog exposed a v2 runnable-stack race that swallowed the post-dialog Application.RequestStop.
  • Inner-host logs (RunOneShotAsync) leaked to stdout in TUI mode (TUI-19) — when verify spawned a child host with AddSimpleConsole, those writes hit System.Console.Out (commandeered by Terminal.Gui's alt-screen) and dumped on shutdown. New Orkeon.Cli.Abstractions.Logging.AmbientLoggerProvider is published by the TUI host on Initialize; RunnerExecution.ConfigureVerboseLogging resolves it via reflection (no project coupling) and substitutes it for AddSimpleConsole when present. Inner host logs now flow into the logs pane.
  • Default LoggerFactory minimum level too restrictive in TUI — runner now sets LogLevel.Trace upstream so all entries reach TerminalGuiLoggerProvider; visible filtering is owned by the provider (toggled at runtime via F2 / Shift+F2 in the status bar).
  • Gray-on-gray invisible text + missing show/hide logs — Terminal.Gui default scheme paints fg and bg in the same gray, so panes appear empty until you select with the mouse. New Orkeon.Cli.TerminalGui.Layout.SchemeFactory builds explicit white-on-black schemes wired into LogsPaneView/ReplPaneView/SplitPaneToplevel. Ctrl+G now toggles the logs pane visibility (REPL fills the screen when hidden).
  • Initial focus landed on the read-only logs pane instead of the prompt input (TUI-16) — _history.CanFocus = false removes it from the focus cycle, plus an Initialized hook on ReplPaneView calls _input.SetFocus() once the view is laid out so typing works immediately without clicking.
  • Status bar shortcuts swallowed by focused TextField (TUI-17) — every Shortcut now sets BindKeyToApplication = true so keystrokes route at app level regardless of focus.
  • Ctrl+Q hung the host when the runner was blocked in Console.ReadLine (TUI-17) — sync-over-async wrapper passed CancellationToken.None. ReplPaneView.CancelPendingRead() is invoked from the host's finally block to forcibly complete the pending TCS with null so the runner's loop sees ReadLine() == null and exits.
  • Hosts hung when the runner ignored cancellation during a long command — added a 2s grace period after linkedCts.Cancel(); if the REPL task doesn't honour cancellation within the window, it's abandoned (orphaned task finishes in background, host exits cleanly).
  • Terminal.Gui split-pane silently exited at startup (TUI-14) — TerminalGuiHost(options, loggerProvider) formed a cycle with the TerminalGuiLoggerProvider DI factory; .Host.Build() exited with code 0 before any UI was rendered. TerminalGuiHost now takes only TerminalGuiOptions; the status bar is built and attached from the TerminalGuiLoggerProvider factory once both exist. Also: explicit DOTNET driver on Linux/macOS (TUI-13), since the default driver emits no output in WSL.

Added

  • Bilingual documentation parity gate (OSS-012, R8.4). scripts/check-docs-parity.sh fails CI when any docs/**.md lacks its docs/fr/ mirror (or vice versa), or when a root README/CONTRIBUTING/CODE_OF_CONDUCT/SECURITY .md lacks its .fr.md pair; wired as the docs-parity job. The rule is documented in both CONTRIBUTING files.
  • Blocking npm vulnerability audit (DEP-010, R8.6). dependency-audit.yml gains an npm-vulnerability-audit job (npm ci --dry-run integrity + npm audit --audit-level=high over the esbuild bootstrap), so a CVE on esbuild/@esbuild/* fails CI instead of being an ignorable Dependabot PR. NuGet lockfile pinning was considered and deferred (bump friction outweighs the reproducibility gain already covered by Dependabot + the blocking audit).
  • Native tool calling for Azure OpenAI (FON-011, R10.7). AzureOpenAILlmProvider is rebased on OpenAICompatibleProviderBase (its hand-rolled pipeline only read choices[0].message.content) and the factory passes the OpenAI strategy: tools/tool_choice are injected and tool_calls parsed natively, with the text fallback kept as the safety net. Ollama stays on the text protocol — its /api/generate pipeline is prompt completion and the native-tools /api/chat response format is incompatible with the OpenAI parser; documented in docs/reference/limitations.md.
  • runCrew script calls are bounded by a configurable timeout (ANT-007/ANT-010, R10.10). Default 10 minutes (ScriptHostFacadeOptions.RunCrewTimeout, ≤ 0 disables): an infinite crew no longer freezes the REPL; scripts get a clear TimeoutException. IConsoleAdapter gains ReadLineAsync/ReadKeyAsync as non-breaking default interface methods, with real TUI overrides on the existing TCS machinery. The assumed-blocking design (Jint is synchronous) is documented in the scripting guide (EN+FR).
  • Terminal.Gui split-pane console (Orkeon.Cli.TerminalGui) — new IConsoleAdapter + ILoggerProvider that route REPL I/O and ILogger writes into separate panes (logs on top, REPL on bottom), driven by Terminal.Gui v2.0.1. All 4 interactive runners (ClaimVerifierRunner, MainMenuRunner, QaRunner, plus the new --ui flag in Orkeon.ConsoleApp + examples/runners/interactive-claim-verification) accept --ui tui|plain|auto, default auto (TUI when interactive TTY, plain in CI/pipe via TtyDetector). Wire-up: services.AddOrkeonCliTerminalGui(). Full keybindings: Ctrl+L (clear logs), Ctrl+K (clear REPL), Ctrl+F (find), Ctrl+G (toggle logs pane), Ctrl+↑/↓ (resize split), F2 (more log details) / Shift+F2 (less log details), Ctrl+C (cancel current command — 2× to force-quit), Ctrl+Q (quit, with confirmation dialog if a command is running). TUI-18 tracks the Terminal.Gui 2.1.x re-evaluation follow-up.
  • IInteractiveRunner interface in Orkeon.Cli.Abstractions.Runners exposes IsCommandRunning + RequestCommandCancellation(). InteractiveRunnerBase implements it; the TUI uses it to drive Ctrl+C cancellation and Ctrl+Q confirmation dialogs.
  • AmbientLoggerProvider in Orkeon.Cli.Abstractions.Logging — process-wide ambient ILoggerProvider registry letting child hosts re-route their logs into a parent TUI's pane without project coupling (resolved via reflection by RunnerExecution.ConfigureVerboseLogging). Wrapped in a non-owning LeasedLoggerProvider so child host disposal doesn't kill the parent's provider.
  • TUI key event diagnostic (examples/runners/tui-keytest) — small standalone runner that boots Terminal.Gui and logs every keystroke arriving at Application.KeyDown to /tmp/tui-keytest.log. Used to diagnose terminal-specific keystroke routing issues (TUI-20). Run with dotnet run --project examples/runners/tui-keytest.
  • Virtual FileSystem v2.2 — enumeration + streaming surface on IFileSystemService (EnumerateFilesAsync, OpenReadStreamAsync, TryReadAllBytesAsync, TryReadAllTextAsync, GetEntryKindAsync). FileSystemDiscoverer now goes through the VFS instead of raw System.IO.
  • Virtual paths across the RaggableTree pipeline — RaggableNode.FilePath → VirtualFilePath, propagated through adapters, tools, DTOs (SourceSlice, SymbolSourceResponse), serializer (bumped to v2.0), and the store. Builder reads source via IFileSystemService.TryReadAllTextAsync.
  • Index introspection tools — index_status and is_path_indexed let agents check which virtual roots are indexed and whether a given virtual path is covered (longest-match on overlapping roots). IRaggableStore.GetIndexedRoots() exposes the underlying list.

Removed / Breaking

  • ImprovedAgentExecutionService renamed to AgentExecutionService (SML-008, R12.4) — it is the only implementation of IAgentExecutionService, so the "Improved" qualifier was meaningless. The value object Version (which shadowed System.Version) is renamed SemanticVersion. Internal/pre-freeze renames in the 0.9.0-beta window. The dead JsonToolCallParser ([Obsolete], no usage, no DI registration) and the empty JsAgentInstance placeholder are removed.
  • --prebuild-index CLI flag removed from the standard runner. Agents now call index_codebase(root_path="/src") themselves (optionally gated by is_path_indexed). The flag pre-built an index the agent could not scope; letting the agent index what it needs, when it needs it, removed a whole-tree cost from every run.
  • Serialization format bump — RaggableTree on-disk cache goes from v1.0 to v2.0 (field rename FilePath → VirtualFilePath). Existing caches will fail to load and need to be rebuilt.

0.9.1-beta - 2026-07-04

Published to GitHub Packages only, without a dedicated changelog section at the time; its changes are folded into the 0.9.2-beta entries above. Recorded here so the version chain has no gap. The v0.9.1-beta.rc* tags that followed re-packed this unchanged version, so --skip-duplicate silently skipped every push — the incident that motivated the tag↔version guard in the publish workflow (see 0.9.2-beta).

0.9.0-beta - 2026-03-27

Added

  • Typed pipeline architecture: ComponentBase<TRequest, TResponse> as the core abstraction for all components, replacing Dictionary<string, object> signatures throughout the codebase
  • ToolBase<TReq, TRes> generic tool base class with typed request/response, YAML defaults merging, and output filtering
  • EvaluatorBase<TInput, TResult> and FlowStepBase<TInput, TOutput> typed base classes bridging interfaces with the typed pipeline
  • 15+ built-in tools: FileRead, FileWrite, WebScrape, HttpApi, JSON, CSV, PDF, XML, Database, GitHub, CodeExecution, and more in dedicated Orkeon.Tools.* projects
  • SimpleCrewOrchestrator replacing the Akka.NET actor model with straightforward async/await orchestration
  • Semantic agent selection using embedding-based similarity to match tasks to the most suitable agent
  • Strongly typed configurations: AgentConfiguration, TaskContext, LlmConfig, and related value objects throughout Domain and Application layers
  • 5 LLM providers: OpenAI, Ollama, Anthropic, Azure OpenAI, and Groq — all HTTP-based implementations extending HttpLlmProviderBase
  • Memory providers: Redis (with vector search), SQLite (long-term persistence), and InMemory (for development and testing)
  • Fluent Builder API: AgentBuilder, TaskBuilder, CrewBuilder, and FluentBuilderFactory for ergonomic agent/crew construction
  • YAML configuration support: full round-trip export/import for agents, tasks, crews, and tool schemas; [FieldSchema], [ComponentContract], and related attributes for schema generation
  • ToolSchemaGenerator: auto-generates JSON/YAML schemas from typed [FieldSchema] attributes, with $ref-based nested type extraction
  • Tool validation framework: security validation, rate limiting, and telemetry hooks on every tool execution
  • Batch tool execution for parallel tool operations
  • Structured tool calling protocol (JSON-based) with ToolCallRequest<TParameters> and FunctionCallInfo
  • CQRS pipeline: commands and queries for Agent, Crew, and Task aggregates; ValidatingCommandHandler decorator; UnitOfWork integration for post-persistence domain event dispatch
  • Strongly-typed entity IDs: 28 concrete EntityId<T> types (ULID-based) — AgentId, TaskId, CrewId, etc. — replacing primitive string identifiers
  • A2A (Agent-to-Agent) communication protocol: AgentCard, discovery, AgentCommunicationClient/Server, TaskRouter, mTLS support, and DI integration (subsequently renamed to AgentCommunication/)
  • Session checkpointing: IStateStore, CheckpointManager, ResumeEngine with three backing stores; time-travel checkpoint history with fork, replay, and diff
  • Cognitive memory system: LLM-powered remember/recall with LanceDB embedded vector store support
  • Enterprise auth: Azure AD and OIDC integration, claims-based authorization
  • Memory encryption at-rest: AES-256-GCM encrypted Redis and SQLite decorators with key rotation
  • DLP (Data Loss Prevention): PiiDetector with 5-channel interceptors and per-channel policy
  • RAG data validation: integrity checks, injection detection, provenance tracking, and quarantine
  • Agent kill switch: IAgentLifecycleManager for controlled agent termination
  • InMemoryAgentMemoryStoreRepository (Infrastructure) for fast in-process agent memory
  • E2E test project (Orkeon.Infrastructure.Tests) with 10+ integration tests; IConfiguration wired into test DI container
  • XML documentation on all public types across all projects (CS1591 enforcement enabled)
  • ToolCallRequest<TParameters> generic typed tool protocol
  • Manual mock library for LLM, Knowledge, Memory, Security, MCP, Process, and Tool interfaces — replaces Moq across the entire test suite
  • Clean Architecture + DDD audit reports (ADRs) documenting architectural decisions and conformance

Changed

  • Complete rename to Orkeon (via the interim Arkeon name) across the entire codebase (solution file, namespaces, projects, docs, HTML, scripts, and examples)
  • Infrastructure layer redesigned without Akka.NET: simple HTTP-based implementations, direct async/await service calls, standard dependency injection replacing the actor model
  • Domain encapsulation hardened: private/internal constructors on all value objects and aggregate roots; Restore() factory methods for persistence; IReadOnlyList<T> replacing mutable List<T> on domain types
  • 15+ anemic domain types converted to immutable records (init-only properties)
  • Value objects refactored: AgentSkill, AgentCapability, AgentSelectionResult, CrewVariables, DomainValueObjects.cs split into per-feature files; renamed duplicates (MemoryEntity, TypedTaskContext, DelegationToolParameters)
  • Domain reorganized feature-first: Builders, Templates, Callbacks, DomainEvents, and ValueObjects moved to bounded-context folders; TrainingScenario moved to Training BC; A2A/ renamed to AgentCommunication/
  • Application layer reorganized feature-first: DTOs co-located with feature folders; dead infrastructure port interfaces removed; KickoffAsync extracted from Crew aggregate to the Application orchestrator
  • Infrastructure layer reorganized by feature/BC: Persistence separated per-aggregate
  • MemoryRelevanceRanker renamed to MemoryRelevanceService
  • AgentStep string ID replaced with typed AgentStepId
  • IRepository simplified: GetAllAsync and IPredicateRepository removed (AP4/R45)
  • IAgent.Tools typed as IReadOnlyList<IBaseTool> (previously untyped)
  • CQRS handlers wired into the ConsoleApp via the standard pipeline; DI lifetimes aligned
  • Test suite migrated from Moq to manual mocks and from FluentAssertions to xUnit Assert; test methods renamed to Should_When convention; Handler-level directory organization
  • Trading tools migrated to typed generic pipeline TradingToolBase<TRequest, TResponse>; tool definitions extracted to YAML
  • Examples updated to use Fluent Builder API and Docker Model Runner LLM configuration
  • ComponentBase JSON serialization extracted from Domain to Infrastructure (N1)
  • ShouldRetain/ShouldPromoteToLongTerm made internal to enforce aggregate boundary (R35/R8)
  • EntityMemory/EpisodicMemory made internal to the aggregate (R8/R35)
  • MemoryItem mutation methods made internal (R35)
  • AgentCapabilities/CrewOutput constructors privatized (R28)
  • CrewInput constructor made internal (R10/R28)
  • ToolResult/ToolUsageMetrics converted to init-only properties (R25)
  • Validation pipeline wired in: CreateTaskCommandValidator handles AgentId validation; ValidatingCommandHandler decorates the CQRS chain
  • UnitOfWork try/finally guard added to ensure domain events are dispatched after persistence even on exceptions (R21/R39)
  • ITaskRepository scoped documented; SaveChangesAsync removed from repository, delegated to IUnitOfWork

Fixed

  • Infrastructure ChatClient adapter no longer overrides caller-supplied LLM configuration
  • Empty task output in process strategies handled gracefully
  • IMemoryScope and IMemoryProviderFactory registered in DI (defaults to NullMemoryScope)
  • LLM DI registration corrected across all examples
  • LLM BaseUrl changed from host.docker.internal to localhost in examples
  • Missing AgentBuilder/CrewTaskBuilder using directives in email-management and research-assistant examples
  • ClassicTrading example: raw strings wrapped with Value Object factories; Agent.AgentId renamed to Agent.Id; namespace corrections for LlmConfig and ILlmProvider
  • Duplicate MemoryProviderConfigDto removed (kept in Memory/, removed from Common/)
  • Duplicate MemoryRelevanceRanker stale reference cleaned up (R43/R50)
  • Domain event dispatch order standardized; DI lifetimes aligned (N5/N6)
  • PromptShieldBuilder tests fixed after AgentBackstory VO migration (null backstory handling)
  • Post-refactoring compilation errors resolved across Infrastructure project
  • CS4014 warning: async Timer callback wrapped with try/catch and discarded correctly
  • Null safety and structured logging fixes (CS8604, CA1873) across Application and Infrastructure
  • Code quality fixes: cognitive complexity (S3776), unused parameters (S1172), collapsed ifs (S1066), assertion improvements (xUnit2013, xUnit2032), and more

Removed

  • Akka.NET dependency and all actor-model code (cluster sharding, distributed data, CRDT, CollaborationActor)
  • All TODO comments from the codebase
  • sonar-project.properties file (caused scanner conflicts; all parameters now passed via CLI)
  • Legacy CodeInterpreterTool (replaced by SecureCodeInterpreterTool)
  • GetAllAsync and IPredicateRepository from IRepository<T> (AP4/R45)
  • 5 dead infrastructure port interfaces from Application layer (R16)
  • Moq and FluentAssertions package references from all test projects
  • [Obsolete] FunctionCall dictionary property replaced by FunctionCallInfo (T17)
  • Telemetry infrastructure (StartSpan → migrated to StartActivity; unused telemetry packages removed)
  • Direct Domain usings from ConsoleApp services (R51)

0.1.0-alpha - 2025-09-21

Initial public development snapshot. Core domain model established in C# following Clean Architecture principles, as an independent implementation.

Added

  • Initial solution structure: Domain, Application, Infrastructure, ConsoleApp projects
  • Core domain entities: Agent (Worker, Manager, Observer, Human), Crew, CrewTask
  • IBaseTool interface and initial tool implementations
  • ILlmProvider with OpenAI and Ollama HTTP implementations
  • Basic memory abstractions (IMemoryProvider)
  • Initial Akka.NET actor-based agent execution (later replaced)
  • Communication protocols: Direct, Broadcast, Consensus, Feedback
  • Redis memory provider with vector search
  • SQLite persistence for long-term memory
  • ClassicTrading example (agent crew for trading workflows)
  • Standalone mode (no Redis required)
  • Console application entry point