arcane-os 0.64.0 → 0.66.0

package/docs/reference/local-ai.md

@@ -1,7 +1,7 @@
 # Local AI through Core
 
-Core owns native llama.cpp and Ollama processes, ONNX worker sessions and
-selected local image generation. The browser retains its own
+Core owns native llama.cpp and Ollama processes, ONNX worker sessions,
+selected local image generation and retained Whisper transcription. The browser retains its own
 Wllama and ONNX implementations, and can also use an explicitly connected Core
 when that system service is available. Runtime installation, model loading and
 inference are separate operations.
@@ -43,7 +43,7 @@ preserved when its version cannot be established.
 
 Both public application/package schemas accept `stable-diffusion.cpp` as a
 string or runtime-record ID. Its record additionally accepts `backend`
-(`auto`, `cpu` or `metal`) and `models`, an array of `sd14`, `flux2-klein-4b` or
+(`auto`, `cpu` or `metal`) and `models`, an array of `sd14`, `flux2-klein-4b`, `sdxl-base-1.0` or
 complete model descriptors. Omitted image version selects `master-929-3f8527a`; omitted backend
 selects `auto`; omitted models leaves model selection empty. Windows/Linux
 distribution defaults use CPU; the selected universal Mac archive supports
@@ -55,6 +55,37 @@ The [FLUX.2 Klein 4B guide](local-image-flux.md) describes its diffusion model,
 VAE and Qwen text-conditioning resources, four-step defaults and `txt2img`
 operation. Each model retains its own supported operation set.
 
+The [SDXL Base 1.0 guide](local-image-sdxl.md) describes its complete checkpoint,
+embedded text encoders and original VAE, 1024-by-1024 default canvas and
+`txt2img` operation. Selecting a family retains the shared native context,
+progress, cancellation and complete PNG result contract.
+
+For native transcription, select a `whisper.cpp` runtime record with a `models`
+array and an explicit `modelId` when selecting more than one model. For example,
+`{id: 'whisper.cpp', backend: 'auto', models: ['whisper-small'], modelId: 'whisper-small'}`
+selects the multilingual small model. Installation prepares its native
+libraries, persistent SDK helper, FFmpeg decoder and selected model files;
+loading and transcription remain separate operations. Development and native
+assembly compose it through the shared speech service without changing the
+browser's selected STT route. See [native Whisper](local-whisper.md) for the
+complete configuration, platform, media and shutdown contracts.
+
+Adding `encoder: 'openvino-npu'` selects the optional Intel NPU audio encoder
+with a separately selected CUDA or CPU decoder. The Windows x64 precompiled
+runtime uses paired GGML/XML/BIN model resources and the computer's installed
+compatible Intel NPU driver. See the [Intel NPU Whisper guide](../guides/native-whisper-openvino.md)
+for preparation, observed initialization, cancellation/reload and custom
+runtime production. Omitting the encoder retains ordinary Whisper preparation.
+
+The selected model stays loaded across recordings. An eligible native
+accelerated failure may drain that helper and retry the same complete recording
+once on the prepared CPU backend. That accepted request retains its actual
+request identity while `recovering` is unloaded and busy; new inference remains
+blocked until actual readiness. Cancellation, unload, close, replacement and
+transport loss retain their owning cancellation behavior. A terminal engine
+failure reaches the original request as its actual error rather than a
+fabricated readiness success. See [native speech reconciliation](native-speech.md).
+
 `llamaCpp` accepts `url`, `model`, `modelsDirectory`, and an `args` string array.
 `model` selects a single GGUF file; `modelsDirectory` selects llama.cpp router
 mode. Paths resolve from the application root. Ollama accepts `url`,
@@ -193,6 +224,52 @@ Those methods use Ollama's native API. Streaming uses the existing
 such as selection, settings and brain creation remain with their existing
 owners; they are separate from this runtime service.
 
+### Selected Ollama model readiness
+
+The built-in `OLLAMA` LLM provider loads its selected model through Ollama's
+empty `generate` request and separately confirms that selected model in
+`running()` (`/api/ps`). A model catalog entry, a connected bridge, and a
+successful preload response alone do not establish a ready model. Ollama's
+empty preload response echoes the requested name; resident snapshots use its
+shortest tagged name. Comparison applies Ollama's default `registry.ollama.ai`
+host, `library` namespace and `latest` tag, so `moon-raccoon` and
+`registry.ollama.ai/library/moon-raccoon:latest` identify the same resident
+model. This comparison leaves outbound model names and payloads unchanged.
+The provider preserves Ollama's configured/default retention duration.
+
+Core refreshes and emits `localai.state` after its Ollama generation, chat,
+embedding and catalog-changing operations, including a failed or cancelled
+operation while the service remains available. Explicit `running()` inspection
+also publishes the actual resident-model snapshot. An SDK-owned process exit
+publishes its unavailable state through the existing process owner.
+Successes and failures belong to their observation order and engine lifetime;
+an older observation cannot replace newer state or a recovered engine's state.
+The complete current failure remains available through the owning state surface.
+
+The LLM provider subscribes before loading and retains that observation while
+loaded. An observed selected-model unload, replacement, unavailable service or
+service error revokes readiness and cancels the active request through the shared
+AI runtime. Each inference checks current residency before dispatch and again
+before accepting its terminal result. These `running({signal})` calls carry the
+owning request's cancellation through Core to `/api/ps`. Streaming chunks still
+arrive immediately through their existing path. Explicit provider unloading sends Ollama's
+`keep_alive: 0` release request; another client can independently reload a model.
+
+Ollama's documented public API exposes resident snapshots, not an ongoing
+resident-model event subscription. Core adds no timer polling. External changes
+between observations, including idle eviction or another client's model load,
+remain unobserved until a subsequent owned operation or explicit inspection.
+There is also an upstream race between a snapshot and the following request;
+these checks do not claim an atomic reservation of the daemon's model state.
+Applications consume the shared provider lifecycle rather than treating a stale
+idle snapshot as proof for their next inference. `Ollama.readiness()` remains a
+service-connectivity result and does not establish selected-model readiness.
+
+Upstream references: [resident models](https://docs.ollama.com/api/ps),
+[model-name defaults and comparison](https://github.com/ollama/ollama/blob/main/types/model/name.go),
+[preload response and resident-name handling](https://github.com/ollama/ollama/blob/main/server/routes.go),
+[preload and retention](https://docs.ollama.com/faq#how-can-i-preload-a-model-into-ollama-to-get-faster-response-times).
+
 ## Browser llama.cpp provider
 
 ```js

package/docs/reference/local-image-generation.md

@@ -47,6 +47,11 @@ four-step defaults and the advertised `txt2img` operation. Keep each model's
 supported operations distinct: selecting FLUX does not enable reference-image
 editing or imply the same input path as SD1.4 img2img.
 
+`sdxl-base-1.0` selects the complete SDXL Base checkpoint, including its text
+encoders and original VAE. Its [family guide](local-image-sdxl.md) covers the
+single model resource, 1024-by-1024 default canvas and native sampling defaults.
+It advertises `txt2img`; selecting it does not enable an editing operation.
+
 The first published distribution path selects CPU on Windows and Linux.
 On macOS, `auto` selects the same upstream universal runtime's built-in Metal
 backend, with CPU fallback; explicit `cpu` remains available. A caller-supplied

package/docs/reference/local-image-sdxl.md

@@ -38,7 +38,7 @@ selection alone does not establish actual execution on any device.
 ## Prepare the checkpoint and generate an image
 
 The single `model` resource is the official
-[sd_xl_base_1.0.safetensors checkpoint](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/462165984030d82259a11f4367a4eed129e94a7b/sd_xl_base_1.0.safetensors)
+[`sd_xl_base_1.0.safetensors` checkpoint](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/462165984030d82259a11f4367a4eed129e94a7b/sd_xl_base_1.0.safetensors)
 at revision `462165984030d82259a11f4367a4eed129e94a7b`. It includes the text
 encoders, denoiser and original VAE. Standalone base generation uses this one
 resource; a refiner, separate VAE, LoRA or Python converter is unnecessary for

package/docs/reference/local-whisper.md

@@ -7,6 +7,12 @@ the model or recording files are reused. The browser's existing
 `AI.fetchSTT(audioFile, signal)` and Core `speech.transcribe` routes retain the
 application's selected model and cancellation signal.
 
+For the optional Intel NPU encoder, add `encoder: "openvino-npu"` to the
+runtime record. The [Intel NPU guide](../guides/native-whisper-openvino.md)
+covers the Windows x64 precompiled distribution, paired GGML/XML/BIN model
+resources, independent CUDA/CPU decoding and joined cancellation. Omitting
+`encoder` preserves the ordinary runtime and model selection below.
+
 ## Select the runtime and model
 
 An application's `arcane-app.json` selects native speech alongside its other
@@ -130,7 +136,7 @@ prepared descriptor returned by `ensureLocalAIRuntimes`; alternatively,
 
 | Member | Contract |
 | --- | --- |
-| `current()` | Returns `providerId`, selected `modelId`, lifecycle `state`, `loaded`, `busy`, correlated `requestId` or null, requested/observed backend, evidence and any error. |
+| `current()` | Returns `providerId`, selected `modelId`, lifecycle `state`, `loaded`, `busy`, correlated `requestId` or null, `requestedBackend`, `observedBackend`, `backendEvidence`, `requestedEncoder`, `observedEncoder`, `encoderEvidence` and any error. Encoder initialization evidence is separate from decoder evidence. |
 | `subscribe(listener, {replay = true, signal} = {})` | Immediately replays current state by default and returns an unsubscribe function. |
 | `load({modelId, signal} = {})` | Prepares the runtime if necessary, then waits for actual native model readiness. With no selected model it remains unloaded. |
 | `transcribe(request, {signal, onProgress, requestId} = {})` | Consumes the complete `audioBase64` recording. Optional `language` defaults to native automatic detection; `translate: true` selects Whisper's translation operation. `model` must match the loaded model. Optional `requestId` carries the caller's existing operation identity through lifecycle snapshots as separate control information; it does not alter the recording or request payload. |

package/docs/reference/mcp-stdio.md

@@ -0,0 +1,263 @@
+# MCP STDIO server
+
+Expose application-owned tools and static resources to an MCP client with
+`arcane-os/mcp/stdio`. This optional Node entrypoint owns one JSON-RPC session,
+UTF-8 newline framing, discovery, request correlation, cooperative cancellation,
+and graceful drain. The application owns its launch command, tool definitions,
+resource contents, business behavior, and underlying service lifetime.
+
+Availability: Node on Windows, Linux, and macOS, using the package's supported
+Node version. Android requires a host that supplies the same Node stream and
+process environment. Importing the entrypoint starts no process or listener.
+It is separate from the native Core `arcane/1` transport and its Content-Length
+frames; the two stream formats are not interchangeable.
+
+## createMcpStdioServer
+
+```javascript
+import {createMcpStdioServer} from 'arcane-os/mcp/stdio';
+
+const menu = {
+    content: 'Moon soup\nExtra tentacles available.',
+    message: {chef: 'Octopus', open: true}
+};
+
+const server = createMcpStdioServer(
+    {
+        serverInfo: {name: 'moon-pantry', version: '1.0.0'},
+        instructions: 'Ask moon.menu for the complete lunar dinner menu.',
+        tools: [
+            {
+                name: 'moon.menu',
+                description: 'Read the complete lunar dinner menu.',
+                inputSchema: {type: 'object'},
+                annotations: {readOnlyHint: true},
+                handler: readMenu
+            }
+        ],
+        resources: [
+            {
+                uri: 'pantry://menu',
+                name: 'menu',
+                title: 'Lunar dinner menu',
+                mimeType: 'application/json',
+                handler: readMenuResource
+            }
+        ]
+    }
+);
+
+function readMenu(args, {signal}) {
+    signal.throwIfAborted();
+    return {
+        content: [{type: 'text', text: JSON.stringify(menu)}],
+        structuredContent: menu
+    };
+}
+
+function readMenuResource({uri}, {signal}) {
+    signal.throwIfAborted();
+    return {
+        contents: [{uri, mimeType: 'application/json', text: JSON.stringify(menu)}]
+    };
+}
+
+server.start();
+try {
+    await server.closed;
+} catch {
+    // The adapter already sent its diagnostic to stderr.
+    process.exitCode = 1;
+}
+```
+
+Save this in the consuming application and configure the MCP client's subprocess
+command as `node` with that application's script path. Client configuration
+file formats and process launch policy remain client-owned. Change `menu` to
+change the complete result; no model, repository, or native host is needed for
+this example.
+
+The application explicitly converts its domain record into an MCP result.
+The SDK does not guess from `content`, `message`, or other domain field names.
+The serialized text in this example is an application-selected representation;
+the SDK never adds it automatically.
+
+### Parameters
+
+`createMcpStdioServer(options)` returns a server object synchronously.
+
+| Option | Contract |
+| --- | --- |
+| `serverInfo` | Required MCP implementation object with `name` and `version` strings. Optional MCP implementation fields are passed through. |
+| `instructions` | Optional complete instruction string returned by initialization. |
+| `tools` | Optional static array; each entry is a complete MCP tool descriptor plus `handler(args, context)`. Defaults to `[]`. Tool names identify handlers exactly and must be unique. |
+| `resources` | Optional static array; each entry is a complete MCP resource descriptor plus `handler(params, context)`. Defaults to `[]`. Each resource requires `uri` and `name`; URIs identify handlers exactly and must be unique. |
+| `onDiagnostic` | Optional error observer. Omit it for complete error text on the selected stderr stream. It may return a promise, which participates in drain. Observer failures are reported to stderr and retained by `closed`. |
+
+The factory captures catalog entries at construction. Discovery preserves
+descriptor fields, including authored schemas, descriptions, annotations,
+icons, and metadata; only the local `handler` function is omitted. No tool
+arguments, descriptions, schemas, resources, or result content are injected,
+trimmed, rewritten, or shortened. Supply JSON-serializable protocol values.
+
+The SDK checks the request envelope and required result container. It does not
+provide a general JSON Schema evaluator. The application supplies a valid
+`inputSchema` object, owns the handler's input semantics, and ensures any
+declared `outputSchema` matches its structured result. This adapter does not
+implement task-augmented execution; descriptors must describe ordinary tool
+execution.
+
+### Handler inputs and results
+
+Tool handlers receive `params.arguments` unchanged. Omitted arguments become
+an empty object as the protocol's no-argument case. Resource handlers receive
+the complete `resources/read` params object, including its exact `uri` and
+any metadata. A handler may return its result directly or return a promise.
+
+Each handler receives a context with:
+
+- `signal`: its own request's `AbortSignal`;
+- `requestId`: the original string or integer ID, including numeric zero;
+- `method`: `tools/call` or `resources/read`;
+- `params`: the complete request params object;
+- `clientInfo` and `clientCapabilities`: the client's initialization objects.
+
+A tool handler returns an explicit MCP `CallToolResult`, including a `content`
+array and optional `structuredContent`, `isError`, `_meta`, or other protocol
+fields. All supplied content blocks and JSON fields pass through. Resource
+handlers return an explicit `ReadResourceResult` with a `contents` array;
+complete text or already encoded binary resource contents pass through.
+The application creates these protocol result objects deliberately. A plain
+domain object with `content: 'some text'` is not a `CallToolResult` and produces
+an internal protocol error rather than being silently converted.
+
+For a domain failure, return a complete `CallToolResult` with `isError: true`.
+An ordinary exception thrown by a tool handler becomes an `isError: true`
+text result containing the exception's complete message, and the complete
+exception is also reported through diagnostics. Throw `McpProtocolError` for
+an explicit JSON-RPC failure. Other resource or adapter exceptions produce
+`-32603` and a diagnostic; malformed result containers and non-serializable
+results also produce `-32603`.
+Custom fields on an ordinary thrown error remain in diagnostics unless the
+application explicitly maps its known outcome to `structuredContent` in an
+`isError: true` tool result.
+
+## start
+
+`server.start({input, output, error})` attaches to caller-owned Node streams and
+returns the same server. Defaults are `process.stdin`, `process.stdout`, and
+`process.stderr`. Start each server exactly once with an open readable input and
+open writable output/diagnostic streams. Output and diagnostics must be separate
+streams. Byte-mode input preserves split UTF-8 sequences; a stream already
+decoded into strings remains responsible for its own decoding.
+
+Messages are processed as their newline arrives, without waiting for EOF. A
+final complete JSON record is also accepted when EOF arrives without its final
+newline. LF and CRLF transport endings are accepted. JSON escaping preserves
+embedded line breaks in the decoded payload. Malformed JSON receives `-32700`;
+its complete original line is included in diagnostics. Invalid UTF-8 fails at
+the decoder and closes the transport with the complete affected input chunks
+and pending decoded text in its diagnostic error.
+
+Requests execute independently, including overlapping calls to one tool.
+Only complete output writes are ordered, waiting for each Node write callback
+before sending the next record. An error, close, or finish event during a pending
+output or diagnostic write settles that write as failed even when its callback
+never arrives; a later callback cannot settle it again. The application decides
+whether its own data access requires narrower serialization. The adapter adds
+no process-wide queue.
+
+Only JSON-RPC messages are written to `output`. Application handlers and their
+dependencies must also reserve stdout for protocol traffic; use stderr or the
+application's diagnostic owner for logs. The adapter does not replace global
+console functions.
+
+## cancel
+
+`server.cancel(requestId, reason)` requests cooperative cancellation and returns
+`true` only when an active cancellable handler was signalled. String and numeric
+IDs remain distinct. Unknown, completed, already cancelled, and initialization
+requests return `false`. The same behavior handles client
+`notifications/cancelled` messages. Late results from cancelled work have no
+protocol response, as described by the
+[MCP cancellation contract](https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/cancellation).
+
+The handler must pass its signal to its actual I/O or computation and release
+owned resources. Signalling does not prove external work stopped. The adapter
+retains the handler promise until it really settles; a handler that ignores
+cancellation can keep drain and close pending.
+
+## drain
+
+`await server.drain()` waits for accepted handlers, diagnostic observers, and
+output write callbacks to settle. It does not stop input or abort requests, so
+newly accepted work can extend the wait. Use `close()` when input must first
+stop. Tool and request errors are delivered as protocol outcomes; transport and
+diagnostic delivery failures are retained by `closed`.
+
+## close
+
+`await server.close({cancelPending: false})` stops reading, pauses the input,
+drains accepted work and writes, detaches the adapter's stream listeners, and
+settles `closed`. It is idempotent. Normal input EOF follows this same graceful
+path. Explicit `cancelPending: true` aborts pending work instead; repeated close
+may request cancellation while an earlier graceful close is draining.
+
+Stream failures request cancellation, report diagnostics, and reject `closed`
+after owned work settles. An input closed without EOF is a transport failure.
+The adapter does not end or destroy caller streams, terminate the process,
+install process signal handlers, start an application host, or close
+application services. The launcher owns those actions after the adapter drains.
+
+## closed
+
+`server.closed` is a promise for actual session cleanup. It resolves after a
+normal close or EOF and rejects with an `AggregateError` when transport or
+diagnostic delivery failed. Observe it even when the initiating caller continues
+other work. Request failures alone do not close the session.
+
+## `MCP_PROTOCOL_VERSION`
+
+`MCP_PROTOCOL_VERSION` is exactly `'2025-11-25'`. Initialization always returns
+that supported version. A client proposing another version must accept this
+profile or disconnect. This is the initialize/initialized STDIO profile;
+support for later discovery-based profiles is not implied. See the normative
+[lifecycle](https://modelcontextprotocol.io/specification/2025-11-25/basic/lifecycle)
+and [STDIO transport](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports).
+
+Supported requests are `initialize`, `ping`, `tools/list`, `tools/call`,
+`resources/list`, `resources/read`, and `resources/templates/list` (an empty
+template catalog). Tools and resources capabilities are advertised when their
+catalogs are nonempty. Lists return their complete catalogs without pagination;
+supplying a cursor receives `-32602`. Send `notifications/initialized` after
+the initialization response before ordinary operations.
+
+There are no prompts, subscriptions, list-change events, MCP logging requests,
+server-to-client requests, sampling, elicitation, task augmentation, HTTP
+transport, or automatic client configuration. Unknown methods return `-32601`;
+notifications never receive responses. JSON-RPC batches are not part of this
+profile. IDs must be strings or integers and are unique for the session.
+
+The result shapes follow the official
+[tool](https://modelcontextprotocol.io/specification/2025-11-25/server/tools)
+and [resource](https://modelcontextprotocol.io/specification/2025-11-25/server/resources)
+contracts. This narrow adapter does not claim every optional MCP capability.
+
+## McpProtocolError
+
+`new McpProtocolError(code, message, data)` represents an explicit protocol
+failure. `code` is a JSON-RPC integer, `message` is its complete string, and
+optional `data` is JSON-serializable protocol detail. It extends `Error` and
+exposes `name`, `code`, `message`, and optional `data`.
+
+The adapter uses `-32700` for malformed JSON, `-32600` for invalid requests,
+`-32601` for unknown methods, `-32602` for malformed params or unknown tools,
+`-32603` for internal failures, and `-32002` for a missing resource. Its
+`-32000` lifecycle error requests initialization before ordinary operations.
+
+## Evidence boundary
+
+`test/mcp-stdio-server.test.mjs` contains focused in-memory stream fixtures for
+these contracts. Authored fixtures and source review do not establish an
+executed client integration or platform run. Run local tests only under the
+applicable explicit testing or selected-output authority.

package/docs/reference/native-speech.md

@@ -26,6 +26,12 @@ selection, supported formats, and native process ownership remain with the
 selected engine and its host composition. Browser-only operation remains
 independent of this native service.
 
+The SDK's [retained Whisper engine](local-whisper.md) supplies native STT.
+Its optional [Intel NPU encoder](../guides/native-whisper-openvino.md) uses the
+same service, readiness events, complete request/result contract and cancellation
+path. The host selects that encoder and its paired model resources; the browser
+continues calling `speech.transcribe` without loading native libraries itself.
+
 ## Startup and status
 
 `start(context)` subscribes to each configured engine and starts their loads

package/docs/reference/runtime-components.md

@@ -1742,6 +1742,14 @@ owner, and the voice control retains its state-specific labels and retry action.
 Desktop speech and the dedicated `voice-transcription.html` component retain their
 existing behavior.
 
+An already accepted file transcription retains its exact owned runtime
+operation through the same provider/model's unloaded, busy `recovering` state
+or correlated pending error. This preserves the actual RPC result or failure;
+it does not enable another recording. Unload, close, provider/model replacement,
+transport loss and caller cancellation still invalidate owned work. Native Web
+Speech microphone capture keeps its independent readiness and final/interim
+cancellation lifetime. See [native speech recovery](native-speech.md).
+
 On desktop, the Hold to talk control remains disabled unless sticky STT state
 is `ready`, the role is not busy, and microphone capture is available. For an explicitly
 selected STT route, a separate keyboard-operable control presents Start
@@ -2115,7 +2123,16 @@ Unknown provider/runtime diagnostics remain complete in the developer console
 and error events, while controls use generic visible outcomes unless the Error
 owner explicitly marks nonblank copy with `userSafe:true`.
 
-For the default manual mode, if sticky readiness is lost during microphone acquisition, capture, or the STT
+An already accepted file transcription can continue through the exact same
+provider/model/runtime operation's unloaded, busy recovery or pending-error
+state. This uses the real runtime operation ID rather than the component's local
+counter; another request supplies no continuation authority. New recording and
+transcription remain readiness-gated, and actual unload, close, replacement,
+transport loss or cancellation still ends the owned request. The same shared
+rule applies to an active continuous file-transcription job. Native Web Speech
+capture retains its separate readiness, stop/final-drain and interim ownership.
+
+Outside that exact continuing request, if sticky readiness is lost during microphone acquisition, capture, or the STT
 request, the component invalidates the session, aborts the owned request signal,
 releases media, discards late completion, and emits
 `speech-transcription-cancelled`. Its source-local reason is

package/docs/reference/runtime-modules.md

@@ -3227,9 +3227,17 @@ Validates and canonicalizes the syntax of Ollama model identifiers without grant
 
 ### Public surface
 
-`normalizeOllamaModelIdentifier()`, `isOllamaModelIdentifier()`.
+`normalizeOllamaModelIdentifier()`, `isOllamaModelIdentifier()`,
+`sameOllamaModelIdentifier(left, right)`.
 
-Exact exports: `isOllamaModelIdentifier`, `normalizeOllamaModelIdentifier`.
+Exact exports: `isOllamaModelIdentifier`, `normalizeOllamaModelIdentifier`,
+`sameOllamaModelIdentifier`.
+
+The comparison helper applies Ollama's default registry (`registry.ollama.ai`),
+namespace (`library`) and tag (`latest`) with case-insensitive name comparison.
+It compares a selected name with resident-model names without rewriting either
+string or any outbound payload; different explicit hosts, namespaces or tags
+remain distinct. The existing identifier-validation functions are unchanged.
 
 ### Availability and normalization