@owlmeans/llm 0.1.18-rc.44 → 0.1.18-rc.45

package/README.md

@@ -20,7 +20,7 @@ abstraction that resolves models from an inheritable policy.
 ## Installation
 
 ```bash
-bun add @owlmeans/llm@^0.1.18-rc.44 @owlmeans/llm-common@^0.1.18-rc.38
+bun add @owlmeans/llm@^0.1.18-rc.45 @owlmeans/llm-common@^0.1.18-rc.39
 bun add @langchain/core @langchain/openai @langchain/anthropic   # peer dependencies
 ```
 
@@ -100,10 +100,10 @@ const resumed = context.executions().restore(state, { models: () => context.llm(
 ### Add a provider
 
 ```typescript
-import { openAiFamily, registerLlmPlugin } from '@owlmeans/llm'
+import { llmPluginRegistry, openAiFamily } from '@owlmeans/llm'
 import { StructuredMode } from '@owlmeans/llm-common'
 
-registerLlmPlugin({
+llmPluginRegistry.register({
   ...openAiFamily,                       // shares owns/refine/toolChoice/responseFormat
   type: 'my-gateway',
   structuredMode: config => config.structuredOutput === true ? StructuredMode.Native : StructuredMode.Tool,
@@ -139,24 +139,25 @@ spectator entry), `filter` (reject a result and force a retry), `useCache` / `ca
 | Reasoning eats the whole output budget | Retry doubles `maxTokens` toward `maxTokensCap` **and** shrinks an absolute reasoning cap |
 | A weak cheap model keeps failing | Walks the `ModelConfig.fallback` chain, `FALLBACK_AFTER_ATTEMPTS` attempts per rung; a rung may be another provider, called in its own dialect |
 | The same model keeps giving the same weak answer | Climbs `ModelConfig.effort` one level per attempt of the rung, up to the model's ceiling; a `TemperatureFactory` request climbs it too |
-| Model stringifies arrays / over-wraps scalars | `coerceToSchema` reconciles the answer with the schema before validation |
-| Model ignores the tool and answers in prose | `parseJsonContent` salvages JSON from fences and surrounding text |
+| Model stringifies arrays / over-wraps scalars | `jsonHelper.coerceToSchema` reconciles the answer with the schema before validation |
+| Model ignores the tool and answers in prose | `jsonHelper.parseJsonContent` salvages JSON from fences and surrounding text |
 | A blank message poisons the request (Anthropic 400 `text content blocks must contain non-whitespace text`, typically an empty file read pasted into a prompt) | Whitespace-only text blocks are dropped before every call; blank tool results are stubbed to keep their `tool_use` pairing, and an all-blank input becomes one stub user message |
 | Nothing usable came back | `NullCapture` — request, response, token accounting and finish reason, to the spectator |
-| An error no retry can fix | `registerFatalError` / `LlmPlugin.isFatal` abort the loop immediately |
+| An error no retry can fix | `retryHelper.registerFatalError` / `LlmPlugin.isFatal` abort the loop immediately |
 
 ### Helpers (usable alongside a model)
 
-`withRetry` · `registerFatalError` · `spectate` · `normalizeInput` · `parseJsonContent` ·
-`coerceToSchema` · `resolveFallbacks`. Also exported from `@owlmeans/llm/helpers`.
+`retryHelper` (`withRetry`, `registerFatalError`, `isFatalError`) · `jsonHelper` (`parseJsonContent`,
+`coerceToSchema`) · `cacheHelper` (`readCacheUsage`, `hasCacheActivity`) · `spectate` ·
+`normalizeInput` · `resolveFallbacks`. Also exported from `@owlmeans/llm/helpers`.
 
 Everything under `src/utils/` is library-private and deliberately not exported.
 
 ### Plugins
 
-Exported from `@owlmeans/llm/plugins` as well as the root: `plugins` (the registry),
-`registerLlmPlugin`, `resolvePlugin`, `pluginOf`, `pluginFor`, `anthropicPlugin`,
-`openAiPlugin`, `compatiblePlugin`, `openAiFamily`.
+Exported from `@owlmeans/llm/plugins` as well as the root: `llmPluginRegistry` (the registry —
+`plugins`, `register`, `resolvePlugin`, `pluginOf`, `pluginFor`, `effortSupportOf`),
+`anthropicSupportHelper`, `anthropicPlugin`, `openAiPlugin`, `compatiblePlugin`, `openAiFamily`.
 
 ## Tests
 
@@ -185,7 +186,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills@^0.1.18-rc.48
+npx @owlmeans/agent-skills@^0.1.18-rc.49
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/llm",
-  "version": "0.1.18-rc.44",
-  "generatedAt": "2026-10-05T08:32:19.108Z",
+  "version": "0.1.18-rc.45",
+  "generatedAt": "2026-10-05T21:03:06.389Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/inquiry/SKILL.md

@@ -48,17 +48,17 @@ interface InquiryAnswer {
   value?: string | string[]
   text?: string
   declined?: boolean            // nobody could decide — an ANSWER, never a failure
-  truncated?: boolean           // set by capAnswer or stateAnswerOf, never by an answerer
+  truncated?: boolean           // set by inquiryHelper.capAnswer or .stateAnswerOf, never by an answerer
 }
 
 interface InquiryTransport { ask: (inquiry: Inquiry, signal?: AbortSignal) => Promise<InquiryAnswer> }
 interface InquiryConfig { transport?: string; policy: InquiryPolicy }
 ```
 
-The pure helpers are the ONE reading of an answer every layer uses — a second reading is a second
-contract: `defaultAnswerFor(inquiry)` (the default, or a decline), `answeredWith(answer)` (the first
-value, else the text, else `null`), `isDeclined(answer)`, `capAnswer(answer, max?)`,
-`stateAnswerOf(answer)`, `renderInquiry(inquiry)` (a one-line label for a note or a run row).
+The pure `inquiryHelper` is the ONE reading of an answer every layer uses — a second reading is a second
+contract: `inquiryHelper.defaultAnswerFor(inquiry)` (the default, or a decline), `.answeredWith(answer)` (the first
+value, else the text, else `null`), `.isDeclined(answer)`, `.capAnswer(answer, max?)`,
+`.stateAnswerOf(answer)`, `.renderInquiry(inquiry)` (a one-line label for a note or a run row).
 
 ## Three policies, and no fourth
 
@@ -69,7 +69,7 @@ policy.
 | Policy | `ExecutionService.ask` does |
 |---|---|
 | `Ask` | Hands the question to the seated transport and waits for the answer |
-| `Default` | Returns `defaultAnswerFor(inquiry)` and asks nobody. The caller is expected to RECORD the assumption where a user can read it |
+| `Default` | Returns `inquiryHelper.defaultAnswerFor(inquiry)` and asks nobody. The caller is expected to RECORD the assumption where a user can read it |
 | `Refuse` | Throws `InquiryDeclined` — nobody may be asked at all |
 
 **No configuration means `Default`.** A run that was never given a channel must never block on one:
@@ -80,20 +80,20 @@ project pipeline, a scheduled job).
 
 `DEFAULT_INQUIRY_ANSWER_CHARS` (2 000) is the only ceiling on a stored answer. The connector's
 `CONNECT_INQUIRY_MAX_TEXT` equals it, the connector's answer schema caps `text` at it, and
-`capAnswer` enforces it. Three ceilings for one value is how a user's 3 000-character answer is
+`inquiryHelper.capAnswer` enforces it. Three ceilings for one value is how a user's 3 000-character answer is
 accepted on the wire and silently halved further in — so never introduce a local cap; import this
 one.
 
 **Only the prose is ever cut.** A `value` is the decision itself — for a `Choice` it must equal one
 of the question's own option values — so a shortened one is not a degraded answer but a different
-answer, matching no option, which `answeredWith` would hand on as what the person chose. An
+answer, matching no option, which `inquiryHelper.answeredWith` would hand on as what the person chose. An
 over-long `value` is a defect upstream (the connector's schema refuses one rather than shortening
-it): `capAnswer` passes it through whole and raises `truncated` on it.
+it): `inquiryHelper.capAnswer` passes it through whole and raises `truncated` on it.
 
-`capAnswer` **reports** the cut (`truncated: true`). A silent truncation is exactly the class of
+`inquiryHelper.capAnswer` **reports** the cut (`truncated: true`). A silent truncation is exactly the class of
 failure the primitive exists to prevent.
 
-A resumable pipeline **state** stores less: `stateAnswerOf` keeps the decision whole and cuts the
+A resumable pipeline **state** stores less: `inquiryHelper.stateAnswerOf` keeps the decision whole and cuts the
 prose to `INQUIRY_STATE_TEXT_CHARS` (200), because a state is keys, markers and paths — two
 full-size answers would make it prose. The full answer still goes back to whoever asked; long text
 belongs in whatever document the application keeps for it (the converter writes
@@ -102,21 +102,21 @@ belongs in whatever document the application keeps for it (the converter writes
 ## The transport registry, and why an absent channel is fatal
 
 ```typescript
-registerInquiryTransport(key, transport)   // seat on attach
-releaseInquiryTransport(key)               // release when the channel goes away
-hasInquiryTransport(key)
-inquiryTransportFor(key | undefined)       // throws InquiryUnavailable — never waits
+inquiryTransportRegistry.register(key, transport)    // seat on attach
+inquiryTransportRegistry.release(key)                // release when the channel goes away
+inquiryTransportRegistry.has(key)
+inquiryTransportRegistry.transportFor(key | undefined) // throws InquiryUnavailable — never waits
 ```
 
 Module-level and keyed by string, exactly like the delegate-transport and provider-plugin
 registries beside it: a process holds many at once, and an execution names the one its run belongs
-to. It is `inquiryTransportFor`, not `transportFor`, because `@owlmeans/llm` and
+to. It is `inquiryTransportRegistry`, not a bare `transportRegistry`, because `@owlmeans/llm` and
 `@owlmeans/llm-delegate` are re-exported into one namespace by `@owlmeans/viable`.
 
 **A transport that cannot serve a question THROWS.** A declined answer is a decision; a channel that
 is gone is terminal, and the two must never look alike.
 
-`InquiryUnavailable` is registered fatal (`registerFatalError`) **beside the throw**, so no caller
+`InquiryUnavailable` is registered fatal (`retryHelper.registerFatalError`) **beside the throw**, so no caller
 has to remember: every retry ladder aborts at once instead of spending itself on a channel nobody is
 behind. `InquiryDeclined` is deliberately NOT fatal — the run decides for itself and carries on.
 
@@ -148,8 +148,8 @@ is a tool the model tries once and remembers as broken.
 
 The body never throws, with exactly one exception: `InquiryUnavailable` is **rethrown**. No channel
 is an answerable situation (`{ error: 'Nobody can answer …' }`); a channel that WAS there and
-vanished is not. That escape only works if the agent passes `fatal: e => isFatalError(e) != null`
-into `safeInvokeTool` — **an agent installing this plugin must**, or the loop spends its whole turn
+vanished is not. That escape only works if the agent passes `fatal: e => retryHelper.isFatalError(e) != null`
+into `toolHelper.safeInvokeTool` — **an agent installing this plugin must**, or the loop spends its whole turn
 budget on a dead channel.
 
 ## Parking a pipeline: `Waiting`
@@ -157,7 +157,7 @@ budget on a dead channel.
 `PipelineRunContext.ask(inquiry)` has three outcomes, in order:
 
 1. An answer already in the state (a resume) is returned at once — a question is never asked twice.
-2. A live channel answers: the answer is recorded in the state (`stateAnswerOf(capAnswer(...))`
+2. A live channel answers: the answer is recorded in the state (`inquiryHelper.stateAnswerOf(inquiryHelper.capAnswer(...))`
    under `state[INQUIRY_ANSWERS_KEY][inquiry.id]`) and the FULL answer is returned.
 3. Nobody is there: the run stops `Waiting` with the inquiry on its row, and the call never returns.
 
@@ -173,7 +173,7 @@ cannot park at all: it throws `PipelineNotResumableError`, because nothing would
 Answers are merged **by the runner**, in both `invoke` and `resume` (`resume(runId, { answers })`),
 never by a caller's mapping: the seed overwrites the restored state key by key, so a mapping that
 forwarded the answers map would wipe the child's own recorded answers. The merge applies the same
-`stateAnswerOf(capAnswer(...))` cut the live path does — a resume is how an answer usually arrives,
+`inquiryHelper.stateAnswerOf(inquiryHelper.capAnswer(...))` cut the live path does — a resume is how an answer usually arrives,
 so a ceiling enforced on the live path alone is enforced where the least text comes in. Answers are
 also the one state key that ACCUMULATES, so `ctx.ask` re-reads the map at write time: steps with no
 edge between them run in one superstep, and a write built from a pre-await copy loses a sibling's

package/agent-meta/skills/llm/SKILL.md

@@ -8,7 +8,7 @@ user-invocable: false
 # @owlmeans/llm
 
 **Layer:** Core
-**Install:** `"@owlmeans/llm": "^0.1.18-rc.44"` in `dependencies` (plus the `@langchain/*` peers)
+**Install:** `"@owlmeans/llm": "^0.1.18-rc.45"` in `dependencies` (plus the `@langchain/*` peers)
 
 The inference runtime. Everything provider-specific is a **plugin**; the model itself only owns the
 provider-independent parts (streaming discipline, retries, validation, observability). Serializable
@@ -27,15 +27,15 @@ symbol "because a test needs it".
 | `makePromptService(options?, alias?)` · `appendPromptService(ctx, options?, alias?)` · `promptServiceApi(options, self)` | Skill registry + the composition plugin chain. Also at `@owlmeans/llm/prompt`. |
 | `rolePlugin`, `skillsPlugin`, `resultsPlugin`, `contextPlugin`, `BUILT_IN_PROMPT_PLUGINS` | The built-in composition plugins. |
 | `PromptContext.claim(key)` · `PromptComposeParams.utility` | Per-composition ownership of a key; a cheap model for one plugin-side call. |
-| `renderSkill`, `sortSkills`, `joinChunks`, `compareAlias`, `prefixHash` · `readCacheUsage`, `hasCacheActivity` | Deterministic rendering primitives — reuse them, never re-implement — and normalized prompt-cache accounting from a completion. |
-| `plugins`, `registerLlmPlugin`, `resolvePlugin`, `pluginOf`, `pluginFor` | The provider-plugin registry. Also at `@owlmeans/llm/plugins`. |
+| `promptRenderHelper.{renderSkill, sortSkills, joinChunks, compareAlias, prefixHash}` · `cacheHelper.{readCacheUsage, hasCacheActivity}` | Deterministic rendering primitives — reuse them, never re-implement — and normalized prompt-cache accounting from a completion. |
+| `llmPluginRegistry.{plugins, register, resolvePlugin, pluginOf, pluginFor}` | The provider-plugin registry. Also at `@owlmeans/llm/plugins`. |
 | `anthropicPlugin`, `openAiPlugin`, `compatiblePlugin`, `openAiFamily` | Built-in providers; `openAiFamily` is the shared OpenAI-client behaviour to spread into a new plugin. |
-| `NO_SAMPLING_PREFIXES` / `rejectsSampling(model)` · `RESPONSES_API_PREFIXES` / `usesResponsesApi(model)` | Which families reject which sampling parameters — see the table below. Consumers pin presets against them. |
-| `effortSupportOf(config)` · `OPENAI_EFFORT_SUPPORT`, `OPENAI_HIDDEN_PROPERTY_NAMES`, `ANTHROPIC_MODEL_SUPPORT` / `anthropicSupportOf(model)` · `REASONING_MIN_MAX_TOKENS` | Which `ModelConfig.effort` levels a model accepts, and the per-family Anthropic facts beside them — see "Fallback chains and provider effort". |
-| `ThinkingOff`, `thinkingOffFor(config)` · `rejectsForcedTool(model)` | The Anthropic off switch a config sends (`disabled`, `between_tools`, or none), and whether a model refuses a pinned `tool_choice`. |
-| `withRetry`, `registerFatalError`, `isFatalError`, `spectate`, `normalizeInput`, `parseJsonContent`, `coerceToSchema`, `resolveFallbacks`, `PROVIDER_NEUTRAL_FIELDS` | Helpers usable alongside a model. Also at `@owlmeans/llm/helpers`. |
+| `NO_SAMPLING_PREFIXES` / `anthropicSupportHelper.rejectsSampling(model)` · `RESPONSES_API_PREFIXES` / `usesResponsesApi(model)` | Which families reject which sampling parameters — see the table below. Consumers pin presets against them. |
+| `llmPluginRegistry.effortSupportOf(config)` · `OPENAI_EFFORT_SUPPORT`, `OPENAI_HIDDEN_PROPERTY_NAMES`, `ANTHROPIC_MODEL_SUPPORT` / `anthropicSupportHelper.anthropicSupportOf(model)` · `REASONING_MIN_MAX_TOKENS` | Which `ModelConfig.effort` levels a model accepts, and the per-family Anthropic facts beside them — see "Fallback chains and provider effort". |
+| `ThinkingOff`, `anthropicSupportHelper.thinkingOffFor(config)` · `anthropicSupportHelper.rejectsForcedTool(model)` | The Anthropic off switch a config sends (`disabled`, `between_tools`, or none), and whether a model refuses a pinned `tool_choice`. |
+| `retryHelper.{withRetry, registerFatalError, isFatalError}`, `spectate`, `normalizeInput`, `jsonHelper.{parseJsonContent, coerceToSchema}`, `resolveFallbacks`, `PROVIDER_NEUTRAL_FIELDS` | Helpers usable alongside a model. Also at `@owlmeans/llm/helpers`. |
 | `LlmError`, `LlmModelError`, `LlmMissconfiguredError`, `LlmPluginError`, `LlmRetryExceededError` | `ResilientError` family. `LlmModelError` is the RETRYABLE one. |
-| `mergePrompt`, `mergePolicy`, `resolveRole`, `effortPatch`, `freezeResults` | Execution merge helpers; `mergePrompt` unions skills and takes the deepest role; `freezeResults` deep-freezes a results view. |
+| `executionPolicyHelper.{mergePrompt, mergePolicy, resolveRole, effortPatch}`, `executionStateHelper.freezeResults` | Execution merge helpers; `mergePrompt` unions skills and takes the deepest role; `freezeResults` deep-freezes a results view. |
 | `DEFAULT_MODEL_RETRIES`, `MODEL_STREAM_TIMEOUT_MS` (3 min idle), `FALLBACK_AFTER_ATTEMPTS`, `TEMPERATURE_PER_EFFORT_STEP`, `DEFAULT_EFFORT`, `EFFORT_TABLE`, `MAX_CACHE_BREAKPOINTS`, `MAX_SYSTEM_BREAKPOINTS`, `MIN_CACHEABLE_TOKENS`, `LLM_SERVICE`, `EXECUTION_SERVICE`, `PROMPT_SERVICE` | Tuning + aliases. |
 
 ## Provider differences are plugins, never `if`s
@@ -47,7 +47,7 @@ symbol "because a test needs it".
 | `build` | the provider switch in the model factory |
 | `owns` / `family` | `instanceof` checks; a `family` change between rungs re-renders the prompt |
 | `refine` | the per-provider retry rebuild (budget doubling, reasoning shrink, effort climb) |
-| `effort` | which `ModelConfig.effort` levels a model accepts (`effortSupportOf(config)`) |
+| `effort` | which `ModelConfig.effort` levels a model accepts (`llmPluginRegistry.effortSupportOf(config)`) |
 | `structuredMode` | native `response_format` vs a structured-output tool call |
 | `toolChoice(toolName, config)` / `responseFormat` | the provider-specific call shapes; `config` is the ACTIVE rung's, so a model that refuses a pinned tool gets the automatic choice |
 | `pinsTool(config)` / `strictTool(config, schema)` | whether `toolChoice` pins the tool (when not, `prepare` appends `toolCallInstruction`), and whether the tool goes `strict` |
@@ -69,7 +69,7 @@ hooks, through a predicate the package root exports:
 
 | Family | Rejects | Predicate |
 |---|---|---|
-| Claude 4.7+ and the 5 family | `temperature`, `top_p`, `top_k` | `NO_SAMPLING_PREFIXES` / `rejectsSampling(model)` |
+| Claude 4.7+ and the 5 family | `temperature`, `top_p`, `top_k` | `NO_SAMPLING_PREFIXES` / `anthropicSupportHelper.rejectsSampling(model)` |
 | OpenAI Responses API (`gpt-6*`, `gpt-5*`, `codex-*`) | `temperature`, `top_p` | `RESPONSES_API_PREFIXES` / `usesResponsesApi(model)` |
 
 A new OpenAI family goes into `RESPONSES_API_PREFIXES` the day it is pinned: outside it the model
@@ -82,7 +82,7 @@ primary's. Keep the predicate exported: consumers
 pin presets against it (viable-agent's `tests/presets.test.ts` asserts no preset entry declares a
 parameter its model rejects), and a second hand-written copy drifts when a family is added.
 
-**Registration order is load-bearing.** Instance lookup (`pluginFor`) returns the FIRST plugin whose
+**Registration order is load-bearing.** Instance lookup (`llmPluginRegistry.pluginFor`) returns the FIRST plugin whose
 `owns` matches, and `compatible` is registered before `openai` because both build a `ChatOpenAI`:
 assuming the tool-calling hack for an unlabelled model is safe everywhere, assuming native
 JSON-schema support is not.
@@ -94,7 +94,7 @@ composes them into an ordered, cacheable system message; a caller's own leading
 folded into the volatile `Context` block, so an unmigrated call site still works. **Do not build a
 persona as a `SystemMessage` in a helper** — declare it as `PromptPolicy.role` plus registered
 skills, or the knowledge duplicates and the cache prefix stops being stable. Skills accumulate down
-the execution chain (project → task → helper) and the deepest declared `role` wins (`mergePrompt`).
+the execution chain (project → task → helper) and the deepest declared `role` wins (`executionPolicyHelper.mergePrompt`).
 Block order, the breakpoint budget, the provider facts behind them, and the plugin seams
 `claim(key)` / `utility`: [[llm-prompt-caching]].
 
@@ -177,7 +177,7 @@ look retryable — costing the whole retry budget with the real message buried u
    (`ContextOverflowError` for an input past the context window, and its siblings) carrying the
    original **only under `cause`**, no `status` of its own — so `e.status === 400` misses it.
 
-Use `isBadRequest` from `plugins/utils.ts`: it walks the `cause` chain for `status === 400`, bounded
+Use `pluginUtils.isBadRequest` from `plugins/utils.ts`: it walks the `cause` chain for `status === 400`, bounded
 in depth so a self-referential chain terminates. Both built-in `isFatal` implementations go through
 it. A context overflow makes this urgent: `refine` escalates the **output** budget on each retry, so
 an over-limit **input** can never improve — every attempt re-sends the identical oversized request,
@@ -216,13 +216,13 @@ model switch depends on preset data rather than code: the role must declare a `f
 in the other direction — a per-call resolver consulted before the global ones and the plugin's
 `isFatal`, for an error the caller knows no retry can fix.
 
-### A loop ABOVE the model asks the same question with `isFatalError`
+### A loop ABOVE the model asks the same question with `retryHelper.isFatalError`
 
 A retry loop is not the only place that decides to carry on: a fix ladder rescues a failed repair and
 climbs to a stronger model, an agent runner catches a round that threw and reports "gave up". Both
 are right for a model that answered badly and wrong for a budget that ran out, and a blanket `catch`
 cannot tell them apart — an exhausted balance becomes more expensive calls instead of a halt.
-`isFatalError(e, fatal?)` runs the same resolvers, in the same order, that `withRetry` uses, and
+`retryHelper.isFatalError(e, fatal?)` runs the same resolvers, in the same order, that `retryHelper.withRetry` uses, and
 returns the error to abort WITH (a resolver may unwrap a carrier and hand back the real cause) or
 `null` when nothing considers it terminal. Ask it rather than re-deriving the rule.
 
@@ -237,7 +237,7 @@ Four fields, and conflating them turns an escalation into a fatal 400 hours into
 | `maxOutput` | what the PROVIDER accepts in one request — a fact about the model |
 | `contextWindow` | total window (input + output); informational, never sent |
 
-`resolveOutputCap` (`utils/config.ts`) reconciles them: the declared cap chooses the ceiling and the
+`configUtils.resolveOutputCap` (`utils/config.ts`) reconciles them: the declared cap chooses the ceiling and the
 capability trims it, and `DEFAULT_MAX_OUTPUT_CAP` applies only when neither is stated. `createModel`
 also clamps `maxTokens` to `maxOutput` and warns about a cap above it. For an aggregated model
 `maxOutput` is the limit of the `inferenceProvider` actually pinned, often far below what the model
@@ -301,14 +301,14 @@ lives — never an inline check on one id:
 | Sonnet 5, Opus 4.8/4.7 | `disabled` | all | accepted | 1024 |
 | Older models (Haiku 4.5, Sonnet 4.6, …) | none — they reason only when asked | per the effort table | accepted | 1024 |
 
-`thinkingOffFor(config)` is the value `build` sends; `refine` carries it through `lc_kwargs` and
+`anthropicSupportHelper.thinkingOffFor(config)` is the value `build` sends; `refine` carries it through `lc_kwargs` and
 reads it back to keep the ceiling, so a climbed retry stops at `high` instead of answering 400. The
 cache minimum is the default under a preset's own `cacheMinTokens`.
 
-**Structured output on a model that refuses a pinned tool** (`rejectsForcedTool`): `toolChoice`
+**Structured output on a model that refuses a pinned tool** (`anthropicSupportHelper.rejectsForcedTool`): `toolChoice`
 answers `{ type: 'auto' }`, `pinsTool` answers `false`, and `prepare` appends
 `toolCallInstruction(toolName)` to the per-call payload after the JSON mention — the prompt is all
-that asks for the call. The tool goes `strict: true` only when `isStrictSchema(schema)` (every object
+that asks for the call. The tool goes `strict: true` only when `schemaUtils.isStrictSchema(schema)` (every object
 closed with `additionalProperties: false`, basic types, scalar `enum`/`const`, `anyOf`/`allOf`, the
 listed formats, `minItems` 0/1; no `$ref`, no length/pattern/numeric constraints, no `nullable`): a
 strict schema outside that subset is a 400 no retry fixes, while a non-strict one is still checked by
@@ -326,7 +326,7 @@ family, not Opus 4.8/4.7); the wire is unchanged.
 **Effort climbs on retries, one level per attempt of the rung** (`LlmRefineParams.rungAttempt`), from
 the rung's declared level — or its model's default once it has retried — to the model's ceiling. So
 each fallback starts from its OWN level. A `TemperatureFactory` request climbs it too
-(`temperatureSteps`: one level per `TEMPERATURE_PER_EFFORT_STEP` = 0.3, at least one), because the
+(`effortUtils.temperatureSteps`: one level per `TEMPERATURE_PER_EFFORT_STEP` = 0.3, at least one), because the
 models that take effort have mostly taken sampling away and "hotter" alone changes nothing on the
 wire. Effort is part of Anthropic's cached prefix, so a climbed retry writes a new cache entry.
 At `high` and above the OpenAI plugin floors the output budget at `REASONING_MIN_MAX_TOKENS` (25k,
@@ -361,7 +361,7 @@ JSON pointer (only keys of a `properties` map — a keyword in keyword position
 fatal to every retry loop. Function calling (`structuredOutput: false`) and Anthropic's tool mode
 keep every name and are not refused. Rename the field (`mandatory` for `required`). `strict: true`
 is not sent to OpenAI: its strict mode also demands every property in `required`, which
-`isStrictSchema` (Anthropic's subset) does not check.
+`schemaUtils.isStrictSchema` (Anthropic's subset) does not check.
 
 ### Reasoning is off unless a preset asks for it — and it is billed against the same budget
 
@@ -378,7 +378,7 @@ the idle deadline reads as a dead connection and retries from scratch
 `makeLlmModel` appends the literal `/no_think` to every request's prepared messages whenever the flag
 is set AND the plugin's `suppressesThinking(config)` does not answer `true` — the soft switch for
 models with no request-level control (Qwen3). The Anthropic plugin answers `true` only for
-`rejectsSampling(model)`, and for those puts the family's off switch (`thinkingOffFor`, the table
+`anthropicSupportHelper.rejectsSampling(model)`, and for those puts the family's off switch (`anthropicSupportHelper.thinkingOffFor`, the table
 above) on the request in `build`, which `refine` carries through `lc_kwargs` on every attempt — on a
 model that always thinks nothing is sent and the flag only keeps the directive out. Below that line
 (`claude-haiku-4-5`, `claude-sonnet-4-6`) and under any plugin declaring no hook the flag injects
@@ -388,9 +388,9 @@ switches TO Anthropic inherits nothing and must name it (viable-agent's `presets
 rung). Turning reasoning ON is a per-role decision.
 
 `ADAPTIVE_MIN_MAX_TOKENS` (32k) is the output floor the Anthropic plugin's `build` applies to every
-`rejectsSampling(model)` config — `disableThinking` is not consulted, so a role with reasoning turned
+`anthropicSupportHelper.rejectsSampling(model)` config — `disableThinking` is not consulted, so a role with reasoning turned
 off is floored just the same. It is a floor, not an override (a preset asking for more keeps it) and
-it is clamped through `resolveOutputCap`, so it can never exceed what the provider accepts and turn a
+it is clamped through `configUtils.resolveOutputCap`, so it can never exceed what the provider accepts and turn a
 retryable empty answer into a fatal 400. Raising or removing it re-opens empty completions.
 
 Two diagnostics the above depends on:

package/agent-meta/skills/llm-prompt-caching/SKILL.md

@@ -34,7 +34,7 @@ its text simply travels a different route.
 ## Rules
 
 - **Order is the cache key.** `PROMPT_BLOCK_ORDER` is declared explicitly, skills sort by
-  `(order, alias)` with a code-unit comparison (`compareAlias`, never `localeCompare` —
+  `(order, alias)` with a code-unit comparison (`promptRenderHelper.compareAlias`, never `localeCompare` —
   ICU data differs between hosts), and detected packages sort alphabetically.
 - **Skill bodies are pure constants.** No timestamps, no absolute paths, no interpolated
   request data. One varying byte invalidates the prefix for every call that shares it.
@@ -59,10 +59,10 @@ its text simply travels a different route.
   may spend at most `MAX_SYSTEM_BREAKPOINTS` (2) — its only STABLE boundaries are the end
   of role+skills and the end of packages — which always leaves two for the messages.
 - **The last message is never cached.** `patchCache` stops one short of the end: the final
-  message is the per-call payload, and `ensureJsonMention` / `applyNoThink` append to it.
+  message is the per-call payload, and `promptUtils.ensureJsonMention` / `.applyNoThink` append to it.
 - **Markers are placed in-place, on the caller's objects.** A caller that carries its
   message array across calls (a coder's growing conversation, a fix loop) hands them back
-  still marked, and they accumulate. `prepare()` therefore calls `stripCacheMarkers()`
+  still marked, and they accumulate. `prepare()` therefore calls `promptUtils.stripCacheMarkers()`
   first, so the per-request count depends on THIS call alone. Anything that places a
   marker outside that pipeline must do the same.
 - **A short prefix is not marked.** Below `MIN_CACHEABLE_TOKENS` (override per alias with
@@ -75,7 +75,7 @@ its text simply travels a different route.
 > logs for `Prompt cache [` lines and a non-zero `read`.
 
 
-`usage_metadata.input_token_details` is the only honest answer. `readCacheUsage(message)`
+`usage_metadata.input_token_details` is the only honest answer. `cacheHelper.readCacheUsage(message)`
 (`@owlmeans/llm/helpers`) normalizes it; `spectate` logs a line whenever a provider reports
 any cache activity. **If `read` stays 0 across repeated calls that share a prefix, something
 is invalidating it** — diff `PromptResult.blocks` between two calls to find what.

package/build/execution/index.d.ts

@@ -1,4 +1,8 @@
 export type * from './types.js';
+export type * from './policy/types.js';
+export type * from './state/types.js';
+export * from './policy.js';
+export * from './state.js';
 export * from './utils.js';
 export * from './service.js';
 //# sourceMappingURL=index.d.ts.map

package/build/execution/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/execution/index.ts"],"names":[],"mappings":"AACA,mBAAmB,YAAY,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/execution/index.ts"],"names":[],"mappings":"AACA,mBAAmB,YAAY,CAAA;AAC/B,mBAAmB,mBAAmB,CAAA;AACtC,mBAAmB,kBAAkB,CAAA;AACrC,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA"}

package/build/execution/index.js

@@ -1,3 +1,5 @@
+export * from './policy.js';
+export * from './state.js';
 export * from './utils.js';
 export * from './service.js';
 //# sourceMappingURL=index.js.map

package/build/execution/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/execution/index.ts"],"names":[],"mappings":"AAEA,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/execution/index.ts"],"names":[],"mappings":"AAIA,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA"}

package/build/execution/policy/types.d.ts

@@ -0,0 +1,34 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { ExecutionEffort, ModelConfigOverride, ModelConfigPatch, ModelEffort, ModelPolicy, ModelRole, PromptPolicy } from '@owlmeans/llm-common';
+/** How an execution's model policy and prompt policy are layered and resolved. */
+export interface ExecutionPolicyHelper {
+    /** Overlay a partial policy onto a base one. Override maps are merged, not replaced. */
+    mergePolicy: (base: ModelPolicy, patch: Partial<ModelPolicy>) => ModelPolicy;
+    /**
+     * Overlay a prompt policy onto the one inherited from the parent level.
+     *
+     * Skills ACCUMULATE — a task adds to what the project declared, a helper adds to the
+     * task — because that is how a capability set is built up as work narrows. The role is
+     * replaced instead: the deepest level that names one owns the persona.
+     *
+     * The union preserves first-seen order and de-duplicates, so the composed prompt is
+     * byte-identical no matter how many levels contributed the same skill.
+     */
+    mergePrompt: (base: PromptPolicy | undefined, patch: PromptPolicy | undefined) => PromptPolicy | undefined;
+    /** Apply the policy's role→role remap. */
+    resolveRole: (policy: ModelPolicy, role: ModelRole) => ModelRole;
+    effortPatch: (effort: ExecutionEffort) => ModelConfigPatch;
+    /**
+     * The effort `steps` levels above what `model` was built with (its model's default when it
+     * declares none), or `undefined` when that model accepts no effort.
+     */
+    raisedEffort: (model: BaseChatModel, steps: number) => ModelEffort | undefined;
+    /** Normalize a {@link ModelConfigOverride} (alias or patch) to a patch. */
+    resolveModelConfig: (override: ModelConfigOverride) => ModelConfigPatch;
+    /**
+     * Merge effort < policy.modelOverride < call-site override into a single patch.
+     * Any field present in a higher-precedence source wins.
+     */
+    mergeOverride: (effortBase: ModelConfigPatch, policyOverride: ModelConfigOverride | undefined, callOverride: ModelConfigOverride | undefined) => ModelConfigPatch;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/execution/policy/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/execution/policy/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAA;AAChF,OAAO,KAAK,EACV,eAAe,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,EAC1G,MAAM,sBAAsB,CAAA;AAE7B,kFAAkF;AAClF,MAAM,WAAW,qBAAqB;IACpC,wFAAwF;IACxF,WAAW,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,WAAW,CAAA;IAC5E;;;;;;;;;OASG;IACH,WAAW,EAAE,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,KAAK,EAAE,YAAY,GAAG,SAAS,KAAK,YAAY,GAAG,SAAS,CAAA;IAC1G,0CAA0C;IAC1C,WAAW,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,KAAK,SAAS,CAAA;IAChE,WAAW,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,gBAAgB,CAAA;IAC1D;;;OAGG;IACH,YAAY,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAA;IAC9E,2EAA2E;IAC3E,kBAAkB,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,gBAAgB,CAAA;IACvE;;;OAGG;IACH,aAAa,EAAE,CACb,UAAU,EAAE,gBAAgB,EAC5B,cAAc,EAAE,mBAAmB,GAAG,SAAS,EAC/C,YAAY,EAAE,mBAAmB,GAAG,SAAS,KAC1C,gBAAgB,CAAA;CACtB"}

package/build/execution/policy/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/execution/policy/types.ts"],"names":[],"mappings":""}

package/build/execution/policy.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutionPolicyHelper } from './policy/types.js';
+export declare const createExecutionPolicyHelper: () => ExecutionPolicyHelper;
+export declare const executionPolicyHelper: ExecutionPolicyHelper;
+//# sourceMappingURL=policy.d.ts.map

package/build/execution/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/execution/policy.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAE9D,eAAO,MAAM,2BAA2B,QAAO,qBA4D9C,CAAA;AAED,eAAO,MAAM,qBAAqB,uBAAgC,CAAA"}

package/build/execution/policy.js

@@ -0,0 +1,49 @@
+import { EFFORT_TABLE } from '../consts.js';
+import { llmPluginRegistry } from '../plugins/registry.js';
+import { configUtils } from '../utils/config.js';
+import { effortUtils } from '../utils/effort.js';
+export const createExecutionPolicyHelper = () => {
+    const mergePolicy = (base, patch) => {
+        const utilityRole = patch.utilityRole ?? base.utilityRole;
+        return {
+            effort: patch.effort ?? base.effort,
+            roleOverrides: patch.roleOverrides != null || base.roleOverrides != null
+                ? { ...base.roleOverrides, ...patch.roleOverrides }
+                : undefined,
+            modelOverrides: patch.modelOverrides != null || base.modelOverrides != null
+                ? { ...base.modelOverrides, ...patch.modelOverrides }
+                : undefined,
+            // Added only when it exists, unlike the maps above: a project that never names a
+            // cheap tier must not gain a `utilityRole` key it would then carry into every snapshot.
+            ...(utilityRole != null ? { utilityRole } : {}),
+        };
+    };
+    const mergePrompt = (base, patch) => {
+        if (base == null && patch == null) {
+            return undefined;
+        }
+        const skills = [...new Set([...(base?.skills ?? []), ...(patch?.skills ?? [])])];
+        return {
+            ...base,
+            ...patch,
+            ...(base?.role != null || patch?.role != null ? { role: patch?.role ?? base?.role } : {}),
+            ...(skills.length > 0 ? { skills } : {}),
+        };
+    };
+    const resolveRole = (policy, role) => policy.roleOverrides?.[role] ?? role;
+    const effortPatch = (effort) => EFFORT_TABLE[effort];
+    const raisedEffort = (model, steps) => {
+        const config = configUtils.readConfig(model);
+        const support = llmPluginRegistry.effortSupportOf(config);
+        return support != null ? effortUtils.raiseEffort(support, config.effort, steps) : undefined;
+    };
+    const resolveModelConfig = (override) => typeof override === 'string' ? { preset: override } : override;
+    const mergeOverride = (effortBase, policyOverride, callOverride) => {
+        const policy = policyOverride != null ? resolveModelConfig(policyOverride) : {};
+        const call = callOverride != null ? resolveModelConfig(callOverride) : {};
+        return { ...effortBase, ...policy, ...call };
+    };
+    return { mergePolicy, mergePrompt, resolveRole, effortPatch, raisedEffort, resolveModelConfig, mergeOverride };
+};
+export const executionPolicyHelper = createExecutionPolicyHelper();
+//# sourceMappingURL=policy.js.map

package/build/execution/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.js","sourceRoot":"","sources":["../../src/execution/policy.ts"],"names":[],"mappings":"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"}

package/build/execution/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/execution/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAOtF,OAAO,KAAK,EACkB,gBAAgB,EAAE,uBAAuB,EAAE,cAAc,EACrD,oBAAoB,EACrD,MAAM,YAAY,CAAA;AASnB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,cAAc,GAAG,cAAc,WAClE,uBAAuB,QAC1B,MAAM,gBAAgB,CAAC,CAAC,CAAC,KAC9B,gBAAgB,CAAC,CAAC,CAoMpB,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,cAAc,GAAG,cAAc,UACrE,MAAM,YACJ,uBAAuB,KAC/B,gBAAgB,CAAC,CAAC,CAMpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,cAAc,GAAG,cAAc,OAEtF,CAAC,UACC,MAAM,YACJ,uBAAuB,KAC/B,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAQ5B,CAAA"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/execution/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAOtF,OAAO,KAAK,EACkB,gBAAgB,EAAE,uBAAuB,EAAE,cAAc,EACrD,oBAAoB,EACrD,MAAM,YAAY,CAAA;AAOnB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,cAAc,GAAG,cAAc,WAClE,uBAAuB,QAC1B,MAAM,gBAAgB,CAAC,CAAC,CAAC,KAC9B,gBAAgB,CAAC,CAAC,CAoMpB,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,cAAc,GAAG,cAAc,UACrE,MAAM,YACJ,uBAAuB,KAC/B,gBAAgB,CAAC,CAAC,CAMpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,cAAc,GAAG,cAAc,OAEtF,CAAC,UACC,MAAM,YACJ,uBAAuB,KAC/B,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAQ5B,CAAA"}