arcane-os 0.83.1 → 0.85.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # 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
+  `arcane-os/core/host` so local clients can use an application's existing
+  window-owned Core without creating another runtime or changing its profile,
+  service instances or saved-data location. Native packages select it with
+  `native.launchContext.coreListener: {endpoint}`.
+- Keep response correlation, cancellation and current-state replay scoped to
+  each connection. Preserve complete application payloads, expose the original
+  handler `requestId` and actual internal `coreRequestId`, and prevent retired
+  request events from attaching to a later reuse of a client ID.
+- Closing a client or listener leaves accepted service-owned work with its
+  runtime. Window shutdown drains Core and then closes its listener. Existing
+  explicitly selected headless shared-host behavior remains available. This
+  capability does not claim to correct or verify model inference.
+
 ## 0.83.1
 
 - Preserve complete failure-only native ONNX diagnostics in `error.onnxRun`,

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.83.1` 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

@@ -234,6 +234,41 @@ Windows and macOS launchers use the same packaged defaults for native state
 selection, so an ordinary executable launch and external MCP can select the
 same app-owned Core.
 
+To expose the actual window-owned Core to an external local client while
+preserving that stdio lifetime, select
+`native.launchContext:{coreListener:{endpoint:"APPLICATION-SELECTED-LOCAL-ENDPOINT"}}`
+instead. The generated entry calls
+`startCoreListener({runtime:host.runtime,endpoint})` after creating its ordinary
+stdio host. It reuses that exact service set and launch context, including the
+existing origin, profile and state root; no headless runtime is created. The
+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,
+and then closes the listener. Signal-driven host shutdown remains observed while
+the listener is binding; a bind failure drains the newly created stdio host and
+reports the failure. The generated entry joins listener closure without changing
+the existing shared-host/headless branches. See
+[the existing-runtime listener contract](core-shared-host.md#attach-to-an-existing-window-owned-core)
+for direct composition, correlation, cancellation and complete error behavior.
+
 `resolveNativeLaunchContext({appId,context={}})` from `arcane-os/core/host` is
 the public, synchronous location owner for native applications and external MCP.
 It returns a new complete context and fills only omitted fields:

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, 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)`.
 
@@ -132,6 +132,27 @@ The shared `arcane-os/core/contracts` module owns `CORE_PROTOCOL` (`arcane/1`),
 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, 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`.
 `core-namespace-unavailable` means the dispatcher has neither a service with
@@ -222,6 +243,21 @@ reach `onError` and reject `closed`. The transport detaches
 its listeners and pauses its input; it does not end caller-owned output streams
 or take ownership of the host process.
 
+Stdio routes responses and request-context events only for its own requests.
+`request.cancel`, `requests.cancelAll` and `runtime.replay` are connection-scoped;
+they do not cancel or replay another attached connection's work. The protocol
+owner gives every accepted request a fresh internal ID and restores its client
+ID on responses, event envelopes and stdio's own `core.state` entries. Handler
+`context.requestId` and complete application payloads keep their original values.
+Uncorrelated runtime/service events remain shared.
+
+`startCoreListener({runtime,endpoint,onError})` from `arcane-os/core/host` can
+attach additional local clients to this same runtime. Its explicit `close()`
+closes only that listener; stdio EOF still closes the runtime and drains all
+accepted service work, then the listener closes automatically. Observe the
+listener's `closed` as well as the stdio owner's `closed` to join both transport
+lifecycles. See [existing-runtime listeners](core-shared-host.md#attach-to-an-existing-window-owned-core).
+
 ## Platform and delivery boundary
 
 These modules use portable Node and JavaScript facilities for Windows, Linux

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

@@ -13,6 +13,70 @@ event history. Application methods and policy stay in the application services.
 Use the [MCP server](mcp-stdio.md) for external MCP framing; local Core continues
 to use the existing `arcane/1` protocol and Content-Length stream framing.
 
+## Attach to an existing window-owned Core
+
+`startCoreListener({runtime,endpoint,onError})` adds a local IPC listener to an
+existing Core runtime. It resolves `{endpoint,closed,close}` after binding the
+selected endpoint. It neither constructs nor starts a runtime or service. The
+existing host retains its application, services, origin, profile, state location
+and shutdown ownership.
+
+```js
+import {startCoreListener} from 'arcane-os/core/host';
+
+// host is the application's existing startCoreHost/startCoreStdio handle.
+const listener = await startCoreListener({runtime: host.runtime, endpoint: selectedEndpoint});
+try {
+    await host.closed;
+} finally {
+    await listener.close();
+}
+```
+
+An external client uses `connectSharedCoreHost({endpoint: selectedEndpoint})`
+with `start` omitted, invokes the application's existing methods through
+`connection.client.invoke(method, parameters)`, and calls `connection.close()`
+when finished. This connection uses the existing SDK framing, correlation and
+current-runtime replay; it does not launch another Core or replay requests.
+The listener does not implement or intercept `core.host.shutdown`.
+`connection.shutdown()` therefore has no listener-owned shutdown operation;
+without an application method of that name it returns the ordinary
+`METHOD_NOT_ALLOWED` error. The window's host remains the shutdown owner.
+
+Disconnect and `listener.close()` cancel only the affected connections'
+request-lifetime work. Explicit listener close drains queued output and releases
+the endpoint without closing the runtime or waiting for accepted service-lifetime
+work; that work remains tracked by its service/runtime owner. When the runtime
+itself begins shutdown, the listener rejects new requests and retains its endpoint
+through runtime drain/disposal, then closes its connections automatically.
+Observe both the host's `closed` and the listener's `closed` for their respective
+completion or failure. `close()` is idempotent. Transport errors reach `onError`
+(complete console diagnostics by default); terminal listener failures reject
+`closed`. Bind failures reject startup with their actual native error and leave
+the supplied runtime alive. A draining/closed runtime rejects attachment with
+`CORE_CLOSING`.
+
+Stdio and each IPC connection have independent request correlation and
+cancellation. Handlers reached through stdio or this listener receive 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.
+Its runtime-state snapshot retains the runtime's internal active IDs. Late events
+from a retired request never attach to a later reuse of that client's ID.
+Uncorrelated service events remain shared. See the
+[runtime metadata contract](core-runtime.md#state-and-frames).
+
+For a generated native entry, select
+`native.launchContext.coreListener:{endpoint}` and omit `sharedHost`. This adds
+the listener to the ordinary window/stdio runtime; closing the native window
+still drains Core. The endpoint is explicit, with no inferred headless startup
+or new default location. Its parent directory must already exist on platforms
+that require one. Selecting both `coreListener` and `sharedHost` reports
+`TypeError` because they select different runtime lifetimes. See
+[native launch locations](core-native-packaging.md#launch-time-locations).
+
 ## Host entry
 
 ```js
@@ -107,8 +171,8 @@ running. `closed` observes connection termination and rejects on a transport
 error. A subsequent connection uses the still-running owner. Reconnection is
 explicit; failed or uncertain requests are never resubmitted.
 
-`await connection.shutdown(invokeOptions)` explicitly invokes the host-owned
-`core.host.shutdown` operation. It drains the shared runtime, returns
+For an owning shared host, `await connection.shutdown(invokeOptions)` explicitly
+invokes the host-owned `core.host.shutdown` operation. It drains the shared runtime, returns
 `{state:'closed'}` after successful service cleanup, then closes the connection.
 A drain failure returns the full Core error. Shutdown affects **all** clients
 of that app endpoint and belongs to the application owner's explicit lifecycle,
@@ -118,13 +182,18 @@ after shutdown acceptance does not undo the shared shutdown.
 
 ## Correlation, events, and state
 
-Each connection has its own request-ID space. The transport substitutes an
-internal Core request ID and restores the originating ID on responses and
+Each connection has its own request-ID space. The owning shared-host adapter
+substitutes an internal Core request ID and restores the originating ID on responses and
 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
@@ -137,10 +206,10 @@ connection's IDs; other connections' active requests retain Core-side IDs.
 requests. A disconnect performs the same scoped cancellation. The underlying
 runtime continues to preserve service-lifetime acceptance.
 
-`runtime.replay` sends only that connection the current `core.ready`,
-`core.state`, and `core.service.state` snapshot. Optional synchronous
-`getReplayEvents()` returns current `{event,data}` records from their actual
-service owners. It is for current domain state, not historical chunks or
+Both listener forms handle `runtime.replay` by sending only that connection the
+current `core.ready`, `core.state`, and `core.service.state` snapshot. Optional
+synchronous `getReplayEvents()` on the owning shared host returns current
+`{event,data}` records from their actual service owners. It is for current domain state, not historical chunks or
 retired requests. Subscribe before requesting a domain snapshot when its live
 events may change; applications own those domain methods and state.
 

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,