arcane-os 0.83.0 → 0.84.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 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`,
+  including session and request identity, failure stage, graph metadata,
+  provider execution, run options and encoded feed/fetch tensors. Existing
+  rejected evaluations and retained decision error state carry the record.
+- Retain the device inventory already consumed by automatic physical selection
+  without another hardware query. Successful inference performs no diagnostic
+  tensor encoding; original errors and diagnostic-construction failures remain
+  observable without changing model inputs, device selection or cancellation.
+- These diagnostics expose evidence for a failed operation; they do not claim
+  to correct an application inference failure. No dependency changes.
+
 ## 0.83.0
 
 - Add optional `shadowPath` to native app-control inspection and actions. Follow

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.0` SDK contract. Development applications declare
+This checkout defines the `0.84.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/docs/reference/core-native-packaging.md

@@ -234,6 +234,27 @@ 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`.
+
+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, 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,18 @@ 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})`. 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.
+
 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 +234,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,69 @@ 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 `context.requestId`; `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 +170,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,8 +181,8 @@ 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
@@ -137,10 +200,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/inventory/package-api.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "sdkVersion": "0.82.0",
+  "sdkVersion": "0.83.0",
   "environment": {
     "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
     "minimumVersion": "22.23.2 for Node entrypoints",
     "moduleSystem": "ESM"
   },
-  "memberCount": 302,
+  "memberCount": 303,
   "runtimeSubpathPatterns": {
     "arcane-os/modules/*": "./runtime/arcane/modules/*",
     "arcane-os/entities/*": "./runtime/arcane/entities/*"
@@ -4374,7 +4374,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. 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}) 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."
     },
     {
       "id": "core-stdio:encodeCoreFrame",
@@ -4416,7 +4416,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}; 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 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"
     },
     {
       "id": "native-portable-provider:createPortableNativeProvider",
@@ -4598,7 +4598,7 @@
       "summary": "Resolves matching per-app native state, workspace and optional shared endpoint defaults for packaged UI and external MCP.",
       "availability": "Node native locations on Windows/Linux/macOS; Android and other hosts supply stateRoot and native adaptation",
       "protocol": "Pure native launch-context resolution and existing local IPC",
-      "normalization": "Returns a new complete context with only omitted stateRoot/workspaceRoot and selected sharedHost endpoint/log fields filled; preserves explicit values and additional payloads. Native launchContext presence opts generated entry into resolution; omitted sharedHost retains stdio. No I/O, saved-state discovery, process startup, migration or ArcaneData/Repos change. Malformed selected appId/stateRoot/sharedHost inputs report TypeError; platform IPC errors remain operation-owned."
+      "normalization": "Returns a new complete context with only omitted stateRoot/workspaceRoot and selected sharedHost endpoint/log fields filled; preserves explicit values and additional payloads. Native launchContext presence opts generated entry into resolution; omitted sharedHost retains stdio. Optional coreListener:{endpoint} is preserved without endpoint defaults and attaches to that same window-owned runtime in the generated entry; selecting it together with sharedHost reports TypeError there. No I/O, saved-state discovery, process startup, migration or ArcaneData/Repos change. Malformed selected appId/stateRoot/sharedHost inputs report TypeError; platform IPC errors remain operation-owned."
     },
     {
       "id": "core-host:readCoreLaunchContext",
@@ -4628,6 +4628,20 @@
       "protocol": "arcane/1 over Content-Length framed stdio",
       "normalization": "Returns the existing {runtime,closed,close} transport owner; an optional abort signal invokes the same idempotent drain without killing the process, replacing service readiness or cancelling accepted service-lifetime work"
     },
+    {
+      "id": "core-host:startCoreListener",
+      "name": "startCoreListener",
+      "displayName": "startCoreListener()",
+      "kind": "function",
+      "signature": "startCoreListener({runtime,endpoint,onError}={})",
+      "entrypoints": ["arcane-os/core/host"],
+      "primaryImport": "arcane-os/core/host",
+      "group": "Shared Core host",
+      "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."
+    },
     {
       "id": "core-host:startSharedCoreHost",
       "name": "startSharedCoreHost",
@@ -4654,7 +4668,7 @@
       "summary": "Connects to one selected host and optionally starts an explicit headless entry when absent.",
       "availability": "Node local IPC and optional explicit child process with diagnostic file",
       "protocol": "arcane/1 Core client; optional Node startup IPC handshake",
-      "normalization": "Returns {client,endpoint,closed,close,shutdown}. Only ENOENT/ECONNREFUSED selects start {command,args,cwd,env,logFile}; no request retry. Close cancels this connection's request work while preserving the host and accepted service work. Explicit shutdown drains all clients' shared host; cancelling a launch wait does not kill the host"
+      "normalization": "Returns {client,endpoint,closed,close,shutdown}. Only ENOENT/ECONNREFUSED selects start {command,args,cwd,env,logFile}; no request retry. Close cancels this connection's request work while preserving the host and accepted service work. Explicit shutdown drains an owning shared host for all clients; cancelling a launch wait does not kill the host. Connect to startCoreListener with start omitted; that borrowed listener implements no core.host.shutdown operation and its runtime owner retains shutdown."
     },
     {
       "id": "core-host:runSharedCoreHost",

package/docs/reference/local-ai.md

@@ -420,9 +420,13 @@ unchanged, including on the final CPU attempt.
 Every loaded session includes an `execution` record in its ordinary state
 events: `preference`, `requestedTarget`, `resolvedDevice`, `resolution`,
 `reason`, `configuredTarget`, `observedTarget`, complete `supportedBackends`,
-`selectedProviders`, ordered `attempts` with their full errors, `fallback`, and
-`discoveryError`. Each attempt records provider names in `executionProviders`,
-its requested `configuredTarget`, `status` (`configured` or `failed`), and
+`selectedProviders`, ordered `attempts` with their full errors, `fallback`,
+`discoveryError`, and `deviceInventory`. The inventory retains the complete
+`{platform,state,devices,issues}` already obtained for that load's automatic
+physical selection. It is `null` when that load did not gather an inventory;
+retaining it performs no additional discovery. Each attempt records provider
+names in `executionProviders`, its requested `configuredTarget`, `status`
+(`configured` or `failed`), and
 `error`. The accepted top-level `configuredTarget` is
 `{source,executionProviders}`; it retains the complete provider options,
 including native numeric `deviceId` values. Its `source` is `cpu-default`,
@@ -531,6 +535,23 @@ String input containing U+0000 reports an incompatibility at the native tensor
 boundary: the Node binding uses null-terminated strings and cannot preserve
 that input completely. The SDK does not alter the supplied string.
 
+A failed run preserves the original error, stack, cause and additional fields,
+and adds the developer diagnostic `error.onnxRun`. It contains `sessionId`,
+`requestId`, `stage`, the original `model` path and `runtimeModulePath`, the
+session's complete `execution` record, `runOptions`, and input/output names and
+metadata. `stage` distinguishes `feed-conversion`, `fetch-conversion`,
+`session.run`, `output-conversion`, and `result-delivery`. `feeds` and `fetches`
+retain complete tensor types, dimensions and data through the existing Core tensor encoding;
+omitted options remain omitted at the JSON boundary. `feedsSource` and
+`fetchesSource` identify `request` records when conversion did not complete,
+or `converted` values prepared for `session.run`. No partial converted map is
+presented as the complete input. The actual input tensors are preserved without changes
+to inference, and successful runs create no diagnostic tensor copy. If building
+this diagnostic fails, its complete `diagnosticError` accompanies the fields
+obtained before that failure; the original run error remains the failure.
+Session metadata and feeds describe graph inputs, not internal node tensors
+that the native runtime has not reported.
+
 `current()` returns `{sessions,closed}`. `subscribe(listener)` replays current
 state synchronously and returns an unsubscribe function. Load, readiness,
 unload and failures remain observable. `unload({id,signal?})` releases that

package/docs/reference/native-decisions.md

@@ -336,6 +336,19 @@ progress includes model preparation, tokenization and evaluation; downloaded
 members report files, not byte progress. Complete technical errors belong in
 developer diagnostics, while the application owns its user-facing status.
 
+An ONNX run failure reaches the rejected evaluation and retained `error` in
+`current()`, `decisions.status`, and `decisions.state`, including the complete
+[`error.onnxRun` diagnostic](local-ai.md#native-onnx-sessions). This identifies
+the actual session, request, failure stage, model path, provider execution
+record, graph metadata and complete encoded feed tensors with their dimensions.
+The activation's `execution.execution.deviceInventory` retains the complete
+inventory consumed by automatic physical selection during its load, or `null`
+when that selection path did not gather one.
+Neither observation starts another hardware query or changes model execution.
+Retain these complete records in the selected developer inspection surface;
+ordinary user status remains application-owned. A retained error identifies
+that failed request and does not by itself establish that a later request failed.
+
 Concurrent callers selecting the same family, model, revision, dtype, source,
 mapping and target share one explicit activation.
 Cancelling a load or evaluation cancels that activation and its outstanding operations, because the

package/docs/reference/sdk-api.md

@@ -427,6 +427,7 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | `arcaneNativeBuilderProvider` | singleton | `arcane-os/native/portable-provider` | Portable native provider | Node; produces a portable payload rather than an executable host |
 | `arcaneNativeBuilderProvider default export` | singleton | `arcane-os/native/portable-provider` | Portable native provider | Node; produces a portable payload rather than an executable host |
 | `startCoreHost()` | function | `arcane-os/core/host` | Native Core host composition | Node with readable input and writable output streams |
+| `startCoreListener()` | function | `arcane-os/core/host` | Shared Core host | Node local IPC attached to an existing runtime |
 | `startSharedCoreHost()` | function | `arcane-os/core/host` | Shared Core host | Node local IPC on Windows, Linux and macOS |
 | `connectSharedCoreHost()` | function | `arcane-os/core/host` | Shared Core host | Node local IPC and optional explicit headless startup |
 | `connectAppControl()` | function | `arcane-os/core/app-control` | Native application control | Node local IPC; current window adapter is Windows WebView2 |
@@ -7394,6 +7395,14 @@ Import it from `arcane-os/core/runtime`. The runtime exposes `current()`,
 `subscribe()`, `onFrame()`, `emit()`, `registerService()`, `getService()`, `start()`, `handle()`
 and idempotent `close()`.
 
+`runtime.handle(frame, {contextRequestId})` optionally preserves a transport's
+original client ID in handler `context.requestId`, while `context.coreRequestId`
+always exposes the actual internal `frame.id`. Active requests, cancellation,
+response IDs and request-event envelopes retain that internal ID. Ordinary
+`handle(frame)` exposes both context IDs equal to `frame.id`. This metadata
+does not change parameters or event data; transports own client-facing protocol
+correlation. See [the runtime contract](core-runtime.md#state-and-frames).
+
 `await runtime.getService(name)` and service `context.getService(name)` return
 the actual registered service after its shared startup. They wait for that
 dependency alone, may start it before `runtime.start()`, and add no renderer or
@@ -7551,6 +7560,13 @@ Import it from `arcane-os/core/stdio`. The result is
 `{runtime, closed, close}`. EOF or input close starts graceful shutdown;
 `closed` settles only after accepted runtime work and queued output settle.
 
+Responses, request events, cancellation controls and current-state replay are
+connection-scoped even when an additional IPC listener shares the runtime.
+Stdio preserves original handler `requestId` values while routing fresh internal
+IDs; uncorrelated service events remain shared. EOF retains its existing
+runtime-wide shutdown ownership. Additional clients attach through
+[`startCoreListener()`](#startcorelistener).
+
 ### Availability and normalization
 
 **Node with readable input and writable output streams.** Parser, input, output
@@ -7995,6 +8011,14 @@ the caller's working-directory meaning. `appId` and the selected state path
 must be nonempty strings; a selected `sharedHost` must be an object. Malformed
 inputs report `TypeError`; native endpoint failures belong to the IPC operation.
 
+`native.launchContext.coreListener:{endpoint}` instead attaches local IPC to
+the existing window/stdio runtime. Its endpoint remains explicit and receives
+no default. The generated entry rejects simultaneous `coreListener` and
+`sharedHost` selections. Client disconnect affects that connection; window
+shutdown still drains Core and closes the additional listener. See
+[`startCoreListener()`](#startcorelistener) and
+[native launch locations](core-native-packaging.md#launch-time-locations).
+
 ```javascript
 import {resolveNativeLaunchContext} from 'arcane-os/core/host';
 
@@ -8793,6 +8817,59 @@ async function bundleMoonCheeseRuntime(outputRoot){
 The ordinary provider invokes this owner only for an explicit native local-AI
 selection. See [selected local-AI runtimes](core-native-packaging.md#selected-local-ai-runtimes).
 
+## startCoreListener()
+
+### Overview and signature
+
+Attaches a local IPC listener to an existing Core runtime, without creating,
+starting or taking ownership of that runtime or its services.
+
+```text
+startCoreListener({runtime,endpoint,onError}={})
+```
+
+Import from `arcane-os/core/host`. Resolves `{endpoint,closed,close}` after the
+selected endpoint binds. `close()` is idempotent, cancels the listener's
+request-lifetime work, flushes queued output and closes its connections. It
+does not call `runtime.close()` or wait for accepted service-lifetime work;
+that work remains tracked by the existing runtime. Runtime shutdown rejects
+new listener requests, retains the endpoint through service drain/disposal,
+and closes the listener automatically. Observe both owners' `closed` promises.
+Bind errors reject startup without closing the supplied runtime. Transport
+errors reach `onError`, with complete console diagnostics by default; terminal
+listener errors reject `closed`. Attaching to a draining/closed runtime reports
+`CORE_CLOSING`.
+
+Node supports named pipes on Windows and Unix-domain sockets on Linux/macOS;
+Android requires its host adaptation. Supply a nonempty endpoint and an existing
+parent directory where required. Connect with `connectSharedCoreHost({endpoint})`
+and omit `start`. Its current-runtime replay does not replay requests. The
+borrowed listener implements no `core.host.shutdown` operation; use client
+`close()` for disconnection and the existing runtime's owner for host shutdown.
+
+Each connection owns response/event correlation and request cancellation.
+Handler `requestId` preserves the client ID; `coreRequestId` is the distinct
+internal dispatch ID. Parameters, results and event data, including
+`data.requestId`, remain unchanged. Runtime-state snapshots retain internal
+active IDs; no service event is invented or retained for later replay.
+
+```js
+import {startCoreListener} from 'arcane-os/core/host';
+
+const listener = await startCoreListener({runtime: host.runtime, endpoint: selectedEndpoint});
+try {
+    await host.closed;
+} finally {
+    await listener.close();
+}
+```
+
+`host` is the application's existing stdio host. Generated native entries
+select this attachment with `native.launchContext.coreListener:{endpoint}`,
+preserving their actual runtime, service set, profile, origin and state root.
+Omit `sharedHost`; the two options describe alternative lifetimes. Full
+contract: [existing-runtime listener](core-shared-host.md#attach-to-an-existing-window-owned-core).
+
 ## startSharedCoreHost()
 
 ### Overview
@@ -8871,6 +8948,12 @@ not kill a host another client may use. No startup timeout is imposed; supply
 before disconnecting. It affects every client; cancellation after acceptance
 does not reverse it. A drain failure returns the full Core error.
 
+The same connector can attach to `startCoreListener()` with `start` omitted.
+There, `close()` still disconnects only this client, and `shutdown()` has no
+listener-owned operation: absent an application method of that name, the
+ordinary dispatcher returns `METHOD_NOT_ALLOWED`. The existing window/runtime
+owner remains responsible for shutdown.
+
 ```js
 import {connectSharedCoreHost} from 'arcane-os/core/host';
 
@@ -8967,9 +9050,10 @@ stdio-owned Core lifetime. See [native shared-host launch](core-shared-host.md#n
 
 ## startCoreHost()
 
-For independent UI and MCP processes sharing one application runtime, use the
-[shared host functions](#startsharedcorehost) above. Ordinary `startCoreHost()`
-retains its existing stdio-owned lifetime.
+For an external client of the actual window-owned runtime, attach
+[`startCoreListener()`](#startcorelistener) to `host.runtime`. For an explicitly
+independent headless lifetime, use the [shared host functions](#startsharedcorehost).
+Ordinary `startCoreHost()` retains its existing stdio-owned lifetime.
 
 ### Overview
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.83.0",
+  "version": "0.84.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

package/src/core/host.mjs

@@ -5,7 +5,7 @@ import Is from 'strong-type';
 import {createCoreRuntime} from './runtime.mjs';
 import {startCoreStdio} from './stdio.mjs';
 
-export {startSharedCoreHost, connectSharedCoreHost, runSharedCoreHost, startSharedCoreBridge} from './shared-host.mjs';
+export {startCoreListener, startSharedCoreHost, connectSharedCoreHost, runSharedCoreHost, startSharedCoreBridge} from './shared-host.mjs';
 
 const is = new Is(false);