arcane-os 0.63.0 → 0.65.0

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## 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
+  service and AI API, with actual model readiness, complete recordings and
+  transcripts, native progress, joined cancellation, and one eligible
+  accelerated-inference recovery on the prepared CPU runtime.
+- Preserve the same accepted transcription through internal recovery using
+  its actual Core request identity. Shared AI and speech controls report
+  recovering/error states honestly without discarding the original request
+  or turning its terminal native failure into cancellation.
+- Add the SDXL Base 1.0 text-to-image descriptor and correct the shared native
+  image binding's asynchronous worker stack allocation while preserving
+  existing model selection, complete inputs and native lifecycle.
+- Add `arcane-os/core/repositories` with per-user `ArcaneData/Repos` defaults
+  and connected working-repository open/status/pull/push/drain ownership.
+  Explicit paths and existing data remain unchanged; applications own
+  connection selection, remotes and product records. No data migration.
+- Keep optional NPU, repository file-write orchestration, generic development
+  Core composition, Codex/MCP and Ollama lifecycle drafts outside this release.
+  The npm dependency tree is unchanged; native resources use their documented
+  upstream installation and matching numeric-release helper assets.
+
 ## 0.63.0
 
 - Add the approved FLUX.2 Klein 4B text-to-image model descriptor to the

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.63.0` SDK contract. Development applications declare
+This checkout defines the `0.65.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/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,
@@ -459,7 +484,10 @@ export function createCoreClient({
         if(eventOwnerFailure)return Promise.reject(eventOwnerFailure);
         let selected;
         try{selected=connect();}catch(error){return Promise.reject(error);}
-        const {signal,timeoutMs=10*60*1000}=options??{};
+        const {signal,timeoutMs=10*60*1000,onRequest}=options??{};
+        if(onRequest!==undefined&&typeof onRequest!=='function'){
+            return Promise.reject(new TypeError('Arcane request observer must be a function.'));
+        }
         if(signal&&(typeof signal.aborted!=='boolean'
             ||typeof signal.addEventListener!=='function'
             ||typeof signal.removeEventListener!=='function')){
@@ -483,6 +511,8 @@ export function createCoreClient({
             if(!settle(id,failure))report(failure);
         }
         try{
+            if(onRequest)Promise.resolve(onRequest({requestId:id})).catch(report);
+            if(!pending.has(id))return promise;
             Promise.resolve(selected.send(frame)).catch(sendFailed);
         }catch(error){sendFailed(error);}
         return promise;
@@ -569,7 +599,7 @@ export function createCoreFacade(client){
         mail:{send:request=>invoke('mail.send',request??{},{timeoutMs:450000})},
         speech:{status:()=>invoke('speech.status',{},{timeoutMs:10000}),
             synthesize:(request,options)=>invoke('speech.synthesize',request??{},{timeoutMs:180000,signal:options?.signal}),
-            transcribe:(request,options)=>invoke('speech.transcribe',request??{},{timeoutMs:180000,signal:options?.signal})},
+            transcribe:(request,options)=>invoke('speech.transcribe',request??{},{timeoutMs:180000,signal:options?.signal,onRequest:options?.onRequest})},
         localAI:{status:()=>invoke('localai.status',{},{timeoutMs:15000}),
             ensurePlatform:()=>invoke('localai.platform.ensure',{},long),recover:request=>invoke('localai.services.recover',request??{},long),
             setParallelRequests:request=>invoke('localai.parallel.requests.set',request??{},long),
@@ -582,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),
@@ -639,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];
@@ -661,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){
@@ -675,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/reference/README.md

@@ -56,11 +56,16 @@ alone does not make bare module names resolve in a browser.
 | Compose native Core dispatch, service lifecycle, and stdio hosting | [Native Core runtime](core-runtime.md) |
 | Run application-selected llama.cpp, Ollama or ONNX through Core | [Local AI through Core](local-ai.md) |
 | Generate complete local PNG images with a retained native model | [Local image generation](local-image-generation.md) |
+| Select FLUX.2 Klein 4B and its three complementary model resources | [FLUX.2 Klein 4B through Core](local-image-flux.md) |
+| Select the complete SDXL Base 1.0 checkpoint for text-to-image generation | [SDXL Base 1.0 through Core](local-image-sdxl.md) |
+| Compose independently loaded transcription and synthesis engines | [Native speech service](native-speech.md) |
+| Keep a native Whisper model loaded across complete recordings | [Native Whisper transcription](local-whisper.md) |
 | Edit an original PNG with a complete prompt and explicit strength | [Local image editing](local-image-editing.md) |
 | Project complete stored model files into native working files | [Model assets through Core](model-assets.md) |
 | Retain a Nemotron model and diarize caller-fed audio streams | [Native speaker diarization](diarization.md) |
 | Persist application-selected preferences through Core | [Core preferences service](core-preferences.md) |
 | Read complete selected Git text without changing a checkout | [Git text snapshots](git-text-snapshot.md) |
+| Own a native working checkout under per-user ArcaneData/Repos | [Native repository workspaces](core-repositories.md) |
 | Build an installed-SDK portable Core payload | [Portable Core packaging](core-native-packaging.md) |
 | Pass host-selected state defaults and unchanged explicit launch values to services | [Launch-time locations](core-native-packaging.md#launch-time-locations) |
 | Build a Windows executable without an OS checkout | [Windows executable packaging](core-native-packaging.md#windows-executable) |
@@ -225,6 +230,7 @@ Ollama, Wllama, Whisper, Kokoro, native, or cloud transport:
 | Use Core-normalized chat | [`globalThis.Arcane.ai`](core/arcane-ai-contracts.md) | Native/Core only when separately admitted. |
 | Run a caller-selected GGUF LLM locally | [`arcane-os/ai/browser-wasm`](ai/browser-wasm.md) | Browser secure context with WebAssembly and OPFS/DBOPFS; explicit CPU selection or WebGPU with full offload and no automatic CPU fallback. |
 | Run application-selected native llama.cpp/Ollama chat | [`arcane-os/ai/core-local`, `arcane-os/core/local-ai`](local-ai.md) | Explicit Core connection and selected native runtimes; installation, availability and loaded-model readiness remain distinct. |
+| Transcribe complete recordings with a retained native Whisper model | [`arcane-os/local-ai/whisper`](local-whisper.md) and [Core speech](native-speech.md) | Matching native helper, Whisper libraries, decoder and selected model; Windows defaults and explicit other-platform distributions have distinct preparation requirements. |
 | Run a local ONNX graph with named tensors | [`arcane-os/local-ai/onnx`, `arcane-os/ai/core-onnx`](local-ai.md#native-onnx-sessions) | Retained native workers; browser access requires an available Core ONNX service. |
 | Generate local images from complete prompts and selected model resources | [`arcane-os/local-ai/image`, `arcane-os/ai/core-image`](local-image-generation.md) | Prepared native image runtime; browser access requires its Core service. CPU Windows/Linux and Mac Metal/CPU paths have distinct actual host requirements. |
 | Supply complete stored model members to a native engine | [`arcane-os/ai/core-model-assets`, `arcane-os/core/model-assets`](model-assets.md) | Available Core service; DBOPFS originals stay authoritative while native owners retain working files. |

package/docs/reference/arcane-ollama.md

@@ -120,7 +120,7 @@ non-writable `globalThis.arcaneOllama` convenience and emits
 | `version()` | `Arcane.ollama.version()` | Raw service version diagnostic. | [version](core/reference/arcane-api/ai-and-ollama.md#arcaneollamaversion) |
 | `models()` | `Arcane.ollama.models()` | Raw installed-model diagnostic. | [models](core/reference/arcane-api/ai-and-ollama.md#arcaneollamamodels) |
 | `list()` | Calls `Arcane.ollama.models()` | Module alias for `models()`; it does not call the bridge's separate `list` alias. | [list](core/reference/arcane-api/ai-and-ollama.md#arcaneollamalist) |
-| `running()` | `Arcane.ollama.running()` | Raw resident-model diagnostic. | [running](core/reference/arcane-api/ai-and-ollama.md#arcaneollamarunning) |
+| `running(options?)` | `Arcane.ollama.running(options?)` | Raw resident-model diagnostic; optional `{signal, timeoutMs, onRequest}` uses the Core request lifetime. No-argument calls remain supported. | [running](core/reference/arcane-api/ai-and-ollama.md#arcaneollamarunning) |
 | `show(model, options)` | `Arcane.ollama.show(...)` | Raw bounded model metadata. | [show](core/reference/arcane-api/ai-and-ollama.md#arcaneollamashow) |
 | `generate(request, options)` | `Arcane.ollama.generate(...)` | Admitted generation; optional chunk callback/signal/timeout. | [generate](core/reference/arcane-api/ai-and-ollama.md#arcaneollamagenerate) |
 | `chat(request, options)` | `Arcane.ollama.chat(...)` | Admitted chat/tools; optional chunk callback/signal/timeout. | [chat](core/reference/arcane-api/ai-and-ollama.md#arcaneollamachat) |