arcane-os 0.64.0 → 0.66.0

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Changelog
 
+## 0.66.0
+
+- Add `readGitIdentity` from `arcane-os/core/repositories` for separate global,
+  repository-local and effective Git configuration observations. Preserve full
+  name/email/githubUser values, empty versus unset fields, configured includes,
+  joined cancellation and complete process/observer failures.
+- Add optional construction-time `gitIdentity: {name, email, username}` to
+  repository workspaces and bare text snapshots. Explicit author fields apply
+  only to child Git configuration/environment; omitted fields retain ordinary
+  inheritance. Username is a credential hint, not authenticated-account proof.
+- Preserve complete selected text, existing clone/pull/commit/push behavior,
+  ordered workspace operations and shared snapshot acquisition. No Git config
+  file, remote, credentials, application preferences or data is rewritten.
+- Preserve original process errors when an observer failure is already included,
+  and report non-UTF-8 Git identity output with its complete raw diagnostics
+  instead of returning substituted identity text.
+- Honor an explicit browser decision `dtype` while preserving the existing
+  Laya FP16 and Julia FP32 defaults. Share the complete tensor-record preparation
+  with the separately developing native owner; this does not deliver native Laya.
+- Keep the dependency tree unchanged. Native Laya and target-bound repository
+  publication remain separate work. Retained compatible native assets continue
+  to use matching numeric-release routes; optional NPU upload follow-through
+  remains separately tracked.
+
+## 0.65.0
+
+- Add optional precompiled Windows x64 Intel NPU encoding for native Whisper
+  with `encoder: "openvino-npu"`, paired small-model resources, separate
+  encoder/decoder state, and existing GPU-first decoding with CPU recovery.
+  Preserve ordinary Whisper, complete transcripts and joined cancellation.
+- Add `createRepositoryWorkspace(...).write({files, message, signal})` for
+  complete selected text, literal-path staging/commit and ordinary push, with
+  complete diagnostics and explicit confirmed or uncertain partial outcomes.
+- Add retained native Codex App Server sessions and an explicit MCP STDIO
+  server through `arcane-os/codex/app-server` and `arcane-os/mcp/stdio`.
+  Preserve complete native payloads, origin-bound server-request replies,
+  ordered live results, cooperative cancellation and owned write settlement.
+- Add application Core composition during source development without requiring
+  local AI, `/arcane-core.js`, and replayed client installation/retirement
+  observation. Preserve the existing local-AI bootstrap, early-close cleanup
+  and ordered reentrant installation notifications.
+- Tie Ollama readiness to actual selected-model residency observations, with
+  ordinary model-name alias comparison, operation cancellation and stale
+  observation/engine ownership. Preserve original outbound model names and
+  complete payloads; no background polling or atomic residency claim.
+- Keep the npm dependency tree unchanged. Native runtime producers and
+  consumers use the documented upstream resources and compatible helper
+  assets attached to this numeric release. Git identity selection and native
+  Laya fp32 integration remain separate subsequent work.
+
 ## 0.64.0
 
 - Add retained native Whisper transcription through the existing Core speech

package/README.md

@@ -20,7 +20,7 @@ selected SDK projection or an explicit live SDK source mount. Both profiles
 share the theme, packaging, event, cancellation,
 and browser run contracts while retaining their selected application layout.
 
-This checkout defines the `0.64.0` SDK contract. Development applications declare
+This checkout defines the `0.66.0` SDK contract. Development applications declare
 `arcane-os` as `latest` and retain their lockfile. Exact SDK pins begin when Roshi
 designates a production build. Follow [Consumer updates](docs/consumer-updates.md)
 to refresh and compare the installed SDK and lockfile with the published channel;

package/browser-runtime/ai/browser-decisions.mjs

@@ -74,7 +74,8 @@ class BrowserDecisionModel {
     #error = null;
     #disposed = false;
 
-    constructor({family, model, revision = 'main', device = 'webgpu', runtime = {}} = {}) {
+    constructor({family, model, revision = 'main', device = 'webgpu',
+        dtype = family === 'laya' ? 'fp16' : 'fp32', runtime = {}} = {}) {
         if (family !== 'laya' && family !== 'julia') {
             throw new TypeError('family must be "laya" or "julia".');
         }
@@ -89,7 +90,7 @@ class BrowserDecisionModel {
             model: requiredText(model, 'model'),
             revision: requiredText(revision, 'revision'),
             device: requiredText(device, 'device'),
-            dtype: family === 'laya' ? 'fp16' : 'fp32',
+            dtype: requiredText(dtype, 'dtype'),
             runtime: {...runtime, moduleUrl: requiredText(moduleUrl, 'runtime.moduleUrl')}
         };
         this.#events = createArcaneEventSource(

package/browser-runtime/ai/decision-runtime.mjs

@@ -82,7 +82,8 @@ export function encodeDecisionRows(tokenizer, rows, family) {
     return {encoded, pad};
 }
 
-function decisionInputs(Tensor, encoded, pad) {
+/** Plain tensor records shared by browser and native ONNX execution owners. */
+export function createDecisionInputs(encoded, pad) {
     let sequenceLength = 0;
     let optionCount = 0;
     for (const row of encoded) {
@@ -108,26 +109,11 @@ function decisionInputs(Tensor, encoded, pad) {
         types[rowIndex] = BigInt(row.qtype);
     }
     return {
-        input_ids: new Tensor(
-            'int64', ids,
-            [batch, sequenceLength]
-        ),
-        attention_mask: new Tensor(
-            'int64', attention,
-            [batch, sequenceLength]
-        ),
-        marker_pos: new Tensor(
-            'int64', positions,
-            [batch, optionCount]
-        ),
-        marker_mask: new Tensor(
-            'bool', mask,
-            [batch, optionCount]
-        ),
-        qtype: new Tensor(
-            'int64', types,
-            [batch]
-        )
+        input_ids: {type: 'int64', data: ids, dims: [batch, sequenceLength]},
+        attention_mask: {type: 'int64', data: attention, dims: [batch, sequenceLength]},
+        marker_pos: {type: 'int64', data: positions, dims: [batch, optionCount]},
+        marker_mask: {type: 'bool', data: mask, dims: [batch, optionCount]},
+        qtype: {type: 'int64', data: types, dims: [batch]}
     };
 }
 
@@ -210,7 +196,8 @@ export function decodeDecisionOutputs(rows, outputs) {
 }
 
 export async function loadDecisionRuntime(configuration, report) {
-    const {family, model: repository, revision = 'main', device = 'webgpu', runtime} = configuration;
+    const {family, model: repository, revision = 'main', device = 'webgpu',
+        dtype = family === 'laya' ? 'fp16' : 'fp32', runtime} = configuration;
     report(
         {phase: 'loading-runtime'}
     );
@@ -219,7 +206,7 @@ export async function loadDecisionRuntime(configuration, report) {
         namespace.env.backends.onnx.wasm.wasmPaths = runtime.wasmPaths;
     }
     const {AutoTokenizer, AutoModel, PreTrainedModel, Tensor} = namespace;
-    const options = {revision, device, dtype: family === 'laya' ? 'fp16' : 'fp32'};
+    const options = {revision, device, dtype};
     // No progress_callback: upstream 4.3 otherwise performs file-size
     // aggregation. This owner reports actual semantic lifecycle transitions.
     report(
@@ -261,7 +248,10 @@ export async function loadDecisionRuntime(configuration, report) {
     async function evaluate(rows) {
         const {encoded, pad} = encodeDecisionRows(tokenizer, rows, family);
         if (encoded.length === 0) return {decisions: [], outputs: {}};
-        const inputs = decisionInputs(Tensor, encoded, pad);
+        const inputs = {};
+        for (const [name, record] of Object.entries(createDecisionInputs(encoded, pad))) {
+            inputs[name] = new Tensor(record.type, record.data, record.dims);
+        }
         let output;
         try {
             output = await model(inputs);

package/browser-runtime/core/client.mjs

@@ -3,9 +3,34 @@ import {CORE_PROTOCOL,CORE_READY_EVENTS,CoreError,serializeCoreError} from './co
 
 const CORE_CLIENT_KEY=Symbol.for('arcane-os.core.client');
 const CORE_CLIENT_INSTALLATION=Symbol.for('arcane-os.core.client.installation');
+const CORE_CLIENT_OBSERVATION=Symbol.for('arcane-os.core.client.observation');
+const CORE_CLIENT_INSTALLATION_EVENT='core.client.installation';
 const CORE_EVENT='core.rpc.event';
 const LONG_OPERATION_TIMEOUT=50*60*1000;
 
+function publishCoreClientInstallation(global,previousClient,reason,error=null){
+    // A classic document-created installation may precede the ESM event owner.
+    // The live installation already owns replay; retain no retired-client record.
+    const observation=global[CORE_CLIENT_OBSERVATION];
+    if(!observation?.source)return;
+    observation.notifications.push({client:getInstalledCoreClient(global),previousClient,reason,error});
+    if(observation.publishing)return;
+    observation.publishing=true;
+    let delivered=0;
+    try{
+        // A listener may change the installation. Finish notifying this
+        // transition's observers before publishing that successor transition.
+        while(delivered<observation.notifications.length){
+            const notification=observation.notifications[delivered];
+            observation.notifications[delivered++]=null;
+            observation.source.dispatch(CORE_CLIENT_INSTALLATION_EVENT,notification);
+        }
+    }finally{
+        observation.notifications.splice(0,delivered);
+        observation.publishing=false;
+    }
+}
+
 /** One RPC client. Native execution and service policy belong to the host. */
 export function createCoreClient({
     global=globalThis,
@@ -587,7 +612,7 @@ export function createCoreFacade(client){
                 return invoke('localai.isolated.question',{...request,operationId},long).finally(unsubscribe);
             }},
         ollama:{version:()=>invoke('ollama.version'),models:()=>invoke('ollama.models'),list:()=>invoke('ollama.models'),
-            running:()=>invoke('ollama.running'),show:(model,options={})=>invoke('ollama.show',{...options,model}),
+            running:function running(options={}){return invoke('ollama.running',{},options);},show:(model,options={})=>invoke('ollama.show',{...options,model}),
             generate:(request,options)=>ollamaInvoke('generate',request,options),chat:(request,options)=>ollamaInvoke('chat',request,options),
             embed:request=>invoke('ollama.embed',request??{}),
             pull:(model,options={},streamOptions)=>ollamaInvoke('pull',{...options,model},streamOptions),
@@ -644,6 +669,28 @@ export function getInstalledCoreClient(global=globalThis){
     return installation?.global===global&&installation.active?client:null;
 }
 
+/** Observe this global's exact installed client without installing a transport. */
+export function subscribeCoreClient(listener,{global=globalThis,emitCurrent=true,signal}={}){
+    if(typeof listener!=='function')throw new TypeError('The Core client installation listener must be a function.');
+    if(signal?.aborted)return function alreadyAborted(){return false;};
+    const observation=global[CORE_CLIENT_OBSERVATION]??={source:null,notifications:[],publishing:false};
+    observation.source??=arcaneEvents.createSource(observation,{
+        source:'core-client-installation',eventTypes:[CORE_CLIENT_INSTALLATION_EVENT]
+    });
+    // Source subscriptions receive the compatibility view, whose shallow detail
+    // preserves these live references; global subscriptions receive snapshots.
+    const unsubscribe=observation.source.on(
+        CORE_CLIENT_INSTALLATION_EVENT,
+        function installedClientChanged(occurrence){listener(occurrence.detail);},
+        {signal}
+    );
+    if(emitCurrent&&!signal?.aborted){
+        try{listener({client:getInstalledCoreClient(global),previousClient:null,reason:'current',error:null});}
+        catch(error){unsubscribe();throw error;}
+    }
+    return unsubscribe;
+}
+
 /** Installs the same synchronous facade used by classic native-host scripts. */
 export function installCoreClient(global=globalThis,options={}){
     if(global[CORE_CLIENT_KEY])return global[CORE_CLIENT_KEY];
@@ -666,6 +713,7 @@ export function installCoreClient(global=globalThis,options={}){
     const failTransport=client.failTransport;
     let installedTransportFailure=null;
     function releaseInstalledClient(){
+        if(!installation.active)return false;
         installation.active=false;
         if(global[CORE_CLIENT_KEY]===client)delete global[CORE_CLIENT_KEY];
         if(global.Arcane===facade){
@@ -680,21 +728,30 @@ export function installCoreClient(global=globalThis,options={}){
             if(previousFailure===undefined)delete global.__arcaneTransportFailed;
             else global.__arcaneTransportFailed=previousFailure;
         }
+        return true;
     }
     client.close=function closeInstalledClient(){
-        installation.active=false;
-        try{return close();}finally{releaseInstalledClient();}
+        const released=releaseInstalledClient();
+        try{return close();}finally{
+            if(released)publishCoreClientInstallation(global,client,'closed');
+        }
     };
     client.failTransport=function failInstalledTransport(error){
         if(installation.active)installedTransportFailure=error instanceof CoreError?error:new CoreError(error);
-        releaseInstalledClient();
-        return failTransport(installedTransportFailure??error);
+        const released=releaseInstalledClient();
+        try{return failTransport(installedTransportFailure??error);}finally{
+            if(released)publishCoreClientInstallation(global,client,'transport-failed',installedTransportFailure);
+        }
     };
     try{client.connect();}catch(error){
         if(error!==installedTransportFailure&&error.code!=='ARCANE_TRANSPORT_UNAVAILABLE'){
             if(options.onError)options.onError(error);
             else global.console?.error('Arcane Core transport initialization failed.',error);
         }
+    }finally{
+        if(getInstalledCoreClient(global)===client){
+            publishCoreClientInstallation(global,null,'installed');
+        }
     }
     return client;
 }

package/docs/guides/native-whisper-openvino.md

@@ -0,0 +1,334 @@
+# Native Whisper with an Intel NPU encoder
+
+Select `encoder: "openvino-npu"` to run Whisper's audio encoder through
+OpenVINO on the Intel NPU. The decoder retains its separate `backend`
+selection. Omitting `encoder` preserves the ordinary native Whisper path.
+
+The initial precompiled distribution and producer target Windows x64 team
+computers with Intel AI Boost and a compatible installed Intel NPU driver.
+The selected runtime uses Whisper 1.9.4 and OpenVINO 2026.3.1. Application
+preparation downloads native resources; it does not install a driver,
+compiler, Python environment, or model converter. Other platform distributions
+require their own complete compatible native resources; the Windows asset
+does not establish NPU support on Linux, macOS, or Android.
+
+## Declare the application requirement
+
+Add the runtime to the application's `arcane-app.json`, retaining its other
+descriptor fields:
+
+```json
+{
+  "native": {
+    "localAI": {
+      "runtimes": [
+        {
+          "id": "whisper.cpp",
+          "encoder": "openvino-npu",
+          "backend": "auto",
+          "models": ["whisper-small"]
+        }
+      ]
+    }
+  }
+}
+```
+
+For a package descriptor, use the equivalent `arcane-package.json` `localAI`
+field. Selecting only the runtime leaves `models` empty. A single prepared
+model becomes the selected `modelId`; with several models, supply a `modelId`
+that names one of them.
+
+The default optional asset contains its matching helper, OpenVINO runtime,
+NPU plugin and compiler libraries, and CUDA and CPU decoder libraries. An
+`auto` installation extracts that complete tree once and creates CUDA and CPU
+records referring to it.
+
+| `backend` | Decoder selection with `encoder: "openvino-npu"` |
+| --- | --- |
+| `auto` | Try CUDA first, with the prepared CPU decoder available for loading or inference recovery. |
+| `cuda` | Select the CUDA variant without Arcane's automatic CPU retry. |
+| `cpu` | Select the CPU decoder. |
+| `metal` | Unavailable in the default Windows distribution. |
+
+Both auto-selected records retain the NPU encoder. A reported
+`WHISPER_ENCODER_UNAVAILABLE` failure ends loading after the helper is drained;
+changing the decoder cannot repair the same failed encoder initialization.
+The helper requests the literal OpenVINO device `NPU` and does not replace it
+with a CPU encoder. Decoder selection is a request; inspect observed metadata
+for native initialization evidence.
+
+## Keep the model files together
+
+Under this encoder selection, the built-in `whisper-small` descriptor selects
+Intel's multilingual small [paired model archive](https://huggingface.co/Intel/whisper.cpp-openvino-models/blob/main/ggml-small-models.zip):
+
+| File | Purpose |
+| --- | --- |
+| `ggml-small.bin` | Whisper model used by the native context. |
+| `ggml-small-encoder-openvino.xml` | OpenVINO encoder description. |
+| `ggml-small-encoder-openvino.bin` | Matching OpenVINO encoder data. |
+
+Preparation extracts the three selected files from that archive. Matching
+prepared models can be reused when another model selection changes. The
+ordinary `whisper-small` selection without `encoder` continues to use its
+existing single GGML download.
+
+A custom local model supplies all three paths:
+
+```js
+const model = {
+    id: 'moon-base-small',
+    path: '/application-owned/models/ggml-small.bin',
+    encoderPath: '/application-owned/models/ggml-small-encoder-openvino.xml',
+    encoderDataPath: '/application-owned/models/ggml-small-encoder-openvino.bin'
+};
+```
+
+Use real paths on the target host. The installer copies the files together,
+preserving their filenames so the XML can locate its matching BIN. A supplied
+`path` selects this local-file route even when the descriptor also retains
+archive metadata. Keep the GGML, XML and BIN from the same selected model
+bundle.
+
+An archive descriptor names each selected member:
+
+```js
+const model = {
+    id: 'whisper-small',
+    archiveUrl: 'https://huggingface.co/Intel/whisper.cpp-openvino-models/resolve/main/ggml-small-models.zip',
+    filename: 'ggml-small.bin',
+    encoderFilename: 'ggml-small-encoder-openvino.xml',
+    encoderDataFilename: 'ggml-small-encoder-openvino.bin'
+};
+```
+
+Put the descriptor in `models`. A standalone GGML `url` does not supply the
+encoder files required by this selection.
+
+## Development, native hosts and bundles
+
+With the declarative requirement, `npm exec -- arcane dev` prepares the
+application's native speech service alongside page serving. Its runtime
+installation is under `.arcane/local-ai/runtimes`; Whisper operation files
+and the OpenVINO encoder cache belong under `.arcane/speech/whisper`.
+Preparation and model loading proceed independently of the page and other AI
+services. Transcription follows the speech role's actual readiness.
+
+A native host can prepare the same requirement explicitly:
+
+```js
+import path from 'node:path';
+import {ensureLocalAIRuntimes, bundleLocalAIRuntimes} from 'arcane-os/local-ai';
+import {createWhisperRuntime} from 'arcane-os/local-ai/whisper';
+
+const appRoot = process.cwd();
+const directory = path.join(appRoot, '.arcane', 'local-ai', 'runtimes');
+const runtimes = [{
+    id: 'whisper.cpp',
+    encoder: 'openvino-npu',
+    backend: 'auto',
+    models: ['whisper-small']
+}];
+
+const [runtime] = await ensureLocalAIRuntimes({runtimes, directory});
+const stt = createWhisperRuntime({
+    runtime,
+    temporaryDirectory: path.join(appRoot, '.arcane', 'speech', 'whisper')
+});
+
+await stt.load();
+console.log(stt.current());
+```
+
+`ensureLocalAIRuntimes` returns prepared descriptors with absolute paths.
+The host owns the engine's lifetime and calls `await stt.close()` at shutdown.
+Use `subscribe(listener, {replay: true, signal})` for current-state replay and
+later state changes. Preparation and loading accept `signal` and the
+preparation APIs and engine constructor accept `onEvent` for diagnostics.
+
+The application's existing native build path is
+`npm exec -- arcane build --target windows-x64`, with the native target declared
+in its descriptor. For an explicitly composed bundle, the same selection can
+be copied into an application-owned output:
+
+```js
+const bundle = await bundleLocalAIRuntimes({
+    runtimes,
+    directory,
+    outputRoot: path.join(appRoot, '.arcane', 'native-output'),
+    platform: 'win32',
+    architecture: 'x64'
+});
+```
+
+Use a fresh bundle destination. This returns `{runtimes, files}` with paths
+relative to the output root and places Whisper resources under
+`runtime/local-ai/whisper.cpp`. The generated native Core entry resolves the
+helper, runtime libraries, decoder and all three model paths from the relocated
+bundle. Its operation files and `encoder-cache` use the native application's
+state root. Native resources remain beside the application executable in the
+bundle; application startup uses the prepared runtime.
+
+## Connect a browser through native speech
+
+The browser accesses this capability through its connected native Core speech
+service. Browser JavaScript does not load OpenVINO DLLs or initialize the NPU.
+Development uses the existing [local AI bootstrap](../reference/local-ai.md);
+native packages compose the same speech service in their generated Core entry.
+
+With an already connected Core client:
+
+```js
+const transcript = await client.speech.transcribe({
+    audioBase64,
+    mimeType: 'audio/webm',
+    model: 'whisper-small'
+}, {signal});
+```
+
+The existing `AI.fetchSTT(audioFile, signal)` route remains available. Observe
+`speech.state` and `speech.status` through the
+[native speech contract](../reference/native-speech.md); `roles.stt` and
+`transcriptionAvailable` expose STT readiness independently of TTS.
+
+Requests retain the complete recording and existing language and translation
+options. Results retain `{text, language, duration, segments}`, with segment
+`start` and `end` in seconds. Native media decoding, transcript content and
+segment delivery follow the [Whisper contract](../reference/local-whisper.md).
+
+## Read initialization evidence and handle failures
+
+The engine's `current()` and state subscriptions separate the encoder from the
+decoder:
+
+| Field | Meaning |
+| --- | --- |
+| `requestedEncoder` | `NPU` for the selected OpenVINO NPU requirement; otherwise `null`. |
+| `observedEncoder` | `NPU` after the public OpenVINO encoder initialization call succeeds; otherwise `null`. |
+| `encoderEvidence` | `openvino-initialization` after that success; otherwise `null`. |
+| `requestedBackend` | The selected decoder variant, or the configured preference before a helper is selected. |
+| `observedBackend` | Backend observed in native initialization logs, when available. |
+| `backendEvidence` | `runtime-log` when that observation is available. |
+
+Before encoder initialization succeeds, observed encoder fields remain
+`null`. The helper emits `ready` only after both its Whisper context and
+selected encoder initialize. This proves initialization for that context;
+it does not prove that a recording has been transcribed, that every operation
+runs on the NPU or GPU, or that either device improves performance.
+
+When native encoder initialization returns a nonzero result,
+`WHISPER_ENCODER_UNAVAILABLE` includes that return code in its message. The
+failure retains the joined helper failure in
+`cause` when present, with captured process output in that failure's `details`.
+For NPU `WHISPER_INFERENCE_FAILED`, Arcane shuts down and
+joins the failed helper before returning the error: a successful shutdown
+record is available in `error.data`, including complete `stderr`; a separate
+exit failure is retained in `error.cause`. When multiple attempts fail,
+inspect the complete `AggregateError.errors` as well. `onEvent` can deliver
+diagnostics while work proceeds. Keep these complete records in developer
+diagnostics; ordinary application status can use the concise lifecycle error.
+
+With `backend: "auto"`, a recoverable accelerated inference failure can retry
+the complete decoded recording once using the CPU decoder and the same NPU
+encoder selection. The engine reports `recovering` while replacing the
+context, retains the accepted request, and accepts no concurrent transcription.
+
+OpenVINO's synchronous encoder call has no per-request cancellation seam in
+Whisper. Cancelling an active NPU inference therefore retires the owned
+helper process and waits for its exit before removing recording files. The
+model becomes unloaded. After cancellation settles, call `await stt.load()`
+with a fresh, unaborted signal before the next transcription. `unload()` also
+cancels active work and drains the helper; `close()` ends the engine's lifetime.
+Cancellation before native inference need not unload an already ready model;
+follow the resulting authoritative state.
+
+## Supply a complete custom runtime
+
+For an existing compatible build, select a complete variant rather than
+individual DLLs:
+
+```js
+const requirement = {
+    id: 'whisper.cpp',
+    encoder: 'openvino-npu',
+    backend: 'cpu',
+    models: ['whisper-small'],
+    variants: [{
+        backend: 'cpu',
+        encoder: 'openvino-npu',
+        root: nativeRuntimeDirectory,
+        libraryDirectory: path.join(nativeRuntimeDirectory, 'bin')
+    }]
+};
+```
+
+Each variant supplies a local `root` or an archive `url`. A supplied
+`libraryDirectory` is relative to or inside that selected tree; otherwise it
+is found from the native Whisper library. Each optional complete tree contains
+its own matching `arcane-whisper.exe` beside the runtime DLLs. Preparation
+retains that variant's executable, so multiple custom builds keep their
+matching helpers. Include all selected OpenVINO, NPU plugin/compiler, TBB,
+Whisper, ggml and compiler-runtime libraries, plus the CUDA libraries when
+selecting CUDA. A CPU variant still needs the OpenVINO NPU resources.
+
+For custom automatic decoder recovery, declare both CUDA and CPU variants
+with `encoder: "openvino-npu"`. Custom variants are prepared as explicitly
+supplied trees. Library search configuration belongs to the launched helper
+process and does not change the machine's global `PATH`. The general Whisper
+helper and FFmpeg decoder overrides remain available through the existing
+[runtime descriptor](../reference/local-whisper.md).
+
+## Produce the optional native runtime
+
+Runtime producers can use the public
+`arcane-os/local-ai/whisper/openvino-build` export with the selected installed
+Whisper 1.9.4 source, OpenVINO 2026.3.1 Windows development tree and an existing
+compatible CMake/MSVC environment. `cudaDirectory`, when supplied, names the
+matching upstream b5130 CUDA distribution's library directory. It supplies
+the precompiled CUDA backend; omitting it produces the NPU-plus-CPU runtime.
+
+```js
+import {cp} from 'node:fs/promises';
+import {buildWhisperOpenVinoRuntime} from 'arcane-os/local-ai/whisper/openvino-build';
+import {buildWhisperHelper} from 'arcane-os/local-ai/whisper/build';
+
+const nativeRuntime = await buildWhisperOpenVinoRuntime({
+    sourceDirectory,
+    openvinoDirectory,
+    cudaDirectory,
+    outputRoot: path.join(appRoot, '.arcane', 'native-build', 'openvino'),
+    env,
+    signal,
+    onEvent
+});
+
+const helper = await buildWhisperHelper({
+    runtime: nativeRuntime,
+    outputRoot: path.join(appRoot, '.arcane', 'native-build', 'helper'),
+    env,
+    signal,
+    onEvent
+});
+
+await cp(path.join(helper.root, 'bin'), nativeRuntime.libraryDirectory, {
+    recursive: true
+});
+```
+
+The variables for source directories, build environment, cancellation and
+diagnostics belong to the producer. Both functions also accept `cmake`,
+`generator` and `cmakeArgs` for that existing build environment.
+
+The runtime producer returns `root`, `directory`, `libraryDirectory`,
+`sourceDirectory`, selected `backends` and complete build `diagnostics`. Its
+output keeps the copied source and build directory separate from the runtime
+tree. It applies the encoder return-value propagation and exception-to-stderr
+corrections in that copied source. The helper build uses the matching headers
+and runtime and installs its required release compiler-runtime libraries;
+copying its complete installed `bin` directory places them with the optional
+runtime. Use `nativeRuntime.root` as the custom variant root and retain its
+packaging notices.
+
+This producer path builds a native distribution. Applications using the
+precompiled asset follow the preparation and bundling paths above.

package/docs/publishing.md

@@ -116,6 +116,45 @@ tag and GitHub release title must both be the same bare numeric
 `MAJOR.MINOR.PATCH`. Prerelease versions do not get a misleading numeric
 GitHub release, and no release creates a Git branch for an npm dist-tag.
 
+## Native runtime assets on numeric releases
+
+Default SDK-hosted native asset URLs use the installed SDK's version and its
+matching numeric GitHub release. Publishing npm alone does not make those
+downloads available. Every applicable numeric release therefore includes its
+compatible retained SDK-hosted assets as release follow-through:
+
+| Selected capability | Windows x64 release asset |
+| --- | --- |
+| Native application host | `arcane-native-windows-x64.tar.gz` |
+| Ordinary native Whisper helper | `arcane-whisper-windows-x64.tar.gz` |
+| Optional Intel NPU Whisper encoder | `arcane-whisper-openvino-windows-x64.tar.gz` |
+
+Attach each asset used by the selected package's default SDK-hosted download
+paths, including later releases whose native implementation is unchanged.
+Include the optional NPU asset when that release supplies `encoder:
+"openvino-npu"`; applications still opt in, and the ordinary Whisper asset
+remains available. Upstream runtime and model versions retain their separate
+upstream distribution URLs; they are not renamed to the SDK version.
+
+Reuse the producer's retained compatible archive and its recorded selected
+evidence. Do not rebuild or redownload an unchanged archive for each release.
+An actual native change belongs to its producer under the existing build and
+dependency authority. Preserve the complete runtime closure and its packaging
+notices together. Models continue through their upstream acquisition path
+unless their redistribution is separately requested.
+
+The release owner assigns each upload, observes its outcome and records the
+exact asset name and public release URL in the durable release handoff. If an
+upload result is uncertain, inspect that release's existing asset before
+retrying. Retain the exact pending operation, executing owner and last result
+until delivery finishes; reassign idle delegated work rather than treating
+delegation as completion.
+
+Source delivery, selected package verification, npm publication, native asset
+delivery, requester notices and documentation/site delivery are distinct.
+Native archive follow-through does not gate npm publication or require a new
+package build. Consumer adoption remains with each application owner.
+
 ## Documentation publication
 
 After every successful npm release and its applicable requester notices, the