arcane-os 0.84.0 → 0.85.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.85.0
+
+- Add `createModelObservationService({runtime, localAI, image, decisions})`
+  through `arcane-os/core/model-observation`, and renderer
+  `attachModelObservation` / observer `subscribeModelObservation` through
+  `arcane-os/ai/model-observation`. Observe the actual existing Core and
+  renderer model owners without creating, loading or replacing a runtime,
+  provider or model.
+- Replay complete current owner state and retain its reported errors, with
+  explicit opt-in live diagnostics and connection-owned cancellation. Keep
+  original client request identity separate from actual internal Core request
+  identity. Native `coreListener` composition reuses existing selected services;
+  applications explicitly attach their renderer owners.
+- Preserve the complete Windows PnP property batch while narrowing only the
+  property cmdlet's internal concurrency. Keep asynchronous shared discovery,
+  cancellation, explicit refresh and model/device selection unchanged. This
+  addresses the observed missing/duplicate property rows without adding retries
+  or another hardware query.
+- These capabilities expose current state and correct the property query;
+  they do not claim to repair or verify native model inference. No dependency
+  changes or native host rebuild are required for this revision.
+
 ## 0.84.0
 
 - Add `startCoreListener({runtime, endpoint, onError})` through

package/README.md

@@ -25,7 +25,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.84.0` SDK contract. Development applications declare
+This checkout defines the `0.85.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/model-observation.mjs

@@ -0,0 +1,315 @@
+import Is from '../dependencies/strong-type/index.js';
+import {CoreError, serializeCoreError} from '../core/contracts.mjs';
+import {getInstalledCoreClient, subscribeCoreClient} from '../core/client.mjs';
+
+const is = new Is(false);
+
+/** Attach the caller's existing renderer owners to its existing Core client. */
+export function attachModelObservation({client, aiRuntimeState = null, imageRuntime = null,
+    decisionModel = null, modelController = null, signal, onError} = {}) {
+    requireOwner(aiRuntimeState, ['getAIRuntimeState', 'subscribeAIRuntimeState'], 'aiRuntimeState');
+    requireOwner(imageRuntime, ['current', 'subscribe'], 'imageRuntime');
+    requireOwner(decisionModel, ['status', 'subscribe'], 'decisionModel');
+    requireOwner(modelController, ['status', 'on'], 'modelController');
+    const lifetime = observationLifetime({client, signal, onError});
+    let attachmentRequestId;
+    let coreRequestId;
+    let snapshot = null;
+    let attached = false;
+
+    function readOwners() {
+        return {
+            aiRuntimeState: aiRuntimeState?.getAIRuntimeState() ?? null,
+            imageRuntime: imageRuntime?.current() ?? null,
+            decisionModel: decisionModel?.status() ?? null,
+            modelController: modelController?.status() ?? null
+        };
+    }
+
+    function publishOwners() {
+        if (!attached || lifetime.stopped) return;
+        try {
+            snapshot = readOwners();
+            lifetime.invoke('model.observation.renderer.publish', {
+                attachmentRequestId, coreRequestId, snapshot: transportSnapshot(snapshot)
+            });
+        } catch (error) {
+            lifetime.fail(error);
+        }
+    }
+
+    function observeOwners() {
+        if (aiRuntimeState) lifetime.cleanup(aiRuntimeState.subscribeAIRuntimeState(
+            publishOwners, {emitCurrent: false, signal: lifetime.signal}
+        ));
+        if (imageRuntime) lifetime.cleanup(imageRuntime.subscribe(
+            publishOwners, {replay: false, signal: lifetime.signal}
+        ));
+        if (decisionModel) lifetime.cleanup(decisionModel.subscribe(
+            publishOwners, {emitCurrent: false, signal: lifetime.signal}
+        ));
+        if (modelController) {
+            lifetime.cleanup(modelController.on('statechange', publishOwners));
+            lifetime.cleanup(modelController.on('progress', publishOwners));
+        }
+    }
+
+    function acknowledgeAttachment(value) {
+        if (lifetime.stopped || attached || value?.attachmentRequestId !== attachmentRequestId) return;
+        try {
+            if (!is.string(value.coreRequestId)) {
+                throw observationError('MODEL_OBSERVATION_CONTEXT_UNAVAILABLE',
+                    'The renderer acknowledgement omitted the actual Core request identity.');
+            }
+            coreRequestId = value.coreRequestId;
+            attached = true;
+            observeOwners();
+            // Read again after all subscriptions exist so changes during the
+            // attachment handshake are represented by current owner state.
+            publishOwners();
+            lifetime.acknowledge(value);
+        } catch (error) {
+            lifetime.fail(error);
+        }
+    }
+
+    if (!lifetime.stopped) {
+        try {
+            snapshot = readOwners();
+            lifetime.cleanup(client.events.on('model.observation.renderer.attached', acknowledgeAttachment));
+            lifetime.invoke('model.observation.renderer.attach', {snapshot: transportSnapshot(snapshot)}, {
+                long: true,
+                onRequest: function identifyAttachment(value) { attachmentRequestId = value.requestId; }
+            });
+        } catch (error) {
+            lifetime.fail(error);
+        }
+    }
+
+    return {
+        ready: lifetime.ready,
+        closed: lifetime.closed,
+        current: function currentRendererObservation() { return snapshot; },
+        close: lifetime.close
+    };
+}
+
+/** Subscribe through an existing Core client; model diagnostics are explicit. */
+export function subscribeModelObservation({client, signal, onState, onDiagnostic, onError} = {}) {
+    if (!is.function(onState)) throw new TypeError('Model observation requires an onState listener.');
+    if (onDiagnostic !== undefined && !is.function(onDiagnostic)) {
+        throw new TypeError('onDiagnostic must be a function.');
+    }
+    const lifetime = observationLifetime({client, signal, onError});
+    let watchRequestId;
+    let snapshot = null;
+
+    function receiveState(value) {
+        if (lifetime.stopped || value?.watchRequestId !== watchRequestId) return;
+        if (!value.snapshot || !is.object(value.snapshot)) {
+            lifetime.fail(observationError('MODEL_OBSERVATION_STATE_INVALID', 'Core omitted the observation snapshot.'));
+            return;
+        }
+        snapshot = value.snapshot;
+        lifetime.acknowledge(snapshot);
+        lifetime.notify(onState, snapshot);
+    }
+
+    function receiveDiagnostic(value) {
+        if (lifetime.stopped || value?.watchRequestId !== watchRequestId) return;
+        lifetime.notify(onDiagnostic, value);
+    }
+
+    if (!lifetime.stopped) {
+        try {
+            lifetime.cleanup(client.events.on('model.observation.state', receiveState));
+            if (onDiagnostic) lifetime.cleanup(client.events.on('model.observation.error', receiveDiagnostic));
+            lifetime.invoke('model.observation.watch', {diagnostics: Boolean(onDiagnostic)}, {
+                long: true,
+                onRequest: function identifyWatch(value) { watchRequestId = value.requestId; }
+            });
+        } catch (error) {
+            lifetime.fail(error);
+        }
+    }
+
+    return {
+        ready: lifetime.ready,
+        closed: lifetime.closed,
+        current: function currentModelObservation() { return snapshot; },
+        close: lifetime.close
+    };
+}
+
+function requireOwner(owner, methods, label) {
+    if (owner === null) return;
+    for (const method of methods) {
+        if (!is.function(owner?.[method])) throw new TypeError(`${label} must be an existing owner exposing ${method}().`);
+    }
+}
+
+function observationError(code, message) {
+    return new CoreError({code, message});
+}
+
+function cancelledObservation() {
+    return new CoreError({name: 'AbortError', code: 'ARCANE_REQUEST_ABORTED', message: 'Model observation was cancelled.'});
+}
+
+function isCancellation(error) {
+    return error?.name === 'AbortError' || error?.code === 'ARCANE_REQUEST_ABORTED' || error?.code === 'REQUEST_ABORTED';
+}
+
+/** Error encoding belongs only to the existing JSON transport boundary. */
+function transportSnapshot(snapshot) {
+    return Object.fromEntries(Object.entries(snapshot).map(function transportOwner([name, value]) {
+        return [name, value && is.error(value.error) ? {...value, error: serializeCoreError(value.error)} : value];
+    }));
+}
+
+function reportObservationFailure(error) {
+    globalThis.console?.error('Model observation failed.', error);
+}
+
+/** Own only observation RPCs and subscriptions, never the supplied owners. */
+function observationLifetime({client, signal, onError = reportObservationFailure}) {
+    if (!is.function(client?.invoke) || !is.function(client?.events?.on)) {
+        throw new TypeError('Model observation requires an existing Core client.');
+    }
+    if (!is.function(onError)) throw new TypeError('onError must be a function.');
+    const controller = new AbortController();
+    const cleanups = [];
+    const pending = new Set();
+    const failures = [];
+    let stopped = false;
+    let acknowledged = false;
+    let completed = false;
+    let resolveReady;
+    let rejectReady;
+    let resolveClosed;
+    let rejectClosed;
+    const ready = new Promise(function ownObservationReadiness(resolve, reject) {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    const closed = new Promise(function ownObservationClosure(resolve, reject) {
+        resolveClosed = resolve;
+        rejectClosed = reject;
+    });
+    // The same failures are reported through onError and retained on these
+    // public promises; unused companion promises must not create extra alerts.
+    ready.catch(function readinessFailureObservedByLifetime() {});
+    closed.catch(function closureFailureObservedByLifetime() {});
+
+    function recordFailure(error) {
+        if (failures.includes(error)) return;
+        failures.push(error);
+        try {
+            Promise.resolve(onError(error)).catch(function reportErrorCallbackFailed(callbackError) {
+                reportObservationFailure(callbackError);
+            });
+        } catch (callbackError) {
+            reportObservationFailure(callbackError);
+        }
+    }
+
+    function finish() {
+        if (!stopped || pending.size || completed) return;
+        completed = true;
+        if (failures.length === 1) rejectClosed(failures[0]);
+        else if (failures.length) rejectClosed(new AggregateError(failures, 'Model observation closed with errors.'));
+        else resolveClosed();
+    }
+
+    function close() {
+        if (!stopped) {
+            stopped = true;
+            for (const cleanup of cleanups.splice(0)) {
+                try { cleanup(); } catch (error) { recordFailure(error); }
+            }
+            controller.abort();
+            if (!acknowledged) rejectReady(failures[0] ?? cancelledObservation());
+        }
+        finish();
+        return closed;
+    }
+
+    function fail(error) {
+        recordFailure(error);
+        close();
+    }
+
+    function cleanup(release) {
+        if (!is.function(release)) throw new TypeError('An observation subscription must return an unsubscribe function.');
+        if (stopped) release();
+        else cleanups.push(release);
+    }
+
+    function invoke(method, parameters, {long = false, onRequest} = {}) {
+        if (stopped) return;
+        // Reserve ownership before invoke: an in-process transport can deliver
+        // acknowledgement synchronously while invoke is still on the stack.
+        const operation = {};
+        pending.add(operation);
+        let task;
+        try {
+            task = client.invoke(method, parameters, {signal: controller.signal, timeoutMs: 0, onRequest});
+        } catch (error) {
+            task = Promise.reject(error);
+        }
+        Promise.resolve(task).then(function observationCompleted() {
+            pending.delete(operation);
+            if (long && !stopped) {
+                if (!acknowledged) fail(observationError('MODEL_OBSERVATION_ENDED', 'The observation ended before acknowledgement.'));
+                else close();
+            }
+            finish();
+        }, function observationFailed(error) {
+            pending.delete(operation);
+            if (isCancellation(error)) close();
+            else fail(error);
+            finish();
+        });
+    }
+
+    function acknowledge(value) {
+        if (stopped || acknowledged) return;
+        acknowledged = true;
+        resolveReady(value);
+    }
+
+    function notify(listener, value) {
+        if (stopped || !listener) return;
+        try {
+            // Callback lifetimes belong to callers, who may await close().
+            // Observe rejection without making that callback a close barrier.
+            Promise.resolve(listener(value)).catch(fail);
+        } catch (error) {
+            fail(error);
+        }
+    }
+
+    function retireObservation() { close(); }
+    if (signal) {
+        signal.addEventListener('abort', retireObservation, {once: true});
+        cleanup(function releaseCallerSignal() { signal.removeEventListener('abort', retireObservation); });
+    }
+    if (is.function(globalThis.addEventListener)) {
+        globalThis.addEventListener('pagehide', retireObservation, {once: true});
+        cleanup(function releasePageLifetime() { globalThis.removeEventListener('pagehide', retireObservation); });
+    }
+    if (getInstalledCoreClient() === client) {
+        cleanup(subscribeCoreClient(function installedOwnerChanged(value) {
+            if (value.client !== client) {
+                if (value.error) fail(value.error);
+                else close();
+            }
+        }, {emitCurrent: false}));
+    }
+    if (signal?.aborted) close();
+
+    return {
+        ready, closed, signal: controller.signal, cleanup, invoke, acknowledge, notify, fail, close,
+        get stopped() { return stopped; }
+    };
+}

package/docs/reference/core-native-packaging.md

@@ -245,6 +245,20 @@ listener endpoint has no default and its parent directory must already exist
 where required by the operating system. `coreListener` and `sharedHost` are
 alternative selections; supplying both reports `TypeError`.
 
+That same `coreListener` opt-in registers one
+[`createModelObservationService()`](model-observation.md) after `startCoreHost()`
+and before binding the listener. It receives `host.runtime` and the exact
+already-created service objects exposing `localai.status`, `image.status` and
+`decisions.status`; a configurable decision-service name remains supported.
+Absent owners are `null`. Composition creates no model or second runtime,
+performs no service lookup and adds no model-readiness wait. Ordinary stdio
+without this opt-in and the existing `sharedHost` branches retain their behavior.
+The application separately calls `attachModelObservation()` with its existing
+renderer owners and Core client; native composition cannot infer those objects.
+Observers select `onDiagnostic` to receive complete live model failure frames
+in their developer diagnostic surface. Observation does not start inference or
+establish that an existing model failure has been corrected.
+
 Clients use `connectSharedCoreHost({endpoint})` with `start` omitted and close
 only their own connection. This listener provides no host-shutdown RPC. Closing
 the window still drains its Core, including accepted service-owned operations,

package/docs/reference/core-runtime.md

@@ -67,7 +67,7 @@ complete diagnostic serialization; the startup promise retains its original
 rejection value.
 
 Each lifecycle hook receives `{application, service, emit, getService}`. Each request handler
-receives `(parameters, {application, service, emit, getService, requestId, coreRequestId, signal})`, with
+receives `(parameters, {application, service, emit, getService, requestId, clientRequestId, coreRequestId, signal})`, with
 `this` bound to its service definition. A hook or handler may publish a complete
 service-owned event through `emit(event, data)`.
 
@@ -133,16 +133,25 @@ availability errors remain observable; unavailable services are not replaced
 with browser behavior.
 
 A transport that assigns internal dispatch IDs may call
-`runtime.handle(frame, {contextRequestId})`. This optional nonempty string sets
-only the service handler's `context.requestId`. `context.coreRequestId` always
-exposes the actual `frame.id`; it distinguishes simultaneous requests whose
-clients selected equal IDs. The supplied `frame.id` still
-owns active-request state, cancellation lookup, response correlation and the
-request event's top-level envelope. Parameters and event data remain unchanged.
-Ordinary `handle(frame)` keeps its existing behavior: `context.requestId` equals
-`frame.id`, and `coreRequestId` equals that same ID. Stdio and
-the borrowed IPC listener use this metadata to preserve the original client ID
-in service-facing data while their transport owner routes unique dispatch IDs.
+`runtime.handle(frame, {contextRequestId, contextClientRequestId})`. Each supplied
+metadata value must be a nonempty string. Handler identities are:
+
+| Field | Value |
+|---|---|
+| `requestId` | `contextRequestId ?? frame.id`, preserving the transport's established handler contract |
+| `clientRequestId` | `contextClientRequestId ?? contextRequestId ?? frame.id`, exposing the actual incoming client identity |
+| `coreRequestId` | `frame.id`, the actual internal dispatch identity |
+
+Ordinary `handle(frame)` exposes all three equal to `frame.id`. Existing callers
+that supply only `contextRequestId` also receive that value as `clientRequestId`.
+Stdio and both IPC listener forms always supply the actual client ID separately.
+Stdio and the borrowed listener preserve it as `requestId` too; the owning
+shared-host adapter retains its established internal `requestId` contract.
+
+The supplied `frame.id` still owns active-request state, cancellation lookup,
+response correlation and the request event's top-level envelope. It distinguishes
+simultaneous requests whose clients selected equal IDs. Parameters, results and
+event data remain unchanged; these identity fields are separate context metadata.
 
 A request with no registered handler retains code `METHOD_NOT_ALLOWED` and
 adds the exact `method`, its first dotted `namespace`, and a `reason`.

package/docs/reference/core-shared-host.md

@@ -58,7 +58,8 @@ the supplied runtime alive. A draining/closed runtime rejects attachment with
 
 Stdio and each IPC connection have independent request correlation and
 cancellation. Handlers reached through stdio or this listener receive the
-original client ID in `context.requestId`; `context.coreRequestId` exposes the
+original client ID in both `context.requestId` and `context.clientRequestId`;
+`context.coreRequestId` exposes the
 fresh internal ID used by runtime dispatch and protocol routing. Responses and
 top-level event correlation return to their originating connection. The new listener leaves all event data,
 including any authored `data.requestId`, and all parameters/results unchanged.
@@ -186,8 +187,13 @@ substitutes an internal Core request ID and restores the originating ID on respo
 the optional top-level event `requestId`. Existing `data.requestId` values that
 carry that same Core correlation ID are restored too. `parameters`, returned results, schemas,
 documents, and content remain complete and unchanged. A handler's
-`context.requestId` is the Core-side correlation ID; put it in the event's
-separate `requestId` field, not inside application content.
+`context.requestId` remains the Core-side correlation ID, equal to
+`context.coreRequestId`; put it in the event's separate `requestId` field, not
+inside application content. The additive `context.clientRequestId` exposes the
+actual incoming client ID independently of that compatibility behavior. Services
+such as [model observation](model-observation.md) can therefore publish explicit
+client-facing acknowledgement fields without changing the existing adapter or
+rewriting application payloads.
 
 Responses and request-context events go to the originating connection in
 order. Core supplies the top-level request correlation outside `data`, so two

package/docs/reference/execution-devices.md

@@ -41,6 +41,12 @@ An adapter whose stable identity cannot be established remains in the inventory
 with `deviceId: null` and a corresponding issue. The SDK does not invent a key
 from a name, enumeration order, hardware model number or adapter LUID.
 
+Windows discovery reads the present PCI devices' bus and address properties in
+one batched `Get-PnpDeviceProperty` call with `-ThrottleLimit 1`. This limits
+concurrency inside that query because concurrent CIM operations have been
+observed to duplicate some device results and omit others. Discovery remains
+asynchronous at the host, with the same shared catalog and explicit refresh.
+
 The CPU choice uses `deviceId: 'cpu'` and `identitySource: 'host-cpu'`. It selects
 the whole-host CPU execution target, without claiming socket or core affinity.
 Its `processors` entries contain `{deviceId, name, socketDesignation, cores,

package/docs/reference/inventory/package-api.json

@@ -1,17 +1,59 @@
 {
   "schemaVersion": 1,
-  "sdkVersion": "0.83.0",
+  "sdkVersion": "0.83.1",
   "environment": {
     "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
     "minimumVersion": "22.23.2 for Node entrypoints",
     "moduleSystem": "ESM"
   },
-  "memberCount": 303,
+  "memberCount": 306,
   "runtimeSubpathPatterns": {
     "arcane-os/modules/*": "./runtime/arcane/modules/*",
     "arcane-os/entities/*": "./runtime/arcane/entities/*"
   },
   "members": [
+    {
+      "id": "core-model-observation:createModelObservationService",
+      "name": "createModelObservationService",
+      "displayName": "createModelObservationService()",
+      "kind": "function",
+      "signature": "createModelObservationService({runtime,localAI=null,image=null,decisions=null}={})",
+      "entrypoints": ["arcane-os/core/model-observation"],
+      "primaryImport": "arcane-os/core/model-observation",
+      "group": "Existing model observation",
+      "summary": "Observes an existing Core runtime and supplied actual native model service owners without creating or starting them.",
+      "availability": "Node with an existing Core runtime and optional existing native model services",
+      "protocol": "arcane/1 model.observation current, watch, renderer.attach and renderer.publish methods",
+      "normalization": "Returns name:model-observation, current(), dispose() and four methods. Complete current snapshots retain core, optional native localAI/image/decisions and request-owned renderer attachments. Missing owners are null; watch diagnostics defaults false and explicit true exposes complete live failed response frames for supplied native method keys without retained failure history. Actual clientRequestId identifies acknowledgements; coreRequestId keys renderer lifetime. Disposal cancels only observation requests/subscriptions, never models or the supplied runtime. No getService, readiness barrier, model creation, inference, polling or fabricated operation identities."
+    },
+    {
+      "id": "ai-model-observation:attachModelObservation",
+      "name": "attachModelObservation",
+      "displayName": "attachModelObservation()",
+      "kind": "function",
+      "signature": "attachModelObservation({client,aiRuntimeState=null,imageRuntime=null,decisionModel=null,modelController=null,signal,onError}={})",
+      "entrypoints": ["arcane-os/ai/model-observation"],
+      "primaryImport": "arcane-os/ai/model-observation",
+      "group": "Existing model observation",
+      "summary": "Attaches the application's existing renderer model owners through its existing Core client.",
+      "availability": "JavaScript with an existing Core client and optional existing renderer owners",
+      "protocol": "Request-owned model.observation.renderer attachment and complete snapshot publication",
+      "normalization": "Returns ready, closed, current() and close(). Ready acknowledges actual attachmentRequestId/coreRequestId; subscriptions publish complete current owner snapshots and reread after acknowledgement. Existing Core serialization encodes owner Error fields at the JSON boundary without changing other fields. Abort, page retirement, exact installed-client retirement, transport failure or explicit close retires only observation RPCs/subscriptions and leaves models/client owned by the caller. Normal cancellation closes cleanly; pre-acknowledgement cancellation rejects ready. Other failures reject public promises and reach onError or complete console diagnostics. No automatic reattachment, owner creation, model work or page-render barrier."
+    },
+    {
+      "id": "ai-model-observation:subscribeModelObservation",
+      "name": "subscribeModelObservation",
+      "displayName": "subscribeModelObservation()",
+      "kind": "function",
+      "signature": "subscribeModelObservation({client,signal,onState,onDiagnostic,onError}={})",
+      "entrypoints": ["arcane-os/ai/model-observation"],
+      "primaryImport": "arcane-os/ai/model-observation",
+      "group": "Existing model observation",
+      "summary": "Subscribes to complete existing model-owner snapshots and explicitly selected live Core diagnostics.",
+      "availability": "JavaScript with an existing Core client and composed observation service",
+      "protocol": "Request-owned model.observation.watch with targeted state and optional error events",
+      "normalization": "Requires onState; returns ready, closed, current() and close(). Ready resolves the first current snapshot; onDiagnostic explicitly selects diagnostics:true and receives complete correlated live failed Core response frames, without recovered history or inferred model IDs. Closing, abort, page/client retirement and transport failures retire only observation work. Normal cancellation closes cleanly; other errors reach onError and reject public promises. Callback errors close the observation while callback promises remain caller-owned. No model refresh, inference, polling, host launch, endpoint discovery, reconnect or saved conversation content."
+    },
     {
       "id": "core-app-control:connectAppControl",
       "name": "connectAppControl",
@@ -4374,7 +4416,7 @@
       "summary": "Creates an app-neutral Core dispatcher with explicit services, request lifetimes, events and graceful drain.",
       "availability": "Node on Windows, Linux and macOS native hosts; Android requires its host adaptation",
       "protocol": "arcane/1 dispatcher and service lifecycle",
-      "normalization": "Starts services independently; runtime.getService(name) and context.getService(name) return the same registered object after only its shared startup, without a renderer or global barrier. Lookup is readiness, not a lifetime lease; new lookups reject during shutdown. runtime.handle(frame,{contextRequestId}) optionally sets handler requestId while coreRequestId remains frame.id; omitted metadata exposes both equal. Internal IDs continue to own cancellation/state/event envelopes and payloads remain unchanged. Preserves complete results/errors, cancels request-lifetime work and drains accepted service work; runtime.replay publishes current dispatcher/service state without restart and preserves reentrant lifecycle publication order. Missing dispatch retains METHOD_NOT_ALLOWED with exact method/namespace and core-namespace-unavailable or core-method-unavailable; named services, registered methods and built-in namespaces establish presence. Handler/startup/permission errors remain unchanged."
+      "normalization": "Starts services independently; runtime.getService(name) and context.getService(name) return the same registered object after only its shared startup, without a renderer or global barrier. Lookup is readiness, not a lifetime lease; new lookups reject during shutdown. runtime.handle(frame,{contextRequestId,contextClientRequestId}) sets requestId=contextRequestId??frame.id, clientRequestId=contextClientRequestId??contextRequestId??frame.id and coreRequestId=frame.id; omitted metadata exposes all three equal. Transports always supply the actual client ID separately, preserving the owning shared-host internal requestId contract. Internal IDs continue to own cancellation/state/event envelopes and payloads remain unchanged. Preserves complete results/errors, cancels request-lifetime work and drains accepted service work; runtime.replay publishes current dispatcher/service state without restart and preserves reentrant lifecycle publication order. Missing dispatch retains METHOD_NOT_ALLOWED with exact method/namespace and core-namespace-unavailable or core-method-unavailable; named services, registered methods and built-in namespaces establish presence. Handler/startup/permission errors remain unchanged."
     },
     {
       "id": "core-stdio:encodeCoreFrame",
@@ -4416,7 +4458,7 @@
       "summary": "Attaches an existing Core runtime to framed input and output with concurrent dispatch and graceful shutdown.",
       "availability": "Node with readable input and writable output streams",
       "protocol": "Content-Length framed arcane/1 stdio",
-      "normalization": "Returns {runtime,closed,close}; scopes responses/request events, cancellation and current-state replay to its connection, preserving original service-facing requestId and complete payloads while routing unique internal IDs. Preserves queued output order, reports parser and stream failures, drains accepted runtime work on EOF and never exits the host or ends caller-owned output"
+      "normalization": "Returns {runtime,closed,close}; scopes responses/request events, cancellation and current-state replay to its connection, preserving original service-facing requestId/clientRequestId and complete payloads while coreRequestId identifies unique internal dispatch. Preserves queued output order, reports parser and stream failures, drains accepted runtime work on EOF and never exits the host or ends caller-owned output"
     },
     {
       "id": "native-portable-provider:createPortableNativeProvider",
@@ -4430,7 +4472,7 @@
       "summary": "Creates the SDK-owned provider that assembles one selected app and explicit services into a portable Core payload.",
       "availability": "Node; produces a portable payload rather than an executable host",
       "protocol": "arcane-native-builder/1 portable provider",
-      "normalization": "Preserves complete selected app and dependency releases; an explicit services selection overrides appDescriptor.native.services, otherwise the descriptor selection is used; optional appDescriptor.native.window carries positive integral logical client width/height and optional resizable into manifest.window with omitted fields preserved; reports executable:false and never substitutes for an unavailable platform host"
+      "normalization": "Preserves complete selected app and dependency releases; an explicit services selection overrides appDescriptor.native.services, otherwise the descriptor selection is used; optional appDescriptor.native.window carries positive integral logical client width/height and optional resizable into manifest.window with omitted fields preserved. Generated coreListener opt-in composes one passive model-observation service from the existing host.runtime and actual services exposing localai.status/image.status/decisions.status before listener binding, with absent owners null and renderer attachment separate. Ordinary stdio and sharedHost/headless behavior remains unchanged; no model creation, getService or readiness barrier. Reports executable:false and never substitutes for an unavailable platform host"
     },
     {
       "id": "native-portable-provider:arcaneNativeBuilderProvider",
@@ -4640,7 +4682,7 @@
       "summary": "Attaches local IPC to an existing window-owned Core runtime without changing its services or lifetime.",
       "availability": "Node named pipes on Windows and Unix-domain sockets on Linux/macOS; Android requires its host adaptation",
       "protocol": "arcane/1 over local IPC with per-connection correlation, cancellation and current-state replay",
-      "normalization": "Returns {endpoint,closed,close}; never constructs, starts or closes the supplied runtime. Explicit close flushes queued output and disconnects its clients while accepted service work remains runtime-owned. Runtime shutdown retains the endpoint through service drain then closes the listener. Preserves parameters/results/event data, original handler requestId and internal coreRequestId; no host shutdown RPC. Bind errors reject startup; transport errors reach onError and terminal errors reject closed. Native launchContext.coreListener:{endpoint} selects the existing stdio branch; no sharedHost/headless selection or inferred endpoint."
+      "normalization": "Returns {endpoint,closed,close}; never constructs, starts or closes the supplied runtime or registers services. Explicit close flushes queued output and disconnects its clients while accepted service work remains runtime-owned. Runtime shutdown retains the endpoint through service drain then closes the listener. Preserves parameters/results/event data, original handler requestId/clientRequestId and internal coreRequestId; no host shutdown RPC. Bind errors reject startup; transport errors reach onError and terminal errors reject closed. Native launchContext.coreListener:{endpoint} selects the existing stdio branch and its existing-instance observation composition; no sharedHost/headless selection or inferred endpoint."
     },
     {
       "id": "core-host:startSharedCoreHost",
@@ -4654,7 +4696,7 @@
       "summary": "Claims an app-selected local endpoint before composing one shared Core runtime.",
       "availability": "Node named pipes on Windows and Unix-domain sockets on Linux/macOS; Android requires its host adaptation",
       "protocol": "arcane/1 over local IPC with per-connection request correlation and current-state replay",
-      "normalization": "Returns {runtime,endpoint,closed,close}; configure(runtime,{signal}) registers independently started services after the endpoint claim. Close joins composition, accepted service work, disposal and queued frames before releasing the endpoint. Complete transport/startup/shutdown errors remain observable; an occupied endpoint never invokes the factory"
+      "normalization": "Returns {runtime,endpoint,closed,close}; configure(runtime,{signal}) registers independently started services after the endpoint claim. Preserves internal handler requestId/coreRequestId and the existing matching data.requestId adapter mapping while additive clientRequestId exposes the actual client ID independently. Other payload fields remain unchanged. Close joins composition, accepted service work, disposal and queued frames before releasing the endpoint. Complete transport/startup/shutdown errors remain observable; an occupied endpoint never invokes the factory"
     },
     {
       "id": "core-host:connectSharedCoreHost",