arcane-os 0.83.1 → 0.84.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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`,

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.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/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.1",
+  "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);
 

package/src/core/runtime-connection.mjs

@@ -0,0 +1,165 @@
+import {randomUUID} from 'node:crypto';
+import Is from 'strong-type';
+import {CORE_PROTOCOL, CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
+
+const is = new Is(false);
+const owners = new WeakMap();
+
+function failure(code, message) {
+    return new CoreError({code, message});
+}
+
+function event(event, data) {
+    return {protocol: CORE_PROTOCOL, type: 'event', event, data, time: new Date().toISOString()};
+}
+
+function runtimeConnections(runtime) {
+    const existing = owners.get(runtime);
+    if (existing) return existing;
+    const connections = new Set();
+    const requests = new Map();
+    const prefix = `connection-${randomUUID()}:`;
+    let sequence = 0;
+
+    function route(frame) {
+        if (frame.type === 'response') {
+            const record = requests.get(frame.id);
+            if (record) {
+                record.release();
+                record.connection.send({...frame, id: record.id}, record);
+            }
+            return;
+        }
+        if (frame.type !== 'event') return;
+        if (Object.hasOwn(frame, 'requestId')) {
+            const record = requests.get(frame.requestId);
+            if (record) record.connection.send({...frame, requestId: record.id}, record);
+            return;
+        }
+        for (const connection of connections) connection.send(frame);
+    }
+
+    const unsubscribe = runtime.onFrame(route);
+    const owner = {
+        connections,
+        requests,
+        allocate(requestPrefix) {
+            // Every acceptance gets a fresh transport correlation. A retired
+            // service context must never target a later use of its client ID.
+            const active = runtime.current().activeRequests;
+            function inUse(candidate) {
+                return requests.has(candidate) || active.some(
+                    function activeRequest(request) { return request.id === candidate; }
+                );
+            }
+            let internalId;
+            do {
+                internalId = `${requestPrefix ?? ''}${prefix}${++sequence}`;
+            } while (inUse(internalId));
+            return internalId;
+        },
+        release() {
+            if (connections.size || requests.size) return;
+            unsubscribe();
+            owners.delete(runtime);
+        }
+    };
+    owners.set(runtime, owner);
+    return owner;
+}
+
+/** One transport connection borrows dispatch; only its host owns runtime.close. */
+export function createCoreRuntimeConnection({
+    runtime, send, requestPrefix, mapFrame, getReplayEvents, preserveContextRequestId = true
+}) {
+    const owner = runtimeConnections(runtime);
+    const requests = new Map();
+    const internalRequests = new Map();
+    let disconnected = false;
+
+    function deliver(frame, record) {
+        if (disconnected) return;
+        const outgoing = mapFrame ? mapFrame(frame, record) : frame;
+        if (outgoing !== undefined) send(outgoing);
+    }
+
+    function cancel(record) {
+        return runtime.handle(
+            {protocol: CORE_PROTOCOL, type: 'control', control: 'request.cancel', requestId: record.internalId}
+        );
+    }
+
+    function cancelAll() {
+        return Promise.all([...requests.values()].map(cancel));
+    }
+
+    function replay() {
+        const state = runtime.current();
+        if (state.state === 'ready') deliver(event('core.ready', {version: state.version, app: state.application}));
+        deliver(event('core.state', state));
+        for (const service of state.services) deliver(event('core.service.state', service));
+        // Only the existing owner's current snapshots, never requests/history.
+        for (const snapshot of getReplayEvents?.() ?? []) deliver(event(snapshot.event, snapshot.data));
+    }
+
+    async function handle(frame) {
+        if (disconnected) throw failure('CORE_CONNECTION_CLOSED', 'The Core connection is closed.');
+        if (frame?.protocol !== CORE_PROTOCOL) throw failure('INVALID_RPC_REQUEST', 'Unknown Core protocol.');
+        if (frame.type === 'control') {
+            if (frame.control === 'runtime.replay') return replay();
+            if (frame.control === 'requests.cancelAll') return cancelAll();
+            if (frame.control === 'request.cancel') {
+                const record = requests.get(frame.requestId);
+                return record ? cancel(record) : undefined;
+            }
+            throw failure('INVALID_RPC_CONTROL', 'Unknown Core control.');
+        }
+        if (frame.type !== 'request' || !is.string(frame.id) || !frame.id || !is.string(frame.method)) {
+            throw failure('INVALID_RPC_REQUEST', 'A Core request requires an id and method.');
+        }
+        if (requests.has(frame.id)) {
+            const answer = {protocol: CORE_PROTOCOL, type: 'response', id: frame.id, ok: false,
+                error: serializeCoreError(failure('RPC_REQUEST_ID_ACTIVE', 'The request id is already active on this connection.')),
+                time: new Date().toISOString()};
+            deliver(answer);
+            return answer;
+        }
+        const record = {connection, id: frame.id, internalId: owner.allocate(requestPrefix), release: releaseRequest};
+        function releaseRequest() {
+            if (requests.get(record.id) === record) requests.delete(record.id);
+            internalRequests.delete(record.internalId);
+            owner.requests.delete(record.internalId);
+            owner.release();
+        }
+        requests.set(record.id, record);
+        internalRequests.set(record.internalId, record);
+        owner.requests.set(record.internalId, record);
+        try {
+            return await runtime.handle(
+                {...frame, id: record.internalId},
+                preserveContextRequestId ? {contextRequestId: record.id} : undefined
+            );
+        } finally {
+            releaseRequest();
+        }
+    }
+
+    function close() {
+        if (disconnected) return Promise.resolve();
+        disconnected = true;
+        owner.connections.delete(connection);
+        const cancellation = cancelAll();
+        owner.release();
+        return cancellation;
+    }
+
+    const connection = {
+        handle,
+        close,
+        send: deliver,
+        has(id) { return requests.has(id); },
+        request(internalId) { return internalRequests.get(internalId); }
+    };
+    owner.connections.add(connection);
+    return connection;
+}

package/src/core/runtime.mjs

@@ -218,7 +218,7 @@ class CoreRuntime {
         return this.current();
     }
 
-    async handle(frame) {
+    async handle(frame, {contextRequestId} = {}) {
         if (frame?.protocol !== CORE_PROTOCOL) throw failure('INVALID_RPC_REQUEST', 'Unknown Core protocol.');
         if (frame.type === 'control') {
             if (frame.control === 'runtime.replay') {
@@ -235,7 +235,10 @@ class CoreRuntime {
         if (frame.type !== 'request' || !is.string(frame.id) || !frame.id || !is.string(frame.method)) {
             throw failure('INVALID_RPC_REQUEST', 'A Core request requires an id and method.');
         }
-        const task = this.#answer(frame);
+        if (contextRequestId !== undefined && (!is.string(contextRequestId) || !contextRequestId)) {
+            throw failure('INVALID_RPC_REQUEST', 'A transport context request id must be a nonempty string.');
+        }
+        const task = this.#answer(frame, contextRequestId);
         this.#responses.add(task);
         try {
             return await task;
@@ -244,7 +247,7 @@ class CoreRuntime {
         }
     }
 
-    async #answer(frame) {
+    async #answer(frame, contextRequestId) {
         let result;
         let error;
         let ok = true;
@@ -254,7 +257,7 @@ class CoreRuntime {
             if (frame.method === 'system.ping') result = {ok: true};
             else if (frame.method === 'version.current') result = this.#version;
             else if (frame.method === 'app.current') result = this.#application;
-            else result = await this.#request(frame);
+            else result = await this.#request(frame, contextRequestId);
         } catch (caught) {
             ok = false;
             error = caught;
@@ -270,7 +273,7 @@ class CoreRuntime {
         return response;
     }
 
-    #request(frame) {
+    #request(frame, contextRequestId) {
         const registration = this.#methods.get(frame.method);
         if (!registration) {
             const namespace = frame.method.split('.')[0];
@@ -300,7 +303,8 @@ class CoreRuntime {
                     const result = await handle.call(
                         service.definition,
                         frame.parameters,
-                        {...runtime.#serviceContext(service, frame.id), requestId: frame.id, signal: controller.signal}
+                        {...runtime.#serviceContext(service, frame.id),
+                            requestId: contextRequestId ?? frame.id, coreRequestId: frame.id, signal: controller.signal}
                     );
                     aborted(controller);
                     return result;

package/src/core/shared-host.mjs

@@ -2,10 +2,14 @@ import {spawn} from 'node:child_process';
 import {open} from 'node:fs/promises';
 import {createServer} from 'node:net';
 import {randomUUID} from 'node:crypto';
+import Is from 'strong-type';
 import {CORE_PROTOCOL, CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
 import {createCoreRuntime} from './runtime.mjs';
 import {createCoreFrameDecoder, encodeCoreFrame} from './stdio.mjs';
 import {connectCoreSocket, createCoreSocketConnection, writeCoreSocket as write} from './socket-connection.mjs';
+import {createCoreRuntimeConnection} from './runtime-connection.mjs';
+
+const is = new Is(false);
 
 function failure(code, message) { return new CoreError({code, message}); }
 function reportError(error) { console.error('Shared Arcane Core failed:', error); }
@@ -23,6 +27,233 @@ function response(id, result, error) {
         time: new Date().toISOString()};
 }
 
+/** Add local IPC to an existing runtime without acquiring its lifetime. */
+export async function startCoreListener({runtime, endpoint, onError = reportError} = {}) {
+    if (!is.string(endpoint) || !endpoint) throw new TypeError('A Core listener endpoint must be a nonempty local pipe/socket path.');
+    if (!runtime || !is.function(runtime.handle) || !is.function(runtime.onFrame)
+        || !is.function(runtime.current) || !is.function(runtime.subscribe)) {
+        throw new TypeError('A Core listener requires an existing Core runtime.');
+    }
+    if (['draining', 'closed'].includes(runtime.current().state)) throw failure('CORE_CLOSING', 'Core is closing.');
+    const peers = new Set();
+    const prefix = `listener-${randomUUID()}:`;
+    let accepting = true;
+    let closing;
+    let terminalError;
+    let resolveClosed;
+    let rejectClosed;
+    let resolveRuntimeClosed;
+    const runtimeClosed = new Promise(
+        function observeRuntimeClosure(resolve) { resolveRuntimeClosed = resolve; }
+    );
+    const closed = new Promise(
+        function ownListener(resolve, reject) {
+            resolveClosed = resolve;
+            rejectClosed = reject;
+        }
+    );
+    closed.catch(function observeReportedListenerFailure() {});
+
+    function diagnostic(error) {
+        report(onError, error);
+    }
+
+    function disconnect(peer) {
+        if (peer.closed) return;
+        peer.closed = true;
+        peers.delete(peer);
+        peer.connection.close().catch(diagnostic);
+    }
+
+    function send(peer, frame) {
+        if (peer.closed) return;
+        let content;
+        try {
+            content = encodeCoreFrame(frame);
+        } catch (error) {
+            diagnostic(error);
+            peer.socket.destroy();
+            return;
+        }
+        peer.writes = peer.writes.then(
+            function writeNext() {
+                if (!peer.closed) return write(peer.socket, content);
+            }
+        ).catch(
+            function outputFailed(error) {
+                diagnostic(error);
+                peer.socket.destroy();
+            }
+        );
+    }
+
+    function accept(socket) {
+        const peer = {socket, closed: false, writes: Promise.resolve(), connection: null};
+        peers.add(peer);
+        peer.connection = createCoreRuntimeConnection(
+            {
+                runtime,
+                requestPrefix: prefix,
+                send(frame) { send(peer, frame); }
+            }
+        );
+        const decoder = createCoreFrameDecoder(
+            function receiveFrame(frame) {
+                if (peer.closed) return;
+                if (!accepting && frame?.type === 'request') {
+                    send(peer, response(frame.id, undefined, failure('CORE_CLOSING', 'The Core listener is closing.')));
+                    return;
+                }
+                // No owning-host shutdown command or application dispatcher.
+                peer.connection.handle(frame).catch(
+                    function requestFailed(error) {
+                        if (frame?.type === 'request') send(peer, response(frame.id, undefined, error));
+                        else send(peer, event('core.error', serializeCoreError(error)));
+                    }
+                );
+            }
+        );
+        socket.on(
+            'data',
+            function receiveData(chunk) {
+                try {
+                    decoder.push(chunk);
+                } catch (error) {
+                    diagnostic(error);
+                    socket.destroy();
+                }
+            }
+        );
+        socket.on('error', diagnostic);
+        socket.on(
+            'end',
+            function inputEnded() {
+                try {
+                    decoder.finish();
+                } catch (error) {
+                    diagnostic(error);
+                }
+                disconnect(peer);
+            }
+        );
+        socket.on('close', function connectionClosed() { disconnect(peer); });
+        socket.resume();
+    }
+
+    const server = createServer({pauseOnConnect: true}, accept);
+    const binding = new Promise(
+        function claimEndpoint(resolve, reject) {
+            function failed(error) {
+                server.off('listening', listening);
+                reject(error);
+            }
+            function listening() {
+                server.off('error', failed);
+                resolve();
+            }
+            server.once('error', failed);
+            server.once('listening', listening);
+            server.listen({path: endpoint});
+        }
+    );
+
+    function close() {
+        if (closing) return closed;
+        accepting = false;
+        closing = Promise.resolve().then(
+            async function closeListener() {
+                try {
+                    await binding;
+                } catch (error) {
+                    terminalError ??= error;
+                }
+                // Window/Core shutdown retains the endpoint through service
+                // drain. Closing this listener never initiates runtime.close().
+                if (runtime.current().state === 'draining') await runtimeClosed;
+                const stopped = new Promise(
+                    function stopListening(resolve, reject) {
+                        server.close(
+                            function listenerClosed(error) {
+                                if (error && error.code !== 'ERR_SERVER_NOT_RUNNING') reject(error);
+                                else resolve();
+                            }
+                        );
+                    }
+                );
+                stopped.catch(function observeListenerStopFailure() {});
+                const connected = [...peers];
+                const cancellations = await Promise.allSettled(
+                    connected.map(
+                        function detachConnection(peer) {
+                            peer.socket.pause();
+                            return peer.connection.close();
+                        }
+                    )
+                );
+                for (const outcome of cancellations) {
+                    if (outcome.status === 'rejected') {
+                        terminalError = terminalError
+                            ? new AggregateError([terminalError, outcome.reason], 'Core listener closure failed.')
+                            : outcome.reason;
+                    }
+                }
+                await Promise.all(connected.map(function flushConnection(peer) { return peer.writes; }));
+                for (const peer of connected) {
+                    peer.socket.resume();
+                    peer.socket.end();
+                }
+                await stopped;
+                if (terminalError) throw terminalError;
+                return {state: 'closed', endpoint};
+            }
+        );
+        closing.then(
+            function listenerClosed(result) {
+                unsubscribe();
+                resolveClosed(result);
+            },
+            function listenerFailed(error) {
+                unsubscribe();
+                diagnostic(error);
+                rejectClosed(error);
+            }
+        );
+        return closed;
+    }
+
+    const unsubscribe = runtime.subscribe(
+        function runtimeChanged(state) {
+            if (state.state === 'draining') accepting = false;
+            if (state.state === 'closed') {
+                resolveRuntimeClosed();
+                close();
+            }
+        }
+    );
+    server.on(
+        'error',
+        function listenerFailed(error) {
+            terminalError = error;
+            close();
+        }
+    );
+    try {
+        await binding;
+        if (!accepting) {
+            await close();
+            throw failure('CORE_CLOSING', 'Core closed while its listener was starting.');
+        }
+        return {endpoint, closed, close};
+    } catch (error) {
+        try {
+            await close();
+        } catch (closeError) {
+            if (closeError !== error) throw new AggregateError([error, closeError], 'Core listener startup and cleanup failed.');
+        }
+        throw error;
+    }
+}
+
 /** Claim one app-selected pipe/socket before importing or creating services. */
 export async function startSharedCoreHost({
     endpoint, application, version, configure, getReplayEvents, signal, onError = reportError
@@ -30,13 +261,10 @@ export async function startSharedCoreHost({
     signal?.throwIfAborted();
     if (typeof endpoint !== 'string' || !endpoint) throw new TypeError('A shared Core endpoint must be a nonempty local pipe/socket path.');
     const peers = new Set();
-    const requests = new Map();
     const incoming = new Set();
     const lifetime = new AbortController();
     const prefix = `shared-${randomUUID()}:`;
-    let sequence = 0;
     let runtime;
-    let unsubscribe;
     let closing;
     let preparation = Promise.resolve();
     let ready = false;
@@ -65,89 +293,61 @@ export async function startSharedCoreHost({
             if (!peer.closed) return write(peer.socket, content);
         }).catch(function outputFailed(error) { diagnostic(error); peer.socket.destroy(); });
     }
-    function cancel(record) {
-        observe(runtime.handle({protocol: CORE_PROTOCOL, type: 'control',
-            control: 'request.cancel', requestId: record.internalId}));
-    }
     function disconnect(peer) {
         if (peer.closed) return;
         peer.closed = true;
         peers.delete(peer);
-        for (const record of peer.requests.values()) cancel(record);
-    }
-    function stateFor(peer, state) {
-        return {...state, activeRequests: state.activeRequests.map(function requestState(record) {
-            const owned = requests.get(record.id);
-            return owned?.peer === peer ? {...record, id: owned.id} : record;
-        })};
-    }
-    function replay(peer) {
-        const state = runtime.current();
-        if (state.state === 'ready') send(peer, event('core.ready', {version: state.version, app: state.application}));
-        send(peer, event('core.state', stateFor(peer, state)));
-        for (const service of state.services) send(peer, event('core.service.state', service));
-        // Domain snapshots belong to the app/service owner, never event history.
-        for (const snapshot of getReplayEvents?.() ?? []) send(peer, event(snapshot.event, snapshot.data));
+        if (peer.connection) observe(peer.connection.close());
     }
-    function route(frame) {
-        if (frame.type === 'response') {
-            const record = requests.get(frame.id);
-            if (record) send(record.peer, {...frame, id: record.id});
-            return;
-        }
-        if (frame.type !== 'event') return;
-        if (Object.hasOwn(frame, 'requestId')) {
-            const owned = requests.get(frame.requestId);
-            if (owned) send(owned.peer, {...frame, requestId: owned.id,
-                data: frame.data?.requestId === owned.internalId ? {...frame.data, requestId: owned.id} : frame.data});
-            return;
-        }
-        const id = frame.data?.requestId;
-        const record = requests.get(id);
-        if (record) {
-            send(record.peer, {...frame, data: {...frame.data, requestId: record.id}});
-            return;
-        }
-        // A retired transport correlation is not a new app-wide event.
-        if (typeof id === 'string' && id.startsWith(prefix)) return;
-        for (const peer of peers) send(peer, frame.event === 'core.state'
-            ? {...frame, data: stateFor(peer, frame.data)} : frame);
+    function attach(peer) {
+        peer.connection = createCoreRuntimeConnection(
+            {
+                runtime,
+                requestPrefix: prefix,
+                preserveContextRequestId: false,
+                getReplayEvents,
+                send(frame) { send(peer, frame); },
+                mapFrame(frame, record) {
+                    // Preserve this owning adapter's established data correlation.
+                    // The borrowed listener and stdio never apply this mapping.
+                    if (record) {
+                        return frame.type === 'event' && frame.data?.requestId === record.internalId
+                            ? {...frame, data: {...frame.data, requestId: record.id}} : frame;
+                    }
+                    if (frame.event === 'core.state') {
+                        return {...frame, data: {...frame.data, activeRequests: frame.data.activeRequests.map(
+                            function requestState(request) {
+                                const owned = peer.connection.request(request.id);
+                                return owned ? {...request, id: owned.id} : request;
+                            }
+                        )}};
+                    }
+                    const id = frame.data?.requestId;
+                    const owned = peer.connection.request(id);
+                    if (owned) return {...frame, data: {...frame.data, requestId: owned.id}};
+                    // A retired transport correlation is not a new app-wide event.
+                    if (is.string(id) && id.startsWith(prefix)) return;
+                    return frame;
+                }
+            }
+        );
     }
     async function dispatch(peer, frame) {
         if (frame?.protocol !== CORE_PROTOCOL) throw failure('INVALID_RPC_REQUEST', 'Unknown Core protocol.');
         if (frame.type === 'control') {
-            if (frame.control === 'runtime.replay') { replay(peer); return; }
-            if (frame.control === 'request.cancel') {
-                const record = peer.requests.get(frame.requestId);
-                if (record) cancel(record);
-                return;
-            }
-            if (frame.control === 'requests.cancelAll') {
-                for (const record of peer.requests.values()) cancel(record);
-                return;
-            }
-            throw failure('INVALID_RPC_CONTROL', 'Unknown Core control.');
+            return peer.connection.handle(frame);
         }
         if (frame.type !== 'request' || typeof frame.id !== 'string' || !frame.id || typeof frame.method !== 'string') {
             throw failure('INVALID_RPC_REQUEST', 'A Core request requires an id and method.');
         }
-        if (peer.requests.has(frame.id)) throw failure('RPC_REQUEST_ID_ACTIVE', 'The request id is already active on this connection.');
+        if (peer.connection.has(frame.id)) throw failure('RPC_REQUEST_ID_ACTIVE', 'The request id is already active on this connection.');
         if (frame.method === 'core.host.shutdown') {
             peer.shutdownIds.push(frame.id);
             close();
             return;
         }
         if (closing) throw failure('CORE_CLOSING', 'Core is closing.');
-        const record = {peer, id: frame.id, internalId: `${prefix}${++sequence}`};
-        peer.requests.set(record.id, record);
-        requests.set(record.internalId, record);
-        try {
-            // Only protocol correlation changes; parameters remain untouched.
-            await runtime.handle({...frame, id: record.internalId});
-        } finally {
-            peer.requests.delete(record.id);
-            requests.delete(record.internalId);
-        }
+        return peer.connection.handle(frame);
     }
     function receive(peer, frame) {
         if (peer.closed) return;
@@ -157,8 +357,9 @@ export async function startSharedCoreHost({
         }));
     }
     function accept(socket) {
-        const peer = {socket, requests: new Map(), shutdownIds: [], closed: false, writes: Promise.resolve()};
+        const peer = {socket, connection: null, shutdownIds: [], closed: false, writes: Promise.resolve()};
         peers.add(peer);
+        if (runtime) attach(peer);
         const decoder = createCoreFrameDecoder(function receiveFrame(frame) { receive(peer, frame); });
         socket.on('data', function data(chunk) {
             try { decoder.push(chunk); } catch (error) { diagnostic(error); socket.destroy(); }
@@ -196,7 +397,6 @@ export async function startSharedCoreHost({
             await Promise.all([...peers].map(function drainWrites(peer) { return peer.writes; }));
             for (const peer of peers) { peer.socket.resume(); peer.socket.end(); }
             await stopped;
-            unsubscribe?.();
             signal?.removeEventListener('abort', abortHost);
             if (error) throw error;
             return runtime?.current() ?? {state: 'closed'};
@@ -222,7 +422,7 @@ export async function startSharedCoreHost({
         // The endpoint is already owned. A losing launcher never calls configure.
         signal?.throwIfAborted();
         runtime = createCoreRuntime({application, version});
-        unsubscribe = runtime.onFrame(route);
+        for (const peer of peers) attach(peer);
         signal?.addEventListener('abort', abortHost, {once: true});
         preparation = Promise.resolve().then(function configureClaimedHost() {
             lifetime.signal.throwIfAborted();

package/src/core/stdio.mjs

@@ -1,6 +1,7 @@
 import {finished} from 'node:stream';
 import Is from 'strong-type';
 import {CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
+import {createCoreRuntimeConnection} from './runtime-connection.mjs';
 
 const is = new Is(false);
 
@@ -116,10 +117,24 @@ export function startCoreStdio({runtime, input = process.stdin, output = process
         ).catch(failOutput);
     }
 
-    const unsubscribe = runtime.onFrame(queueFrame);
+    const connection = createCoreRuntimeConnection(
+        {
+            runtime,
+            send: queueFrame,
+            mapFrame(frame) {
+                if (frame.event !== 'core.state') return frame;
+                return {...frame, data: {...frame.data, activeRequests: frame.data.activeRequests.map(
+                    function requestState(request) {
+                        const owned = connection.request(request.id);
+                        return owned ? {...request, id: owned.id} : request;
+                    }
+                )}};
+            }
+        }
+    );
 
     function receiveFrame(frame) {
-        const task = runtime.handle(frame);
+        const task = connection.handle(frame);
         pending.add(task);
         task.then(
             function requestSettled() {
@@ -157,7 +172,7 @@ export function startCoreStdio({runtime, input = process.stdin, output = process
     }
 
     async function releaseTransportListeners() {
-        unsubscribe();
+        await connection.close();
         output.off('error', failOutput);
         // destroy(error) marks a stream destroyed before its scheduled error
         // and close events. The native completion owner observes their delivery;

package/src/native/portable-layout.mjs

@@ -203,7 +203,7 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         "import path from 'node:path';",
         "import {isSea} from 'node:sea';",
         ...(launchDefaults === undefined ? [] : ["import {mkdir} from 'node:fs/promises';"]),
-        "import {readCoreLaunchContext, startCoreHost, runSharedCoreHost, startSharedCoreBridge} from 'arcane-os/core/host';",
+        "import {readCoreLaunchContext, startCoreHost, startCoreListener, runSharedCoreHost, startSharedCoreBridge} from 'arcane-os/core/host';",
         '',
         ...(localAI === undefined ? [] : [
             '// Bundled runtime paths are artifact-root-relative POSIX paths.',
@@ -249,6 +249,10 @@ export function coreEntrySource(application, version, services, {localAI, runtim
             : `    ...await readCoreLaunchContext({appId: ${JSON.stringify(application.id)}, defaults: JSON.parse(${JSON.stringify(JSON.stringify(launchDefaults))})})`,
         '};',
         '',
+        'if (context.coreListener !== undefined && context.sharedHost !== undefined) {',
+        "    throw new TypeError('coreListener attaches to the window-owned Core; sharedHost selects its separate owning host.');",
+        '}',
+        '',
         ...(launchDefaults === undefined ? [] : [
             '// The shared endpoint and diagnostic log require their selected state directory.',
             'if (context.sharedHost !== undefined) await mkdir(context.stateRoot, {recursive: true});',
@@ -284,10 +288,29 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         `const application = JSON.parse(${JSON.stringify(JSON.stringify(application))});`,
         `const version = ${JSON.stringify(version)};`,
         'let host;',
+        'let listener;',
         'if (context.sharedHost === undefined) {',
         '    const services = [];',
         '    await createServices(function register(service) { services.push(service); });',
         '    host = startCoreHost({application, version, services});',
+        '    if (context.coreListener !== undefined) {',
+        "        process.on('SIGINT', closeCore);",
+        "        process.on('SIGTERM', closeCore);",
+        '        try {',
+        '            listener = await startCoreListener({runtime: host.runtime, endpoint: context.coreListener?.endpoint});',
+        '            listener.closed.catch(function listenerFailed() { process.exitCode = 1; });',
+        '        } catch (error) {',
+        '            try {',
+        '                await host.close();',
+        '            } catch (closeError) {',
+        "                throw new AggregateError([error, closeError], 'Core listener startup and host drain failed.');",
+        '            }',
+        '            throw error;',
+        '        } finally {',
+        "            process.off('SIGINT', closeCore);",
+        "            process.off('SIGTERM', closeCore);",
+        '        }',
+        '    }',
         "} else if (process.argv.includes('--arcane-core-headless')) {",
         '    host = await runSharedCoreHost({',
         '        endpoint: context.sharedHost.endpoint, application, version,',
@@ -319,6 +342,12 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         "    console.error('Arcane Core host failed:', error);",
         '    process.exitCode = 1;',
         '} finally {',
+        '    try {',
+        '        await listener?.close();',
+        '    } catch {',
+        '        // The listener reports its complete failure through onError.',
+        '        process.exitCode = 1;',
+        '    }',
         "    process.off('SIGINT', closeCore);",
         "    process.off('SIGTERM', closeCore);",
         '}',