@camstack/addon-pipeline 1.1.27 → 1.1.29

package/dist/detection-pipeline/index.mjs

@@ -1,103 +1,13 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { B as errMsg, E as hfModelUrl, F as runtimeDevices$1, G as EventCategory, J as createEvent, M as pipelineExecutorCapability, Q as parseJsonUnknown, R as supportedRuntimes$1, S as defaultDeviceFor$1, T as evaluateZoneRules, V as BaseAddon, Y as hydrateSchema, a as COCO_TO_MACRO, i as COCO_80_LABELS, j as nodePin, m as YAMNET_TO_MACRO, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, tt as sleep, w as detectionPipelineCapability } from "../dist-CgEP_0OL.mjs";
+import { $ as sleep, B as errMsg, E as hfModelUrl, F as runtimeDevices$1, G as EventCategory, K as createEvent, M as pipelineExecutorCapability, R as supportedRuntimes$1, S as defaultDeviceFor$1, T as evaluateZoneRules, V as BaseAddon, X as parseJsonUnknown, a as COCO_TO_MACRO, i as COCO_80_LABELS, m as YAMNET_TO_MACRO, q as hydrateSchema, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, w as detectionPipelineCapability } from "../dist-DjuGmyG9.mjs";
+import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { a as isModelDownloaded, i as ensureModel, n as deleteModelFromDisk } from "../model-download-service-C-IHWnXx-BPy6aoAx.mjs";
+import { FrameRingReaderCache } from "@camstack/shm-ring";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import * as os from "node:os";
 import { spawn } from "node:child_process";
 import sharp from "sharp";
-//#region src/detection-pipeline/engine-store-keys.ts
-/**
-* Per-node scoping for the detection-pipeline engine cascade.
-*
-* The detection addon's settings store is a single CLUSTER-SHARED blob (the
-* settings-store cap is hub-resident; every node's detection instance reads and
-* writes the same keys). That is correct for node-agnostic settings (pipeline
-* steps, tuning) but WRONG for the engine cascade — `engineBackend` /
-* `engineDevice` / `probedBestEngine` are hardware-specific, so the hub (NPU)
-* and a remote agent (iGPU, or no accelerator at all) must hold INDEPENDENT
-* selections. Sharing them lets one node's pick (e.g. `openvino/npu`) override
-* another node that has no NPU.
-*
-* These three keys are therefore persisted node-scoped as `<key>@<nodeId>`.
-* Everything else in the store stays shared. A legacy un-scoped value (written
-* before this change, or by an older build) is read as a migration fallback
-* for the HUB ONLY — the pre-scoping store was only ever written by a
-* hub-only deployment, so serving the bare value to any other node leaks the
-* hub's hardware pick (e.g. `openvino/auto`) onto a node that cannot run it
-* (the CB3 "Mac runs OpenVINO" / N100 AUTO-device bug). A non-hub node with
-* no scoped key reads `undefined`, which drives its own auto-pick.
-*/
-var ENGINE_CASCADE_KEYS = [
-	"engineBackend",
-	"engineDevice",
-	"probedBestEngine"
-];
-function isEngineCascadeKey(key) {
-	return ENGINE_CASCADE_KEYS.includes(key);
-}
-/**
-* Normalise a raw kernel node id to the bare node id used for scoping.
-* `localNodeId` can carry a `<node>/<addon>` suffix; the engine selection is
-* per-NODE, so strip the addon segment. Falls back to `hub`.
-*/
-function normalizeEngineNodeId(rawNodeId) {
-	const raw = rawNodeId ?? "hub";
-	return raw.includes("/") ? raw.split("/")[0] ?? "hub" : raw;
-}
-/** The node-scoped store key for an engine cascade field. */
-function nodeEngineKey(base, nodeId) {
-	return `${base}@${normalizeEngineNodeId(nodeId)}`;
-}
-/**
-* Read an engine cascade value for a node: the node-scoped key if present,
-* otherwise — for the HUB only — the legacy un-scoped value (migration),
-* otherwise undefined. The bare fallback is hub-restricted because only the
-* hub ever wrote the pre-scoping store; serving it to other nodes leaked the
-* hub's engine selection cluster-wide (CB3). A non-hub node with no scoped
-* key gets `undefined` so its own platform-driven auto-pick runs and persists
-* a real per-node selection.
-*/
-function readNodeEngineValue(store, base, nodeId) {
-	const scoped = store[nodeEngineKey(base, nodeId)];
-	if (scoped !== void 0) return scoped;
-	return normalizeEngineNodeId(nodeId) === "hub" ? store[base] : void 0;
-}
-/**
-* Re-map a UI/settings patch so engine cascade fields persist under the
-* node-scoped key; all other keys pass through unchanged. Used on the write
-* path so a UI save on one node never clobbers another node's engine.
-*/
-function scopeEnginePatch(patch, nodeId) {
-	const out = {};
-	for (const [key, value] of Object.entries(patch)) out[isEngineCascadeKey(key) ? nodeEngineKey(key, nodeId) : key] = value;
-	return out;
-}
-/**
-* Project a raw store onto the plain engine cascade keys for THIS node, so the
-* UI schema (whose field keys are the bare `engineBackend` etc.) hydrates from
-* the node's own selection. Non-engine keys are left untouched. Node-scoped
-* keys for OTHER nodes are dropped from the projection (not relevant to this
-* node's form).
-*/
-function projectNodeEngine(store, nodeId) {
-	const out = {};
-	const scopedForAnyNode = /* @__PURE__ */ new Set();
-	for (const key of Object.keys(store)) {
-		const atIdx = key.indexOf("@");
-		if (isEngineCascadeKey(atIdx >= 0 ? key.slice(0, atIdx) : key)) {
-			scopedForAnyNode.add(key);
-			continue;
-		}
-		out[key] = store[key];
-	}
-	for (const base of ENGINE_CASCADE_KEYS) {
-		const value = readNodeEngineValue(store, base, nodeId);
-		if (value !== void 0) out[base] = value;
-	}
-	return out;
-}
-//#endregion
 //#region src/detection-pipeline/runtimes.ts
 var KNOWN_PLATFORMS = [
 	"darwin",
@@ -269,6 +179,88 @@ function pickBestRuntime(env, bestBackendHint) {
 	};
 }
 //#endregion
+//#region src/detection-pipeline/engine-store-keys.ts
+/**
+* Per-node scoping for the detection-pipeline engine cascade.
+*
+* The detection addon's settings store is a single CLUSTER-SHARED blob (the
+* settings-store cap is hub-resident; every node's detection instance reads and
+* writes the same keys). That is correct for node-agnostic settings (pipeline
+* steps, tuning) but WRONG for the engine cascade — `engineBackend` /
+* `engineDevice` / `probedBestEngine` are hardware-specific, so the hub (NPU)
+* and a remote agent (iGPU, or no accelerator at all) must hold INDEPENDENT
+* selections. Sharing them lets one node's pick (e.g. `openvino/npu`) override
+* another node that has no NPU.
+*
+* These three keys are therefore persisted node-scoped as `<key>@<nodeId>`.
+* Everything else in the store stays shared. There is NO fallback to a legacy
+* un-scoped value for ANY node (the hub included) and no in-code migration: a
+* bare key (written before scoping, or by an older build) is inert — invisible
+* to every node. A node with no scoped key reads `undefined`, which drives its
+* OWN live resolve (`resolveAutoEngine` picks the node's runtime from the local
+* kernel each boot; `reprobeEngine` persists an explicit probe under
+* `<key>@<node>`). Serving a bare value to any node
+* would leak one node's hardware pick (e.g. `openvino/auto`) onto a node that
+* cannot run it (the CB3 "Mac runs OpenVINO" / N100 AUTO-device bug). This
+* mirrors the decoder's `readNodeDecoderBackend` no-fallback rule.
+*/
+var ENGINE_CASCADE_KEYS = [
+	"engineBackend",
+	"engineDevice",
+	"probedBestEngine"
+];
+function isEngineCascadeKey(key) {
+	return ENGINE_CASCADE_KEYS.includes(key);
+}
+/**
+* Normalise a raw kernel node id to the bare node id used for scoping.
+* `localNodeId` can carry a `<node>/<addon>` suffix; the engine selection is
+* per-NODE, so strip the addon segment. Falls back to `hub`.
+*/
+function normalizeEngineNodeId(rawNodeId) {
+	const raw = rawNodeId ?? "hub";
+	return raw.includes("/") ? raw.split("/")[0] ?? "hub" : raw;
+}
+/** The node-scoped store key for an engine cascade field. */
+function nodeEngineKey(base, nodeId) {
+	return `${base}@${normalizeEngineNodeId(nodeId)}`;
+}
+/**
+* Read an engine cascade value for a node: the node-scoped key if present,
+* otherwise `undefined` — for EVERY node, the hub included. There is no
+* fallback to the legacy un-scoped key: a bare value in the store is inert.
+* A node with no scoped key gets `undefined` so its own platform-driven
+* auto-pick runs and persists a real per-node selection under `<key>@<node>`.
+* (A bare fallback would leak one node's engine selection cluster-wide — CB3.)
+*/
+function readNodeEngineValue(store, base, nodeId) {
+	return store[nodeEngineKey(base, nodeId)];
+}
+/**
+* Project a raw store onto the plain engine cascade keys for THIS node, so the
+* UI schema (whose field keys are the bare `engineBackend` etc.) hydrates from
+* the node's own selection. Non-engine keys are left untouched. Node-scoped
+* keys for OTHER nodes are dropped from the projection (not relevant to this
+* node's form).
+*/
+function projectNodeEngine(store, nodeId) {
+	const out = {};
+	const scopedForAnyNode = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(store)) {
+		const atIdx = key.indexOf("@");
+		if (isEngineCascadeKey(atIdx >= 0 ? key.slice(0, atIdx) : key)) {
+			scopedForAnyNode.add(key);
+			continue;
+		}
+		out[key] = store[key];
+	}
+	for (const base of ENGINE_CASCADE_KEYS) {
+		const value = readNodeEngineValue(store, base, nodeId);
+		if (value !== void 0) out[base] = value;
+	}
+	return out;
+}
+//#endregion
 //#region src/detection-pipeline/engine/shared-inference-pool.ts
 /**
 * SharedInferencePool — TypeScript wrapper for inference_pool.py.
@@ -4341,6 +4333,15 @@ var ONNX_FLOOR = {
 	device: "cpu"
 };
 /**
+* How long the first-boot pick waits for the node's `platform-probe` to flip
+* `ready` (= its FULL async probe done, embedded-Python install included).
+* MUST stay finite — `readinessRegistry.awaitReady` defaults to Infinity,
+* which would wedge `setApi` (and the addon's onInitialize) forever on a
+* node whose probe never completes. On timeout the pick proceeds
+* conservatively (platform floor, never persisted when non-authoritative).
+*/
+var PROBE_READY_TIMEOUT_MS = 12e4;
+/**
 * Build the onnx-cpu floor pick using `pickBestRuntime` with a null hardware
 * env.  Used wherever the old `detectBestEngine()` sync probe fell back — the
 * result is identical (onnx / cpu) but is now derived through the shared rules
@@ -4419,6 +4420,16 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	lastStepsSignature = null;
 	/**
+	* CB5 shm passthrough — the process-local, LONG-LIVED reader cache for
+	* `runPipeline({ frameHandle })`. Opens each named shm segment ONCE and
+	* reuses the mapping for every later handle on the same ring (never
+	* open/close per-call). Lazily created on first handle, unmapped in
+	* {@link shutdown}. The executor and the runner are both hub-local
+	* processes sharing `/dev/shm`, so a LOCAL handle resolves to a zero-copy
+	* read here.
+	*/
+	frameHandleReaders = null;
+	/**
 	* True once the engine + models are fully ready for inference. No
 	* longer gates runtime dispatch (Phase 4 removed the legacy `runFrame`
 	* which read this flag); kept as a diagnostic the admin UI / tests
@@ -4444,13 +4455,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	needsAutoPick = false;
 	/**
-	* Unsubscribe handle for the deferred-auto-pick `platform-probe` ready
-	* listener (armed in `setApi` when the probe isn't ready yet). Cleared once
-	* the engine is resolved — either by the listener firing or by the boot
-	* safety-net `ensureBootEngineProvisioned`.
-	*/
-	deferredAutoPickUnsub = null;
-	/**
 	* Warm cache for benchmark engine-override runs.
 	*
 	* Each override rebuild costs a full Python pool spin-up (~300-500ms)
@@ -4551,108 +4555,71 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/** Store the addon context. ctx.api is a lazy getter resolved at call time. */
 	async setApi(addonCtx) {
 		this.addonCtx = addonCtx;
-		if (this.needsAutoPick) if (this.addonCtx.useCapability("platform-probe").isReady) {
-			await this.autoPickAndPersist();
-			this.needsAutoPick = false;
+		if (!this.needsAutoPick) {
 			this.startProvisioningForCurrentEngine();
-		} else {
-			const unsubscribe = this.addonCtx.onCapabilityStateChange("platform-probe", { type: "global" }, (state) => {
-				if (state !== "ready") return;
-				this.cancelDeferredAutoPick();
-				if (!this.needsAutoPick) return;
-				this.autoPickAndPersist().then(() => {
-					this.needsAutoPick = false;
-					this.startProvisioningForCurrentEngine();
-				});
-			});
-			this.deferredAutoPickUnsub = unsubscribe;
-			this.addonCtx.addDisposer(() => this.cancelDeferredAutoPick());
+			return;
 		}
-		else this.startProvisioningForCurrentEngine();
-	}
-	/** Tear down the deferred-auto-pick probe listener, if still armed. */
-	cancelDeferredAutoPick() {
-		if (this.deferredAutoPickUnsub) {
-			this.deferredAutoPickUnsub();
-			this.deferredAutoPickUnsub = null;
+		const nodeId = this.localProbeNodeId();
+		const registry = this.addonCtx.kernel?.readinessRegistry;
+		if (registry) try {
+			await registry.awaitReady("platform-probe", {
+				type: "node",
+				nodeId
+			}, { timeoutMs: PROBE_READY_TIMEOUT_MS });
+		} catch (err) {
+			this.log.warn("platform-probe readiness gate timed out — conservative engine pick (floor is not persisted)", { meta: {
+				nodeId,
+				timeoutMs: PROBE_READY_TIMEOUT_MS,
+				error: errMsg(err)
+			} });
 		}
-	}
-	/**
-	* Boot safety-net: deterministically provision the hardware-probed engine.
-	*
-	* Called from the addon's `onInitialize` right after `reprobeEngine` has
-	* written this node's probe-driven selection (e.g. `engineBackend=openvino`)
-	* to the store. When first-boot auto-pick was DEFERRED (probe not ready at
-	* `setApi`), the engine would otherwise stay `idle` — selected but never
-	* provisioned — because the `onCapabilityStateChange('platform-probe')` ready
-	* edge can be missed when the cap is already 'ready' by the time we subscribe
-	* (the old eager-onnx-floor masked this; removing it surfaced a node that
-	* boots with no engine at all). This loads the now-persisted selection and
-	* starts provisioning it, so the node reliably comes up on its real best
-	* engine (openvino on Intel) with no onnx floor and no missed boot. No-op
-	* when provisioning already started (persisted-engine path / listener fired)
-	* or when nothing has been selected yet.
-	*/
-	async ensureBootEngineProvisioned() {
-		if (this.getEngineProvisioning().state !== "idle") return;
-		const stored = await this.loadEngine();
-		if (!stored) return;
-		this.currentEngine = stored;
+		await this.resolveAutoEngine();
 		this.needsAutoPick = false;
-		this.cancelDeferredAutoPick();
-		this.log.info("Boot engine provisioning from probed selection", { meta: {
-			runtime: stored.runtime,
-			backend: stored.backend,
-			device: stored.device ?? null
-		} });
 		this.startProvisioningForCurrentEngine();
 	}
 	/**
-	* Auto-pick the best supported runtime at first boot (no stored engine).
-	* Uses the platform-probe cap's hardware + bestScore hint when available;
-	* falls back to platform/arch when the probe cap is not yet reachable.
+	* Resolve the `'auto'` engine LIVE from this node's own kernel inference
+	* resolver (`ctx.kernel.inferenceEngine`) — the runtime mirror of
+	* `ctx.kernel.hwaccel`. Each node (hub + forked worker + remote agent)
+	* resolves its OWN accelerators in-process, so a forked agent child never
+	* adopts the hub's runtime from the `platform-probe` singleton.
 	*
-	* Persists the selection as `engineBackend` + `engineDevice` so subsequent
-	* boots load it via `loadEngine()` and skip this path — but ONLY when the
-	* probe actually answered (real `hardware` or a `bestScore` hint). If the
-	* probe query failed (cold-start race, cap momentarily unreachable), the
-	* pick floors to onnx purely for lack of information; persisting that would
-	* LOCK onnx and skip auto-pick on every future boot even after the
-	* accelerator surfaces. In that case we set the in-memory floor for liveness
-	* but leave the store untouched so the next boot re-attempts the pick.
+	* NEVER persists. `'auto'` is a live-resolved sentinel: the pick is recomputed
+	* every boot from the local hardware, so it is inherently self-healing — the
+	* old `autoPickAndPersist` sticky-onnx bug (a premature onnx pick persisted
+	* during a boot race, then locked forever) cannot recur because the store is
+	* never written here. Only an explicit operator override is persisted, and
+	* that write happens through the settings UI, not this path.
 	*/
-	async autoPickAndPersist() {
+	async resolveAutoEngine() {
 		let hardware = null;
 		try {
-			const api = this.addonCtx?.api;
-			if (api) hardware = (await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() }))?.hardware ?? null;
+			hardware = await this.addonCtx?.kernel?.inferenceEngine?.resolveHardware() ?? null;
 		} catch {}
-		const pick = pickBestRuntime(runtimeEnvFromProcess(toProbedHardware(hardware)), null);
-		const engine = {
+		const pick = pickBestRuntime(runtimeEnvFromProcess(hardware ? toProbedHardware(hardware) : null), null);
+		this.currentEngine = {
 			runtime: "python",
 			backend: pick.runtimeId,
 			format: modelFormatFor(pick.runtimeId),
 			device: pick.device
 		};
-		this.currentEngine = engine;
-		if (!(pick.runtimeId !== "onnx" || hardware !== null)) {
-			this.log.info("Auto-pick: onnx floor pending gpu probe — NOT persisting (re-pick on done)", { meta: {
-				backend: pick.runtimeId,
-				device: pick.device
-			} });
-			return;
-		}
-		const apNode = this.localProbeNodeId();
-		await this.writeStore({
-			[nodeEngineKey("engineBackend", apNode)]: pick.runtimeId,
-			[nodeEngineKey("engineDevice", apNode)]: pick.device
-		});
-		this.log.info("Auto-picked engine (platform-deterministic)", { meta: {
+		this.log.info("Resolved auto engine (local kernel)", { meta: {
 			backend: pick.runtimeId,
 			device: pick.device,
-			hadProbeHardware: hardware !== null
+			hadHardware: hardware !== null
 		} });
 	}
+	/**
+	* The RUNTIME that `'auto'` actually resolved to on this node (the live
+	* `currentEngine.backend`), narrowed to a {@link RuntimeId}. The addon feeds
+	* this into `resolveBackendTuning` when the stored config is `'auto'`, so the
+	* pool tuning + respawn detection track the RESOLVED backend rather than the
+	* `'auto'` sentinel (which would otherwise floor to onnx tuning).
+	*/
+	resolvedEngineBackend() {
+		const backend = this.currentEngine.backend;
+		return backend === "openvino" || backend === "coreml" ? backend : "onnx";
+	}
 	/** Map a backend string to a known RuntimeId, flooring to onnx. */
 	toRuntimeId(backend) {
 		return [
@@ -4726,6 +4693,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const prev = this.currentEngine;
 		const stored = await this.loadEngine();
 		if (stored) this.currentEngine = stored;
+		else await this.resolveAutoEngine();
 		if ((prev.runtime !== this.currentEngine.runtime || prev.backend !== this.currentEngine.backend || prev.format !== this.currentEngine.format || (prev.device ?? "") !== (this.currentEngine.device ?? "")) && this.engineFactory) {
 			this.log.info("engine selection changed — rebuilding pool in place", { meta: {
 				from: `${prev.backend}/${prev.device ?? "default"}`,
@@ -4827,17 +4795,18 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}, { ...state }));
 	}
 	/**
-	* Fetch the probed HARDWARE for engine + device gating. Returns null when the
-	* probe cap is not yet reachable (cold-start / probe addon not installed), so
-	* callers fall back to the registry's safe minimum. The engine OFFER derives
-	* from hardware ONLY — install state (probe `scores`) never gates it.
+	* Fetch this node's inference HARDWARE (gpu/npu) for engine + device gating,
+	* from the local kernel resolver. Returns null when the resolver is not wired
+	* yet (cold-start), so callers fall back to the registry's safe minimum. The
+	* engine OFFER derives from hardware ONLY — install state never gates it.
 	*/
 	/**
-	* The local Moleculer node id (child-suffix stripped). MUST be passed to every
-	* `platformProbe.getCapabilities` query: the cap is a singleton and a query
-	* with no nodeId resolves to the HUB's probe — so on a remote agent the engine
-	* decision would use the HUB's hardware (e.g. an Intel NPU the agent doesn't
-	* have) and pin a device the node can't run, breaking provisioning.
+	* The local Moleculer node id (child-suffix stripped). Used to scope this
+	* node's engine-cascade store keys (`<key>@<node>`). Hardware itself is now
+	* resolved in-process via `ctx.kernel.inferenceEngine` (never the
+	* `platform-probe` singleton, whose no-nodeId query resolved to the HUB and
+	* pinned a device a remote agent couldn't run) — so this id is a store-scoping
+	* concern, not a probe-routing one.
 	*/
 	localProbeNodeId() {
 		const raw = this.addonCtx?.kernel?.localNodeId ?? "hub";
@@ -4845,9 +4814,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async fetchProbeGatingData() {
 		try {
-			const api = this.addonCtx?.api;
-			if (!api) return { hardware: null };
-			return { hardware: (await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() }))?.hardware ?? null };
+			return { hardware: await this.addonCtx?.kernel?.inferenceEngine?.resolveHardware() ?? null };
 		} catch {
 			return { hardware: null };
 		}
@@ -5187,6 +5154,53 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		} });
 		return { success: true };
 	}
+	/** This executor's cluster node id (suffix-stripped, matching the runner). */
+	ownNodeId() {
+		const raw = this.addonCtx?.kernel?.localNodeId ?? "hub";
+		return raw.includes("/") ? raw.split("/")[0] : raw;
+	}
+	/**
+	* CB5 — resolve a shm `FrameHandle` to pixels zero-copy. Returns `null`
+	* when:
+	*  - the handle is FOREIGN (its segment lives on another node — a local
+	*    `shm_open` would flood ENOENT; the runner only sends LOCAL handles, so
+	*    this is a defensive guard against an unexpected topology);
+	*  - the ring slot was recycled before the read (latest-wins drop) or the
+	*    segment could not be mapped.
+	* A `null` degrades the caller to an empty `FrameResult` — the runner ships
+	* pixels via `frame` as the fallback.
+	*/
+	resolveFrameHandle(handle) {
+		if (handle.nodeId !== this.ownNodeId()) return null;
+		if (!this.frameHandleReaders) this.frameHandleReaders = new FrameRingReaderCache(this.log);
+		const decoded = this.frameHandleReaders.read(handle);
+		if (!decoded) return null;
+		return {
+			data: decoded.data,
+			width: decoded.width,
+			height: decoded.height,
+			format: decoded.format,
+			timestamp: decoded.timestamp
+		};
+	}
+	/**
+	* Minimal detection-free `FrameResult` returned when a `frameHandle` read
+	* misses (recycled slot / foreign / unmappable). Shape-identical to a
+	* zero-detection runtime result so downstream consumers treat it as a
+	* dropped frame, not an error.
+	*/
+	emptyFrameHandleResult(input) {
+		return {
+			kind: "frame",
+			frameId: `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+			deviceId: input.deviceId ?? 0,
+			timestamp: Date.now(),
+			width: input.frameHandle?.width ?? 0,
+			height: input.frameHandle?.height ?? 0,
+			detections: [],
+			debug: { totalInferenceMs: 0 }
+		};
+	}
 	async runPipeline(input, onProgress) {
 		const nodeId = this.addonCtx?.kernel?.localNodeId ?? "hub";
 		const sessionId = input.sessionId ?? `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
@@ -5222,15 +5236,22 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		let jpegProvider;
 		const sources = [
 			input.frame ? "frame" : null,
+			input.frameHandle ? "frameHandle" : null,
 			input.image ? "image" : null,
 			input.imageBase64 ? "imageBase64" : null,
 			input.referenceImage ? "referenceImage" : null
 		].filter((s) => s !== null);
-		if (sources.length === 0) throw new Error("runPipeline requires exactly one of: frame, image, imageBase64, referenceImage");
+		if (sources.length === 0) throw new Error("runPipeline requires exactly one of: frame, frameHandle, image, imageBase64, referenceImage");
 		if (sources.length > 1) throw new Error(`runPipeline received conflicting image sources: ${sources.join(", ")}`);
+		let handleFrame = null;
+		if (input.frameHandle) {
+			handleFrame = this.resolveFrameHandle(input.frameHandle);
+			if (!handleFrame) return this.emptyFrameHandleResult(input);
+		}
+		const runtimeFrame = input.frame ?? handleFrame ?? void 0;
 		const decodeT0 = performance.now();
-		if (input.frame) {
-			const frame = input.frame;
+		if (runtimeFrame) {
+			const frame = runtimeFrame;
 			imageWidth = frame.width;
 			imageHeight = frame.height;
 			const data = Buffer.from(frame.data.buffer, frame.data.byteOffset, frame.data.byteLength);
@@ -5424,7 +5445,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			emit("Running inference...");
 			const tree = buildExecutableTree(benchmarkSteps, (stepId) => this.engineFactory.getEngine(stepId));
 			setupMs = performance.now() - wallT0 - decodeMs;
-			const isRuntime = Boolean(input.frame);
+			const isRuntime = Boolean(runtimeFrame);
 			const effectiveDeviceId = input.deviceId ?? 0;
 			const deviceOverrides = effectiveDeviceId > 0 ? await this.readDeviceStore(effectiveDeviceId) : {};
 			const effectiveTree = Object.keys(deviceOverrides).length > 0 ? applyDeviceOverridesToTree(tree, "object-detection", deviceOverrides) : tree;
@@ -5995,6 +6016,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			this.executor = null;
 		}
 		for (const id of Array.from(this.deviceProxies.keys())) this.releaseDeviceProxy(id);
+		this.frameHandleReaders?.close();
+		this.frameHandleReaders = null;
 	}
 	/**
 	* Resolve and cache a {@link DeviceProxy} for the given camera. Pins
@@ -6177,15 +6200,20 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* Phase 2b — resolve the engine from the addon's new schema-backed
 	* fields (`engineRuntime`, `engineBackend`, `engineDevice`). Fallback
 	* to the legacy `KEY_ENGINE` JSON blob for pre-migration stores.
-	* Returns null when neither source has anything; the caller keeps
-	* the onnx floor set at construction until autoPickAndPersist() runs.
+	*
+	* The `'auto'` sentinel is treated as NO override (returns null) so the
+	* caller re-resolves LIVE via `resolveAutoEngine()` — `'auto'` is the
+	* self-healing default, never a persisted concrete backend. An explicit
+	* concrete backend (onnx/openvino/coreml) is honored as an operator override.
+	* Returns null when neither source has a concrete selection; the caller keeps
+	* the onnx floor set at construction until `resolveAutoEngine()` runs.
 	*/
 	async loadEngine() {
 		const store = await this.readStore();
 		const storedRuntime = store["engineRuntime"];
 		const node = this.localProbeNodeId();
 		const storedBackend = readNodeEngineValue(store, "engineBackend", node);
-		if (typeof storedBackend === "string" && storedBackend.length > 0) {
+		if (typeof storedBackend === "string" && storedBackend.length > 0 && storedBackend !== "auto") {
 			const backend = storedBackend;
 			const storedDeviceRaw = readNodeEngineValue(store, "engineDevice", node);
 			const storedDevice = typeof storedDeviceRaw === "string" ? storedDeviceRaw : "";
@@ -6339,12 +6367,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return { success: true };
 	}
 	async reprobeEngine() {
-		const api = this.addonCtx?.api;
 		let hardware = null;
-		if (api) try {
-			hardware = (await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() }))?.hardware ?? null;
+		try {
+			hardware = await this.addonCtx?.kernel?.inferenceEngine?.resolveHardware() ?? null;
 		} catch {}
-		const pick = pickBestRuntime(runtimeEnvFromProcess(toProbedHardware(hardware)), null);
+		const pick = pickBestRuntime(runtimeEnvFromProcess(hardware ? toProbedHardware(hardware) : null), null);
 		const best = {
 			runtime: "python",
 			backend: pick.runtimeId,
@@ -6354,47 +6381,18 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const probedLabel = `${best.backend}/${best.device ?? "default"}`;
 		const rpNode = this.localProbeNodeId();
 		if (pick.runtimeId !== "onnx" || hardware !== null) {
-			await this.writeStore({
-				[nodeEngineKey("probedBestEngine", rpNode)]: probedLabel,
-				[nodeEngineKey("engineBackend", rpNode)]: best.backend,
-				[nodeEngineKey("engineDevice", rpNode)]: best.device ?? "cpu"
-			});
-			this.log.info("Re-probed engine (platform-deterministic) — wrote back", { meta: {
+			await this.writeStore({ [nodeEngineKey("probedBestEngine", rpNode)]: probedLabel });
+			this.log.info("Re-probed engine (local kernel) — updated probedBestEngine hint", { meta: {
 				backend: best.backend,
 				device: best.device ?? null,
 				probedBestEngine: probedLabel
 			} });
-		} else this.log.info("Re-probe: onnx floor pending gpu probe — NOT persisting (re-pick on done)", { meta: {
+		} else this.log.info("Re-probe: onnx floor pending gpu probe — hint NOT persisted", { meta: {
 			backend: best.backend,
 			device: best.device ?? null
 		} });
 		return best;
 	}
-	/**
-	* Re-pick the engine when the platform-probe finishes its async hardware +
-	* Python detection (the `platform-probe.phase` `done` event). At boot the
-	* probe's accelerator result may not be ready yet, so the engine floored to
-	* onnx; once the probe answers (e.g. a Mac's CoreML/ANE surfaces after the
-	* embedded Python is installed) this re-runs the probe-driven pick and
-	* re-provisions. Idempotent: `startProvisioningForCurrentEngine` skips a
-	* no-op when the selection is unchanged.
-	*/
-	async repickEngineOnProbeReady() {
-		const before = `${this.currentEngine.backend}/${this.currentEngine.device ?? "default"}`;
-		await this.reprobeEngine();
-		const stored = await this.loadEngine();
-		if (stored) {
-			this.currentEngine = stored;
-			this.needsAutoPick = false;
-			this.cancelDeferredAutoPick();
-		}
-		const after = `${this.currentEngine.backend}/${this.currentEngine.device ?? "default"}`;
-		if (before !== after) this.log.info("Engine re-picked after platform-probe completed", { meta: {
-			before,
-			after
-		} });
-		this.startProvisioningForCurrentEngine();
-	}
 	async getReferenceAudioFiles() {
 		const dir = resolveReferenceAudioDir();
 		if (!dir) return [];
@@ -6806,7 +6804,7 @@ var DEFAULT_CONFIG = {
 	intraOpThreads: 0,
 	numWorkers: 0,
 	engineRuntime: "python",
-	engineBackend: "onnx",
+	engineBackend: "auto",
 	engineDevice: "cpu",
 	probedBestEngine: "",
 	activeEngine: ""
@@ -6836,6 +6834,15 @@ function stableEngineKey(engines) {
 	return JSON.stringify(stripped);
 }
 /**
+* Narrow a topology-reported platform string to the runtime-relevant
+* `NodeJS.Platform` values the engine cascade branches on (darwin/linux/win32).
+* A type guard, not a cast; any other value → undefined so the caller floors to
+* `process.platform`. These three match `HardwarePlatformSchema` in the cap.
+*/
+function toNodePlatform(value) {
+	return value === "darwin" || value === "linux" || value === "win32" ? value : void 0;
+}
+/**
 * Tuning fields that bind into the Python pool at construction. Any
 * change requires a pool respawn to take effect (the executor caches
 * `tuning` at engine-factory build time). `onConfigChanged` watches
@@ -6850,7 +6857,7 @@ var POOL_BOUND_KEYS = [
 	"intraOpThreads",
 	"numWorkers"
 ];
-var DetectionPipelineAddon = class extends BaseAddon {
+var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 	provider = null;
 	/** Last non-null probed hardware PER NODE — reused when the probe transiently
 	*  returns null so offered backends / device lists don't collapse. Keyed by
@@ -6858,13 +6865,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	*  Carries the probed node's platform/arch too, so a transient null probe
 	*  doesn't flip a remote node's env back to the serving hub's platform. */
 	lastGoodHardwareByNode = /* @__PURE__ */ new Map();
-	/** This node's effective engine selection, cached from the node-scoped store
-	*  so the synchronous `resolveBackendTuning` and the reprobe gate don't read
-	*  the cluster-shared bare keys. Refreshed at init + on every config change. */
-	nodeEngineBackend = DEFAULT_CONFIG.engineBackend;
-	nodeProbedBestEngine = "";
 	engineMetricsTimer = null;
-	probePhaseUnsub = null;
 	/** Snapshot-equality cache for engine-metrics emit. Most ticks
 	*  the engine inventory is unchanged (no model load/unload), so
 	*  we skip the bus emit and let the heartbeat re-emit at
@@ -6912,6 +6913,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					description: "Auto-detected best engine for this host (format: provider/device, e.g. \"openvino/npu\"). Click the refresh icon to re-run the probe — the detected provider and hardware device are written back into the two fields below, overwriting any manual override.",
 					readonlyField: true,
 					default: "",
+					perNode: true,
 					actions: [{
 						action: "reprobe-engine",
 						icon: "refresh-cw",
@@ -6930,9 +6932,13 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					type: "select",
 					key: "engineBackend",
 					label: "Execution provider",
-					options: [...STATIC_BACKEND_OPTIONS],
+					options: [{
+						value: "auto",
+						label: "Auto (best for this node)"
+					}, ...STATIC_BACKEND_OPTIONS],
 					default: DEFAULT_CONFIG.engineBackend,
-					immediate: true
+					immediate: true,
+					perNode: true
 				}),
 				this.field({
 					type: "select",
@@ -6940,7 +6946,8 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					label: "Hardware device",
 					options: [...STATIC_DEFAULT_DEVICE_OPTIONS],
 					default: DEFAULT_CONFIG.engineDevice,
-					immediate: true
+					immediate: true,
+					perNode: true
 				})
 			]
 		}, {
@@ -7069,12 +7076,17 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		const env = await this.probeHardwareEnv(targetNode);
 		const hardware = env.hardware;
 		const offered = supportedRuntimes(env);
-		const runtimeBackends = offered.map((id) => ({
+		const runtimeBackends = [{
+			value: "auto",
+			label: "Auto (best for this node)"
+		}, ...offered.map((id) => ({
 			value: id,
 			label: runtimeLabel(id)
-		}));
+		}))];
 		const storedBackend = typeof merged.engineBackend === "string" ? merged.engineBackend : "";
+		const isAuto = storedBackend === "auto";
 		const backend = (() => {
+			if (isAuto) return pickBestRuntime(env, null).runtimeId;
 			const rid = toRuntimeId(storedBackend);
 			if (rid === "onnx") return "onnx";
 			if (offered.includes(rid)) return rid;
@@ -7085,9 +7097,10 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		const device = deviceOptions.find((d) => d.value === storedDevice)?.value ?? defaultDeviceFor(backend);
 		const prov = targetNode === this.localNodeId() ? this.provider?.getEngineProvisioning() : void 0;
 		const activeEngine = prov && prov.runtimeId ? `${prov.runtimeId}/${prov.device ?? "default"} (${prov.state})` : "";
+		const displayBackend = isAuto ? "auto" : backend;
 		const raw = {
 			...merged,
-			engineBackend: backend,
+			engineBackend: displayBackend,
 			engineDevice: device,
 			activeEngine
 		};
@@ -7163,14 +7176,37 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		const hardware = await this.resolveProbeHardware(node);
 		if (hardware) this.lastGoodHardwareByNode.set(node, hardware);
 		const effective = hardware ?? this.lastGoodHardwareByNode.get(node) ?? null;
-		const useProbedPlatform = node !== this.localNodeId();
+		const isRemote = node !== this.localNodeId();
+		const topo = isRemote ? await this.resolveTopologyPlatform(node) : null;
 		return {
-			platform: useProbedPlatform && effective?.platform !== void 0 ? effective.platform : process.platform,
-			arch: useProbedPlatform && effective?.arch !== void 0 ? effective.arch : process.arch,
+			platform: (isRemote ? topo?.platform ?? effective?.platform : void 0) ?? process.platform,
+			arch: (isRemote ? topo?.arch ?? effective?.arch : void 0) ?? process.arch,
 			hardware: effective
 		};
 	}
 	/**
+	* Read the TARGET node's platform/arch from cluster topology — the
+	* registration self-report (`nodes.topology`), which is hub-local and
+	* available immediately, independent of the node's async accelerator probe.
+	* Mirrors the audio analyzer's `resolveNodePlatform` (the D6 reference
+	* pattern) so detection + audio share ONE topology-read path. Returns null
+	* when topology is unreachable (caller falls back to the probe report, then
+	* `process.platform`). Narrows the reported platform to the runtime-relevant
+	* `NodeJS.Platform` values via a type guard (no cast); any other value is
+	* dropped so the caller floors safely.
+	*/
+	async resolveTopologyPlatform(nodeId) {
+		try {
+			const picked = pickNodePlatformArch(await this.ctxIfReady?.api?.nodes?.topology.query(), nodeId);
+			return {
+				platform: toNodePlatform(picked.platform),
+				arch: picked.arch
+			};
+		} catch {
+			return null;
+		}
+	}
+	/**
 	* Fetch the probed hardware from the platform-probe cap for `nodeId` (default
 	* = self). Returns null when the cap is not reachable (caller falls back to
 	* the registry's safe minimum). Carries the probed node's `platform`/`arch`
@@ -7182,7 +7218,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 			const api = this.ctxIfReady?.api;
 			if (!api) return null;
 			const node = nodeId ?? this.localNodeId();
-			const hw = (node === this.localNodeId() ? await api.platformProbe.getCapabilities.query() : await api.platformProbe.getCapabilities.query(void 0, nodePin(node)))?.hardware;
+			const hw = (node === this.localNodeId() ? await api.platformProbe.getCapabilities.query() : await api.platformProbe.getCapabilities.query({ nodeId: node }))?.hardware;
 			if (!hw) return null;
 			return {
 				npu: hw.npu ? { type: hw.npu.type } : null,
@@ -7207,81 +7243,6 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		return normalizeEngineNodeId(this.ctxIfReady?.kernel?.localNodeId ?? "hub");
 	}
 	/**
-	* One-time store migration (hub only, F1/CB3): the pre-scoping store
-	* persisted the engine cascade under BARE keys (`engineBackend`, …) that
-	* only the hub ever wrote. `readNodeEngineValue` used to serve those bare
-	* values as a fallback to EVERY node, leaking the hub's engine (e.g.
-	* `openvino/auto`) onto agents with no scoped key. The fallback is now
-	* hub-only (engine-store-keys.ts) and this migration re-homes the bare
-	* values to their `<key>@hub` scoped form and deletes the bare keys so the
-	* legacy values cannot resurface. Guarded: runs only while a bare key is
-	* still present, so post-migration boots are a no-op. Best-effort — an
-	* unreadable store skips the migration (retried on the next boot).
-	*/
-	async migrateLegacyBareEngineKeys() {
-		if (this.localNodeId() !== "hub") return;
-		const store = await this.resolveUiSettingsStore();
-		if (store === null) return;
-		const patch = {};
-		for (const base of ENGINE_CASCADE_KEYS) {
-			const bare = store[base];
-			if (bare === void 0 || bare === null) continue;
-			const scopedKey = nodeEngineKey(base, "hub");
-			if (store[scopedKey] === void 0) patch[scopedKey] = bare;
-			patch[base] = void 0;
-		}
-		if (Object.keys(patch).length === 0) return;
-		await this.ctxIfReady?.settings?.writeAddonStore(patch);
-		this.ctx.logger.info("Migrated legacy bare engine keys to their @hub scoped form", { meta: { keys: Object.keys(patch) } });
-	}
-	/**
-	* Refresh this node's cached engine selection from the node-scoped store.
-	* `resolveBackendTuning` is synchronous and the reprobe gate runs before the
-	* provider exists, so both read these cached fields instead of the
-	* cluster-shared bare keys (which belong to no single node). Best-effort: a
-	* transiently-unreadable store leaves the last cached values in place.
-	*/
-	async refreshNodeEngineFromStore() {
-		const store = await this.resolveUiSettingsStore();
-		if (store === null) return;
-		const node = this.localNodeId();
-		const backend = readNodeEngineValue(store, "engineBackend", node);
-		if (typeof backend === "string" && backend !== "") this.nodeEngineBackend = backend;
-		const probed = readNodeEngineValue(store, "probedBestEngine", node);
-		this.nodeProbedBestEngine = typeof probed === "string" ? probed : "";
-	}
-	/**
-	* Persist a settings patch, mirroring the engine cascade fields to the TARGET
-	* node's scoped keys so each node keeps an INDEPENDENT engine selection in the
-	* cluster-central store. The hub addon serves writes for every node, so it
-	* scopes by the requested `nodeId` (default self).
-	*
-	* The engine cascade keys are NEVER written bare (F1, CB3): the bare keys are
-	* the legacy pre-scoping store whose values used to leak to every node with
-	* no scoped key. When the target IS this node, `super.updateGlobalSettings`
-	* drives the normal apply path (`resolveConfig` / `onConfigChanged` /
-	* `requiresRestart` restart) with the engine keys STRIPPED from its patch —
-	* they were already persisted node-scoped, and `onConfigChanged` re-reads
-	* them from the scoped keys. When the target is a SIBLING node, one scoped
-	* write persists the engine keys under `<key>@<target>` + the non-engine
-	* keys bare, and this node's restart/reprovision is NOT run — the owning
-	* node applies its own engine selection on its next (re)start.
-	*/
-	async updateGlobalSettings(patch, nodeId) {
-		const targetNode = nodeId ? normalizeEngineNodeId(nodeId) : this.localNodeId();
-		const patchRecord = patch;
-		if (targetNode !== this.localNodeId()) {
-			const scoped = scopeEnginePatch(patchRecord, targetNode);
-			if (Object.keys(scoped).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(scoped);
-			return;
-		}
-		const scopedEngine = {};
-		for (const key of ENGINE_CASCADE_KEYS) if (key in patchRecord) scopedEngine[nodeEngineKey(key, targetNode)] = patchRecord[key];
-		if (Object.keys(scopedEngine).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(scopedEngine);
-		const { engineBackend: _engineBackend, engineDevice: _engineDevice, probedBestEngine: _probedBestEngine, ...sharedPatch } = patch;
-		await super.updateGlobalSettings(sharedPatch, nodeId);
-	}
-	/**
 	* Resolve the effective pool tuning for the configured backend.
 	*
 	* Reads the registry's `tuningFor(backend)` and ignores any persisted
@@ -7295,7 +7256,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* a reason to disagree.
 	*/
 	resolveBackendTuning() {
-		const t = tuningFor(toRuntimeId(this.nodeEngineBackend ?? DEFAULT_CONFIG.engineBackend));
+		const t = tuningFor(this.config.engineBackend === "auto" ? this.provider?.resolvedEngineBackend() ?? "onnx" : toRuntimeId(this.config.engineBackend));
 		const num = (v, dflt) => typeof v === "number" && v > 0 ? v : dflt;
 		const batch = (v, dflt) => v === "none" || v === "list" || v === "window" ? v : dflt;
 		return {
@@ -7308,44 +7269,59 @@ var DetectionPipelineAddon = class extends BaseAddon {
 			numWorkers: num(t["numWorkers"], 1)
 		};
 	}
+	/**
+	* Construct a fresh provider with the given effective tuning. Single source of
+	* truth for the provider wiring — shared by `onInitialize`, the post-resolve
+	* tuning reconciliation, and the `onConfigChanged` pool respawn.
+	*/
+	buildProvider(modelsDir, tuning) {
+		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
+		return new DetectionPipelineProvider(this.ctx.settings, modelsDir, this.ctx.logger, this.ctx.eventBus ?? null, () => ({ sections: [] }), {
+			concurrency: tuning.concurrency,
+			tuning: {
+				batchMode: tuning.batchMode,
+				windowMs: tuning.windowMs,
+				maxBatchSize: tuning.maxBatchSize,
+				numStreams: tuning.numStreams,
+				intraOpThreads: tuning.intraOpThreads
+			},
+			numWorkers: tuning.numWorkers,
+			pythonPath: this.pythonPath,
+			pythonAddonDir: this.pythonAddonDir
+		});
+	}
+	/**
+	* Pool-bound tuning keys of `a` and `b` are equal (used to decide whether a
+	* post-resolve / config-change respawn is actually needed).
+	*/
+	static poolTuningEqual(a, b) {
+		return a.concurrency === b.concurrency && a.batchMode === b.batchMode && a.windowMs === b.windowMs && a.maxBatchSize === b.maxBatchSize && a.numStreams === b.numStreams && a.intraOpThreads === b.intraOpThreads && a.numWorkers === b.numWorkers;
+	}
 	async onInitialize() {
 		const modelsDir = await this.resolveModelsDir();
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
-		await this.migrateLegacyBareEngineKeys();
-		await this.refreshNodeEngineFromStore();
 		this.pythonAddonDir = resolveAddonPythonDir();
 		const py = await ensurePythonReady(this.ctx.deps, this.ctx.logger);
 		if (py.ok && py.pythonPath) this.pythonPath = py.pythonPath;
 		else this.ctx.logger.warn("Detection engine boot continues without Python — selection will provision on demand", {});
 		await this.proactivelyInstallOpenvino();
-		const effectiveTuning = this.resolveBackendTuning();
-		this.provider = new DetectionPipelineProvider(this.ctx.settings, modelsDir, this.ctx.logger, this.ctx.eventBus ?? null, () => ({ sections: [] }), {
-			concurrency: effectiveTuning.concurrency,
-			tuning: {
-				batchMode: effectiveTuning.batchMode,
-				windowMs: effectiveTuning.windowMs,
-				maxBatchSize: effectiveTuning.maxBatchSize,
-				numStreams: effectiveTuning.numStreams,
-				intraOpThreads: effectiveTuning.intraOpThreads
-			},
-			numWorkers: effectiveTuning.numWorkers,
-			pythonPath: this.pythonPath,
-			pythonAddonDir: this.pythonAddonDir
-		});
+		const initialTuning = this.resolveBackendTuning();
+		this.provider = this.buildProvider(modelsDir, initialTuning);
 		await this.provider.init();
 		await this.provider.setApi(this.ctx);
-		if (!this.nodeProbedBestEngine) await this.provider.reprobeEngine().catch((err) => {
+		const resolvedTuning = this.resolveBackendTuning();
+		if (!DetectionPipelineAddon.poolTuningEqual(initialTuning, resolvedTuning)) {
+			this.ctx.logger.info("detection-pipeline tuning reconciled to resolved engine", { meta: {
+				from: initialTuning,
+				to: resolvedTuning
+			} });
+			this.provider = this.buildProvider(modelsDir, resolvedTuning);
+			await this.provider.init();
+			await this.provider.setApi(this.ctx);
+		}
+		if (!this.config.probedBestEngine) await this.provider.reprobeEngine().catch((err) => {
 			this.ctx.logger.warn("auto-reprobe engine failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
-		await this.provider.ensureBootEngineProvisioned().catch((err) => {
-			this.ctx.logger.warn("ensureBootEngineProvisioned failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		});
-		this.probePhaseUnsub = this.ctx.eventBus?.subscribe({ category: EventCategory.PlatformProbePhase }, (event) => {
-			if (event.data?.phase !== "done") return;
-			this.provider?.repickEngineOnProbeReady().catch((err) => {
-				this.ctx.logger.warn("repick on platform-probe done failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-			});
-		}) ?? null;
 		await this.provider.warmPool();
 		this.engineMetricsTimer = setInterval(() => this.emitEngineMetricsSnapshot(), ENGINE_METRICS_SNAPSHOT_INTERVAL_MS);
 		this.lastAppliedPoolConfig = this.snapshotPoolConfig();
@@ -7399,13 +7375,18 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* first loaded (gated by `loadEngine`'s `isPythonBackendAvailable` check).
 	*
 	* Failure is non-fatal: a warning is logged and the addon continues with
-	* the onnx-cpu baseline. The hardware query itself is also best-effort —
-	* if the platform-probe cap isn't wired yet the error is caught here.
+	* the onnx-cpu baseline. The hardware resolve itself is also best-effort —
+	* if the kernel resolver isn't wired yet the error is caught here.
 	*/
 	async proactivelyInstallOpenvino() {
 		if (!this.pythonAddonDir || !this.pythonPath) return;
 		try {
-			const hardware = await this.ctx.api.platformProbe.getHardware.query();
+			const hw = await this.ctx.kernel?.inferenceEngine?.resolveHardware();
+			const hardware = {
+				platform: process.platform,
+				gpu: hw?.gpu ?? null,
+				npu: hw?.npu ?? null
+			};
 			if (!shouldInstallOpenvino(hardware)) return;
 			this.ctx.logger.info("Intel hardware detected — proactively installing OpenVINO Python package", { meta: {
 				gpu: hardware.gpu?.type ?? null,
@@ -7419,10 +7400,6 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		}
 	}
 	async onShutdown() {
-		if (this.probePhaseUnsub) {
-			this.probePhaseUnsub();
-			this.probePhaseUnsub = null;
-		}
 		if (this.engineMetricsTimer) {
 			clearInterval(this.engineMetricsTimer);
 			this.engineMetricsTimer = null;
@@ -7470,7 +7447,6 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* re-spin, frames are dropped (never crashed), no addon bounce.
 	*/
 	async onConfigChanged() {
-		await this.refreshNodeEngineFromStore();
 		if (this.provider) await this.provider.onEngineSelectionChanged().catch((err) => {
 			this.ctx.logger.warn("engine provisioning re-select failed on config change", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
@@ -7489,21 +7465,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 			this.ctx.logger.warn("provider shutdown failed during tuning respawn", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		}
 		const modelsDir = await this.resolveModelsDir();
-		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available during respawn");
-		const effectiveTuning = this.resolveBackendTuning();
-		this.provider = new DetectionPipelineProvider(this.ctx.settings, modelsDir, this.ctx.logger, this.ctx.eventBus ?? null, () => ({ sections: [] }), {
-			concurrency: effectiveTuning.concurrency,
-			tuning: {
-				batchMode: effectiveTuning.batchMode,
-				windowMs: effectiveTuning.windowMs,
-				maxBatchSize: effectiveTuning.maxBatchSize,
-				numStreams: effectiveTuning.numStreams,
-				intraOpThreads: effectiveTuning.intraOpThreads
-			},
-			numWorkers: effectiveTuning.numWorkers,
-			pythonPath: this.pythonPath,
-			pythonAddonDir: this.pythonAddonDir
-		});
+		this.provider = this.buildProvider(modelsDir, this.resolveBackendTuning());
 		await this.provider.init();
 		await this.provider.setApi(this.ctx);
 		await this.provider.warmPool();