@owlmeans/llm 0.1.15 → 0.1.16-rc.0

package/agent-meta/instructions/llm-prompt-caching.instructions.md

@@ -0,0 +1,100 @@
+---
+description: "How the OwlMeans LLM layer composes a system prompt from a role and skills, and the prompt-cache rules that layout exists to satisfy — block order, breakpoint budget, determinism invariants, and the provider facts behind them. Consult before changing prompt composition, skills, a prompt plugin, or anything a request sends before its first per-call byte."
+applyTo: "**/*.ts, **/*.tsx"
+---
+<!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
+
+# Prompt composition and caching
+
+**Layer:** Core · **Packages:** `@owlmeans/llm` (`./prompt`), `@owlmeans/llm-common`, `@owlmeans/agent-skills` (`./llm`)
+
+A prompt cache is an **exact prefix match**. Everything below follows from that: the bytes
+every call shares must come first, physically, and must be identical down to the
+whitespace.
+
+## The block layout
+
+`PromptService.compose()` renders four ordered blocks into one system message:
+
+| # | Block | Contributed by | Changes | Breakpoint |
+|---|-------|----------------|---------|-----------|
+| 0 | `Role` | `rolePlugin` ← `PromptPolicy.role` | per role | — |
+| 1 | `Skills` | `skillsPlugin` ← registry + `inline` | per helper | ✅ closes role+skills |
+| 2 | `Packages` | app plugins | per request | ✅ its own |
+| 3 | `Context` | `contextPlugin` ← `context`, `callSkills` | per call | **never** (unless sole block) |
+
+A caller's own leading `SystemMessage` is detached by `makeLlmModel` and re-emitted as
+`Context`, so a helper that has not adopted `prompt: { role, skills }` keeps working.
+
+## Rules
+
+- **Order is the cache key.** `PROMPT_BLOCK_ORDER` is explicit; skills sort by
+  `(order, alias)` with a code-unit comparison (never `localeCompare`); detected packages
+  sort alphabetically.
+- **Skill bodies are pure constants** — no timestamps, paths, or interpolated request data.
+- **A volatile block is never marked.** The trailing `Context` block changes every
+  call: a breakpoint there would pay a cache WRITE on every request and never read
+  one back. It is marked ONLY when it is the entire prompt (a caller that has not
+  adopted role/skills), because there it IS the stable part. Its parts are merged
+  into one chunk for the same reason — nothing downstream needs them separable.
+- **Volatile content goes last.** Per-call skills use `LlmCallOptions.skills` (→ `Context`),
+  never the execution's `skills` (→ the cached `Skills` block).
+- **Budget: 4 breakpoints per request.** The system prompt spends at most 3.
+- **The last message is never cached** — it is the per-call payload.
+- **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()`
+  first, so the per-request count depends on THIS call alone. Anything that places a
+  marker outside that pipeline must do the same.
+- **A prefix below `MIN_CACHEABLE_TOKENS` is left unmarked** (`ModelConfig.cacheMinTokens`
+  overrides per alias).
+- **A prompt plugin MUST be deterministic**, and registering the same alias twice replaces
+  rather than appends.
+
+## Verifying it works
+> **The smoke test cannot catch a caching bug.** It makes no model calls. A breakpoint-budget
+> or marker-accumulation fault only appears under a real multi-call agent run — and it
+> surfaces as a `400`, which the retry loop can bury for minutes. Check the agent's own pod
+> logs for `Prompt cache [` lines and a non-zero `read`.
+
+
+`readCacheUsage(message)` from `@owlmeans/llm/helpers` reads
+`usage_metadata.input_token_details`. If `read` stays 0 across repeated calls that share a
+prefix, something is invalidating it — diff `PromptResult.blocks` between two calls.
+
+## Package skills in a prompt (`@owlmeans/agent-skills/llm`)
+
+`owlmeansPackagesPlugin(options)` notices which `@owlmeans/*` packages a request mentions
+and loads their published skills into the `Packages` block. Everything a package documents
+is loaded — there is no relevance filtering, by design.
+
+Resolution order per package: the host's `LlmFileProvider` (the only path that sees a
+sandbox or remote workspace) → an installed copy under `node_modules` → the canonical
+repository over HTTPS. Every failure is a miss, never a throw. Results, including misses,
+are cached per plugin instance.
+
+```typescript
+ctx.prompts().use(owlmeansPackagesPlugin({
+  files: () => ctx.files(),      // tried first
+  exclude: ['@owlmeans/llm'],    // already covered by the static Skills block
+  fetch: false,                  // air-gapped: skip the repository fallback
+}))
+```
+
+The manifest deliberately carries no git ref — version-matching comes from shipping the
+copy inside the tarball, so for a package that is NOT installed the ref is a plugin option
+(`ref`, default `main`).
+
+## Provider facts these rules encode
+
+**Anthropic** ([docs](https://platform.claude.com/docs/en/build-with-claude/prompt-caching.md)):
+render order `tools` → `system` → `messages`; max 4 breakpoints; minimum cacheable prefix is
+model-dependent and **not monotonic** (512 newest / 1024 most / 4096 on Opus 4.6-4.5 and
+Haiku 4.5); writes cost ~1.25× at 5m TTL and ~2× at 1h; a `system` change invalidates
+system + messages but not `tools`.
+
+**OpenAI** ([docs](https://developers.openai.com/api/docs/guides/prompt-caching)): automatic
+from 1024 tokens; routing hashes roughly the first 256 tokens and mixes in
+`prompt_cache_key`. The `openai` plugin sets it from the config alias; the `compatible`
+plugin does not, because aggregators with `provider.require_parameters` can drop providers
+over an unknown field.

package/agent-meta/instructions/llm.instructions.md

@@ -1,5 +1,5 @@
 ---
-description: "How to use @owlmeans/llm — the LLM inference runtime: four-method model, provider plugins, model factory service, and the policy-driven execution abstraction."
+description: "How to use @owlmeans/llm — the LLM inference runtime: four-method model, provider plugins, model factory service, the policy-driven execution abstraction, and the prompt/skill composition service."
 applyTo: "**/*.ts, **/*.tsx"
 ---
 <!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
@@ -7,7 +7,7 @@ applyTo: "**/*.ts, **/*.tsx"
 # @owlmeans/llm
 
 **Layer:** Core
-**Install:** `"@owlmeans/llm": "^0.1.15"` in `dependencies` (plus the `@langchain/*` peers)
+**Install:** `"@owlmeans/llm": "^0.1.16-rc.0"` in `dependencies` (plus the `@langchain/*` peers)
 
 The inference runtime. Everything provider-specific is a **plugin**; the model owns only the
 provider-independent parts. Serializable contracts live in `@owlmeans/llm-common`.
@@ -19,6 +19,8 @@ provider-independent parts. Serializable contracts live in `@owlmeans/llm-common
 | `makeLlmModel(options, spectator)` | `ask` / `talk` / `invoke` / `request`. |
 | `makeLlmService` · `appendLlmService` · `llmServiceApi` | Model factory/registry; `llmServiceApi` composes into your own service. |
 | `makeExecutionService` · `appendExecutionService` · `executionServiceApi` | Frozen 3-level executions, policy resolution, snapshot/restore/checkpoint. |
+| `makePromptService` · `appendPromptService` · `promptServiceApi` | Skill registry + composition plugin chain (`@owlmeans/llm/prompt`). |
+| `renderSkill`, `sortSkills`, `compareAlias`, `readCacheUsage` | Deterministic rendering and prompt-cache accounting. |
 | `plugins`, `registerLlmPlugin`, `resolvePlugin`, `pluginOf`, `pluginFor` | Provider-plugin registry (`@owlmeans/llm/plugins`). |
 | `anthropicPlugin`, `openAiPlugin`, `compatiblePlugin`, `openAiFamily` | Built-ins; spread `openAiFamily` into a new OpenAI-compatible plugin. |
 | `withRetry`, `registerFatalError`, `spectate`, `normalizeInput`, `parseJsonContent`, `coerceToSchema` | Helpers (`@owlmeans/llm/helpers`). |
@@ -30,14 +32,22 @@ provider-independent parts. Serializable contracts live in `@owlmeans/llm-common
   exported. Place a new function on the right side rather than exporting a util for a test.
 - Never branch on the provider (`instanceof ChatAnthropic`, `provider === …`) in the model or
   the service — put it on the `LlmPlugin` (`build` / `owns` / `family` / `refine` /
-  `structuredMode` / `toolChoice` / `responseFormat` / `patchCache` / `isFatal`).
+  `structuredMode` / `toolChoice` / `responseFormat` / `patchSystem` / `patchCache` / `isFatal`).
 - Plugin registration order is load-bearing: `pluginFor` returns the first `owns` match, and
   `compatible` precedes `openai` so an unlabelled `ChatOpenAI` gets the conservative
   tool-calling behaviour.
+- Never `instanceof` an error from a provider SDK: `@langchain/*` bundle their own
+  nested copies, so the check silently fails and a fatal `400` gets retried eight
+  times. Match `status === 400` instead.
 - `@langchain/*` are **peer** dependencies — model instances cross the package boundary and
   two installed copies are nominally distinct types. Pin one copy in the consumer.
 - Extend the execution generically: your own `ExecutionShape`, your collaborator fields in
   `collaboratorKeys`. Do not narrow inherited method signatures (contravariance error).
+- Never hand-build a persona as a `SystemMessage` in a helper. Declare it as
+  `PromptPolicy.role` plus registered skills and let the prompt service compose it —
+  otherwise the knowledge duplicates and the cacheable prefix stops being stable. Skills
+  accumulate project → task → helper; the deepest declared role wins (`mergePrompt`).
+  Block order, breakpoint budget and the provider facts: `llm-prompt-caching`.
 
 ## Usage
 

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "package": "@owlmeans/llm",
-  "version": "0.1.15",
-  "generatedAt": "2026-08-07T17:06:32.901Z",
+  "version": "0.1.16-rc.0",
+  "generatedAt": "2026-08-11T14:02:34.979Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {
@@ -12,12 +12,26 @@
       "file": "skills/llm/SKILL.md",
       "canonicalPath": ".claude/skills/llm/SKILL.md"
     },
+    {
+      "kind": "skill",
+      "name": "llm-prompt-caching",
+      "category": "multi-package",
+      "file": "skills/llm-prompt-caching/SKILL.md",
+      "canonicalPath": ".claude/skills/llm-prompt-caching/SKILL.md"
+    },
     {
       "kind": "instruction",
       "name": "llm",
       "category": "package-specific",
       "file": "instructions/llm.instructions.md",
       "canonicalPath": ".github/instructions/llm.instructions.md"
+    },
+    {
+      "kind": "instruction",
+      "name": "llm-prompt-caching",
+      "category": "multi-package",
+      "file": "instructions/llm-prompt-caching.instructions.md",
+      "canonicalPath": ".github/instructions/llm-prompt-caching.instructions.md"
     }
   ]
 }

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

@@ -1,6 +1,6 @@
 ---
 name: llm
-description: How to use @owlmeans/llm — the LLM inference runtime (four-method model, provider plugins, model factory service, policy-driven execution abstraction). Auto-invoked when importing the model, an LlmPlugin, the LlmService, or the execution service.
+description: How to use @owlmeans/llm — the LLM inference runtime (four-method model, provider plugins, model factory service, policy-driven execution abstraction, and the prompt/skill composition service). Auto-invoked when importing the model, an LlmPlugin, the LlmService, the execution service, or the prompt service.
 user-invocable: false
 ---
 <!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
@@ -8,7 +8,7 @@ user-invocable: false
 # @owlmeans/llm
 
 **Layer:** Core
-**Install:** `"@owlmeans/llm": "^0.1.15"` in `dependencies` (plus the `@langchain/*` peers)
+**Install:** `"@owlmeans/llm": "^0.1.16-rc.0"` 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,
@@ -22,12 +22,17 @@ observability). Serializable contracts live in `@owlmeans/llm-common`.
 | `makeLlmService(options, alias?)` · `appendLlmService(ctx, options, alias?)` | Model factory/registry — resolves a `ModelConfig` by alias, memoized per alias+override. |
 | `llmServiceApi(options, self)` | The factory half WITHOUT `createService`, to compose into your own service (role accessors, domain helpers). |
 | `makeExecutionService(alias?, options?)` · `appendExecutionService(ctx, alias?, options?)` | Frozen 3-level executions + policy resolution + snapshot/restore/checkpoint. |
+| `makePromptService(options?, alias?)` · `appendPromptService(ctx, options?, alias?)` · `promptServiceApi(options, self)` | Skill registry + the composition plugin chain. Also at `@owlmeans/llm/prompt`. |
+| `rolePlugin`, `skillsPlugin`, `contextPlugin`, `BUILT_IN_PROMPT_PLUGINS` | The built-in composition plugins. |
+| `renderSkill`, `sortSkills`, `joinChunks`, `compareAlias`, `prefixHash` | Deterministic rendering primitives — reuse them, never re-implement. |
+| `readCacheUsage`, `hasCacheActivity` | Normalized prompt-cache accounting from a completion. |
 | `executionServiceApi(options, self)` | The execution half without `createService`, for the same composition pattern. |
 | `plugins`, `registerLlmPlugin`, `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. |
 | `withRetry`, `registerFatalError`, `spectate`, `normalizeInput`, `parseJsonContent`, `coerceToSchema` | Helpers usable alongside a model. Also at `@owlmeans/llm/helpers`. |
 | `LlmError`, `LlmModelError`, `LlmMissconfiguredError`, `LlmPluginError`, `LlmRetryExceededError` | `ResilientError` family. `LlmModelError` is the RETRYABLE one. |
-| `DEFAULT_MODEL_RETRIES`, `MODEL_STREAM_TIMEOUT_MS`, `FALLBACK_AFTER_ATTEMPTS`, `DEFAULT_EFFORT`, `EFFORT_TABLE`, `LLM_SERVICE`, `EXECUTION_SERVICE` | Tuning + aliases. |
+| `mergePrompt`, `mergePolicy`, `resolveRole`, `effortPatch` | Execution merge helpers; `mergePrompt` unions skills and takes the deepest role. |
+| `DEFAULT_MODEL_RETRIES`, `MODEL_STREAM_TIMEOUT_MS` (3 min idle), `FALLBACK_AFTER_ATTEMPTS`, `DEFAULT_EFFORT`, `EFFORT_TABLE`, `MAX_CACHE_BREAKPOINTS`, `MAX_SYSTEM_BREAKPOINTS`, `MIN_CACHEABLE_TOKENS`, `LLM_SERVICE`, `EXECUTION_SERVICE`, `PROMPT_SERVICE` | Tuning + aliases. |
 
 ## helpers/ vs utils/ — the rule this package follows
 
@@ -50,7 +55,9 @@ Adding a function? Decide which side it belongs to first, then place it. Do not
 | `refine` | the per-provider retry rebuild (budget doubling, reasoning shrink) |
 | `structuredMode` | native `response_format` vs the forced-tool-call hack |
 | `toolChoice` / `responseFormat` | the provider-specific call shapes |
-| `patchCache` | prompt-cache markers |
+| `patchSystem` | how the composed system blocks are rendered and where their cache breakpoints go |
+| `patchCache` | the message-prefix cache marker |
+| `cacheKey` (via `ModelConfig.cacheKey`) | provider cache-routing hints such as OpenAI's `prompt_cache_key` |
 | `isFatal` | "this error can never be retried" |
 
 **Registration order is load-bearing.** Instance-based lookup (`pluginFor`) returns the
@@ -58,6 +65,19 @@ FIRST plugin whose `owns` matches. `compatible` is registered before `openai` be
 build a `ChatOpenAI`, and assuming the tool-calling hack for an unlabelled model is safe
 everywhere while assuming native JSON-schema support is not.
 
+## System prompts: a role and skills, never a hand-built message
+
+`makeLlmModel` takes `prompt` (a `PromptInput`) and a `prompts` resolver. The prompt service
+composes them into an ordered, cacheable system message; a caller's own leading
+`SystemMessage` is 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 — see `mergePrompt`. Full rules, breakpoint budget and the provider
+facts behind them: [[llm-prompt-caching]].
+
 ## Execution: policy in, model out
 
 ```
@@ -66,6 +86,9 @@ ProjectExecution   ← root: policy + purpose + models resolver
        └─ HelperExecution ← + a RESOLVED model + temperatureFactory, bound to a role
 ```
 
+`prompt` (role + skills) travels on `ExecutionState`, so it survives snapshot/restore;
+`prompts` and `files` are collaborators and never enter a snapshot.
+
 Every method returns a NEW `Object.freeze`d object. Resolution precedence in
 `model(exec, role, override)`: **roleOverride → modelOverride → effort tier →
 `LlmService.getModel`**. `escalate(exec, { effort })` raises the tier once and cascades to
@@ -79,6 +102,19 @@ inherited method signatures**, which would be a contravariance error.
 `snapshot` excludes `state` itself; without that, every `derive`/`escalate`/`withPurpose`
 on a task would nest another copy of the previous state.
 
+## Never `instanceof` an error from a provider SDK
+
+`@langchain/anthropic` and `@langchain/openai` bundle their OWN nested copies of the
+provider SDKs, so an error they throw is an instance of a DIFFERENT class than the one this
+package imports — `e instanceof BadRequestError` silently returns `false`. `isFatal` used
+that check, so every fatal `400` was classified retryable and burned all eight attempts,
+turning one malformed request into minutes of thrash with the real message buried under the
+retries.
+
+Match on the wire shape instead — `(e as { status?: unknown })?.status === 400`. The same
+trap applies to any cross-copy `instanceof`; it is the runtime face of the peer-dependency
+identity rule below.
+
 ## Peer-dependency rule (langchain identity)
 
 `@langchain/core`, `@langchain/openai` and `@langchain/anthropic` are **peer** dependencies:
@@ -99,6 +135,19 @@ const model = makeLlmModel(
 const spec = await model.invoke('Describe the app', SpecSchema, { action: 'spec' })
 ```
 
+## Hangs are bounded by an IDLE deadline, not a total one
+
+A stalled provider is aborted after `MODEL_STREAM_TIMEOUT_MS` (3 min) of SILENCE and
+surfaces as a retryable `LlmModelError`, so the escalator moves on. The timer re-arms on
+every token, so a long-but-productive generation is never cut off — which is why the value
+can be low. Set it for a whole deployment with `LlmServiceOptions.streamTimeout` where the
+application composes its context; a preset that names its own `ModelConfig.streamTimeout`
+keeps it.
+
+Note what this does NOT bound: a call that keeps streaming forever, and retries. A fatal
+error misclassified as retryable multiplies its own latency by `DEFAULT_MODEL_RETRIES` —
+see the `instanceof` trap above.
+
 ## Resilience already handled — do not reimplement
 
 Idle stream deadline · duplicate-final-chunk dedup · output-budget escalation · reasoning-cap
@@ -118,4 +167,5 @@ on `OPENROUTER_SECRET` / `ANTHROPIC_SECRET` in the repo-root `.env` and self-ski
 ## Related
 
 - [[llm-common]] — the serializable contracts
+- [[llm-prompt-caching]] — prompt composition, block order and the cache invariants
 - [[context]] — service registration · [[error]] — the `ResilientError` family

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

@@ -0,0 +1,135 @@
+---
+name: llm-prompt-caching
+description: How the OwlMeans LLM layer composes a system prompt from a role and skills, and the prompt-cache rules that layout exists to satisfy — block order, breakpoint budget, determinism invariants, and the provider facts behind them. Auto-invoked when touching prompt composition, skills, LlmPromptPlugin, patchSystem/patchCache, or anything that changes what a request sends before its first per-call byte.
+user-invocable: false
+---
+<!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
+
+# Prompt composition and caching
+
+**Layer:** Core · **Packages:** `@owlmeans/llm` (`./prompt`), `@owlmeans/llm-common`, `@owlmeans/agent-skills` (`./llm`)
+
+A prompt cache is an **exact prefix match**. Everything in this document follows from that
+one fact: the bytes every call shares must come first, physically, and must be identical
+down to the whitespace. The block layout, the ordering rules and the determinism
+invariants are not style — they are the cache.
+
+## The block layout
+
+`PromptService.compose()` renders four ordered blocks (`PromptBlock`, `PROMPT_BLOCK_ORDER`)
+into a single system message:
+
+| # | Block | Contributed by | Changes | Breakpoint |
+|---|-------|----------------|---------|-----------|
+| 0 | `Role` | `rolePlugin` ← `PromptPolicy.role` | per role | — |
+| 1 | `Skills` | `skillsPlugin` ← registry + `inline` | per helper | ✅ closes role+skills |
+| 2 | `Packages` | app plugins (e.g. `owlmeansPackagesPlugin`) | per request | ✅ its own |
+| 3 | `Context` | `contextPlugin` ← `context`, `callSkills` | per call | **never** (unless sole block) |
+
+A caller's own leading `SystemMessage` is detached by `makeLlmModel` and re-emitted as
+`Context`, so a helper that has not adopted `prompt: { role, skills }` keeps working —
+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` —
+  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.
+- **A volatile block is never marked.** The trailing `Context` block changes every
+  call: a breakpoint there would pay a cache WRITE on every request and never read
+  one back. It is marked ONLY when it is the entire prompt (a caller that has not
+  adopted role/skills), because there it IS the stable part. Its parts are merged
+  into one chunk for the same reason — nothing downstream needs them separable.
+- **Volatile content goes last.** Per-call skills belong in `LlmCallOptions.skills`
+  (→ `Context`), not in the execution's `skills` (→ the cached `Skills` block).
+- **Budget: 4 breakpoints per request, total** — across tools, system AND messages.
+  Anthropic rejects the fifth outright (`400 A maximum of 4 blocks with cache_control may
+  be provided. Found 5.`), and a 400 is fatal, so the whole call fails. The system prompt
+  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.
+- **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()`
+  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
+  `ModelConfig.cacheMinTokens`) a marker buys nothing and costs a breakpoint.
+
+## Verifying it works
+> **The smoke test cannot catch a caching bug.** It makes no model calls. A breakpoint-budget
+> or marker-accumulation fault only appears under a real multi-call agent run — and it
+> surfaces as a `400`, which the retry loop can bury for minutes. Check the agent's own pod
+> logs for `Prompt cache [` lines and a non-zero `read`.
+
+
+`usage_metadata.input_token_details` is the only honest answer. `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.
+
+## Adding a plugin
+
+```typescript
+ctx.prompts().use({
+  alias: 'my-plugin',
+  order: 50,                         // built-ins hold 0 (role), 10 (skills), 90 (context)
+  compose: ctx => ctx.add(PromptBlock.Skills, text),   // static, runs first
+  inspect: ctx => { /* reads ctx.messages */ },        // after every compose pass
+})
+```
+
+A plugin MUST be deterministic. Anything it contributes to a cached block and cannot
+reproduce byte-for-byte breaks the prefix for everyone sharing it. Register by alias —
+re-registering the same alias replaces rather than appends, so double-wiring cannot
+double-emit.
+
+## Package skills in a prompt (`@owlmeans/agent-skills/llm`)
+
+`owlmeansPackagesPlugin(options)` notices which `@owlmeans/*` packages a request mentions
+and loads their published skills into the `Packages` block. Everything a package documents
+is loaded — there is no relevance filtering, by design.
+
+Resolution order per package: the host's `LlmFileProvider` (the only path that sees a
+sandbox or remote workspace) → an installed copy under `node_modules` → the canonical
+repository over HTTPS. Every failure is a miss, never a throw. Results, including misses,
+are cached per plugin instance.
+
+```typescript
+ctx.prompts().use(owlmeansPackagesPlugin({
+  files: () => ctx.files(),      // tried first
+  exclude: ['@owlmeans/llm'],    // already covered by the static Skills block
+  fetch: false,                  // air-gapped: skip the repository fallback
+}))
+```
+
+The manifest deliberately carries no git ref — version-matching comes from shipping the
+copy inside the tarball, so for a package that is NOT installed the ref is a plugin option
+(`ref`, default `main`).
+
+## Provider facts these rules encode
+
+**Anthropic** ([prompt-caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching.md)) —
+render order is `tools` → `system` → `messages`; **max 4** `cache_control` breakpoints per
+request; the minimum cacheable prefix is model-dependent and **not monotonic** across
+generations (512 tokens on the newest models, 1024 on most, 4096 on Opus 4.6/4.5 and
+Haiku 4.5); a write costs ~1.25× at the 5-minute TTL and ~2× at `ttl: '1h'`, so the long
+TTL only pays from the third read; changing `system` invalidates system + messages but not
+`tools`; each breakpoint looks back at most 20 content blocks.
+
+**OpenAI** ([prompt-caching](https://developers.openai.com/api/docs/guides/prompt-caching)) —
+caching is automatic from 1024 tokens in 128-token increments, with no markers to place.
+Requests are routed by a hash of roughly the first 256 tokens, and `prompt_cache_key` is
+mixed into that hash, so requests sharing a key land on the same backend and can actually
+hit each other's entries. The `openai` plugin sets it from the config alias (one value per
+role); the `compatible` plugin deliberately does not, because aggregators running with
+`provider.require_parameters` can drop every serving provider over an unknown field.
+
+## Related
+
+- [[llm]] — the runtime and the provider-plugin seam
+- [[llm-common]] — `SkillDefinition`, `PromptPolicy`, `PromptBlock`, `LlmFileProvider`
+- [[agent-skills]] — `@owlmeans/agent-skills/llm`, the package-skills plugin

package/build/consts.d.ts

@@ -1,9 +1,11 @@
 import { ExecutionEffort } from '@owlmeans/llm-common';
-import type { ModelConfigPatch } from '@owlmeans/llm-common';
+import type { CacheTtl, ModelConfigPatch } from '@owlmeans/llm-common';
 /** Context-service alias for the {@link LlmService} (model factory / registry). */
 export declare const LLM_SERVICE = "owlmeans-llm-service";
 /** Context-service alias for the {@link ExecutionService}. */
 export declare const EXECUTION_SERVICE = "owlmeans-llm-execution-service";
+/** Context-service alias for the {@link PromptService} (skill registry + composition). */
+export declare const PROMPT_SERVICE = "owlmeans-llm-prompt-service";
 /** Default number of attempts a single model call makes before giving up. */
 export declare const DEFAULT_MODEL_RETRIES = 8;
 /**
@@ -13,7 +15,13 @@ export declare const DEFAULT_MODEL_RETRIES = 8;
  * against a provider that accepts the request and then never streams anything (observed
  * with throughput-sorted OpenRouter routing), which would otherwise block forever —
  * `maxRetries` never helps there because the request never errors, it just hangs.
- * Overridable per model via `ModelConfig.streamTimeout`.
+ * Overridable per model via `ModelConfig.streamTimeout`, or for every model at once via
+ * `LlmServiceOptions.streamTimeout` where the application composes its context.
+ *
+ * Three minutes, not longer: the timer resets on every token, so a legitimately long
+ * generation is never at risk — this only bounds SILENCE. The cost of a high value is
+ * paid entirely by hung calls, and a hang that takes five minutes to notice is a hang
+ * that can stall an agent run for half an hour once retries multiply it.
  */
 export declare const MODEL_STREAM_TIMEOUT_MS: number;
 /**
@@ -30,8 +38,33 @@ export declare const FALLBACK_AFTER_ATTEMPTS = 3;
  * issue a 400 "max_tokens exceeds the model's per-request limit".
  */
 export declare const DEFAULT_MAX_OUTPUT_CAP: number;
-/** Provider hard limit on prompt-cache breakpoints (Anthropic). */
+/** Provider hard limit on prompt-cache breakpoints per REQUEST (Anthropic). */
 export declare const MAX_CACHE_BREAKPOINTS = 4;
+/**
+ * Share of {@link MAX_CACHE_BREAKPOINTS} the composed system prompt may spend.
+ *
+ * Two is all it can use: the only STABLE boundaries are the end of role+skills and the end
+ * of the packages block. The trailing context block is volatile and deliberately never
+ * marked, so the remaining two breakpoints always stay available to the message prefix.
+ */
+export declare const MAX_SYSTEM_BREAKPOINTS = 2;
+/** Cache lifetime used when neither the call nor the service asks for another. */
+export declare const DEFAULT_CACHE_TTL: CacheTtl;
+/**
+ * Smallest prefix worth marking as cacheable, in tokens. Providers silently refuse to
+ * create an entry below their own threshold (1024 tokens on most Claude models, 512 on
+ * the newest, 4096 on a few older ones — it is NOT monotonic across generations), so a
+ * marker on a short prefix costs nothing but wastes a breakpoint and produces a
+ * "caching enabled" log for an entry that was never written. Override per model with
+ * `ModelConfig.cacheMinTokens`.
+ */
+export declare const MIN_CACHEABLE_TOKENS = 1024;
+/**
+ * Characters per token used to size a prefix against {@link MIN_CACHEABLE_TOKENS}. A rough
+ * average for English prose and TypeScript; only ever used to decide whether marking is
+ * worth a breakpoint, never for billing or budgeting.
+ */
+export declare const CHARS_PER_TOKEN = 4;
 /**
  * Appended to the prompt of `invoke`/`request` when no message already mentions JSON.
  * Some providers refuse or ignore JSON modes unless the word appears in the prompt;

package/build/consts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAE5D,mFAAmF;AACnF,eAAO,MAAM,WAAW,yBAAyB,CAAA;AAEjD,8DAA8D;AAC9D,eAAO,MAAM,iBAAiB,mCAAmC,CAAA;AAEjE,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,QAAgB,CAAA;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,QAAY,CAAA;AAE/C,mEAAmE;AACnE,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAGkD,CAAA;AAE/E;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,cAAc,CAAA;AAE7C,uFAAuF;AACvF,eAAO,MAAM,iBAAiB,YAAY,CAAA;AAE1C,8DAA8D;AAC9D,eAAO,MAAM,cAAc,2BAA2B,CAAA;AAEtD;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,eAAe,EAAE,gBAAgB,CAKlE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,EAErC,CAAA"}
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAEtE,mFAAmF;AACnF,eAAO,MAAM,WAAW,yBAAyB,CAAA;AAEjD,8DAA8D;AAC9D,eAAO,MAAM,iBAAiB,mCAAmC,CAAA;AAEjE,0FAA0F;AAC1F,eAAO,MAAM,cAAc,gCAAgC,CAAA;AAE3D,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,QAAgB,CAAA;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,QAAY,CAAA;AAE/C,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,IAAI,CAAA;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAA;AAEvC,kFAAkF;AAClF,eAAO,MAAM,iBAAiB,EAAE,QAAe,CAAA;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAExC;;;;GAIG;AACH,eAAO,MAAM,eAAe,IAAI,CAAA;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAGkD,CAAA;AAE/E;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,cAAc,CAAA;AAE7C,uFAAuF;AACvF,eAAO,MAAM,iBAAiB,YAAY,CAAA;AAE1C,8DAA8D;AAC9D,eAAO,MAAM,cAAc,2BAA2B,CAAA;AAEtD;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,eAAe,EAAE,gBAAgB,CAKlE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,EAErC,CAAA"}

package/build/consts.js

@@ -3,6 +3,8 @@ import { ExecutionEffort } from '@owlmeans/llm-common';
 export const LLM_SERVICE = 'owlmeans-llm-service';
 /** Context-service alias for the {@link ExecutionService}. */
 export const EXECUTION_SERVICE = 'owlmeans-llm-execution-service';
+/** Context-service alias for the {@link PromptService} (skill registry + composition). */
+export const PROMPT_SERVICE = 'owlmeans-llm-prompt-service';
 /** Default number of attempts a single model call makes before giving up. */
 export const DEFAULT_MODEL_RETRIES = 8;
 /**
@@ -12,9 +14,15 @@ export const DEFAULT_MODEL_RETRIES = 8;
  * against a provider that accepts the request and then never streams anything (observed
  * with throughput-sorted OpenRouter routing), which would otherwise block forever —
  * `maxRetries` never helps there because the request never errors, it just hangs.
- * Overridable per model via `ModelConfig.streamTimeout`.
+ * Overridable per model via `ModelConfig.streamTimeout`, or for every model at once via
+ * `LlmServiceOptions.streamTimeout` where the application composes its context.
+ *
+ * Three minutes, not longer: the timer resets on every token, so a legitimately long
+ * generation is never at risk — this only bounds SILENCE. The cost of a high value is
+ * paid entirely by hung calls, and a hang that takes five minutes to notice is a hang
+ * that can stall an agent run for half an hour once retries multiply it.
  */
-export const MODEL_STREAM_TIMEOUT_MS = 5 * 60 * 1000;
+export const MODEL_STREAM_TIMEOUT_MS = 3 * 60 * 1000;
 /**
  * Number of failed attempts after which the retry escalator switches from a role's
  * cheap primary model to its configured `fallback` (stronger) model. With
@@ -29,8 +37,33 @@ export const FALLBACK_AFTER_ATTEMPTS = 3;
  * issue a 400 "max_tokens exceeds the model's per-request limit".
  */
 export const DEFAULT_MAX_OUTPUT_CAP = 3 * 64000;
-/** Provider hard limit on prompt-cache breakpoints (Anthropic). */
+/** Provider hard limit on prompt-cache breakpoints per REQUEST (Anthropic). */
 export const MAX_CACHE_BREAKPOINTS = 4;
+/**
+ * Share of {@link MAX_CACHE_BREAKPOINTS} the composed system prompt may spend.
+ *
+ * Two is all it can use: the only STABLE boundaries are the end of role+skills and the end
+ * of the packages block. The trailing context block is volatile and deliberately never
+ * marked, so the remaining two breakpoints always stay available to the message prefix.
+ */
+export const MAX_SYSTEM_BREAKPOINTS = 2;
+/** Cache lifetime used when neither the call nor the service asks for another. */
+export const DEFAULT_CACHE_TTL = '5m';
+/**
+ * Smallest prefix worth marking as cacheable, in tokens. Providers silently refuse to
+ * create an entry below their own threshold (1024 tokens on most Claude models, 512 on
+ * the newest, 4096 on a few older ones — it is NOT monotonic across generations), so a
+ * marker on a short prefix costs nothing but wastes a breakpoint and produces a
+ * "caching enabled" log for an entry that was never written. Override per model with
+ * `ModelConfig.cacheMinTokens`.
+ */
+export const MIN_CACHEABLE_TOKENS = 1024;
+/**
+ * Characters per token used to size a prefix against {@link MIN_CACHEABLE_TOKENS}. A rough
+ * average for English prose and TypeScript; only ever used to decide whether marking is
+ * worth a breakpoint, never for billing or budgeting.
+ */
+export const CHARS_PER_TOKEN = 4;
 /**
  * Appended to the prompt of `invoke`/`request` when no message already mentions JSON.
  * Some providers refuse or ignore JSON modes unless the word appears in the prompt;
@@ -71,6 +104,6 @@ export const EFFORT_TABLE = {
  * without excluding it every `derive`/`escalate`/`withPurpose` would nest another copy.
  */
 export const COLLABORATOR_KEYS = [
-    'state', 'models', 'model', 'temperatureFactory', 'outputErrors',
+    'state', 'models', 'model', 'temperatureFactory', 'outputErrors', 'files', 'prompts',
 ];
 //# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -1 +1 @@
-{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAGtD,mFAAmF;AACnF,MAAM,CAAC,MAAM,WAAW,GAAG,sBAAsB,CAAA;AAEjD,8DAA8D;AAC9D,MAAM,CAAC,MAAM,iBAAiB,GAAG,gCAAgC,CAAA;AAEjE,6EAA6E;AAC7E,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAA;AAEtC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAA;AAEpD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAA;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,GAAG,KAAK,CAAA;AAE/C,mEAAmE;AACnE,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAA;AAEtC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,6DAA6D;MACzF,gHAAgH;MAChH,iGAAiG;MACjG,2EAA2E,CAAA;AAE/E;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAA;AAE7C,uFAAuF;AACvF,MAAM,CAAC,MAAM,iBAAiB,GAAG,SAAS,CAAA;AAE1C,8DAA8D;AAC9D,MAAM,CAAC,MAAM,cAAc,GAAG,eAAe,CAAC,QAAQ,CAAA;AAEtD;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAA8C;IACrE,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE;IAClD,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,EAAE;IAC9B,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE;IACjE,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE;CACjE,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAa;IACzC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,oBAAoB,EAAE,cAAc;CACjE,CAAA"}
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAGtD,mFAAmF;AACnF,MAAM,CAAC,MAAM,WAAW,GAAG,sBAAsB,CAAA;AAEjD,8DAA8D;AAC9D,MAAM,CAAC,MAAM,iBAAiB,GAAG,gCAAgC,CAAA;AAEjE,0FAA0F;AAC1F,MAAM,CAAC,MAAM,cAAc,GAAG,6BAA6B,CAAA;AAE3D,6EAA6E;AAC7E,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAA;AAEtC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAA;AAEpD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAA;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,GAAG,KAAK,CAAA;AAE/C,+EAA+E;AAC/E,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAA;AAEtC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAA;AAEvC,kFAAkF;AAClF,MAAM,CAAC,MAAM,iBAAiB,GAAa,IAAI,CAAA;AAE/C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAA;AAExC;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAA;AAEhC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,6DAA6D;MACzF,gHAAgH;MAChH,iGAAiG;MACjG,2EAA2E,CAAA;AAE/E;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAA;AAE7C,uFAAuF;AACvF,MAAM,CAAC,MAAM,iBAAiB,GAAG,SAAS,CAAA;AAE1C,8DAA8D;AAC9D,MAAM,CAAC,MAAM,cAAc,GAAG,eAAe,CAAC,QAAQ,CAAA;AAEtD;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAA8C;IACrE,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE;IAClD,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,EAAE;IAC9B,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE;IACjE,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE;CACjE,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAa;IACzC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,OAAO,EAAE,SAAS;CACrF,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/execution/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAKlE,OAAO,KAAK,EACkB,gBAAgB,EAAE,uBAAuB,EAAE,cAAc,EACrD,oBAAoB,EACrD,MAAM,YAAY,CAAA;AAKnB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,cAAc,GAAG,cAAc,EAC3E,SAAS,uBAAuB,EAChC,MAAM,MAAM,gBAAgB,CAAC,CAAC,CAAC,KAC9B,gBAAgB,CAAC,CAAC,CA6HpB,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,cAAc,GAAG,cAAc,EAC5E,QAAO,MAA0B,EACjC,UAAS,uBAA4B,KACpC,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,EAE3F,KAAK,CAAC,EACN,QAAO,MAA0B,EACjC,UAAS,uBAA4B,KACpC,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAQ5B,CAAA"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/execution/service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAKlE,OAAO,KAAK,EACkB,gBAAgB,EAAE,uBAAuB,EAAE,cAAc,EACrD,oBAAoB,EACrD,MAAM,YAAY,CAAA;AAMnB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,cAAc,GAAG,cAAc,EAC3E,SAAS,uBAAuB,EAChC,MAAM,MAAM,gBAAgB,CAAC,CAAC,CAAC,KAC9B,gBAAgB,CAAC,CAAC,CAkIpB,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,cAAc,GAAG,cAAc,EAC5E,QAAO,MAA0B,EACjC,UAAS,uBAA4B,KACpC,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,EAE3F,KAAK,CAAC,EACN,QAAO,MAA0B,EACjC,UAAS,uBAA4B,KACpC,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAQ5B,CAAA"}