@orkestrel/scaffold 0.0.103 → 0.0.104

package/dist/host/guides/mcp.md

@@ -34,8 +34,11 @@ boundary that wraps it with `JSON.parse` / `JSON.stringify` plus the parse
 the `id` it could not read. The client mirrors it: `connect` negotiates the modern revision, `tools()`
 exposes the remote tools as local `ToolInterface`s, and `call` runs one — a
 remote failure throws locally, so an agent's `ToolManager` isolates it exactly
-like a local throw. A remote JSON-RPC error rejects with `MCPError`, preserving
-its numeric `code` and optional `error.data` as `context`.
+like a local throw. A remote tool result with `isError: true` throws `MCPToolError`
+(an `Error` subclass with `code` `'TOOL'`, recognized by `isMCPToolError`), so a
+caller separates a tool refusal from a transport failure. A remote JSON-RPC error
+rejects with `MCPError`, preserving its numeric `code` and optional `error.data`
+as `context`.
 
 **The wire lives one layer out.** [`src/server`](../src/server) carries the
 Node transports and [`src/browser`](../src/browser) the browser face.
@@ -2246,6 +2249,7 @@ Passing a legacy revision to
 | `MCPClient`                | class | Connects to a remote MCP server over any injected `MCPMessageTransportInterface`, negotiates the modern revision, and exposes the server's tools as local `ToolInterface`s an agent can run.                                                                                                                                                                                       |
 | `MCPTaskClient`            | class | Issues the `tasks/*` methods over one correlated-request door — the client half of the stable Tasks extension, exposed as an `MCPClientInterface`'s `tasks`.                                                                                                                                                                                                                       |
 | `HTTPClientTransport`      | class | Drives a remote Streamable-HTTP MCP server over `fetch` — a client `MCPMessageTransportInterface` for the Model Context Protocol, the egress mirror of the server's `createMCPRoutes`.                                                                                                                                                                                             |
+| `MCPToolError`             | class | Distinguishes a completed remote tool call that the peer itself reported as failed.                                                                                                                                                                                                                                                                                                |
 | `MCPError`                 | class | Preserves a Model Context Protocol error's machine-readable numeric code and optional structured context.                                                                                                                                                                                                                                                                          |
 
 ### Constants
@@ -2379,6 +2383,7 @@ A `Shape` cell holds the constant's declared type.
 | `isModernRequest`                  | function | Determines whether a JSON-RPC invocation uses the modern per-request MCP wire shape.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `isMCPModernVersion`               | function | Determines whether a value is a modern protocol revision accepted by a bare server.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `isMCPLegacyVersion`               | function | Determines whether a value is a revision accepted by the optional legacy decorator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `isMCPToolError`                   | function | Determines whether an unknown value is an `MCPToolError`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `isMCPError`                       | function | Determines whether an unknown value is an `MCPError`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `parseJSONRPCMessage`              | function | Narrows an already-parsed value to a `JSONRPCMessage`, or `undefined` when it is not one.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `parseRequestContext`              | function | Parses the reserved modern request metadata into an `MCPRequestContext`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
@@ -4502,7 +4507,9 @@ import {
 	isJSONRPCMessage,
 	isJSONRPCResponse,
 	isMCPError,
+	isMCPToolError,
 	MCPError,
+	MCPToolError,
 } from '@orkestrel/mcp'
 import { createToolManager } from '@orkestrel/tool'
 
@@ -4519,6 +4526,11 @@ const remote = new MCPError('Method not found', -32601, { method: 'missing' })
 isMCPError(remote) // true
 remote.code // -32601
 remote.context // { method: 'missing' }
+
+const refusal = new MCPToolError('tool exploded')
+isMCPToolError(refusal) // true
+isMCPError(refusal) // false
+refusal.code // 'TOOL'
 ```
 
 ### Route a request by era and build a modern result

package/dist/host/guides/ollama.md

@@ -5,7 +5,7 @@
 
 The package supplies a chat provider wire on the `/api/chat` path and a raw judge wire for Mica on the `/api/generate` path. The `OllamaProvider` class extends the `AgentProvider` engine for chat generation and streaming. The `OllamaJudge` class extends the `AgentJudge` engine for calibrated candidate probabilities. The shared engines own deadlines, transport, headers, and result assembly; see [Agent](agent.md) for their contracts.
 
-The design is deliberately spare — an external boundary kept honest. Every `unknown` wire value is narrowed through the `@orkestrel/contract` guards (`isRecord`, `isString`, `isNumber`) rather than a type assertion, and a missing or malformed field degrades to a sensible default (empty content, no usage, `{}` arguments) rather than a throw. Every provider call streams: the request always carries `stream: true`, and `generate` drains the same NDJSON path `stream` exposes, so neither call can report content the other would not. The wire `think` flag is configurable through `OllamaOptions.think` (default `false`) and overrideable per call through `ProviderStreamOptions.think`; with `think: true` the daemon returns reasoning on the separate `message.thinking` channel, streamed live as `thinking` deltas. Either way the base's splitter separates any `<think>` span the daemon inlines anyway, so the assembled `content` is clean and the reasoning surfaces as `ProviderResult.thinking`, never in the conversation. A per-call `ProviderStreamOptions.schema` (a JSON schema object, from `@orkestrel/agent`) forwards verbatim as the wire's structured-output `format` field, and is omitted from the request when no schema is supplied. Token usage reuses the `TokenUsage` shape rather than minting its own.
+The design is deliberately spare — an external boundary kept honest. Every `unknown` wire value is narrowed through the `@orkestrel/contract` guards (`isRecord`, `isString`, `isNumber`) rather than a type assertion, and a missing or malformed field degrades to a sensible default (empty content, no usage, `{}` arguments) rather than a throw. Every provider call streams: the request always carries `stream: true`, and `generate` drains the same NDJSON path `stream` exposes, so neither call can report content the other would not. The wire `think` flag is configurable through `OllamaOptions.think` (default `false`) and overrideable per call through `ProviderStreamOptions.think`; with `think: true` the daemon returns reasoning on the separate `message.thinking` channel, streamed live as `thinking` deltas. Either way the base's splitter separates any `<think>` span the daemon inlines anyway, so the assembled `content` is clean and the reasoning surfaces as `ProviderResult.thinking`. The agent records that reasoning on the assistant message. The provider's `replay` policy filters stored reasoning at the provider input boundary; the Ollama request mapper omits that reasoning from the wire. A per-call `ProviderStreamOptions.schema` (a JSON schema object, from `@orkestrel/agent`) forwards verbatim as the wire's structured-output `format` field, and is omitted from the request when no schema is supplied. `OllamaOptions.truncate` and `OllamaOptions.shift` are opt-in context controls: each is sent as a top-level wire key only when set, so omission delegates to the daemon default and leaves the request body unchanged, and `false` requests refusal instead of truncation or shifting. A fixture test proves the encoding and makes no claim about daemon support. Token usage reuses the `TokenUsage` shape rather than minting its own.
 
 The dependency is strictly one-way: this surface imports the base and the contract types from `@orkestrel/agent` and reaches errors through that base, the parser factory from `@orkestrel/ndjson`, tool-call shapes from `@orkestrel/tool`, the usage shape from `@orkestrel/budget`, and the guards from `@orkestrel/contract` — those packages never import from here. The published face is core, so `src/core` reaches no `node:*` module and no DOM global and the same build serves a server process and a browser page. It is tested live against `qwen3.5:2b-q4_K_M` in a dedicated `service` test project that requires the daemon and warms the model first, with no `skipIf`, while the `src:core` project stays hermetic on canned-transport and recording-proxy assertions that pass with the daemon down. Source: [`src/core`](../src/core). Surfaced through the `@orkestrel/ollama` barrel, aliased `@src/core` inside this repo.
 
@@ -29,6 +29,7 @@ result.usage // { prompt, completion, total } when the wire reported counts —
 `generate` resolves the assembled `ProviderResult` (content + any tool calls + any usage). For live output, `stream` is the same call streamed: it yields `ProviderDelta`s (`content` for answer text, `thinking` for live reasoning) and returns the assembled result when the stream completes. Drive the generator and read its terminal `value`:
 
 ```ts
+import type { ProviderDelta } from '@orkestrel/agent'
 import { createAbort } from '@orkestrel/abort'
 import { isProviderAbortError } from '@orkestrel/agent'
 import { createOllama } from '@orkestrel/ollama'
@@ -36,24 +37,31 @@ import { createOllama } from '@orkestrel/ollama'
 const provider = createOllama({ model: 'qwen3.5:2b-q4_K_M' })
 const abort = createAbort()
 const messages = [{ id: '1', role: 'user', content: 'Say hello.' }] as const
-const answer: string[] = []
-const reasoning: string[] = []
+const deltas: ProviderDelta[] = []
 
 try {
-	const generator = provider.stream(messages, abort.signal)
-	let step = await generator.next()
-	while (!step.done) {
-		if (step.value.channel === 'content') answer.push(step.value.text)
-		if (step.value.channel === 'thinking') reasoning.push(step.value.text)
-		step = await generator.next()
+	const stream = provider.stream(messages, abort.signal)
+	for (;;) {
+		const step = await stream.next()
+		if (step.done) {
+			const result = step.value // the assembled ProviderResult
+			const answer = deltas
+				.filter((delta) => delta.channel === 'content')
+				.map((delta) => delta.text)
+			const reasoning = deltas
+				.filter((delta) => delta.channel === 'thinking')
+				.map((delta) => delta.text)
+			console.log(result.content) // the answer — the settled content is the authoritative one
+			console.log(answer.join('')) // what arrived on the content channel, which a reclassified <think> span leaves longer
+			console.log(reasoning.join('')) // what arrived on the thinking channel
+			break
+		}
+		deltas.push(step.value)
 	}
-	const result = step.value // the assembled ProviderResult
-	result.content // the answer — the settled content is the authoritative one
-	answer.join('') // what arrived on the content channel, which a reclassified <think> span leaves longer
 } catch (error) {
 	if (isProviderAbortError(error)) {
 		const recovered = error.partial.content // everything that streamed before the cancel
-		answer.push(recovered)
+		console.log(recovered)
 	} else throw error
 }
 ```
@@ -66,27 +74,32 @@ Pass `tools` (a non-empty `ToolDefinition[]` from `@orkestrel/tool`) to advertis
 
 A `Shape` cell holds an interface's data members as bare names in braces, `?` marking an optional member and `plus` introducing its call-signature members, and a type alias's own type literal with a union's arms escaped as `\|`. An extended interface's name comes before `plus`, with the members it adds after. A function row's `Shape` cell holds its signature, and a guard row's the type it narrows to. A class row's `Shape` cell holds the interface it implements, or its constructor signature where it implements none. A `Shape` cell holds the constant's declared type.
 
-| API                  | Kind      | Shape                                                                       | Summary                                                                                                                                                                     |
-| -------------------- | --------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `createOllama`       | function  | `(options: OllamaOptions) => ProviderInterface`                             | Creates a local Ollama inference provider — a `ProviderInterface` over the daemon's `POST /api/chat`, assembling `generate` from the same NDJSON engine as `stream`.        |
-| `OllamaProvider`     | class     | `AgentProviderInterface`                                                    | Implements the Ollama `/api/chat` wire over the shared `AgentProvider` engine.                                                                                              |
-| `OllamaOptions`      | interface | `ProviderOptions plus { model, url?, keepAlive?, options?, think? }`        | Represents the configuration `createOllama` accepts for the local Ollama backend.                                                                                           |
-| `WireChatRequest`    | interface | `{ model, messages, stream, keep_alive, think, options?, tools?, format? }` | Represents the exact `POST /api/chat` request body `OllamaProvider` sends — the internal typed wire contract.                                                               |
-| `DEFAULT_OLLAMA_URL` | const     | `string`                                                                    | Names the local Ollama daemon base URL, `'http://localhost:11434'`, assumed when `OllamaOptions.url` is omitted.                                                            |
-| `DEFAULT_KEEP_ALIVE` | const     | `string`                                                                    | Names how long the model stays resident after a call — `'5m'` when `OllamaOptions.keepAlive` is omitted, Ollama's own `keep_alive` default, expressed as a duration string. |
-| `OLLAMA_CHAT_PATH`   | const     | `string`                                                                    | Names the Ollama chat endpoint appended to the configured base URL.                                                                                                         |
-| `mapMessages`        | function  | `(messages: readonly Message[]) => WireChatRequest['messages']`             | Maps conversation turns onto the `/api/chat` wire's minimal message shape.                                                                                                  |
-| `extractContent`     | function  | `(record: Readonly<Record<string, unknown>>) => string`                     | Extracts the assistant text of one wire record.                                                                                                                             |
-| `extractThinking`    | function  | `(record: Readonly<Record<string, unknown>>) => string`                     | Extracts the daemon-side reasoning of one wire record.                                                                                                                      |
-| `extractUsage`       | function  | `(record: Readonly<Record<string, unknown>>) => TokenUsage \| undefined`    | Extracts the token usage of one wire record.                                                                                                                                |
-| `extractTools`       | function  | `(record: Readonly<Record<string, unknown>>) => readonly ToolCall[]`        | Extracts the tool calls of one wire record's `message.tool_calls`.                                                                                                          |
-| `extractArguments`   | function  | `(value: unknown) => Readonly<Record<string, unknown>>`                     | Extracts a wire `arguments` value as a record.                                                                                                                              |
-
-`OllamaOptions` extends `ProviderOptions`, so a caller also passes the base's own keys through it: `timeout` (the per-call deadline), `fetch` (the transport), `headers` (the per-request header hook), and `format` (the context-framing default). [`agent.md`](agent.md) states each one.
+| API                  | Kind      | Shape                                                                                          | Summary                                                                                                                                                                     |
+| -------------------- | --------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `createOllama`       | function  | `(options: OllamaOptions) => ProviderInterface`                                                | Creates a local Ollama inference provider — a `ProviderInterface` over the daemon's `POST /api/chat`, assembling `generate` from the same NDJSON engine as `stream`.        |
+| `OllamaProvider`     | class     | `AgentProviderInterface`                                                                       | Implements the Ollama `/api/chat` wire over the shared `AgentProvider` engine.                                                                                              |
+| `OllamaOptions`      | interface | `ProviderOptions plus { model, url?, keepAlive?, options?, think?, truncate?, shift? }`        | Represents the configuration `createOllama` accepts for the local Ollama backend.                                                                                           |
+| `WireChatRequest`    | interface | `{ model, messages, stream, keep_alive, think, options?, tools?, format?, truncate?, shift? }` | Represents the exact `POST /api/chat` request body `OllamaProvider` sends — the internal typed wire contract.                                                               |
+| `OllamaDurations`    | interface | `{ total, load, prompt, decode }`                                                              | Carries the daemon durations of one terminal record in raw nanoseconds.                                                                                                     |
+| `OllamaCounts`       | interface | `{ prompt, decode, cached }`                                                                   | Carries the token counts of one terminal record.                                                                                                                            |
+| `OllamaTiming`       | interface | `{ durations, counts, invalid }`                                                               | Carries the timing observation of one terminal record.                                                                                                                      |
+| `DEFAULT_OLLAMA_URL` | const     | `string`                                                                                       | Names the local Ollama daemon base URL, `'http://localhost:11434'`, assumed when `OllamaOptions.url` is omitted.                                                            |
+| `DEFAULT_KEEP_ALIVE` | const     | `string`                                                                                       | Names how long the model stays resident after a call — `'5m'` when `OllamaOptions.keepAlive` is omitted, Ollama's own `keep_alive` default, expressed as a duration string. |
+| `OLLAMA_CHAT_PATH`   | const     | `string`                                                                                       | Names the Ollama chat endpoint appended to the configured base URL.                                                                                                         |
+| `mapMessages`        | function  | `(messages: readonly Message[]) => WireChatRequest['messages']`                                | Maps conversation turns onto the `/api/chat` wire's minimal message shape.                                                                                                  |
+| `extractContent`     | function  | `(record: Readonly<Record<string, unknown>>) => string`                                        | Extracts the assistant text of one wire record.                                                                                                                             |
+| `extractThinking`    | function  | `(record: Readonly<Record<string, unknown>>) => string`                                        | Extracts the daemon-side reasoning of one wire record.                                                                                                                      |
+| `extractUsage`       | function  | `(record: Readonly<Record<string, unknown>>) => TokenUsage \| undefined`                       | Extracts the token usage of one wire record.                                                                                                                                |
+| `extractTruncated`   | function  | `(record: Readonly<Record<string, unknown>>) => true \| undefined`                             | Extracts whether one terminal wire record reports that the model ended its answer at its own token limit.                                                                   |
+| `extractTiming`      | function  | `(record: Readonly<Record<string, unknown>>) => OllamaTiming \| undefined`                     | Extracts the daemon timing of one terminal wire record.                                                                                                                     |
+| `extractTools`       | function  | `(record: Readonly<Record<string, unknown>>) => readonly ToolCall[]`                           | Extracts the tool calls of one wire record's `message.tool_calls`.                                                                                                          |
+| `extractArguments`   | function  | `(value: unknown) => Readonly<Record<string, unknown>>`                                        | Extracts a wire `arguments` value as a record.                                                                                                                              |
+
+`OllamaOptions` extends `ProviderOptions`, so a caller also passes the base's own keys through it: `timeout` (the per-call deadline), `fetch` (the transport), `headers` (the per-request header hook), and `replay` (the stored-thinking policy). [`agent.md`](agent.md) states each one.
 
 The wire leaves — `mapMessages` and the `extract*` narrowing set — are the pure request projection and response extractions `OllamaProvider` composes. They are exported and unit-tested on their own so the package's highest-risk code, the boundary narrowing of every wire `unknown` through the `@orkestrel/contract` guards, is provable without a daemon. Everything they do not do lives in `@orkestrel/agent`: the deadline, the transport seam, the streaming spine, the splitter, and the assembly of a `ProviderResult`.
 
-`OllamaProvider` declares `name` (`'ollama'`) and inherits the rest of its data members from the base: `id` is the stable per-instance trace label, and `format` is the context-framing default `OllamaOptions.format` supplies (see [Context framing](#context-framing)). Its wire seams are documented under [Methods](#methods), and the `generate` / `stream` boundary it inherits under `AgentProviderInterface` in [`agent.md`](agent.md). `AgentProvider` / `AgentProviderInterface` / `ProviderInterface` / `ProviderOptions` / `ProviderRequest` / `ProviderIncrement` / `ProviderParserInterface` / `ProviderResult` / `ProviderDelta` / `ProviderStreamOptions` / `ProviderError` / `isProviderError` / `ProviderAbortError` / `isProviderAbortError` / `Message` / `ContextFormat` are owned by `@orkestrel/agent`; `ToolDefinition` / `ToolCall` by `@orkestrel/tool`; the `TokenUsage` shape by `@orkestrel/budget`; `createNDJSONParser` by `@orkestrel/ndjson`. All are reused here, never redefined. The agent package also owns the `JudgeInterface` interface, `JudgeRequest` type, `JudgeResult` interface, `JudgeAnswer` type, `Refusal` interface, `AgentJudge` class, `JudgeError` class, `JudgeAbortError` class, and `computeReading` function.
+`OllamaProvider` declares `name` (`'ollama'`) and inherits the rest of its data members from the base: `id` is the stable per-instance trace label, and `replay` selects which stored assistant reasoning reaches the provider input (default `'none'`). The Ollama request mapper omits stored reasoning from the wire regardless of that policy. Its wire seams are documented under [Methods](#methods), and the `generate` / `stream` boundary it inherits under `AgentProviderInterface` in [`agent.md`](agent.md). `AgentProvider` / `AgentProviderInterface` / `ProviderInterface` / `ProviderOptions` / `ProviderRequest` / `ProviderIncrement` / `ProviderParserInterface` / `ProviderResult` / `ProviderDelta` / `ProviderStreamOptions` / `ProviderError` / `isProviderError` / `ProviderAbortError` / `isProviderAbortError` / `Message` / `ContextSectionFormat` / `InstructionInterface` are owned by `@orkestrel/agent`; `ToolDefinition` / `ToolCall` by `@orkestrel/tool`; the `TokenUsage` shape by `@orkestrel/budget`; `createNDJSONParser` by `@orkestrel/ndjson`. All are reused here, never redefined. The agent package also owns the `JudgeInterface` interface, `JudgeRequest` type, `JudgeResult` interface, `JudgeAnswer` type, `Refusal` interface, `AgentJudge` class, `JudgeError` class, `JudgeAbortError` class, and `computeReading` function.
 
 The raw judge exports the following declarations.
 
@@ -117,49 +130,50 @@ The wire seams `OllamaProvider` declares — exactly the members of `AgentProvid
 
 #### `OllamaProvider`
 
-The `frame` method opens the call's framing state and the `finish` method drains it; the `body` method writes the request and the `read` method reads one record back.
+The `frame` method opens the call's framing state and the `finish` method drains it; the `encode` method writes the request and the `read` method reads one record back.
 
-| Method   | Returns                                            | Summary                                                                        |
-| -------- | -------------------------------------------------- | ------------------------------------------------------------------------------ |
-| `frame`  | `ProviderParserInterface`                          | Creates fresh NDJSON framing state for a call.                                 |
-| `body`   | `WireChatRequest`                                  | Projects conversation turns and per-call options onto the Ollama request body. |
-| `read`   | `ProviderIncrement`                                | Extracts a record's content, reasoning, tools, and completed usage report.     |
-| `finish` | `ReadonlyArray<Readonly<Record<string, unknown>>>` | Recovers a final NDJSON record that arrived without its line terminator.       |
+| Method   | Returns                                            | Summary                                                                                |
+| -------- | -------------------------------------------------- | -------------------------------------------------------------------------------------- |
+| `frame`  | `ProviderParserInterface`                          | Creates fresh NDJSON framing state for a call.                                         |
+| `encode` | `WireChatRequest`                                  | Projects conversation turns and per-call options onto the Ollama request body.         |
+| `read`   | `ProviderIncrement`                                | Extracts a record's content, reasoning, tools, completed usage report, and truncation. |
+| `finish` | `ReadonlyArray<Readonly<Record<string, unknown>>>` | Recovers a final NDJSON record that arrived without its line terminator.               |
 
 #### `OllamaJudge`
 
 The engine calls these seams for each question. Call the inherited `ask` method to validate the full request, issue the calls, and merge their answers and usage.
 
-| Method | Returns               | Summary                                                                     |
-| ------ | --------------------- | --------------------------------------------------------------------------- |
-| `body` | `WireGenerateRequest` | Projects a single question onto Mica's raw generate request.                |
-| `read` | `JudgeResult`         | Decodes a completed raw response into an answer or a missing-label refusal. |
+| Method   | Returns               | Summary                                                                     |
+| -------- | --------------------- | --------------------------------------------------------------------------- |
+| `encode` | `WireGenerateRequest` | Projects a single question onto Mica's raw generate request.                |
+| `read`   | `JudgeResult`         | Decodes a completed raw response into an answer or a missing-label refusal. |
 
 ## Contract
 
 These invariants hold across `src/core` ↔ `ollama.md`. The engine contract itself — `ProviderInterface`, `AgentProvider`, `ProviderResult`, `ProviderError`, `ProviderAbortError` — is in `@orkestrel/agent`, and [`agent.md`](agent.md) states it.
 
 1. **Doc ↔ source bijection.** Every `function` / `class` / `const` / `interface` / `type` row in the `## Surface` table is a real export of the `src/core` surface, and every export appears as a Surface row — exhaustive, both directions.
-2. **Imports each boundary from its owner, no cycle.** `OllamaProvider` extends `AgentProvider` and implements `AgentProviderInterface`; that base, `ProviderRequest`, `ProviderIncrement`, `ProviderParserInterface`, `ProviderInterface`, `ProviderOptions`, and `Message` come from `@orkestrel/agent`. `createNDJSONParser` comes from `@orkestrel/ndjson`, `ToolCall` from `@orkestrel/tool`, `TokenUsage` from `@orkestrel/budget`, and the guards (`isRecord` / `isString` / `isNumber` / `parseJSONAs`) from `@orkestrel/contract`. The provider errors are owned by `@orkestrel/agent` and `ToolDefinition` by `@orkestrel/tool`: `src/core` imports neither, and both reach a caller through the base — the base throws the errors this wire's failures become, and it accepts the `ToolDefinition[]` a call advertises. Each dependency is one-way and never imports from `@src/core`. No module under `src/` imports `@orkestrel/timeout` — the base arms the deadline — and the manifest declares it as a development dependency for the guide's bounding pattern, which imports it as a consumer would.
-3. **The `/api/chat` wire body.** `OllamaProvider` POSTs to `${url}${OLLAMA_CHAT_PATH}`, defaulting `url` to `DEFAULT_OLLAMA_URL` and `keep_alive` to `DEFAULT_KEEP_ALIVE`. The body carries `model`, the mapped `messages`, `stream: true` on every provider call, `keep_alive`, and `think` (the per-call `ProviderStreamOptions.think` override when present, else `OllamaOptions.think`, default `false`), adding `options` only when configured, `format` only when the call supplies a `ProviderStreamOptions.schema`, and `tools` only when a non-empty `ToolDefinition[]` is passed. Each tool maps to `{ type: 'function', function: { name } }`, with `description` and `parameters` added only when the corresponding `ToolDefinition` fields are supplied. `title` and `annotations` are **never sent**: the `/api/chat` tool function object carries no field for either. Messages map to the wire's minimal `{ role, content }` turn, with `tool_calls` added only on a turn that replays them and `images` only on a multimodal turn. A non-OK status is the base's failure, not this package's: it throws `ProviderError` with code `'HTTP'`, the response `status`, and a message bounded to an excerpt of the response body.
-4. **Configurable `think` on the wire; the base's splitter keeps the assembled content clean.** For a thinking-capable model (for example `qwen3`) the per-request `think` flag is the only wire-level reasoning control (its native renderer honours neither the qwen3 `/no_think` token nor a Modelfile `PARAMETER think false`). It is configurable through `OllamaOptions.think` (default `false` — so the general-purpose provider stays immediate for non-thinking models and tests fast) and overrideable per call through `ProviderStreamOptions.think`. Set `think: true` when the caller displays reasoning separately from the answer: the daemon then separates reasoning natively, returning it on the distinct `message.thinking` channel, which `read` reports and the engine yields as `ProviderDelta` `{ channel: 'thinking', text }` and accumulates onto `ProviderResult.thinking`. Either way the base's `split` behaviour stays armed, because a daemon may ignore `think: false` for a thinking model and render reasoning inline as `<think>…</think>` content; `OllamaProvider` passes no `split` to `super`, so the default separation applies and the assembled `content` is the splitter's clean accumulation. The reasoning never re-enters the conversation.
+2. **Imports each boundary from its owner, no cycle.** `OllamaProvider` extends `AgentProvider` and implements `AgentProviderInterface`; that base, `ProviderRequest`, `ProviderIncrement`, `ProviderParserInterface`, `ProviderInterface`, `ProviderOptions`, and `Message` come from `@orkestrel/agent`. `createNDJSONParser` comes from `@orkestrel/ndjson`, `ToolCall` from `@orkestrel/tool`, `TokenUsage` from `@orkestrel/budget`, and the guards (`isRecord` / `isString` / `isNumber` / `isNonNegativeInteger` / `parseJSONAs`) from `@orkestrel/contract`. The provider errors are owned by `@orkestrel/agent` and `ToolDefinition` by `@orkestrel/tool`: `src/core` imports neither, and both reach a caller through the base — the base throws the errors this wire's failures become, and it accepts the `ToolDefinition[]` a call advertises. Each dependency is one-way and never imports from `@src/core`. No module under `src/` imports `@orkestrel/timeout` — the base arms the deadline — and the manifest declares it as a development dependency for the guide's bounding pattern, which imports it as a consumer would.
+3. **The `/api/chat` wire body.** `OllamaProvider` POSTs to `${url}${OLLAMA_CHAT_PATH}`, defaulting `url` to `DEFAULT_OLLAMA_URL` and `keep_alive` to `DEFAULT_KEEP_ALIVE`. The body carries `model`, the mapped `messages`, `stream: true` on every provider call, `keep_alive`, and `think` (the per-call `ProviderStreamOptions.think` override when present, else `OllamaOptions.think`, default `false`), adding `options` only when configured, `format` only when the call supplies a `ProviderStreamOptions.schema`, and `tools` only when a non-empty `ToolDefinition[]` is passed. The top-level `truncate` and `shift` keys follow `tools`, each present only when its `OllamaOptions` member is set, with `false` carried verbatim and neither nested in `options`; `generate` and `stream` encode them identically. `false` requires daemon support to take effect. Each tool maps to `{ type: 'function', function: { name } }`, with `description` and `parameters` added only when the corresponding `ToolDefinition` fields are supplied. `title` and `annotations` are **never sent**: the `/api/chat` tool function object carries no field for either. Messages map to the wire's minimal `{ role, content }` turn, with `tool_calls` added only on a turn that replays them and `images` only on a multimodal turn. A non-OK status is the base's failure, not this package's: it throws `ProviderError` with code `'HTTP'`, the response `status`, and a message bounded to an excerpt of the response body.
+4. **Configurable `think` on the wire; the base's splitter keeps the assembled content clean.** For a thinking-capable model (for example `qwen3`) the per-request `think` flag is the only wire-level reasoning control (its native renderer honours neither the qwen3 `/no_think` token nor a Modelfile `PARAMETER think false`). It is configurable through `OllamaOptions.think` (default `false` — so the general-purpose provider stays immediate for non-thinking models and tests fast) and overrideable per call through `ProviderStreamOptions.think`. Set `think: true` when the caller displays reasoning separately from the answer: the daemon then separates reasoning natively, returning it on the distinct `message.thinking` channel, which `read` reports and the engine yields as `ProviderDelta` `{ channel: 'thinking', text }` and accumulates onto `ProviderResult.thinking`. Either way the base's `split` behaviour stays armed, because a daemon may ignore `think: false` for a thinking model and render reasoning inline as `<think>…</think>` content; `OllamaProvider` passes no `split` to `super`, so the default separation applies and the assembled `content` is the splitter's clean accumulation. The agent records the reasoning on the assistant message. `OllamaOptions.replay` filters its return to the provider input, defaulting to `'none'`; the Ollama request mapper omits stored reasoning from the wire.
 5. **One provider NDJSON path.** Every provider call consumes NDJSON — one JSON object per `\n`-terminated line. `frame()` returns `createNDJSONParser()`, fresh per call, so no call inherits another's half-read record, and the base pairs it with a streaming `TextDecoder` so a record split across byte reads is reassembled. At end of input the base calls `finish(parser)`, which feeds a trailing `\n` through the parser: a non-conformant proxy's final unterminated line is recovered rather than silently dropped. `OllamaProvider` passes no `strict` to `super`, so a stream that ends without a settled record still assembles its result from the deltas it carried.
 6. **`stream` yields deltas and returns the assembled result.** The engine yields each non-empty clean content delta as `{ channel: 'content', text }` and each daemon-side reasoning delta as `{ channel: 'thinking', text }`; its return value is the assembled `ProviderResult` whose `content` is the splitter's authoritative clean accumulation — the concatenation of the yielded content deltas, except across an implicit-open reclassification, where the reasoning prefix had already streamed before a bare `</think>` revealed it and the yields cannot be recalled — plus any tool calls collected across lines, the usage from the `done` line, and the separated `thinking` when the turn produced any.
-7. **Usage from the `done` line (reuses `TokenUsage`).** `read` reports `usage` only for a record whose `done` is `true` and whose `prompt_eval_count` and `eval_count` are both numbers — mapped to `{ prompt, completion, total: prompt + completion }`, the `TokenUsage` shape, imported rather than redefined. A delta line carries no counts and a `done: false` line's counts are ignored, so neither contributes usage, and `ProviderResult.usage` is absent when the turn reported none.
+7. **Usage and truncation from the `done` line (reuses `TokenUsage`).** `read` reports `usage` only for a record whose `done` is `true` and whose `prompt_eval_count` and `eval_count` are both numbers — mapped to `{ prompt, completion, total: prompt + completion }`, the `TokenUsage` shape, imported rather than redefined. A delta line carries no counts and a `done: false` line's counts are ignored, so neither contributes usage, and `ProviderResult.usage` is absent when the turn reported none. `read` projects the same record's `done_reason` through `extractTruncated`: `'length'` (the `num_predict` cap or a full context window) becomes `truncated: true` on the increment and so on `ProviderResult.truncated`, and any other reason, a missing one, or a `done_reason` on a record that is not `done` leaves `truncated` absent. The projection does not read the request's `truncate` setting, so a prompt the daemon truncates under its default returns normally and reports nothing.
 8. **Tool-call extraction with id-generation (no `as`).** `result.tools` is the model's `message.tool_calls`, each entry narrowed to `{ id, name, arguments }`: the entry and its `function` must be records and `name` a string (else the entry is dropped); `arguments` is the wire object as-is, a JSON string parsed to a record, or `{}` when neither; `id` is the wire's `id` when a string, else a freshly minted `crypto.randomUUID()`. An empty result `tools` is never surfaced — its absence means "no calls".
 9. **Boundary narrowing — all wire `unknown` through guards, never `as`.** Every value read off the wire (each NDJSON record, `message`, `content`, `thinking`, the usage counts, `tool_calls`, `arguments`) arrives as `unknown` and is narrowed through the `@orkestrel/contract` guards — never a type assertion. A missing or malformed provider field degrades to a sensible default (empty content, no usage, `{}` arguments), never a throw — the one external boundary kept honest.
 10. **The base owns everything that is not the wire.** The per-call deadline (`OllamaOptions.timeout`, `120_000`ms when omitted, folded with the caller's signal so either cancels the request and the timer is always cleared), the cancellation rule (a `stream` cancelled mid-flight throws `ProviderAbortError` carrying the partial, and the reader and parser are released in a `finally`), the transport seam (`OllamaOptions.fetch` and the per-request `OllamaOptions.headers` hook, awaited inside the deadline and raced against the combined signal), and the bounded error read all live in `AgentProvider`. `OllamaOptions` extends `ProviderOptions`, so those keys are the base's and behave identically for every provider built on it; [`agent.md`](agent.md) states each rule once.
-11. **Context-framing `format` (provider-default cascade level, expose-only).** `OllamaOptions.format` is an optional `ContextFormat` (from `@orkestrel/agent`) — the provider's context-framing default, passed to `super` and exposed as `provider.format`. It is the provider-default level of the `AgentContext` build cascade (beats the managers' built-in framing, beaten by a manager-options or per-item override; see [`agent.md`](agent.md)), read by the Agent when it assembles the prompt. Omitted ⇒ `undefined` (framing-agnostic; core's built-in framing applies unchanged). It is **never sent on the `/api/chat` wire**: it is consumed by core, absent from the request `body`, and unrelated to Ollama's structured-output `format` parameter — that one is sent in the request `body`, but only when a per-call `ProviderStreamOptions.schema` is supplied — the framing default and that wire parameter only share a word.
+11. **Context framing.** An instruction manager accepts a `ContextSectionFormat<InstructionInterface>` through `createInstructionManager({ format })`. The agent uses that manager to build the instruction text. Ollama structured output uses the separate per-call `ProviderStreamOptions.schema` value, forwarded as the wire `format` field.
 12. **Event-free.** A pure functional boundary — no Emitter, no events. Each call is a function of its arguments.
 13. **A core face that runs in a browser.** The package publishes the `.` entry alone, built from `src/core`, which imports no `node:*` module and no DOM global; the scoped core typecheck compiles it with the `ESNext` and `WebWorker` libraries and no ambient `@types`, so neither Node's globals nor the DOM's are in scope, and the base binds `globalThis.fetch` to its own receiver so a browser does not throw `Illegal invocation` on a bare transport reference. [`tests/service/page.test.ts`](../tests/service/page.test.ts) gates that claim rather than recording it: it launches the host's own Chrome or Edge through `@orkestrel/browser`, serves the built `@orkestrel/ollama` core entry and its whole `@orkestrel` import closure from an import map on a `127.0.0.1` fixture, and reads the page's requests from the browser's own request log. The page loads with no uncaught error and no console error, on the recorders a deliberate page fault then makes report; an `Agent` holding a page-defined DOM-writing `Tool` completes a tool loop against the live daemon through a same-origin `createRelay` server, where the model's recorded call reaches the page, the tool's minted receipt is read back out of the real DOM and found again as the `role: 'tool'` message of the relay request and the `/api/chat` request that follow the turn the call was dispatched in, and the run settles with `partial: false`; the page issues exactly one `POST /inference` per turn and nothing else across the whole operation window, with a deliberate `/control` request proving such a window can report one; a wrong bearer arrives as `ProviderError` with code `'HTTP'` and status `401` with no daemon request made; and `createOllama` in the page answers a prompt over `/api/chat` on the daemon's own origin after `requireDaemonOrigin` confirms the daemon permits the page's origin. Each attempt ends within its allowance plus its release share, so nothing the attempt schedules outlasts the case that holds it. The attempt's signal cancels the part of the connection the installed `BrowserOptions.signal` races — discovery, the port-free check, the launch, and `client.connect()` — and the attempt's own race is what bounds every phase after that, the target listing the connection ends with included; [`tests/service/page.test.ts`](../tests/service/page.test.ts) and the `PAGE_BOUNDS` table it spends state the mechanism. The model's choice to call a tool is retried at most 3 times, and that choice is the only reading another attempt buys: every attempt retains its observations before any page read can throw, and only a run that completed an answer without dispatching the tool spends another launch. An acquisition, read, release, or run failure ends the retry, and so does a run that deadline interrupted before it settled — an interrupted run reports no tool call for a reason another launch cannot clear, so retrying it would report the exhaustion as the model never choosing the tool. The request accounting is asserted over each retained attempt, so what the gate establishes is that the model called the tool within those attempts and that no attempt's traffic went unread. The daemon is the remaining limit — a page reaches `/api/chat` directly only where the daemon, or a proxy in front of it, answers the page's origin; otherwise relay the call through your own server ([Relaying through your own server](#relaying-through-your-own-server)).
 14. **Tested live against a real local Ollama (no `skipIf`).** The live tests run against a real Ollama daemon — no mocks, only genuine third-party calls — model `qwen3.5:2b-q4_K_M`, with `OLLAMA_HOST` / `OLLAMA_MODEL` overridable. Unlike the other surfaces, the dedicated `service` project requires the daemon: `tests/setupService.ts` throws a clear error if it is unreachable and warms the model (a `num_predict: 1` chat) before the suite, so the live tests run unconditionally (no `describe.skipIf`). The project runs serially (`fileParallelism: false`) with a 120s test/hook timeout so a cold load cannot flake it; `keep_alive` keeps the model resident across files, and `bash scripts/ollama.sh` brings the daemon and model up before the battery in CI. Assertions are structural — they hold whatever wording a small model produces — and never pin exact output. The hermetic half sits in `tests/src/core/`, and the relay round trip is proved hermetically in [`tests/src/core/integration.test.ts`](../tests/src/core/integration.test.ts) and live in [`tests/service/relay.test.ts`](../tests/service/relay.test.ts).
-15. **Doc ↔ source method bijection.** Each `## Methods` table lists the methods its class declares: `frame`, `body`, `read`, and `finish` for `OllamaProvider`; `body` and `read` for `OllamaJudge`. The inherited `generate`, `stream`, and `ask` methods are declared by the agent package's engines.
+15. **Doc ↔ source method bijection.** Each `## Methods` table lists the methods its class declares: `frame`, `encode`, `read`, and `finish` for `OllamaProvider`; `encode` and `read` for `OllamaJudge`. The inherited `generate`, `stream`, and `ask` methods are declared by the agent package's engines.
 
 16. **Render.** The raw prompt mirrors the TypeSafe adapter path of Mica's server: the `rows_from_request` function in the `typesafe_server.py` file followed by the `prompt_for` function in the `native.py` file. Structured state uses JSON with a one-space indent and JavaScript numeric spelling: JavaScript cannot distinguish 100.0 from 100 and spells an exponent as 1e-7 where Python spells 1e-07. Parity is byte-exact for string states and structured states whose numbers spell the same in both runtimes. The wire preserves the system prompt and escapes control tokens in state, instructions, option names, and descriptions with U+200B after the opening angle bracket. Noul criteria render false before true; an absent or empty side renders its key. Choice names render in brackets unless empty, positional (including Unicode decimal digits), or equal to the wire label. A null description renders the `None` text. Score levels omit names. The assistant suffix disables thinking with the `<think>\n\n</think>\n\n` text.
 17. **Readout.** The wire sends each question in its own `POST` request to the `OLLAMA_GENERATE_PATH` endpoint. Each body carries the `raw: true`, `stream: false`, `logprobs: true`, and `top_logprobs: 20` settings. The fixed `num_predict: 1` and `temperature: 1` settings override the caller's sampling settings. Calibration divides candidate logprob gaps by its finite positive temperature before a softmax over candidates alone. The `extractTopLogprobs` function reads only the `logprobs[0].top_logprobs` list and preserves token text. Malformed or duplicate entries raise a `JudgeError` error with the `PROTOCOL` code. The wire reads usage from a completed record through the `extractUsage` function and reports usage only when the `isTokenUsage` guard admits it.
 18. **Refusal.** A label outside the top list refuses that question. The `missing` collection names the caller's option, level index, or the `false` or `true` key. The wire still answers the other questions and the result keeps the spent usage. A missing label never receives an invented probability.
 19. **Limits.** A choice admits 2 to 20 options and a score 2 to 10 levels. A request outside those limits raises a `JudgeError` error with the `QUESTION` code. Structured instructions or criteria raise the same error before inference because the Mica server flattens them with Python's `str()` function. The engine validates every body before making a transport call. The `keepAlive` setting accepts a duration string or a number and defaults to the `DEFAULT_KEEP_ALIVE` value. The daemon enforces its context window. The caller selects the wire.
 20. **Identity and cancellation.** The `judge.model` property and every `JudgeResult.model` property carry a JSON tuple of the model tag, system prompt, effective calibration temperature, effective options with sorted keys, and the `MICA_RENDER_REVISION` value. The effective options include the fixed `num_predict: 1` and `temperature: 1` settings. Equal option bags yield one identity regardless of key order; a changed effective option changes it. Each call has the inherited deadline and header hook. Cancellation raises a `JudgeAbortError` error carrying the completed calls' answers, refusals, and usage.
+21. **Terminal timing.** The `extractTiming` function reads the daemon's own measurements from one parsed record and changes no request, scheduling, usage extraction, or inference count. It returns `undefined` unless the record owns `done: true`. The `OllamaDurations` members map `total_duration`, `load_duration`, `prompt_eval_duration`, and `eval_duration` to `total`, `load`, `prompt`, and `decode`; they are raw integer nanoseconds that the function keeps verbatim and never converts. The `OllamaCounts` members map `prompt_eval_count`, `eval_count`, and `prompt_eval_cached_count` to `prompt`, `decode`, and `cached`; they are tokens. A field the record does not own is unknown: its member is `undefined` and its key is absent from `invalid`, and no member is ever defaulted to zero or inferred. A field the record owns whose value is not a non-negative safe integer, including an own `undefined`, negative zero, a string, a fraction, or an integer above `Number.MAX_SAFE_INTEGER`, also reads `undefined` and its wire key enters `invalid`, in the order the wire fields are listed above. The function neither mutates the record nor throws for an ordinary hostile record, and it reads own fields only. Whether a pinned daemon sends each field is a live measurement, not a property of this function.
 
 ## Patterns
 
@@ -278,7 +292,7 @@ const response = {
 computeAnswer(question, extractTopLogprobs(response)) // { form: 'noul', noul: 0.5 }
 const judge = new OllamaJudge(options)
 const request = { state: 'Approved.', questions: { approval: question } }
-judge.body(request).prompt === prompt // true
+judge.encode(request).prompt === prompt // true
 judge.read(response, request).model === identity // true
 ```
 
@@ -335,7 +349,7 @@ The seam members are ordinary methods, so a test or a debugging session can read
 import { OllamaProvider } from '@orkestrel/ollama'
 
 const provider = new OllamaProvider({ model: 'qwen3.5:2b-q4_K_M', keepAlive: '9m' })
-const request = provider.body({
+const request = provider.encode({
 	messages: [{ id: '1', role: 'user', content: 'Say hello.' }],
 	options: { think: true },
 })
@@ -441,25 +455,33 @@ The `headers` hook is called once per request (async, so a token can be refreshe
 
 ### Context framing
 
-`OllamaOptions.format` is the provider's context-framing default — a `ContextFormat` (from `@orkestrel/agent`) declaring how this provider's models prefer the context sections framed (for example XML group wrappers vs. Markdown headers). It is the **provider-default level** of the `AgentContext` build cascade (see [`agent.md`](agent.md)): it beats the managers' built-in framing but is beaten by a manager-options or per-item override. `createOllama` accepts it directly and `OllamaProvider` hands it to the base, which exposes it as `provider.format`; the Agent reads it when it assembles the prompt. Omit it and the provider is framing-agnostic — core's built-in section framing applies unchanged.
+Configure the instruction manager's `format` option to change the prompt text the agent builds. The provider accepts the resulting messages; see [Agent](agent.md) for the manager's rendering cascade.
 
 ```ts
+import type { ContextSectionFormat, InstructionInterface } from '@orkestrel/agent'
+import { createAgent, createInstructionManager } from '@orkestrel/agent'
 import { createOllama } from '@orkestrel/ollama'
 
-const provider = createOllama({
-	model: 'qwen3.5:2b-q4_K_M',
-	format: {
-		instructions: {
-			open: '<instructions>',
-			render: (instruction) => `<instruction>${instruction.content}</instruction>`,
-			close: '</instructions>',
-		},
-	},
-})
-provider.format // the ContextFormat preceding — read by AgentContext.build()
+const format: ContextSectionFormat<InstructionInterface> = {
+	open: '<instructions>',
+	render: (instruction) => `<instruction>${instruction.content}</instruction>`,
+	close: '</instructions>',
+}
+const instructions = createInstructionManager({ format })
+instructions.add({ name: 'concise', content: 'Answer briefly.' })
+const provider = createOllama({ model: 'qwen3.5:2b-q4_K_M' })
+const agent = createAgent(provider, { instructions })
+agent.context
+	.build()
+	.some(
+		(message) =>
+			message.content.includes('<instructions>') &&
+			message.content.includes('<instruction>Answer briefly.</instruction>') &&
+			message.content.includes('</instructions>'),
+	) // true
 ```
 
-**Not the wire `format`.** This is the prompt-context framing consumed by `AgentContext.build()` — it is **expose-only** and is never sent on the `/api/chat` request. It is unrelated to Ollama's `/api/chat` `format` parameter (structured output / JSON schema): that wire field is driven by a different, per-call source — `ProviderStreamOptions.schema` (from `@orkestrel/agent`) — forwarded verbatim as `format` and omitted from the body when `schema` is undefined. The framing default and the wire parameter share a word and nothing else: the framing default is a hint the daemon never sees, and the wire parameter is a per-call constraint the provider never exposes back.
+The wire `format` field carries the JSON schema from the per-call `ProviderStreamOptions.schema` option. The provider omits that field when no schema is supplied. Instruction framing renders inside message content.
 
 ### Narrowing a failed call with `isProviderError`
 
@@ -497,8 +519,10 @@ A cancel is outside that taxonomy: the caller's signal and the deadline both thr
 - **Recover the stream's partial** — wrap a driven `stream` in `try`/`catch` and narrow with `isProviderAbortError` to keep the content that arrived before a cancel.
 - **Branch on the code and the status, not the message** — narrow a caught value with `isProviderError` and read `error.code` and `error.status` (`404` for an unpulled model) instead of parsing `error.message`.
 - **Fold usage into a budget** — `result.usage` is the `TokenUsage` shape; `consume` it per turn to enforce a token ceiling.
-- **Give a thinking model headroom** — with `think: true`, a reasoning model (for example `qwen3.5:2b` at `temperature: 0`) can spend 200+ tokens on `message.thinking` before any `content` token arrives; a tight `num_predict` cap or a tight external token budget can exhaust before content starts, yielding empty `result.content` — and `@orkestrel/agent`'s budget enforcement can abort mid-stream with `partial: true` if the cap is hit while thinking is still draining it. Size `num_predict` and the budget with thinking overhead in mind for any model run with `think: true`.
+- **Give a thinking model headroom** — with `think: true`, a reasoning model (for example `qwen3.5:2b` at `temperature: 0`) can spend 200+ tokens on `message.thinking` before any `content` token arrives; a tight `num_predict` cap ends the turn before content starts, yielding empty `result.content` with `result.truncated` set, and a tight external token budget exhausts on the usage the turn reports. Size `num_predict` and the budget with thinking overhead in mind for any model run with `think: true`.
+- **Read the model layer** — a `num_predict` cap reached sets `result.truncated`, and an agent run ending there reports `stop.layer: 'model'`. A prompt the daemon truncates under the default `truncate: true` returns normally and is not reported.
 - **Tune through `options`** — pass sampling parameters (`temperature`, `seed`, and `num_predict`) through `OllamaOptions.options`; they forward verbatim to the wire.
+- **Refuse instead of truncating** — set `OllamaOptions.truncate` or `OllamaOptions.shift` to `false` to ask the daemon to refuse an oversized prompt or a window shift. Leave them unset to keep the daemon default. The provider only forwards the key; whether a given daemon honors `false` is a live measurement.
 - **Observe at the call site** — the provider publishes no events; read `stream`'s deltas and its returned result for everything a turn produced.
 
 ## Tests
@@ -509,16 +533,16 @@ The judge proofs cover the recorded wire and the live models.
 - [`tests/src/core/helpers.test.ts`](../tests/src/core/helpers.test.ts) compares the rendered prompts byte for byte and checks calibration, candidate-only normalization, label mapping, escaping, and identity.
 - [`tests/service/judge.test.ts`](../tests/service/judge.test.ts) requires Mica and the native decision model, reads the deletion noul within 0.005 of the desk's pinned No probability 0.9884, asks the native model every form in one request, and asserts Mica's System One HTTP 400 refusal. `OLLAMA_JUDGE_MODEL`, `OLLAMA_JUDGE_TEMPERATURE`, and `OLLAMA_DECISION_MODEL` override the recorded defaults. Mica warmup admits 300000 ms because the recorded cold load took 230850 ms.
 
-The hermetic projects — `src:core`, `setup`, `guides`, `conformance`, `policy`, and `config` — run with no daemon and no network. The `service` project requires a warm local Ollama and, for the page proof, a Chromium-family browser and a built `dist`; `distribution` packs and installs the artifact.
+The hermetic projects — `src:core`, `setup`, `guides`, `conformance`, `policy`, and `config` — run with no daemon and no network. The `service` project requires a warm local Ollama and, for the page proof, a Chromium-family browser and a built `dist`; `distribution` packs and installs the artifact. The import guard reads `distribution` with the hermetic projects, because it never reaches the daemon; it leaves out `probe` and `service` alone, the two projects that may.
 
-- [`tests/guides.test.ts`](../tests/guides.test.ts) — the `## Surface` ↔ `src/core` bijection (value + type exports), the `OllamaProvider` method bijection, and the equality gate: every `Summary` cell against its declaration's description paragraph, the titled `createOllama + generate` fence against the `@example` block of that title (pinned so the titled pair cannot be retired silently), and the README pitch against this guide's tagline. It also runs the flagship fences and asserts the values their comments claim.
-- [`tests/src/core/OllamaProvider.test.ts`](../tests/src/core/OllamaProvider.test.ts) — hermetic provider request-shape, framing, transport-seam, abort, deadline, and unreachable-upstream coverage, plus the streaming fold — deltas, tool-call accumulation, done-line usage, the unterminated tail flush, and think separation — driven over a canned NDJSON transport. Its recording proxy uses a deliberately unreachable default and asserts only captured requests and local provider behavior.
-- [`tests/src/core/helpers.test.ts`](../tests/src/core/helpers.test.ts) — the wire leaves: the request projection and every response extraction, including each malformed-wire degradation.
+- [`tests/guides.test.ts`](../tests/guides.test.ts) — the `## Surface` ↔ `src/core` bijection (value + type exports), the `OllamaProvider` method bijection, and the equality gate: every `Summary` cell against its declaration's description paragraph, the titled `createOllama + generate` fence against the `@example` block of that title (pinned so the titled pair cannot be retired silently), and the README pitch against this guide's tagline. It also runs the flagship fences and asserts the values they log. It extracts each streaming fence from the README and from this guide and executes it, with its real imports and a global `fetch` the test replaces, over the turns the fence handles: this guide's over a plain, a reclassified, a cancelled, and a refused turn, and the README's, which has no `catch` arm, over the plain and the reclassified turn. It asserts the logged values, the deltas, the fence's message list, the whole body of each request, and the error the fence throws.
+- [`tests/src/core/OllamaProvider.test.ts`](../tests/src/core/OllamaProvider.test.ts) — hermetic provider request-shape (including the opt-in `truncate` and `shift` keys), framing, transport-seam, abort, deadline, and unreachable-upstream coverage, plus the streaming fold — deltas, tool-call accumulation, done-line usage, the `done_reason: 'length'` truncation and its stray-reason refusals, the unterminated tail flush, and think separation — driven over a canned NDJSON transport. Its recording proxy uses a deliberately unreachable default and asserts only captured requests and local provider behavior.
+- [`tests/src/core/helpers.test.ts`](../tests/src/core/helpers.test.ts) — the wire leaves: the request projection and every response extraction, including each malformed-wire degradation, the `done_reason` reader's `'length'`, other-reason, missing, and non-string cases, and the terminal timing reader's verbatim nanoseconds, zero, absent, malformed, and `done` cases.
 - [`tests/src/core/factories.test.ts`](../tests/src/core/factories.test.ts) — hermetic `createOllama` shape, identity, defaults, passthrough, and unreachable-upstream coverage.
-- [`tests/src/core/integration.test.ts`](../tests/src/core/integration.test.ts) — the `src/core` integration scope. A real `@orkestrel/server` + `@orkestrel/router` relay in front of this provider carries ordered content and thinking deltas, tools, and usage while keeping the browser and daemon credentials apart, refuses a wrong bearer with an empty `401` before the daemon transport is entered, crosses a browser cancel and a server deadline as an abort frame with its partial, reduces a daemon stream failure to the fixed public error frame, and replays a returned tool call. Beside those, hermetic context framing, recap, reference, cherry-pick, canonical assembly order, scope allow-lists, workspace injection, and conversation selection run through the unreachable recording proxy, with a compile-time drift gate asserting the wire request and response shapes stay compatible with the official `ollama` client's types; that gate's authoritative check is `npm run check` (root tsc), while its run under vitest is an incidental no-op (`expectTypeOf` performs no runtime assertions).
-- [`tests/setup.test.ts`](../tests/setup.test.ts) — the shared host-independent test infrastructure, over the conversation padding, the throwing and recording summarizers, the workspace seeder, and the `PAGE_TOOL` definition `tests/setup.ts` exports, and over the host-independent half of `tests/setupServer.ts`: its request-narrowing guards, its refusing and streaming transports, its tool fixtures, its scripted agent stream and agent-stream driver, and its environment readers.
-- [`tests/setupServer.test.ts`](../tests/setupServer.test.ts) — the Node-resource half of `tests/setupServer.ts`: the recording proxy and the relay server on real loopback sockets, the captured and open transports, whose fixtures answer in memory, the capture wait, the provider-stream driver, the wire tables `WEATHER_TOOL` and the insatiable tool's chunk line, and the page fixture's Node half — the request recorder the relay server and the page fixture share, the derived import map, the served document's presence guards, the contained file route, the control route, the port reservation, the membership the page bounds declare — the attempt allowance, the release share beside it, the per-call shares spent inside them, the case bound that contains the pair, and the launch count the retry spends — the ordering the live controls' own intervals hold, the attempt deadline's own expiry error, the elapsed completion a bounded attempt reports on each interleaving that can outlast it (an acquisition that never settles, one that settles inside the release share, a release that parks past that share, and a release that crossed the allowance), each of those measured against the deadlines it had to wait out plus one named scheduling allowance, so what the case proves is timer-bounded completion rather than a nominal sum, the failure each of them keeps reachable as its cause — the attempt's own failure under a composed strand, and the deadline's `TimeoutError` under a crossed release — the reading each thrown failure carries into a composed message, the decision the bounded retry's predicate makes over an inert attempt record, including the interrupted run it refuses, the release order a real fixture takes when the release after it rejects, the evaluate boundary's narrowing and the deadline it carries, and the guards that narrow what the page reports back.
-- [`tests/setupService.test.ts`](../tests/setupService.test.ts) — the hermetic half of the `service` project's setup: the environment readers, the sampling tables, the readiness contract, and each live page gate's refusal — a host with no browser, a tree with no build, and a daemon that refuses the page's origin.
+- [`tests/src/core/integration.test.ts`](../tests/src/core/integration.test.ts) — the `src/core` integration scope. A real `@orkestrel/server` + `@orkestrel/router` relay in front of this provider carries ordered content and thinking deltas, tools, and usage while keeping the browser and daemon credentials apart, refuses a wrong bearer with an empty `401` before the daemon transport is entered, crosses a browser cancel and a server deadline as an abort frame with its partial, reduces a daemon stream failure to the fixed public error frame, and replays a returned tool call. Beside those, a real agent over a canned NDJSON stream reports the model, meter, and budget layers in `result.stop`, and hermetic context framing, recap, reference, cherry-pick, canonical assembly order, scope allow-lists, workspace injection, and conversation selection run through the unreachable recording proxy, with a compile-time drift gate asserting the wire request and response shapes stay compatible with the official `ollama` client's types; that gate's authoritative check is `npm run check` (root tsc), while its run under vitest is an incidental no-op (`expectTypeOf` performs no runtime assertions).
+- [`tests/setup.test.ts`](../tests/setup.test.ts) — the shared host-independent test infrastructure, over the conversation padding, the window consumers, the throwing and recording summarizers, the workspace seeder, and the `PAGE_TOOL` definition `tests/setup.ts` exports, and over the host-independent half of `tests/setupServer.ts`: its request-narrowing guards, its refusing and streaming transports, its tool fixtures, its scripted agent stream and agent-stream driver, and its environment readers.
+- [`tests/setupServer.test.ts`](../tests/setupServer.test.ts) — the Node-resource half of `tests/setupServer.ts`: the recording proxy and the relay server on real loopback sockets, the captured and open transports, whose fixtures answer in memory, the capture wait, the provider-stream driver, the wire tables `WEATHER_TOOL` and the insatiable tool's chunk line, and the page fixture's Node half — the request recorder the relay server and the page fixture share, the derived import map, the served document's presence guards, the contained file route, the control route, the port reservation, the membership the page bounds declare — the attempt allowance, the release share beside it, the per-call shares spent inside them, the case bound that contains the pair, and the launch count the retry spends — the ordering the live controls' own intervals hold, the attempt deadline's own expiry error, the elapsed completion a bounded attempt reports on each interleaving that can outlast it (an acquisition that never settles, one that settles inside the release share, a release that parks past that share, and a release that crossed the allowance), each of those measured against the deadlines it had to wait out plus one named scheduling allowance, so what the case proves is timer-bounded completion rather than a nominal sum, the failure each of them keeps reachable as its cause — the attempt's own failure under a composed strand, and the deadline's `TimeoutError` under a crossed release — the reading each thrown failure carries into a composed message, the decision the bounded retry's predicate makes over an inert attempt record, including the interrupted run it refuses, the release order a real fixture takes when the release after it rejects, the evaluate boundary's narrowing and the deadline it carries, the guards that narrow what the page reports back, the live page proof's browser and build gates — a host with no browser and a tree with no build — the scenarios that capture the first request a provider sends through a recording proxy, each ending the call by aborting it, awaiting it, or leaving it open, the readers and runners that measure a packed package, proved against a dependency-free fixture package and a loopback registry that answers only `ping`, and the guard that keeps every hermetic project from importing `tests/setupService.ts`, which contacts the daemon when it loads: it takes the projects from `vite.config.ts`, follows every import form to a fixed point, and refuses the module as a setup file. It compares the files that references and setup paths resolve to, never their spelling, so a backslash separator, a letter case the host folds, and a query after the path cannot hide the module, while a `?raw` or `?url` import stays an asset. It refuses a `new URL(…, import.meta.url)` built at run time as it refuses a computed `import()`, apart from `vite.config.ts`, whose computed URL is inspected and listed.
+- [`tests/setupService.test.ts`](../tests/setupService.test.ts) — the hermetic half of the `service` project's setup: the environment readers, the sampling tables, the readiness contract, and the live page gate's refusal of an origin the daemon refuses.
 - [`tests/conformance.test.ts`](../tests/conformance.test.ts) — where this package's wire types drift from the official `ollama` client they are written against.
 - [`tests/distribution.test.ts`](../tests/distribution.test.ts) — the packed package installed into a throwaway consumer: the exports map, the shipped declarations, and the module objects a real runtime hands that consumer.
 - [`tests/policy.test.ts`](../tests/policy.test.ts) and [`tests/config.test.ts`](../tests/config.test.ts) — the vendored cross-cutting proofs: the path- and text-shaped repository laws, and that the root configuration resolves its aliases, projects, and outputs.
@@ -528,7 +552,7 @@ The hermetic projects — `src:core`, `setup`, `guides`, `conformance`, `policy`
 - [`tests/service/transport.test.ts`](../tests/service/transport.test.ts) — the transparent wire proxy, end-to-end. A `createRecordingProxy(OLLAMA_CONFIG.host)` — a real `@orkestrel/server` + `@orkestrel/router` HTTP server — records the inbound request, forwards it to the selected Ollama service, and streams the response back.
 - [`tests/service/page.test.ts`](../tests/service/page.test.ts) — the live page receipt, in a real Chrome or Edge that `@orkestrel/browser` launches against a `127.0.0.1` fixture serving the page, the installed `@orkestrel` module tree, this workspace's own build, a `/control` route, and the authenticated relay from one origin. It proves that the published closure evaluates in the page with the page error recorder and the console recorder quiet, that the page parks exactly the operation table this proof evaluates by name, read back out of the running browser, that an `Agent` holding a page-defined DOM-writing `Tool` completes a tool loop against the live daemon over the same-origin relay and carries the minted receipt into the next turn's `role: 'tool'` message on the relay wire and the daemon wire, that the browser log, the page's Resource Timing drain, and the fixture's own record each report a request the page deliberately made, and the page error recorder and the console recorder each report a fault the page deliberately produced, that a wrong bearer is refused before the daemon is contacted, and that `createOllama` in the page answers a prompt on the daemon's own origin. Controls beside those drive a real browser through each interleaving the attempt bound covers, and assert the elapsed time of the whole call against the allowance plus the release share every time: an allowance too short to finish reads the attempt's own expiry error back rather than an inner browser timeout; an allowance the observation outlasts leaves the session released; an acquisition that settles after the allowance is released rather than abandoned, and is never reported as stranded; and an attempt whose release crossed the allowance reports that release rather than the answer the observation had already returned. Every precondition is a hard throw naming its fix — the daemon and model from `tests/setupService.ts`, the browser from `requirePageBrowser`, the build from `requireBuild`, and the daemon's permission for the page origin from `requireDaemonOrigin` — so a host missing one fails the project rather than skipping.
 - [`tests/service/tools.test.ts`](../tests/service/tools.test.ts) and [`tests/service/authority.test.ts`](../tests/service/authority.test.ts) — live tool dispatch through the agent loop, and the authority gate's approval and denial paths.
-- [`tests/service/budget.test.ts`](../tests/service/budget.test.ts) and [`tests/service/lifecycle.test.ts`](../tests/service/lifecycle.test.ts) — live token-budget enforcement mid-stream, and the agent's status, event, and abort lifecycle.
+- [`tests/service/budget.test.ts`](../tests/service/budget.test.ts) and [`tests/service/lifecycle.test.ts`](../tests/service/lifecycle.test.ts) — live token-budget enforcement on the reported usage, the meter layer's mid-stream trip under `allowance: budget`, the daemon's `done_reason: 'length'` at a `num_predict` cap with its `result.truncated` and model-layer `stop`, and the agent's status, event, and abort lifecycle.
 - [`tests/service/schema.test.ts`](../tests/service/schema.test.ts) and [`tests/service/scopes.test.ts`](../tests/service/scopes.test.ts) — a live structured-output `schema` constraining the answer, and a live scope filtering what reaches the wire.
 - [`tests/service/compaction.test.ts`](../tests/service/compaction.test.ts) and [`tests/service/conversation.test.ts`](../tests/service/conversation.test.ts) — live recap retention with manual, automatic, and repeated compaction, and live non-fatal compaction errors and long-conversation instruction behavior, with proxy calls explicitly forwarding to `OLLAMA_CONFIG.host`.
 

package/dist/host/guides/probe.md

@@ -746,7 +746,7 @@ const claim: Claim = {
 const probe = new Probe({ workspace: process.cwd() })
 const verdict = await probe.prove(claim)
 verdict.digest // 'bdf03e5dfd6bd413ead671c7a2940fcf'
-verdict.receipt // 'probe:bdf03e5dfd6bd413ead671c7a2940fcf:type:typescript@6.0.3:oxlint@1.87.0:vitest@4.1.11:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
+verdict.receipt // 'probe:bdf03e5dfd6bd413ead671c7a2940fcf:type:typescript@6.0.3:oxlint@1.89.0:vitest@4.1.12:configs/src/tsconfig.core.json@434f59254d58cf2683d453a26bd0d837'
 await probe.destroy()
 ```