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.RecordUsageandTokenBudgetTracker.EstimateCosteach 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: trueon an input folder — set by the assistant from the need, or by a client infolders.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 samepath(a renamed folder says it again);examples: trueon an output folder is refused, aFORGE-FOLDERS-INVALIDin a confirmed list and a refusedbrief_submitin the assistant's brief.- A tool's schema says all of JSON Schema a model reads (#415):
ParameterSchemagainsProperties(the properties of an object parameter, each with itsRequired),Items(the schema of an array's items, at any depth),AnyOf,AllowsAdditionalProperties(falsewritesadditionalProperties: false), and the boundsMinimum,Maximum,ExclusiveMinimum,ExclusiveMaximum,MinLength,MaxLength,Pattern,MinItemsandMaxItems;ToolSchemagainsAllowsAdditionalParameters.ParameterSchema.ToJsonSchema()andToolSchema.ToInputJsonSchema()write the JSON Schema, and are the one writer of every provider - the OpenAI and the Anthropic tool formats, Ollama's included - and oforkeon 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 anEnumMapas itsenum, as the providers did, and an array whose items are not known carriesitems: {}(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 carriesitems: {};orkeon mcp servealso publishes theformatand theitemsits 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,ItemsFormatandItemPropertiesstill work: they are read whenItemsis not set.McpToolAdapter.ConvertToToolSchemaand theMcpToolAdapterconstructor (experimental) now throwInvalidOperationExceptionfor a schema beyond the client's budgets (the #415 entry under Fixed).
Fixed
shell_commanddropped the identity of a commit (#404): the command it starts receives a fixed list of the host's variables, andGIT_AUTHOR_NAME,GIT_AUTHOR_EMAIL,GIT_COMMITTER_NAMEandGIT_COMMITTER_EMAILwere 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, whoseHOMEis a folder of its own - a crew allowed to commit (Orkeon:Tools:Shell:AllowInterpreters) stopped onAuthor identity unknownwhatever identity the caller set;Orkeon:Tools:Shell:Environment:Propagatecould not carry them either, its secret filter refusingGIT_AUTHOR_*for theAUTHofAUTHOR. The four are now on the built-in list, under every confinement backend. They hold a name and an address; no otherGIT_*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_graphreturned the modules with no edge andpackage_summaryno dependency. A Python import is now read from its syntax and resolved against the files of the tree:a/b.pyora/b/__init__.pyunder 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 offrom a.b import cthat is a submodule reaches its file, the others reacha.b;import a.bwherebis an attribute reachesa.py; a relative import starts from the importing file's package. An absolute import that no folder holds goes toext::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 toext::pypi::with a name of the new path below the indexed root, or to the__init__.pyof 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 servewrote every member it did not carry asnull(#405): a response held"error": nullbeside its result, or"result": nullbeside 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 toinitializewas dropped and the connection timed out. A response now carriesresultorerror, never both, and an optional member is absent when it has no value:nextCursorof a list,mimeTypeanddataof a text content,dataof an error,descriptionof 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 atools/callwithout arguments no"arguments": null.- The container image
ghcr.io/orkeon/orkeonhad nogit(#404). A crew that runs it throughshell_commandon the repository mounted on/workspacegotgit: not found, and read the empty output as an empty repository. The image now installsgit, 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--userthat differs, a mount owned by root - is read all the same. The image sets no git identity: a commit needsGIT_AUTHOR_*andGIT_COMMITTER_*from the caller. The shell allowlist is unchanged:shell_commandrunsgit status,log,diffandshowby default, and any other git command (rev-parse,commit) still needsOrkeon: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 atools/callto 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_ingesttook itssourcesfor 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 alongis along(it was adouble), any other number adouble, andnullisnull(it was the stringnull).tools/listpublishes theitemsof an array parameter (their type, and their properties for an array of objects), as the schema an agent's model reads does.rag_ingestanswers 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 itssourcesparameter says it holds strings.- The opt-in token budget priced a call without its provider (#396).
TokenBudgetTrackerlooked 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 aCustomPricingsrow with aProvider. The cost it compared withMaxCostPerCrewcame 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 newRecordUsageoverload now gets the row the pricing registry picks for that provider. A call to the provider-less overload is priced as before. orkeon mcp serveanswered a line that is no valid request with-32700,-32601, a success or nothing (#414).-32700is now kept for text that is not JSON, and-32600 Invalid Requestanswers 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), ajsonrpcthat is absent or not"2.0", amethodthat is absent, empty or no string, anidthat isnullor neither a string nor an integer, and aparamsthat is neither an object nor an array. A response (aresultor anerrorwith nomethod) is dropped, as JSON-RPC asks: it used to be answered-32601. The answer carries theidwhen it could be read,nullotherwise. A message that carries anidbeside anotifications/*method is now answered (-32600, with itsid): it used to be taken for a notification, obeyed and left without an answer. A C# host that callsMcpServer.ProcessRequestAsyncgets the same answers for the request it is handed, except what a request it deserialized itself no longer holds: anullidand an absentjsonrpc(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 servelet badtools/callparameters through (#413).argumentsthat were present and no object were replaced by none, and the tool ran: they are refused with-32602, for a registry tool, arun_crew_*tool andprompts/getalike. Aparamsthat is an array or anamethat is no string answered-32603 Internal error: it answers-32602. A number beyond the range of adouble(1e400) failed the call with the .NET serializer's own message: the call now answersisError: truewithArgument 'x' is not a finite number.(x[0],x.ywhen 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
typeis an array (["string", "null"], a nullable parameter), on anenumof numbers or booleans, and on arequiredentry or adescriptionthat is no string; the connection failed with a .NET message that named neither the tool nor the property. Atypearray is now read as its one member that is not"null", every scalarenumvalue is kept, and a tool that cannot be registered - anullentry of the list, a tool with no name, aninputSchemathat still cannot be read, aname, adescriptionorannotationsof 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 aninputSchemathat cannot be read):tools/listis read tool by tool. A tool that becomes unreadable at atools/list_changedleaves the registry. - The rest of what an MCP server lists is read the same way.
prompts/listandresources/listwere 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": nullor"resources": nullfailed it too. They are read entry by entry: a prompt with no name, a resource with nourior an entry of the wrong JSON type is set aside alone, with a warning written once (mcp.entry.unreadable), andnulllists nothing; a prompt name or a resourceurilisted twice is kept once, the first (mcp.entry.duplicate); a prompt's"arguments": nullis no argument, and apromptsorresourcesmember of the wrong shape lists what could be read, with a warning (mcp.listing.unreadable). Atools/listanswer of the wrong shape - atoolsthat is neithernullnor an array, anextCursorthat 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 atools/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"isnullhas an empty description. - The MCP client kept too little of a remote tool's parameter (#415): the
itemsof an array were dropped, so an agent's model saw a barearray, and so were theformatand theadditionalPropertiesof 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 withitems: {}, any JSON value, where a provider that wantsitemson 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 notype({}, ananyOfof several schemas, a$refthat names nothing local) was read as astring: it now has no type, and the model may give any JSON value. Adefaultis kept as the value it is: a whole number stays whole (it was read as adouble), an array or an object is no longer its JSON text, and"default": nullis no default (it was the textnull). A number nodoubleholds (1e400) is dropped from anenumor adefault, and items that declarepropertiesand notypeare 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 ofanyOf/oneOf, aconst, and the local$ref/$defsit resolves; a nullableanyOf(Pydantic'sOptional) is read as its one schema, and anallOfof objects as one object. A tool whoseinputSchemaexpands to more than 4096 schemas, or copies more than 1 MiB of text, each use of a$refcounted (a definition used many times counts each time), is set aside with a warning written once per distinct tool definition. A tool served byorkeon mcp servenow publishes theformatof 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_metaof the modern era. Both announce the version of the release they run, the oneorkeon --versionprints.MCP:Server:Versionis empty by default and still wins when it is set. An installation that copied"Version": "1.0.0"fromappsettings.sample.jsonkeeps announcing1.0.0: removeMCP:Server:Versionor leave it empty. - Outside MCP too, Orkeon announced a fixed
1.0.0whatever 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 oneorkeon --versionprints. They all read it from one place, theOrkeon.Domainassembly, theUser-AgentandOrkeon.Scriptingincluded: an application that mixes Orkeon packages of two versions announces one version, not one per assembly. OneHttpClienthanded to several HTTP tools carried the product once per tool in itsUser-Agent: it carries it once.A2A:AgentVersionis empty by default and still wins when it is set; an installation that copied"AgentVersion": "1.0.0"fromappsettings.sample.jsonkeeps announcing1.0.0: remove the key or leave it empty. The HTTP tools sendUser-Agent: Orkeon/<version> (+https://github.com/Orkeon/orkeon)where they sentOrkeon/1.0: a site that filters on the exact former string sees the change at every release. The public constantsOrkeonDiagnostics.ServiceVersion,OrkeonActivitySources.Version,PlatformDefaults.VersionandHttpDefaults.DefaultUserAgentkeep their value for the callers that compiled them in; Orkeon no longer reads them (DefaultUserAgentis the fallback when a build's version is no valid product token).GitHubToolsent a bareUser-Agent: Orkeon: it sends the same value as the other HTTP tools.AgentCard.Versionkeeps its default,1.0.0: an agent card read from a peer that names noversionreads1.0.0, as before. orkeon forge(#400): an input folder confirmed withoutexampleskept the proposal's value only when itspathwas the proposal's to the letter, case included, while a list compares two of its paths ignoring case (/Inboxand/inboxare 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 doctorfails whentscis required byTypeCheck: Alwaysand 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_messagefor 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.Providerscopes a pricing row to a provider (null means any provider), andIModelPricingRegistrygains the provider-awareTryGetPricing(string? provider, string model)andCalculateCost(string? provider, string model, ...)overloads, as default interface methods that delegate to the existing members: an implementation of your own still compiles.RegisterPricingfiles a row that names aProviderunder that provider, andGetAllPricingslists the provider-less rows only, custom rows included: a provider-scoped row, built-in or custom, is not in it.Orkeon:CostTracking:CustomPricings:<i>:Providersets it from the settings (#383).TaskResult.EndedOnIterationCap,TaskResult<TOutput>.EndedOnIterationCap,TaskExecutionSnapshot.EndedOnIterationCapandCrewExecutionEvent.EndedOnIterationCap(allbool,falseby default,initproperties) mark a task whose answer came from the tool-free turn after the agent loop's iteration cap. The task keepsSuccessandAgentExitReason.Completed: the flag sits beside them, it is no new enum member. Thetask.completedline oforkeon run --eventscarries it asendedOnIterationCap(always written, just beforedeliverableMissing), the forge trial'stask.completedtoo, 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 answersfalse. 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(JSONended_on_iteration_cap) tells the delegating agent that its coworker ended on its cap, and the tool's message says so.TaskResult<TOutput>gainsCacheHitTokens,CacheMissTokens(long?) andEndedAt(DateTimeOffset?),initproperties, and itsTokensUsed,PromptTokens,CompletionTokens,IterationsUsedandRetryCount, which a typed task left at 0, now carry the task's figures; a resumed typed task replays the cache tokens andEndedAtfrom its checkpoint (a typed checkpoint written before this change holds none of them: it replays no cache tokens and no date). Therun.finishedline carriescappedTasks, the number of tasks whose last attempt ended on the iteration cap (always written,0when none did):orkeon run, the forge trial (counted per trial),orkeon-hostand the MCP crew tool host write it (#388).- Loading a crew, YAML or
.ork.ts, checks itstool_calldeliverables: a task whose deliverable no agent able to run it can write (the agent it names in asequential,parallelorgraphcrew, every agent when it names none or one the crew does not carry; every agent but the manager in ahierarchicalorconsensualcrew, every agent in anautonomousone; with a built-in tool that writes that path:docx_writer,xlsx_writer,image_generation,firefoxfor their formats, orfile_writefor a text file, never a binary one) logs a warning, andorkeon run --validateprints it once as aWARNING: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(withKindandMessage, the sentence a host reports) andDeliverableFindingKind(Orkeon.Application.Crew) expose the check to a C# host, withDeliverableToolCheck.IsBinary,WritersOf,PreferredWriterOf(string?),WriterHeldFor,CanWrite,FileWriterToolNamesand theFileWriteToolNameconstant, andDeliverableBaselineScope.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(defaulttrue) set tofalseturns 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.ScriptingorOrkeon.Tools.Embeddings.LocalwithExcludeAssets="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 anInvalidOperationExceptionthat namesLocalEmbeddingsModel/default/model.onnxand the exclusion. PutExcludeAssets="build"on every reference that reaches the package,Orkeon.ScriptingandOrkeon.Tools.Embeddings.Localalike: NuGet unions the flags, so one reference without it keeps the model download. A Slow end-to-end test pins both. A customLocalEmbeddingOptions.ModelPaththat holds no loadable model builds the provider the same way and fails the first embedding with anInvalidOperationExceptionthat names theModelPath, the library's error as inner exception; neither the failure of the embedder nor that ofDimensionsis 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 ragandeval ragis a breaking change, filed under Changed.orkeon forgerecords its fingerprint per session, at/forge/embedding-fingerprint.json(the default ofOrkeon:Embeddings:FingerprintPathat the lowest precedence: an explicit setting still wins), so it guards nothing across sessions.orkeon ragandorkeon eval raguse no host fingerprint (their defaultFingerprintPathis empty): the manifest of each collection guards the collection instead, andorkeon rag ingest --reindex, which rebuilds it, is no longer blocked. The warning of a fingerprint it cannot read or write namesOrkeon: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 whoseFingerprintPathlies 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.
ollamaand 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 (anorkeon-hostdaemon warns once for its lifetime), no longer once per call, namingOrkeon:CostTracking:CustomPricings, and under aMaxCostUsdbudget, 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). ACustomPricingsrow always wins over a built-in one: a row with noProviderapplies 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): aCustomPricingsrow written as a fallback (gpt,claude) now prices every model it prefixes; narrow itsModelPattern, or scope it withProvider.gemini-3.8-flashis 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) anddeepseek-flashhas 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-k3andgrok-4.7. Long-context price tiers are not modelled (#383). What to do: aMaxCostUsdcap 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 aCustomPricingsrow for that model at 0. Orkeon:CostTracking:Enabledfalsenow 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.trueis unchanged (#383).- The
SECURITYline of the shell interpreters is logged once per host, at the firstshell_commandcall validated once interpreters are enabled, instead of at construction and listing ofshell_command. It states the confinement in force: the backend, ornonewith its reason (a container,Mode = None), orunavailablewhen every call fails. Under a confining backend it also saysnetwork onornetwork off(fromConfinement.AllowNetwork), and under bubblewrapsystem directories are read-only; underMode = None, or unconfined inside a container, it always saysnetwork 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 rawArgumentException(ParamNameid) that named neither the section nor the file. It is now a settings refusal namingLlm:ModelCapabilities: the host build refuses it with aRunnerSettingsException, andorkeon run,--validateand--list-toolsprint the settings error and exit1(#385). orkeon doctorno longer reports a missingtscas a warning when nothing needs it (#387); thefailunderOrkeon:Scripting:Toolchain:TypeCheckAlwaysis 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 adiris named to the designer with its size (report.md (750 KB), largest first), and the plan prompt adds the reading rules (search withgrepfirst, then read by range) and amaxIterationsof 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 toRetryCount + 1, sotask.completedsaysattempt3 for a task that took three attempts, where it said 1 (untyped, typed and decision replays alike). A checkpoint written before this change holds noretryCountand replays0. A peer takeover in Autonomous mode whose task fails is now reported as a failure: the channel answers the peer's error (elsethe peer failed), the delegating agent takes its[DELEGATION FAILED]path and the task's snapshot readsSuccess = 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
--eventsstream with arun.finishedline (success: false,outputPathnull, zero durations and tokens, thecappedTasksandmissingDeliverablesof what ran before the crash) before its stage fails; it wroterun.startedand norun.finishedbefore. 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 packingOrkeon.Templatesfrom a checkout stages its templates underobj-linux/instead of under the project folder; the published packages are unchanged (#390). - An agent without
file_writeis no longer told to write itstool_calldeliverable 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_writerfor a.docx), neverfile_writefor a binary file. Afinal_messagedeliverable 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_calldeliverable 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 keepsSuccess, is flagged byTaskResult.DeliverableMissing,TaskResult<TOutput>.DeliverableMissing,TaskExecutionSnapshot.DeliverableMissing,CrewExecutionEvent.DeliverableMissingandAgentChannelResponse.DeliverableMissing(experimental,ORKEXP002) (allbool,falseby default,initproperties), 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 deliverableinAUTO_SUMMARY.md(⚠ completed on its iteration cap without writing its deliverablewhen it also ended on its cap). The check goes through the virtual file system and is best-effort: a probe that fails leaves the flagfalse, 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. Thetask.completedline carriesdeliverableMissing(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 replaysfalse) and reports it when the file of atool_calldeliverable is gone at resume, while afinal_messageorstructured_outputfile 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. Therun.finishedline carriesmissingDeliverables, counted likecappedTaskson each task's last attempt when it succeeded (always written,0when none):orkeon run, the forge trial (per trial),orkeon-hostand the MCP crew tool host write it. A decision task that declares adeliverable:is reported once at load, in a YAML crew, acrew.ork.tsand underorkeon run --validatealike, 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 holdsfile_read.TaskResult.DeliverablePath,TaskResult<TOutput>.DeliverablePath,AgentChannelResponse.DeliverablePath(experimental,ORKEXP002) and the applicationTaskOutput.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()'soutput(#369):JsCrewResult.outputis anobject?, where it was astringholding 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 itsclrproperty, where it caught the CLR type itself (#364).
Added
ctx.fileSystem.prompt(#378): an agent body reads the## File systemsection 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 thesystemprompt it givesctx.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 throughAgentFileSystemPrompt.Render(Orkeon.Application.Agent), so the wording and the order cannot drift, and a body no longer needs alist_mountscall to rebuild part of it.llm.profiles(#364): the namesllm.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 asllm.profilecompares.InvalidScriptError(#366): a script's own mistake the host refuses (clrType"InvalidScriptException": a builder method orbuild(), astateMachine/stateGraphliteral,llm.profile, anllmoption, the rejection of an awaitedctx.llm.*call) is an instance of this global class, anErrorsubclass, so a script testse instanceof InvalidScriptErrorinstead of comparingclrType. A value over a domain limit (ArgumentException) and an out-of-rangeErrorAction.retrydelay (OverflowException) stay a plainError; a C# caller still gets theInvalidScriptException.- 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,OllamaLlmProviderandAnthropicLlmProvider. A caller that brings its own Polly policy can still keep the text protocol (nullstrategy), 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 afilesystem:that is not a list (no value,~ornullis 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 withholdsDelete.list_mountslists the scope,shell_commandbinds the scope's entries alone,start_joblogs only where the scope writes,rag_ingestjudges 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); aworking_rootmust lie inside the scope. In.ork.ts,ctx.delegatehands 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, andrag.ingestfrom a scoped body stays inside it. The C# side isFileSystemScopeEntry,AgentFileSystemScopeandAgentRunScope.FileSystem. - The system prompt of an agent with a file-system tool gains a
## File systemsection (#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_codebaseandincremental_reindexcount as file-system tools.announce_mounts: falseturns 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 withIBaseTool.UsesFileSystem(ToolBase.UsesFileSystem, false by default). orkeon llm probetests the reasoning controls per model: M15 sends the thinking toggle on then off, M16 sweeps the effort levels (lowtomaxthen the values of M18'seffort:*fragments, or the list of the new--sweep-efforts, which takes vendor values such asnone), 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 probegains 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 reportedacceptedorrefusedby the vendor.- Each reasoning step of
orkeon llm probealso reports what the vendor's answer itself carried, read on the wire before the provider parses it:vendorTrace,vendorReasoningTokensandvendorFinishReason, in every dialect (chat completions, Anthropic messages, the Responses API, Gemini, Ollama). A trace the vendor sent but the provider did not surface readswire only. The reasoning prompt is now a counting problem, so that a model with adaptive thinking reasons at all. orkeon llm probechecks 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) readsmissing restriction, a value Orkeon lowered or left out that the vendor takes readstoo narrow(the off switch andnoneonly when they stopped the reasoning; nothing when the vendor keeps reasoning ateffort:none); either fails the mode. M15 now reads the Hugging Face switch (chat_template_kwargs.enable_thinking). The steps carrytableCheckandtableNotein the JSON, aTablecolumn in the report, and the campaign's "Reasoning per model" table gains aTablecolumn naming the contradictions.- A script reads what a model takes for reasoning (#359):
LlmConfig.capabilitiesgives{ model, known, thinking, efforts }, the effort levels being the provider's narrowed by the model's (empty when the model takes none),thinkingone ofnone,effortOnly,toggle,budget, andknownwhether the capability table has an entry. The C# side isILlmProvider.DescribeReasoning(model)(LlmReasoningCapabilities,ORKEXP005). - A script reads what became of the effort it asked (#360):
reasoningonLlmConfig, on the results ofactandchatand on the objectstream()returns gives{ model, asked, sent, notice },sentnull when no effort went out andnoticelowered,droppedorunchecked, whichever set the effort (the call, the agent, the configuration orLlm:Thinking:Effort). The C# side isILlmProvider.ReportEffort(config)(LlmEffortReport,LlmEffortNotice,ORKEXP005), judged as the call is and forwarded by every decorator. Inside an agent,ctx.llm.reasoning(opts)andctx.llm.capabilities(opts)answer for the call those options name, on the agent's provider, model and effort: the reportcompleteandextractcannot carry. The typings name the levelsEffortLevel. Azure OpenAI's and Ollama'sGenerateStreamingAsyncnow 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 thethinkingswitch 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) byIModelCapabilityRegistry.TryGet(model, provider), then the model's own entry: built in formammouth/gemini-3.7and-3.8,openrouter/google/gemini-3.7and-3.8(always reasoning,minimaltomax, where Google's own API takesnonetohigh) andtogether/zai-org/glm-5.3(unrestricted, where Z.AI's own API refuses the off switch and most efforts); configured asLlm:ModelCapabilities:<provider>/<model>:.... AThinkingvalue 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: falseand warns that the effort is not sent. - Anthropic: "on" sends
thinking: {type: adaptive, display: summarized}; "off" sends the model's own value (between_toolson Sonnet 5.5 up to efforthigh,disabledup toxhighon Sonnet 5 and up tohighelsewhere) and is left out with a warning above that effort. A buffered answer now carries its thinking blocks in thereasoning_contentmetadata, as the stream did. - Declared levels widen to what the provider campaign measured: up to
xhighon 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 fromreasoning_contentorreasoning, the declared field first. The chat-client adapter maps the provider's finish reason ontoChatResponse.FinishReason: Gemini'sMODEL_CONTEXT_WINDOW_EXCEEDEDreads asLength, itsRECITATIONandPROHIBITED_CONTENTasContentFilter. - 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.EffortLevelsForis gone: a dialect writes its thinking fields in the internalWriteReasoningFields.OpenRouterLlmProvider,QwenLlmProviderandZaiLlmProviderkeep theirApplyProviderSpecificOptionsoverride for the public surface; it now only runs the base method.
Migration:
- An effort a listed model refuses is now sent lowered (
mediumreaches GLM-5.3 aslow) 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>:Thinkingand:ReasoningEfforts, or for one provider alone withLlm: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
IModelCapabilityRegistryitself getsTryGet(model, provider)as a default method readingTryGet(model); implement it to serve provider-scoped entries.
Fixed
relational_database_query(andmysql_query,mariadb_query,postgres_query,sqlserver_query) refuses a SELECT whosemax_rowsis below 1 or above 100000, and any query whosetimeout_secondsis below 1 (#372), in a message that names the field and its default. A small model that filled every field sentmax_rows: 0, got no row and a success, and the crew reported made-up figures; atimeout_seconds: 0waited without bound. An Execute or a Scalar query, which never readsmax_rows, still takes any value. A SELECT response carriestruncated, true when the result set held rowsmax_rowsleft out (absent on Execute and Scalar).csv_readerrefuses amax_rowsbelow 1 the same way, itstruncatedis no longer true when the file holds exactlymax_rowsrows, 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_queryandarcadedb_querymax_results,rag_searchtop_k,rag_evalk,structural_searchmax_resultsandmax_files,structural_rewritemax_files,file_readmax_length(where a negative value threw), andcount_patternmax_matches_returnedwheninclude_matchesis true (a negative value was silently read as 0),package_summarymax_exports,dependency_graphmax_cycle_membersandmax_nodes(max_cycleskeeps 0 as its count-only mode, now stated in its schema, and refuses a negative value),flow_tracemax_depth,impact_analysismax_depthandmax_nodes,sub_graphdepthandmax_nodes,flow_tracemax_paths,codebase_searchandstatement_querytop_k,complexity_reporttop_n,symbol_detailmax_children(also refused above 200),symbol_sourcemax_linesandcodebase_mapmax_entries(where 0 was silently read as 1). On a Find,mongodb_queryrefuses alimitbelow 1 (MongoDB reads 0 as "no limit": the whole collection came back) and a negativeskip. A limit ofint.MaxValueoncodebase_search,statement_query,flow_trace,codebase_mapordependency_graphno longer overflows the one-past probe that setstruncated, which asked the store for nothing.A consumer of
Orkeon.Tools.Embeddings.LocalorOrkeon.Scriptinggets the BGE-micro-v2 model (#368). TheSmartComponents.LocalEmbeddingspackage (~40 KB) carries no weights: itsbuild/target downloadsmodel.onnxandvocab.txtfrom huggingface.co on the consumer's first build and copies them toLocalEmbeddingsModel/default/.Orkeon.Tools.Embeddings.Localreferenced SmartComponents, andOrkeon.ScriptingreferencedOrkeon.Tools.Embeddings.Local, with NuGet's default private assets, so each nuspec excludedBuildon that dependency, the target never ran in a consumer, andAddOrkeonLocalEmbeddings()(whichRunnerHostcalls by default) threw at startup. Both references now carryPrivateAssets="none", andscripts/check-package-closure.pyrefuses a lineup project, or a packed nuspec, that hidesbuildon any dependency whose closure reaches that package. The first build of such a consumer needs the network: offline, it fails in the upstreamDownloadFiletask.A provider constructed by hand sends an agent's tools (#367): the constructors without an
IToolCallingStrategy—new OllamaLlmProvider(llm, httpClientFactory)asbootstrap.mdshows,new OpenAILlmProvider(...)and every OpenAI-compatible provider,new AnthropicLlmProvider(...)— left the strategy null and sent notools, so the model wrote the call as text and the task completed without it. They now take the vendor's native strategy, asLlmProviderFactorydoes; the overload that takes a strategy still acceptsnullto keep the text protocol.crew.run()'soutputis the last agent output that was notnull(#369) [breaking]: an object stays an object, the same value as that run'stasks[i].output, where it was the object's CLR type name ("System.Dynamic.ExpandoObject");false,0and""count, and""still means every output wasnull.CrewResult.outputisunknownincrew.d.tsandJsCrewResult.outputanobject?in C#: this edits a member of the 1.0.0 frozen surface (*REMOVED*inPublicAPI.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 readres.outputas astringnarrows it (typeof res.output === "string"); a C# caller ofJsCrew.RunAsynccastsoutput. The REPL'sscript-host.runCrewsummary shows an object output as its JSON.Eight scripting examples print their run (#370):
01–07and14ended with a bareawait crew.run(), soorkeon runprinted{"result": null};01–07now end withglobalThis.result = await crew.run().14-decision-and-whenhands its crew off (globalThis.crew = crew) instead: run procedurally, its decision andwhentasks 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 ofwrite-a-crew-in-typescript.mddoes the same, and theresultrow ofscripting-dsl.mdno longer says aCrewResultcannot be serialised.A script catches the refusals of the
llmnamespace (#364):llm.profile(name)on a profile the host does not offer,llm.model(name)andLlmConfig.with(...)on a value they refuse, andctx.llm.reasoning,ctx.llm.capabilitiesandctx.llm.streamon allm: { profile }the host lacks threw a CLR exception that crossed everytry … catchand ended the command. They now throw anErrorthroughJsHostError.Guard(SCR-25), with the same message and the CLR exception onclr. The awaitedctx.llm.complete,chat,extractanddeciderejected on the same refusal with the wrapped CLRAggregateException, nomessage: a script's mistake (InvalidScriptException) now rejects as anErrortoo. Uncaught, a bridged error reaches the host as its CLR exception:orkeon runreportsInvalidScriptExceptionas the root cause after theJavaScriptExceptionwrapper, where it stopped at the wrapper.A script catches the refusals of the builders and factories too (#364): every method of
agentBuilder(),taskBuilder(),crewBuilder()andtoolBuilder(),stateGraph(...),stateMachine(...),ErrorAction.*and thetestnamespace (a failedtest.assertLlmCalled, a refused mock) threw its CLR exception the same raw way, soagentBuilder().effort(level)on a level read from data could not fall back inside atry. Each goes throughJsHostError.Guardnow: anErrorwith the same message, itsclrTypenaming 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.queueandtopic, and anLlmConfig'scapabilitiesandreasoningfollow the same rule;ctx.memory.*.storeanddeletereject rather than throw;ctx.llm.interrupt()called after the agent's attempt ended does nothing, where it threwObjectDisposedException. The engine's own limits (time, memory, recursion, statement count) still stop the script:Guardlets them through. A C# caller ofnew JsAgentBuilder()still gets the raw exception.[breaking] A C# host that evaluates a script and catches the refusal's CLR type (
InvalidScriptException,DuplicateAgentNameException,AssertionException…) aroundEngine.Evaluatenow gets aJint.Runtime.JavaScriptException: the CLR exception is on theclrproperty of itsError(ex.Error.Get("clr").ToObject()).orkeon runand the error policy's codes unwrap it already (#364).Z.AI's
reasoning_efforttakesxhigh(#356): the campaign of 2026-11-14 found GLM-5.2 accepting it and reasoning at it, betweenhighandmax, where Orkeon lowered it tohigh. 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.greptakes a file aspathand searches it alone, asrg <file>does; aglobgiven beside a file is refused with a message naming the fix, and a missing path saysPath not foundinstead ofDirectory not found; an emptyglobbeside a file counts as absent (#351).Z.AI's GLM-5.3 family takes the efforts
low,highandmaxonly: amediumasked for is lowered tolowwith 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.extractandctx.llm.decideraise it with its status and the vendor's message, andctx.llm.chatanswers with the<undefined-llm:…>markercompleteandactalready gave (#354).ctx.llm.extractsays 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 onlengthormax_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, underfinish_reason(LlmResponseMetadataKeys.FinishReason) on buffered and streamed answers alike:finish_reasonof the OpenAI dialect,stop_reasonof Anthropic,done_reasonof Ollama; Azure's text-only stream aside (#353).In
orkeon-repl, ahuman_inputquestion 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 readsanswer [t8]>(the TUI follows the question throughTuiIntegration.AnswerPromptandQuestionChanged), the answer is taken from the main field or from the task's thread (TuiIntegration.SendToTaskis 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*Bindingclasses (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.tsAPI 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, withReplPaneView.InputandReplPaneView.KeyCaptured; - the constructors of the Tree-sitter tools of
Orkeon.Tools.Analysis(EditBatchTool,NodeEnsureTool,NodeInsertTool,NodeOutlineTool,NodeReadTool,NodeReplaceTool,StructuralRewriteTool,StructuralSearchTool), which took aTreeSitterParserPool.
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).
EmailAccountStatusandDriveAccountStatusgainConfigurationProblems(the registry's problems in order, the section's first; empty when the account resolves) andCredentialProblem(the diagnosis of a resolved account), whichProblemused to merge into one joined string a sentence holding;could not be split back from.EmailAccountStatusalso carries what a blank field resolves to —IncomingHost/Port/Security,OutgoingHost/Port/Security,Username,SaveSentCopy,TokenEndpoint—,DriveAccountStatusitsTokenEndpoint.orkeon email accounts --jsonandorkeon drive accounts --jsonwrite them in snake case, and the text listing oforkeon email accountsshows the connection on one line. A client such as Orkeon Studio checks a configuration throughListAsyncinstead of the internal binder. Additive:Problemkeeps 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.mdand the READMEs link to it.
Changed
- NuGet lock files — every project of
Orkeon.slnoutsideexamples/restores with a committedpackages.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, thedotnet publish -rsteps insideDockerfile.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 thedotnet newtemplates carry no lock file. A package change regenerates the lock files withdotnet 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.mdsupports the latest 1.x minor; the aptstablechannel carries the final releases;opt-in-subsystems.mdmarks experimental APIs instead of a "Beta" status. - The
orkeon-plugintemplate asks for[1.0.0,2.0.0)inplugin.json. - NuGet.org waits for the release — on a
v*tag,publish.ymlpushes to NuGet.org only once therelease.ymlrun of the same tag has succeeded, so a package never precedes installers that failed their smokes.docs.ymlpins 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 anactions/cache(CodeQLactions/cache-poisoning). - The container image follows the GitHub Release —
release.ymlpushesghcr.io/orkeon/orkeonafter the Release, smokes the start of its REPL (ORKEON_ENTRYPOINT=repl) before the push, and labels it with the OCIsource,descriptionandlicensesannotations. - Dependabot watches
tools/scripting-typecheckand the NuGet packages ofexamples/. - 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.Vfsloads 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=replstarts — the REPL of the image exited at once, with no file system mount. Its wrapper now mounts/workspaceread-write by default; a--mounton/workspace, or a--settingsfile declaringOrkeon: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-hostused 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 reportsSERVICE_STOPPEDwith 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-accessalerts — the decision probe and its test double build their dictionaries withImmutableDictionary.CreateRangeinstead ofImmutableDictionary<K,V>.Empty.Add; same contents, same comparer. - The apt publication retries a push refused by git 2.53 —
publish-apt-channel.shtook 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
actprunes stale tool results on the script's word (#327) —ActOptions.onContextPressureruns before a model turn once the loop's messages passcontextPressure.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 earlieractare never offered, since running them again is not harmless. It answerskeep,headordropper 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_budgetreads 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'slib/recap.shandlib/recap.ps1regenerate it after every campaign, together with the same table inllmproviders-test/README.md. orkeon llm proberuns the decision providers —-p typesafe,liquidorkevruns seven decision modes, D1–D7 (noul, choice, score, box on an image, the context-limit refusal, a typed error for an unknown model, cancellation), throughSystemOneDecisionModel, and writes the same JSON as the chat modes. The LLM provider campaign kit takestypesafelike any provider: the catalog gives it its modes, its key variable andjev-previewas 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-preflightto 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>-dirtywhensrc/holds uncommitted changes; the end of a campaign lists the identifiers each provider serves thatlib/served-models.jsondoes not, and those it no longer serves; a report points at the provider's notes inlib/catalog.jsoninstead of copying them. The nightly integration run passes theTYPESAFE_API_KEYrepository secret to the TypeSafe integration tests.
Added — one ctx.llm call on another LLM profile
{ llm: { profile } }runs onectx.llmcall on a host profile (#331) —LlmCallOptions.llm, and soActOptions.llm, takesprofilebesidemodel:ctx.llm.act(brief, { llm: { profile: "small" } })runs that call (andcomplete,chat,stream,extract,decide) on the provider ofLlm:Profiles:small, while the agent keeps its own for its other calls. The rule isllm.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. Amodelbeside the profile is the model within that profile's provider —{ profile, model }isllm.profile(profile, { model }). AnLlmConfigpassed asllm(llm.profile(...).with(...)) is refused, since its temperature and token cap would not apply; an empty profile name is refused;streamchecks 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 nowzai-org/GLM-5.3-Flash.meta-llama/Llama-3.3-70B-Instruct-Turbois no longer serverless: every call to it answersUnable 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 inPublicAPI.Shipped.txt.Before After no model, or meta-llama/Llama-3.3-70B-Instruct-Turboon Togetherzai-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 nowgemini-3.8-flash(wasgemini-3.7-flash, which the vendor labels "previous generation"), andOpenRouterandMammouthfollow 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 inPublicAPI.Shipped.txt.LlmProviderDefaultModels.MiniMax[breaking] is nowMiniMax-M3(wasMiniMax-M2, listed as legacy): 10/0/2 that day, reading the image, whereMiniMax-M2was 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-flashon OpenRouter) to keep the former modelno model on MiniMax, running MiniMax-M2MiniMax-M3; pinModel: MiniMax-M2to keep the former model
Changed — Kimi's and Z.AI's default models [breaking]
LlmProviderDefaultModels.Kimi[breaking] is nowkimi-k3.1-pro(waskimi-k2.6): 12/12 on the LLM campaign of 2026-11-11, wherekimi-k2.6stayed 10/1/1 (M8json_objectfenced in markdown, M10 no cache breakdown). The K3 family fixestemperature(only 1 is allowed) andtop_pand refuses athinkingfield:KimiLlmProvidernow 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 pinskimi-k3.1-proat 131 072 likekimi-k3. The value changes inPublicAPI.Shipped.txt.LlmProviderDefaultModels.Zai[breaking] is nowglm-5.3-flashx(wasglm-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), whereglm-5.2stayed 10/2 (M9 code1210, text only; M10 0 cached). The GLM-5.3 family cannot switch thinking off:ZaiLlmProviderno longer sendsthinking: disabledto it and reports the option instead; an enabled toggle and the effort hint are sent as before. The value changes inPublicAPI.Shipped.txt.Before After no model on Kimi, running kimi-k2.6kimi-k3.1-pro; pinModel: kimi-k2.6to keep the former modelTemperature,TopPorThinking.Enabledset for a K3 modelnot sent, one warning each; pick a kimi-k2model to steer themno model on Z.AI, running glm-5.2glm-5.3-flashx; pinModel: glm-5.2to keep the former modelThinking.Enabled = falseon a GLM-5.3 modelnot sent, one warning; pick glm-5.2to turn reasoning off
Fixed
- The
firefoxtool starts its browser again when the firstsession.newgoes unanswered (#335) — a nightly run saw Firefox 159 announce its WebDriver BiDi endpoint, take the WebSocket, and leavesession.newwithout an answer forCommandTimeoutSeconds; 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 atimeouterror 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 beforeWireCompletionsattached its drain let the registry report no work left, and acompleted()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 wholeLlm:MaxRetriesbudget (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 as400/402and the code-graph embedding provider are out of scope (docs/architecture/llm-providers.md). orkeon llm models -p geminilists usable identifiers — Google's OpenAI-compatible/modelsnames every modelmodels/<id>, a form no configuration writes; the listing now drops the prefix. The LLM campaign kit compared those names with the bare ids oflib/served-models.jsonand 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-carbonandMiniMax-M3.1-Flashsat in their provider'snotesinstead ofcandidateModels, so--candidatesskipped them; they are candidates again, as the README already listed them. reasoning_effort: nonereaches OpenAI again — since the effort levels gainedxhighandmax(#242), a value outsidelow…maxwas "lowered" tolow, and thegpt-5row of the model capability table caughtgpt-5.6-*and omittednonethere: every GPT-5.6 and GPT-6 tier that needsnoneto take function tools on chat/completions answered tools and the messages-array shape with a 400 (LLM campaign of 2026-11-11).LlmThinkingConfig.EffortFornow returns a value outside the levels unchanged, for the vendor to judge, andgpt-5.6has its own unrestricted row.
Fixed — the dotnet tools carry the natives of every desktop runtime
orkeonandorkeon-replrun on Windows and macOS again (#324) — the build trim that drops the native assets of other runtimes also ran whiledotnet packpacked a tool, so the1.0.0-rc.6Orkeon.Scripting.Clipackage, 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.,RecursiveAgentInvocationExceptionRecursive invocation of agent '<name>' is not supported., and a second waiter on an agent's inboxOnly 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]:MaxTokensandMaxCostUsdwere recorded and never applied — no path readIsWithinBudget. Every LLM call now passes throughICostBudgetManager.CheckBudgetat the provider entrance (MeteredLlmProvider, wired for YAML crews,.ork.tsscripts, 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, withBudgetExhaustedException(dimensionTokens, or the newBudgetDimension.Cost;BudgetExhaustedError.dimensionis"cost"in a script). The call that crosses a cap completes; a refused call ends its taskBudgetExhausted(ChatClientAgentLoopno longer folds it intoLlmCallFailed), 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 ownctx.llmcalls are summed under the crew's name. A call outside a crew run is under no budget, andOrkeon:CostTracking:Enabled = falserecords 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). TheTokenBudgetExceededandCostBudgetExceededalerts are now raised when the total reaches the cap, as the refusal is, not only past it.BudgetLimit.MaxCallsPerMinuteandBudgetAlertType.RateLimitExceededare removed [breaking]: the key was read by nothing that limited a call;RateLimitingis the call limiter.Who carries the budget manager:
MeteredLlmProvider.Wrap,ManagerLlmResolverandSequentialCrewOrchestratortake it as an optional last argument, andLlmProviderFactoryOptions.Budgetcarries it to the factory; the host's registrations pass the oneAddOrkeonCostTrackingregisters.Before After DefaultCrewBudget: { MaxCallsPerMinute: 30 }RateLimiting: { GlobalRequestsPerMinute: 30 }a custom ICostBudgetManagerimplements 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.mdandyaml-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'sbudget:caps the autonomous mode only, andSecurity:Audit:RetentionDaysis 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.RunandOrkeon.Studio.Wpfprojects and their test projects, all out ofOrkeon.sln; theorkeon-studio,orkeon-studio-configandorkeon-studio-runexecutables from the MSI, ZIP, tarball and.debinstallers (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 theorkeonCLI 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 .debinstall Orkeon Studio next to the CLIThey 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]:WrittenByStudiois removed, replaced bystring? WriterNote. When it is set,TeamLauncherScriptwrites it as one comment line right after the header of bothrun.cmd(rem) andrun.sh(#); a line break or any control character becomes a space, and inrun.cmda 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 isclient(client://client), no longerstudio. A client that relied on the default passes--client <name>; a crew whoselinks:block namedclient:studiofor the default peer namesclient:client.Team sidecar [breaking]:
ConventionalNames.TeamSidecarFileisteam.json, no longerstudio-team.json.orkeon usecases exportwrites it,orkeon forge renamerenames the team in it andorkeon forge promotekeeps it under that name only: astudio-team.jsonis 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 jsonlanswers atclient://studioit answers at client://client; pass--client studioto 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) andOrkeon.Cli.Abstractions(the interactive-runner contracts) are packed straight from their projects;Orkeon.Cli.TerminalGuiis packed by the newsrc/packaging/Orkeon.Cli.TerminalGuiwrapper and depends onOrkeon, which carries theOrkeon.Constants.Configurationit reads, and onOrkeon.Cli.Abstractions.Orkeon.Scriptingno longer embedsOrkeon.Constants.Cli: it takes a nuspec dependency on it, so no assembly ships in two packages.Orkeon.Hostingstays insideOrkeon.Scripting, and theSuppressVfsCompliance/SuppressConsoleComplianceattributes insideOrkeon(Orkeon.Domain);Orkeon.Compliance.Vfsremains the analyzer alone.scripts/check-package-closure.pycounts a lineup package packed from its own project as carrying its assembly and project closure.Before After Orkeon.ScriptingcarriesOrkeon.Constants.Cli.dllinlib/Orkeon.Scriptingdepends on theOrkeon.Constants.Clipackage, restored with it
Fixed — orkeon run --validate judges a .ork.ts the way orkeon run does (#315, #316)
--validate, procedural scripts (#316): a.ork.tswhose source never assignsglobalThis.crew(a crew published through an imported helper, or run withcrew.run()) runs on the scripting host, and--validateno longer loads it through the declarative loader, whose checks (a task required, nocontextTokenson 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 acrew.run()at its top level — and printsVALIDATION OK: <config> (procedural script: bundled, not run).RunnerOptionsBase.ProceduralScriptcarries 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 oneTS6200line on the copy that says to runorkeon typings.
Removed — the { context } verdict of onToolCall (#307) [breaking]
Scripts,
onToolCall(#307) [breaking]:{ context: string }is no longer anonToolCallverdict.ctx.llm.actaccepted 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 droppedreturn "allow"; to change what the model reads of the result, return{ context }fromonToolResult
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\, soc:\Proj\src\a.tsand git'sC:/proj/src/a.tscome 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 (whatwslpath -wprints), andShellCommandTool.WindowsPaths. Under WSL, unconfined, a Windows program on thePATH(a.exeunder/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,
onToolCallbefore the gate (#303) [breaking]: without the host's invocation pipeline,ctx.llm.actrunsonToolCallfirst 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 returnsa gate denial skips onToolCallonToolCallruns, then the gate deniesTypings,
onToolCallandonToolResult(#305):orkeon typingsdescribes 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, reachesonToolResultas aDENIED: …result. Runorkeon typingsagain 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;PendingInputis 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_requiredon the API). The resume fingerprint reads a task's description and expected output with the kickoff variables in them: a changed--varreruns the task. A task failure no longer marks the sessionFailed(ICheckpointManager.FailSessionAsyncdoes, for the crew), and--resumechecks the liveness of aFailedsession 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 mostOrkeon:Checkpointing:MaxVersionsversions per session (20; zero or negative keeps all), deleting the oldest;JsonFileStateStore's constructor takesmaxVersions.Host API and A2A [breaking]:
/healthzanswers200("status": "stopping") while the host drains; only/readyzanswers503. A second, different answer to a question already handed to a held run answers409 no_pending_input(it was202 recorded, then overwritten); the same answer again answers200 already_answered.POST /runs/{id}/inputanswers409 input_unavailableon a host without checkpoints.RequireMutualTlswithout an ApiKey or Bearer scheme keeps the415/421checks (HostApiOptions.IsUnauthenticatedis replaced byNeedsBrowserGuard). The A2A listener without ApiKey or Bearer refuses aPOSTwithoutContent-Type: application/json(415) and aHostthat does not name it (421), through the newBrowserRequestGuard. 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
Urlthat receives credentials (anAuthtype, or anenv:header) must be https, or http on loopback.HeadersrefusesAccept,Content-Type,Mcp-Session-Id,MCP-Protocol-Version,Mcp-Method,Mcp-NameandLast-Event-ID, and a static header never overwrites one the transport set.prompts/list,prompts/get,resources/list,resources/readand the subscriptions are bounded byCallTimeout, after a device sign-in owed first. A new session is adopted only onceinitializeandnotifications/initializedsucceeded. SSE events and JSON bodies are capped at 16 MiB; the transport's ownHttpClientfollows no redirect and has no client timeout; an empty SSEid:resetsLast-Event-ID; a slowtools/listrelisting no longer ends the watch oflist_changed; a resumed legacy stream relists the tools; stdio answers a serverping; 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_coworkerandask_question_to_coworkeris bound to the tool typeICoworkerDelegationTool(seen throughIToolWrapper), andToolRegistryrefuses any other tool under those names (an MCP server or a plugin could claim them);ToolInvocationPipeline.IsDelegationTool(string)is removed andMemoryRecallTooltakes a new constructor. AnonToolCallthat answers "ask" is first checked underplan,dontAskor 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). Aspawn_agentchild runs under the stricter of its own permission mode and its spawner's, and so do actx.spawnBackgroundchild of it and a latercrew.sendto it (newPermissionModes.Stricter). The fail-closed judge's chunks overlap by a quarter (LlmJudgeGuard.ChunkStep). A relativeTscPathis refused.memory_recallanswers only for a crew with memory. A.dlldropped flat in the plugin directory is refused and recorded (fail fast by default). WithPlugins:ContinueOnError: truea plugin tool registered by type, factory or key that its manifest does not declare, or that fails to build, resolves tonulland is recorded once inIPluginRegistry.Failuresinstead of failing every resolution ofIEnumerable<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_messagecustom 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 anOrkeon:Embeddingssection. A guarded task's held output keeps its order while the hold is released.eval benchreads--baselinebefore it writes its report and refuses a baseline that is the file it writes;eval runreports carry their dataset, andbench/comparerefuse a report without it, of another dataset or another evaluator set, the same file twice, and a--thresholdoutside 0..1.File system (security) [breaking]:
IFileSystemService.ResolveAndValidate(throughFileSystemRegistry.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,linkpointing outside) let a read or a write reach past the mount, sincePathValidatorresolved 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 ofwaiting_for_inputfor the runner, the run histories and the host API.Before After GET /healthzanswers503during a drain200,"status": "stopping";/readyzanswers503a second answer to a held question: 202 recorded409 no_pending_input(200 already_answeredfor the same answer)HostApiOptions.IsUnauthenticatedHostApiOptions.NeedsBrowserGuardan unauthenticated A2A listener reads any POST415withoutContent-Type: application/json,421for a foreignHostMCP:Servers:<name>:Url: http://remote/...withAuthor anenv:headeran https address, or http on loopback MCP:Servers:<name>:Headers:MCP-Protocol-Version(and the other transport headers)refused at configuration IMcpServerExtensionimplements StopAdmitting()tooToolInvocationPipeline.IsDelegationTool(name)CoworkerDelegationand the tool typeICoworkerDelegationToola tool of another kind named delegate_work_to_coworkerorask_question_to_coworkerrefused by ToolRegistrynew JsonFileStateStore(fs, path)keeps every versionmaxVersions(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 runreport withoutdatasetread byeval comparerefused: run it again a host enumerating IBaseToolitself underContinueOnErrorskips null
Fixed — final review of the FWK lots [breaking]
- MCP [breaking]:
orkeon mcp serve --toolsno longer unregisters tools: it setsMCP:Server:AllowedTools, whichMcpServerapplies ontools/listandtools/call, so an excluded tool cannot come back on an upstreamlist_changed. A--crewcall no longer holds a--max-concurrencyslot 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 outsideConnectTimeoutandCallTimeout. Closing a session never signs in and never throws out ofDisposeAsync; 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 sendsnotifications/cancelledwhen a call times out or is cancelled;mcp serveends 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
POSTneedsContent-Type: application/json(415) and theHostheader must name the listener (421)./readyzchecks no longer carry adescription, and their result is cached forOrkeon:Host:Api:ReadinessCacheTtl(3 s). Event streams are capped byOrkeon:Host:Api:MaxEventStreams(64, then 503too_many_streams).POST /runs/{id}/inputwith norequest_idwhile several questions are held answers 409request_id_requiredwith their ids; the same answer posted again answers 200already_answered. The run timeout stops while the run holds on a question, so the hold's own timeout can switch it to suspend. WithOrkeon:RunHistoryoff, a hosted run runs under the idPOST /runsreturned. AddedIPendingInputBroker.HeldRequestIds/WatchHoldsandIRunHistoryReader.ReadEventsAsync(runId, fromSeq, limit, ct). - Run history: a resumed run keeps its
started_atand 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 inFileSystemService); 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.1on every attempt of a retried task.--resume <id> --inputgiven 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;ResumeEnginetakes optionalIRunHistoryReaderandIRunProcessProbe. 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 newphaseandcompleted_countcolumns. 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-/AIzapatterns 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-onlyinvalid_api_key,authentication_errororpermission_erroris refused. The embedding model guard (FWK-25) runs inorkeon run, the other runner commands and the REPL, not only in hosts that start their services (EmbeddingModelGuard.CheckAsync).llm.profile(...)providers answer fromtest.mockLlmunderorkeon run --test. The mock LLM provider warns for each option it cannot honour, andgpt-5-chattakes no reasoning effort. - Guardian, permissions, scripting, plugins, graph [breaking]: under
FailMode: Closedthe LLM judge judges a long text whole in chunks ofMaxContentCharsthat 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 --validateno longer resolvestscfrom the working directory (configuredTscPath, the install directory orPATH); 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 optionalentryType, and a plugin whose assembly holds one plugin type activates that type alone. A decision node with nootherwiseedge 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 withReplayMissException(never a fallback on the network). The two switches and--llm-mockare 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) andLlm:Replay:Cassetteset the same thing for a host written in C#.LlmProviderFactoryputsRecordingLlmProviderorReplayLlmProviderunder the call-mode layer, above the vendor's provider, so the cassette holds the messages that really went over the wire andLlmProviderEntrance.Enterand its callers do not change.ILlmCallObserverwas 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_messagecustom 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,Bearertokens,sk-andAIzakeys,key=/api_key=/token=query values and URL user info are redacted from every line. orkeon eval run --crewtakes--llm-recordand--llm-replaytoo, 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]
LlmProviderFactorytakes a last optionalLlmReplayOptions.LlmSettings.ReadProfilesnow setsLlmConfig.Profileto the profile's name (null stays the default profile). - [breaking]
RunnerVirtualRoots.LlmCassette(/llm-cassette) joinsRunnerVirtualRoots.All: a user mount may not claim it.RunnerMountPlangainsLlmRecordCassetteandLlmReplayCassette;MeteredLlmProvider.Unwraplooks through the cassette decorators.
Added — Mistral, Azure OpenAI and Gemini embeddings, and a guard on the embedding model (FWK-25)
Orkeon:Embeddings:Provideracceptsmistral(MistralEmbeddingProvider,mistral-embed, 1024 dimensions),azure-openai(AzureOpenAIEmbeddingProvider,Modelis the deployment name,Endpointthe resource URL) andgemini(GeminiEmbeddingProvider,gemini-embedding-001, 3072 dimensions, Google's OpenAI-compatible endpoint). They shareOpenAICompatibleEmbeddingProviderBase: answers re-ordered byindex, batches cut atBatchSize, a vector whose length is notDimensionrefused, a 4xx or 5xx raised as anHttpRequestExceptionthat never carries the key.- New
Orkeon:Embeddingskeys:ApiKey(secret),ApiKeyEnvVar,Endpoint,ApiVersionandFingerprintPath.mistralandgeminiswap in their own model and dimensions whenModelandDimensionkeep 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 anOrkeon:Embeddingssection (a host that embedded under the default and then names another provider is refused); with no/workspacemount, or an emptyFingerprintPath, it runs unguarded with a warning. mistralandgeminirefuse, when the provider is built and before any call, aDimensionother than the fixed size ofmistral-embed(1024) orgemini-embedding-001(3072). Embedding calls do not retry;Llm:MaxRetriesis 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 toModelCapabilities(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.LlmProviderCapabilitiesstays per provider.- Audio as input: an audio part sent to a model the table credits with audio input becomes an
input_audiopart (raw bytes,audio/wavoraudio/mpeg) on the OpenAI-compatible family (OpenAI, Gemini). A model without audio, or unknown to the table, is refused with aNotSupportedExceptionnaming 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. LlmProfileRegistryreads 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,ToAIContentsandToChatMessagetake the model id the request is sent to (and an optionalIModelCapabilityRegistry): audio is judged against it. Pass the model of the call.LlmProviderFactory's constructor takes a last optionalIModelCapabilityRegistry.
Added — durable human-in-the-loop (FWK-23) [breaking]
- A question to a human survives the process. With
Orkeon:Checkpointing:Enabled,DurableHumanInputProviderandDurableToolApprovalChannelpersist the question with the run's checkpoint session (SessionState.PendingInput,SessionPhase.WaitingForInput,PendingInputRequest,PendingInputKind; the answers inSessionState.AnsweredInputs), in the store the task checkpoints already use, throughIPendingInputStore(implemented byCheckpointManager). 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(PauseHold|Suspend,HoldTimeout):Holdwaits on anIPendingInputBrokerup toHoldTimeout, whose expiry suspends (the question stays persisted, nothing is refused);Suspendstops the run withRunSuspendedException(final: never retried, never a failed checkpoint). Unset:Holdwhen a person can be asked,Suspendotherwise;orkeon-hostholds 30 minutes,--eventswithout 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 itsrun.finishedcarriesstatus: "waiting_for_input",requestId;RunStatus.WaitingForInputin the run history,waiting_for_inputinorkeon runsand the API.input.neededcarriesrequestId(and is correlated by it);input.givenis also written for a held run's answer.POST /runs/{id}/inputon the host API (pending_inputonGET /runs/{id}), same authorization as the other run routes:200 deliveredto a held run,202 recordedfor a suspended one,409for a second answer or another question. [breaking]orkeon-hostnow registers thehuman_inputtool and its provider (it had none).- A2A:
A2ATaskStatus.InputRequired, serializedinput-requiredby[JsonStringEnumMemberName]on that member alone; a hosted run waiting for input answersinput-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.ToolInvocationPipelinestops the agent's loop when a tool left its run waiting for input;IHumanInputProvider.AsksAPerson(defaulttrue;falsefor 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 (theorkeon runstderr line,GET /runs/{id}, the output of a suspended run); the stored prompt and answer stay in plaintext, whichdocs/reference/limitations.mdsays. - 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 aHostApiServeron its ownHttpListener, off by default.GET /healthz(liveness,system_resourcesonly, never an external service) andGET /readyz(crew_registry,state_store,run_history,memory_provider, andllm_provideronly whenReadinessTagslistsllm) answer without authentication; once the stop has closed admission/readyzanswers503and/healthzstays200("status": "stopping").POST /runs(202,429+Retry-After,404,503,409),GET /runs,GET /runs/{id},GET /runs/{id}/events(SSE withid: seqandLast-Event-ID, else NDJSON) andPOST /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 ofA2ACredentialValidatorandHttpRequestAuthenticatorname the configuration section of their caller (sectionName,A2A:Securityby default). - Idempotency:
idempotency_keyplus a hash of the request. The same key and request answers200on the first run, another request409; two requests at once start one run. Keys live in memory forIdempotencyTtl(24 h) and are written intorun.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, experimentalORKEXP006): the mutual-TLS and Bearer/ApiKey checks ofA2AServer, extracted so the host API enforces the same rules.A2ACredentialValidatortakes the neutral options too.AddOrkeonHealthChecks()(Orkeon.Infrastructure.Telemetry.HealthChecks, tagslive,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.RunAsynctakes a trailingRunIdempotency?. - Health checks always registered [breaking]: they were added by
AddOrkeonTelemetry, so a host without telemetry had none.AddOrkeonInfrastructure()now registers them throughAddOrkeonHealthChecks(), andllm_providercarries the tagllm,memory_providerready,system_resourceslive.
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}underprocess: graphdescribes the graph the crew runs (ADR-018):to: ENDends the run, several edges from onefromare one conditional edge evaluated in the order declared, the first whosewhenholds wins and the edge withoutwhenis the "otherwise". Awhenkeeps 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 bymaxVisits, and on a revisit the latest output and decision win.edgeswithoutnodesgives one node per task, named after it; withoutgraph: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
whenon a task that is no decision, a decision with no edge withoutwhen, two edges withoutwhenfrom 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-levelwhen:ordependencies:beside nodes or edges, and agraph:outsideprocess: graph. The topology faults come fromGraphTopologyValidator, all at once; the export checks them before it writes and writesgraph: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;CheckpointingAgentExecutionServicekeeps the decision outcome in the stored result). Sequential and Parallel still ask their decision tasks again on resume.Domain:
GraphConfiggainsStart,Nodes(GraphNodeConfig) andEdges(GraphEdgeConfig, with an optionalTaskCondition) and the constantGraphConfig.End.GraphProcessStrategybuilds the described graph on the Domain engine, with the default budgets of the implicit graph (visits = sum of1 + retries, transitions = 2 × visits + 1).[breaking] the YAML
graphConfig:block is replaced bygraph:; a crew that still writesgraphConfigis refused at load, pointing tograph:.maxStateVisitsbecomesmaxVisits, and there is nomaxCycles(a bound on cycles ismaxVisits, a retry is the task'sretry:).Before After graphConfig: { circuitBreakerPreset, maxTransitions, maxTotalDurationSeconds }graph: { circuitBreakerPreset, maxTransitions, maxTotalDurationSeconds }graphConfig.maxStateVisitsgraph.maxVisitsCrewYamlConfig.GraphConfig,CrewSettingsYamlConfig.GraphConfig,CrewMappingSettings.GraphConfigGraphGraphYamlConfig.MaxStateVisitsGraphYamlConfig.MaxVisits(the domainGraphConfig.MaxStateVisitskeeps its name)The example
09-experimental/102-graph-orchestrationand the round-trip witnesses are migrated (a newgraph.yamlwitness 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 acrew.ork.tsthroughICrewScriptRunner, configured fromappsettings.json),orkeon-plugin(anIOrkeonPlugin, one tool and theplugin.jsonthat declares it) andorkeon-tool(aToolBase<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 ofsrc/Directory.Build.props.orkeon initkeeps the settings file and does not overlap. Orkeon.Pluginsnow ships inside theOrkeonumbrella 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.Pluginsstill resolves nothing: the umbrella carries it. The assembly and its public API are unchanged.publish.ymlinstalls 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.ToolCallDeltaandToolCallDelta(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 perdelta.tool_callsfragment, Anthropic one when atool_useblock opens and one perinput_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),onToolCallDeltaonctx.llm.act(typings incontext.d.ts), andCrewExecutionEvent.ToolCallfor a streamed run.llm.deltagainsdeltaKind(contenton every text delta,tool_callon a fragment) andtoolCall: {index, id?, name?, argumentsDelta}. The field isdeltaKindand notkind:kindis already the event's own name on the wire. The text delta is otherwise unchanged.- DLP: a host that registered
AddOrkeonDlpgets 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 scriptedact,ScriptingHostPorts.ToolCallDlp, which the hosts fill withToolCallDeltaDlp.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)becomesAddLlmConsoleStreaming(configuration, enabledByDefault = false): the REPL passestrueand so streams to the console unlessOrkeon:Cli:ConsoleStreaming:Enabledisfalse; 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 toolrun_crew_<name>(the crew'sname, lower case): itsinputSchemais one required string property per{placeholder}of the tasks'descriptionandexpectedOutput, its result the crew's final output (a crew that fails is a result withisError), and a call carrying_meta.progressTokengets onenotifications/progressper finished task. Only the crews named are served: no tool takes a path. Each crew is loaded throughCrewRunEntryPoint, in a host of its own, so the budget, the guardian and the permission gate are those oforkeon run;--allow-external-mountsis theorkeon runguard 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), andnotifications/cancelledcancels the running crew. The progresstotalis 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/listandprompts/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. Thepromptscapability is advertised only with--crew.- New public types
IMcpServerExtension,IMcpProgressandMcpRequestException(ORKEXP004). [breaking]McpServer's constructor takes an optionalextensionafterlogger: a caller passing arguments by position pastloggeradapts. --crewfollows 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 --validatetype-checks a.ork.tsby default, so a script with a type error that used to validate now fails with exit1wherevertscis installed.Orkeon:Scripting:Toolchain:TypeCheck: Offis the opt-out; a machine withouttsconly gets a warning.Before After --validateon a.ork.tsnever looked at its types--validaterunstscfirst; a type error isVALIDATION FAILED: type errors, exit1no setting Orkeon:Scripting:Toolchain:TypeCheckValidate(default),Off,Always;Offrestores the old behaviourThe check runs
tscagainst theorkeon.d.tsroll-up this build embeds (test.d.tsincluded), after the MCP servers connect and before the crew loads, on the script and the local modules it imports. A type error printsVALIDATION FAILED: type errors, then<virtual path>:line:col TSxxxx messageper error. The compiler reads and prints physical paths, so it checks a scratch copy (theorkeon-scriptpragma 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,Validatedefault,Always),TscPathandTypeCheckTimeout(60 s).Alwaysalso checks before every run (ERROR: type errors, exit 2).tscis found throughTscPath(the only candidate when set),tools/scripting-typecheck/node_modules/.bin/, thenPATH; nothing is downloaded. Without it,Validatewarns (WARNING: type check skipped: …) and goes on,Alwaysfails (VALIDATION FAILED: type check unavailable). Atscthat 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 doctorgains atsccheck;TscTypeChecker,TscOutputParser,TypeCheckDiagnostic,TscNotFoundExceptionandTypeCheckModejoin the public surface ofOrkeon.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 onLlmJudgeGuard, 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.OutputjoinsInput,ToolExecutionandDelegation, withGuardianPolicy.OutputGuardEnabled(default true).ExecutionOrchestratorruns it on the validated output, before the deliverable, the memory andtask.completed: a block fails the task (GuardianBlocked,Blocked by Guardian (output): <reason>) and nothing is kept. A call that endedLlmCallFailedhas 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;Openlets it in with a warning. Both auditguardian.judge.unavailable. A text longer thanMaxContentChars(8000) is judged whole underClosed, in chunks of that size that overlap by a quarter (any chunk that blocks blocks; beyondLlmJudgeGuard.MaxChunkschunks the text is refused, audited asguardian.judge.truncated); underOpenit 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 asguardian.judge.truncated.While the output phase is guarded, a task's streamed deltas (
llm.delta, the host'sILlmDeltaSink) 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.IsPhaseGuardedtells the orchestrator when.A host that enables the judge without a decision model is refused at start, and so is a
Phasesvalue other thanInputorOutput(ToolExecutionandDelegationare checked by rules).The output phase covers crew tasks (
ExecuteTaskCoreAsync) only: a scriptedctx.llm.actcrosses the input phase but its answer is not judged.[breaking]
DecisionInputGuardis renamedLlmJudgeGuard,DecisionGuardOptionsis merged intoGuardianLlmOptionsand the sectionOrkeon:Decision:Guardmoves toOrkeon: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 DecisionInputGuardLlmJudgeGuardDecisionGuardOptionsGuardianLlmOptions(underGuardianOptions.Llm)Orkeon:Decision:Guard:*Orkeon:Guardian:Llm:*Orkeon:Decision:Guard:FailClosed: false(default)Orkeon:Guardian:Llm:FailMode: OpenOrkeon:Decision:Guard:FailClosed: trueOrkeon: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 toattemptsruns in all (the first included, at least 1, required);backoffMs(default 0) andbackoff(fixed, the default, orexponential, doubling and capped at five minutes) set the wait, taken on the host'sTimeProviderand 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 itsTaskCheckpoint.RetryCount(newretryCountargument ofICheckpointManager.CheckpointAsync) andTaskResult.RetryCountsay 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 declareretry:(refused at load, and byCrewTaskBuilder.Build()). A retry is announced by atask.startedcarryingattempt(additive field of the JSONL protocol, also ontask.completed, where it says which attempt ended the task;TaskStartSnapshot.Attempt,CrewExecutionEvent.Attempt; the strategy's own start is attempt 1). - [breaking]
graphConfig.maxRetryCyclesis removed: a crew that writes it is refused at load as an unknown key, andGraphConfig.MaxRetryCycles,GraphYamlConfig.MaxRetryCyclesandGraphProcessStrategy.MaxRetryCyclesgo with it. The Graph process no longer retries a failed task by itself (CrewGraphState.RetryCounts,MaxRetryCycles,RetryRequestedand 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 declaresretry:. MigrategraphConfig: {maxRetryCycles: 2}toretry: {attempts: 3}on the tasks that need it. The default breaker bounds of a Graph crew count the attempts:maxStateVisitsis the sum over the tasks of1 + retries(retries=attempts - 1),maxTransitionstwice that plus one. The script engine's ownstateGraphmaxRetryCyclesis 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.CheckpointAsyncgains a trailingint 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
fallbackis the recovery); the graph'smaxRetryCyclesis gone and a decision task cannot declareretry:.
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--crewthe crew runs once per case first (its prompt is the case'stask_description), offline on the mock provider with--llm-mock; its final output replacesoutputin the report and the dataset file is never modified.eval bench --runs N --baseline <json>andeval compare a.json b.jsonexit 1 on a regression.RunnerHostbinds theEvaluationsection (AddOrkeonEvaluation(configuration), next to the permission gate) and registersAddOrkeonBenchmarking():Evaluation:EnableLlmJudgewas bound by no shipped binary.orkeonandorkeon-hostnow listEvaluationamong 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 runprints from it, andeval run --crewreads it once per case.--offlinewith--crewrefuses 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.Redactis 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) andReportExporter.ReadComparableReport.
Changed — orkeon rag eval is orkeon eval rag (FWK-09)
- [breaking]
orkeon rag evalis noworkeon eval rag, with the same options and no alias;ragkeepsingestandsearch. Migration: replaceorkeon rag evalwithorkeon eval ragin scripts and CI (rag-eval.ymldoes). The error lines readorkeon eval rag: ....
Added — OAuth for the MCP client: client credentials and device flow (FWK-16)
MCP:Servers:<id>:Auth:Typetakesoauth2-client-credentialsandoauth2-device(the enum namesOAuth2ClientCredentialsandOAuth2Deviceare read too) with the keysTokenUrl,DeviceAuthorizationUrl,ClientId,ClientSecretEnv,ScopesandAudience.OAuthMcpAuthenticatorkeeps the access token in memory only (never on disk), renews it 60 seconds before it expires, and on a401renews it once and sends the request again once; a second401is the answer. Requests refused together share one renewal; theGETstream renews and reopens once in a row.IMcpRequestAuthenticatorgainsHandleUnauthorizedAsync(default: nothing to renew).OAuth2Client(internal toOrkeon.Tools.Abstractions, now visible toOrkeon.Infrastructure) gainsRequestClientCredentialsAsync;OAuthSettingsgainsAudienceandOAuthFlow.ClientCredentials.Auth:Typeis read from a closed list of spellings (the names, andoauth2-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, soMcpStartupnow 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.OAuthTokenSetno longer prints its tokens.- The token endpoint is reached through the named
HttpClientorkeon-mcp-oauth(McpServiceExtensions.OAuthHttpClientName), excluded from the LLM exchange log; it must behttps(loopbackhttpexcepted). The client secret and the tokens are scrubbed from every error and log line. orkeon run,--validate/--list-toolsand the REPL register anIOAuthLoginInteractionthat shows the device code on stderr;orkeon-hostregisters none, so a server inoauth2-deviceis set aside at startup with an error naming it.McpToolProvider's constructor takes a trailingIOAuthLoginInteraction?. 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](andFallbackBudgetSeconds) names the profiles a call moves to when<name>fails in a way a retry cannot cure: a transport error, a 5xx, a 429 onceLlm:MaxRetriesis spent, a timeout. A 4xx, a blocked content and a failure nothing is known about are the answer and move nothing.FallbackLlmProvideris 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 (ErrorTypeFallbackExhausted). Unknown names, self-references and cycles refuseLlmProfileRegistry's construction; a fallback with fewerLlmProviderCapabilitieslogs one warning.LlmFailureClassifieris the one classification, andResiliencePoliciestakes its retryable statuses from it (no change of behaviour). Code:AddOrkeonLlmProfile(name, provider, baseConfig, fallback)andLlmProfileRegistration.Fallback/FallbackBudget. Guide:docs/architecture/llm-providers.md#profile-fallback.llm.fallback(profile,from,to,reason) joinsRunEventKinds(nineteen kinds) and the--eventsstream, written through the newILlmFallbackObserverport; a consumer that does not know the kind ignores it (UnknownEventKindToleranceTestslocks that for the inbound pump).- The provider batch APIs stay out: documented in
docs/reference/limitations.mdwith 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'sstateGraph(...)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 withoutpossibleTargets) is assumed to reach END and any node. [breaking]Compile()now also refuses an orphan and a graph with no path to END, andstateGraph(...)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/routeloop is gone: traces, logs andgraph.node.enteredname the tasks.CrewGraphState.PendingTaskIdsandFailedTaskIdsare removed. The visit bound (graph.maxVisits, the Domain'sMaxStateVisits) counts the visits of one node, not of the whole run. A failing task is retried only by its ownretry:(FWK-15); the graph does not loop a node on itself (FWK-28 removedgraphConfigandmaxRetryCycles).GraphProcessStrategy's constructor takes a trailingIGraphNodeObserver?. graph.node.entered, a new run event kind (node,visit,task?,graph?), is written byorkeon run --events jsonlfor both engines:GraphRunner<TState>.OnNodeEnteredfor a crew,stateGraphfor a script (ScriptingHostPorts.GraphObserver). A reader that does not know the kind ignores it (UnknownEventKindToleranceTests).- On a script's
stateGraph,maxRetryCycles: kandmaxStateVisits: k + 1are the same bound on a graph that loops on one node (GraphBudgetParityTests); a YAML crew bounds a node withgraph.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.
RunStdioAsyncstarts 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/cancelledcancels the request itsrequestIdnames, 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/outputas read-only resources:resources/list(paged,ResourcesPageSize100, opaquenextCursor) andresources/read(textor base64blob, up toMaxResourceBytes1 MiB) onorkeon:///output/<path>, throughIFileSystemServiceand its Read right./workspaceand any other mount are never exposed, no URI or error carries a physical path, and there is noresources/subscribe.McpServerOptionsgainsMaxConcurrency,ExposeOutput,ResourcesPageSizeandMaxResourceBytes.- [breaking]
McpServer's constructors take a requiredIFileSystemServiceafter 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(Enabledfalse in the library andorkeon run, true inorkeon-hostand theorkeon inittemplate;Storejsonlorsqlite;Path/runs;RetentionDays30;MaxRuns1000;IncludeDeltasfalse) keeps the events of every run after it ended, under./.orkeon/runsmounted at/runsas an internal mount next to the checkpoint state (RunnerVirtualRoots.Runs). Thejsonlstore writes<run id>.jsonlandindex.jsonlthrough the VFS, one serialized writer per run; thesqlitestore (SqliteRunEventSink, WAL) holdsrunsandrun_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:showandtailprint the very lines oforkeon run --events jsonl. Exit1on an unknown subcommand, a run absent from the history or a history not enabled.- Ports
IRunEventSinkandIRunHistoryReader(Orkeon.Application.Runs, experimentalORKEXP007) withRunEvent,RunQuery,RunSummary,RunEventWire(the one wire form) andRunHistoryRetention. The observers of a run write to aRunEventPublisher(Orkeon.Hosting), which stamps each event once and fans it out to every destination. The stdout stream of--eventsis unchanged byte for byte, pinned by a golden test. orkeon-hostrecords every hosted run under the run'sExecutionId(opened as the run identity beforerun.started, adopted by the kickoff):run.started(with the daemon's own run id ashostRunId), the task events,errorandrun.finished. Thetool.*,llm.call.*andcost.updatedevents of a hosted run are not published (stated indocs/reference/limitations.md).- A run is recorded with or without
--eventsonceOrkeon:RunHistory:Enabledis true (read from the settings before the host exists, sorun.startedis the history's first event); without--eventsnothing goes to stdout and the run's stdin and logs are left alone.--resume latestand a run whose host cannot be built are not recorded. - A killed run is
orphaned:run.startedis recorded with the pid and host of the writing process, and a run stillrunningwhose process is gone from the same host is readorphanedbylist,showandtail --follow(which ends), and is purgeable. On another host it staysrunning.RunStatusgainsOrphaned;RunSummarygainsPid,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 toorkeon runsor a host that only reads, and the store writes through a file system of its own, so thatrun.finishedoforkeon runis 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, overLogSanitizer);orkeon initwritesOrkeon:RunHistory:Enabledand adds.orkeon/to the.gitignoreof 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, soseqis strictly increasing within a run id andReadEventsAsync(id, fromSeq)andtail --followare unambiguous; the secondrun.startedof the history carriesresumed: true. The stdout stream of each process still counts from 1. - The scripting path reserves
/stateand/runsas the YAML one does (--mount ./d:/runs:rwis refused). - [breaking]
RunEventObserver,ObservedTool(withObservedToolDecorator) andRunEventsLlmCallObservermoved from theorkeonCLI toOrkeon.Hosting(Orkeon.Hosting.Runs, internal) and take anIRunEventSinkinstead of the CLI'sOrkeonEventWriter;ObservedRunContexttakes aRunEventPublisher.OrkeonEventWriterstays for theforge,email,driveandusecasesstreams, now overRunEventWire, and implementsIRunEventSink.RunnerMountPlangainsRunHistoryByDefault;Orkeon.HostingreferencesOrkeon.Constants.Protocol;Orkeon:RunHistoryjoinsSettingsSections.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,orkeonVersionas 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(aPluginLoadException, soPlugins:ContinueOnErrorrecords it) refuses a plugin whose manifest is absent, malformed or incomplete, whose entry assembly is missing, does not matchPlugins:SearchPatternor 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 anIBaseToolitstoolslist does not declare. A refused plugin leaves no registration (the service collection is restored, a throwingConfigureServicesincluded). 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 aPluginManifestExceptionnaming the plugin and a failure of the tool's code aPluginLoadException. [breaking] WithPlugins:ContinueOnError: truesuch a tool is dropped: it resolves tonull, the refusal is recorded once inIPluginRegistry.Failures, and Orkeon's consumers ofIEnumerable<IBaseTool>skip it, so a host that enumeratesIBaseToolitself must skipnull; withfalse(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
.dlldropped flat in the plugin directory is no longer loaded, and a folder holding a.dllwithoutplugin.jsonis refused: move each plugin to<dir>/<name>/with a manifest. Only the plugin the manifest names is configured: the otherIOrkeonPlugintypes of its assembly are constructed (Nameis an instance property) but theirConfigureServicesis never called, and a constructor that throws fails the load.Plugins:SearchPatternfilters the entry assembly's file name.PluginLoadExceptionis no longer sealed;PluginAssemblyCandidategainsManifestandManifestFailure,LoadedPluginAssemblygainsManifest,PluginLoadergains a constructor taking the Orkeon version.
Added — one checkpoint per task and orkeon run --resume (FWK-07)
orkeon run <crew> --resume <id>|latestcontinues 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 needsOrkeon:Checkpointing:Enabled=true, and is refused with--validate,--list-tools, a procedural.ork.ts, and with--eventswhen the id islatest.KickoffOptions.Resumeis 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 ofIAgentExecutionService, 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 latesttakes the most recent run of the crew that is not completed, and refuses one still markedRunning(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.ExecutionIdcarries the id of the run.task.completedcarriesresumedin every mode.TaskResult<TOutput>gainsResumed,TokensUsed,PromptTokens,CompletionTokensandIterationsUsed;ResumeResult.Refusal,ResumePlan.ResumedTaskIdsandRunnerOptionsBase.WorkingDirectoryare new, andCheckpointingAgentExecutionServicetakes an optionalITaskRepository.TaskResult.Resumed,TaskExecutionSnapshot.Resumed,ResumeOptions.ExecutionId,ICrewTask.KeyandRunOptionNames.Resumeare 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.StartSessionAsynccontinues 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.ResumeFromIndexis removed: a resume is keyed by task, an index does not survive the non-linear modes.RunScope.Resumeis aResumePlan?(the session and the outputs it completed), no longer astring?.SequentialCrewOrchestrator's constructor takes a trailingIResumeEngine?, andRunnerRunIdentity.Ambientis gone. A run whose crew did not succeed now ends its sessionFailed(resumable); it wasCompleted.
Added — cognitive memory wired into the runners (FWK-04)
Orkeon:CognitiveMemory:Enabled(false) wiresICognitiveMemoryServiceintoorkeon,orkeon-hostandorkeon-repl. A crew withmemory: truethen recalls by composite score (similarity, recency, importance; floorsOrkeon:CrewMemory:MinCompositeScore, 0.4, distinct fromMinScore, andMinSemanticScore, 0.5: relevance is required apart, a fresh memory otherwise reaches the composite floor alone), stores throughRememberAsync(an analysis that fails stores the memory with the default importance and logsmemory.analysis.degraded), holds the newmemory_recall(query, limit)tool (injected only withmemory: true), and consolidates its memory when a run ends, whatever its outcome, underOrkeon:CrewMemory:ConsolidateOnRunEnd(false). No YAML key: the analysis cost is the operator's. Without the setting nothing changes.Orkeon:CognitiveMemory:Profilenames 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]
ICognitiveMemoryServiceis registered as a singleton (was scoped): resolve it from the root provider.MemoryCoordinator's constructor takes a trailingICognitiveMemoryService? cognitiveMemory, andTaskToolbelt.Composea trailingbool memoryEnabled: a caller that built either by hand recompiles.IMemoryCoordinator.FinishRunAsyncis a default interface method.
Added — a browser for the agents
firefox, a built-in tool ofOrkeon.Tools.Web: the Firefox installed on the machine, driven over WebDriver BiDi on a WebSocket — no driver, no vendor package, no browser download. Oneactionargument:navigate,back,snapshot,read,find,search,click,type,press,evaluate,screenshot,tabs,new_tab,switch_tab,close_tab,close; the reading actions pass inplanmode,screenshotis an edit, the others executions. A page is read as a semantic graph (PageOutlineMapperinOrkeon.Analysis, the newUniversalNodeKind.Control) in aRaggableTreeof its own, whose node ids (p2#7) the next actions take;searchembeds 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 unlessOrkeon:Tools:Firefox:Profilenames one of the host's Firefox (AllowedProfilesare the ones an agent may ask for with theprofileargument,DeniedProfilesthe ones no browser ever starts on);SharedInstancegives the host one browser per profile, shared between the runs, each driving tabs of its own (tabs,new_tab,switch_tab,close_tab);Lifetime: hostkeeps 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 - untilclose, 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 unlessOrkeon:Tools:Firefox:Headlessis 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,tabsanddialogsare 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]
SseMcpTransportis renamedStreamableHttpMcpTransport(no alias) and is a real Streamable HTTP client (FWK-17): an SSE answer is read event by event instead of keeping its lastdata:, theMcp-Session-Idis kept and sent back, a 404 on a session replays the initialize handshake, a legacy session opens aGETstream resumed withLast-Event-ID, and a request of the server is answered-32601. Its constructor takes a trailingTimeProvider.McpServerConfig.Transportkeeps the valueSse, which means Streamable HTTP; the HTTP+SSE transport of 2024-11-05 with a separate endpoint is not supported.McpClientgainsListenAsync(subscriptions/listen),SubscribeResourceAsyncandUnsubscribeResourceAsync;McpToolProviderkeeps the listen stream open on a modern HTTP server and gainsSubscribeResourceAsyncandReadResourceAsync(cached for subscribed resources, invalidated byresources/updated);McpCapabilityInfogainsSubscribe. The nightly runsMcpReferenceServerInteropTestsagainstserver-everything.McpClient.ReadResourceAsyncreturnsMcpResourceReadResult(the spec'scontentsarray) instead ofMcpToolCallResult, which read an emptycontentfrom a real server;resources/readnow sendsMcp-Name(the uri) as the 2026-07-28 revision requires.McpToolProvideralso gainsUnsubscribeResourceAsync; apingof the server is answered with an empty result on HTTP. Migration: replaceSseMcpTransportbyStreamableHttpMcpTransport, and readContentsinstead ofContentafter a resource read.
Added — authentication, tool filter and call timeout for MCP servers (FWK-03)
MCP:Servers:<id>gainsAuth(None,Bearer,Basic, credentials read from the environment variables it names on every request),Headers(literal orenv:VAR; anAuthorizationheader is refused),Tools:Allow/Tools:Deny(applied before registration; an entry that matches no tool warns) plusCallTimeout(60 s; expiry ends the call as a typed tool error,McpCallTimeoutException) andConnectTimeout(30 s, the handshake and tool listing of any caller). Non-positive timeouts, andAuthorHeaderson aStdioserver, 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 sharedorkeon-mcpclient, excluded from the LLM exchange log.- [breaking]
McpServerConfiggainsHeaders,Auth,Tools,CallTimeoutandConnectTimeout; the constructors ofMcpToolProvider(IHttpClientFactory?),StreamableHttpMcpTransport(IMcpRequestAuthenticator?, namedSseMcpTransportuntil FWK-17) andMcpToolAdapter(TimeSpan? callTimeout) each take one more optional parameter, so the three signatures change;McpServerStatusgainsUnmatchedToolFilters.
Changed — one run identity and a configurable checkpoint store (FWK-01) [breaking]
- A run has one identifier, an
ExecutionId: the checkpoint session id, thecorrelationIdof the eventsorkeon run --eventswrites, and the idKickoffAsyncNoWaitreturns (it used to create one, then letKickoffAsynccreate another).KickoffOptions.ExecutionId,CrewKeyandResumecarry what the caller decides, through the newICrewOrchestrationService.KickoffAsync(crewId, input, options, ct);IRunScope(AsyncLocalRunScope, registered byAddOrkeonInfrastructure) shows the run in flight to decorators and observers. - [breaking]
ICheckpointManager.StartSessionAsync(string crewId)isStartSessionAsync(ExecutionId sessionId, string crewKey): the session id is the run's id, no longer a newGuid.ICrewOrchestrationServicehas a new member (the kickoff with options): implementers add it. - [breaking]
SessionState.CrewIdandSessionSummary.CrewIdareCrewKey: 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.GetLatestCheckpointAsyncandIResumeEnginefilter on it. The SQLite and PostgreSQL columncrew_idiscrew_key, with no migration: a database written by an earlier build is not read. - [breaking]
AddOrkeonSqliteCheckpointingandAddOrkeonPostgresCheckpointingreplace the registeredIStateStore(Replace) instead of leaving the in-memory store in place afterAddOrkeonInfrastructure(TryAdd).ICheckpointManagerandIResumeEnginestayTryAdd. Orkeon:Checkpointing(Enabled,Storememory, json, sqlite or postgres,Path,ConnectionString) chooses the store:AddOrkeonCheckpointing(IConfiguration).orkeon runandorkeon-hostread it, andOrkeon:ExecutionState:Persistencewith it;jsonandsqlitewrite under./.orkeon/state, mounted at/state(RunnerVirtualRoots.State).OrkeonEventWriterfillscorrelationIdfromIRunScopewhen an event names none (an additive field of the JSONL envelope):orkeon run --eventsopens the run's identity beforerun.started, so every line of the stream, the lifecycle ones included, carries the id of the checkpoint session.- [breaking]
ICrewOrchestrationServicegains two members:KickoffAsync(crewId, input, options, ct)andKickoffStreamingAsync(crewId, input, options, ct). RunnerMountPlan.WorkingDirectorynames the folder./.orkeon/stateis resolved against (the process's by default); the host plans/stateitself, whichever command builds it, and the store reaches it through the privileged view of the file system (an internal mount).Orkeon:Checkpointing:StorewithoutEnabled: trueis ignored, with a warning at the host's start.- Not unified yet: the A2A task id and the API's (
StateStoreA2ATaskStorekeeps 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]
ToolInvocationPipelineconsults theIPermissionGate(FWK-06), after the Guardian, for the calls of an agent: YAML crews are gated as scripts are, onceOrkeon:Security:PermissionGate:Enabledis true. It is the one place the gate is consulted for a call:ctx.llm.actno 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: anonToolCallthat answersaskgoes 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 takespermissionGate,approvalChannelanddefaultMode(a constructor change);ToolInvocationCallercarriesPermissionModeandGateExempt. Anaskwith no approval channel is a refusal. The delegation tools,orkeon mcp serveand the forge's assistant are not put to the gate.permissionModeon a YAML agent (default,acceptEdits,bypassPermissions,plan,dontAsk),AgentBuilder.PermissionMode,Agent.PermissionModeand theOrkeon.Domain.Security.PermissionModeenum;Orkeon:Security:PermissionGate:DefaultModefor an agent that declares none.
Added — running a crew without a model
Provider: mock: an LLM profile (or theLlmsection) written"Provider": "mock", "Responses": "<virtual path>"answers from a JSONL file of{match, regex?, content, toolCalls?}lines throughJsonlMockLlmProvider(Orkeon.Infrastructure.LLMs.Mock): offline, deterministic, streamed as one chunk, tool calls rendered in the OpenAI response shape.LlmProviderKeys.Mockis not one of the sixteen providers.Providertakes 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}incontentfor 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.LlmMockjoinsRunnerVirtualRoots.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 --testbinds the globaltest(test.mockLlm,test.mockTool,test.assertLlmCalled,test.assertToolCalled) in a procedural script, over aTestOverrideLlmProviderthat wraps the configured provider: an expectation oftest.mockLlmis served before the profile. Without the flag there is notest; on a YAML crew, a crew directory, a declarative script or--validatethe flag is refused (exit1) rather than ignored.TestOverrideLlmProviderkeeps the streaming of the configured provider.Typings/test.d.tsdeclares it, and the typings parity test covers it.JsEngineFactory.EnableTestNamespaceis the switch.MockLlmProvider.When(string | Regex).Respond(...)andMockTool.When(string | Regex).Respond(...): a public builder for .NET tests;AddExpectationstays internal.scripts/validate-all-examples.sh --llm-mockruns the examples that have anexamples/mock-responses/<example>.jsonl— one per orchestration mode: sequential, parallel, hierarchical, consensual, graph and autonomous (examples/autonomous-budget) — and keeps--validatefor the others.
Changed — the LLM provider factory takes the file system [breaking]
- [breaking]
LlmProviderFactory's constructor takes anIFileSystemServiceas 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:ProviderandLlm:Responses(and the same keys of each profile) are now read;Providerother thanmockis refused at load.
Added — notifications, pagination and prompts for the MCP client (FWK-10)
tools/list,resources/listandprompts/listfollownextCursor(100 pages at most, thenInvalidOperationException); a server that paginates is no longer truncated.- A frame of the server without an
idreachesIMcpTransport.Notificationsinstead 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:McpToolProviderlists 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 warningmcp.tool.rejected. A task in progress keeps its tools.McpClient.ListPromptsAsyncandGetPromptAsync,McpToolProvider.ListPromptsAsyncandGetPromptAsync, and the built-in toolmcp_prompt_get(Orkeon.Infrastructure, 124 tool classes), registered byAddOrkeonMcp.IToolRegistrygainsReplaceToolAsync(current, replacement), an atomic swap (a default implementation unregisters then registers);ToolRegistryoverrides it.- [breaking]
IMcpTransport(experimental,ORKEXP004) gainsNotifications;McpToolProvidertakes an optionalTimeProvideras 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.jsonsettings fallback is removed:RunnerSettings.ResolveSettingsPathwalks up from the crew directory looking only forappsettings/appsettings.json. Move a_shared/appsettings.jsontoappsettings/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:PrometheusEndpointand theRaggableTreekeysExclude,RootAlias,IndexMode,EnrichWithLlm,IncludeStatementsfall 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 underOrkeon:Guardian:Llm, send telemetry to an OTLP collector (Telemetry:OtlpEndpoint), start an MCP server withorkeon mcp serve, pass index options to eachindex_codebasecall. - [breaking]
AddOrkeonMcpandAddOrkeonMcpServerno longer throw a dedicatedInvalidOperationExceptionforMCP:EnableServer, norAddOrkeonTelemetryforTelemetry: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,Gpt35TurboandGpt35TurboWithSecretare removed:LlmConfig.Create(model, apiKey)with the model named. - [breaking]
ToolSchemaGenerator.GenerateReturns(both overloads) is removed:GenerateReturnsWithTypes<T>().Returns. - [breaking]
AgentSelectionResult.SelectedAgentandScoreare removed:SelectedAgentIdandConfidenceScore.CrewInput.Parametersis removed:CrewInput.Variables. - [breaking]
Deconstructis removed fromLlmMetadata,TypedTaskExecutionContext,AgentStepContextandStepMetadata: read the properties by name. - [breaking]
Orkeon.Domain.Common.Identity<T>is removed: theEntityId<T>ids (AgentId,TaskId, ...). - [breaking]
ToolBase.ExecuteCoreAsync(string, CancellationToken)is removed: overrideExecuteCoreAsync(ProtocolToolCallRequest, CancellationToken);ExecuteAsync(string)converts the string into a protocol call. - [breaking]
WebPageLoaderno longer accepts thewebkind:url. - [breaking] The
[Obsolete]ProcessIsolationSandboxalias is removed:HostProcessRunner(its file is nowHostProcessRunner.cs). - [breaking] The
IPerformanceMetricsport,PerformanceMetricsCollectorand their records (PerformanceReport,AgentMetrics,ToolMetrics,LlmMetrics,ProviderMetrics,MemoryMetrics,OperationMetrics,DurationStatistics) are removed, with theAgentExecutionServiceconstructor parameter that took the port. Metrics come from OpenTelemetry only. - [breaking] The flat
AgentStep.CreateSuccess(output, structuredOutput, agentId, taskId, action, input, toolsUsed, context), the flatExecutionMetadataconstructor and the flatExecutionSnapshotconstructor are removed: passAgentStepInfo,ExecutionTimingInfo+ExecutionIdentityInfo, andExecutionStatusInfo+ExecutionTiming. - [breaking]
Application.Execution.TaskOutput.RawOutputis removed:Content.FunctionCallInfoandLlmMessage.FunctionCallInfoare removed:LlmMessage.RawToolCalls. - [breaking]
TokenBudgetTracker.EstimateCost(int, int, string)is removed:EstimateCost(prompt, completion, model, registry)(registry: nullkeeps the built-in table). - [breaking]
IncrementalReindexTooltakes anIndexFreshnessService, now required; the constructor with a store and a builder factory, and its fallback path, are removed. - [breaking]
IncrementalReindexRequestlosesLanguagesandEnrichWithLlm(languagesandenrich_with_llmofincremental_reindex): only the removed fallback path read them; a refresh takesroot_pathwithchanged_filesorfrom_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 inJsonComponentSerializerare removed, with its coercions (a scalar read as a one-element array,nullas 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 CS0618lines (no obsolete member behind them) are removed from the LLM providers, theorkeonCLI commands and the tests.
Analysis
- [breaking]
InlineFqnValidationResultloses its positional constructor(ExtractedFqns, UnknownFqns): the object initializer. - [breaking]
edge_kindsofdependency_graph,sub_graph,flow_traceandedge_listno longer falls back toEdgeKindmember names:extendsandimplementsare canonical workflow names (GraphKindNames.EdgeKindNamesiscontains, calls, imports, inherits, extends, implements, tests, documents, project_depends), so a script sends back theedges[].kindit read;ProjectDependsis refused as an unknown name, sendproject_depends. Names stay case-insensitive. The tool schemas andtools.generated.d.tsdrop the "Legacy enum names … are still accepted" sentence. - [breaking]
Orkeon.Analysis.Abstractions.Interfaces.IEmbeddingProvidergainsstring? ModelName(defaultnull): an implementation overrides it to have its model recorded (see Fixed below). Theindex_codebasecache key carries that model name: an existing cache entry misses once and is rebuilt.
Scripting
orkeon-cli.d.tsno longer announcesaborted/throwIfAbortedaliases onCommandSignal: 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({...})fillsContext["expect_schema"], read by the hierarchical manager prompt),ToolsNamespaceBinding, the esbuild probe (the "main-package" layoutnode_modules/esbuild/bin, in its error message and three test names too),ScriptCommandLoaderOptionsand its registration.
Docs and tooling
CONTRIBUTING.md(andCONTRIBUTING.fr.md): the deprecation window applies from 1.0; during the1.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
apiKeyparameter ofLlmConfig(kept;ApiKeySecretNameis preferred), the constructors ofHttpToolBase,HttpToolBase<TRequest, TResponse>andHttpApiToolthat take noIUrlValidator(the fail-closed default SSRF guard applies), thedecisionreranker (notypesafealias), the S107 pragmas of the flatCrew,Agent,TaskOutputandMemoryMetadataforms,CrewInput's positional constructor, the defaults ofdocs/reference/opt-in-subsystems.md, and the flatcrew.yaml+agents.yaml+tasks.yamltriplet, a supported layoutYamlCrewExporterwrites. scripts/lint-example-configs.py: the deadrunnerparameter ofmanifest_from_list_toolsis 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.AgentIdand the agent ids ofCreateCrewCommandaccept a ULID, the form everyAgentIdprints, and still a GUID:CreateTaskCommandValidatorandCreateCrewCommandValidatorrefused ULIDs, and the crew validator letGuid.Emptythrough to a handler that threw. A ULID is accepted only when it is Crockford base32 that fits 128 bits (Ulid.TryParsedecodes any 26 characters into some id); the validators' error readsis not a valid agent id (a ULID or a GUID).- The embedding model an index records (
embedding_stats.modelofindex_codebase) is the one the embedding provider names (IEmbeddingProvider.ModelName: the OpenAI, Ollama and local providers return theirs,LocalEmbeddingProvider.EmbeddedModelName=bge-micro-v2, or theModelPathwhen set), no longer the request'sembedding_modeldefaulttext-embedding-3-smallwhile the host embeds locally withbge-micro-v2; the request's value is recorded only when the provider names none. - The RAG ingestion pipeline records the same name:
AnalysisEmbeddingProviderAdaptertakes the inner provider'sModelNamebefore itsanalysis-embeddingdefault, so a local index built throughOrkeon.Ragno longer recordsanalysis-embeddingforbge-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, againstOrkeon:Cli:Session:ContextWindowTokens(200000when unset, as fortoken_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'sctx.promptreads. - Palettes: the setting
Orkeon:Cli:Tui:Theme(Dark,Light,None),NO_COLORwhen it is left out, andctx.setTheme/ctx.themeto 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.writeBlockmarkdown 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_fileorfile_writeshows 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.writeBlockpatches 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 implementingIReplCommandCatalog.
Added — a selection panel for ctx.prompt and tool approvals
- In the split-pane console,
ctx.promptopens a panel forselectandconfirmin 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. Aconfirmopens 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,cancellableanddetaileddescribe the panel.ctx.interactivesays whether it opens: the plain console and a replay keep the numbered lines and read the same answers. - A
selectleft with Esc answersnull, soPromptResultnow includesnull[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,sorn) 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
runCrewAsynctakes{ onMain: true }: in the split-pane console the crew writes its text, calls, diffs and approvals on themainscreen, 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 nocompleted,Esc Escreaches it whatever was typed since, and a second such crew launched meanwhile is an ordinary task.- The
mainrow 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 tomain.
Changed — installing the REPL from source is documented, and the script says how
install-from-sourcerun with the default set on Windows or macOS now ends by saying that-AppSet full/--app-set fulladdsorkeon-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_writeshowed asfilewrite.
Fixed — a scripted command may wait longer than ten seconds
- A
defineCommandhandler still pending after ten seconds failed with Jint's promise timeout while it kept running. When it was waiting onctx.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 theExecutionTimeoutclock stops while a prompt waits for its answer. - With that bound gone, a
completedwhose promise never settles keeps its file's engine: cancelling the invocation that waits for that engine (Esc Esc, Ctrl+C) ends the wait, andctx.signalin acompletedfollows 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 offersIStreamConsole.WriteStream, whichConsoleLlmDeltaSinkprefers overWrite: a token is never taken for a prompt.Writeand its heuristic stay for what the runner writes. ctx.llm.actopens oneexecute_toolspan on theOrkeon.Scriptingsource per call the model makes, so the activity sentence (Read 1 file, edited 2 files) and the status line'stoolstate cover a prompt's turn, which they missed. Tool spans now carry their tags from their start, whichToolActivityAggregator.HasOpenToolCallneeds: it never read true.
Fixed — orkeon typings writes an orkeon.d.ts that TypeScript parses (#288)
- The build copies
Typings/*.d.tsinto the roll-up byte for byte (an inline MSBuild task instead ofReadLinesFromFile/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, andscripts/check-scripting-typings.shtypechecks the built roll-up with tsc (--rollupin 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_searchandrag_ingestopen 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 ofshell_command).file_readno longer sends.emlfiles toemail_parser;edit_filesays thatreplace_alllifts the "exactly once" rule;rag_searchno longer offers'raggable-tree'as a collection, so a code question goes tocodebase_searchand never to RAG. shell_command.actionpublishes its values (run,start_job,job_status,job_tail) as an enum.docs/tools/inventory.mdfollows 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,totaland the counts before its bulky collections, andmermaid_flowchart/dotlast: the pipeline cuts a result from the end, so the model kept reading a cutdependency_graphoredge_listas a complete one. A test serialisesdependency_graphandsub_graphthrough the real tool path and asserts the key order. include_mermaiddefaults to false ondependency_graphandsub_graph[breaking]: the rendering is for a human reader and doubled the result; a caller that wants it passesinclude_mermaid: true.AgentDefaults.MaxToolResultLengthOverridesboundsdependency_graph,sub_graph,edge_list,flow_trace,impact_analysis,codebase_map,package_summary,symbol_detail,codebase_search,structural_search,structural_rewriteandaffected_testsat 12 000 characters (AgentDefaults.AnalysisToolResultLength) instead of 4 000.directory_readreturns 200 entries by default instead of 500 [breaking].truncatedmeans "more results exist than were returned" everywhere:codebase_search,flow_trace,statement_query,dependency_graphandcodebase_mapsaid true on a page that was exactly full; they now ask the store for one item past the bound. The rule is indocs/tools/new-tool-pattern.md.
Fixed — every analysis tool publishes its parameter schema, and the typings are rendered from it (#282)
ToolSchemaGeneratorkeeps the request properties carrying[FieldSchema]alone, and the analysis DTOs carried almost none: the model receivedsub_graphwithoutseedsnordirection,symbol_detailwithoutexpand,codebase_searchwithoutquery,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) andstructural_rewritewith no parameter at all;session_store,session_snipandprogress_reportwere 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_pathandlabelare 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 fromSchema.Parameters; no allowlist.StructuralToolSchemaTestscoversstructural_search,structural_rewrite,affected_tests,edge_list,sub_graphandsymbol_detail. Typings/tools.generated.d.tsis 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;| nullis 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)
extracttook a prompt string alone, appended its JSON instruction to it and always asked forjson_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 formschattakes), the caller's turns sent in order throughChatAsync. The newsystemoption goes first as asystemmessage 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 setsLlmResponseFormat.JsonSchema("extract", schema, strict: false)(a hand-written schema rarely carries theadditionalProperties: falseand fullrequireda strict one needs, which OpenAI would refuse); otherwisejson_objectas before. An explicitresponseFormaton the call still wins,"text"included. Usage is metered underextractas before. chat({ messages: [...] })sent an empty conversation: the object form is read as the bare array is. Typings:MessageList,ExtractOptions, overloads ofchatandextract.
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 inInMemoryCategoryMemoryStoreand died with the process. NewFileCategoryMemoryStorekeeps 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 sectionOrkeon:Cli:Memory(Persist, default off;RootDirectory, must not be blank whenPersistis on), bound and judged at the host's start;AddOrkeonSessionToolsresolves the file store whenPersistis on and the in-memory one otherwise; the REPL turnsPersiston when the key is absent, as it does for the session. memory_storegainsreplace(id,content: retires a stale fact in place, same id and category,created_atset again) andlisttakesnewest_first(created_atdescending, then id descending). The descriptions say thataddreturnsidand that every entry carriescreated_at.- [breaking]
ICategoryMemoryStore.ListAsynctakes(string? category, bool newestFirst, CancellationToken ct)and the port gainsReplaceAsync(int id, string content, CancellationToken ct) -> bool;InMemoryCategoryMemoryStorefollows.MemoryEntryserialises 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_snipdocumentedretain_countas 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 ausermessage and owns thetool,assistantandnotemessages that follow it. The head message is still kept on its own; a buffer holding fewer turns than asked, or nousermessage, is left untouched;retain_count: 0keeps the head alone. Thetruncateoperation ofsession_storefollows the same rule.- The response gains
kept_from(index, in the buffer before the cut, of the first message kept after the head, always ausermessage;-1when nothing was removed or the head alone was kept). - [breaking]
ISessionBufferService.Truncate(int retainTurns)answers aSessionTruncationrecord (RemovedCount,KeptFromIndex) instead of anint;InMemorySessionBufferService,FileSessionBufferServiceand 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 ofAddRaggableTreeTools):edge_kinds(required, workflow names), optionalroot_fqn,cursorandpage_size(default 200, at most 1000). It walks the whole index, unlikedependency_graphwhosemax_nodesbounds the nodes before the edges are collected, and answersedges: [{ from, to, kind, from_id, to_id }](ends as FQNs and node ids),next_cursor(null on the last page) andtotal. Edges come in a stable order (source FQN, target FQN, kind, edge id) and the cursor resumes after the last edge returned.root_fqnkeeps the edges with an end at or under one node, resolved ascodebase_mapanddependency_graphresolve theirs: a package or a file by path, a type or a member by FQN with a boundary (Orkeon.Domainno longer matchesOrkeon.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.IRaggableStoregainsListEdgesAsync(EdgeListQuery, CancellationToken), answered with anEdgeListPage, andNodeQuerygainsRootFqnwith the same meaning, socodebase_mapanddependency_graphfilter by root inside the store and their page andtruncateddescribe the root's subset (a root whose nodes lay past the first page answered nothing).SemanticSearchAsyncanswers aSemanticSearchResult(Hits,PreFilterCapped) instead of a hit list, socodebase_searchreads 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
Implementstoward an interface andExtendstoward a class, as Java and TypeScript already did. Every C# base was anExtendsedge: a query forimplementsover C# code now finds them, and one forextendsno 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#
usingof 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_detailwithexpand: "inheritance"addsderived_byandimplemented_by, the types that extend or implement the symbol, and givesextendsandimplementsas FQNs (they were node ids).- [breaking]
flow_trace.edge_kindsis a list of workflow names read byGraphKindNames.ParseEdgeKinds, asdependency_graphandsub_graphread theirs:inheritsfollows bothextendsandimplements, an unknown name is refused naming it, an empty list followscalls.FlowTraceRequest.EdgeKindsis anImmutableArray<string>(wasImmutableArray<EdgeKind>); a legacy enum name (Calls) is still read. codebase_searchsetstruncatedalso when its kind or language prefilter matched more than the 1000 nodes it ranks: the hits came from a cut candidate set andtruncatedstayed false.
Fixed — the console copies a keyboard selection and takes the terminal's paste over SSH
- Over SSH (the
dotnetdriver, 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 toCtrl+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+Cnow 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=1also traces every modified key and bracketed paste the driver delivers, the focused view atCtrl+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
TextViewcontext 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 itsCommand.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.contextis seeded as a user message of its own, aftersystemand before the prompt. The prompt stays the last user message, the request theguardandroutestages 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).systemno longer has to carry a context that changes every turn, and keeps its prompt-cache hit.LlmJudgeGuardstill 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[].kindofdependency_graphandsub_graphwas a number (1,3) while the typings saystring: 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); forEdgeKindthese are the namesedge_kindstakes. A value that is itself a named member keeps that name (ExpandModes.Allisall).- 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_detailnow takesexpand: "members"or"callers, callees", which failed with aJsonException; an unknown name lists the valid ones. - An
ImmutableArray<EdgeKind>writes the same names (project_depends, wasprojectDepends). GraphCycle.EdgeKind(cycles[].edge_kind) is anEdgeKindagain, not astring; on the wireimports, calls(wasImports, Calls). Persisted RaggableTree graphs are untouched:RaggableTreeSerializerkeeps 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 onlymetrics.cycle_countreached 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_countkeeps a cycle's size andcycles_truncatedsays whether either cap cut the list.metrics.cycle_countkeeps the full count. - The tool description and the
GraphMetricsdoc comment say which figures cover what:cyclesandcycle_countthe whole scope,node_countandedge_countthe nodes returned (selected bymax_nodes,root_fqnandnode_kinds). - The cycles follow the edge kinds the graph follows. An empty
edge_kindsdrewedgesover imports but searched cycles over every kind and labelled themCalls; both now use imports. A cycle'sedge_kindnames 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
verifystage 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;finalis the default. - The
guardandverifyquestions carryinstructionswith 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_riskanddecision_reason;DecisionBlockedException.FromResponsereads them, and a text stream throws that exception instead of anInvalidOperationException[breaking]. A script receives a block as aDecisionBlockedError(errorType,profile,stage,risk,reason;onErrorcodedecision_blocked) fromcomplete,chat,extract,decide,actandstream, never as an<undefined-llm:…>marker; uncaught, it fails the run with theDecisionBlockedException(#269).JsLlmFacade.complete,chat,extractanddecideare now bridged JS functions (JsValue) [breaking]: a C# caller usesCompleteAsync,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/tmpunless asked, so the mode stopped withNo mount found for virtual pathand 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-pathnames, which implies--llm-log; theLlmLoggingsection tunes it, as fororkeon 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 runandorkeon-replresolve, 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 1prints one summary line per exchange, never the bodies, and that--allow-external-mountscovers an--llm-log-pathoutside the working directory.
Added — an agent confined to a working root, detached shell jobs (RT-06, RT-11, #137, #138)
working_root(YAML key; aliasworkingRoot, C#AgentBuilder.WorkingRoot): a virtual path under a mount that confines the agent's file tools andshell_commandto 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_commandtakesaction:start_jobruns an allowlisted command detached with the same confinement and returns ajob_idand the output file/output/jobs/<id>.log;job_statusreportsrunningor theexit_code;job_tailreturns the lasttail_lineslines. 16 live jobs per run, ids valid for the run that started them, the end of the run kills the jobs still running. Withoutactionthe 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_readtakesoffsetandlimit.edit_filereplaces a uniqueoldbynew(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 withcreate_backupnever overwrites an earlier backup.globandgrepreturnpath:linehits under the agent root (a..segment is refused) and skip files over 1 MiB (counted infiles_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'sact;ctx.delegateruns without deadlock underconcurrency(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; eachactcancels only the children it started. - Instances.
crew.instances()lists addressable agent instances; they takesendandstop,maxInstances(default 32) andctx.instanceId; an act that ends onmaxIterationskeeps its transcript, so a latersendhas its context. Caps: 40 messages and 32k characters per instance. - Durable agent memory.
ctx.memory.agentpersists per project throughIScriptAgentMemoryStore(FileScriptAgentMemoryStore, root/workspace/.orkeon/agent-memory, key = agent name). A corrupt file is refused, never overwritten. The root is not configurable yet: see limitations. actoptions.act({ tools })narrows the offered tools and throwsUnknownToolErrorbefore the model is called (case-insensitive);effortonactandAgentBuilder.effort()reaches the provider;onToolCallandonToolResultrun 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).withAutonomousTooltools are offered inact, gated by their declared access, and an innertools.*call is not asked twice.runCrewAsyncfromcompletedchains 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_inputworks inorkeon-repl(also under--ui=tui, through the console adapter) withmultiand arecommendedoption; headless,HumanInputOptions.HeadlessPolicyanswers the default or refuses, and the JSON-lines provider oforkeon runaccepts[a, b]or a comma list formulti.- 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:StartScriptruns once at start; what it printed is prepended to the first turn (ISessionBufferService.SetState(), keysession_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 byLlm:MaxRateLimitWait(5 minutes by default; the 5xx ladder keeps its 30-second cap); beyond it the call fails at once withLlmRateLimitException(aDomainException). LlmResponse.CacheWriteTokensand the cache read tokens reachCostBudgetManagerandsession_stats.LlmCacheConfig.Ttl(5mor1h) 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).
.mdand.markdownfiles giveSection,CodeFence,LinkandFrontMatternodes (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 carriestarget:<raw target>and is never resolved toresolved:<fqn>in a built or reindexed index. - Selectors (RT-44, RT-38).
node_outlineandnode_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 byfqnsorchanged_files, parity withaccess-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_filesexceeded reportstruncated.- Graph kinds (RT-33).
EdgeKindgainsTests,DocumentsandProjectDepends(flags1<<5to1<<7; there is noreferenceskind).edge_kindsandnode_kindsofdependency_graphandsub_graphare 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.ProjectGraphBuilderreads each csproj forproject_dependsandContainsedges,TestEdgeLinkertags[Fact]/[Theory]methods and linkstestsedges. Limit: atestsedge to an overloaded member links every overload, and TypeScript tests are tagged withouttestsedges. - Dev-workflow queries (RT-34, RT-36, RT-37).
affected_tests(changed_filesorbase, default the working tree) answersall,test_projects,test_classes,unresolved;batch_anchors(closure,overlap; an unresolved anchor never proves disjointness);documented_inanddocuments_ofoverDocumentsedges built from Markdown code spans, links and headings (DocumentsEdgeLinker;documents_ofreads at most 1000 sections). - Incremental reindex (RT-30).
incremental_reindexand 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_replacesplices one node's bytes, refuses a staleexpected_hash(StaleHashException) and any new parse diagnostic, and restores a backup when the write fails.node_insertadds a nodeinside,beforeorafteran anchor.edit_batchappliesnode_replaceandnode_insertover 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>.journalreplayed only while it matches,validate: "build"restores on a red build.structural_rewriteapplies a rule'sfix(FixTemplate),dry_runby 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 thenode_ensuretool and theopfield ofedit_batch. A no-op writes nothing and reportsapplied=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 notmain. 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 forbypassPermissions,dontAskandacceptEdits), the hints,↓ taskswhen a task exists;↑/↓ select · enter viewfrom the list. The recipient left the bar. - Tasks list. After a blank line:
mainfirst, 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 mainwhen the recipient ends while the prompt has focus;⎿ Interrupted · What should Orkeon do instead?onEsc 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 thanmain, and does nothing otherwise. On a long wrapped line↑/↓first move through its rows.Home/Endreach the line's ends,Ctrl+Home/Ctrl+Endthe 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;Entersends 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,EscorF4back to the prompt (text and caret restored),Home/Endfirst/last row,Enterprints the task's detail and sends nothing, a printable key returns to the prompt with it typed.Tableaves the list likeEsc;Ctrl+Vor a right-click leaves it and pastes at the restored caret;Esc Escfrom 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> ─;mainis the default. Until a host wiresTuiIntegration.SendToTask,Enterto a task prints that sending to a task is not supported yet and keeps the text in the field. - Hint bar.
f4 agentsbecomes↓ tasksin the field and↑/↓ select · enter viewin the list.F4and the new keys stand down while a modal dialog has focus, asCtrl+Vdoes.
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 Escinterrupts the prompt's turn. The firstEscclears 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/psticket shows cancelled). The hint bar showsesc esc to interruptwhile 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+Conly 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 (
↓orF4),Escreturns to the prompt and cancels nothing, a turn running or not; a secondEscright after it interrupts the prompt's turn. Ctrl+Qasks 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 parameterlessOnCallSettled(), so existing observers still compile);LlmCallSettlementcarries the effectiveModelandSucceeded, andLlmRetryEvent.Modelnames the model of a retry.ModelAvailability(Available,Reconnecting,Unavailable) is new inOrkeon.Cli.Abstractions, andModelWitnessInfoinOrkeon.Cli.TerminalGui.LlmRetryProgressObservergainsCurrent,Reset()andOnCallSettled(LlmCallSettlement); a host registering its ownILlmRetryObservergets 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 unlessConfinement: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:Autoleaves the shell unconfined and logs it once (shell confinement off: running in a container; set Orkeon:Tools:Shell:Confinement:Mode to force it). Theorkeon-runners, console andorkeon-hostimages also setOrkeon__Tools__Shell__Confinement__Mode=Noneexplicitly. - Fail closed. When the backend is unavailable (
bwrapmissing, 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
PATHonly (never the working directory), and a cmd.exe built-in runs ascmd.exe /d /v:off /s /c "<built-in> <arguments>",%refused. A batch file (.bat,.cmd) runs withMode = Noneonly (npmfindsnpm.cmdafter.exeand.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'sdir,vol,attribandwhere /ranswer "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/bwraplifts 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 theOrkeon.Toolsumbrella, 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 accountProvider, a mandatoryRightslist (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.
Rootconfines 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 emptyShare:AllowedRecipientsallows nobody, no notification is sent unless asked, and public links stay off untilShare:AllowPublicLinks. An account that only reads asks for a read-only scope. Deletion goes to the trash;permanentneedsPurge.drive_readopens 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 adrivesubdirectory of the runner's internal/credentialsroot, 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.tstypings (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.providerbecomesOrkeon:Rag:Providerin 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."),promoteandresume("take the session slug only: no other word.") refuse extra words; drop them. - Migration:
orkeon-hostexits 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> --helpexits 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:
localhostoutside port 11434 is no longer Ollama, and…:11434/v1reaches Ollama. - Migration: for an Ollama elsewhere, use its
/v1address and"ApiKey": "not-needed"; addhttp://to an address that lacks it; drop the/anthropicpath 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
--mountoutside the working directory, accepted before without the flag, is refused. - Migration: add
--allow-external-mountsor setORKEON_ALLOW_EXTERNAL_MOUNTS; fororkeon-host, an operator--mountoutside 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 atranscribe_audiotool: theMCP:Serversand 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 filefile_readreads, 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.mdno 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
/crewor/scriptdeclared 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
--mountarguments are placed byRunnerHost's own rule, over its layers (the environment, its settings files, its command line): a--mounton a declared root replaces every entry of that root for the session, and the log saysmount /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-dirand--crews-dir) or/credentials; a root declared several times with nothing to choose one; a missing folder, those of--commands-dirand--crews-dirincluded. Without--commands-dir,--mount <folder>:/cli-commands:rois accepted. - A declared entry in force is readable outside the working directory, as for a runner.
- Breaking: a mount on
/credentials, and the same--mounttwice (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.GenericandServices.TaskRouting(PatternMatchingErrorHandler,ErrorClassifier,TaskExecutionRouter,TaskExecutorFactory,ResearchTaskExecutor,ResearchFindings...),RetryDefaults, and in DomainTaskClassificationService,TaskCategory,ResearchTask,AnalysisTask,CodeGenerationTaskwith their contexts. Migration: none was registered; retries and error handling live in the strategies and the resilience policies, and a task is aCrewTask. - Mappers, DTOs and value objects of an absent HTTP API (decision 2):
CrewMapper,TaskMapper,ExecutionMapper,ToolMapper, the list overloads andToSummaryDtoofAgentMapper,ApiResponse<T>and the otherApiDTOs,ApiMetadata,ToolMetadata,ToolDto,ExecutionResultDto,CollaborationDtos,LlmConfigOverrideDto,LlmThinkingConfigDto,TokenUsageDto,TokenModelUsageDto,MemorySearchFilter, the ApplicationBatchOutput(not the one ofICrewOrchestrationService),MessageDefaults,PaginationDefaults, and DomainAgentCapabilities,CollaborationContext,CommunicationProtocol,PerformanceMetrics,SecurityContext,TaskComplexity. Migration: define the DTOs of your own API in your host;AgentMapper.ToDto(agent)remains. The unusedOrkeon.Application.Common.DTOs.MemoryItemDtogoes too (theMemoryItemDtoofSearchMemoryQuerystays). - Read DTO fields no handler fills (decision 3):
CrewDtokeepsId,Name,Description,ProcessType,Status,Verbosity,CreatedAt;AgentDtolosesLlm,Capabilities,PerformanceMetrics,Metadata,WithStatus,WithPerformanceMetrics;TaskDtokeepsId,Name,Description,ExpectedOutput,AssignedAgent,Status,Priority,CreatedAt.LlmDto,AgentCapabilitiesDto,PerformanceMetricsDto,TaskComplexityDto,TaskOutputDto,MemoryConfigurationDto,CrewDefaults.DefaultEstimatedTaskDurationand DomainOrchestrationDefaultsgo 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/,TemplateParametersand the DomainAgent/CompositiontypesCompositionResult,CompositionTypes,TemplateParameter. Migration: remove any registration ofITemplateEngine; nothing in a run resolved it. - Task delegator (decision 5):
ITaskDelegator, the DomainDelegation/types,DelegationStrategy,DelegationParameters,DelegationDecisionandNullTaskDelegator. Migration: remove any registration ofITaskDelegator; delegation goes through theIAgentChannel(Autonomous mode) and thedelegate_work_to_coworker/ask_question_to_coworkertools. - 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 typesEntityMemory,EpisodicMemory,MemoryContext,EpisodicMemoryMetadata,EpisodeEventDataand the seven eventsAgentLeftCrewEvent,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 ofUpdateBackstory; a crew no longer loses an agent or a task once built. - Training subsystem (decision 9):
AddOrkeonTraining,TrainingExtensionsand the Application, Infrastructure and DomainTraining/folders. Migration: remove any call toAddOrkeonTraining; Evaluation (IEvaluationSuite, the evaluators, theEvaluationsection,IBenchmarkRunner) stays. - Call override of the LLM cascade (decision 10): the cascade stops at the task.
LlmProviderExtensions(GenerateAsync/ChatAsyncwith aLlmConfigOverride),LlmConfigOverride.ForResponseFormatand thecallOverrideparameter are removed;LlmConfigResolver.Resolvetakes two arguments. Migration: a call passes its ownLlmConfig, starting fromprovider.BaseConfig((provider.BaseConfig ?? LlmConfig.OnProfile()) with { ResponseFormat = ... });Resolve(baseConfig, taskOverride);new LlmConfigOverride { ResponseFormat = ... }instead ofForResponseFormat(...). TaskStatus.Blocked: the value no transition reached. Migration: usePendingfor 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 useOrkeonMeter.NameandOrkeonMeter.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) andCognitiveMemoryOptions.AnalysisTemperature(Infrastructure) are nowdouble. - 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(orORKEON_ALLOW_EXTERNAL_MOUNTS=1) makes a--mountoutside the working directory readable; without it, such a mount stays mounted and refused at access, as fororkeon run.- The
--commands-dirand--crews-dirfolders are entries of the REPL, like the script oforkeon 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
functionused 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
toolmessage per call. - A result is cut once, at
AgentDefaults.ResolveMaxToolResultLength, with the framework's notice; a failed provider turn resolvesoutputto<undefined-llm:<error>>, ascomplete. NativeToolCallTranscript(Application) holds the assistant turn and the bound, shared by the C# agent loop andact.
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.5artefacts. - Immutable Releases join the mechanisms: GitHub's own
release/v0.2statement covers the tag and every asset, bothSHA256SUMSmanifests included. - The token-free API query decodes the statements with
jqand prints the builder and the commit; the Release's SBOM andpublish.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:
TracingInstrumentationandOrkeonTelemetryChatClient(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
PromptTemplatewithout{{ .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 eachPromptTemplate, 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
MaxExecutionTimenow fails (ExecutionTimeExceeded). - Breaking:
AgentDto.MaxExecutionTimeis nowint?(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
AgentandCrew, their builder methods (AgentBuilder,CrewBuilder,AgentSpawnRequestBuilder), theirAgentCreateOptions/CrewCreateOptionsmembers and their arguments ofAgent.Create,Crew.CreateandAgentSpawnRequestare removed. - Migration: remove the calls to
CacheEnabled,MaxRetryLimit,ShareCrew,OutputLogFile,LanguageandFullOutput, and theirAgent.Create,Crew.CreateandAgentSpawnRequestarguments: none had an effect. Ask for a language in the task or the backstory; keep a run's log withorkeon run --events jsonlorKickoffStreamingAsync.
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.shreads the image'spath-exclude/path-includerules as dpkg applies them (the last matching pattern decides) and leaves out themissinglines 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 servesverify-aptafter publication, which would have failed the same way on Ubuntu 22.04, 24.04 and 26.04.apt-index.ymlruns the publication bench a second time with the release's pinnedubuntu:24.04as client: its bench packages ship a file under/usr/share/doc.- The guide Verify what you install says which
missinglines a minimised image prints. scripts/apt/check-apt-branch.shempties the fake GitHub's request log once its readiness probe has answered. Run on the runner, asapt-publishandapt-maintenancerun it, the probe's own404 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:TimeoutSecondsbounds 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 (errornaming the setting,error_typeTaskCanceledException), the partial content kept and noRawResponseBody; 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_typeStreamIdleTimeout, 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_reasonor[DONE],message_stop,done: true) is a failed call when no answer text and no tool call arrived (error_typeStreamTruncated, the sentence saying how much reasoning was streamed); with some answer it is served as it came, flaggedstream_truncatedin its metadata. Anthropic's mid-streamerrorevent is read as the OpenAI dialect's root-levelerroralready 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.Timeoutonce (LlmTimeoutRetries), as the buffered path does, instead of up toLlm:MaxRetriestimes; the OpenAI dialect'sChatAsyncreports an answer withoutchoicesorusageas 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.mdgains "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,dotnetoransi) andTUI_DIAG(1), the diagnosis switches of the text interfaces, andOLLAMA_BASE_URL, the address the Ollama provider takes when it is given none. orkeon settings envprints the same three lists in the terminal, offline, and--jsonhands them to a program.envis 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 emailandorkeon ragreadORKEON_DEBUGas every other verb does —1,trueoryes— where they took1alone.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.exampletemplates 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 wroteRateLimiting:RequestsPerMinute,RateLimiting:MaxConcurrentandLlm:Provider, which nothing reads: they areGlobalRequestsPerMinute,MaxConcurrentRequestsandLlm:BaseUrlnow. - A
jsonblock 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 gaveOrkeon:Rag:Retrieval:CandidateK50; 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:ConsoleandOrkeon:Scripting:Limits:RecursionLimitread "the.NET". - The settings files and the pages are listed from what git knows, so a clone that keeps other
projects under
examples/othersdoes 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.
RateLimitingis 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
Llmsection, 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.shand.ps1shipscripts/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.mdsays 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-replwrites it asorkeon-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:Hostin a fileorkeon runshares 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: onerunner-settingsline atwarnper section, beside thefaillines; 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.mdsays at the head of each subsystem that no shipped binary activates it;configuration.mdgains "When a setting is only reported";cli.mdsays whatrunner-settingswarns 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 settingsanswers from the catalogue the tool carries: the eleven categories with the sections of each, thenorkeon 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 (ratefindsRateLimitingandToolRateLimiting, notFallbackStrategy). A name the operator chose stands where the catalogue writes<name>:Llm:Profiles:fast:Modelis 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|replnarrows every listing to what one binary reads. --alllists everything by category;--jsonwrites the catalogue itself — one object,sectionsandsettings, 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
secretand has no default. It shows what a key is worth when nothing sets it, not what the machine has set:orkeon doctorstays the verb that judges a file. The listing holds in 100 columns. orkeon --helpnames the verb and now ends on the documentation site and the configuration reference, instead of the repository's address.orkeon settingsstays the verb in a folder that holds asettings/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, onSettingsReferencePageTests). - Rate and budgets sets
RateLimiting(the calls to the model, in every host) besideToolRateLimitingandTokenBudget(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. Llmis a table followed by its three cautions, each under a title: the timeout and the models that think,MaxTokensas 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.mdandlocal-models.mdlink to the section they cite;security.mdno longer copies the defaults ofRateLimiting.
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, inOrkeon.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:
orkeonreads 46 sections,orkeon-host52,orkeon-repl41. 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:CheckpointingandOrkeon:ExecutionState:Persistence. - The catalogue is embedded in
Orkeon.Hosting— four produced files underSettings/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) andscripts/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 --versionanswers the version of the checkout —1.0.0-rc.4.local.<commit date>off a tag — andorkeon doctornames the channelsource. Run again after agit 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— andcurlandopensslon 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 -NoArchiveprepare the staging tree and stop there: no archive, noSHA256SUMS. The scripts above pass it; CI never does.orkeon doctortells asourceinstallation togit pulland 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, besideinstall.ps1in 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 withinstall.ps1; neither is in the MSI.- A reinstall that cannot run is refused before it changes anything.
install.ps1lists 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.-Uninstallrefuses the same way. - Proven under both PowerShell editions.
smoke-windowsruns the whole Windows smoke twice, underpwshand underpowershell, and the smoke gains three passes: an install throughinstall.cmd; a second install over the first (the same tree, onePATHentry, 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.ps1declares#Requires -Version 5.1;package-installers.ps1,build-msi.ps1andbuild-msi-service.ps1declare#Requires -Version 7.0, so Windows PowerShell says which version they need instead of failing on a parameter.orkeon doctortells a zip installation to runinstall.cmdto update.- Docs (EN, FR): the README, three ways to run Orkeon, the publication matrix and the
README of every archive present
install.cmdfirst; 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 byinstall.ps1andinstall.sh. An MSI is harvested from the zip's tree and installs its own marker in place of the zip's. orkeon doctorgainsinstall-channel, afterdotnet-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, answersunknownand staysok; a marker that names no channel is a warning. The dotnet tool carries no marker and is known by its path. A Debian package answersdeband gives both commands — the apt repository's and the downloaded package's —, since nothing in it tells the two apart.doctor --jsontherefore lists one more check.orkeon --version --verboseadds achannel: <channel>line under the version line, whichorkeon --versionalone 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.ps1and 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-Filefor 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 andregistry.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
orkeonalone (the Windows and Linux ones carry Orkeon Studio), nor counts the checks oforkeon 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 byscripts/test-resolve-version.sh.publish.yml, the apt dev channel and bothpackage-installersscripts read it. - A build made from a checkout is
<props version>.local.<stamp>,<stamp>being the commit's date,YYYYMMDDHHMMin 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 av*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.ymltherefore 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-4reasons by default and streamsdelta.contentas an array of typed chunks, the shape the buffered path has read since 2026-08-30. The text stream (GenerateStreamingAsync) threwInvalidOperationExceptionon 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.jsonis 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 accountsandorkeon email checkfollow, and so doesorkeon-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.ShowDeviceCodeAsynctakes 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 jsonlthat isemail.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.IEmailLoginInteractiongainsShowRedirectRejectedAsync(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.Emaillists, reads, writes, renames and removes the accounts and carriesDefaultAccount,Screening:WithholdRejectedandCredentialsDirectory. 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.
DefaultAccountfollows 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_2when another account already names it, never anORKEON_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 --jsonanswers 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 » runsorkeon 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 newEmailCliClientof 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 absolutehttpsaddress. 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 runsorkeon 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
DefaultAccountthat names no account, aScreening:WithholdRejectedthat 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 emptyIncoming:Hostblocks 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.
Providerandproviderin an account,HostandhostunderIncoming,DefaultAccountanddefaultaccountin the section: the JSON configuration refuses the second, no run starts, and the check said nothing.STUDIO-MAIL-TWINnames 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 correctsSTUDIO-MAIL-DUPLICATEon 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.Ofgives 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, soEmailAccountRulesspells its rules again;EmailValidationOracleTestshands 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: aPasswordEnvVarorClientSecretEnvVarthat 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 (
copyrightin the Debian package),THIRD-PARTY-NOTICES.mdand a non-emptylicenses/<pack>/per bundled runtime are asserted on the tree the user keeps: the CLI archive and whatinstall.ps1orinstall.shmakes of it, the two MSIs once installed, the full Windows archive, the.deb. No smoke lists the folders it expects: each*.runtimeconfig.jsonof the payload names the frameworks its application bundles, and the pack is<framework>.Runtime.<rid>. A payload with no*.runtimeconfig.jsonis a failure, never an empty pass. Two twin functions hold the rule,smoke_assert_notices(lib/smoke-common.sh) andInvoke-OrkeonNoticesAssertions(lib/notices-windows.ps1), both proved in CI on throwaway trees. release-verify.ymlreplays 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..dockerignoreandDockerfile.runnerssay what Docker does.*.mddrops 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 whypackages/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_deletereturns the ids it deleted. A newmessageslist holds eachidand, for a move to the trash, thenew_idthe 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_searchreturnstotal, and says whatcountandlimitare.countis the size of the page;totalis the number of messages of the folder matching the criteria, every page counted (IMAP, not withhas_attachments).limitis a ceiling: a page is cut to what the agent loop keeps of a tool result, about ten messages, so a page shorter thanlimitis not the end of a folder —next_cursoralone is. Nothing changes in what a page holds; the schema, the tool description and the guide now say it.email_foldersshows wherearchivegoes on Gmail. No Gmail folder carries the rolearchive, whichemail_moveaccepts and sends to All Mail: that folder (roleall) now lists it underalso_roles. The tool description and thefolderargument namealltoo.- 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 thatemail_accountsgives 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.
StudioTeamMetadatacarries 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 gainslastRunAtafter 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\uDCCApair: 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:rwwithout the folder failed its first run from Studio:orkeon runrefuses a mount whose folder does not exist, and Studio created the folders only when it wrote the sidecar — after that run, inRecordRun. Before a launch — Run, Run with--validate, Replay — the Launch tab now examines every well-formed./xentry 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./../xare left alone. The rule is the onerun.sh/run.cmdapply (TeamFolderPreparationin Studio.Core, pure overIDirectoryProbe); the creation at the sidecar's write is unchanged and still creates every folder,roincluded. 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\teamswith 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: theORKEON_STUDIO_TEAMS_ROOTvariable, 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(TeamsRootin itsStudiosection, 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-runreads the variable alone — it parses no startup option and has no preferences file — and hands the root to itsRunSession, which recorded no last run before. - No
Orkeon:Studiokey. The settings file is the oneorkeon runreads, and the host refuses at start anyOrkeon:*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 childorkeonprocess inherits lands as the root-level keySTUDIO_TEAMS_ROOT, neither read nor refused. WorkshopLayout(Studio.Core) reads the Orkeon Workshop folder around a teams root — whether it is one (settings/andworkbooks/beside the teams root), the team's settings filesettings/<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 fromorkeon-studio-runnow stamps its team'slastRunAt, 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 promoteand 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, afterrem,REMor#; BOM, CR LF and LF tolerated). The header of the releases up to1.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.RegenerateandWritePortableanswer the newTeamLaunchersOutcome.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'sonSavednow receives theTeamLaunchersResult?;TeamsViewModel.Announce). The settings hook stays silent, and the adoption line never seesForeignKept: 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 noticeScheduledRunIssue.ForeignLaunchers(ScheduledRunCheck.Of/FirsttakeforeignLaunchers) 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 scheduleregisters 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
RateLimitingin<workshop>/settings/<slug>/appsettings.json, which itsrun.sh/run.cmdpass 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 whosesettings/<slug>/appsettings.jsonexists 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 fromORKEON_STUDIO_TEAMS_ROOT, its label reading « Settings: auto (team file: …) ». - The
ORKEON_Llm__*overlay is unchanged. A card withoutprofilelays Studio'sORKEON_Llm__Profiles__<id>__*only, and the team file'sLlmsection andRateLimitingapply as they are; a card naming a setting of this machine lays that setting'sORKEON_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'sLlm:Profilesand in Studio's settings merges field by field, Studio'sProfiles__<id>__*winning key by key. - Migration: a plain catalogue has no
<root>/../settings/<slug>/: nothing changes — no--settingsfor 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 runread a multi-file team folder one way. A workshop team keeps its crew undercrew/and one folder per mount point at its root; a mount point namedagents/ortasks/— or a scripting entry point (*.ork.ts) — made the root the crew in Studio, and the run failed onconfig.yaml (or crew.yaml) not found. The CLI read the root the same way and never looked intocrew/. Both now probecrew/first: when it holds a crew, it is the definition — Studio runs it from the team folder,orkeon run <folder>loads it (CrewDirectoryLayoutdesignates it asCrewDirectoryInspection.CrewRoot). One step down, nevercrew/crew/; acrew/holding no crew leaves the root under its old rules. The CLI's rule is the narrower one:orkeon run <folder>descends into acrew/that holdsagents/,tasks/or the flat triplet, where Studio also resolves acrew/holding a single-file crew or a script — for those, pointorkeon runat 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 thecrew/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 fromorkeon run <folder>— it was refused with « no recognized crew layout » — and its settings are looked up fromcrew/:crew/appsettings.json, then anappsettings/or_shared/folder above it; anappsettings.jsonat the team folder's root is not found any more, pass--settings. A folder whose root is itself a multi-file crew and holds acrew/that is one now runscrew/, in Studio with the line above and silently in the CLI; rename the nested folder to keep the root in charge.orkeon-hostloads a directory crew as given and does not look intocrew/.
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 assettings/$(basename "$DIR")— and eachmounts.<name>/<slug>. Rename in My teams movedteams/<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 followssettings/<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, underarchive/<slug>/<kind>/—archive/<slug>-2/when the name is taken, by the free-suffix rule every folder Orkeon names follows (TeamCatalog.FreeSibling); amounts.<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>-copydid not exist, so the copy ran on the machine's model where the original ran on its own. In a workshop, Duplicate now copiessettings/<slug>tosettings/<slug>-copyand 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/andworkbooks/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.DeleteandDuplicatekeep their signatures;CopyTreeis nowinternal. - Migration: in a workshop, Delete archives instead of erasing — a team taken out sits whole under
archive/<slug>/, to delete by hand or withorkeon-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
/workspaceto read came with them whenever the brief had any input, a URL included. The brief now carriesreadsFiles(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.proposedcarriesdefaults: truewhen 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.readynow carriesheldFolders— 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
/workspacekept 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'sfolders/<name>,/workspaceincluded;--readstill 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
purposeand 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 adeliverable, 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 oneneed.rephrasedline; 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-EMPTYis now a warning in every scope, in Studio and in theorkeon-studio-configTUI 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.ymlalready builds, smokes and attests; the signed index lives on the orphanaptbranch. The source is a deb822 file (installers/apt/orkeon.sources) withSigned-By:pointing at/usr/share/keyrings/orkeon-archive-keyring.gpg— noapt-key, nothing trusted system-wide. Nothing adds it for you: neither the.debnorinstall.sh. The block to copy, the channels, going back to a version, removal, Docker builds and troubleshooting are in Install with apt. - Three channels.
stablecarries final versions only and stays empty until one is published;rccarries every tagged release;devcarries theorkeonpackage of every greenmain(1.0.0~rc.4.dev.<n>), unstable and unsupported, the three latest builds only, never published to NuGet.org. Switching is oneSuites:line. Every version still attached to a Release stays in its channel:sudo apt install orkeon=<version>goes back to it. apt-dev.ymlfeedsdevafter every green CI run onmain: both.debon the fixed-tag prereleaseapt-dev, a dropped build's assets deleted only once the pushed index no longer lists them; the README's newest-tag one-liner andgit describenow readv*tags only.- A
.debfor arm64.orkeon_<version>_arm64.debships 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 thelinux-arm64archive, smoke-tested on a real ARM runner (smoke-debis a matrix, each entry checkingdpkg --print-architecture), attested and listed inSHA256SUMS.linux-arm64users no longer need the multi-app archive andinstall.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 throughapt upgrade.orkeonrecommends it; the setup block installs it explicitly, since--no-install-recommendswould 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.shpoints at the apt repository on Debian, Ubuntu and their derivatives — it reads/etc/os-releaseand prints the guide's address, nothing more: it writes nothing under/etcand never callssudo.
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, notorkeon_1.0.0~rc.4_amd64.deb. GitHub rewrites~in an uploaded asset name, so the published file never matched itsSHA256SUMSline. The file name now follows the tag; the package'sVersion:field keeps the~(1.0.0~rc.4), which sorts a pre-release before its final version. The1.0.0-rc.3and1.0.0-rc.4Releases are left as published (rewriting them would break their attestations): their.debis namedorkeon_1.0.0.rc.N_amd64.debwhile theirSHA256SUMSnames it with~— the digest is the same, only the name differs: check that file by hand.release.ymlrefuses an asset GitHub would rename (any character outside[A-Za-z0-9._-]), an asset without aSHA256SUMSline and a line without its asset (scripts/check-release-assets.sh, in theinstallersjob and in thereleasejob before publishing).- The post-publication verification runs.
release-verify.ymlwas triggered byrelease: published, which never fires for a Release created with the workflow'sGITHUB_TOKEN:release.ymlnow calls it in itsverify-publishedjob, right afterrelease; it can still be run by hand for a tag. It no longer skips a manifest line whose file is missing (--ignore-missingremoved): every published asset must have its manifest line, and every line its asset; it replays the smoke of both.deb. Run by hand onv1.0.0-rc.3orv1.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
Dependsacceptslibicu78andlibicu77besideslibicu76down tolibicu70(Ubuntu 26.04 ships onlylibicu78). Recommends: orkeon-archive-keyring— notDepends, so a localsudo apt install ./orkeon_<version>_amd64.debwithout the repository keeps working.Homepagepoints at the repository, https://github.com/Orkeon/orkeon.- The package ships
md5sums:dpkg -V orkeon/debsums orkeoncheck the installed files, and the Debian smoke assertsdpkg -V orkeonis silent. - Reproducible: two builds of the same commit give the same bytes (
release.ymlsetsSOURCE_DATE_EPOCHto 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
installersjob as a non-blocking report in the job summary; the expected tags of a self-contained package are listed with their reason inscripts/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 theORKEON_prefix and the keys without case and reads:like__, so a run readsORKEON_LLM__APIKEY,orkeon_llm__apikeyorORKEON_Llm:ApiKeyasLlm: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 variableLlm:ApiKeyEnvVarnames is still read by its exact name, as the run reads it.LlmApiKeyResolver.Resolvereturns anLlmApiKeyResolution(the key, none, or the conflict); its overloads over a function and over the machine without a seam, andLlmForm.ToProbeRequest(Func), are removed — pass anIEnvironmentVariables(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.jsonis 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, ±∞ and1e400like 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.
AppSettingsValidatorjudgesLlmand eachLlm:Profiles:<id>entry by the run's rules: strings, a finite temperature,MaxTokens,TimeoutSecondsandMaxRetrieswhole numbers that fit anint— like every other integer field (RateLimiting,LlmLogging:MaxBodyLengthChars,Orkeon:Rag:Corrective:MaxIterations), « must be a whole number » —,Thinking:EnabledandGrammarbooleans,BaseUrlan absolute http(s) URL,ApiKeyEnvVara variable's name;Llm:Profilesand each entry objects. AnApiKeywritten${NAME}is the errorSTUDIO-LLM-APIKEY-PLACEHOLDER, giving the run's remedy ("ApiKeyEnvVar": "NAME"), and an entry nameddefaultthe errorSTUDIO-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 sixSTUDIO-TARGET-*,STUDIO-MOUNT-ID,STUDIO-MOUNT-SHARED— have theirs, in the five languages, and a test requires one of everySTUDIO-*orWIN-*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
profileof 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'sfollowRename,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 andTeamLaunchers.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.
ScheduledRunCheckcompares 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 byKeyAgrees) — 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.Savedis 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 leavesschedule/behind. - The engine writes nothing of the machine into
FORGE.mdorforge.json. The card's schedule section keepsorkeon forge schedule .and loses « By hand, on this machine » and its command, which rides thepromotedevent and a refusal'serroronly;forge renameretitles the card's title line alone. Whatforge scheduleinstalled is recorded inschedule/installed.json(ConventionalNames.ScheduleDirectory,ConventionalNames.ScheduleInstallationFile), beside the artifacts, no longer inforge.json'sschedule.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 newAddOrkeonSettings<T>(path)(Orkeon.Infrastructure.DependencyInjection), orDeclareSettings(path)on anOptionsBuilder<T>,ValidateSettings(...)for a rule worded by its key, andDeclareSettingsShape(path, type)for a section read raw (SettingsDeclaration,Orkeon.Application.Configuration).RunnerHost.Buildruns one start validation before anything else — no warning printed, no telemetry started —, which the REPL andorkeon doctorshare: every declared section's options are created (the binder, the rules, the names they hold), then the section names, then the keys, thenOrkeon:Rag:LlmProfile; the first refusal is theRunnerSettingsException. 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-toolscrashed on itsAllowInterpreters),Orkeon:Ragand itsIngestion,QueryRouting,Retrieval:HybridandWebFallback,Orkeon:CrewMemory,Memory, the five memory providers' sections,Orkeon:Consensus,Orkeon:CodeSandbox,Orkeon:CostTracking,Orkeon:TokenCounter,Orkeon:Encryption,Orkeon:Embeddings,Orkeon:EmbeddingCache,Orkeon:Scripting:Limitsand:Toolchain,Orkeon:Cli:Session: all refuse the start now. The effectiveRagOptionsare validated options too (theOrkeon:Rag:Profilepreset with the section bound over it). - No value is swallowed. The default
Llmsection is read as strictly as its profiles — aTimeoutSecondsof"600s"ran on 30 s —,Thinking:EnabledandGrammararetrueorfalseeverywhere, and aTemperatureis a finite number, in the default section and every profile:"NaN","Infinity"or1e400(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 tookNaNand the infinities without a word: anOrkeon:Rag:Generation:Temperaturefailed every RAG answer, anOrkeon:CrewMemory:MinScorerecalled nothing.RaggableTree:Embedding:Provideris one of its five names (a number is refused),DimensionsandMaxTextCharsare whole numbers;LlmLoggingis read strictly under--llm-log; a flatOrkeon:Rag:Retrieval:Hybridis a boolean;Orkeon:Cli:Session:ContextWindowTokensis a number above zero, whichtoken_budgetreads from the session options (CliSessionOptions);Orkeon:Checkpointingis 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 fromBaseUrland 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 underOrkeon:and underOrkeon:Cli,Orkeon:Tools,Orkeon:Scripting,Orkeon:SecurityandSecurityis one ofSettingsSections.Known(Orkeon.Constants.Configuration), the closest proposed (Orkeon:Guardain→Orkeon:Guardian). The root,Loggingbeyond 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:ProviderandOrkeon:Rag:Provider, with what the named provider needs (Orkeon:LanceDb:Endpoint;Orkeon:Pinecone:ApiKeyandIndexName, orHost); theRerank:Kind,QueryTransform:Mode,Context:OrderingandIngestion:DefaultChunkingStrategyof the effective RAG options, against the factories this host builds — a C# host without the ONNX reranker refusesbalancedandqualityat its start, namingonnx;Orkeon:Rag:QueryRouting:Classifier;Orkeon:Embeddings:Provider,openaiorollama— another name took the OpenAI branch; the rule ofOrkeon:Sqlite:TableName.MemoryProviderFactoryno longer falls back on the volatile provider: an unknown type, orlancedbwithout its endpoint, is refused where it is reached, and a YAML crew'smemoryProvider:that names no provider fails its load, like an unknown tool (MemoryProviderTypes,Orkeon.Application.Memory, is the one list). Loggingis 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-replstarts behind the same barrier (ReplStartup): its registrations,Logging, the start validation — one line,orkeon-repl: <reason>, exit1, no console; a--settingsfile it cannot read is named with the line and the position. It opened on a fileorkeon runrefused.orkeon doctorjudges the file asorkeon rundoes. Arunner-settingscheck, afterllm-profiles, applies the run's guards to the mounts the file declares, then builds the hostorkeon runbuilds — the ONNX reranker the CLI adds included, no crew, no MCP connection — and runs its start validation: onefailrow per refusal, each naming its key, or oneokrow; skipped when theLlmsection is already refused. The--jsonschema 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.exampletemplates, the smoke fixtures). Theorkeon-hostexample named its DeepSeek key underLlm:ApiKeyEnvironmentVariable, which nothing reads — the daemon started without its key and every run failed on "API key is required" —: it writesApiKeyEnvVar, and it and the streaming demo loseLlm:Provider. The release smokes' RAG fixture wrote its database underOrkeon:Rag:ConnectionString, so it stayed in memory and the search process found nothing the ingestion process wrote: it writesOrkeon:Sqlite:ConnectionString. The porting guide'sMemory:ConnectionStringisOrkeon: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) andlinks— an emptylinks: []stays a closed door, an absent block stays absent —, an agent'sguardrailsandknowledge(the short form for an attachment that only names its collection), a task'sdeliverableandguardrails: each was lost. What the loader transformed is written as the configuration carries it: a guardrailspreset:as the header, rules and tool rules it brought, the crew'sllm:under each agent,anchors:as their text.ExportToDirectoryAsyncwrites the crew keys from the same mapping asExportToString, where it kept a copy of its own. - Under the author's keys.
AgentConfiguration.KeyandTaskConfiguration.Keykeep 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.tsscript has none. The export writes each entry, and eachagent:,dependencies:andmanagerAgent:, 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 anInvalidOperationExceptionnaming them: the loader would refuse the file. - No key nobody set.
YamlDotNetSerializer.Serializeno longer writes a null property as an emptykey:line — an exported crew of three agents carried dozens —, the form the forge already used throughSerializeWithoutNulls, which is gone. A value set to its default,falseor0, is still written. - The validator names an agent or a task by its key.
Invalid crew configuration: Agent 'researcher' must have a goal., whereorkeon runnamedAgent '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:EnableDebugLoggingandDefaultTimeoutwere lost, and a strategy aservices.Configure<OrkeonApplicationOptions>(…)had set before it was reset toFirstFit. The two routes the documentation gives now compose, in either order.OrkeonApplicationOptionskeepsAgentSelectionStrategy, the only setting anything read;CrewRepositoryType(with theRepositoryTypeenum),CrewsPath,DefaultMaxIterations,EmbeddingDimension,EmbeddingProvider,OpenAIApiKey,OpenAIEmbeddingModel,AzureOpenAIEndpoint,AzureOpenAIDeploymentName,EnableDebugLoggingandDefaultTimeoutare removed — no section bound them, nothing read them —, with the constants only they used (PathDefaults,EmbeddingDefaults.FallbackProviderandDefaultOpenAIModel). - A task state machine and a task queue no mode runs.
TaskStateManager(Orkeon.Application.Services.StateManagement, withStateTransitionResult<TState>,TaskStateEvent,TaskReadinessFlags,TaskStatusFlags,TaskAction,PriorityAdjustmentand a secondTaskExecutionContext—Orkeon.Domain.Agent.TaskExecutionContextstays) and what it alone used (RetryPolicy,ExecutionTimePolicy, three delays ofTaskDefaults): a run moves its tasks through their lifecycle itself (GAP-21).AsyncTaskPipeline<T>,CrewTaskPipeline,ITaskQueue<T>andWorkItem<T>: no mode queued a task through them. - Aggregate restores.
CrewTask.Restore(both overloads),CrewTaskSnapshot, the restore constructors ofCrewTaskandCrewTaskBase<TContext>, andCrew.Restorehad no caller — no repository persists the aggregates —, and the snapshot lost a task's deliverable, LLM override and guardrails, asAgentSnapshotlost an agent'sLlmConfig(GAP-26). - The crew export.
CrewConfigurationMapper.ToConfiguration, the class's last method, ran only in its tests.CrewConfiguration.ExecutionConfigandCrewConfiguration.Metadata, set by no loader (YAML,.ork.ts) and read by no run, go with it, and so do theExecutionConfigrecord andTaskDefaults.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, withCallbackConfigDto,MemoryConfigDto,MemoryLimitsDto,MemoryCleanupDto,VectorConfigDto,RetryConfigDtoandTimeoutConfigDto, had no user;CrewDto.ExecutionHistory(ExecutionHistoryDto) was filled by nothing. - Aggregate mutators.
Agent.UpdateConfiguration,Crew.UpdateConfiguration(both overloads, withCrewConfigurationUpdate) andCrewTaskBase<TContext>.UpdateConfigurationhad 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.
IAgentLifecycleManagerwithAgentLifecycleStateandAgentLifecycleManager— registered byAddOrkeonInfrastructure(), resolved by nothing since GAP-26 —,Agent.RegisterCancellation,Agent.StopAsync,AgentKilledEvent(30 domain events remain),Crew.SetKillAllStrategyandCrew.StopAllAgentsAsync. A run stops through its cancellation token (orkeon run,orkeon-host's/stop). - Two ports nothing resolved.
IYamlDiffServiceandITemplateInstantiator, 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,RollbackResultandConfigurationVersionId;InstantiationValidation,TemplateType,InstantiationPreview,AgentTemplateDefinition,TaskTemplateDefinition,CrewTemplate,AgentTemplate,TaskTemplateand their ids (AgentTemplateId,TaskTemplateId,CrewTemplateId),InvalidTemplateParameters,ResolvedTemplateParametersandTemplateConfiguration.TemplateInstantiationParametersandTemplateParameterValue, whichITemplateEngineuses, stay. - A package reference nothing used.
Orkeon.Tools.Abstractionsno longer referencesMicrosoft.Extensions.AI: the nine tool families,Orkeon.Interop.AgentFramework, four test projects and thelocal-embeddingsexample no longer restore it through it.Orkeon.Infrastructurekeeps it, so the binaries and theOrkeonpackage — the only oneOrkeon.Tools.Abstractionsships 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 publishedghcr.io/orkeon/orkeon-runnersand itslocal-llmvariant),deploy/Dockerfile.hostand the rootDockerfilecopyLICENSE.mdandTHIRD-PARTY-NOTICES.mdto/usr/share/doc/orkeon/, the Debian package's path, and.dockerignoreno 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.shand its.ps1mirror runpython3 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'sdeps.jsonnames, found where the inventory looks:licenses/Microsoft.NETCore.App.Runtime.<rid>/, pluslicenses/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.debinstalls them under/usr/share/doc/orkeon/licenses/, the service MSI underlicenses\(its build script requires the folder), the CLI MSI with the rest of the tree, and the archives'install.shandinstall.ps1copy them withTHIRD-PARTY-NOTICES.mdinto the installed tree — they copiedLICENSE.mdalone. The packaging scripts need Python 3. esbuildhas its section. Section 12 gives the MIT license of the TypeScript transpiler the archives, the.deb, the CLI MSI and theorkeon-runnersimage ship, at the versiontools/scripting-esbuild/package-lock.jsonlocks.- The Studio TUIs ship the pinned versions.
orkeon-studio-configandorkeon-studio-rungotMarkdigand tenMicrosoft.Extensions.*packages fromTerminal.Guialone, at its minimums (1.3.2 and 10.0.11), whileDirectory.Packages.propspins 1.4.0 and 10.0.12: central management pins direct references only.Orkeon.Cli.TerminalGuinow references the fiveTerminal.Guiasks for —Markdig,Microsoft.Extensions.Configuration,.Configuration.Binder(10.0.12, a new central pin),.Configuration.Jsonand.Options—, their dependencies follow, and the inventory loses its eleven older rows: 151 versions, one per package. --checkkeeps 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 versionDirectory.Packages.propspins, naming the applications and both versions.scripts/test-third-party-notices.pyproves 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.
CrewFactorypasses 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
toolRulesfails the load.file_writeandFile_Writename 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.
CrewFactorypasses anAgentConfiguration'sSystemTemplate,PromptTemplateandResponseTemplateto 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 readsPromptTemplateyet.
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, andforge renamestill finds the header (TeamLauncherScript.HeaderreplacesForgePromoter.LauncherHeaderandTeamLaunchers.Header). Each value is written for the runner first, then forcmd— every%doubled; a value without a quote betweencmd's quotes end to end; a value with one outside them, each quote and operator escaped; the stretch carrying%~dp0always between quotes —: every value reaches the run as written, whatever the team's path holds. A line break is a space inrun.cmd— a comment line says so — and is kept inrun.sh. run.cmd's frame: UTF-8 without a BOM, named so by both writers; ASCII up tochcp 65001, the caller's code page captured and given back beforeorkeonstarts;setlocal EnableExtensions DisableDelayedExpansionwhatever the registry says; the command in a block ended byexit /b, which keepsorkeon's exit code and never letscmdread the file again — a launcher written again during a run is not read from the middle.- Beyond 8 191 characters once expanded,
run.cmdlaunches nothing: it prints the length, the bound and the longest option on stderr, and exits 1;run.shstays complete.forge promotesays so with awarning(FORGE-LAUNCHER-TOO-LONG) and succeeds. Studio's adoption line says it —TeamLaunchers.Regeneratereturns aTeamLaunchersResult(written, unchanged, no team, disk refused, and the Windows launcher's refusal) instead of abool— and says the engine's last warning in the sentence of its code:FORGE-SCHEDULE-STILL-INSTALLEDno longer reads as a session folder not renamed. orkeon run --option=valuetakes 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 runnow 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'sRunArgumentsBuilderwrite 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'sExecStartescapes the path (\\,\",%%,$$) and the cron line puts it between single quotes (\%for a%).forge schedule --checkreads a task of the former formstale(reasonoutdated), 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
cmdunder 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.Providerholds 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'sApiKey,Llm__ApiKey, then the variableLlm:ApiKeyEnvVarnames, 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.KeyMissingfor 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 initand the TUI write"ApiKey": "not-needed", Studio's card wrote nothing. A setting of that card now writes it in its entry, and inLlmwhen elected — the oneApiKeyStudio writes, where none is set —, lays it on its launches and presents it to « Test »; electing another card takes exactly that value out ofLlm, where it would pass before the elected setting'sApiKeyEnvVar. One rule judges a section's key (LlmProfilesSection.KeyAgrees), and an entry or anLlmthat disagrees is written again at the next gesture, once. The validator reportsnot-neededbeside anLlm:ApiKeyEnvVar(a hand edit).DockerModelRunnerDefaults.DefaultModeland.ApiKeyPlaceholderare aliases of theOrkeon.Constants.Llmvalues Studio reads, asBaseUrlalready 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, asClose()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.StartAsyncandStartListenerstart 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, on127.0.0.1(localhostunder Windows):HttpListenerbinds the first address its host name resolves to —::1forlocalhoston 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 withClose()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 twoOrkeon.Application.Testsfailures 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
asyncExecutiontest 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.AI1.20.0 brings an edge toMicrosoft.Extensions.AI.Abstractions (>= 10.8.2), a version nuget.org never published: every restore ofexamples/interop/agent-frameworkwhose 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 eightactions/cachesteps 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).
maxRpmis applied, as CrewAI'smax_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.MaxRpmandCrew.MaxRpmareint?, 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.tsgainsagentBuilder().maxRpm(n)andcrewBuilder().maxRpm(n), in YAML parity; the procedural shape, whosectx.llmcalls are no agent turns, applies neither and warns once. AmaxRpmof 0 or less fails the load naming the agent or the crew — it became 10 —, and so does amaxIterof 0 or less — it became 15. maxIteris 20 everywhere.AgentDefaults.MaxIterationsgoes from 15 to 20 — CrewAI'smax_iter— and is the one default: YAML,AgentConfigurationand the DSL read it, and a C# agent withoutMaxIterationstakes 20 turns too.ExecutionOrchestrator.MaxIterationsand the loops' default iteration count never applied —Agent.Createrefuses zero — and are removed: the number of turns is set on the agent.- The host's per-agent cap is each agent's.
RateLimiting:AgentRequestsPerMinutewas a bucket per role, in a singleton, created once: two teams oforkeon-hostwith a "Researcher" each shared it, from one run to the next. It now bounds each agent instance's own window, with itsmaxRpm, 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.
GlobalRequestsPerMinutecounted 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,AddOrkeonLlmProviderandAddOrkeonLlmProfile, the profile registry'sForProvider, the manager's resolver, a C# crew's planner —: every model call of the host takes one lease, the scripts'ctx.llmincluded, andorkeon runno 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: 1no 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 itsRetryAfter, 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,RunTimeoutand/stopwaited for it.IManagerAgent.ReviewOutputAsynctakes 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.pyreads the restoredproject.assets.jsonof the six applications the tool packages, the installers and the container images publish —orkeon,orkeon-repl,orkeon-hostand the three Orkeon Studio applications the installers add — and the.nuspecfiles of the local NuGet cache: the assets file'spackageFolders, a Windows path there also tried at its WSL mount, thenNUGET_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.deband 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.ymlrunspython3 scripts/third-party-notices.py --checkafter 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.1stated,4.16.3shipped) and Microsoft.Extensions.AI.Abstractions (10.9.0,10.10.0), both corrected —; and when an installer table, aPackAsToolproject 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.pyproves 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__ApiKeyserves 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__ApiKeyfirst when it is set (STUDIO-49): the test checks the setting's key, andorkeon doctor'sllm-configrow and the run's startup line say where the default's key really comes from. ProviderBalanceAccount.RequestWithloses its fallback, andProviderBalanceAccount.Forgives a setting that names no variable an account with none (KeyVariableempty) where it namedORKEON_Llm__ApiKey. The documentation ofLlmProbeRequest.ApiKeysays whose key it is.- Nothing changes on screen otherwise.
LlmSectionViewModelkeeps what the settings screen calls — the election, the mirror of the settings intoLlm: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 theLlmsection 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-knames, in its own process alone — beforeORKEON_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 asorkeon doctordoes (RunnerSettings.ReadConfiguration, thenLlmSettings.ReadDefault): the key the configuration resolves, else the variableLlm:ApiKeyEnvVarnames, 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, anApiKeywritten${NAME}, aBaseUrlthat 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 theappsettings.jsonandappsettings.{Environment}.jsonof the current directory — since .NET 10,<binary>.settings.jsonand its environment twin too — and, inDevelopment, the user secrets. The folder a terminal happened to be in could add profiles, MCP servers or mounts to a run, andorkeon doctor, which read the file andORKEON_alone, never saw them; the REPL did the same, its--settingsfiles 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 theOTEL_EXPORTER_OTLP_ENDPOINTa .NET Aspire AppHost sets through it, whichOpenTelemetryIntegrationTestsnow proves —, the resolved file (for the REPL, its--settingsfiles, else the global file), thenORKEON_; the REPL's command line stays last.RunnerSettings.ReadConfiguration—orkeon doctor,orkeon forge, the--llm-profileguard,init's probe — composes the same layers: a bareLlm__ApiKeythat changed the run changes the verdict too.orkeon-hostreads./appsettings.jsonas its settings file when--settingsnames none, as its help says — by resolution now, which its reserved-root guard reads too —, never under the file--settingsnames. No source watches its file: the default host's watcher over the current directory's tree went with its files. The REPL project's ownappsettings.json, never shipped, is deleted. Migration: a setting that came from anappsettings.jsonof the current directory moves into the settings file the run resolves (theappsettingsrow oforkeon doctornames it) or the one--settingsnames;orkeon-host --settings <file>no longer reads./appsettings.jsonbeside it; a bare variable that overrode a REPL settings file (Llm__Model) takes theORKEON_prefix (ORKEON_Llm__Model), which wins over the file in every host. orkeon-hostnames the profiles it offers. Under its allow-list (Orkeon:Host:LlmProfiles), the startup lineLLM profiles offered to crews besides the defaultlisted 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.GetDoublereads any JSON number, the integers the screens write included (Llm:MaxTokensandTimeoutSeconds, theRateLimitingfields,LlmLogging:MaxBodyLengthChars,Orkeon:Rag:Corrective:MaxIterations);GetInt32reads one whose text is an integer withinint— adouble600 included, never0.5,600.0or a value beyondint, 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.jsonfollows 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.TemperatureandLlmConfig.TopParedouble?: 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(anLlmsection or a profile withoutTemperature),LlmConfig.OnProfile()andCreate,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 writestop_p: 1when nothing sets one (AlwaysEmitTopP, measured); Kimi re-sends its mandated temperature only for a value that was set and refused. The runners' startup line saystemperature=(not set: the model's own). - What is set is sent, whatever its value. The composer forwards an agent's temperature and
top_pwhen 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.
YamlCrewExporterwrites an agent's temperature at 0.7 like any other, itstopP,thinking,responseFormatandresponseSchema,cacheand profile, and a task'sllmOverride— what the loader reads back. - What a dialect cannot send is said (decision 8). Ollama writes
top_p,seedandstopin itsoptions— it dropped atop_pa YAML crew declared —, throughOllamaRequestOptions.Builder, whoseAddTemperature,AddTopPandAddSeedtake nullable values, withAddStop. Afrequency_penaltyor apresence_penalty, on every dialect, and aseed, 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'sLlmConfigreach the call (the tool-free retry keeps them, and the agent's model, which it lost); both MEAI adapters carry the stop sequences, and anIChatClientwrapped as a provider no longer receives a temperature, atop_por a zero penalty nobody set. The Microsoft Agent Framework bridge announces a temperature or atop_pwhatever its value. LlmParameters, which nothing used and whose 0.7 and 1.0 contradicted the rule, is deleted, withLlmDefaults.DefaultTemperature;LlmDto.Temperatureis 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: theLlmsection 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 itsApiKeyEnvVarnames), 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 withoutOrkeon:Rag:LlmProfile, a script'sllm.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,defaultelects nothing, and the id is matched without regard to case. An id the settings and theORKEON_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,--validateand--list-tools(RunnerExecution.EnsureLlmProfileIsKnown); a host built without that guard refuses it too (RunnerHost.Build(…, llmProfile)). The name isRunOptionNames.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--mountanchored 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 renamereads 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 areConventionalNames.WindowsTeamLauncherandPosixTeamLauncher(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'sExecStart, 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.
CrewHostServicenow 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 asFailed. The runs admitted before keep their grace,/statusand/stopstill answer, and the channel and the A2A server still stop after the drain. - A refused setting is one line and an exit code.
RunnerHost.Buildraises one type,RunnerSettingsException(Orkeon.Hosting, anInvalidOperationException), for every setting it refuses: a retired key, an invalidLlm:Profiles, an unknownOrkeon:Rag:LlmProfile,MCP:EnableServer, mounts it cannot honour, a value the configuration binder cannot convert (theMCP:Serversentries are now bound at build too), a settings file it cannot read — named, with the line and the position —, and aRaggableTree:Embedding:BaseUrlorTelemetry:OtlpEndpointthat is nohttp(s)address, refused by its key instead of a bareUriFormatException. A host already built is disposed first.orkeon run— YAML, crew directory, declarative.ork.ts—,--validate,--list-toolsandorkeon mcp serveanswer it withERROR: <reason>as the last stderr line and exit1(an--events jsonlrun closes its stream onrun.finished, exit code 1); a procedural.ork.tswithorkeon run: <reason>andorkeon forgewithorkeon forge: <reason>, exit1both — they were exit2. Most of these ended on an unhandled exception, a stack and a core dump (exit 134).ORKEON_DEBUG=1prints the exception before the line. orkeon-hostrefuses before it starts. Its whole pre-start sequence runs under the exit-78 barrier: the configuration it boots from, its sections —Orkeon:Hostwith itsA2A,Orkeon:Host:Discord, and theA2Asection —, now read once, at start (aRunTimeoutor aDiscord:ProgressIntervalof"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\Orkeonlisten 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-Uninstallremoves it; the service MSI reserves nothing — it installs before any configuration — and its closing screen gives the step. sendSubscribestreams a run's progress. A peer following a task readWorking, then nothing until the final state, while a chat thread watching the same run read a line per finished task.IA2ATaskRouter.RouteTaskAsynctakes anIProgress<string>: the server passes one forsendSubscribeonly, and each line becomes aWorkingupdate carrying it inA2ATaskUpdate.Message(message, omitted when null;partialOutputstays the output). One writer drains one queue, so no line follows the final state.orkeon-hostreports the lines a thread reads; the agent router reports none.- Stdout carries the protocol alone.
Telemetry:ExportToConsoleattached OpenTelemetry's console exporter, which writes on stdout — into--events jsonl, the--list-toolsmanifest,orkeon mcp serve,orkeon forge --events jsonlandorkeon email accounts --json. It is removed, withTelemetry:PrometheusEndpoint, which nothing read, and theOpenTelemetry.Exporter.Consolepackage; a section that still writes either key, whatever its value, is refused, naming the OTLP collector that replaces it. orkeon mcp servenever starts under itself. Settings declaringorkeon mcp serveunder their ownMCP:Serversmade each server start another before answering, until the first gave up after 30 s. A serve now setsORKEON_MCP_SERVEin its environment before it connects its servers, and one that finds it set refuses to start: exit1, 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.mdsaid therag_*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 anIBaseToolinto anAIFunctionthat 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.SetCrewPolicyandSetAgentPolicyhad no caller, so the per-crew and per-agent policies were always empty. They are gone, andGetPolicy(crewId, agentId)is thePolicyproperty: the host'sOrkeon: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,CrewTaskRequestand 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 ignoredProcess—,AgentMapper.CreateFromRequest,TaskMapper.CreateFromRequest); and the DTO enumsProcessType,CrewStatus,TaskStatusandTaskPriority(the read DTOs carry those as strings). OneProcessTyperemains: the value object. - Per-agent planning.
IAgentExecutionService.PlanTaskExecutionAsyncandIExecutionOrchestrator.PlanExecutionAsync(withTaskExecutionPlanandPlannedStep) asked a stub planner for the same fixed plan, and nothing asked them: the planner (IAgentPlanner,AgentPlannerService,TaskPlan,PlanStep,PlanFeedback,PlanValidationResult, and the ApplicationPlanningContext,PlanningStep,PlanningResult) is gone, and so are the secondExecutionPlan(Orkeon.Domain.SharedKernel.ValueObjects, withExecutionStepandExecutionStrategy) andExecutionPlanDto(TaskDto.ExecutionPlan, never filled). A crew'splanning: trueis the orchestrator's (GAP-31).ExecutionOrchestrator's constructors lose theirplannerparameter. - Other dead surfaces.
OrkeonApplicationOptions.MaxShortTermMemoryItems,EnablePersistence,EnableRAG,MemoryDatabasePathandDefaultMemoryProvider(copied, never read — the REPL'sappsettings.jsonloses itsOrkeon:DefaultMemoryProviderkey);ShortTermMemory,LongTermMemory,EntityMemoryandContextualMemory(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 byCrewDefinitionValidator);CrewConfigurationMapper.ToDomainCrew, which re-created the agents under new ids and never set the manager (the loaders build crews throughCrewFactory);Agent.RestoreandAgentSnapshot, which lost the agent'sLlmConfig;Agent.ValidateForExecution("Agent has no tools assigned" — an agent without tools is valid) withExecutionValidationResult,IExecutionOrchestrator.ValidateExecutionAsyncandIAgentExecutionService.CanExecuteTaskAsync;IExecutionOrchestrator.MapExecutionContextwithSimpleTaskExecutionContextandAgentMemory;ExecutionStatus.Cancelled(no run reached it: a cancelled run endsFailed, GAP-32; the other values keep their numbers);ExecutionConfig.EnableAsyncExecution; and the constants and ids only these used (MemoryDefaults.DefaultMaxShortTermItems,PathDefaults.DefaultMemoryDatabasePath,PlanningDefaultsofOrkeon.Application.Constants.Execution, threeStatusDefaultsplan statuses,MemoryId,TaskPlanId,PlanStepId). - A crew's request rate is exported under its own key.
CrewConfigurationMapper.ToConfigurationwroteCrew.MaxRpmintoExecutionConfig.MaxConcurrentTasks, a task concurrency nothing reads (andToDomainCrewread it back as the request rate). The export writesExecutionConfig.MaxRPM, andMaxConcurrentTasksis 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) andCrews, 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'sName, its description the crew's newDescriptionkey —, 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(orsendSubscribe) on a published id — compared exactly — runs that crew throughCrewRunneron the task'sinput, itsmetadataas the run's variables: under the crew's mounts, inside itsMaxConcurrentRuns— chat conversations and A2A tasks counted together, a task over the bound answeringFailed, never queued —, underRunTimeout, logged with its origina2a:<task id>.Completedcarries the crew's answer; a failed run answersFailedwith 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 answersFailed, naming the published ones. - Refused at start (exit 78): an enabled section that exposes no crew, or a crew
Orkeon:Host:Crewsdoes not declare; a malformedHostorPort; a listener beyond the loopback whileA2A:Securitydeclares neither an authentication scheme nor mutual TLS; and the C# hosts'A2A:EnableServer,A2A:HostandA2A:Port, which the daemon does not read. A server refusing itsA2A:Security(a scheme without its validator) is a refused configuration too, not a crash to restart on. The rest of theA2Asection — the card's identity,A2A:Securityand 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.
IA2ATaskRoutergainsGetSkillsAsync, andA2AServerbuilds 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.A2ATaskRouterlists one skill per available agent, as the card did.AddOrkeonA2Aregisters 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-scopeIAgentRepository(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 hostorkeon run --list-toolsreports — 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 buthuman_input, which answers for the operator of a run (an MCP client has a human of its own).--toolsserves the named tools only, and a name the host does not have refuses the start. Stdout carries the protocol and nothing else: logs, warnings,--helpand usage errors go to stderr.--list-toolsand 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 oneERROR:line and exit1—--list-toolsended there on an unhandled exception and a core dump. - Each call is guarded.
McpServertakes theIToolInvocationPipelineand calls every tool through it, under the callermcp: the guardian's tool phase, the call, the one truncation rule, the result sanitizer and aToolExecutionaudit event. The client reads what a crew agent's model reads: a blocked call answersisError: truewithError: Blocked by Guardian (ToolExecution): …and never reaches the tool, a result arrives truncated and tagged as data, a failure readsError: ….RunStdioAsyncno longer disposes the process's console streams when the client leaves. - The verb is the switch.
MCP:EnableServerandMcpOptions.EnableServerare removed:AddOrkeonMcpregisters the client only, andAddOrkeonMcpServer(configuration)registers the server, itsMcpServerOptionsbound fromMCP:Server(Name,Version). A section that still carries the key,trueorfalse, is refused at startup — by both extensions and by every runner built onRunnerHost, servers declared or not — with a message namingorkeon 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— whichWithAgentFrameworkAgentcalls — setAgent.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 isAgent.Llm(AgentCreateOptions.Llm,AgentSnapshot.Llm, thellmparameter ofAgent.Create) — the provider the agent's turns run on, CrewAI'sllmgiven as an object — and the run honours it: the orchestrator builds a client over it once per provider instance (ILlmProfileRegistry.ForProvider, namedprovider:<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'sllm_overridenames (defaultincluded), 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, afterCrew.ManagerLlm;provider:<name>in the run's log and the export). - Its own provider or a host profile, not both.
Agent.CreateandAgentBuilder.Build()refuse an own provider with anLlmConfigthat 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 byAIAgentLlmProviderand relayed by the meter, makesAgent.Create,AgentBuilder.Build(),AddToolandUpdateConfiguration(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 (itstools:,human_input, the delegation tools of an agent that allows delegation — a YAML agent does unless it writesallowDelegation: 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.
AIAgentLlmProvidernow 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.
MeteredLlmProvidercounts 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 underagent-framework:<name>. The metering guard declaresLlmProfileRegistryan 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
LlmConfigdeclares (model, temperature, max tokens, response format, thinking…) is a structured warning ofAIAgentLlmProvider— event 110, the HTTP providers' wording —, once per crew run and option, through the loggerWithAgentFrameworkAgent(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
Llmshape —Llmand eachLlm:Profiles:<id>— gainsApiKeyEnvVar: the name of the environment variable that holds its key, never the key.LlmSettingsreads it when the configuration resolves noApiKey(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,initand Studio. - Where each key came from, never the key. The runner host's
LLM resolved:line ends withapiKey=<source>—from configuration (Llm:ApiKey),from the variable named by Llm:ApiKeyEnvVar (process environment)or(user environment),none—, oneLLM 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 ofApiKeyEnvVar: it may be a key pasted in the wrong field.LlmSettings.DescribeApiKeyandLlmSettings.UnresolvedApiKeyReferencesare the public surface. - Blank reads as absent. A value left blank in a section of the
Llmshape —Thinking:Effortincluded — 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 intoLlmwhole —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,AvailableModelsandProfilesstay. A team launched on another setting than the default lays every modeledORKEON_Llm__*field over its child, its value or blank,ORKEON_Llm__ApiKeyEnvVarincluded: 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.HostKeyVariableis 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 usedORKEON_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 initandorkeon-studio-configwrite it too.orkeon init --api-key-env <name>writesLlm:ApiKeyEnvVar: <name>— nothing forORKEON_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-replcomposed the default .NET host alone: neitherORKEON_Llm__ApiKey— it readLlm__ApiKey— nor the global fileorkeon initwrites reached it. It now reads the--settingsfiles — else the global file, which a named file replaces as fororkeon run—, then theORKEON_variables, prefix removed, before the command line, and logs once where each key comes from, with the runner's warning.Orkeon.ConsoleAppnow referencesOrkeon.Hostingfor that path (RunnerSettings.GetGlobalSettingsPath, code that stays with the runners rather than a copy): theorkeon-repltool package carries four more assemblies —Orkeon.Hosting,Orkeon.Tools.EventHub,Orkeon.Constants.CliandCommandLineParser(MIT), all of which theorkeontool already ships. orkeon doctorreads the key a run would.llm-configsays where the default's key comes from, warns when its reference resolves nothing and fails when the section cannot be read; a newllm-profilesrow covers the profiles, onellm-profile-keyrow warns per profile whose reference resolves nothing, andllm-reachabilityqueries the catalogue with the resolved key.- The ten
examples/appsettings/*.local.json.exampletemplates 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
ManagerDecisionfallback. On asequential,parallel,graphorautonomouscrew,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 asequential,parallel,graphorconsensualcrew was never called. Both are refused now — by the YAML loader, the.ork.tsadapter,CrewDefinitionValidator,CrewBuilder.Build()andCrew.Create(CrewCreateOptions)— with a message that names the key and the mode and says what to do: remove the manager, or usehierarchicalorconsensual(an autonomous crew's manager is an LLM: the default profile, orWithManagerLlmin C#). Two predicates of theProcessTypevalue object carry the rule,AcceptsManagerAgentandAcceptsManagerLlm, and the domain keeps it:Crew.SetManagerAgentaccepts a consensual crew (it refused every mode but Hierarchical);ChangeProcessTypesets 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;Validatechecks 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'sagent: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 itsmanagerfield 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 isAcceptBestScore. 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 nomanagerAgent: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 neithercost.updatednorrun.finished, although the documentation said "metered asoperation: planning".SequentialCrewOrchestratornow 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.Createrefuses it — fromCrewBuilder.Build()andCrewCreateOptionsalike —, andUpdateConfiguration(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 refusesdefault, 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 runin a terminal reads the same file and needs onlyORKEON_Llm__Profiles__<id>__ApiKey. - Entries written by hand stay as written. An entry of
Llm:Profilesno setting owns is listed read-only under the settings, never rewritten nor removed. Choosing « no model » for the default — in Studio or inorkeon-studio-config— removed the wholeLlmsection, 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-configshowsLlm:Profilesand the RAG's profile, read-only.Orkeon.Constants.LlmgainsLlmProfileNames.Default(ADR-009): the reserved name the runtime refuses for a profile, which Studio refuses too;LlmProfiles.Defaultreads 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
managerAgentcarriedllm: { profile: claude }had its tasks assigned and reviewed on the host's default profile: the manager agent'sllm: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.AddAgentmade the first agent of such a crew its manager, taking it out of the workers. The manager now runs, resolved once per run byManagerLlmResolver, onCrew.ManagerLlmwhen C# set one (CrewAI'smanager_llm, metered like a provider the host registers), else on its manager agent'sllm: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, andCrew.Validate,StartExecutionandChangeProcessTypeaccept it. An autonomous crew hands its tasks out onCrew.ManagerLlmtoo. The export'sExecutorSettings["ManagerLlm"]names that LLM (it carried a CLR type name), the unusedExecutionConfig.ManagerLlmstring is gone, and a YAML or.ork.tshierarchical crew withoutmanagerAgentfails 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, thellmclassifier and the evaluation judge all took the container's chat client — the default profile. They now call the host profileOrkeon:Rag:LlmProfilenames (RagOptions.LlmProfile; unset, the default), resolved at the first RAG call that needs a model. A name the host does not offer —orkeon-host'sOrkeon:Host:LlmProfilesallow-list included — refuses the start of the runner hosts and the REPL, listing the known ones (RagLlm.EnsureProfileIsKnown);orkeon rag eval --offlineignores the key, its stub answering in place of every model. - A
.ork.tstask changes profile like a YAML task.taskBuilder().withProfile(name)sets the task'sllm_overrideprofile (alongsidewithResponseFormatwhen both are given); a name the host does not offer fails the load, listing the known ones.task.d.tsdeclares it. - An address is not a glob.
SourceGlobExpandertook the?of a query string, or a*, in anhttp(s)://source for a wildcard:rag_ingestandrag.ingestwalked the virtual file system for it and failed ("No mount for virtual path '/https:/…'"), andorkeon rag ingest --sourceturned it into/workspace/https://…. An absolute http(s) address now reaches the web loader as written, on every surface — the crewrag: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.actrefuses an unknown tool. A procedural.ork.tsagent whose.tools([...])names a tool the host does not offer —web_serchforweb_search— ranactwithout that tool, silently, where the declarative shape fails its load on the same name (StrictTools).actnow rejects, before any model call, with the declaredUnknownToolError(new inerrors.d.ts, planted as a global like the others:agentName,toolNames,availableTools); anonErrorhandler reads it asvalidation, and a C# host callingJsCrew.RunAsyncgets the typedUnknownToolException(Orkeon.Scripting.Exceptions). Names still match case-insensitively, and a body that never callsactis not concerned.CrewResultdeclares whatcrew.run()serves. The typings promisedoutput: TOutandartifacts: ReadonlyMap<string, unknown>; the runtime served a string and a CLR dictionary that was always empty, soresult.artifacts.get("x")compiled and threw.CrewResultis now{ output: string; tasks: readonly TaskResult[] },TaskResult.outputisunknown, the type parameters ofCrewResult,TaskResultandCrew.runare gone, and so isJsCrewResult.artifacts.TypingsRuntimeParityTestspairs 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 showedsources: ["./data/catalogue/**/*.pdf"]and["./docs/procedures/"]: both failed at ingestion ("No document loader can handle source"), the sources reaching the pipeline verbatim.RagCollectionsBootstrappernow expands a glob throughSourceGlobExpander, asrag_ingest,orkeon rag ingest,rag.ingestand 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 —/crewunderorkeon run crew.yaml); anhttp(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.confirmednow refuses it — a recoverableFORGE-FOLDERS-INVALIDsaying to confirm the folders in a run that stops before its trial (orkeon forge resume <slug> --dry) and to try the team withorkeon forge resume <slug>, whose host mounts and allows them from its start. The validator is unchanged, and Studio, which confirms the folders in a--dryrun, is not concerned. - A forge trial knows the host's LLM profiles. It loaded a forged
.ork.tscrew 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 withLlmProfiles, likeorkeon runand 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.
KickoffStreamingAsyncruns exactly whatKickoffAsyncruns — 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. CrewExecutionEventspeaks the run's wire vocabulary. ItsKindis aRunEventKindsconstant:task.startedandtask.completedfor each task (task id, agent role; success, skip, duration, tokens, tool calls),tool.calledandtool.returnedfor each tool call (the tool's name, success and duration — never an argument's value nor the result),llm.deltafor the model's text as it arrives (with the task and agent of the call), andrun.finished, always last, whoseOutputis the run'sCrewOutput— after anerror(Codecrew_failedorcrew_cancelled, newRunEventErrorCodesinOrkeon.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 thetool_useblocks 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 (noIChatClient) stream every event but the text. orkeon run --streamstreams a crew's turns. The run observer's delta sink now reaches the agent loop (ExecutionOrchestrator.DeltaSink, set byAddOrkeonApplicationfrom the registeredILlmDeltaSink): a YAML crew, a crew directory and a declarative.ork.tscrew writellm.deltaevents, where onlyctx.llm.*calls did. The observer registers the sink only under--stream, so a run with--eventsalone 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.FailExecutionwith the output's error (a readable sentence when it has none):CrewExecutionFailedEventwith thatReason, naming each failed or skipped task, and noException; the crew and its execution stayFailed. Only a run whose every task succeeded completes it — one terminal transition per run. A cancelled run is a failed run whoseExceptionis theOperationCanceledException, and a task the cancellation caught running isCancelled(it was failed with "Operation was cancelled"). - A task counts once, by its final outcome.
CrewExecutionCompletedEvent.CompletedTasksandCrewExecution.CompletedTaskscount 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 aPartialSuccessexecution.CrewExecutionCompletedHandlerlogs "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 byValidateCanKickoff.AUTO_SUMMARY.mdis written,orkeon-hosthears it, andorkeon run --events jsonlsayserror(crew_failed, the cause) beforerun.finished— as the run event bus promised. A failure a strategy reported is never reported twice. KickoffForEachAsyncruns each input in sequence, as its contract says and like CrewAI'skickoff_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.Wrapalways wraps — without callbacks it notifies the stream of a streamed run alone —, so anExecutionOrchestratorbuilt by hand streams its tool calls too.- The
Orkeonpackage embedsOrkeon.Constants.Protocol, whichOrkeon.Applicationnow 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_contextincluded), 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 byPlanningDefaults: 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, elsejson_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 atInformation. - 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 byUndefinedLlmProvideralone, and passed through byMeteredLlmProviderand — now —RateLimitedLlmProvider, whoseCapabilitieshid the wrapped provider's. A keylessorkeon runof aplanning: truecrew exits 0. .ork.ts:crewBuilder().planning(value = true), YAML'splanning: 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:
IPlanningStrategyandDefaultPlanningStrategy(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; theplanparameter ofIProcessStrategy.ExecuteSequentialAsyncandExecuteParallelAsyncand ofConsensualProcessStrategy.ExecuteConsensualAsync;IExecutionPlanParser.ParseAsyncandParserName, and the text fallback ofExecutionPlanParser.
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'scontext) 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, soAUTO_SUMMARY.mdandorkeon run --eventsfollow 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: sequentialorparallel: in YAML (YamlCrewMapper), in a.ork.tscrew when the run adapts it (JsCrewConfigurationAdapter), in a configuration built in code (CrewDefinitionValidator), and in C# (CrewBuilder.Build()throwsBuilderValidationException).asyncExecution: false, the default, loads everywhere;ProcessType.AcceptsAsyncExecutionsays 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, andTaskLifecycleapplies 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 throughIDomainEventDispatcher, 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 holdsCompleted,FailedorCancelled, with the dates; a crew kicked off again without being reloaded reopens its tasks (CrewTask.Reopen). StepsExecutedis real.TaskCompletionInfo.StepsExecuted, handed to everyICallbackHandlerand logged byLoggingCallbackHandler, 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_coworkerderives the coworker's context from the delegating task's withwith— the crew's id, the memory scope, the outputs so far and the parent's settings, so it recalls when the parent does — and turnsStoreResultInMemoryoff: undermemory: truea 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
delegaterequest 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. Withmemory: 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; withmemory: false, or nomemory:, nothing is stored or recalled and no memory system is materialized. The default is unchanged: off.memoryProvider:withoutmemory: trueis refused, the remedy in the message — at load, and byCrew.Create(soCrewBuilder.Build()) andCrew.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.tscrew — the DSL has nomemoryProvider— never kept anything.orkeon-hostnow remembers from one message to the next;orkeon runfrom one process to the next only with a durable store (memoryProvider: sqlite, or a durableMemory:Provider). An unnamed C# crew keeps a store of its own. - The recall is a vector search in the crew's scope.
AgentExecutionServiceasksIMemoryCoordinator.RecallAsyncfor 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, underPromptDefaults.MemoriesHeader, one--- date · role · task ---line before each; the Guardian screens them with the rest of the prompt. The newOrkeon:CrewMemorysection (CrewMemoryOptions, bound byAddOrkeonInfrastructure()) bounds it:RecallLimit5,MinScore0.6 (cosine, measured on the local model),MaxChars4,000. A consensual candidate and a hierarchical attempt recall — they answer the task; a ballot does not (SimpleExecutionContext.RecallFromMemory, turned off byAgentBallotCollector). - 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 withmemory: trueembeds 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.ConsensualProcessStrategyno longer fails a retained answer it cannot store. Hierarchicalstores the accepted output only, once, under the assigned agent: every attempt runs withStoreResultInMemoryoff — 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
StoreAsyncrefuses an item without an embedding before any request (ArgumentException), as their collection paths did — they sent no vector, which a real server rejects. Pinecone'sSearchAsyncthrowsNotSupportedException: it has no text search, and sent an empty vector with an exact match on the content. ChromaDB's sendsPOST …/getwithwhere_document: {"$contains": query}and the filter aswhere— case-sensitive, as the server matches; an empty query sends the filter alone — where it sentquery_texts, which only the clients serve. Thememory_providerhealth 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 whateverLlm:TimeoutSecondssaid, without the provider'sThinkingnor 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 byHttpLlmProviderBase.EffectiveConfigin 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.TimeoutSecondsis nullable. It defaulted to 30, so a call could not tell "not set" from "30": null now inherits the provider's timeout, elseLlmDefaults.DefaultTimeoutSeconds(30 s,LlmConfig.ResolveTimeoutSeconds()).planning: trueplans. The orchestrator planned only when the crew carried a planning provider, which only C#'sWithPlanningLlmsets: a YAML crew, or a C# one calling.Planning(true)alone, planned nothing while the documentation said it did (the.ork.tsDSL 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-replserves a chat client on itsLlmsection. It registered its provider without one, so itsIChatClient— 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 wayorkeon rundoes — 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 anLlmsection.- The RaggableTree summarizer names no model by default:
SummarizerOptions.ModelandLlmNodeSummarizerOptions.Modelwereclaude-haiku-4-5on whatever vendor the host runs; the provider's own model now. - Removed:
AddOrkeonInfrastructure()'s model fallbacks — the keylessIBasicLlmProviderandIChatClientit 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.EnablePlanningandPlanningLlmModel,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-memoryandcrew = <the crew's name>, and the crew's searches ask the provider for both. The name — thename:of the YAML file, crew directory or.ork.tscrew,CrewBuilder.Namein 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.MemoryCoordinatoralso tags each memorycrew:<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 newSimpleExecutionContext.StoreResultInMemory(on by default) is off for the candidates and the ballots —AgentBallotCollectorturns 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.SearchAsynctakes thefilterofSearchSimilarAsync(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'swhere, Pinecone's metadata filter and LanceDB's prefiltered predicate. On the way: ChromaDB refused a filter of two keys (they go under one$andnow); 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 — socrew = "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)seededLlmConfig.Create(LlmDefaults.DefaultModelName): on a DeepSeek or Anthropic host, such an agent sent OpenAI's model. They start fromLlmConfig.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 emptymodelnow, 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 andctx.llm's call-time overrides on a provider that declares no configuration, the context-window summarizer, the cognitive memory's analysis calls withoutAnalysisModel(documented as "the default provider model"), the chat client registered without a base configuration (AddOrkeonLlmProvider(provider)), andorkeon llm probeon 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 itsDefaultModel— for the payload, the response'sModel(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 anIChatClientleaveModelIdunset instead of empty, and the meter attributes a stream that named no model to the provider's. - An
Llmsection — or a profile — withoutModelruns on the inferred provider's own default model: the settings reader, and the REPL's, filled in OpenAI's, which a DeepSeek endpoint inferred fromBaseUrlrefused. 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.Modelis empty by default, andLlmConfig.OnProfile()is the configuration that names no model.DefaultModelmoved fromOpenAICompatibleProviderBasetoHttpLlmProviderBase(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 —
ICrewAgentFactorywas a singleton holding the root-resolved orchestrator, so everyCrewAgentof 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 theIServiceScopeFactory, andCreate(loadCrew, name, description?)replacesCreate(crewId, name?, description?)andCreate(crew): each turn opens a scope,loadCrewregisters 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.CrewIdis nowCrewId?(nullfor that form). Migration: move the code that adds the crew's agents, tasks and crew to the repositories (or loads it throughICrewFactory) into the loader, resolving the repositories from the provider it receives, and return the crew's id — seeexamples/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,roleinput|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/workspaceto read (only when something comes in) and/outputto write. A folder is one absolute segment;/forgeand 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 optionaldir, the real directory bound behind it) in.brief.readynow follows the confirmation and carries the confirmed list. A list that breaks the rules is a recoverableFORGE-FOLDERS-INVALID. The terminal and--autotake the proposal as it is and print it. Migration: a client oforkeon forge --events jsonlmust answerfolders.proposedwithfolders.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/outputonly); the crew'smounts: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 andforge reopen's rebuilt session all follow it./workspaceand/outputare 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, andforge promotemoves it into the team. --read <dir>now answers the first input folder the confirmed list binds to no directory (/workspacewhen 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 fromfolders.jsonon a resume). Studio.Core gainsForgeEventKinds.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 stringsStudio.Create.QFolders/FoldersExisting/FoldersInside/FoldersLater/ReadRootTitle/WriteRootTitle/ FoldersPolicyHint/AddRootHint/AddRootWrite/AddRoot/PrecisionsTitle/PrecisionsSubin the five languages; the capture stopsetape1-dossiers-existants/-equipebecamedossiers-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 byForgeSessionModel.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.HintAnswersbecameHintAssistant— 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.Peekfalls 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.Saveis nowSaveAsync: 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__ApiKeyfromModelProfilesViewModel.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_tokens16, 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 byLlmProbeText: 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-configTUI 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 theLlmsection (BaseUrl,ApiKey,Model,Temperature,MaxTokens,TimeoutSeconds,MaxRetries,Thinking,Grammar); theLlmsection stays the default profile.orkeon run,orkeon-hostand 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:defaultis reserved, an invalidBaseUrlor 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'sllm_override(that task only;profile: defaultreturns to the default)..ork.ts:agentBuilder().llm(llm.profile("claude", overrides?)); a procedural agent configured with it hasctx.llmtalk to that profile's provider. Aresponse_formator 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-hostdecides which profiles its third-party crews may name:Orkeon:Host:LlmProfilesis 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.updatedreading 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.CrewFactorybuilt every agent without theLlmConfigthe YAML or.ork.tsmapping had produced, so a per-agent model, temperature, token cap, thinking block, response format or cache request never reached the wire underorkeon 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, emptyModel) instead of pinning the framework's default model on whatever vendor the host runs;CrewValidatoraccepts an empty model. - Removed: the provider pre-validation of
CrewConfigurationMapper.ToDomainCrew, which built a provider per agent and threw it away; itsILlmProviderFactoryparameter is nowILlmProfileRegistry? 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
IAgentPlannerbeforeAddOrkeonApplication; that registration loses, becauseAddOrkeonApplicationadds the stub withoutTryAddand the last registration wins. It now says after, asdefault-behaviors.mdalready did. ORKVFS005names a service that exists. Its message sent you to "IVirtualFileSystemWatcher via IFileSystemService", which exposes no watcher; it now says to injectIVirtualFileSystemWatcherand consumeWatchAsync. The rule id is unchanged. Both copies ofSuppressVfsComplianceAttributedocument the seven rules (ORKVFS001..007) and the ratified reason categories; a test now refuses a[SuppressVfsCompliance]reason insrc/that does not start withEXCEPTION-BOOTSTRAP,EXCEPTION-WATCHER-BRIDGEorOUT-OF-SCOPE(four Studio capture reasons had none).WithOrkeonSettingtakes the full configuration path. Its documentation and the Aspire test now say so:orkeon-host's run timeout isWithOrkeonSetting("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.shand.ps1run the unit and fast suites only, with the filter ofcoverage.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.mdlists the six folders it missed (quickstart/,crew-multifile/,appsettings/,aspire/,interop/,forge/). - Removed (no caller):
Orkeon.Application.Interfaces.IConsensualProcessStrategy— nothing resolved it;ConsensualProcessStrategy.ExecuteConsensualAsyncstays on the class, andProcessStrategyFactorykeeps routingProcessType.ConsensualthroughIProcessStrategy;Orkeon.Application.Configuration.ConfigurationVersionMetadata, used by its tests alone; the internalAggregateEventHelper. - Docs: the long-form
rag:example of the YAML schema page (EN and FR) no longer showsprovider:, 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.
Evaluationis wired.AddOrkeonInfrastructure(configuration)binds the section, andEnableLlmJudge = trueputs the coherence, fluency and groundedness judges in the defaultIEvaluationSuite, over the registeredIChatClient(none registered: resolving the suite fails, naming the setting, instead of leaving the judges out).AddOrkeonEvaluationis idempotent — a second call binds the configuration and registers no evaluator twice. The judges no longer appear asIEvaluatorregistrations; the placeholder evaluators that stood in for them when disabled are gone. Removed:EvaluationOptions.DefaultRunsPerCaseandRegressionThreshold, which nothing read.Resilienceis removed.ResilienceOptionsand its binding are gone, with theResiliencePolicieshelpers no component called —GetRetryPolicy,GetCircuitBreakerPolicy,GetTimeoutPolicy,GetCombinedPolicy,GetDatabaseRetryPolicy. The LLM policy (GetLlmApiPolicy, budgetLlm:MaxRetries, timeoutLlm:TimeoutSeconds) and the Redis policy (GetRedisRetryPolicy, three attempts) stay.RaggableTreecarriesEnabledandEmbedding, nothing else. The runner refuses to start on any other key of the section, naming it. Removed fromRaggableTreeOptions:Languages,Exclude,RootAlias,IndexMode,EnrichWithLlm,IncludeStatements,VectorStore,Cache, with the typesRaggableTreeIndexMode,VectorStoreKind,VectorStoreOptionsandCacheOptions. ASummarizer.Providerother thanNonenow registers the LLM summarizer on its own; each call still chooses withenrich_with_llm.index_codebasedeclares what the build reads.include_statements,summarizer_model,summarizer_max_tokensandsummarizer_concurrencyare removed fromIndexCodebaseRequest: 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
Resiliencesection 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.Flowsnamespace (IFlow,IFlowStep,IFlowDefinition,FlowStep,FlowState,FlowStepParameters,FlowConfigurationSettings,FlowResult,FlowStepResult,FlowExecutionResult, the[Flow]/[Start]/[Listen]/[Router]marker attributes, the flow event types…),FlowId,FlowStepIdandFlowEventId;IFlowEnginewithFlowValidationResultandFlowMetrics,IFlowStepExecutor,FlowDefinitionBuilder/FlowStepBuilder(Orkeon.Application.Flow); the wholeOrkeon.Infrastructure.Flowsnamespace —FlowEngine,DefinitionBasedFlow,FlowStepExecutor,YamlFlowDefinitionLoader,InMemoryFlowDefinition,FlowStepBase<TInput, TOutput>, the six steps (CrewFlowStep,LlmFlowStep,ToolFlowStep,ConditionalFlowStep,HumanInputFlowStep,DelayFlowStep),FlowExecutionTrackerandFlowGraphSerializer;AddOrkeonFlows()andAddOrkeonFlowVisualization(), whichAddOrkeonInfrastructure()no longer calls;OrkeonApplicationOptions.EnableFlowPersistence(read by nothing). - The
flowusage operation is gone.LlmUsageOperations.Flowand its Studio mirrorRunCostOperations.Floware removed: acost.updatedreading never carriesoperation: "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 listedIFlowEngineas 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-hostconnects theMCP:Serversat 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:Routesmaps a Discord channel id to a hosted crew: a thread opened in that channel starts that crew, and any other thread startsOrkeon: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 unknownDefaultCrew, 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 defaultIToolRegistrythatAddOrkeonInfrastructure()registers: seeded from everyIBaseToolin DI, concurrent, a duplicate DI name fails its construction with both types named, andRegisterToolAsyncstill refuses a name another tool holds. The runners use it as they are;ServiceProviderToolRegistry(Orkeon.Hosting) and the emptyInMemoryToolRegistrystub 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 ownrag_searchcalls it, not the host's. The registered tools still supplyhuman_input. - EventHub: nothing given is swallowed, no identifier is invented.
post_messageandsend_requestdeliver theirmetadatainto the envelope the recipient reads;IEventHub.PostAsyncandSendAsynctake aMailboxOptions(withMetadata) before theCancellationToken.PublishAsyncandPostAsyncreturn the message'sMessageId, whichpublish_event'sevent_idandpost_message'smessage_idnow are;send_requestno longer returns acorrelation_id. The run event bus'shub.messagegainsmessageId?andmetadata?.post_messageandMailboxAddressdocument the fourth scheme,client://. - Removed, never answering:
IToolRegistry.GetToolsByTagsAsyncandGetToolsByCapabilityAsync(always empty — no tool carries tags or capabilities), andMcpServerOptions.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,KickoffAsyncNoWaitand both paths ofKickoffStreamingAsyncgo through the same point. A run delivers the construction events still queued (CrewCreatedEvent, …), thenCrewExecutionStartedEvent, thenCrewExecutionCompletedEventorCrewExecutionFailedEvent. A handler that throws is logged and skipped: theCrewOutputand the run's error are unchanged.SequentialCrewOrchestratortakes anIDomainEventDispatcherafter itsIExecutionPlanParser.DomainEventDispatcheris now scoped, so the scoped handlers resolve from the run's scope rather than the root provider. ICallbackHandlerreceives a step per tool call.OnStepStartedAsyncbefore each call of the agent loops (chat-client, native, text, streaming),OnStepCompletedAsyncafter it, with the tool's raw result andSuccess = falsewhen the tool failed, threw or was blocked by the guardian.StepNotifyingToolInvocationPipelinewraps the tool-invocation point;ExecutionOrchestrator.Callbacks(set byAddOrkeonApplication()) and an optionalICallbackOrchestratoronStreamingAgentExecutionServicefeed it.ICallbackOrchestratorgainsNotifyStepStartedAsync/NotifyStepCompletedAsync.- Removed, never raised:
AgentSpawnedEvent,CrewCompletedEvent,TaskBlockedEvent,TaskUnblockedEvent,TaskDelegatedEvent,DelegationCompletedEvent(with itsOrkeon.Domain.Delegation.Events.DelegationOutcome),DelegationQueuedEvent,AgentRegisteredForDelegationEvent,AgentUnregisteredFromDelegationEvent,HumanInputRequestedEvent, andTaskContextUpdatedEventwithTypedTaskContext<T>.GetEvents()/ClearEvents(). 33 domain events remain, each raised by its aggregate. - Removed, never invoked:
IStepCallback,ITaskCallback,IStepProgressHandlerandStepProgressContext;Agent.StepCallback,Crew.StepCallback/TaskCallback,CrewTaskBase.Callback, their*CreateOptions/*Snapshot/TaskOutputOptionsmembers and the matching parameters ofAgent.Create,Crew.CreateandCrewTask.Create;AgentBuilder.WithStepCallback,CrewBuilder.WithStepCallback/WithTaskCallback,CrewTaskBuilder.WithCallback;NullStepCallback,NullStepProgressHandler,NullTaskCallback. FromICallbackHandler:OnTaskProgressAsync,OnFlowStepStartedAsync,OnFlowStepCompletedAsyncand theirTaskProgressContext,FlowStepStartedContext,FlowStepIdentity,FlowStepCompletedContext. FromICallbackOrchestrator: theCallbackHandlersparameter (always null) and class,NotifyStepProgressAsyncwithStepProgressInfo;CallbackOrchestrator.NotifyToolUsedAsync/NotifyDelegationAsync;TaskCallbacksandCallbackExamples(withCustomWorkflowCallbackHandler).
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.CrewFactoryresolves them like an agent's — same registry, sameStrictToolscheck, 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, thenhuman_inputwhen the task asks for it), feeds the three agent loops, the streaming path, the prompt's tool list and the guardrails' tool rules, sohuman_inputnow reaches the native and text loops too. The.ork.tstaskBuilder().tools([...])takes the same path.CrewConfigurationMapperexports a task's tools. circuitBreaker:is removed and refused at load, at the crew root and on a task, with a message naminggraphConfig. The task block configuredTaskExecutionStateMachine, which no execution path ran; its three guard limits were read by nothing; the crew block was read by Graph alone, wheregraphConfigcarries 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, theCircuitBreakermembers ofCrewConfiguration/TaskConfiguration/CrewCreateOptions/CrewMappingSettings, andCircuitBreakerPolicyFactory.Resolve/CreateTaskFsm/CreateGuardContext;ResolveGraph(graphConfig, fallback)lost itscrewDefault. The genericStateMachine<,>engine andCircuitBreakerPolicystay (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-valueProcessType,VerbosityLevel,AgentType,TaskPriority) and its builders (ConfigurationBuilder.cs) had no consumer.Orkeon.Application.Execution.MemoryTypeandOrkeon.Domain.Agent.MemoryTypeare gone:AgentMemory.TypeisOrkeon.Domain.Memory.MemoryType, the one enum left.TaskConfiguration.TimeoutSeconds, which nothing set or read, is removed, andTaskConfiguration.RequiredToolsis renamedTools. - C#:
CrewTaskBase.RequiredTools/AddRequiredTool(ToolId),CrewTaskBuilder.RequiresToolandCrewTaskSnapshot.RequiredTools(opaque ids nothing filled) becomeTools/AddTool(IBaseTool),WithTool/WithToolsandCrewTaskSnapshot.Tools.GuardrailsPromptRenderer.AppendAgentAndTaskGuardrailstakes 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:Toolchainis read. No host bound it:EsbuildPathwas the first place the lookup claimed to search (the error message cited it) andEsbuildTimeoutcould not be changed. Every host now builds its transpiler withEsbuildTranspiler.Create(configuration)(ScriptingToolchainOptions.FromConfiguration):orkeon run, the shared runner,orkeon doctor,orkeon forge(its esbuild probe and its trial) and the REPL's*.cmd.tsloader.RunnerSettings.ReadConfiguration(settingsPath)gives a CLI path the settings file plus theORKEON_*variables before a host exists.orkeon typingswrites the editor typings.orkeon.d.ts(the DSL) is embedded inOrkeon.Scriptingby its build andorkeon-cli.d.tsin theorkeontool; the new verb writes both into./.orkeon/(--out <dir>), overwriting what is there. Adotnet tool installuser had neither. The pack item of the non-packableOrkeon.Scriptingand theorkeon-cli.d.tsresource ofOrkeon.Cli.Commands.Scripting, which nothing read, are gone. The dotnet tool still does not ship esbuild — the docs andorkeon doctornow say so and say how to get it (npm install -g esbuild,ORKEON_ESBUILD_PATHorEsbuildPath).orkeon forge --eventsno longer swallows the need. The option takes a value only when it isjsonl:orkeon forge --events veille des prixforges "veille des prix" (it used to send "des prix"). Studio's--events jsonlis unchanged.ctx.command.rawInputis the line the user typed (/deploy prod --force), not the command's name; acompletedreplay reads the line that launched its ticket.orkeon-cli.d.tsdeclares what the runtime serves.runCrewreturnsCrewRunOutput(not aPromise—.thenon it threw),"configuration"is no longer listed as a service key,services.get("commands")/get("script-host")are typed, and anargsschema gives the handler typed arguments (they wereunknown).scripts/check-scripting-typings.shnow typechecks everyexamples/**/*.cmd.tsagainst 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
llmsurface.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, andllm.anthropic()on an OpenAI host sentclaude-haiku-4-5to OpenAI.Orkeon:DefaultLlmProvider, which only renamed that provider, is removed with them, and so is thellm.defaultalias.LlmConfig.with(...)appliesmodel,temperature,maxTokensandresponseFormatand 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 anLlmConfig;withAgent(s)/withTask(s)refuse a builder callback or a plain object;withAutonomousTool(s)refuses anything but atoolBuilder()tool. actruns the agent's tool instances.ctx.llm.actoffers thewithAutonomousToolinstances next to the.tools([...])built-ins; the loop posts each call to a JS pump in theacttrampoline, which runs the tool'sexecuteon 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…), plusclrTypeandclr— including a rejection fromqueue.pop,ctx.receiveandact.BudgetExhaustedExceptionis declared asBudgetExhaustedError. - By name.
ctx.send,ctx.delegate,crew.removeandcrew.hastake an agent or its name.ctx.delegatenow runs exactly ascrew.runAgent: the delegated body gets its own context, its semaphore and itsonErrorpolicy (it used to receive noctx). - Smaller fixes.
agent.role;ctx.log.info(message, ...args)writes every argument;withTaskToolis removed (nothing read it). - The typings say what the runtime does:
ErrorCodelists the codes the mapper produces (ErrorCodeMapper.CodeToolError,CodeLlmErrorandCodeLockTimeout, never produced, are removed),ErrorContextis{ code, message, exception, attempt, agent },LlmCallOptionsis{ responseFormat, llm: { model } },ChatResponseis{ content, tokensUsed, model },actresolves to{ output, iterations },runStreamemitsagent.start/agent.stop,CrewRunOptionshas noinputs,PublishedEventhas nopublisherandEventTopicOptionsnomaxHandlers;withResponseFormat,withResponseSchema,crew.agents,crew.findById,ctx.crew,ctx.stateWithandreceive({ timeout })are declared. - Two gates.
TypingsRuntimeParityTestscompares each declared interface with its runtime type, member by member;scripts/check-scripting-typings.shnow typechecks every.ork.tsunderexamples/, not onlyexamples/scripting/. - C#:
JsEngineFactoryandLlmNamespaceBinding.Registerlose theirIConfigurationparameter;JsCrewBuilder.withAgent,JsExecutionContext.delegate/send/receiveandJsEventQueue.popchange 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):
grammaris a capability the configuration switches on.LlmProviderCapabilities.GbnfGrammaris 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 ofOpenAICompatibleProviderBase, both Ollama endpoints and Anthropic drop the grammar with a structured warning (event id 110) naming the key. Anthropic never takes it.structured_outputusesjson_schemaon a provider that declares it. The deliverable's schema now also travels as a non-strictjson_schemaresponse format (LlmChatOptionsKeys.StructuredOutput); the chat-client adapter sends the grammar to an endpoint configured for it, the schema to a provider whoseResponseFormatisJsonSchema, never both, and a response format the crew set itself still wins.StructuredOutputResolverkeeps parsing the answer.- Ollama refuses audio and file parts.
ContentConverter.ToOllamaMessagethrowsNotSupportedException, 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/generatefirst. - Removed:
MultiModalOptions.AutoResizeImagesandMaxImageDimension(nothing resized an image) andLlmLoggingExtensions.AddLlmExchangeFileLogging(no caller, and it registered neitherLlmLoggingOptionsnor the options singleton the RaggableTree embedding client reads). - A provider declares its capabilities by overriding
HttpLlmProviderBase.DeclaredCapabilities;Capabilitiesis 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.
A2ATaskRouterpicks the agent whose id equals theskillIdexactly — theidof a skill on/.well-known/agent.json— and runs an ad hoc task built frominput(itsmetadatabecome the task variables) throughIAgentExecutionService, resolved in the request's scope.Completedcarries the agent's output,Failedits error; a host withoutAddOrkeonApplication()getsFailedsaying 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 answersCancelled, the record endsCancelled), answers 409 for a finished task — whose record keeps its state — and 404 for an unknown one, store or not. - The server is hosted.
AddOrkeonA2AwithEnableServerregisters 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. CallingAddOrkeonA2Atwice registers one server. - The client authenticates.
A2A:Security:ClientAuthScheme(BearerorApiKey) andClientCredentialSecretNamemakeA2AClientsendAuthorizationon every task call, the secret read throughISecretProvider(new optionalsecretProviderconstructor parameter); a credential that cannot be read fails the call before anything is sent. - Removed:
A2AOptions.Enabled(callingAddOrkeonA2Ais the switch) andA2AOptions.RemoteAgents(no agent tool calls a peer;IA2AClientandIA2AAgentDiscoveryremain 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 byAddOrkeonApplication()) is called by the chat-client, native, text and streaming loops, the automatic-function-invocation path andctx.llm.act. It chains the Guardian's tool phase (ToolGuard: path traversal, SSRF targets, SQL injection outside the*_querytools) — or, fordelegate_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 aToolExecutionaudit event. A blocked call never runs; the model readsError: 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, nowBlock, a High or Critical pattern fails the task withAgentExitReason.GuardianBlockedand the pattern named; a lower one is a logged, audited warning. - Tool results are tagged, never rewritten.
Security:ToolResults:Policy(defaultWarn) is now read: the result reaches the model betweenDATA CONTEXT - NOT INSTRUCTIONSmarkers and each injection pattern leaves aSecurityEvent;Blockwithholds a High/Critical result and says so. Theemail_*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:Enabledis the real switch. TheStrippolicy, 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
ToolExecutionevent per call (never the arguments) and aSecurityEventper Guardian block or warning and per injection pattern in a result. - A2A credentials are validated.
Bearertokens go to the registeredIAuthenticationProviders —AzureAdAuthProvider(A2A:Security:AzureAD, signing keys now read from the tenant's OpenID configuration) andOidcAuthProvider(A2A:Security:Oidc), registered byAddOrkeonA2A(configuration)for each filled section;ApiKeykeys are read throughISecretProviderfromA2A:Security:ApiKeySecretNamesand compared in constant time. A rejected credential is a 401; a server that declares a scheme without a validator refuses to start. The validation isA2ACredentialValidator, public for other inbound surfaces. image_generationreadsOPENAI_API_KEYthroughISecretProvider(ORKEON_OPENAI_API_KEYby default); a missing key fails naming the secret.web_searchsends its Tavily key as anAuthorizationheader 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 inAddOrkeonInfrastructure(),IAuthorizationPolicywithClaimsAuthorizationPolicyandRoleBasedAuthorizationPolicy,ToolAccessGuardand itsToolAccessPolicyExtensions,GuardianPolicy.AllowedTools/BlockedTools/OutputGuardEnabled(tool access isToolAccessPolicy),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_generationnow listsORKEON_OPENAI_API_KEYamong 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:PineconeandOrkeon:LanceDbare bound byAddOrkeonInfrastructure().Memory:Provider, a crew'smemoryProvider:andOrkeon:Rag:Provideronly 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.
RedisMemoryProvidertakesRedisMemoryOptionsand opens its oneConnectionMultiplexerat the first call, safely under concurrent callers; an unreachable server is aRedisConnectionExceptionon that call, retried on the next.AddOrkeonRedisMemorybindsOrkeon: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.SupportedTypeslists the aliases; the RAG store validatesOrkeon:Rag:Provideragainst it instead of a copy. - ChromaDB, Pinecone and LanceDB take their client from
IHttpClientFactory(a named client per provider).AddOrkeonChromaDb/AddOrkeonPinecone/AddOrkeonLanceDbexpose the shared instance by its class. - Pinecone reaches the real index host:
Orkeon:Pinecone:Hostwhen set, otherwise thehostreturned by onedescribe_indexcall (GET https://api.pinecone.io/indexes/{IndexName}) made on first use. - Removed:
Memory:ConnectionString;Orkeon:Rag:ConnectionStringandOrkeon:Rag:ProviderOptions(RagStoreOptionskeepsProvider), and the Studio field that edited the former;PineconeOptions.Environment;IMemoryProviderFactory.CreateandCreateAndInitializeAsync,MemoryProviderConfigDtoandMemoryProviderConfigDefaults;MemoryProviderBase.InitializeAsync,ConfigurationandValidateConfiguration, and the DomainMemoryProviderConfigthey carried (itsRetentionPeriodandMaxItemswere read by nothing).MemoryServiceno longer takes anILoggerFactory.
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.
RunnerHostcallsAddOrkeonRag+AddOrkeonRagTools, soorkeon runin all its forms andorkeon-hostingest a crew'srag:collections when it loads, inject its agents'knowledge:into their prompts, and let an agent listrag_search,rag_ingestorrag_evalintools:. The CLI adds the ONNX reranker on every path (balanced/quality), not only for scripts.--validatestill ingests nothing. Thetxt_search/mdx_search/pdf_search/directory_searchtools, 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 unknownOrkeon:Rag:Providerfails the first ingestion or retrieval, no longer every crew. - An attachment retrieves through its profile: its
profile, elserag.defaults.profile(copied onto it at crew load), elseOrkeon:Rag:Profile. The augmenter runs that pipeline's retrieval half (IRagRetrievalCapable) — hybrid and rerank as the profile says, never a nested generation.correctiveandadaptivecannot retrieve alone and fail the task with a message saying so.min_scorenow filters on the score the profile reports (the cross-encoder's under a reranking profile). Orkeon:Rag:Collectionis the collectionrag_searchqueries when the agent names none (elsedefault), and the onerag_evalevaluates 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 arag:block already did. rag.provideris 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.KnowledgeContextAugmenteris built over anIRagProfileResolverand a default profile, andCitation.Contentcarries the full cited passage.AddOrkeonRagToolsis 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 isIBallotCollector(Orkeon.Application.Interfaces, defaultAgentBallotCollector); 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.
AcceptBestScorekeeps the last count's leader and re-runs nothing.ManagerDecisionasks 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.QuorumPercentandAllowAbstentionare enforced: the quorum is the share of expressed ballots; withAllowAbstention: falsean abstention counts against every answer. The dead copyVotingOptions.MaxVotingRoundsis removed —Orkeon:Consensus:MaxVotingRoundsis the one that counts.- The crew's input variables reach every execution and ballot;
IConsensualProcessStrategy.ExecuteConsensualAsynctakes 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.Successisfalse,Errornames every task that did not succeed and why, the execution hook hearsFailedwith that same reason, andorkeon runexits 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 hearsFailed, no longerCanceled, which stays for an actual cancellation. A failed task with no peer to delegate to fails the crew instead of throwingNo 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
Failfallback fails its task and skips its dependants instead of stopping the crew on the spot; the error still readsConsensus 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 readsTask 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.
CrewFactorykept a resolved tool only when it implemented the emptyIToolmarker, which the three RAG tools andMcpToolAdapterdid not. A crew listingrag_search(in a host that callsAddOrkeonRagTools()) or a tool of a connected MCP server failed to load underStrictToolswith anunknown tool(s)line whose available tools named that same tool, and lost the tool silently without it.AgentMapper.CreateFromRequestandCrewConfigurationMapper.ToDomainCrewdropped such tools without a word. All three now attach anyIBaseTool. - A tool name belongs to one tool.
IToolRegistry.RegisterToolAsyncreturnsfalsewhen 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:ServiceProviderToolRegistryandInMemoryToolRegistryused to overwrite. - An MCP tool named like a registered tool is refused. Before, a server exposing
file_readreplaced 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.RejectedToolNameslists 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. BothMcpToolProvider.ConnectServerAsyncoverloads now log alike. - Two DI tools with one name stop the host with an error that names them.
ServiceProviderToolRegistrythrew a bare "An item with the same key has already been added"; theInvalidOperationExceptionnow names the tool and both types. - The refusal of a
.ork.tsscript 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 theexamples/scripting/13-email-triageexample: a Gmail app password, theOrkeon:Tools:Emailblock,orkeon email accountsandcheck, the run, then how to adapt it (folders, the Send right behindSend: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 emailcommands 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.
- An E-mail section in the documentation index, EN and FR, holds the tutorial, the guide,
the
13-email-triage.appsettings.jsonraisesOrkeon:Scripting:Limits:ExecutionTimeoutto 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.mdgains the .NET Aspire integration (AddOrkeonHost,AddOrkeonCrewRun) and a telemetry section.
- Flows (FlowEngine) (
- 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
AddOrkeonRagalready 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 onlyIBaseTool.orkeon run crew.yamlregisters no RAG, sorag:andknowledge: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-hostconnects 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-reploptions. - The configuration reference gives the real keys of about 45 sections.
- The
.ork.tsreference 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.
- The CLI reference covers every command, option and exit code, and the
- 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.
- The README TypeScript crew ended with
- Smaller fixes:
index.mdsaid 14 providers, not 16.studio.mdEN 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:actdoes not seewithAutonomousToolinstances.- The
cli-ts-commandstranscripts gain their leading/. 97-multi-party-negotiationdoes ship one reference file underdata/.
Added — a dev channel: the latest main is installable between two tags
publish.ymlgains apublish-devjob. Once CI is green on a push tomain, every packable is packed as<props version>.dev.<CI run number>—1.0.1-dev.<n>after a stable1.0.0, which1.0.0-dev.<n>would sort below — and pushed to GitHub Packages only: never NuGet.org, which cannot delete a version. The newscripts/prune-dev-packages.shthen deletes the older dev builds, so the feed keeps each tagged release plus the latestmain. Tagged versions are never touched and dev builds are not attested.dotnet tool install -g Orkeon.Scripting.Cli --prereleaseagainst that feed installs the latestmain; the steps are in Update Orkeon (docs/getting-started/three-ways-to-run-orkeon.md), the mechanism indocs/reference/publication-matrix.md.scripts/test-prune-dev-packages.shproves the retention rules in CI against a fakegh— 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.ConsoleAppandOrkeon.GeneratorsREADMEs pin a release with--version. On the GitHub feed,--prereleasenow 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 --versionto check, thePATHand Studio traps when a package already installedorkeon, 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 thatorkeon --versionexits1: it prints the version and exits0.
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 theOrkeon.Toolsumbrella, and the second motivated exception to the scope freeze, decided by the owner on 2026-09-26 (an.ork.tsscript 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, andemail_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:993orpop.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;Nonetowards 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 accountProvider,Address,DisplayName, a mandatoryRightslist (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;Fromis forced;MaxRecipients/MaxPerHourcap the volume;email_draftis 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 itsToolAccess, andorkeon forgekeeps 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, andnext_cursor/next_offsetresume exactly there. - OAuth2, written by hand, and
orkeon email. Device code for Microsoft, authorization code with PKCE on a127.0.0.1listener for Google — with a paste-the-address fallback for WSL, containers and SSH — and refresh with rotation; no MSAL, no Google SDK. The new verborkeon email accounts | login | logout | checklists 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 throughPrivilegedFileSystemAccess; physically<per-user settings directory>/credentials/email/, or theemailsubdirectory ofCredentialsDirectoryfor a service, owner-only on Unix. A user mount claiming/credentialsis 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 byorkeon-repl, where OAuth accounts are refused for want of a token store; theOrkeon.Toolsumbrella 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 declaretools.email*— arguments and results keep the tools' own snake_case keys (unread_only,reply_to_id,new_name) — withexamples/scripting/13-email-triage.ork.ts. Documentation: the e-mail guide, the tool inventory, security, configuration, CLI, limitations and VFS pages, ADR-012 and theSECURITY.mdthreat model, EN and FR.THIRD-PARTY-NOTICES.mdgains MailKit, MimeKit and BouncyCastle.Cryptography, now redistributed inside theorkeonandorkeon-repltools 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 registersemail_parser;AddOrkeonEmailTools(configuration)does, and both shipped runners call it — a crew listingemail_parserunderorkeon runororkeon-replneeds no change. A host of your own adds the call. The public typesOrkeon.Tools.FileSystem.EmailParserTool,EmailParserRequest,EmailParserResponseandEmailAttachmentInfoare removed, no shim. - Parameters.
path(the virtual path of the.emlfile),offsetandmax_chars(the body comes in slices of 200 to 3000 characters, 2500 by default;next_offsetcontinues).extract_attachmentsandparse_htmlare 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— withfolderset to the file's path. Migration: readtextwherebodywas;headersandpriorityhave no successor; an attachment'sfilenamebecomesfile_nameand itsencoded_size/estimated_sizebecome onesize_bytes. .msgis no longer supported. It was never parsed — the old tool returned a placeholder for it. Save an Outlook message as.emlbefore handing it toemail_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 toSystem.Double— andToolParameterValidatoraccepted onlyintandlongfor anintegerparameter, sotools.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 — adouble, afloat, adecimalor a smaller integer type — which is JSON Schema's own definition of an integer; the typed deserializer already turned20.0into20. 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 theorkeonandorkeon-repltools and the installers, which is the file's own criterion (a), yet had no notice. The package ships no license text and the upstreamLICENSEcarries 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 versionDirectory.Packages.propspins, instead of the1.7.2it 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 inlibexec\orkeon\orkeon.exe, a directory the lookup never probed;bin\onPATHholds only.cmdwrappers, which the Windows lookup (orkeon.exeonly) rejects. Studio therefore reported « the orkeon command-line tool was not located », or silently drove an olderorkeon.exefound onPATH(a global dotnet tool).OrkeonBinaryLocatornow probes thelibexec/orkeonsibling 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, formerlyCount). 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
lastRunAtand stampsaddedAtinstudio-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
lastRunAtonce 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.ImportandUseCaseImporter.ImportAsynctake the arrival date.ArchiveChangednow carries every folder one gesture moved (ArchiveChangedEventArgs.Paths).
- A card's last run falls back on the sidecar's
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
-2past another session's name); session.json,forge.json, Studio'sstudio-team.json(itsnameonly — every other field kept), the title and install command ofFORGE.mdand 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, orFORGE-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 eventteam.renamed;--nameis no longer reserved topromote, and--referenceis now refused onschedule/unscheduleas on the other folder verbs.- the folder takes the name's folder (the one folder rule); the session rule R links to it follows
(suffixed
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.
Added — Studio archives a team: out of the active list, every link kept (STUDIO-31)
- 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.Listtakes 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— stampslastRunAtinto its team; a team's last activity is the most recent of that date, its latest history entry andforge.jsonpromotedAt. - 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 seamforge renameshares (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 runand 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 itsdata/;- 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--langas 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 reopenrebuilds a session fromcrew/(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 withUSECASES-DESTINATION-NOT-EMPTY.--events jsonlanswers withusecases.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.TeamSidecarFileandUseCaseEventKinds.Exportedjoin 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>.
--checkanswers installed, absent or stale.orkeon forge unscheduleremoves the registration andschedule/.- a Windows task
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.
- An OS refusal is
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.jsonreference, announced onsession.started), and a resume or aforge reopencomposes with it again. - The promotion traces it: « Inspiré de :
<title>(<id>) » inFORGE.md, andreferenceinforge.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.jsonis 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.updatedgains an optionaloperation: the kind of work the engine attributed the call to —agent,manager,planning,rag,memory,flow,judge, or a script'sctx.llm.*method. It is omitted for a call no scope claimed, and the envelope staysv: 2.- Studio's
RunCost.Model/Providerfollow the agents' own calls only, a script'sctx.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.EstimatedTokensandRunProgressModel.FinalEstimatedTokenscarry 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.
MeteredLlmProviderwraps every provider thatLlmProviderFactorybuilds, and every hand-made provider registered through the newAddOrkeonLlmProvider(...). It reports each call, buffered or streamed, toILlmUsageSink. With no sink registered, providers stay bare.- The live
cost.updatedand the finalrun.finished.tokensnow count calls they used to miss: the hierarchical manager, planning, agent-loop retries and fallbacks, the RAG pipelines, flows, memory and LLM judges.
- The live
- Attribution.
LlmUsageScope, anAsyncLocal, names crew, agent, task and operation (agent,manager,planning,rag,memory,flow,judge,ctx.llm.*). A call no scope claims is counted asunattributed.CostUsageEventgainsTaskId. - 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.updatedandrun.finishedgainestimatedTokens, 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).
- a source scan (providers built only by the factory or through
- 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 listanswers:- 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 searchsession 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
Balanceslot 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 titlesFORGE.md,forge.jsonand 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.jsonandforge.jsontake the new slug.- The new event
session.renamed {from, to, dir, suffixed}announces it, and Studio follows it.
- When another session already has that name, a
- A rename the disk refuses is a warning, not a failure. The promotion still exits 0, and a
new
warning {code, message}event carriesFORGE-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 taskOrkeon <team>, the install command, the launchers' header, andFORGE.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.BuildPromoteandForgeClient.PromoteAsynctake the team name.
Added — Studio: the progress model holds everything in flight (STUDIO-30)
RunProgressModelnow exposes:- every tool at work with its start (
ActiveTools;ActiveToolNamederives from it) and the call tally (ToolCallCount,SucceededToolCalls,FailedToolCalls); - the delegations under way (
ActiveDelegations, fromdelegation.starteduntil itstool.returned) and the spawned agents (SpawnedAgents); IsWaitingForAnswer;StartedAtandElapsed, with an injectableTimeProvider, frozen at the run's own duration once it ends.
- every tool at work with its start (
- A call still open at
run.finishedmoves toUnfinishedTools/UnfinishedDelegationsand is never counted as a success. ChangedbecomesEventHandler<RunProgressChangedEventArgs>. ItsKindnames the event that changed the state, so a screen can skip per-tokenllm.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 jsonlwithout a text opens a session:usecases.ready, then oneusecases.resultsperusecases.queryline on stdin, correlated bycorrelationId. The model loads once, and closing stdin exits 0. The kinds are declared inOrkeon.Constants.Protocol.UseCaseEventKinds. listfilters by category, process and tag.show <id>prints a sheet and its files, plus its crew file with--crew. An unknown id isUSECASES-UNKNOWN-ID. Both also answer in--events jsonl.- Embedded in the tool:
examples/usecases.json, each example's crew file and itsdata/folder, about 217 KB compressed. The finance examples stay reference only: their shared_tools/is not embedded. - Golden set:
examples/usecases.golden.yamlholds 22 queries in the five languages, andUseCaseGoldenSetTests(Slow) reports recall@5 and MRR per language and per mode.
Changed — a stable session id and one rule link a team to its forge session (STUDIO-25)
- 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 onsession.started, and copied byforge promoteinto the team'sforge.json. - A rebuilt session gets a new id.
- A forge session gets an id (GUID) at creation. It is written to
- 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
promotedTodesignates the folder; - it is also linked when that folder is gone or no longer carries the id: the team was moved or renamed;
- when
promotedTodesignates 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).
- it is linked when its
forge reopenapplies rule R.- A moved team resumes its session:
promotedTois re-pointed, and there is no more-2duplicate. - 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.
- A moved team resumes its session:
forge promote --toupdates 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.FindPromotedToandIsSameDirectory. - New:
ForgeSessionCatalog.FindById/ReadTeamSessionId,TeamSummary.ForgeSessionId,ForgeSessionModel.SessionId.
- Removed, without a shim:
Added — the 105 use cases state the user's problem in five languages (STUDIO-37, draft)
- Every
usecase.yamlnow 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.pynow 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.yamlbeside 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.pyalso writes the deterministic manifestexamples/usecases.json, adding the derived fields:- format, process, agent and task counts, tools;
hasSampleData(adata/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_datanow means "adata/folder exists", soexamples/INDEX.mddoes not change when the new sheets are added.lint-example-configs.pychecks 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
.aihost, CNY on the.cnone) 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.
- DeepSeek, Kimi (USD on the
- 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.KeyConsoleUriandLlmPresets.KeyConsoleForgive the https link of the vendor console, from the existingKeyConsoleUrltext.- 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 throughFolderSlug, public inOrkeon.Domain.FileSystem: lowercase ASCII, accents dropped, one dash between words, 64 characters cut at a word — andnullwhen 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.SlugifyandTeamCatalog.MaxSlugLengthare removed, without a shim;TeamCatalog.MaxNameLengthisFolderSlug.MaxLength. A new agent whose name holds only spaces previews the keyagent, as an empty name did, instead of throwing from the slug rule.FolderSlugDriftTestsfails 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.updatedoforkeon run --events jsonlnow carries the run's cumulativepromptTokensandcompletionTokens, and the cache paircacheHitTokens/cacheMissTokensonce a provider measured it — the fieldsrun.finishedalready had. The event names theprovideron the YAML path too, and its envelope carries thecrewId(the agent's role staysagentId). The envelope keepsv: 2: the fields are additive, andrun-event-bus.mdnow 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 thecostmetadata, and it died at the chat client adapter. It now travels as billed — the provider states its currency beside it (cost_currency,USDfor OpenRouter's dollar credits), the adapter carries both onto theChatResponse(buffered and streamed fallback), the agent loop and the scripting facade put them on the usage event, andcost.updatedrelayscost,currencyandcostSource: "vendor". A free model bills0, relayed as0; 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.Costisdecimal?(breaking): null means unknown, andCostBudgetManagerprices from its registry only a null — a vendor's0used to be read as "not provided" and charged at the registry price. The event also gainsCostCurrency, and the agent loop now fillsProvider,CrewIdandOperationType(agent).LlmResponse.Costis removed (breaking): nothing read or wrote it; the charge travels in the metadata and is read withLlmVendorCost.TryRead.- Studio's
RunProgressModelfolds the new fields intoRunCost(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.CSharpreference from 4.8.0 back to 5.9.0 — the repository's own compiler — and1.0.0-rc.4of 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 withCS9057and skips it silently, so a consumer project with aFile.ReadAllTextcall builds clean. TheVersionOverrideis 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
Llmsection at all: its provider was the infrastructure's keyless OpenAI default, so "NoLlmsection 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.RunnerHostnow registers the echo provider itself (UndefinedLlmProvider, the one the scripting facade answers<undefined-llm>with) asIBasicLlmProviderandIChatClientwhen 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
S2583bugs ofToolCallTextParser(the JSON block scanner is now an explicitBlockScanstate with one method per transition), the sixteen methods above the cognitive-complexity ceiling (MountSelection.Resolve,RunnerHostconfiguration,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.UnknownMountIdsandTeamTarget.UnknownMountIdsare methods now — a property must not copy a collection.ImportTeamViewModeltakes anImportTeamDependenciesrecord, like the other Studio screens.McpToolProvideris sealed. Every false-positive arbitration lives in the code, as a[SuppressMessage]or#pragmawith its justification (13 × S3604 on primary constructors, 2 × S1168 third-state nulls, the JS-called members ofJsLlmFacade, 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)
TogetherAiLlmProvidersends the 4096 fallback again, not the model's window. LLM-10 named the window as the cap on Together (131 072 onLlama-3.3-70B-Instruct-Turbo, up to 1 048 575 onGLM-5.3-Flash) on the assumption thatcontext_length_exceeded_behavior: truncateclamps 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 fourtogether:entries are withdrawn fromLlmModelOutputLimits; 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_exceededor "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-astrais pinned totemperature: 1inllmproviders-test/lib/catalog.json(Only the default (1) value is supported) and, unlike Sol, has noreasoning_effort: none(Supported values are: 'low', 'medium', 'high', and 'xhigh'): function tools stay refused on chat/completions (use /v1/responses). Both facts are indocs/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,--eventsits only option) names the session whosepromotedTois the folder when one exists, and otherwise rebuilds one from the folder itself: the plan is read back fromcrew/(per-entity or single-file YAML) into a blueprint, the brief comes from the newforge.json, the crew is copied verbatim, and the session lands at the--drypause withpromotedToset —resume --edit --dry,resume,resume --adoptand apromote --toonto the same folder follow as usual (ForgeSessionRebuilder,ForgeTeamReader,ForgeTrigger.Rebuilt, eventteam.reopened {slug, dir, path, state, rebuilt, brief}). A folder with no readable YAML crew is refused withFORGE-TEAM-UNREADABLEand the reasons. forge promotewritesforge.jsonnext toFORGE.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 saysbrief: 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 runsforge reopenon 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.ModifyNoSessionreworded, 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-idagainst 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:Mountsmay carry a 26-character ULID before a|—01J9Z3K4M5N6P7Q8R9S0T1V2W3|C:\data:/output:rw(FileSystemMount.Id,MountId, strict Crockford validation ahead of the lenientUlid.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.yamlgain amounts:block —/output, or<ulid>|/outputto pin one settings entry (CrewConfiguration.Mounts,MountReference);forge promotewrites 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):--mounton the root replaces every entry of that root, else--mount-id, else the crew'smounts:, 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 tonullat its own index, not whitelisted, its folder not probed.RunnerHostapplies the sameMountSelection.Resolvewhile 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-idfor a declaration and--mountonly 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/outputrows 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_mountsand the access-denied messages never show an id (D-08).- The settings half of the duplicate-root guard reads
Orkeon:FileSystem:Mountswith its indices (RunnerSettings.ReadDeclaredAgentFacingMounts);EnsureMountSourcesExistskips the entries a selection withdrew; the runners pre-read the crew'smounts:block from disk (CrewMountDeclarations, anEXCEPTION-BOOTSTRAP) so the refusal comes in one line before "Using settings". - The
orkeon-hostdaemon stays out of the selection (D-11): per-crew roots, an id prefix on an operator--mountparses, no crew block is read. Astudio-team.jsonwritten 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 itsSystem.*companions to 10.0.12,Microsoft.Extensions.AIto 10.10.0,Microsoft.Agents.AI.Abstractionsto 1.22.0,Aspire.Hostingto 13.5.4,Microsoft.Data.SqlClient7.1.0,MongoDB.Driver3.12.0,Gremlin.Net3.8.2,StackExchange.Redis3.3.0,AngleSharp1.8.2,Polly8.8.0,Markdig1.4.0, theIdentityModeltrio 8.23.0,Azure.Security.KeyVault.Secrets4.11.1,AWSSDK.SecretsManager4.0.100.14,OpenTelemetry1.19.0,Microsoft.ML.OnnxRuntime1.30.0,Terminal.Gui2.5.0,Jint4.16.3; on the test sideMicrosoft.NET.Test.Sdk18.10.1,xunit.v34.0.1 andTestcontainers4.15.0.Orkeon.Compliance.Vfsis built against Roslyn 5.9.0, the compiler the repo runs, instead of 4.8.0;Orkeon.HostreferencesMicrosoft.CodeAnalysis.CSharpdirectly. 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:TimeoutSeconds180), 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 — raiseLlm:MaxTokens" and retried once without tools, for a second full timeout: six minutes, zero tokens, wrong advice. Now the provider's failure travels asLlmResponse.Error(LlmResponseMetadataKeys), the bufferedLlmProviderToChatClientAdapterpath throws it the way the streaming path already did, and the loops exitAgentExitReason.LlmCallFailedat 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 withinLlm:TimeoutSeconds= 180 s … raiseLlm:TimeoutSeconds(600 s is a safe value for a reasoning model), or turn thinking off", naming the settings key, the crewllm.thinking.enabledblock and the Studio switch. - An HttpClient timeout is retried — once. The retry clause written as
!ex.CancellationToken.IsCancellationRequestednever fired on a real timeout (HttpClient cancels its own linked token), so every timeout failed on its first attempt whateverLlm:MaxRetriessaid.ResiliencePolicies.IsHttpClientTimeoutrecognises the shape (a nestedTimeoutException); 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 whenMaxRetriesis 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
⊘ skippedinAUTO_SUMMARY.md(with a Skipped count), astask.completedwithskipped: trueon the event stream (RunTaskProgress.Skippedin 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/ThinkingEfforttravel asORKEON_Llm__Thinking__{Enabled,Effort}; the profile editor offers provider default / on / off and the effort hint;LlmSectionreads and writes the same keys, the validator types them, and the TUI form has aThinkingfield. Picking Kimi, DeepSeek, Z.AI or MiniMax — whose default model reasons before it answers — pre-fills the timeout withLlmPresets.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 byEngineDefaultsDriftTests. The watermark is a theme feature: anyInputtext box orComboBoxshows itsTagwhile 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 runhonours theMCPsection. 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.RunnerHostnow callsAddOrkeonMcpwhenMCP:Serversdeclares at least one server andMCP:Enabledis notfalse, and an explicit startup step (McpStartup) connects every server before the crew loads — and before--validatejudges it and--list-toolsprints 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 underStrictTools.McpToolProvideralso implementsIDisposableso a host disposed synchronously releases the child processes.ConfigurationKeys.McpSectionspells 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 ofbrave_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, theshell_commandallow-list (Orkeon:Tools:Shell), never written as an empty array. The catalogue lives in Core (ToolCatalog) and a test pins it againstdocs/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
MCPsection as cards: the switch and one card per server (identifier, transport, command, arguments, environment, URL), written in place through the newMcpSectionso 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-SECRETat information level for a secret written in clear).SecretRowViewModelis 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,FieldShadowBrushin 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 newInputPasswordstyle, bound throughPasswordBinding.Text(WPF keepsPasswordout 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,
InputMultilineandInputMultilineMono, onMinLines/MaxLinesrather 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 hardMinHeight/MaxHeightthose 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
Promotedbefore it emitspromoted, and the shell re-reads the catalogs onTeamAdopted; 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 bypromotedTo) stays the way to reopen an adopted team, and the reopened arbitration offersretry. Nothing is deleted on disk. - Deleted with the card:
IsSaved/NotSaved,SavedPath,InstallCommand,ReopenComposeCommand,RetryTrialCommand,ReopenAdoptedAsyncand the auto-retry flag, the card's markup, eightStudio.Create.*strings in five languages. The expert-only scheduling hint (installof thepromotedevent) is no longer displayed: the schedule lives in the sidecar, on the team card and in the team'sschedule/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 inMainWindow.xaml, themodale-declarer-dossiercapture stop, elevenStudio.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 (rwndnarrows 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.ListSubdirectoriesand theLeftIndentconverter leave with their only consumer, the tree.
Fixed — Studio opens on the per-user settings file (STUDIO-18)
- The window loads
%APPDATA%\Orkeon\appsettings.jsonat startup ($XDG_CONFIG_HOME/Orkeon/appsettings.jsonelsewhere) — the fileorkeon initwrites 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
Llmsection, 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.MaxTokensis a pin, nullable, null by default. Nothing pinned means the request carries the model's documented maximum output from the newOrkeon.Constants.Llm.LlmModelOutputLimitscatalogue (each entry with its vendor page and the date it was read, 2026-09-19): 128 000 ongpt-5.6-sol/gpt-6-astraand the Claude 5 generation, 393 216 ondeepseek-flash, 131 072 onkimi-k3(the vendor's own default), the GLM-5 and Qwen 3.7/3.8 families andMiniMax-M2, 65 536 on Gemini 3.x Flash, 128 000 ongrok-4.6; no cap at all where the vendor documents none (Mistral: prompt plusmax_tokensmay not exceed the window, so the field is left out; Ollama:num_predictis left out, the runtime generates to its context); the window itself on Together, whose provider now sendscontext_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'smax_tokens— always wins, including an explicit 4096, which the old!= 4096sentinels 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.TryAdaptRejectedPayloadnow 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 initwrites noMaxTokens; the example settings templates drop theirs where the model is in the catalogue. - Breaking in the public API:
LlmConfig.MaxTokensisint?,CreateValidated(maxTokens)takesint?(null = unpinned),OllamaRequestOptions.Builder.AddNumPredict(int?), and the YAML exporter writesmaxTokensonly 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.startedjoins the run event stream (orkeon run --events jsonl): every orchestration mode announces a task the moment its agent is chosen, through a newICrewExecutionHook.OnTaskStartedAsync(TaskStartSnapshot: task, agent role, start time) dispatched byCrewHookDispatcherlike the completions. The payload is deliberately thin — nothing has been measured yet. The envelope stays atv: 2: an older client ignores the kind, and a client must not refuse atask.completedit never saw started. The hierarchical mode'stask.completednow carries the agent's role underagentRole, as every other mode does, instead of the agent's GUID.- The Run screen shows what is running now.
RunProgressModelfoldstask.started/task.completedinto an in-flight list andtool.called/tool.returnedinto 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 noTargetName;CapturePoseholds 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_tokensand says that the tool-free retry cannot call tools and that a reasoning model needsLlm:MaxTokens16384 or more. Owner recette 2026-09-19: akimi-k3profile withoutMaxTokens(engine default 4096) spent the budget reasoning, answered empty, and the tool-free retry narrated the.docxinstead 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.DeepSeekisdeepseek-flash. DeepSeek retired V4 Flash and V4 Flash Vision Exp on 2026-09-10 with the V4.1 Flash release:deepseek-v4-flashanddeepseek-v4-flash-vision-expare legacy names the API "temporarily" routes to V4.1 Flash, anddeepseek-flashis 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, theorkeon inittemplate, the Studio DeepSeek card, the examples and the guides name the new id, and the kit'svisionModelcompanion 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.ModelPricingRegistryfollows the vendors' pricing pages (read 2026-09-19). OpenAI:gpt-5.6-sol4 / 20 $/M (promotional through 2026-11-21; was 5 / 30),gpt-5.6-terra2 / 12,gpt-5.6-luna0.20 / 1.20,gpt-6-astra10 / 50 added (its 2× billing above 272K input tokens is not expressible in a flat registry). Anthropic:claude-sonnet-52 / 10 (the rise to 3 / 15 was cancelled),claude-fable-5-1andclaude-fable-510 / 50,claude-haiku-4-51 / 5 added.- Catalogue review of the 16 providers.
docs/reference/llm-providers-comparison.mdgains a "Defaults and newer models" section (EN/FR) and theLlmProviderDefaultModelscomments carry the dated findings:gpt-6-astra(nononeeffort, 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), theglm-5.3family (thinking cannot be disabled),qwen3.8-max/qwen3.8-flash(noqwen3.8-plus),kimi-k3(fixed sampling, always reasons),MiniMax-M3, Together'szai-org/GLM-5.3-Flash, HuggingFace'sQwen/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 andresume): 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);promoterefuses the option, since it mounts nothing. A read folder outside the process working directory is whitelisted for the file tools the wayorkeon runwhitelists 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.TeamCatalogresolves the entries once, at its boundary (Describe,DescribeTargetandListreturn absolute paths; the raw entries stay onMetadata.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.RebaseMountsis removed.DeclaredMounts.IsInsideTeamis public and vouches for a./entry before the team folder exists;MountValidator.Validatetakes an optionalteamDirectoryand skips the existence check of a relative entry until one is known.TeamMountPaths(Studio.Core) is the one helper for the convention, andFolderPolicynames 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 forgerefused any settings file whoseOrkeon:FileSystem:Mountsnamed/workspace,/forgeor/output(ERROR: '/output' is a virtual root reserved by the runner…, exit 1). That guard predates STUDIO-15: since a--mountis placed by virtual root, the forge's own three mounts replace such an entry for the trial, and theDuplicate virtual pathscrash 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/sandboxalone (the one root it does not mount itself); a settings entry on/workspace,/forgeor/outputis replaced for the trial and logged asmount /output: --mount replaces the settings entry, a line the forge now lets through to stderr.RunnerVirtualRoots.ForgeReservedis 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 globalOrkeon: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. KeysStudio.Settings.TeamFolders{Title,Intro,Empty,Row}in the five cultures; the capture seed givesrapport-hebdoan in-team./output:/output:rw, photographed byreglages-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 »
/workspaceread, « The results »/outputwritten); « 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,AddRootHintin the five languages; theetape1-dossiers-existantsstop 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/outputno longer reads red on its card. Theinput/warning stays for a read root answered inside the team: thatinput/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(), replacingWithDerivedWriteMounts(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./outputreads « 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 owninput/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--readmeets it only when a folder is known, and then refuses it on the failure card (STUDIO-13). - The Run screen turns
--allow-external-mountson 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.Opentakes aninitialRights; three capture stops (etape1-dossiers-existants,etape1-dossiers-equipe,etape2-dossiers-dans-equipe); fourteen newStudio.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
TextBlockrenders line breaks even without wrapping and has noMaxLines. The name is now one line everywhere it is displayed (run card, team card and its tooltip, launch history) throughTeamCatalog.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
descriptionafter 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 readTeamSummary.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/outputinto one character per line. The row now puts the name first, never shrunk, and the badge last in one word (MountEditorViewModel.RightsBadge,MountRightsTokens.GetBadge, keysStudio.Settings.RightsBadgeRo/Rw/Rwndin the five cultures) with the full label as its tooltip. - The three
DisplayMemberPathdrop-downs (the two rights lists, the trial screen's team picker) showedMountRightsChoice { Rights = ReadWrite, … }once closed: the globalComboBoxtemplate boundSelectionBoxItemTemplatebut not the item template selectorDisplayMemberPathgoes through. The template now bindsContentTemplateSelectorandContentStringFormatlike 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-equipeandequipes-liste;reglages-dossiers-selectionnow 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)
RunnerHostplaces every--mountby virtual root. On a root the declaredOrkeon:FileSystem:Mountsarray (settings file andORKEON_environment) already holds, the--mountis written at that entry's index and replaces it for the run — logged asmount /x: --mount replaces the settings entry; on a new root it is appended after the highest declared index. A settings entry and a--mountnaming the same root used to reachFileSystemRegistryas two mounts and fail every such run at kickoff withDuplicate virtual pathsout 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.InternalMountskeep appending. Only a case that failed changes outcome.RunnerExecution.EnsureVirtualRootsAreUnique(public, wired in the YAML runner'sTryBuildHostand inorkeon run's script path): two--mounton 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); theCrew execution failedlog entry carries the message only, and the exception with its stack trace moves to aDebugentry (--verbose 2, orORKEON_DEBUG=1on stderr). - A mount declared in the settings is always whitelisted for
PathValidator(STUDIO-12 C4): its base path joinsPathSecurity:AdditionalAllowedDirectorieswithout 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-mountscould not rescue it since it only whitelists--mountarguments — which it still does, and only that. - Studio predicts the by-root rule (
MountOverrideSemantics.ComputeEffectiveMounts, theStudio.Settings.Explanation/ThisLaunch/EffectiveReplacedstrings 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/crewmount appended after the declared entries — instead of the index-0 masking that never happened. An empty--mountentry is reported against the--mountoption 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--settingsfile, 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.
CreateTeamViewModelcarries one failure model,WizardFailure(Kind,Headline,Detail,CommandLine,ExitCode,Stderr,EngineError,Journal), exposed asFailure/HasFailure, withBuildFailureReport(),CanCopyFailureReportandFailureReportCopiedon the diagnostic screen's pattern. Five families, classified on the run outcome, the engine'serrorevent and the exit code:EngineMissing(the locator found no binary —NotStarted),ConfigRefused(anerrorevent withrecoverable: false, aFORGE-*code),EngineStopped(non-zero exit, with or without stderr — and a session that reportedfailed),Unknown(an exception out of the launch, which used to reach aMessageBoxat best —RunEngineAsyncnow catches it, cancellation excepted) andPromoteRefused(step 4, nopromotedevent). « Arrêter » never produces one.- The report is the
orkeon forgecommand 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. CreateTeamViewshows 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 faultMessageBoxof the other commands are untouched.Studio.Create.StatusFailednow 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 (TaskExecutionOrderin the Domain,CrewTaskSequencerin 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, soconsolidate.yamlran before theextract.yamlit 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" fromcrew.Taskswhen 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 asCompleted; the task fails with the reason inTaskResult.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 theerrorrun event), and the one-shot runner exits 2 withERROR: <reason>as its last stderr line — it returned 0 for every crew failure, sorun.finishedsaidsuccess:trueover an empty output mount. The reason namesLlm:MaxTokens, the setting that usually explains it for a reasoning model. - Studio:
MaxTokenson the model profile.ModelProfile.MaxTokens(null = the engine default, 4096), emitted asORKEON_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.jsonloaded zero profiles, silently; a file that fails to parse was indistinguishable from an empty one.LoadAsyncnow returns aModelProfileLoadResultwhoseErrorthe 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/*.ymlfile as that file (RunTargetKind.SingleFileCrewDirectory: run path = the file, selected path = the folder, at the root or under the promotedcrew/nesting); several YAML files resolve tocrew.yamlthenconfig.yaml, else are offered as candidates.TeamCatalog.Importruns 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
onCrewStartthat throws fails the run and reachesonCrewError(it ran outside the error path before); a run started on an already-cancelledsignalskipsonCrewStart, andonCrewErrorstill runs (a C# caller with a cancelled token getsOperationCanceledExceptionbefore any hook). AnonCrewErrorthat 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 codeunknown, then throw at the next step anyway). Anderr.codefor a failure that arrived as a faultedTaskmaps from the innermost CLR exception (receive_timeoutfor actx.receive({ timeout })that expired, …) instead ofunknownfor the wrapper. - An async
onAgentStart/onAgentStopthat rejects is logged as a warning; it no longer throws out ofcrew.add,ctx.spawnorcrew.remove, which stay synchronous and never drain the hook. crew.runAgentruns its target under the instance semaphore, with anAgentContextand the agent's ownonErrorpolicy; it accepts a name or anAgent, honoursopts(signal,timeout), and throwsRecursiveAgentInvocationExceptionwhen called on the agent whose body is executing instead of deadlocking on the semaphore that body holds. It used to invokebody(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 explicitsignalremains 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 bridgedOperationCanceledException(clrType,message) as a raced body await, not Jint's raw cancelled-task object. crew.runStreamis the run, observed as a stream: same semaphore, contexts, hooks and spans asrun;atis epoch milliseconds (Date.now()) instead of .NET ticks;breakout of thefor awaitends the run without firingonCrewCompleteoronCrewError.ExecutionTimeoutandMemoryLimitBytes(Orkeon:Scripting:Limits, 30 s and 100 MB by default) span a whole CLR-driven run — theglobalThis.crewhandoff throughScriptHost.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.RunAsyncandJsTool.CallAsyncpropagate cancellation asOperationCanceledException— a 30-minute wait that ignored the token, and a failedToolCallResponse, 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).
- A JSON envelope written as text is a tool call.
ToolCallTextParsergains the third shape next to[TOOL_CALL]and<invoke>:{"name", "parameters"|"arguments"},{"type":"function","function":{…}},{"type":"function","function":"<name>", …}, atool_callsarray, fenced or not, with raw line breaks inside strings repaired before parsing. - 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 —
LooksLikeToolCallAttemptrequires the envelope vocabulary and one of the agent's tool names, so a JSON deliverable is never mistaken for one. - 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:1bstill 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.SupportsStreamingfollowsIsConfiguredinstead of being an unconditionaltrueon 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'sfor awaitcompleted 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 scriptingllmfacade) see it change with the configuration.AgentWorkloadTrackerandTaskExecutionRoutertake an injectedTimeProvider. 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),NuGetAuditis declared rather than inherited as a side effect of-warnaserror, and a tag carrying a prerelease suffix now publishes as a prerelease instead of becomingLatestby 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-Afterpolicy test reads a monotonicStopwatchinstead ofDateTime.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.TestsEventHub,Callback,Analysishybrid 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
S3358nested ternaries, 18S107over-long parameter lists, 11S125commented-out code, 7S3267loops replaced by LINQ, 5S1168null 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:S101onI18n(the rule proposes18N),S3604onLock _gate = new()fields of primary- constructor types,S107on[LoggerMessage]partials,S1168wherenullis a third state the caller reads (ICrewLinkProvider.LinksFor, the shell-tool allowlist),S2737on catch clauses that exist to carry an exception filter,S3925on the EventHub exceptions,S3871on 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 xS4792(the framework's own logging wiring), 2 xS5443(/tmpis 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 inSequentialProcessStrategy,GraphProcessStrategy,AutonomousProcessStrategyandConsensualProcessStrategy.Orkeon.Rag.Pipeline.StagedRagPipelineDependenciesandOrkeon.Rag.Pipeline.IngestionPipelineDependencies(new) replace the optional collaborator tails ofStagedRagPipeline,CorrectiveRagPipelineandDefaultIngestionPipeline.- The remaining
S107sites inOrkeon.ScriptingandOrkeon.Hostingfollow the same shape; every move is declared in the affected projects'PublicAPI.Shipped.txt(theUnshippedfiles 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 threehumanInputreviews, 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
_toolsTypeScript module replacesOrkeon.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 theRandom-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 theexamples/_sharedlibrary — from both solutions and from the disk.publish.ymlno longer packsOrkeon.Runners.Shared: that package is discontinued.MathNet.NumericsandYahooFinanceApileave the package versions with no consumer left, the container image drops its trading publish stage and banner line, and the installers drop theorkeon-tradinglauncher. - A declarative
.ork.tsnow runs through the real pipeline. A bareorkeon run crew.ork.tsused to execute a flat loop over agent bodies that ignored tasks, process, manager,humanInputand deliverables — the full orchestration was reachable only behind--config.runnow routes to the shared one-shot runner whenever the script declares theglobalThis.crewhandoff, 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.tsbesideconfig.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'sorkeon-exampledispatch. 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
CA5394waiver 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 fromOrkeononly for dependency weight (database drivers, PDF and spreadsheet libraries live here). Depends onOrkeon.Orkeon.Rag.OnnxandOrkeon.Tools.Embeddings.Localnow depend on theOrkeonpackage 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.ymlpushes the new lineup (Orkeon,Orkeon.Tools, the ONNX reranker pair, the local-embeddings tool package, and theorkeondotnet tool) and a new gate —scripts/check-package-closure.py— fails the workflow if a lineup package depends on anOrkeon.*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=falsehad silently disabled emission, shipping non-debuggable packages with no SourceLink attachment point);EmbedUntrackedSourcesis on. - The
orkeondotnet 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, andnamespaceLayout: flattenedremoves the 26 dead breadcrumb links the nested layout generated. - A missing
--mountsource directory now fails with a clean actionableERROR:line and exit 1 — in the YAML runner,--validate,--list-toolsandorkeon runalike — instead of a raw dependency-injection stack trace. CrewConfigurationMapperreports skipped tools and failed LLM-provider resolution through an optionalILogger(source-generated warnings) instead of writing to the console from the Application layer; theExampleCallbacksdemo handlers moved out of the publishedOrkeon.Applicationassembly into the test suite that was their only consumer.- Supply-chain hardening: a root
nuget.configpins 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.ForgeSessionHydratorrebuilds 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 amanifest.jsoncarrying 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.
SkipSplashForCaptureran a zero-duration animation and setVisibilityfrom itsCompletedhandler — and a zero duration is not a synchronous completion:BeginAnimationattaches 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 aPoseSplashForCapturethat 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.
ApplyThemeForCapturedoes 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 ownHwndSourceand therefore invisible toRenderTargetBitmap: 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
LoadedbelowRender, so the second dispatcher fence returned immediately andTask.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.
Savereturned 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_tokensinside 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 inreasoning_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:
ChatStreamingAsyncbuilt the same payload as the buffered path without callingWarnOnUnsendableAttachments, 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.
BuildChatPayloadnow 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 asminimax, the Kimi twin pattern. llm.minimax: the scripting namespace gained the accessor (binding, provider-name switch, typings, PublicAPI), asllm.grokhad — a first-class provider should not be reachable everywhere but from a script.llm.grokgets 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-2604probes athigh, 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-effortis 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 | Nonerow 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-effortreached the CLI reference; the Grok custom-endpoint report's paste-ready journal line named a path that does not exist; and this file's ownmax_completion_tokensentry 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_tokensis retired on current models. The campaign failed ten modes out of twelve ongpt-5.6-solover that one field ("Unsupported parameter: 'max_tokens' ... Use 'max_completion_tokens' instead"). The OpenAI dialect now writesmax_completion_tokens— verified live to be accepted by the older generations too (gpt-4o-mini) — through aMaxTokensFieldNamehook onOpenAICompatibleProviderBasethat onlyOpenAIProvideroverrides: DeepSeek and the rest of the compatible family still document and expectmax_tokens, and every provider campaigned that day passed with it. - Gemini:
response_formatworks and was being refused. DeclaredNonewhen 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 acceptsjson_objectandjson_schemaand enforces the schema server-side (additionalPropertiesincluded). The declaration is nowJsonSchema. - DeepSeek: vision arrived, per model.
deepseek-v4-flash-vision-expreads 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 = truenow, 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-idheader — Messages API and/v1/modelsalike — and Orkeon had no way to send one.LlmConfig.WorkspaceId(a scoping identifier, not a secret, same family asApiVersion) now travels as that header when set; classic keys change nothing. Wired throughorkeon llm probe --workspace-idand the campaign kit (workspaceIdper provider). - Ollama: every buffered completion was accounted as free. The buffered
/api/generateparse hard-codedTokensUsed = 0behind a comment claiming Ollama provides no count in that format — while the live server returnsprompt_eval_countandeval_countright beside the durations the same parse was already reading. Zero fed the token dimension ofAgentExecutionBudgetand the crew accounting. Found by the M1 probe archivingtokens=0on 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 2052on 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_callsfragment verbatim — Gemini rejects a replay that lost its per-callthought_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_effortto['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 notop_pis refused ("top_p must be 1 when using greedy sampling.") while the same request with an explicittop_p: 1passes. The Mistral dialect now always writes the configured value (AlwaysEmitTopPhook — 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_efforton, Mistral answersmessage.contentas an ARRAY of typed chunks (thinking+text) and the string-only read dropped both: M7 archivedaccepted, 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 asreasoning_content; the re-run archivesreasoning 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.Testsby 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 8Category=Slowtests — 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--loggerargument 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 todotnet-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.CodeAnalysis5.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.Toolsetnow replaces the SDK'scscso both are actually loaded. It isPrivateAssets="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 testin its VSTest mode no longer drives them. - Jint interop pinned to
ArrayConversionMode.Copy. Jint 4.14 changed the default for CLR arrays toLiveView, under whichArray.isArrayon a returned array is false. The scripting DSL's typings promisereadonly number[][]fromllm.embed(), so a script branching onArray.isArraysilently took the wrong path. The pin restores the behaviour the typings describe. Note the scope honestly: this governs CLR arrays, so a binding returningIReadOnlyList<T>is host-wrapped under either mode andArray.isArraystays 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
IApiKeyStoreas 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 tostudio-history.json): reusable settings, a default election mirrored into theLlmsection through the ordinary save cycle, per-profileORKEON_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 sameorkeon initcatalogue 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 jsonlchild — the stepper projects the engine's milestones, the per-step "consigne + questions" blocks travel downuser.message, arbitration buttons come fromdecision.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 astudio-team.jsonsidecar (name, need, profile, displayed schedule — never a key). The sidecar's profile rides every launch of the team — Run, Test, and history replays — asORKEON_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.messagegains anexpectsReply: truefield, emitted only on an agent'ssend. The peer must not have to guess which correlated lines are questions — a topic relay can carry acorrelationIdtoo, and the answer to the peer's ownsendpairs by correlation as well. The field is additive; readers that ignore it lose nothing. - Studio Core:
RunProgressModelfolds marked sends into aPendingAgentRequestqueue (dedupe by correlation id, cleared atrun.finished,ReplyAccepted()mirroringAnswerAccepted()), alongside the untouchedHubMessagesjournal. - 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:GuildIdsis 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
/stoparriving 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.Userwas never read, so anyone who could see the thread could kill a run while typing/stopwas gated. Button and slash commands now converge on oneCommandInvocationpath checked againstAllowedUserIds; an unauthorized click gets an ephemeral refusal instead of a silent stop. - The privileged
MessageContentintent 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 withFORGE-ESBUILD-MISSING). Both converge on the sameCrewDefinitionValidator, 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_commandandcode_interpreterare gone from the list that feeds both the blueprint prompt and the validation, and writes are confined to the session's/outputmount, snapshotted per run. - The verdict is recomputed, never trusted: score ≥ 0.7 and no blocking finding, with
a missed
mustcriterion blocking regardless of score. With no judge available, the verdict announces itself asdeterministicand 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.cmdcomposed against the CLI's ownorkeon rungrammar with the sample inputs pre-filled, andFORGE.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: truewas 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.KickoffAsyncfor 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). TwoCategory=Slowfacts spawn the realorkeonCLI from source and--validatea 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-erroron 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 newAddOrkeonA2ATaskPersistence(), and the A2A server records every task lifecycle transition (IA2ATaskStoreport over the existingIStateStore, best-effort — a store outage never fails the task exchange). The endpoint answers200with the recorded state and404for unknown ids;DELETE /a2a/tasks/{id}now records the cancellation and answers404for unknown ids instead of fabricating an acknowledgement (cancellation stays advisory). Without the opt-in, the explicit501remains — 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 withserver/discover; a modern answer selects the newest mutually supported revision (renegotiating onUnsupportedProtocolVersionError, including mid-flight), anything else falls back to the legacyinitializehandshake — which now really negotiates (2025-11-25,2025-06-18,2024-11-05) instead of pinning2024-11-05, and finally sends the requirednotifications/initialized(it never did). Modern requests carry per-request_meta(protocol version, client info/capabilities);input_requiredinterim results (MRTR) are surfaced as explicit tool errors rather than partial data. - Server (
McpServer): dual-era on the same endpoint — implements the mandatoryserver/discover, validates the per-request declared version (-32022UnsupportedProtocolVersionErrorwith the supported list), answers legacyinitializewith real version negotiation, no longer replies to notifications, returnstools/listin deterministic order with the requiredresultType/ttlMs/cacheScopefields 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: nosubscriptions/listen, no MRTR, no MCP OAuth, JSON-response mode only on HTTP, and2025-03-26excluded (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 newdocs.ymlworkflow builds the site strictly (--warningsAsErrors) on every PR touching sources or docs, and deploys it to GitHub Pages on eachv*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-checkedexamples/INDEX.mdis 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, andscripts/check-docs-parity.shnow runs inci.ymlon 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 emptyPublicAPI.Unshipped.txt, checked byMicrosoft.CodeAnalysis.PublicApiAnalyzers. An undeclared public API addition or removal is a build error (RS0016/RS0017promoted viaWarningsAsErrors). Executables (src/apps/) opt out — an app's surface is not a contract. [Experimental]on the unstable surfaces — 71 types now carryExperimentalAttributewith stable diagnostic IDs, documented indocs/reference/experimental-apis.md(EN + FR):ORKEXP001A2A (pre-v1.0.1 implementation),ORKEXP002Autonomous orchestration (budget, A2A channel, spawn),ORKEXP003corrective RAG (CRAG contracts),ORKEXP004MCP (pinned to2024-11-05until the protocol upgrade). Referencing them from outside the repository is a compile error to suppress explicitly;src/,tests/andexamples/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
InternalsVisibleTodeclarations 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 theorkeontool 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 persrc/zone (core, cli, scripting, analyzers, tools, rag, analysis, generators, hosting, plugins); a per-zoneDirectory.Build.propsdeclares the family and the central props pack it asicon.png, so every.nupkgcarries 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 viaPackageReadmeFile; the five projects that already had a rich developer README ship that one. The shared genericnuget/README.mdthat seven packages used to duplicate is removed. PackageReleaseNotes— centralized insrc/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 formFileSystemMount.Parsereads back;orkeon-studio-run— the crew launcher in the terminal: pick aconfig.yaml, a crew directory or a.ork.tsscript, set the options (--validateincluded), 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 },nullwhile the stream runs andnullfor good when the provider reported nothing) andreasoningChunks. Read them after the loop.- Deliberately NOT callbacks. A callback has to be invoked from the stream's own thread, and Jint's
Engineis single-threaded: the first cut of this did exactly that, and a measured run — seven area writers streaming concurrently — died of aNullReferenceExceptioninsideScriptFunction.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.
usageis 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 asIHybridSearchCapable:RetrieveAsyncrunstransform → retrieve → fuse → rerank → assembleand stops. Declared as a separate interface rather than added toIRagPipelinebecause 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.StagedRagPipelineimplements it;QueryAsyncandRetrieveAsyncnow share oneRetrieveCoreAsync, so the two cannot drift. The returnedRagAnswerkeeps the same shape (emptyText, populatedCitations) and the trace carries ageneratestep 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 asrag.query. On a pipeline that is not retrieval-capable it throws rather than falling back toQueryAsync: 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
ChatAsynccall 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
OpenAICompatibleProviderBaseRoleFidelityTestsread 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 onILlmProvideras a default-implemented member (likeBaseConfig), 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.ApplyProviderSpecificOptionswent 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 thereasoning_contentextraction; both were refactored onto the base and shrank to what is genuinely theirs (DeepSeek's cache counters, Z.AI'sreasoning_tokens). Their 33 + 15 existing tests pass unmodified. - Structured outputs on all 12 providers (G-15) —
LlmResponseFormatgains an optionalSchema(LlmJsonSchema { Name, Schema, Strict }) and aJsonSchema(...)factory;Typeis untouched, so existing configurations behave identically. Dialects:response_format(OpenAI-compatible family, withjson_schemawhere 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 tojson_objectwith a warning, never in silence. - ⚠️ Anthropic has no schema-less JSON mode.
output_config.formattakes exactlytype(alwaysjson_schema) andschema— there is no equivalent ofjson_object, andname/strictdo not belong there (strictexists, but on individual tools). Ajson_objectrequest 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.
YamlCrewMapperaccepted onlytextandjson_objectand downgraded everything else tonull— which would have discardedjson_schemabefore 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 aresponse_schema:block (name,schema,strict) next toresponse_format: json_schema; aresponse_schema:on its own impliesjson_schema. The scripting DSL gainswithResponseSchema(name, schema, strict?)on both the agent and task builders. - Thinking on all 12 providers (G-16, G-19) — four dialects:
reasoning_effort(+ thethinkingblock where the API has an explicit toggle) on the OpenAI-compatible family,thinking: {type: "adaptive"}+output_config.efforton Anthropic,think(boolean or effort level) on Ollama,enable_thinking+thinking_budgeton Qwen's DashScope dialect.LlmThinkingConfiggainsBudgetTokens, mapped only to Qwen — thebudget_tokensshape found in many older sources is rejected with an HTTP 400 by the current Claude generation, so it is reported rather than sent. reasoning_contentextraction is generic; its replay stays DeepSeek-only, driven byReplaysReasoningContent— 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
formatandthinkare wired on the current/api/generatepath: contrary to what the audit reported, both are accepted there, and only native tool calling actually requires the/api/chatmigration.
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, defaultORKEON_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) —
BuildEndpointwas 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, noapi-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 withapi_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/chatwhenever the conversation declares tools, replays tool calls, or carries an image, andLlmProviderFactorywires it with the native OpenAI strategy. The response is reshaped once — Ollama returnsmessage.tool_callswithargumentsas a JSON object and nochoicesarray, which is precisely why the framework's single parser could not read it — into the OpenAI body (argumentsas a JSON string, positional call ids since Ollama issues none). Everything else keeps/api/generate, so NDJSON streaming and GBNFgrammarare untouched and the text fallback remains in charge for models without tool support. - Ollama vision — images travel in a bare base64
imagesarray 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.mdno longer describes a limit that has been lifted; its Ollama entry now states what actually remains (no/api/chatstreaming, 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) —
ChatStreamingAsyncused 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, emittingContentDelta,ReasoningDelta(extended thinking) and a terminalCompletedwhose response is indistinguishable from the buffered one. - Anthropic cache metrics (G-21) —
cache_creation_input_tokensandcache_read_input_tokensfeed the typedCacheHitTokens/CacheMissTokens, soCacheHitRatiois finally computable on Claude. The three input counters do not overlap, soPromptTokensis their sum; absent counters staynull(unmeasured, not zero). - Explicit prompt caching (G-17) — new
LlmCacheConfigvalue object, cascaded likeLlmThinkingConfig(crew → agent → task → call-site,cache:block in YAML). Anthropic's cache is explicit: without acache_controlbreakpoint 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_urlcomposition 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 base64imagesarray 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/:preferredand 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. AddedWithRoutingPolicy/WithPartnerhelpers 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/anthropicspeaks the Messages API, but host inference matcheddeepseek.comand 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_searchandcode_interpreterexecute on Groq's side, so they pass through neitherIBaseTool, 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-4reaches end of life 2026-10-23 and caps context at 8 192 tokens), Anthropicclaude-3-5-sonnet-20241022→claude-sonnet-5(retired 2025-10-28), DeepSeekdeepseek-chat→deepseek-v4-flash(retired 2026-07-24), Kimimoonshot-v1-8k→kimi-k2.6(themoonshot-v1-*series sunsets 2026-08-31), Qwenqwen-turbo→qwen3.7-plus(absent from the catalogue), Mistralmistral-large-latest→mistral-medium-3-5-26-04.LlmDefaults.DefaultModelName— the fallback ofLlmConfig.Modelitself — 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), Kimiapi.moonshot.cn→api.moonshot.ai(the mainland host was the default for every account, including international ones; setBaseUrlexplicitly 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.comand the per-workspace*.maas.aliyuncs.comhosts (G-12).router.huggingface.cowas already matched by the existinghuggingface.corule — the audit's G-13 was a false positive, and is now pinned by a test. - Mistral routing trap fixed (G-14) —
InferFromModelrouted everymistral*model to Ollama, so a cloud identifier such asmistral-medium-3-5-26-04was sent tolocalhost:11434. Only the baremistraland its Ollama tags (mistral:7b) stay local; versioned identifiers, includingministral-*, now reach the Mistral cloud. SettingBaseUrlstill wins over model-name inference. - Azure configuration guard aligned across all four entry points (D-01) —
ChatStreamingAsyncwas not overridden, so with a missingBaseUrlit reachedBuildEndpointand threw aNullReferenceExceptionwhere the other paths returned a typed error. It now emits the standardCompletedevent carrying that same error.GenerateStreamingAsyncstill 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/-lunaandclaude-opus-5/claude-sonnet-5registered inModelPricingRegistry;gpt-4keeps its own entry so configurations that pin it still produce a real cost. LlmConfig.Gpt4()→LlmConfig.WithDefaultModel()(andGpt4WithSecret→WithDefaultModelSecret). These factories have always returned the platform default model, not literallygpt-4; with the default moved, the old names became actively misleading. The former names remain as[Obsolete]forwarders with identical behaviour — pass"gpt-4"toLlmConfig.Createif you really want that model.
Fixed — post-RAG coherence audit (2026-07-26)
LlmProviderToChatClientAdapterhonors the standardChatOptions.ResponseFormat— the adapter only read theLlmChatOptionsKeys.ResponseFormatAdditionalProperties key stashed by the orchestrator, so callers built on plain Microsoft.Extensions.AI options (RAG retrieval evaluator, groundedness checker, query complexity classifier settingChatResponseFormat.Json) never reached providers wiringresponse_format(e.g. DeepSeekjson_object). The adapter now falls back toChatOptions.ResponseFormatwhen 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 —
CorrectiveRagMechanismSlowTestsasserted only thatnotes-power.mdwas 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) acrossREADME(.fr).md,CLAUDE.md,limitations.md,publication-matrix.md;publication-matrix.mdworkflow narrative matched to reality (all NuGet pack/push lives inpublish.yml→ GitHub Packages; nothing on NuGet.org);CONTRIBUTING(.fr).mdno longer claims a CI parity gate that was never wired; ADR-006 amended with the RAG-06 decisions (CRAG onStateGraph, web-fallback policy/transport split,correctivepreset, no separaterag-adr.md);docs/INDEX.mdlinksrag-pipeline.md;limitations.md+opt-in-subsystems.mddocument the ONNX requirement (balanced/quality/adaptive) and the double-opt-in web fallback; French mirrordocs/fr/architecture/rag-pipeline.mdadded; eval README header corrected to 9 cases / 12 documents;Orkeon.Tools.RagNuGet 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), anIRagPipelinewhose execution is aStateGraph<RagGraphState>(immutable record state) with conditional edges and controlled cycles:retrieve→evaluate(IRetrievalEvaluator→RetrievalVerdictCorrect | Incorrect | Ambiguous) → per verdictgenerate/refine(decompose-then-recompose, never empties the working set) /rewrite_query(vocabulary-gap rewrite, loops back toretrieve) →generate(original question, same[n]rank-based markers, token budget andedgeslayout as the staged pipeline) →check_groundedness(IGroundednessChecker; ungrounded → re-loop). Every node run is traced ascorrective:<node>with the iteration ordinal; verdicts, rewritten probes and loop count land inRagTrace.Verdicts/QueryVariants/Iterations. Evaluator and checker are LLM-backed when anIChatClientis registered (LlmRetrievalEvaluator/LlmGroundednessChecker, constrained viaLlmResponseFormat—json_objectwhere wired, e.g. DeepSeek — tolerant JSON parsing elsewhere), deterministic heuristics with a warning otherwise.AddOrkeonCorrectiveRag(configuration)(idempotentTryAdd, called byAddOrkeonRag). - 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 ownCircuitBreakerPolicyis 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) andOrkeon:Rag:WebFallback(transport —WebSearchDocumentRetriever, SearxNG-compatible JSON search,ApiKeyEnvVaronly,AddOrkeonRagWebFallback). Every downloaded page passesPromptInjectionDocumentValidator(deterministic heuristics — model-addressed directives EN+FR, chat-template control tokens, hidden HTML, exfiltration vectors; verdictClean | Suspicious | Rejected):Rejectednever leaves the retriever,Suspiciousis flagged or discarded perSuspiciousAction, content is never rewritten. Threat model + honest limits (pattern-based, evadable) indocs/architecture/security.md. Web chunks carryScoreOrigin = "web". correctiveprofile + Adaptive lift (C2, 6D) —RagProfile.Corrective/correctiveinRagProfilePresetsand the resolver (sameIRagPipelinefaç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 = falseon purpose (the graph runs its nativecheck_groundednessnode whenever a checker is registered). Theadaptiveprofile'sIterativeroute now delegates to the memoizedcorrectivepipeline — the RAG-05 documented fallback toqualityis lifted (routestep tracesdelegate=corrective).- Vitrine (C3, 6B) —
docs/architecture/rag-pipeline.mdcompleted (CRAG topology, verdicts, double bound, web fallback, ADR pointers); three new runnable offline examplesexamples/rag/hybrid-retrieval(BM25+RRF vs vector-only),examples/rag/custom-reranker(hostIRerankerviaIRerankerRegistrar),examples/rag/crew-yaml(crewrag:/knowledge:blocks) + scripting variantexamples/scripting/08-rag.ork.ts; all fourexamples/rag/*projects inOrkeon.Examples.sln;examples/INDEX.mdregenerated. - 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;correctiveat 0.78 / 0.64 — worse thanqualityoffline, 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 inexamples/rag/eval/README.md. The causal end-to-end proof of the mechanism (verdictIncorrect→ rewrite →notes-power.mdcited on the seeded q-007 case thatqualitymisses, same store and embeddings) isCorrectiveRagMechanismSlowTests(scripted LLM for the two roles CI cannot provide, labelled). CI gate unchanged (balanced,correctifcases 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 perQueryTransformKind: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 viaAddOrkeonQueryTransforms()(chat client resolved lazily; unknown names fail loudly); optionsOrkeon:Rag:QueryTransform(Modedefaultnone,VariantCountdefault 3). Unusable/failing LLM responses degrade to[original]with a warning — never an exception. - Pipeline integration (5D) — the
StagedRagPipelinetransform stage resolves the configured transformer and wires retrieve/fuse perKind(union / rrf / replacement probe). The transform step tracestransformer,kind,variants(count) and the truncatedvariant_ntexts;RagTrace.QueryVariantscarries the full produced texts (original excluded); the fuse step traces itsmethod(union/rrf/dedup). - MMR diversification (C2, opt-in) —
MaximalMarginalRelevance.Selectapplied after fusion/dedup and before rerank whenOrkeon:Rag:Retrieval:Mmr:Enabledis set (Lambdadefault 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) andLlmQueryComplexityClassifier(constrained JSON, tolerant parsing, SingleShot fallback with warning).AddOrkeonQueryRouting(configuration), optionsOrkeon:Rag:QueryRouting:Classifier(heuristic|llm;llmwithout a chat client falls back to heuristic with a warning). Adaptiveprofile (C3/5D) —RagProfile.Adaptive/adaptiveinRagProfilePresetsand the resolver: theAdaptiveRagPipelineclassifies first, thenNoRetrieval→ direct LLM answer (no retrieval, empty citations),SingleShot→ delegates to the memoized balanced pipeline,Iterative→ documented fallback toqualityuntil the corrective/iterative engine ships with RAG-06. The decision is always traced:RagTrace.Route+ a firstroutestep (route,classifier,delegate, fallback detail).Orkeon:Rag:Profile=adaptiveroutes 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:--offlineswaps in a deterministic extractive chat client, so the LLM-backed transformers (multi-query / rag-fusion / hyde) and thellmclassifier have no real LLM to call — the measured path isMode=none+ heuristic routing; the transformer/MMR levers are wired and unit-tested, their quality delta will be measured with a realIChatClientand/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 caseq-007taggedcorrectif), 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 toolrag_eval, CLIorkeon 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 theHybridSearchDocumentStoredecorator (works over all 6 memory providers; in-process index memory documented), native provider hybrid preferred via the newIHybridSearchCapableDomain capability (LanceDB), native scores viaIScoredVectorSearch(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 withAddOrkeonOnnxReranker();LlmListwiseReranker(universal fallback over the 12 providers) andNoopReranker; default cascade CandidateK 50 → TopN 5. - Staged pipeline + profiles (C4, plan §5.1–5.2) —
StagedRagPipelinereplacesLinearRagPipeline(breaking rename, beta window): transform (hooknone, RAG-05) → retrieve (CandidateK, per-query hybrid) → fuse (RRF/dedup) → rerank (named,RerankerFactory) → assemble (token budget + anti-Lost-in-the-Middleedgesordering: 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 inRagAnswer.Trace.RagProfile { Fast, Balanced, Quality }+RagProfilePresets→RagOptionsv2 bound onOrkeon:Rag(profile = preset, configuration = per-key override; defaults inOrkeon.Domain.Constants.Rag.RagDefaults);ProfileRagPipelineResolverbuilds and memoizes one pipeline per profile (unknown names fail loudly listingfast, balanced, quality, default). Default profile isfast(deviation from plan §5.2'sbalanced: balanced requires the opt-in ONNX package; opt in with one keyOrkeon:Rag:Profile=balanced). The store is now always wrapped in the hybrid decorator (ingestion feeds BM25; disabled default mode = strict passthrough);RetrievalQuery.Hybridtoggles 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,
correctifexcluded ⇒ gated aggregates 1.00/1.00 for all profiles), and the seededq-007defeats the cross-encoder too (measured score of the relevantnotes-power.md: 0.0000, dead last; decoyfaq-battery.md: 0.9997) — vocabulary bridging is exactly the RAG-05/RAG-06 lever (plan §9.1:correctifmust 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 ofA2ASecurityOptions.TrustedCertificateAuthorities(X509CustomRootTrustchain — also covers validity dates, removing the lastDateTime.Nowinsrc/) or match the newTrustedClientCertificateThumbprintspin list; unpinned self-signed certificates are rejected (403). Starting the server withRequireMutualTlsand 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).
A2ASecurityHandlerFactoryonly vouches forRemoteCertificateChainErrors(private CA unknown to the OS store);RemoteCertificateNameMismatch/RemoteCertificateNotAvailableare never accepted. The explicitValidateServerCertificate = falseopt-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 theX509Certificate2(never disposed) and create a fresh handler+client — a full mTLS handshake per call.A2ASecurityHandlerFactorynow returns a pooledSocketsHttpHandler(SslOptions.ClientCertificates,PooledConnectionLifetime2 min) cached lazily byA2AClient; per-call clients wrap it withdisposeHandler: false.A2AClientis nowIDisposableand 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 noseverity = nonecarve-out:- Exposed collections are read-only (CA1002/CA2227/CA1819):
List<T>/T[]properties and returns becomeIReadOnlyList<T>; settable collection properties becomeinit/get-only. Deserialization-safe by construction —IConfiguration-bound options useCollection<T>get-only, YamlDotNet DTOs keep a settableCollection<T>?, System.Text.Json DTOs useIReadOnlyList<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 acrossIHttpClient,IA2AClient,LlmConfig.BaseUrl, options and tool DTOs now useSystem.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 theOrkeon.Domain.Sharednamespace renamed toOrkeon.Domain.SharedKernelsolution-wide (it collided with the VBSharedkeyword). - 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 madeinternalwhen they are implementation details.
All changes are behaviour-preserving (order, JSON wire format, and config/YAML binding verified empirically per layer).
dotnet build Orkeon.slnstays 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.- Exposed collections are read-only (CA1002/CA2227/CA1819):
Redundant default-value initializers removed and
System.Randomaudited acrosssrc/; 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 srcSystem.Randomuses 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 aserrorso any newRandomuse 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.slnstays at 0 warning / 0 error.Logging converted to the
LoggerMessagesource generator across allsrc/; CA1848 + CA1873 frozen as build errors (R11.3, zero-warning campaign wave B3). The 113 srcILogger.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 anIsEnabledguard. The single dynamic-level audit sink uses cachedLoggerMessage.Definedelegates. Both rules are locked aserrorforsrc/**. Behaviour is unchanged (same levels, templates, args, exceptions); tests andexamples/keep their occurrences and are not frozen.dotnet build Orkeon.slnstays 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 getArgumentNullException.ThrowIfNull(param)as their first statement (the netstandard2.0 analyzer project uses the classicif (x is null) throwform), and CA1062 is locked aserrorforsrc/**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 andexamples/(separate solution / test doubles) keep their occurrences and are not frozen.dotnet build Orkeon.slnstays 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 aserrorforsrc/**in.editorconfig, so framework code can never silently reintroduce one. Arbitrage "Ordinal default + protect ToLower": comparisons →StringComparison.Ordinal(OrdinalIgnoreCasefor identifier/key matching), formatting →CultureInfo.InvariantCulture, and the 91ToLowerInvariant()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) intests/.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 withoutAnalysisMode=All;dotnet build Orkeon.slnstays 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
FakeDriverfor tests). 2.0.1 is the last stable release before that redesign. Same code compiles unchanged (API surface compatible). The xUnitModuleInitializercrash (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.ThrowIfNullguards added in R11.2:ValidationResult.Combine,TypedTaskContext.Transform,AgentMapper.ToDto/CreateFromRequestandSequentialCrewOrchestrator.KickoffAsyncnow correctly reject null (the orchestrator'sCrewInputhas no empty form, so a null input is genuinely invalid — the test that expected "graceful" handling now expects the throw).TaskDescription.Fromis the one behavioural fix: the R11.2ThrowIfNullhad fragmented its validation so a null value surfacedArgumentNullException("Value cannot be null") instead of the value object's unifiedArgumentException("… 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-globalActivityListenerpicking up a concurrent test's tool-call span, by filtering on the uniquetool.nametag like the sibling crew/agent span tests already do.dotnet build Orkeon.slnstays at 0 warning / 0 error. - Tool URL parameters typed as
System.Urino longer break the agent tool contract (R11.7-D1 follow-up). The D1 API-shape wave (CA1054/CA1056) converted tool request/response URL properties toSystem.Uri, but the typed-tool schema generator mappedUrito JSON type"object"— so every tool call carrying a string URL was rejected before execution withParameter 'url' has invalid type. Expected: object(≈30 direct failures cascading acrossweb_scrape,scrape_element,http_api,cache_searchandarcadedb_query). Fixed at a single point rather than reverting the DTOs:ToolSchemaGeneratornow mapsUrito"string"(formaturi) likeGuid/DateTime, and a new tolerantUriTolerantConverter(registered only in the component pipeline's options) round-tripsUri↔string — empty/whitespace maps tonull(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 useOriginalStringto preserve the exact URL with no trailing-slash canonicalisation. TheUrityping (and the frozen CA1054/CA1056 errors) are kept. The samestring→Uri?conversion had also silently flipped the requiredurlparameter ofweb_scrape/scrape_element/http_apito optional in the generated schema (a non-nullablestringinfers required; a nullableUri?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'sbolt_uriwas already required). Also corrected three test concerns surfaced by the same Windows run: theMockHttpMessageHandler/TestHttpMessageHandlerdoubles now capture a buffered clone of each request so post-send body assertions survive the provider's R10.2 content disposal (wasObjectDisposedException×27), theIUrlValidatorSSRF stub recordsOriginalStringinstead of the canonicalised form, and threeLlmBasedManagernull-argument tests now expect theArgumentNullExceptionthe R11.2 guards correctly throw (wasNullReferenceException).dotnet build Orkeon.slnstays 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) whileConversationPolicyusedOrdinalIgnoreCase, so a mixed-case role like"Assistant"was serialized one way and policy-matched another. A newLlmRoles(canonical lowercase wire values + a singleIs/IsXhelper) now routes every comparison and message construction in the Anthropic/OpenAI-compatible providers,ConversationPolicy, and theLlmMessagefactories. This fixes a real bug where a mixed-case"Tool"orphan survived history trimming and produced the orphantool_resultthe trim exists to prevent. The scripting default models (LlmNamespaceBinding) were de-duplicated (they were defined twice in the same file); reconciling them withProviderDefaultsis a maintainer product decision (the values differ). release.ymlandci.ymlno longer publish divergent NuGet perimeters (OSS-011, R8.3).release.ymlwas missingOrkeon.Infrastructureeven though the README documents installing it; both workflows now pack the same three core libraries. The published set is documented indocs/reference/publication-matrix.md(promotion of the tools family /orkeontool is held until decision D3 so the scripting twins' names are not locked into NuGet before a possible rename). Stale metadata fixed: theCONTRIBUTINGclone/upstream URLs (Orkeon/orkeon), theOrkeon.ConsoleApplocal1.0.0version override (now inherits0.9.0-beta), and the obsolete+orkeoncoverage-filter comment.HttpRequestMessage/HttpResponseMessageare disposed on the LLM request path (ANT-006, R10.2). The 20 per-call CA2000 leaks in the Anthropic/OpenAI-compatible/Ollama providers andHttpClientAdapterare fixed by real lifetime:using varfor 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 inExecuteHttpRequestAsync. The 11LlmProviderFactorysites are ownership transfers (the provider is wrapped in the returned adapter; itsDisposeis a no-op) — collapsed into one genericAdapt<T>helper carrying a single justified suppression.- Semantic memory recall no longer silently returns empty on the default configuration (MAT-017, R10.1).
IMemoryProvider.SearchSimilarAsyncwas a default interface method returning empty, andInMemoryProvider's real cosine implementation was unreachable through the interface (C# does not re-map derived members onto a base-implemented interface).SearchSimilarAsyncis now an abstract member ofMemoryProviderBase(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. ICodeSandboxresolution no longer launches adocker versionprocess under the DI singleton lock (ORG-012, R10.3). The availability probe lives in a memoized lazy decorator (LazyProbingCodeSandbox) and runs at the firstExecuteAsync(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 bansGetAwaiter().GetResult()/.Resultinsrc/DI factories (single documented exemption: plugins).- Script command loading no longer blocks the DI thread (ANT-002, R10.3).
ScriptCommandRegistryresolution 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. MemoryProviderFactoryno longer creates bareHttpClients (ANT-013, R10.5). Chroma/Pinecone/LanceDB clients useSocketsHttpHandlerwithPooledConnectionLifetime(2 min) so rotating cloud endpoints are re-resolved; ChromaDB and Pinecone providers gained the missingDispose(the client was never released) and all three providers are nowIDisposable.CrewOutput.TokensUsedis real telemetry for all 6 process types (MAT-004, R10.8). Parallel/Hierarchical/Consensual/Autonomous now record token usage (new thread-safeTokenUsageTally), Graph propagates its existing internal count (success and circuit-breaker paths), and the prompt/completion split is extracted fromUsageDetailsinstead of being discarded. Breaking (0.9.0-beta):TokensUsedis now nullable —nullmeans "not measured", never a fabricatedTokenUsage(0,0,0); the persisted checkpoint projection recordsTokensMeasuredso the distinction survives round-trips.- Application placeholders implemented or removed (MAT-018, R10.9).
CrewConfigurationMapper.ToConfigurationexports agents and tasks for real (round-trip tested; breaking: the caller now provides the materialized entities);CrewValidatorvalidates LLM configs (model + canonical numeric bounds);CrewPlannerconsumes its previously-ignoredstrategyparameter; the stubAgentPlannerServiceis 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).IAgentRepositoryis now registered withTryAddScopedby the infrastructure: when A2A ran first, itsSharedStoreAgentRepositoryupgrade used to be silently won back by the laterAddScoped(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 overrideIAgentRepositoryafterAddOrkeonInfrastructure()withoutReplacekeep the last-wins behaviour as before.- Ctrl+C in TUI cancels the current command instead of being intercepted as SIGINT (TUI-20) —
Console.TreatControlCAsInput = trueis set afterApplication.Initso Ctrl+C reaches Terminal.Gui's input loop. The .NET runtime'sConsole.CancelKeyPresshook is skipped in TUI mode (would race with the keystroke path). A globalApplication.KeyDownhandler inTerminalGuiHostis the source of truth: 1×Ctrl+C requestsIInteractiveRunner.RequestCommandCancellation(with REPL-pane feedback⏹ Cancellation requested...); 2×Ctrl+C within 2s force-quits the TUI as an escape hatch.RunOneShotAsyncnow accepts anexternalCtparameter soVerifyCommandpropagates 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 customQuitConfirmDialogexposed a v2 runnable-stack race that swallowed the post-dialogApplication.RequestStop. - Inner-host logs (RunOneShotAsync) leaked to stdout in TUI mode (TUI-19) — when
verifyspawned a child host withAddSimpleConsole, those writes hitSystem.Console.Out(commandeered by Terminal.Gui's alt-screen) and dumped on shutdown. NewOrkeon.Cli.Abstractions.Logging.AmbientLoggerProvideris published by the TUI host on Initialize;RunnerExecution.ConfigureVerboseLoggingresolves it via reflection (no project coupling) and substitutes it forAddSimpleConsolewhen present. Inner host logs now flow into the logs pane. - Default
LoggerFactoryminimum level too restrictive in TUI — runner now setsLogLevel.Traceupstream so all entries reachTerminalGuiLoggerProvider; 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.SchemeFactorybuilds explicit white-on-black schemes wired into LogsPaneView/ReplPaneView/SplitPaneToplevel.Ctrl+Gnow 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 = falseremoves it from the focus cycle, plus anInitializedhook onReplPaneViewcalls_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 = trueso 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 passedCancellationToken.None.ReplPaneView.CancelPendingRead()is invoked from the host's finally block to forcibly complete the pending TCS withnullso the runner's loop seesReadLine() == nulland 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 theTerminalGuiLoggerProviderDI factory;.Host.Build()exited with code 0 before any UI was rendered.TerminalGuiHostnow takes onlyTerminalGuiOptions; the status bar is built and attached from theTerminalGuiLoggerProviderfactory once both exist. Also: explicitDOTNETdriver 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.shfails CI when anydocs/**.mdlacks itsdocs/fr/mirror (or vice versa), or when a rootREADME/CONTRIBUTING/CODE_OF_CONDUCT/SECURITY.mdlacks its.fr.mdpair; wired as thedocs-parityjob. The rule is documented in bothCONTRIBUTINGfiles. - Blocking npm vulnerability audit (DEP-010, R8.6).
dependency-audit.ymlgains annpm-vulnerability-auditjob (npm ci --dry-runintegrity +npm audit --audit-level=highover the esbuild bootstrap), so a CVE onesbuild/@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).
AzureOpenAILlmProvideris rebased onOpenAICompatibleProviderBase(its hand-rolled pipeline only readchoices[0].message.content) and the factory passes the OpenAI strategy:tools/tool_choiceare injected andtool_callsparsed natively, with the text fallback kept as the safety net. Ollama stays on the text protocol — its/api/generatepipeline is prompt completion and the native-tools/api/chatresponse format is incompatible with the OpenAI parser; documented indocs/reference/limitations.md. runCrewscript 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 clearTimeoutException.IConsoleAdaptergainsReadLineAsync/ReadKeyAsyncas 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) — newIConsoleAdapter+ILoggerProviderthat route REPL I/O andILoggerwrites 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--uiflag inOrkeon.ConsoleApp+examples/runners/interactive-claim-verification) accept--ui tui|plain|auto, defaultauto(TUI when interactive TTY, plain in CI/pipe viaTtyDetector). 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. IInteractiveRunnerinterface inOrkeon.Cli.Abstractions.RunnersexposesIsCommandRunning+RequestCommandCancellation().InteractiveRunnerBaseimplements it; the TUI uses it to drive Ctrl+C cancellation and Ctrl+Q confirmation dialogs.AmbientLoggerProviderinOrkeon.Cli.Abstractions.Logging— process-wide ambientILoggerProviderregistry letting child hosts re-route their logs into a parent TUI's pane without project coupling (resolved via reflection byRunnerExecution.ConfigureVerboseLogging). Wrapped in a non-owningLeasedLoggerProviderso 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 atApplication.KeyDownto/tmp/tui-keytest.log. Used to diagnose terminal-specific keystroke routing issues (TUI-20). Run withdotnet run --project examples/runners/tui-keytest. - Virtual FileSystem v2.2 — enumeration + streaming surface on
IFileSystemService(EnumerateFilesAsync,OpenReadStreamAsync,TryReadAllBytesAsync,TryReadAllTextAsync,GetEntryKindAsync).FileSystemDiscoverernow goes through the VFS instead of rawSystem.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 viaIFileSystemService.TryReadAllTextAsync. - Index introspection tools —
index_statusandis_path_indexedlet 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
ImprovedAgentExecutionServicerenamed toAgentExecutionService(SML-008, R12.4) — it is the only implementation ofIAgentExecutionService, so the "Improved" qualifier was meaningless. The value objectVersion(which shadowedSystem.Version) is renamedSemanticVersion. Internal/pre-freeze renames in the 0.9.0-beta window. The deadJsonToolCallParser([Obsolete], no usage, no DI registration) and the emptyJsAgentInstanceplaceholder are removed.--prebuild-indexCLI flag removed from the standard runner. Agents now callindex_codebase(root_path="/src")themselves (optionally gated byis_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, replacingDictionary<string, object>signatures throughout the codebase ToolBase<TReq, TRes>generic tool base class with typed request/response, YAML defaults merging, and output filteringEvaluatorBase<TInput, TResult>andFlowStepBase<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 SimpleCrewOrchestratorreplacing 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, andFluentBuilderFactoryfor 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>andFunctionCallInfo - CQRS pipeline: commands and queries for Agent, Crew, and Task aggregates;
ValidatingCommandHandlerdecorator;UnitOfWorkintegration 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 toAgentCommunication/) - Session checkpointing:
IStateStore,CheckpointManager,ResumeEnginewith 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):
PiiDetectorwith 5-channel interceptors and per-channel policy - RAG data validation: integrity checks, injection detection, provenance tracking, and quarantine
- Agent kill switch:
IAgentLifecycleManagerfor controlled agent termination InMemoryAgentMemoryStoreRepository(Infrastructure) for fast in-process agent memory- E2E test project (
Orkeon.Infrastructure.Tests) with 10+ integration tests;IConfigurationwired 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/awaitservice 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 mutableList<T>on domain types - 15+ anemic domain types converted to immutable records (
init-only properties) - Value objects refactored:
AgentSkill,AgentCapability,AgentSelectionResult,CrewVariables,DomainValueObjects.cssplit into per-feature files; renamed duplicates (MemoryEntity,TypedTaskContext,DelegationToolParameters) - Domain reorganized feature-first: Builders, Templates, Callbacks, DomainEvents, and ValueObjects moved to bounded-context folders;
TrainingScenariomoved to Training BC;A2A/renamed toAgentCommunication/ - Application layer reorganized feature-first: DTOs co-located with feature folders; dead infrastructure port interfaces removed;
KickoffAsyncextracted fromCrewaggregate to the Application orchestrator - Infrastructure layer reorganized by feature/BC: Persistence separated per-aggregate
MemoryRelevanceRankerrenamed toMemoryRelevanceServiceAgentStepstring ID replaced with typedAgentStepIdIRepositorysimplified:GetAllAsyncandIPredicateRepositoryremoved (AP4/R45)IAgent.Toolstyped asIReadOnlyList<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 toShould_Whenconvention; 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/ShouldPromoteToLongTermmade internal to enforce aggregate boundary (R35/R8)EntityMemory/EpisodicMemorymade internal to the aggregate (R8/R35)MemoryItemmutation methods made internal (R35)AgentCapabilities/CrewOutputconstructors privatized (R28)CrewInputconstructor made internal (R10/R28)ToolResult/ToolUsageMetricsconverted to init-only properties (R25)- Validation pipeline wired in:
CreateTaskCommandValidatorhandlesAgentIdvalidation;ValidatingCommandHandlerdecorates the CQRS chain UnitOfWorktry/finally guard added to ensure domain events are dispatched after persistence even on exceptions (R21/R39)ITaskRepositoryscoped documented;SaveChangesAsyncremoved from repository, delegated toIUnitOfWork
Fixed
- Infrastructure
ChatClientadapter no longer overrides caller-supplied LLM configuration - Empty task output in process strategies handled gracefully
IMemoryScopeandIMemoryProviderFactoryregistered in DI (defaults toNullMemoryScope)- LLM DI registration corrected across all examples
- LLM
BaseUrlchanged fromhost.docker.internaltolocalhostin examples - Missing
AgentBuilder/CrewTaskBuilderusingdirectives in email-management and research-assistant examples - ClassicTrading example: raw strings wrapped with Value Object factories;
Agent.AgentIdrenamed toAgent.Id; namespace corrections forLlmConfigandILlmProvider - Duplicate
MemoryProviderConfigDtoremoved (kept inMemory/, removed fromCommon/) - Duplicate
MemoryRelevanceRankerstale reference cleaned up (R43/R50) - Domain event dispatch order standardized; DI lifetimes aligned (N5/N6)
PromptShieldBuildertests fixed afterAgentBackstoryVO migration (null backstory handling)- Post-refactoring compilation errors resolved across Infrastructure project
- CS4014 warning: async Timer callback wrapped with
try/catchand 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.propertiesfile (caused scanner conflicts; all parameters now passed via CLI)- Legacy
CodeInterpreterTool(replaced bySecureCodeInterpreterTool) GetAllAsyncandIPredicateRepositoryfromIRepository<T>(AP4/R45)- 5 dead infrastructure port interfaces from Application layer (R16)
- Moq and FluentAssertions package references from all test projects
[Obsolete]FunctionCalldictionary property replaced byFunctionCallInfo(T17)- Telemetry infrastructure (
StartSpan→ migrated toStartActivity; 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,ConsoleAppprojects - Core domain entities:
Agent(Worker, Manager, Observer, Human),Crew,CrewTask IBaseToolinterface and initial tool implementationsILlmProviderwith 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