@camstack/addon-pipeline 1.1.28 → 1.1.30

package/dist/detection-pipeline/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-DxM2DSns.js");
-const require_dist = require("../dist-Biq62zt4.js");
+const require_dist = require("../dist-Cwc0TUQr.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_fs = require("node:fs");
@@ -15,87 +15,6 @@ node_os = require_model_download_service_C_IHWnXx.__toESM(node_os);
 let node_child_process = require("node:child_process");
 let sharp = require("sharp");
 sharp = require_model_download_service_C_IHWnXx.__toESM(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. 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 platform auto-pick (`autoPickAndPersist` / `reprobeEngine` persist the
-* node's own 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/runtimes.ts
 var KNOWN_PLATFORMS = [
 	"darwin",
@@ -267,6 +186,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.
@@ -335,6 +336,51 @@ var PoolHandle = class {
 	}
 	async dispose() {}
 };
+/**
+* How long to wait for a worker to exit on SIGTERM before escalating to
+* SIGKILL. A worker idle between frames exits well under this; only a worker
+* stuck in a native inference call (openvino/onnx C++) needs the escalation.
+*/
+var POOL_WORKER_TERM_GRACE_MS = 2e3;
+/**
+* Terminate a spawned child GRACEFULLY THEN FORCEFULLY: end stdin, send
+* SIGTERM, and if the process hasn't exited within `graceMs`, send SIGKILL.
+* Resolves once the process has exited (or was already dead).
+*
+* The old teardown sent SIGTERM and dropped the reference immediately — a
+* worker busy in a native inference loop ignores SIGTERM and ORPHANS at full
+* CPU (observed after an engine re-spin). SIGKILL cannot be ignored, so the
+* escalation guarantees the process dies. Exported for tests.
+*/
+async function terminateChild(proc, graceMs) {
+	if (proc.exitCode !== null || proc.signalCode !== null) return;
+	try {
+		proc.stdin?.end();
+	} catch {}
+	await new Promise((resolve) => {
+		let settled = false;
+		let timer = null;
+		const done = () => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			resolve();
+		};
+		proc.once("exit", done);
+		try {
+			proc.kill("SIGTERM");
+		} catch {
+			done();
+			return;
+		}
+		timer = setTimeout(() => {
+			try {
+				proc.kill("SIGKILL");
+			} catch {}
+			done();
+		}, graceMs);
+	});
+}
 var PoolWorker = class {
 	process = null;
 	receiveBuffer = Buffer.alloc(0);
@@ -490,12 +536,11 @@ var PoolWorker = class {
 		return await this.dispatch(MSG_COMMAND, payload);
 	}
 	async dispose() {
-		if (this.process) {
-			this.process.stdin?.end();
-			this.process.kill("SIGTERM");
-			this.process = null;
-			this.ready = false;
-		}
+		const proc = this.process;
+		if (!proc) return;
+		this.process = null;
+		this.ready = false;
+		await terminateChild(proc, POOL_WORKER_TERM_GRACE_MS);
 	}
 	dispatch(msgType, payload) {
 		const reqId = this.allocRequestId();
@@ -4579,56 +4624,53 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				error: require_dist.errMsg(err)
 			} });
 		}
-		await this.autoPickAndPersist();
+		await this.resolveAutoEngine();
 		this.needsAutoPick = false;
 		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 (next boot retries)", { 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 [
@@ -4702,6 +4744,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"}`,
@@ -4803,17 +4846,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";
@@ -4821,9 +4865,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 };
 		}
@@ -6209,15 +6251,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 : "";
@@ -6371,12 +6418,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,
@@ -6386,17 +6432,13 @@ 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 (next boot retries)", { meta: {
+		} else this.log.info("Re-probe: onnx floor pending gpu probe — hint NOT persisted", { meta: {
 			backend: best.backend,
 			device: best.device ?? null
 		} });
@@ -6813,7 +6855,7 @@ var DEFAULT_CONFIG = {
 	intraOpThreads: 0,
 	numWorkers: 0,
 	engineRuntime: "python",
-	engineBackend: "onnx",
+	engineBackend: "auto",
 	engineDevice: "cpu",
 	probedBestEngine: "",
 	activeEngine: ""
@@ -6866,7 +6908,7 @@ var POOL_BOUND_KEYS = [
 	"intraOpThreads",
 	"numWorkers"
 ];
-var DetectionPipelineAddon = class extends require_dist.BaseAddon {
+var DetectionPipelineAddon = class DetectionPipelineAddon extends require_dist.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
@@ -6941,7 +6983,10 @@ var DetectionPipelineAddon = class extends require_dist.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,
 					perNode: true
@@ -7082,12 +7127,17 @@ var DetectionPipelineAddon = class extends require_dist.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;
@@ -7098,9 +7148,10 @@ var DetectionPipelineAddon = class extends require_dist.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
 		};
@@ -7218,7 +7269,7 @@ var DetectionPipelineAddon = class extends require_dist.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, require_dist.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,
@@ -7256,7 +7307,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	* a reason to disagree.
 	*/
 	resolveBackendTuning() {
-		const t = tuningFor(toRuntimeId(this.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 {
@@ -7269,6 +7320,34 @@ var DetectionPipelineAddon = class extends require_dist.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");
@@ -7277,22 +7356,20 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		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);
+		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) } });
 		});
@@ -7349,13 +7426,18 @@ var DetectionPipelineAddon = class extends require_dist.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,
@@ -7434,21 +7516,7 @@ var DetectionPipelineAddon = class extends require_dist.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();