@openclaw/diagnostics-otel 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{runtime-api-BF77iERj.js → runtime-api-1JbI8_wJ.js}

@@ -1,21 +1,27 @@
 import { isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, redactSensitiveText } from "./api.js";
-import { SpanKind, SpanStatusCode, TraceFlags, context, metrics, trace } from "@opentelemetry/api";
+import { ROOT_CONTEXT, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, diag, isSpanContextValid, metrics, propagation, trace } from "@opentelemetry/api";
+import * as otelCore from "@opentelemetry/core";
+import { CompositePropagator, ExportResultCode, W3CBaggagePropagator, W3CTraceContextPropagator, getStringListFromEnv } from "@opentelemetry/core";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { BatchSpanProcessor, ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
+import * as resources from "@opentelemetry/resources";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { BasicTracerProvider, BatchSpanProcessor, ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { registerUnhandledRejectionHandler } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { normalizeDiagnosticLane, normalizeDiagnosticValue } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { readFileSync } from "node:fs";
 import nodePath from "node:path";
+import { collectErrorGraphCandidates } from "openclaw/plugin-sdk/error-runtime";
 import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
 import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { B3InjectEncoding, B3Propagator } from "@opentelemetry/propagator-b3";
+import { JaegerPropagator } from "@opentelemetry/propagator-jaeger";
 import { ATTR_GEN_AI_INPUT_MESSAGES, ATTR_GEN_AI_OUTPUT_MESSAGES, ATTR_GEN_AI_SYSTEM_INSTRUCTIONS, ATTR_GEN_AI_TOOL_CALL_ARGUMENTS, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_CALL_RESULT, ATTR_GEN_AI_TOOL_DEFINITIONS, GEN_AI_OPERATION_NAME_VALUE_EXECUTE_TOOL, GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT } from "@opentelemetry/semantic-conventions/incubating";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asFiniteNumber, asFiniteNumberInRange, isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 const DROPPED_OTEL_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
 	"openclaw.callId",
 	"openclaw.call_id",
@@ -38,7 +44,6 @@ const DROPPED_OTEL_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
 	"openclaw.traceId",
 	"openclaw.trace_id"
 ]);
-const LOW_CARDINALITY_VALUE_RE = /^[A-Za-z0-9_.:-]{1,120}$/u;
 const SECURITY_TARGET_NAME_VALUE_RE = /^[A-Za-z0-9@/_.:-]{1,256}$/u;
 const MAX_OTEL_LOG_BODY_CHARS = 4 * 1024;
 const MAX_OTEL_LOG_ATTRIBUTE_VALUE_CHARS = 4 * 1024;
@@ -49,9 +54,13 @@ const BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
 	"prototype",
 	"constructor"
 ]);
+const OTEL_EXPORTER_OTLP_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_ENDPOINT";
 const OTEL_EXPORTER_OTLP_TRACES_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
 const OTEL_EXPORTER_OTLP_METRICS_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT";
 const OTEL_EXPORTER_OTLP_LOGS_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT";
+const OTEL_EXPORTER_OTLP_TRACES_PROTOCOL_ENV = "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL";
+const OTEL_EXPORTER_OTLP_METRICS_PROTOCOL_ENV = "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL";
+const OTEL_EXPORTER_OTLP_LOGS_PROTOCOL_ENV = "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL";
 const OTEL_EXPORTER_OTLP_CERTIFICATE_ENV = "OTEL_EXPORTER_OTLP_CERTIFICATE";
 const OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_ENV = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE";
 const OTEL_EXPORTER_OTLP_CLIENT_KEY_ENV = "OTEL_EXPORTER_OTLP_CLIENT_KEY";
@@ -297,203 +306,81 @@ function describeJsonValue(value) {
 	return typeof value;
 }
 //#endregion
-//#region extensions/diagnostics-otel/src/service-attributes.ts
-function redactOtelAttributes(attributes) {
-	const redactedAttributes = {};
-	for (const [key, value] of Object.entries(attributes)) {
-		if (DROPPED_OTEL_ATTRIBUTE_KEYS.has(key)) continue;
-		redactedAttributes[key] = typeof value === "string" ? redactSensitiveText(value) : value;
-	}
-	return redactedAttributes;
-}
-function lowCardinalityAttr(value, fallback = "unknown") {
-	if (!value) return fallback;
-	const redacted = redactSensitiveText(value.trim());
-	const redactedLower = redacted.toLowerCase();
-	if (redactedLower.startsWith("agent:") || redactedLower.includes(":agent:")) return fallback;
-	return LOW_CARDINALITY_VALUE_RE.test(redacted) ? redacted : fallback;
-}
-function securityTargetNameAttr(value, fallback = "unknown") {
-	if (!value) return fallback;
-	const redacted = redactSensitiveText(value.trim());
-	const redactedLower = redacted.toLowerCase();
-	if (redactedLower.startsWith("agent:") || redactedLower.includes(":agent:")) return fallback;
-	return SECURITY_TARGET_NAME_VALUE_RE.test(redacted) ? redacted : fallback;
-}
-function lowCardinalityQueueLaneAttr(value, fallback = "unknown") {
-	if (!value) return fallback;
-	const redacted = redactSensitiveText(value.trim());
-	if (redacted.toLowerCase().startsWith("agent:")) return fallback;
-	const scopedLaneIndex = redacted.indexOf(":");
-	const lane = scopedLaneIndex >= 0 ? redacted.slice(0, scopedLaneIndex) : redacted;
-	return LOW_CARDINALITY_VALUE_RE.test(lane) ? lane : fallback;
-}
-function shouldCaptureOtelLogBody(policy) {
-	return policy.logBodies;
-}
-function otelLogTimestampIso(timestamp) {
-	if (timestamp instanceof Date) return timestamp.toISOString();
-	if (typeof timestamp === "number" && Number.isFinite(timestamp)) return new Date(timestamp).toISOString();
-	if (Array.isArray(timestamp)) {
-		const [seconds, nanoseconds] = timestamp;
-		if (Number.isFinite(seconds) && Number.isFinite(nanoseconds)) return new Date(seconds * 1e3 + Math.trunc(nanoseconds / 1e6)).toISOString();
-	}
-	return (/* @__PURE__ */ new Date()).toISOString();
-}
-function writeStdoutDiagnosticLogRecord(params) {
-	const { logRecord, serviceName, traceContext } = params;
-	const line = {
-		ts: otelLogTimestampIso(logRecord.timestamp),
-		signal: "openclaw.diagnostic.log",
-		"service.name": serviceName,
-		severityText: logRecord.severityText,
-		severityNumber: logRecord.severityNumber,
-		body: logRecord.body,
-		attributes: logRecord.attributes ?? {},
-		...traceContext?.traceId ? { trace_id: traceContext.traceId } : {},
-		...traceContext?.spanId ? { span_id: traceContext.spanId } : {},
-		...traceContext?.traceFlags ? { trace_flags: traceContext.traceFlags } : {}
-	};
-	process.stdout.write(`${JSON.stringify(line)}\n`);
-}
-function assignOtelLogAttribute(attributes, key, value) {
-	if (Object.keys(attributes).length >= 64) return;
-	if (BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS.has(key)) return;
-	if (redactSensitiveText(key) !== key) return;
-	if (!OTEL_LOG_ATTRIBUTE_KEY_RE.test(key)) return;
-	if (typeof value === "string") {
-		attributes[key] = normalizeOtelLogString(value, MAX_OTEL_LOG_ATTRIBUTE_VALUE_CHARS);
-		return;
-	}
-	if (typeof value === "number" && Number.isFinite(value)) {
-		attributes[key] = value;
-		return;
-	}
-	if (typeof value === "boolean") attributes[key] = value;
-}
-function assignOtelLogEventAttributes(attributes, eventAttributes) {
-	if (!eventAttributes) return;
-	for (const [rawKey, value] of Object.entries(eventAttributes)) {
-		if (Object.keys(attributes).length >= 64) break;
-		const key = rawKey.trim();
-		if (BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS.has(key)) continue;
-		if (redactSensitiveText(key) !== key) continue;
-		if (!OTEL_LOG_RAW_ATTRIBUTE_KEY_RE.test(key)) continue;
-		assignOtelLogAttribute(attributes, `openclaw.${key}`, value);
-	}
-}
-function assignOtelSecurityEventAttributes(attributes, eventAttributes) {
-	if (!eventAttributes) return;
-	for (const [rawKey, value] of Object.entries(eventAttributes)) {
-		if (Object.keys(attributes).length >= 64) break;
-		const key = rawKey.trim();
-		if (BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS.has(key)) continue;
-		if (redactSensitiveText(key) !== key) continue;
-		if (!OTEL_LOG_RAW_ATTRIBUTE_KEY_RE.test(key)) continue;
-		assignOtelLogAttribute(attributes, `openclaw.security.attribute.${key}`, typeof value === "string" ? lowCardinalityAttr(value) : value);
-	}
-}
-function securitySeverityText(severity) {
-	switch (severity) {
-		case "critical": return "FATAL";
-		case "high": return "ERROR";
-		case "medium": return "WARN";
-		case "info":
-		case "low": return "INFO";
-	}
-	return severity;
-}
-function assignOtelSecurityAttributes(attributes, evt) {
-	assignOtelLogAttribute(attributes, "openclaw.security.event_id", evt.eventId);
-	assignOtelLogAttribute(attributes, "openclaw.security.category", evt.category);
-	assignOtelLogAttribute(attributes, "openclaw.security.action", lowCardinalityAttr(evt.action));
-	assignOtelLogAttribute(attributes, "openclaw.security.outcome", evt.outcome);
-	assignOtelLogAttribute(attributes, "openclaw.security.severity", evt.severity);
-	if (evt.reason) assignOtelLogAttribute(attributes, "openclaw.security.reason", lowCardinalityAttr(evt.reason));
-	if (evt.actor) {
-		assignOtelLogAttribute(attributes, "openclaw.security.actor.kind", evt.actor.kind);
-		if (evt.actor.idHash) assignOtelLogAttribute(attributes, "openclaw.security.actor.id_hash", lowCardinalityAttr(evt.actor.idHash));
-		if (evt.actor.deviceIdHash) assignOtelLogAttribute(attributes, "openclaw.security.actor.device_id_hash", lowCardinalityAttr(evt.actor.deviceIdHash));
-		if (evt.actor.channel) assignOtelLogAttribute(attributes, "openclaw.security.actor.channel", lowCardinalityAttr(evt.actor.channel));
-		if (evt.actor.role) assignOtelLogAttribute(attributes, "openclaw.security.actor.role", lowCardinalityAttr(evt.actor.role));
-		if (evt.actor.scopes?.length) assignOtelLogAttribute(attributes, "openclaw.security.actor.scopes", evt.actor.scopes.map((scope) => lowCardinalityAttr(scope)).join(","));
-	}
-	if (evt.target) {
-		assignOtelLogAttribute(attributes, "openclaw.security.target.kind", evt.target.kind);
-		if (evt.target.idHash) assignOtelLogAttribute(attributes, "openclaw.security.target.id_hash", lowCardinalityAttr(evt.target.idHash));
-		if (evt.target.name) assignOtelLogAttribute(attributes, "openclaw.security.target.name", securityTargetNameAttr(evt.target.name));
-		if (evt.target.owner) assignOtelLogAttribute(attributes, "openclaw.security.target.owner", lowCardinalityAttr(evt.target.owner));
-	}
-	if (evt.policy) {
-		if (evt.policy.id) assignOtelLogAttribute(attributes, "openclaw.security.policy.id", lowCardinalityAttr(evt.policy.id));
-		if (evt.policy.decision) assignOtelLogAttribute(attributes, "openclaw.security.policy.decision", evt.policy.decision);
-		if (evt.policy.reason) assignOtelLogAttribute(attributes, "openclaw.security.policy.reason", lowCardinalityAttr(evt.policy.reason));
-	}
-	if (evt.control) {
-		if (evt.control.id) assignOtelLogAttribute(attributes, "openclaw.security.control.id", lowCardinalityAttr(evt.control.id));
-		if (evt.control.family) assignOtelLogAttribute(attributes, "openclaw.security.control.family", evt.control.family);
-	}
-	assignOtelSecurityEventAttributes(attributes, evt.attributes);
-}
-//#endregion
 //#region extensions/diagnostics-otel/src/service-exporter.ts
 function normalizeEndpoint(endpoint) {
 	const trimmed = endpoint?.trim();
 	return trimmed ? trimmed.replace(/\/+$/, "") : void 0;
 }
-function resolveOtelUrl(endpoint, path) {
-	if (!endpoint) return;
-	const endpointWithoutQueryOrFragment = endpoint.split(/[?#]/, 1)[0] ?? endpoint;
-	if (/\/v1\/(?:traces|metrics|logs)$/i.test(endpointWithoutQueryOrFragment)) return endpoint;
-	if (/[?#]/u.test(endpoint)) try {
+const SIGNAL_QUALIFIED_OTLP_PATH_PATTERN = /\/v1\/(traces|metrics|logs)$/iu;
+function appendOrReplaceSignalPath(value, path) {
+	const base = value.replace(/\/+$/u, "");
+	return SIGNAL_QUALIFIED_OTLP_PATH_PATTERN.test(base) ? base.replace(SIGNAL_QUALIFIED_OTLP_PATH_PATTERN, `/${path}`) : `${base}/${path}`;
+}
+function resolveSharedOtelUrl(endpoint, path) {
+	const matchedSignal = (endpoint.split(/[?#]/, 1)[0] ?? endpoint).replace(/\/+$/u, "").match(SIGNAL_QUALIFIED_OTLP_PATH_PATTERN)?.[1];
+	const requestedSignal = path.slice(path.lastIndexOf("/") + 1);
+	if (matchedSignal?.toLowerCase() === requestedSignal.toLowerCase()) return endpoint;
+	if (/[?#]/u.test(endpoint)) {
 		const url = new URL(endpoint);
-		url.pathname = `${url.pathname.replace(/\/+$/u, "")}/${path}`;
+		url.pathname = appendOrReplaceSignalPath(url.pathname, path);
 		return url.toString();
-	} catch {}
-	return `${endpoint}/${path}`;
+	}
+	return appendOrReplaceSignalPath(endpoint, path);
+}
+function normalizeSignalEndpoint(endpoint) {
+	return endpoint?.trim() || void 0;
 }
 function resolveSignalOtelUrl(params) {
-	return resolveOtelUrl(normalizeEndpoint(params.signalEndpoint ?? params.signalEnvEndpoint) ?? params.endpoint, params.path);
+	const signalEndpoint = normalizeSignalEndpoint(params.signalEndpoint ?? params.signalEnvEndpoint);
+	const endpoint = signalEndpoint ?? params.endpoint;
+	const signalEnvEndpoint = params.signalEnvEndpoint?.trim() ? params.signalEnvEndpoint : void 0;
+	const sharedEnvEndpoint = params.sharedEnvEndpoint?.trim() ? params.sharedEnvEndpoint : void 0;
+	const consumedSharedEnvEndpoint = signalEnvEndpoint ? void 0 : sharedEnvEndpoint;
+	const appendedSharedEnvEndpoint = consumedSharedEnvEndpoint ? `${consumedSharedEnvEndpoint}${consumedSharedEnvEndpoint.endsWith("/") ? "" : "/"}${params.path}` : void 0;
+	const resolvedEndpoint = endpoint && URL.canParse(endpoint) && !signalEndpoint ? resolveSharedOtelUrl(endpoint, params.path) : endpoint;
+	for (const candidate of [
+		endpoint,
+		signalEnvEndpoint ?? sharedEnvEndpoint,
+		appendedSharedEnvEndpoint,
+		resolvedEndpoint
+	]) if (candidate && !URL.canParse(candidate)) throw new Error("Configured OpenTelemetry collector endpoint is invalid; check the collector URL");
+	return resolvedEndpoint;
 }
 function readOtelEnvFile(params) {
 	const signalEnvName = `OTEL_EXPORTER_OTLP_${params.signalIdentifier}_${params.signalSuffix}`;
 	const filePath = normalizeOtelEnvValue(process.env[signalEnvName]) ?? normalizeOtelEnvValue(process.env[params.sharedEnvName]);
 	if (!filePath) return;
 	try {
-		return readFileSync(nodePath.resolve(process.cwd(), filePath));
-	} catch {
-		params.logger.warn(`diagnostics-otel: ${params.warning}`);
-		return;
-	}
+		const material = readFileSync(nodePath.resolve(process.cwd(), filePath));
+		if (material.length > 0) return material;
+	} catch {}
+	throw new Error(`Configured OpenTelemetry ${params.label} file is missing, empty, or unreadable; refusing insecure export`);
 }
 function normalizeOtelEnvValue(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : void 0;
+	return value?.trim() ? value : void 0;
 }
 function resolveOtelHttpAgentOptions(params) {
-	const { url, signalIdentifier, logger } = params;
-	if (!url) return;
+	const { url, signalIdentifier } = params;
 	const ca = readOtelEnvFile({
 		signalIdentifier,
 		signalSuffix: "CERTIFICATE",
 		sharedEnvName: OTEL_EXPORTER_OTLP_CERTIFICATE_ENV,
-		logger,
-		warning: "failed to read root certificate file"
+		label: "TLS root certificate"
 	});
 	const cert = readOtelEnvFile({
 		signalIdentifier,
 		signalSuffix: "CLIENT_CERTIFICATE",
 		sharedEnvName: OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_ENV,
-		logger,
-		warning: "failed to read client certificate chain file"
+		label: "mTLS client certificate"
 	});
 	const key = readOtelEnvFile({
 		signalIdentifier,
 		signalSuffix: "CLIENT_KEY",
 		sharedEnvName: OTEL_EXPORTER_OTLP_CLIENT_KEY_ENV,
-		logger,
-		warning: "failed to read client certificate private key file"
+		label: "mTLS client private key"
 	});
+	if (cert === void 0 !== (key === void 0)) throw new Error("Configured OpenTelemetry mTLS requires both a client certificate and private key; refusing insecure export");
+	if (!url) return;
 	const agentOptions = {
 		keepAlive: true,
 		...ca !== void 0 ? { ca } : {},
@@ -506,11 +393,11 @@ function resolveOtelHttpAgentOptions(params) {
 			targetUrl: url,
 			agentOptions
 		});
-		return agent ? () => agent : void 0;
+		if (agent) return () => agent;
 	} catch {
-		logger.warn(`diagnostics-otel: env proxy agent unavailable for OTLP ${signalIdentifier.toLowerCase()} exporter; falling back to default Node agent`);
-		return;
+		throw new Error("Configured telemetry proxy is invalid or unsupported; refusing direct export");
 	}
+	return (ca || cert || key) && new URL(url).protocol === "https:" ? agentOptions : void 0;
 }
 function resolveSampleRate(value) {
 	if (typeof value !== "number" || !Number.isFinite(value)) return;
@@ -528,39 +415,12 @@ function formatError(err) {
 }
 function errorCategory(err) {
 	try {
-		if (err instanceof Error && typeof err.name === "string" && err.name.trim()) return lowCardinalityAttr(err.name, "Error");
-		return lowCardinalityAttr(typeof err, "unknown");
+		if (err instanceof Error && typeof err.name === "string" && err.name.trim()) return normalizeDiagnosticValue(err.name, "Error");
+		return normalizeDiagnosticValue(typeof err, "unknown");
 	} catch {
 		return "unknown";
 	}
 }
-function collectNestedErrorCandidates(err) {
-	const queue = [err];
-	const seen = /* @__PURE__ */ new Set();
-	const candidates = [];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current == null || seen.has(current)) continue;
-		seen.add(current);
-		candidates.push(current);
-		if (Array.isArray(current)) {
-			for (const item of current) if (item != null && !seen.has(item)) queue.push(item);
-			continue;
-		}
-		if (typeof current !== "object") continue;
-		const record = current;
-		for (const nested of [
-			record.cause,
-			record.reason,
-			record.original,
-			record.error
-		]) if (nested != null && !seen.has(nested)) queue.push(nested);
-		if (Array.isArray(record.errors)) {
-			for (const nested of record.errors) if (nested != null && !seen.has(nested)) queue.push(nested);
-		}
-	}
-	return candidates;
-}
 function readErrorName(err) {
 	if (!err || typeof err !== "object") return;
 	const name = err.name;
@@ -572,7 +432,13 @@ function readErrorCode(err) {
 	return typeof code === "string" || typeof code === "number" ? code : void 0;
 }
 function findOtlpExporterError(reason) {
-	for (const candidate of collectNestedErrorCandidates(reason)) if (readErrorName(candidate) === "OTLPExporterError" && candidate && typeof candidate === "object") return candidate;
+	for (const candidate of collectErrorGraphCandidates(reason, (current) => Array.isArray(current) ? current : [
+		current.cause,
+		current.reason,
+		current.original,
+		current.error,
+		...Array.isArray(current.errors) ? current.errors : []
+	])) if (readErrorName(candidate) === "OTLPExporterError" && candidate && typeof candidate === "object") return candidate;
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service-events.ts
@@ -583,7 +449,7 @@ function createDiagnosticsEventHandler(params) {
 		try {
 			switch (evt.type) {
 				case "model.usage":
-					recordModelUsage(evt, metadata);
+					recordModelUsage(evt, metadata, privateData.hostPluginId);
 					return;
 				case "webhook.received":
 					recordWebhookReceived(evt);
@@ -736,6 +602,257 @@ function createDiagnosticsEventHandler(params) {
 	};
 }
 //#endregion
+//#region extensions/diagnostics-otel/src/service-exporter-health.ts
+function publicFailureKey(event) {
+	return `${event.reason ?? "unspecified"}\u0000${event.errorCategory ?? "unknown"}`;
+}
+/** Owns route transitions so one producer cannot recover another producer's failure. */
+function createExporterHealthEventEmitter(publish) {
+	const failures = /* @__PURE__ */ new Map();
+	return (event) => {
+		const key = `${event.exporter}\u0000${event.signal}\u0000${event.transport}`;
+		if (event.status === "started" || event.status === "dropped") {
+			failures.delete(key);
+			publish(event);
+			return;
+		}
+		const reason = event.reason ?? "unspecified";
+		if (event.status === "failure") {
+			const route = failures.get(key) ?? { active: /* @__PURE__ */ new Map() };
+			failures.set(key, route);
+			if (route.active.has(reason)) return;
+			route.active.set(reason, event);
+			if (route.reported === void 0) {
+				route.reported = reason;
+				publish(event);
+			}
+			return;
+		}
+		const route = failures.get(key);
+		if (!route?.active.delete(reason) || route.reported !== reason) return;
+		const next = route.active.entries().next().value;
+		if (next) {
+			route.reported = next[0];
+			publish(next[1]);
+			return;
+		}
+		failures.delete(key);
+		publish(event);
+	};
+}
+/** Coalesces private transport transitions into the shipped signal-level public stream. */
+function createPublicExporterHealthEventEmitter(publish) {
+	const signals = /* @__PURE__ */ new Map();
+	return (event) => {
+		const signalKey = `${event.exporter}\u0000${event.signal}`;
+		let state = signals.get(signalKey);
+		if (!state) {
+			if (event.status === "dropped") return;
+			state = {
+				routes: /* @__PURE__ */ new Set(),
+				started: false,
+				routeFailures: /* @__PURE__ */ new Map()
+			};
+			signals.set(signalKey, state);
+		}
+		const routeKey = event.transport;
+		if (event.status === "dropped") {
+			const removed = state.routes.delete(routeKey);
+			state.routeFailures.delete(routeKey);
+			if (!removed || state.routes.size > 0) return;
+			signals.delete(signalKey);
+			publish({
+				...event,
+				status: "dropped"
+			});
+			return;
+		}
+		state.routes.add(routeKey);
+		if (event.status === "started") {
+			state.routeFailures.delete(routeKey);
+			if (state.started) return;
+			state.started = true;
+			publish({
+				...event,
+				status: "started"
+			});
+			return;
+		}
+		if (event.status === "recovered") {
+			state.routeFailures.delete(routeKey);
+			return;
+		}
+		const failureKey = publicFailureKey(event);
+		if (state.routeFailures.get(routeKey) === failureKey) return;
+		const duplicate = [...state.routeFailures.entries()].some(([transport, activeFailure]) => transport !== routeKey && activeFailure === failureKey);
+		state.routeFailures.set(routeKey, failureKey);
+		if (!duplicate) publish({
+			...event,
+			status: "failure"
+		});
+	};
+}
+/**
+* Observes the exporter result callback, which runs only after the OTLP
+* transport has exhausted dependency-owned retries.
+*/
+function observeOtlpExporterHealth(exporter, params) {
+	const observed = exporter;
+	const exportItems = observed.export.bind(observed);
+	const shutdown = observed.shutdown.bind(observed);
+	const emit = (status, reason, error) => {
+		params.emitExporterEvent({
+			exporter: "diagnostics-otel",
+			signal: params.signal,
+			transport: "otlp-http-protobuf",
+			status,
+			reason,
+			...error ? { errorCategory: errorCategory(error) } : {}
+		});
+	};
+	observed.export = (items, resultCallback) => {
+		let dependencyCallbackInvoked = false;
+		try {
+			exportItems(items, (result) => {
+				dependencyCallbackInvoked = true;
+				if (result.code === ExportResultCode.FAILED) emit("failure", "export_failed", result.error);
+				else if (result.code === ExportResultCode.SUCCESS) emit("recovered", "export_failed");
+				resultCallback(result);
+			});
+		} catch (error) {
+			if (!dependencyCallbackInvoked) emit("failure", "export_failed", error);
+			throw error;
+		}
+	};
+	observed.shutdown = async () => {
+		try {
+			await shutdown();
+		} catch (error) {
+			emit("failure", "shutdown_failed", error);
+			throw error;
+		}
+	};
+	return exporter;
+}
+//#endregion
+//#region extensions/diagnostics-otel/src/service-attributes.ts
+function redactOtelAttributes(attributes) {
+	const redactedAttributes = {};
+	for (const [key, value] of Object.entries(attributes)) {
+		if (DROPPED_OTEL_ATTRIBUTE_KEYS.has(key)) continue;
+		redactedAttributes[key] = typeof value === "string" ? redactSensitiveText(value) : value;
+	}
+	return redactedAttributes;
+}
+function securityTargetNameAttr(value, fallback = "unknown") {
+	if (!value) return fallback;
+	const redacted = redactSensitiveText(value.trim());
+	const redactedLower = redacted.toLowerCase();
+	if (redactedLower.startsWith("agent:") || redactedLower.includes(":agent:")) return fallback;
+	return SECURITY_TARGET_NAME_VALUE_RE.test(redacted) ? redacted : fallback;
+}
+function shouldCaptureOtelLogBody(policy) {
+	return policy.logBodies;
+}
+function otelLogTimestampIso(timestamp) {
+	if (timestamp instanceof Date) return timestamp.toISOString();
+	if (typeof timestamp === "number" && Number.isFinite(timestamp)) return new Date(timestamp).toISOString();
+	if (Array.isArray(timestamp)) {
+		const [seconds, nanoseconds] = timestamp;
+		if (Number.isFinite(seconds) && Number.isFinite(nanoseconds)) return new Date(seconds * 1e3 + Math.trunc(nanoseconds / 1e6)).toISOString();
+	}
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function writeStdoutDiagnosticLogRecord(params) {
+	const { logRecord, serviceName, traceContext } = params;
+	const line = {
+		ts: otelLogTimestampIso(logRecord.timestamp),
+		signal: "openclaw.diagnostic.log",
+		"service.name": serviceName,
+		severityText: logRecord.severityText,
+		severityNumber: logRecord.severityNumber,
+		body: logRecord.body,
+		attributes: logRecord.attributes ?? {},
+		...traceContext?.traceId ? { trace_id: traceContext.traceId } : {},
+		...traceContext?.spanId ? { span_id: traceContext.spanId } : {},
+		...traceContext?.traceFlags ? { trace_flags: traceContext.traceFlags } : {}
+	};
+	process.stdout.write(`${JSON.stringify(line)}\n`);
+}
+function assignOtelLogAttribute(attributes, key, value) {
+	if (Object.keys(attributes).length >= 64) return;
+	if (BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS.has(key)) return;
+	if (redactSensitiveText(key) !== key) return;
+	if (!OTEL_LOG_ATTRIBUTE_KEY_RE.test(key)) return;
+	if (typeof value === "string") {
+		attributes[key] = normalizeOtelLogString(value, MAX_OTEL_LOG_ATTRIBUTE_VALUE_CHARS);
+		return;
+	}
+	if (typeof value === "number" && Number.isFinite(value)) {
+		attributes[key] = value;
+		return;
+	}
+	if (typeof value === "boolean") attributes[key] = value;
+}
+function assignOtelEventAttributes(attributes, eventAttributes, keyPrefix, normalizeString) {
+	if (!eventAttributes) return;
+	for (const [rawKey, value] of Object.entries(eventAttributes)) {
+		if (Object.keys(attributes).length >= 64) break;
+		const key = rawKey.trim();
+		if (BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS.has(key) || redactSensitiveText(key) !== key || !OTEL_LOG_RAW_ATTRIBUTE_KEY_RE.test(key)) continue;
+		const normalized = typeof value === "string" && normalizeString ? normalizeString(value) : value;
+		assignOtelLogAttribute(attributes, `${keyPrefix}${key}`, normalized);
+	}
+}
+function assignOtelLogEventAttributes(attributes, eventAttributes) {
+	assignOtelEventAttributes(attributes, eventAttributes, "openclaw.");
+}
+function assignOtelSecurityEventAttributes(attributes, eventAttributes) {
+	assignOtelEventAttributes(attributes, eventAttributes, "openclaw.security.attribute.", normalizeDiagnosticValue);
+}
+function securitySeverityText(severity) {
+	switch (severity) {
+		case "critical": return "FATAL";
+		case "high": return "ERROR";
+		case "medium": return "WARN";
+		case "info":
+		case "low": return "INFO";
+	}
+	return severity;
+}
+function assignOtelSecurityAttributes(attributes, evt) {
+	assignOtelLogAttribute(attributes, "openclaw.security.event_id", evt.eventId);
+	assignOtelLogAttribute(attributes, "openclaw.security.category", evt.category);
+	assignOtelLogAttribute(attributes, "openclaw.security.action", normalizeDiagnosticValue(evt.action));
+	assignOtelLogAttribute(attributes, "openclaw.security.outcome", evt.outcome);
+	assignOtelLogAttribute(attributes, "openclaw.security.severity", evt.severity);
+	if (evt.reason) assignOtelLogAttribute(attributes, "openclaw.security.reason", normalizeDiagnosticValue(evt.reason));
+	if (evt.actor) {
+		assignOtelLogAttribute(attributes, "openclaw.security.actor.kind", evt.actor.kind);
+		if (evt.actor.idHash) assignOtelLogAttribute(attributes, "openclaw.security.actor.id_hash", normalizeDiagnosticValue(evt.actor.idHash));
+		if (evt.actor.deviceIdHash) assignOtelLogAttribute(attributes, "openclaw.security.actor.device_id_hash", normalizeDiagnosticValue(evt.actor.deviceIdHash));
+		if (evt.actor.channel) assignOtelLogAttribute(attributes, "openclaw.security.actor.channel", normalizeDiagnosticValue(evt.actor.channel));
+		if (evt.actor.role) assignOtelLogAttribute(attributes, "openclaw.security.actor.role", normalizeDiagnosticValue(evt.actor.role));
+		if (evt.actor.scopes?.length) assignOtelLogAttribute(attributes, "openclaw.security.actor.scopes", evt.actor.scopes.map((scope) => normalizeDiagnosticValue(scope)).join(","));
+	}
+	if (evt.target) {
+		assignOtelLogAttribute(attributes, "openclaw.security.target.kind", evt.target.kind);
+		if (evt.target.idHash) assignOtelLogAttribute(attributes, "openclaw.security.target.id_hash", normalizeDiagnosticValue(evt.target.idHash));
+		if (evt.target.name) assignOtelLogAttribute(attributes, "openclaw.security.target.name", securityTargetNameAttr(evt.target.name));
+		if (evt.target.owner) assignOtelLogAttribute(attributes, "openclaw.security.target.owner", normalizeDiagnosticValue(evt.target.owner));
+	}
+	if (evt.policy) {
+		if (evt.policy.id) assignOtelLogAttribute(attributes, "openclaw.security.policy.id", normalizeDiagnosticValue(evt.policy.id));
+		if (evt.policy.decision) assignOtelLogAttribute(attributes, "openclaw.security.policy.decision", evt.policy.decision);
+		if (evt.policy.reason) assignOtelLogAttribute(attributes, "openclaw.security.policy.reason", normalizeDiagnosticValue(evt.policy.reason));
+	}
+	if (evt.control) {
+		if (evt.control.id) assignOtelLogAttribute(attributes, "openclaw.security.control.id", normalizeDiagnosticValue(evt.control.id));
+		if (evt.control.family) assignOtelLogAttribute(attributes, "openclaw.security.control.family", evt.control.family);
+	}
+	assignOtelSecurityEventAttributes(attributes, evt.attributes);
+}
+//#endregion
 //#region extensions/diagnostics-otel/src/service-trace-context.ts
 function normalizeTraceContext(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
@@ -789,7 +906,7 @@ const LOG_SEVERITY_MAP = {
 	FATAL: 21
 };
 function createDiagnosticsLogExporter(params) {
-	const { contentCapturePolicy, emitExporterEvent, flushIntervalMs, headers, logger, logsEnabled, logsToOtlp, logsToStdout, logUrl, resource, serviceName } = params;
+	const { contentCapturePolicy, emitExporterEvent, flushIntervalMs, headers, logger, logsEnabled, logsToOtlp, logsToStdout, logHttpAgentOptions, logUrl, resource, serviceName } = params;
 	let logProvider = null;
 	const logSeverityMap = LOG_SEVERITY_MAP;
 	let recordLogRecord;
@@ -797,29 +914,29 @@ function createDiagnosticsLogExporter(params) {
 	if (logsEnabled) {
 		let logRecordExportFailureLastReportedAt = Number.NEGATIVE_INFINITY;
 		let otelLogger;
+		const activeTransports = [...logsToOtlp ? ["otlp-http-protobuf"] : [], ...logsToStdout ? ["stdout"] : []];
 		if (logsToOtlp) {
-			const logHttpAgentOptions = resolveOtelHttpAgentOptions({
-				url: logUrl,
-				signalIdentifier: "LOGS",
-				logger
-			});
 			logProvider = new LoggerProvider({
 				resource,
 				processors: [new BatchLogRecordProcessor({
-					exporter: new OTLPLogExporter({
+					exporter: observeOtlpExporterHealth(new OTLPLogExporter({
 						...logUrl ? { url: logUrl } : {},
 						...headers ? { headers } : {},
 						...logHttpAgentOptions ? { httpAgentOptions: logHttpAgentOptions } : {}
+					}), {
+						emitExporterEvent,
+						signal: "logs"
 					}),
 					...typeof flushIntervalMs === "number" ? { scheduledDelayMillis: Math.max(1e3, flushIntervalMs) } : {}
 				})]
 			});
 			otelLogger = logProvider.getLogger("openclaw");
 		}
-		const reportLogExportFailure = (err, label) => {
+		const reportLogExportFailure = (err, label, transport) => {
 			emitExporterEvent({
 				exporter: "diagnostics-otel",
 				signal: "logs",
+				transport,
 				status: "failure",
 				reason: "emit_failed",
 				errorCategory: errorCategory(err)
@@ -830,14 +947,36 @@ function createDiagnosticsLogExporter(params) {
 				logger.error(`diagnostics-otel: ${label} export failed: ${formatError(err)}`);
 			}
 		};
-		const emitLogRecord = ({ logRecord, traceContext }) => {
-			if (logsToOtlp) otelLogger?.emit(logRecord);
-			if (logsToStdout) writeStdoutDiagnosticLogRecord({
-				logRecord,
-				serviceName,
-				...traceContext ? { traceContext } : {}
+		const reportLogExportRecovery = (transport) => {
+			emitExporterEvent({
+				exporter: "diagnostics-otel",
+				signal: "logs",
+				transport,
+				status: "recovered",
+				reason: "emit_failed"
 			});
 		};
+		const reportLogPreparationFailure = (err, label) => {
+			for (const transport of activeTransports) reportLogExportFailure(err, label, transport);
+		};
+		const emitLogRecord = ({ logRecord, traceContext }, label) => {
+			if (logsToOtlp) try {
+				otelLogger?.emit(logRecord);
+				reportLogExportRecovery("otlp-http-protobuf");
+			} catch (error) {
+				reportLogExportFailure(error, label, "otlp-http-protobuf");
+			}
+			if (logsToStdout) try {
+				writeStdoutDiagnosticLogRecord({
+					logRecord,
+					serviceName,
+					...traceContext ? { traceContext } : {}
+				});
+				reportLogExportRecovery("stdout");
+			} catch (error) {
+				reportLogExportFailure(error, label, "stdout");
+			}
+		};
 		const buildDiagnosticLogRecord = (evt, metadata) => {
 			const logLevelName = evt.level || "INFO";
 			const severityNumber = logSeverityMap[logLevelName] ?? 9;
@@ -886,17 +1025,19 @@ function createDiagnosticsLogExporter(params) {
 		};
 		recordLogRecord = (evt, metadata) => {
 			try {
-				emitLogRecord(buildDiagnosticLogRecord(evt, metadata));
+				const record = buildDiagnosticLogRecord(evt, metadata);
+				emitLogRecord(record, "log record");
 			} catch (err) {
-				reportLogExportFailure(err, "log record");
+				reportLogPreparationFailure(err, "log record");
 			}
 		};
 		recordSecurityEvent = (evt, metadata) => {
 			if (!metadata.trusted) return;
 			try {
-				emitLogRecord(buildSecurityLogRecord(evt, metadata));
+				const record = buildSecurityLogRecord(evt, metadata);
+				emitLogRecord(record, "security event");
 			} catch (err) {
-				reportLogExportFailure(err, "security event");
+				reportLogPreparationFailure(err, "security event");
 			}
 		};
 	}
@@ -908,9 +1049,13 @@ function createDiagnosticsLogExporter(params) {
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service-metrics.ts
-function createDiagnosticsMetrics(meter) {
+const DEFAULT_METRIC_NAME_PREFIX = "openclaw.";
+function createDiagnosticsMetrics(meter, metricNamePrefix = DEFAULT_METRIC_NAME_PREFIX) {
+	const resolveMetricName = (name) => `${metricNamePrefix}${name.slice(9)}`;
+	const createCounter = (name, options) => meter.createCounter(resolveMetricName(name), options);
+	const createHistogram = (name, options) => meter.createHistogram(resolveMetricName(name), options);
 	return {
-		tokensCounter: meter.createCounter("openclaw.tokens", {
+		tokensCounter: createCounter("openclaw.tokens", {
 			unit: "1",
 			description: "Token usage by type"
 		}),
@@ -924,236 +1069,316 @@ function createDiagnosticsMetrics(meter) {
 			description: "GenAI client operation duration",
 			advice: { explicitBucketBoundaries: GEN_AI_OPERATION_DURATION_BUCKETS }
 		}),
-		costCounter: meter.createCounter("openclaw.cost.usd", {
+		costCounter: createCounter("openclaw.cost.usd", {
 			unit: "1",
 			description: "Estimated model cost (USD)"
 		}),
-		durationHistogram: meter.createHistogram("openclaw.run.duration_ms", {
+		durationHistogram: createHistogram("openclaw.run.duration_ms", {
 			unit: "ms",
 			description: "Agent run duration",
 			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
 		}),
-		harnessDurationHistogram: meter.createHistogram("openclaw.harness.duration_ms", {
+		harnessDurationHistogram: createHistogram("openclaw.harness.duration_ms", {
 			unit: "ms",
 			description: "Agent harness lifecycle duration",
 			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
 		}),
-		contextHistogram: meter.createHistogram("openclaw.context.tokens", {
+		contextHistogram: createHistogram("openclaw.context.tokens", {
 			unit: "1",
 			description: "Context window size and usage",
 			advice: { explicitBucketBoundaries: CONTEXT_TOKENS_BUCKETS }
 		}),
-		webhookReceivedCounter: meter.createCounter("openclaw.webhook.received", {
+		webhookReceivedCounter: createCounter("openclaw.webhook.received", {
 			unit: "1",
 			description: "Webhook requests received"
 		}),
-		webhookErrorCounter: meter.createCounter("openclaw.webhook.error", {
+		webhookErrorCounter: createCounter("openclaw.webhook.error", {
 			unit: "1",
 			description: "Webhook processing errors"
 		}),
-		webhookDurationHistogram: meter.createHistogram("openclaw.webhook.duration_ms", {
+		webhookDurationHistogram: createHistogram("openclaw.webhook.duration_ms", {
 			unit: "ms",
 			description: "Webhook processing duration"
 		}),
-		messageQueuedCounter: meter.createCounter("openclaw.message.queued", {
+		messageQueuedCounter: createCounter("openclaw.message.queued", {
 			unit: "1",
 			description: "Messages queued for processing"
 		}),
-		messageReceivedCounter: meter.createCounter("openclaw.message.received", {
+		messageReceivedCounter: createCounter("openclaw.message.received", {
 			unit: "1",
 			description: "Inbound messages received"
 		}),
-		messageDispatchStartedCounter: meter.createCounter("openclaw.message.dispatch.started", {
+		messageDispatchStartedCounter: createCounter("openclaw.message.dispatch.started", {
 			unit: "1",
 			description: "Inbound message dispatch attempts started"
 		}),
-		messageDispatchCompletedCounter: meter.createCounter("openclaw.message.dispatch.completed", {
+		messageDispatchCompletedCounter: createCounter("openclaw.message.dispatch.completed", {
 			unit: "1",
 			description: "Inbound message dispatch attempts completed"
 		}),
-		messageDispatchDurationHistogram: meter.createHistogram("openclaw.message.dispatch.duration_ms", {
+		messageDispatchDurationHistogram: createHistogram("openclaw.message.dispatch.duration_ms", {
 			unit: "ms",
 			description: "Inbound message dispatch duration"
 		}),
-		messageProcessedCounter: meter.createCounter("openclaw.message.processed", {
+		messageProcessedCounter: createCounter("openclaw.message.processed", {
 			unit: "1",
 			description: "Messages processed by outcome"
 		}),
-		messageDurationHistogram: meter.createHistogram("openclaw.message.duration_ms", {
+		messageDurationHistogram: createHistogram("openclaw.message.duration_ms", {
 			unit: "ms",
 			description: "Message processing duration"
 		}),
-		messageDeliveryStartedCounter: meter.createCounter("openclaw.message.delivery.started", {
+		messageDeliveryStartedCounter: createCounter("openclaw.message.delivery.started", {
 			unit: "1",
 			description: "Outbound message delivery attempts started"
 		}),
-		messageDeliveryDurationHistogram: meter.createHistogram("openclaw.message.delivery.duration_ms", {
+		messageDeliveryDurationHistogram: createHistogram("openclaw.message.delivery.duration_ms", {
 			unit: "ms",
 			description: "Outbound message delivery duration"
 		}),
-		queueDepthHistogram: meter.createHistogram("openclaw.queue.depth", {
+		queueDepthHistogram: createHistogram("openclaw.queue.depth", {
 			unit: "1",
 			description: "Queue depth on enqueue/dequeue"
 		}),
-		queueWaitHistogram: meter.createHistogram("openclaw.queue.wait_ms", {
+		queueWaitHistogram: createHistogram("openclaw.queue.wait_ms", {
 			unit: "ms",
 			description: "Queue wait time before execution"
 		}),
-		laneEnqueueCounter: meter.createCounter("openclaw.queue.lane.enqueue", {
+		laneEnqueueCounter: createCounter("openclaw.queue.lane.enqueue", {
 			unit: "1",
 			description: "Command queue lane enqueue events"
 		}),
-		laneDequeueCounter: meter.createCounter("openclaw.queue.lane.dequeue", {
+		laneDequeueCounter: createCounter("openclaw.queue.lane.dequeue", {
 			unit: "1",
 			description: "Command queue lane dequeue events"
 		}),
-		sessionStateCounter: meter.createCounter("openclaw.session.state", {
+		sessionStateCounter: createCounter("openclaw.session.state", {
 			unit: "1",
 			description: "Session state transitions"
 		}),
-		sessionTurnCreatedCounter: meter.createCounter("openclaw.session.turn.created", {
+		sessionTurnCreatedCounter: createCounter("openclaw.session.turn.created", {
 			unit: "1",
 			description: "Agent session turns created"
 		}),
-		sessionStuckCounter: meter.createCounter("openclaw.session.stuck", {
+		sessionStuckCounter: createCounter("openclaw.session.stuck", {
 			unit: "1",
 			description: "Sessions stuck in processing"
 		}),
-		sessionStuckAgeHistogram: meter.createHistogram("openclaw.session.stuck_age_ms", {
+		sessionStuckAgeHistogram: createHistogram("openclaw.session.stuck_age_ms", {
 			unit: "ms",
 			description: "Age of stuck sessions"
 		}),
-		sessionRecoveryRequestedCounter: meter.createCounter("openclaw.session.recovery.requested", {
+		sessionRecoveryRequestedCounter: createCounter("openclaw.session.recovery.requested", {
 			unit: "1",
 			description: "Session recovery attempts requested"
 		}),
-		sessionRecoveryCompletedCounter: meter.createCounter("openclaw.session.recovery.completed", {
+		sessionRecoveryCompletedCounter: createCounter("openclaw.session.recovery.completed", {
 			unit: "1",
 			description: "Session recovery attempts completed"
 		}),
-		sessionRecoveryAgeHistogram: meter.createHistogram("openclaw.session.recovery.age_ms", {
+		sessionRecoveryAgeHistogram: createHistogram("openclaw.session.recovery.age_ms", {
 			unit: "ms",
 			description: "Age of sessions selected for recovery"
 		}),
-		talkEventCounter: meter.createCounter("openclaw.talk.event", {
+		talkEventCounter: createCounter("openclaw.talk.event", {
 			unit: "1",
 			description: "Talk events emitted by type"
 		}),
-		talkEventDurationHistogram: meter.createHistogram("openclaw.talk.event.duration_ms", {
+		talkEventDurationHistogram: createHistogram("openclaw.talk.event.duration_ms", {
 			unit: "ms",
 			description: "Talk event duration when reported"
 		}),
-		talkAudioBytesHistogram: meter.createHistogram("openclaw.talk.audio.bytes", {
+		talkAudioBytesHistogram: createHistogram("openclaw.talk.audio.bytes", {
 			unit: "By",
 			description: "Talk audio frame byte lengths"
 		}),
-		runAttemptCounter: meter.createCounter("openclaw.run.attempt", {
+		runAttemptCounter: createCounter("openclaw.run.attempt", {
 			unit: "1",
 			description: "Run attempts"
 		}),
-		toolLoopCounter: meter.createCounter("openclaw.tool.loop", {
+		toolLoopCounter: createCounter("openclaw.tool.loop", {
 			unit: "1",
 			description: "Detected repetitive tool-call loop events"
 		}),
-		skillUsedCounter: meter.createCounter("openclaw.skill.used", {
+		skillUsedCounter: createCounter("openclaw.skill.used", {
 			unit: "1",
 			description: "Skills used by agent runs"
 		}),
-		modelCallDurationHistogram: meter.createHistogram("openclaw.model_call.duration_ms", {
+		modelCallDurationHistogram: createHistogram("openclaw.model_call.duration_ms", {
 			unit: "ms",
 			description: "Model call duration"
 		}),
-		modelCallRequestBytesHistogram: meter.createHistogram("openclaw.model_call.request_bytes", {
+		modelCallRequestBytesHistogram: createHistogram("openclaw.model_call.request_bytes", {
 			unit: "By",
 			description: "UTF-8 byte size of sanitized model request payloads"
 		}),
-		modelCallResponseBytesHistogram: meter.createHistogram("openclaw.model_call.response_bytes", {
+		modelCallResponseBytesHistogram: createHistogram("openclaw.model_call.response_bytes", {
 			unit: "By",
 			description: "UTF-8 byte size of bounded streamed model response payloads"
 		}),
-		modelCallTimeToFirstByteHistogram: meter.createHistogram("openclaw.model_call.time_to_first_byte_ms", {
+		modelCallTimeToFirstByteHistogram: createHistogram("openclaw.model_call.time_to_first_byte_ms", {
 			unit: "ms",
 			description: "Elapsed time before the first streamed model response event"
 		}),
-		modelFailoverCounter: meter.createCounter("openclaw.model.failover", {
+		modelFailoverCounter: createCounter("openclaw.model.failover", {
 			unit: "1",
 			description: "Model failovers by source, destination, lane, and reason"
 		}),
-		toolExecutionDurationHistogram: meter.createHistogram("openclaw.tool.execution.duration_ms", {
+		toolExecutionDurationHistogram: createHistogram("openclaw.tool.execution.duration_ms", {
 			unit: "ms",
 			description: "Tool execution duration"
 		}),
-		toolExecutionBlockedCounter: meter.createCounter("openclaw.tool.execution.blocked", {
+		toolExecutionBlockedCounter: createCounter("openclaw.tool.execution.blocked", {
 			unit: "1",
 			description: "Tool executions blocked by policy or sandbox diagnostics"
 		}),
-		execProcessDurationHistogram: meter.createHistogram("openclaw.exec.duration_ms", {
+		execProcessDurationHistogram: createHistogram("openclaw.exec.duration_ms", {
 			unit: "ms",
 			description: "Exec process duration"
 		}),
-		memoryRssHistogram: meter.createHistogram("openclaw.memory.rss_bytes", {
+		memoryRssHistogram: createHistogram("openclaw.memory.rss_bytes", {
 			unit: "By",
 			description: "Resident set size reported by diagnostic memory samples"
 		}),
-		memoryHeapUsedHistogram: meter.createHistogram("openclaw.memory.heap_used_bytes", {
+		memoryHeapUsedHistogram: createHistogram("openclaw.memory.heap_used_bytes", {
 			unit: "By",
 			description: "Heap used bytes reported by diagnostic memory samples"
 		}),
-		memoryHeapTotalHistogram: meter.createHistogram("openclaw.memory.heap_total_bytes", {
+		memoryHeapTotalHistogram: createHistogram("openclaw.memory.heap_total_bytes", {
 			unit: "By",
 			description: "Heap total bytes reported by diagnostic memory samples"
 		}),
-		memoryExternalHistogram: meter.createHistogram("openclaw.memory.external_bytes", {
+		memoryExternalHistogram: createHistogram("openclaw.memory.external_bytes", {
 			unit: "By",
 			description: "External memory bytes reported by diagnostic memory samples"
 		}),
-		memoryArrayBuffersHistogram: meter.createHistogram("openclaw.memory.array_buffers_bytes", {
+		memoryArrayBuffersHistogram: createHistogram("openclaw.memory.array_buffers_bytes", {
 			unit: "By",
 			description: "ArrayBuffer bytes reported by diagnostic memory samples"
 		}),
-		memoryPressureCounter: meter.createCounter("openclaw.memory.pressure", {
+		memoryPressureCounter: createCounter("openclaw.memory.pressure", {
 			unit: "1",
 			description: "Diagnostic memory pressure events"
 		}),
-		asyncQueueDroppedCounter: meter.createCounter("openclaw.diagnostic.async_queue.dropped", {
+		asyncQueueDroppedCounter: createCounter("openclaw.diagnostic.async_queue.dropped", {
 			unit: "1",
 			description: "Async diagnostic queue drops by dropped event class"
 		}),
-		payloadLargeCounter: meter.createCounter("openclaw.payload.large", {
+		payloadLargeCounter: createCounter("openclaw.payload.large", {
 			unit: "1",
 			description: "Oversized payload diagnostics by surface and action"
 		}),
-		payloadLargeBytesHistogram: meter.createHistogram("openclaw.payload.large_bytes", {
+		payloadLargeBytesHistogram: createHistogram("openclaw.payload.large_bytes", {
 			unit: "By",
 			description: "Oversized payload byte sizes by surface and action"
 		}),
-		livenessWarningCounter: meter.createCounter("openclaw.liveness.warning", {
+		livenessWarningCounter: createCounter("openclaw.liveness.warning", {
 			unit: "1",
 			description: "Diagnostic liveness warning events"
 		}),
-		livenessEventLoopDelayP99Histogram: meter.createHistogram("openclaw.liveness.event_loop_delay_p99_ms", {
+		livenessEventLoopDelayP99Histogram: createHistogram("openclaw.liveness.event_loop_delay_p99_ms", {
 			unit: "ms",
 			description: "P99 event-loop delay reported by diagnostic liveness warnings"
 		}),
-		livenessEventLoopDelayMaxHistogram: meter.createHistogram("openclaw.liveness.event_loop_delay_max_ms", {
+		livenessEventLoopDelayMaxHistogram: createHistogram("openclaw.liveness.event_loop_delay_max_ms", {
 			unit: "ms",
 			description: "Maximum event-loop delay reported by diagnostic liveness warnings"
 		}),
-		livenessEventLoopUtilizationHistogram: meter.createHistogram("openclaw.liveness.event_loop_utilization", {
+		livenessEventLoopUtilizationHistogram: createHistogram("openclaw.liveness.event_loop_utilization", {
 			unit: "1",
 			description: "Event-loop utilization reported by diagnostic liveness warnings"
 		}),
-		livenessCpuCoreRatioHistogram: meter.createHistogram("openclaw.liveness.cpu_core_ratio", {
+		livenessCpuCoreRatioHistogram: createHistogram("openclaw.liveness.cpu_core_ratio", {
 			unit: "1",
 			description: "CPU core ratio reported by diagnostic liveness warnings"
 		}),
-		telemetryExporterCounter: meter.createCounter("openclaw.telemetry.exporter.events", {
+		telemetryExporterCounter: createCounter("openclaw.telemetry.exporter.events", {
 			unit: "1",
 			description: "Diagnostic telemetry exporter lifecycle and failure events"
 		})
 	};
 }
 //#endregion
+//#region extensions/diagnostics-otel/src/service-propagation.ts
+const DEFAULT_PROPAGATORS = ["tracecontext", "baggage"];
+const CONTEXT_OWNER_KEY = createContextKey("openclaw.owned-sdk.context-owner");
+const PROPAGATOR_OWNER_KEY = createContextKey("openclaw.owned-sdk.propagator-owner");
+var OwnedContextManager = class extends AsyncLocalStorageContextManager {
+	constructor(owner) {
+		super();
+		this.owner = owner;
+	}
+	with(activeContext, fn, thisArg, ...args) {
+		const probe = activeContext.getValue(CONTEXT_OWNER_KEY);
+		if (probe && typeof probe === "object") probe.owner = this.owner;
+		return super.with(activeContext, fn, thisArg, ...args);
+	}
+};
+var OwnedPropagator = class {
+	constructor(delegate, owner) {
+		this.delegate = delegate;
+		this.owner = owner;
+	}
+	inject(carrierContext, carrier, setter) {
+		const probe = carrierContext.getValue(PROPAGATOR_OWNER_KEY);
+		if (probe && typeof probe === "object") {
+			probe.owner = this.owner;
+			return;
+		}
+		this.delegate.inject(carrierContext, carrier, setter);
+	}
+	extract(carrierContext, carrier, getter) {
+		return this.delegate.extract(carrierContext, carrier, getter);
+	}
+	fields() {
+		return this.delegate.fields();
+	}
+};
+function ownsGlobalPropagator(owner) {
+	const probe = {};
+	propagation.inject(ROOT_CONTEXT.setValue(PROPAGATOR_OWNER_KEY, probe), {}, { set() {} });
+	return probe.owner === owner;
+}
+function ownsGlobalContextManager(owner) {
+	const probe = {};
+	context.with(ROOT_CONTEXT.setValue(CONTEXT_OWNER_KEY, probe), () => {});
+	return probe.owner === owner;
+}
+function createConfiguredPropagator(warn) {
+	const names = (getStringListFromEnv("OTEL_PROPAGATORS") ?? DEFAULT_PROPAGATORS).map((name) => name.toLowerCase());
+	if (names.includes("none")) return null;
+	const propagators = [...new Set(names)].flatMap((name) => {
+		switch (name) {
+			case "tracecontext": return [new W3CTraceContextPropagator()];
+			case "baggage": return [new W3CBaggagePropagator()];
+			case "b3": return [new B3Propagator()];
+			case "b3multi": return [new B3Propagator({ injectEncoding: B3InjectEncoding.MULTI_HEADER })];
+			case "jaeger":
+				warn("The Jaeger propagator is deprecated and will be removed in a future release. Use the W3C TraceContext propagator (\"tracecontext\") instead.");
+				return [new JaegerPropagator()];
+			default:
+				warn(`Propagator "${name}" requested through environment variable is unavailable.`);
+				return [];
+		}
+	});
+	if (propagators.length === 0) return null;
+	return propagators.length === 1 ? propagators[0] : new CompositePropagator({ propagators });
+}
+function registerOwnedSdkRuntime(warn) {
+	const owner = {};
+	const contextManager = new OwnedContextManager(owner).enable();
+	const ownsContext = context.setGlobalContextManager(contextManager);
+	if (!ownsContext) contextManager.disable();
+	const propagator = createConfiguredPropagator(warn);
+	const ownsPropagation = propagator ? propagation.setGlobalPropagator(new OwnedPropagator(propagator, owner)) : false;
+	if (!ownsContext && !ownsPropagation) return null;
+	return () => {
+		if (ownsPropagation && ownsGlobalPropagator(owner)) propagation.disable();
+		if (ownsContext && ownsGlobalContextManager(owner)) context.disable();
+		else if (ownsContext) contextManager.disable();
+	};
+}
+//#endregion
 //#region extensions/diagnostics-otel/src/service-recorder-runtime.ts
 function createDiagnosticsRecorderRuntime(params) {
 	return {
@@ -1168,12 +1393,12 @@ function createDiagnosticsRecorderRuntime(params) {
 function createHarnessRecorders(runtime) {
 	const { harnessDurationHistogram, modelFailoverCounter, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, trackTrustedSpan, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
 	const harnessRunMetricAttrs = (evt) => ({
-		"openclaw.harness.id": lowCardinalityAttr(evt.harnessId, "unknown"),
-		"openclaw.harness.plugin": lowCardinalityAttr(evt.pluginId),
+		"openclaw.harness.id": normalizeDiagnosticValue(evt.harnessId, "unknown"),
+		"openclaw.harness.plugin": normalizeDiagnosticValue(evt.pluginId),
 		...evt.type === "harness.run.started" ? {} : { "openclaw.outcome": evt.type === "harness.run.error" ? "error" : evt.outcome },
-		"openclaw.provider": lowCardinalityAttr(evt.provider, "unknown"),
-		"openclaw.model": lowCardinalityAttr(evt.model, "unknown"),
-		...evt.channel ? { "openclaw.channel": lowCardinalityAttr(evt.channel) } : {}
+		"openclaw.provider": normalizeDiagnosticValue(evt.provider, "unknown"),
+		"openclaw.model": normalizeDiagnosticValue(evt.model, "unknown"),
+		...evt.channel ? { "openclaw.channel": normalizeDiagnosticValue(evt.channel) } : {}
 	});
 	const recordHarnessRunStarted = (evt, metadata) => {
 		if (!tracesEnabled || !metadata.trusted) return;
@@ -1186,7 +1411,7 @@ function createHarnessRecorders(runtime) {
 		harnessDurationHistogram.record(evt.durationMs, harnessRunMetricAttrs(evt));
 		if (!tracesEnabled) return;
 		const spanAttrs = { ...harnessRunMetricAttrs(evt) };
-		if (evt.resultClassification) spanAttrs["openclaw.harness.result_classification"] = lowCardinalityAttr(evt.resultClassification);
+		if (evt.resultClassification) spanAttrs["openclaw.harness.result_classification"] = normalizeDiagnosticValue(evt.resultClassification);
 		if (typeof evt.yieldDetected === "boolean") spanAttrs["openclaw.harness.yield_detected"] = evt.yieldDetected;
 		if (evt.itemLifecycle) {
 			spanAttrs["openclaw.harness.items.started"] = evt.itemLifecycle.startedCount;
@@ -1213,7 +1438,7 @@ function createHarnessRecorders(runtime) {
 		span.end(evt.ts);
 	};
 	const recordHarnessRunError = (evt, metadata, privateData) => {
-		const errorType = lowCardinalityAttr(evt.errorCategory, "other");
+		const errorType = normalizeDiagnosticValue(evt.errorCategory, "other");
 		const attrs = {
 			...harnessRunMetricAttrs(evt),
 			"openclaw.harness.phase": evt.phase,
@@ -1266,22 +1491,22 @@ function createHarnessRecorders(runtime) {
 	};
 	const recordModelFailover = (evt, metadata) => {
 		const metricAttrs = {
-			"openclaw.failover.reason": lowCardinalityAttr(evt.reason, "unknown"),
+			"openclaw.failover.reason": normalizeDiagnosticValue(evt.reason, "unknown"),
 			"openclaw.failover.suspended": evt.suspended === void 0 ? "unknown" : String(evt.suspended),
-			"openclaw.lane": lowCardinalityQueueLaneAttr(evt.lane, "unknown"),
-			"openclaw.model": lowCardinalityAttr(evt.fromModel),
-			"openclaw.provider": lowCardinalityAttr(evt.fromProvider),
-			"openclaw.failover.to_model": lowCardinalityAttr(evt.toModel),
-			"openclaw.failover.to_provider": lowCardinalityAttr(evt.toProvider)
+			"openclaw.lane": normalizeDiagnosticLane(evt.lane, "unknown"),
+			"openclaw.model": normalizeDiagnosticValue(evt.fromModel),
+			"openclaw.provider": normalizeDiagnosticValue(evt.fromProvider),
+			"openclaw.failover.to_model": normalizeDiagnosticValue(evt.toModel),
+			"openclaw.failover.to_provider": normalizeDiagnosticValue(evt.toProvider)
 		};
 		modelFailoverCounter.add(1, metricAttrs);
 		if (!tracesEnabled) return;
-		const spanAttrs = { "openclaw.failover.reason": lowCardinalityAttr(evt.reason, "unknown") };
+		const spanAttrs = { "openclaw.failover.reason": normalizeDiagnosticValue(evt.reason, "unknown") };
 		if (evt.fromProvider) spanAttrs["openclaw.provider"] = evt.fromProvider;
 		if (evt.fromModel) spanAttrs["openclaw.model"] = evt.fromModel;
 		if (evt.toProvider) spanAttrs["openclaw.failover.to_provider"] = evt.toProvider;
 		if (evt.toModel) spanAttrs["openclaw.failover.to_model"] = evt.toModel;
-		if (evt.lane) spanAttrs["openclaw.lane"] = lowCardinalityQueueLaneAttr(evt.lane, "unknown");
+		if (evt.lane) spanAttrs["openclaw.lane"] = normalizeDiagnosticLane(evt.lane, "unknown");
 		if (evt.suspended !== void 0) spanAttrs["openclaw.failover.suspended"] = evt.suspended;
 		if (evt.cascadeDepth !== void 0) spanAttrs["openclaw.failover.cascade_depth"] = evt.cascadeDepth;
 		spanWithDuration("openclaw.model.failover", spanAttrs, 0, {
@@ -1314,7 +1539,13 @@ function genAiOperationName(api, observationUnit) {
 	return "chat";
 }
 function positiveFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+	return asFiniteNumberInRange(value, {
+		min: 0,
+		minExclusive: true
+	});
+}
+function nonNegativeFiniteNumber(value) {
+	return asFiniteNumberInRange(value, { min: 0 });
 }
 function assignPositiveNumberAttr(attrs, key, value) {
 	const normalized = positiveFiniteNumber(value);
@@ -1326,15 +1557,17 @@ function assignModelCallSizeTimingAttrs(attrs, evt) {
 	assignPositiveNumberAttr(attrs, "openclaw.model_call.time_to_first_byte_ms", evt.timeToFirstByteMs);
 }
 function assignNumberAttr(attrs, key, value) {
-	if (typeof value === "number" && Number.isFinite(value)) attrs[key] = value;
+	const normalized = asFiniteNumber(value);
+	if (normalized !== void 0) attrs[key] = normalized;
 }
 function modelCallPromptTokens(usage) {
-	if (typeof usage.promptTokens === "number" && Number.isFinite(usage.promptTokens)) return usage.promptTokens;
-	const input = usage.input ?? 0;
-	const cacheRead = usage.cacheRead ?? 0;
-	const cacheWrite = usage.cacheWrite ?? 0;
-	const total = input + cacheRead + cacheWrite;
-	return total > 0 ? total : void 0;
+	const promptTokens = nonNegativeFiniteNumber(usage.promptTokens);
+	if (promptTokens !== void 0) return promptTokens;
+	const input = nonNegativeFiniteNumber(usage.input);
+	const cacheRead = nonNegativeFiniteNumber(usage.cacheRead);
+	const cacheWrite = nonNegativeFiniteNumber(usage.cacheWrite);
+	if (input === void 0 && cacheRead === void 0 && cacheWrite === void 0) return;
+	return (input ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
 }
 function assignModelCallPromptStatsAttrs(attrs, evt) {
 	const stats = evt.promptStats;
@@ -1364,11 +1597,14 @@ function assignModelCallUsageAttrs(attrs, evt) {
 		["gen_ai.usage.output_tokens", usage.output],
 		["gen_ai.usage.cache_read.input_tokens", usage.cacheRead],
 		["gen_ai.usage.cache_creation.input_tokens", usage.cacheWrite]
-	]) assignPositiveNumberAttr(attrs, key, value);
+	]) {
+		const normalized = nonNegativeFiniteNumber(value);
+		if (normalized !== void 0) attrs[key] = normalized;
+	}
 }
 function assignGenAiSpanIdentityAttrs(attrs, input) {
-	if (emitLatestGenAiSemconv()) attrs["gen_ai.provider.name"] = lowCardinalityAttr(input.provider);
-	else attrs["gen_ai.system"] = lowCardinalityAttr(input.provider);
+	if (emitLatestGenAiSemconv()) attrs["gen_ai.provider.name"] = normalizeDiagnosticValue(input.provider);
+	else attrs["gen_ai.system"] = normalizeDiagnosticValue(input.provider);
 	if (input.model) attrs["gen_ai.request.model"] = redactSensitiveText(input.model.trim());
 	attrs["gen_ai.operation.name"] = genAiOperationName(input.api, input.observationUnit);
 }
@@ -1382,14 +1618,14 @@ function modelCallObservationUnit(evt) {
 function modelCallSpanName(evt) {
 	if (!emitLatestGenAiSemconv()) return "openclaw.model.call";
 	const operationName = genAiOperationName(evt.api, evt.observationUnit);
-	return operationName === GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT ? operationName : `${operationName} ${lowCardinalityAttr(evt.model)}`;
+	return operationName === GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT ? operationName : `${operationName} ${normalizeDiagnosticValue(evt.model)}`;
 }
 function modelCallSpanKind() {
 	return SpanKind.CLIENT;
 }
 function addUpstreamRequestIdSpanEvent(span, upstreamRequestIdHash) {
 	if (!upstreamRequestIdHash) return;
-	const boundedHash = lowCardinalityAttr(upstreamRequestIdHash);
+	const boundedHash = normalizeDiagnosticValue(upstreamRequestIdHash);
 	if (boundedHash === "unknown") return;
 	span.addEvent?.("openclaw.provider.request", { "openclaw.upstreamRequestIdHash": boundedHash });
 }
@@ -1626,18 +1862,18 @@ function assignOtelToolContentAttributes(attributes, content, policy) {
 //#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-model.ts
 function createModelRecorders(runtime) {
-	const { genAiOperationDurationHistogram, modelCallDurationHistogram, modelCallRequestBytesHistogram, modelCallResponseBytesHistogram, modelCallTimeToFirstByteHistogram, spanWithDuration, activeTrustedParentContext, trackTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, contentCapturePolicy, tracesEnabled } = runtime;
+	const { genAiOperationDurationHistogram, modelCallDurationHistogram, modelCallRequestBytesHistogram, modelCallResponseBytesHistogram, modelCallTimeToFirstByteHistogram, spanWithDuration, activeTrustedParentContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, contentCapturePolicy, tracesEnabled } = runtime;
 	const modelCallMetricAttrs = (evt) => ({
 		"openclaw.provider": evt.provider,
 		"openclaw.model": evt.model,
-		"openclaw.api": lowCardinalityAttr(evt.api),
-		"openclaw.transport": lowCardinalityAttr(evt.transport),
+		"openclaw.api": normalizeDiagnosticValue(evt.api),
+		"openclaw.transport": normalizeDiagnosticValue(evt.transport),
 		"openclaw.model_call.observation_unit": modelCallObservationUnit(evt)
 	});
 	const genAiModelCallMetricAttrs = (evt, errorType) => ({
 		"gen_ai.operation.name": genAiOperationName(evt.api, evt.observationUnit),
-		"gen_ai.provider.name": lowCardinalityAttr(evt.provider),
-		"gen_ai.request.model": lowCardinalityAttr(evt.model),
+		"gen_ai.provider.name": normalizeDiagnosticValue(evt.provider),
+		"gen_ai.request.model": normalizeDiagnosticValue(evt.model),
 		...errorType ? { "error.type": errorType } : {}
 	});
 	const recordGenAiModelCallDuration = (evt, errorType) => {
@@ -1653,6 +1889,8 @@ function createModelRecorders(runtime) {
 	};
 	const recordModelCallStarted = (evt, metadata) => {
 		if (!tracesEnabled || !metadata.trusted) return;
+		const trackedSpan = getTrackedInternalOrTrustedSpan(evt, metadata);
+		if (trackedSpan) return trackedSpan.spanContext();
 		const spanAttrs = {
 			"openclaw.provider": evt.provider,
 			"openclaw.model": evt.model
@@ -1661,11 +1899,11 @@ function createModelRecorders(runtime) {
 		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
 		if (evt.transport) spanAttrs["openclaw.transport"] = evt.transport;
 		assignModelCallPromptStatsAttrs(spanAttrs, evt);
-		trackTrustedSpan(evt, metadata, spanWithDuration(modelCallSpanName(evt), spanAttrs, void 0, {
+		return trackTrustedSpan(evt, metadata, spanWithDuration(modelCallSpanName(evt), spanAttrs, void 0, {
 			kind: modelCallSpanKind(),
 			parentContext: activeTrustedParentContext(evt, metadata),
 			startTimeMs: evt.ts
-		}));
+		})).spanContext();
 	};
 	const recordModelCallCompleted = (evt, metadata, modelContent) => {
 		const metricAttrs = modelCallMetricAttrs(evt);
@@ -1694,11 +1932,11 @@ function createModelRecorders(runtime) {
 		span.end(evt.ts);
 	};
 	const recordModelCallError = (evt, metadata, modelContent) => {
-		const errorType = lowCardinalityAttr(evt.errorCategory, "other");
+		const errorType = normalizeDiagnosticValue(evt.errorCategory, "other");
 		const metricAttrs = {
 			...modelCallMetricAttrs(evt),
 			"openclaw.errorCategory": errorType,
-			...evt.failureKind ? { "openclaw.failureKind": lowCardinalityAttr(evt.failureKind, "other") } : {}
+			...evt.failureKind ? { "openclaw.failureKind": normalizeDiagnosticValue(evt.failureKind, "other") } : {}
 		};
 		modelCallDurationHistogram.record(evt.durationMs, metricAttrs);
 		recordModelCallSizeTimingMetrics(evt, metricAttrs);
@@ -1710,7 +1948,7 @@ function createModelRecorders(runtime) {
 			"openclaw.errorCategory": errorType,
 			"error.type": errorType
 		};
-		if (evt.failureKind) spanAttrs["openclaw.failureKind"] = lowCardinalityAttr(evt.failureKind, "other");
+		if (evt.failureKind) spanAttrs["openclaw.failureKind"] = normalizeDiagnosticValue(evt.failureKind, "other");
 		assignGenAiModelCallAttrs(spanAttrs, evt);
 		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
 		if (evt.transport) spanAttrs["openclaw.transport"] = evt.transport;
@@ -1743,12 +1981,12 @@ function createModelRecorders(runtime) {
 function createOperationsRecorders(runtime) {
 	const { durationHistogram, queueDepthHistogram, queueWaitHistogram, laneEnqueueCounter, laneDequeueCounter, sessionStateCounter, sessionTurnCreatedCounter, sessionStuckCounter, sessionStuckAgeHistogram, sessionRecoveryRequestedCounter, sessionRecoveryCompletedCounter, sessionRecoveryAgeHistogram, talkEventCounter, talkEventDurationHistogram, talkAudioBytesHistogram, runAttemptCounter, toolLoopCounter, memoryRssHistogram, memoryHeapUsedHistogram, memoryHeapTotalHistogram, memoryExternalHistogram, memoryArrayBuffersHistogram, memoryPressureCounter, asyncQueueDroppedCounter, tracer, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
 	const recordLaneEnqueue = (evt) => {
-		const attrs = { "openclaw.lane": lowCardinalityQueueLaneAttr(evt.lane) };
+		const attrs = { "openclaw.lane": normalizeDiagnosticLane(evt.lane) };
 		laneEnqueueCounter.add(1, attrs);
 		queueDepthHistogram.record(evt.queueSize, attrs);
 	};
 	const recordLaneDequeue = (evt) => {
-		const attrs = { "openclaw.lane": lowCardinalityQueueLaneAttr(evt.lane) };
+		const attrs = { "openclaw.lane": normalizeDiagnosticLane(evt.lane) };
 		laneDequeueCounter.add(1, attrs);
 		queueDepthHistogram.record(evt.queueSize, attrs);
 		if (typeof evt.waitMs === "number") queueWaitHistogram.record(evt.waitMs, attrs);
@@ -1760,8 +1998,8 @@ function createOperationsRecorders(runtime) {
 	};
 	const recordSessionTurnCreated = (evt) => {
 		sessionTurnCreatedCounter.add(1, {
-			"openclaw.agent": lowCardinalityAttr(evt.agentId, "unknown"),
-			"openclaw.channel": lowCardinalityAttr(evt.channel, "unknown"),
+			"openclaw.agent": normalizeDiagnosticValue(evt.agentId, "unknown"),
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel, "unknown"),
 			"openclaw.trigger": evt.trigger
 		});
 	};
@@ -1795,17 +2033,17 @@ function createOperationsRecorders(runtime) {
 	const recordSessionRecoveryCompleted = (evt) => {
 		const attrs = sessionRecoveryAttrs(evt);
 		attrs["openclaw.status"] = evt.status;
-		attrs["openclaw.action"] = lowCardinalityAttr(evt.action, "unknown");
+		attrs["openclaw.action"] = normalizeDiagnosticValue(evt.action, "unknown");
 		if (evt.outcomeReason) attrs["openclaw.reason"] = redactSensitiveText(evt.outcomeReason);
 		sessionRecoveryCompletedCounter.add(1, attrs);
 		sessionRecoveryAgeHistogram.record(evt.ageMs, attrs);
 	};
 	const talkEventAttrs = (evt) => ({
-		"openclaw.talk.brain": lowCardinalityAttr(evt.brain),
-		"openclaw.talk.event_type": lowCardinalityAttr(evt.talkEventType),
-		"openclaw.talk.mode": lowCardinalityAttr(evt.mode),
-		"openclaw.talk.provider": lowCardinalityAttr(evt.provider),
-		"openclaw.talk.transport": lowCardinalityAttr(evt.transport)
+		"openclaw.talk.brain": normalizeDiagnosticValue(evt.brain),
+		"openclaw.talk.event_type": normalizeDiagnosticValue(evt.talkEventType),
+		"openclaw.talk.mode": normalizeDiagnosticValue(evt.mode),
+		"openclaw.talk.provider": normalizeDiagnosticValue(evt.provider),
+		"openclaw.talk.transport": normalizeDiagnosticValue(evt.transport)
 	});
 	const recordTalkEvent = (evt, metadata) => {
 		if (!metadata.trusted) return;
@@ -1818,12 +2056,12 @@ function createOperationsRecorders(runtime) {
 		runAttemptCounter.add(1, { "openclaw.attempt": evt.attempt });
 	};
 	const toolLoopAttrs = (evt) => ({
-		"openclaw.toolName": lowCardinalityAttr(evt.toolName, "tool"),
+		"openclaw.toolName": normalizeDiagnosticValue(evt.toolName, "tool"),
 		"openclaw.loop.level": evt.level,
 		"openclaw.loop.action": evt.action,
 		"openclaw.loop.detector": evt.detector,
 		"openclaw.loop.count": evt.count,
-		...evt.pairedToolName ? { "openclaw.loop.paired_tool": lowCardinalityAttr(evt.pairedToolName, "tool") } : {}
+		...evt.pairedToolName ? { "openclaw.loop.paired_tool": normalizeDiagnosticValue(evt.pairedToolName, "tool") } : {}
 	});
 	const recordToolLoop = (evt) => {
 		const attrs = toolLoopAttrs(evt);
@@ -1885,13 +2123,13 @@ function createOperationsRecorders(runtime) {
 			"openclaw.model": evt.model ?? "unknown"
 		};
 		if (evt.channel) attrs["openclaw.channel"] = evt.channel;
-		if (evt.blockedBy) attrs["openclaw.blocked_by"] = lowCardinalityAttr(evt.blockedBy, "unknown");
+		if (evt.blockedBy) attrs["openclaw.blocked_by"] = normalizeDiagnosticValue(evt.blockedBy, "unknown");
 		durationHistogram.record(evt.durationMs, attrs);
 		if (!tracesEnabled) return;
 		const spanAttrs = { "openclaw.outcome": evt.outcome };
 		addRunAttrs(spanAttrs, evt);
-		if (evt.blockedBy) spanAttrs["openclaw.blocked_by"] = lowCardinalityAttr(evt.blockedBy, "unknown");
-		if (evt.errorCategory) spanAttrs["openclaw.errorCategory"] = lowCardinalityAttr(evt.errorCategory, "other");
+		if (evt.blockedBy) spanAttrs["openclaw.blocked_by"] = normalizeDiagnosticValue(evt.blockedBy, "unknown");
+		if (evt.errorCategory) spanAttrs["openclaw.errorCategory"] = normalizeDiagnosticValue(evt.errorCategory, "other");
 		const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
 		if (redactedError) spanAttrs["openclaw.error"] = redactedError;
 		const trustedTrace = trustedTraceContext(evt, metadata);
@@ -1935,20 +2173,21 @@ function createOperationsRecorders(runtime) {
 //#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-tools.ts
 function createToolAndSystemRecorders(runtime) {
-	const { queueDepthHistogram, skillUsedCounter, toolExecutionDurationHistogram, toolExecutionBlockedCounter, execProcessDurationHistogram, payloadLargeCounter, payloadLargeBytesHistogram, livenessWarningCounter, livenessEventLoopDelayP99Histogram, livenessEventLoopDelayMaxHistogram, livenessEventLoopUtilizationHistogram, livenessCpuCoreRatioHistogram, telemetryExporterCounter, spanWithDuration, activeTrustedParentContext, exportedInternalOrTrustedContext, trackTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, paramsSummaryAttrs, contentCapturePolicy, tracesEnabled } = runtime;
+	const { queueDepthHistogram, skillUsedCounter, toolExecutionDurationHistogram, toolExecutionBlockedCounter, execProcessDurationHistogram, payloadLargeCounter, payloadLargeBytesHistogram, livenessWarningCounter, livenessEventLoopDelayP99Histogram, livenessEventLoopDelayMaxHistogram, livenessEventLoopUtilizationHistogram, livenessCpuCoreRatioHistogram, telemetryExporterCounter, spanWithDuration, activeTrustedParentContext, exportedInternalOrTrustedContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, paramsSummaryAttrs, contentCapturePolicy, tracesEnabled } = runtime;
 	const toolExecutionBaseAttrs = (evt) => ({
 		"openclaw.toolName": evt.toolName,
-		"openclaw.tool.source": lowCardinalityAttr(evt.toolSource, "core"),
+		"openclaw.tool.source": normalizeDiagnosticValue(evt.toolSource, "core"),
 		"gen_ai.tool.name": evt.toolName,
-		...evt.toolOwner ? { "openclaw.tool.owner": lowCardinalityAttr(evt.toolOwner) } : {},
+		...evt.toolOwner ? { "openclaw.tool.owner": normalizeDiagnosticValue(evt.toolOwner) } : {},
 		...paramsSummaryAttrs(evt.paramsSummary)
 	});
+	const toolTimestampMs = (evt) => evt.sourceTimestampMs ?? evt.ts;
 	const skillUsedAttrs = (evt) => ({
-		"openclaw.skill.name": lowCardinalityAttr(evt.skillName, "skill"),
-		"openclaw.skill.source": lowCardinalityAttr(evt.skillSource),
-		"openclaw.skill.activation": lowCardinalityAttr(evt.activation),
-		...evt.agentId ? { "openclaw.agent": lowCardinalityAttr(evt.agentId) } : {},
-		...evt.toolName ? { "openclaw.toolName": lowCardinalityAttr(evt.toolName, "tool") } : {}
+		"openclaw.skill.name": normalizeDiagnosticValue(evt.skillName, "skill"),
+		"openclaw.skill.source": normalizeDiagnosticValue(evt.skillSource),
+		"openclaw.skill.activation": normalizeDiagnosticValue(evt.activation),
+		...evt.agentId ? { "openclaw.agent": normalizeDiagnosticValue(evt.agentId) } : {},
+		...evt.toolName ? { "openclaw.toolName": normalizeDiagnosticValue(evt.toolName, "tool") } : {}
 	});
 	const recordSkillUsed = (evt, metadata) => {
 		if (!metadata.trusted) return;
@@ -1966,12 +2205,14 @@ function createToolAndSystemRecorders(runtime) {
 	};
 	const recordToolExecutionStarted = (evt, metadata) => {
 		if (!tracesEnabled || !metadata.trusted) return;
+		const trackedSpan = getTrackedInternalOrTrustedSpan(evt, metadata);
+		if (trackedSpan) return trackedSpan.spanContext();
 		const spanAttrs = toolExecutionBaseAttrs(evt);
 		assignOtelToolIdentityAttributes(spanAttrs, evt);
-		trackTrustedSpan(evt, metadata, spanWithDuration("openclaw.tool.execution", spanAttrs, void 0, {
+		return trackTrustedSpan(evt, metadata, spanWithDuration("openclaw.tool.execution", spanAttrs, void 0, {
 			parentContext: activeTrustedParentContext(evt, metadata),
-			startTimeMs: evt.ts
-		}));
+			startTimeMs: toolTimestampMs(evt)
+		})).spanContext();
 	};
 	const recordToolExecutionCompleted = (evt, metadata, toolContent) => {
 		const attrs = toolExecutionBaseAttrs(evt);
@@ -1983,61 +2224,61 @@ function createToolAndSystemRecorders(runtime) {
 		assignOtelToolContentAttributes(spanAttrs, toolContent, contentCapturePolicy);
 		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.tool.execution", spanAttrs, evt.durationMs, {
 			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
+			endTimeMs: toolTimestampMs(evt)
 		});
 		setSpanAttrs(span, spanAttrs);
-		span.end(evt.ts);
+		span.end(toolTimestampMs(evt));
 	};
 	const recordToolExecutionError = (evt, metadata, toolContent) => {
 		const attrs = {
 			...toolExecutionBaseAttrs(evt),
-			"openclaw.errorCategory": lowCardinalityAttr(evt.errorCategory, "other")
+			"openclaw.errorCategory": normalizeDiagnosticValue(evt.errorCategory, "other")
 		};
 		toolExecutionDurationHistogram.record(evt.durationMs, attrs);
 		if (!tracesEnabled) return;
 		const spanAttrs = { ...attrs };
 		addRunAttrs(spanAttrs, evt);
 		assignOtelToolIdentityAttributes(spanAttrs, evt);
-		if (evt.errorCode) spanAttrs["openclaw.errorCode"] = lowCardinalityAttr(evt.errorCode, "other");
+		if (evt.errorCode) spanAttrs["openclaw.errorCode"] = normalizeDiagnosticValue(evt.errorCode, "other");
 		assignOtelToolContentAttributes(spanAttrs, toolContent, contentCapturePolicy);
 		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.tool.execution", spanAttrs, evt.durationMs, {
 			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
+			endTimeMs: toolTimestampMs(evt)
 		});
 		setSpanAttrs(span, spanAttrs);
 		span.setStatus({
 			code: SpanStatusCode.ERROR,
 			message: redactSensitiveText(evt.errorCategory)
 		});
-		span.end(evt.ts);
+		span.end(toolTimestampMs(evt));
 	};
 	const recordToolExecutionBlocked = (evt, metadata) => {
 		toolExecutionBlockedCounter.add(1, {
 			...toolExecutionBaseAttrs(evt),
-			"openclaw.deniedReason": lowCardinalityAttr(evt.deniedReason, "other")
+			"openclaw.deniedReason": normalizeDiagnosticValue(evt.deniedReason, "other")
 		});
 		if (!tracesEnabled) return;
 		const spanAttrs = {
 			...toolExecutionBaseAttrs(evt),
 			"openclaw.outcome": "blocked",
-			"openclaw.deniedReason": lowCardinalityAttr(evt.deniedReason, "other")
+			"openclaw.deniedReason": normalizeDiagnosticValue(evt.deniedReason, "other")
 		};
 		addRunAttrs(spanAttrs, evt);
 		assignOtelToolIdentityAttributes(spanAttrs, evt);
-		const span = spanWithDuration("openclaw.tool.execution", spanAttrs, 0, {
+		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.tool.execution", spanAttrs, 0, {
 			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
+			endTimeMs: toolTimestampMs(evt)
 		});
 		setSpanAttrs(span, spanAttrs);
-		span.end(evt.ts);
+		span.end(toolTimestampMs(evt));
 	};
 	const recordPayloadLarge = (evt) => {
 		const attrs = {
 			"openclaw.payload.action": evt.action,
-			"openclaw.payload.surface": lowCardinalityAttr(evt.surface, "unknown"),
-			"openclaw.channel": lowCardinalityAttr(evt.channel, "none"),
-			"openclaw.plugin": lowCardinalityAttr(evt.pluginId, "none"),
-			"openclaw.reason": lowCardinalityAttr(evt.reason, "none")
+			"openclaw.payload.surface": normalizeDiagnosticValue(evt.surface, "unknown"),
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel, "none"),
+			"openclaw.plugin": normalizeDiagnosticValue(evt.pluginId, "none"),
+			"openclaw.reason": normalizeDiagnosticValue(evt.reason, "none")
 		};
 		payloadLargeCounter.add(1, attrs);
 		const bytes = positiveFiniteNumber(evt.bytes);
@@ -2057,7 +2298,7 @@ function createToolAndSystemRecorders(runtime) {
 			"openclaw.exec.command_length": evt.commandLength
 		};
 		if (typeof evt.exitCode === "number") spanAttrs["openclaw.exec.exit_code"] = evt.exitCode;
-		if (evt.exitSignal) spanAttrs["openclaw.exec.exit_signal"] = lowCardinalityAttr(evt.exitSignal, "other");
+		if (evt.exitSignal) spanAttrs["openclaw.exec.exit_signal"] = normalizeDiagnosticValue(evt.exitSignal, "other");
 		if (evt.timedOut !== void 0) spanAttrs["openclaw.exec.timed_out"] = evt.timedOut;
 		const span = spanWithDuration("openclaw.exec", spanAttrs, evt.durationMs, {
 			parentContext: exportedInternalOrTrustedContext(evt, metadata),
@@ -2074,7 +2315,7 @@ function createToolAndSystemRecorders(runtime) {
 	};
 	const recordLivenessWarning = (evt) => {
 		const reason = evt.reasons.join(":");
-		const attrs = { "openclaw.liveness.reason": lowCardinalityAttr(reason, "unknown") };
+		const attrs = { "openclaw.liveness.reason": normalizeDiagnosticValue(reason, "unknown") };
 		livenessWarningCounter.add(1, attrs);
 		queueDepthHistogram.record(evt.queued, { "openclaw.channel": "liveness" });
 		if (evt.eventLoopDelayP99Ms !== void 0) livenessEventLoopDelayP99Histogram.record(evt.eventLoopDelayP99Ms, attrs);
@@ -2106,7 +2347,7 @@ function createToolAndSystemRecorders(runtime) {
 	const recordDiagnosticPhaseCompleted = (evt) => {
 		if (!tracesEnabled) return;
 		const spanAttrs = {
-			"openclaw.phase": lowCardinalityAttr(evt.name, "unknown"),
+			"openclaw.phase": normalizeDiagnosticValue(evt.name, "unknown"),
 			...evt.cpuUserMs !== void 0 ? { "openclaw.phase.cpu_user_ms": evt.cpuUserMs } : {},
 			...evt.cpuSystemMs !== void 0 ? { "openclaw.phase.cpu_system_ms": evt.cpuSystemMs } : {},
 			...evt.cpuTotalMs !== void 0 ? { "openclaw.phase.cpu_total_ms": evt.cpuTotalMs } : {},
@@ -2118,11 +2359,11 @@ function createToolAndSystemRecorders(runtime) {
 	const recordTelemetryExporter = (evt, metadata) => {
 		if (!metadata.trusted) return;
 		telemetryExporterCounter.add(1, {
-			"openclaw.exporter": lowCardinalityAttr(evt.exporter, "unknown"),
+			"openclaw.exporter": normalizeDiagnosticValue(evt.exporter, "unknown"),
 			"openclaw.signal": evt.signal,
 			"openclaw.status": evt.status,
 			...evt.reason ? { "openclaw.reason": evt.reason } : {},
-			...evt.errorCategory ? { "openclaw.errorCategory": lowCardinalityAttr(evt.errorCategory, "other") } : {}
+			...evt.errorCategory ? { "openclaw.errorCategory": normalizeDiagnosticValue(evt.errorCategory, "other") } : {}
 		});
 	};
 	return {
@@ -2143,17 +2384,17 @@ function createToolAndSystemRecorders(runtime) {
 //#region extensions/diagnostics-otel/src/service-recorders-usage.ts
 function createUsageRecorders(runtime) {
 	const { tokensCounter, genAiTokenUsageHistogram, costCounter, durationHistogram, contextHistogram, webhookReceivedCounter, webhookErrorCounter, webhookDurationHistogram, messageQueuedCounter, messageReceivedCounter, messageDispatchStartedCounter, messageDispatchCompletedCounter, messageDispatchDurationHistogram, messageProcessedCounter, messageDurationHistogram, messageDeliveryStartedCounter, messageDeliveryDurationHistogram, queueDepthHistogram, tracer, activeTrustedSpans, activeTrustedSpanAliases, trustedSpanAliasKey, spanWithDuration, trustedTraceContext, internalOrTrustedTraceContext, internalOrTrustedExplicitParentContext, activeTrustedParentContext, activeInternalOrTrustedContext, trackTrustedSpan, trackInternalOrTrustedSpan, getTrackedInternalOrTrustedSpan, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
-	const recordModelUsage = (evt, metadata) => {
+	const recordModelUsage = (evt, metadata, hostPluginId) => {
 		const attrs = {
 			"openclaw.channel": evt.channel ?? "unknown",
-			"openclaw.agent": lowCardinalityAttr(evt.agentId),
+			"openclaw.agent": normalizeDiagnosticValue(evt.agentId),
 			"openclaw.provider": evt.provider ?? "unknown",
 			"openclaw.model": evt.model ?? "unknown"
 		};
 		const genAiAttrs = {
 			"gen_ai.operation.name": "chat",
-			"gen_ai.provider.name": lowCardinalityAttr(evt.provider),
-			"gen_ai.request.model": lowCardinalityAttr(evt.model)
+			"gen_ai.provider.name": normalizeDiagnosticValue(evt.provider),
+			"gen_ai.request.model": normalizeDiagnosticValue(evt.model)
 		};
 		const usage = evt.usage;
 		if (usage.input) {
@@ -2212,6 +2453,7 @@ function createUsageRecorders(runtime) {
 			"openclaw.tokens.cache_write": usage.cacheWrite ?? 0,
 			"openclaw.tokens.total": usage.total ?? 0
 		};
+		if (metadata.trusted && metadata.internal && hostPluginId) spanAttrs["openclaw.plugin"] = normalizeDiagnosticValue(hostPluginId);
 		assignGenAiSpanIdentityAttrs(spanAttrs, evt);
 		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.input_tokens", genAiInputTokens);
 		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.output_tokens", usage.output);
@@ -2231,8 +2473,8 @@ function createUsageRecorders(runtime) {
 	};
 	const recordWebhookProcessed = (evt) => {
 		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.webhook": lowCardinalityAttr(evt.updateType)
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel),
+			"openclaw.webhook": normalizeDiagnosticValue(evt.updateType)
 		};
 		if (typeof evt.durationMs === "number") webhookDurationHistogram.record(evt.durationMs, attrs);
 		if (!tracesEnabled) return;
@@ -2241,8 +2483,8 @@ function createUsageRecorders(runtime) {
 	};
 	const recordWebhookError = (evt) => {
 		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.webhook": lowCardinalityAttr(evt.updateType)
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel),
+			"openclaw.webhook": normalizeDiagnosticValue(evt.updateType)
 		};
 		webhookErrorCounter.add(1, attrs);
 		if (!tracesEnabled) return;
@@ -2260,22 +2502,22 @@ function createUsageRecorders(runtime) {
 	};
 	const recordMessageQueued = (evt) => {
 		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.source": lowCardinalityAttr(evt.source)
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel),
+			"openclaw.source": normalizeDiagnosticValue(evt.source)
 		};
 		messageQueuedCounter.add(1, attrs);
 		if (typeof evt.queueDepth === "number") queueDepthHistogram.record(evt.queueDepth, attrs);
 	};
 	const recordMessageReceived = (evt) => {
 		messageReceivedCounter.add(1, {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.source": lowCardinalityAttr(evt.source)
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel),
+			"openclaw.source": normalizeDiagnosticValue(evt.source)
 		});
 	};
 	const recordMessageDispatchStarted = (evt, metadata) => {
 		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
-			"openclaw.source": lowCardinalityAttr(evt.source)
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel),
+			"openclaw.source": normalizeDiagnosticValue(evt.source)
 		};
 		messageDispatchStartedCounter.add(1, attrs);
 		if (!tracesEnabled) return;
@@ -2288,24 +2530,24 @@ function createUsageRecorders(runtime) {
 	};
 	const recordMessageDispatchCompleted = (evt) => {
 		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel),
 			"openclaw.outcome": evt.outcome,
-			"openclaw.reason": lowCardinalityAttr(evt.reason, "none"),
-			"openclaw.source": lowCardinalityAttr(evt.source)
+			"openclaw.reason": normalizeDiagnosticValue(evt.reason, "none"),
+			"openclaw.source": normalizeDiagnosticValue(evt.source)
 		};
 		messageDispatchCompletedCounter.add(1, attrs);
 		messageDispatchDurationHistogram.record(evt.durationMs, attrs);
 	};
 	const recordMessageProcessed = (evt, metadata) => {
 		const attrs = {
-			"openclaw.channel": lowCardinalityAttr(evt.channel),
+			"openclaw.channel": normalizeDiagnosticValue(evt.channel),
 			"openclaw.outcome": evt.outcome ?? "unknown"
 		};
 		messageProcessedCounter.add(1, attrs);
 		if (typeof evt.durationMs === "number") messageDurationHistogram.record(evt.durationMs, attrs);
 		if (!tracesEnabled) return;
 		const spanAttrs = { ...attrs };
-		if (evt.reason) spanAttrs["openclaw.reason"] = lowCardinalityAttr(evt.reason, "unknown");
+		if (evt.reason) spanAttrs["openclaw.reason"] = normalizeDiagnosticValue(evt.reason, "unknown");
 		const trackedSpan = getTrackedInternalOrTrustedSpan(evt, metadata);
 		const span = trackedSpan ?? spanWithDuration("openclaw.message.processed", spanAttrs, evt.durationMs, {
 			parentContext: internalOrTrustedExplicitParentContext(evt, metadata),
@@ -2324,8 +2566,8 @@ function createUsageRecorders(runtime) {
 		span.end(evt.ts);
 	};
 	const messageDeliveryAttrs = (evt) => ({
-		"openclaw.channel": lowCardinalityAttr(evt.channel),
-		"openclaw.delivery.kind": lowCardinalityAttr(evt.deliveryKind, "other")
+		"openclaw.channel": normalizeDiagnosticValue(evt.channel),
+		"openclaw.delivery.kind": normalizeDiagnosticValue(evt.deliveryKind, "other")
 	});
 	const recordMessageDeliveryStarted = (evt) => {
 		messageDeliveryStartedCounter.add(1, messageDeliveryAttrs(evt));
@@ -2349,7 +2591,7 @@ function createUsageRecorders(runtime) {
 		const attrs = {
 			...messageDeliveryAttrs(evt),
 			"openclaw.outcome": "error",
-			"openclaw.errorCategory": lowCardinalityAttr(evt.errorCategory, "other")
+			"openclaw.errorCategory": normalizeDiagnosticValue(evt.errorCategory, "other")
 		};
 		messageDeliveryDurationHistogram.record(evt.durationMs, attrs);
 		if (!tracesEnabled) return;
@@ -2482,6 +2724,11 @@ function createDiagnosticsTraceRuntime(tracer) {
 		const retainedSpanContext = retainedTrustedSpanContext(traceContext, traceContext.spanId, owner) ?? retainedTrustedSpanContext(traceContext, traceContext.parentSpanId, owner);
 		return retainedSpanContext ? trace.setSpanContext(context.active(), retainedSpanContext) : void 0;
 	};
+	const exportedSpanContextForDiagnosticTraceContext = (traceContext) => {
+		if (!traceContext.spanId) return;
+		const spanContext = activeTrustedSpans.get(traceContext.spanId)?.spanContext() ?? retainedTrustedSpanContext(traceContext, traceContext.spanId);
+		return spanContext && isSpanContextValid(spanContext) ? spanContext : void 0;
+	};
 	const activeInternalOrTrustedContext = (evt, metadata) => exportedInternalOrTrustedContext(evt, metadata) ?? internalOrTrustedParentContext(evt, metadata);
 	const trackTrustedSpan = (evt, metadata, span) => {
 		const spanId = trustedTraceContext(evt, metadata)?.spanId;
@@ -2567,6 +2814,7 @@ function createDiagnosticsTraceRuntime(tracer) {
 		activeTrustedParentContext,
 		activeInternalOrTrustedContext,
 		exportedInternalOrTrustedContext,
+		exportedSpanContextForDiagnosticTraceContext,
 		trackTrustedSpan,
 		trackInternalOrTrustedSpan,
 		takeTrackedTrustedSpan,
@@ -2580,162 +2828,349 @@ function createDiagnosticsTraceRuntime(tracer) {
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service.ts
+const OTLP_HTTP_PROTOBUF_PROTOCOL = "http/protobuf";
+const RESOURCE_DETECTORS = [
+	["host", resources.hostDetector],
+	["os", resources.osDetector],
+	["serviceinstance", resources.serviceInstanceIdDetector],
+	["process", resources.processDetector],
+	["env", resources.envDetector]
+];
+const OTEL_SIGNAL_PROTOCOL_ENV = {
+	traces: OTEL_EXPORTER_OTLP_TRACES_PROTOCOL_ENV,
+	metrics: OTEL_EXPORTER_OTLP_METRICS_PROTOCOL_ENV,
+	logs: OTEL_EXPORTER_OTLP_LOGS_PROTOCOL_ENV
+};
+function isOtelSdkDisabled(logger) {
+	const value = process.env.OTEL_SDK_DISABLED?.trim().toLowerCase();
+	if (!value || value === "false") return false;
+	if (value === "true") return true;
+	logger.warn("diagnostics-otel: invalid OTEL_SDK_DISABLED value; expected true or false, using false");
+	return false;
+}
+function readNonblankOtelEnv(name) {
+	const value = process.env[name];
+	return value?.trim() ? value : void 0;
+}
+function readPositiveOtelNumber(name, fallback) {
+	const value = otelCore.getNumberFromEnv(name);
+	if (value !== void 0 && value <= 0) {
+		diag.warn(`${name} (${value}) is invalid, expected number greater than 0, using default.`);
+		return fallback;
+	}
+	return value ?? fallback;
+}
+function resolveResourceDetectors() {
+	const names = otelCore.getStringListFromEnv("OTEL_NODE_RESOURCE_DETECTORS");
+	if (names === void 0) return [
+		resources.envDetector,
+		resources.processDetector,
+		resources.hostDetector
+	];
+	if (names.includes("all")) return RESOURCE_DETECTORS.map(([, detector]) => detector);
+	if (names.includes("none")) return [];
+	return names.flatMap((name) => {
+		const detector = RESOURCE_DETECTORS.find(([candidate]) => candidate === name)?.[1];
+		if (!detector) diag.warn(`Invalid resource detector "${name}" specified in the environment variable OTEL_NODE_RESOURCE_DETECTORS`);
+		return detector ? [detector] : [];
+	});
+}
+function resolveSignalProtocol(signal, configuredProtocol) {
+	return configuredProtocol ?? readNonblankOtelEnv(OTEL_SIGNAL_PROTOCOL_ENV[signal]) ?? readNonblankOtelEnv("OTEL_EXPORTER_OTLP_PROTOCOL") ?? OTLP_HTTP_PROTOBUF_PROTOCOL;
+}
+function createStartupRollbackError(startupError, cleanupError) {
+	return new AggregateError([startupError, cleanupError], "diagnostics-otel startup failed and rollback cleanup failed", { cause: startupError });
+}
+function publicExporterEventForHealth(event) {
+	const base = {
+		exporter: event.exporter,
+		signal: event.signal
+	};
+	if (event.status === "recovered") return;
+	if (event.status === "started") return {
+		...base,
+		status: "started",
+		reason: "configured"
+	};
+	if (event.status === "dropped") return {
+		...base,
+		status: "dropped"
+	};
+	const reason = event.reason === "export_failed" ? "emit_failed" : event.reason;
+	return {
+		...base,
+		status: "failure",
+		...reason && reason !== "default_endpoint" ? { reason } : {},
+		...event.errorCategory ? { errorCategory: event.errorCategory } : {}
+	};
+}
+function diagnosticTraceContextFromSpanContext(spanContext) {
+	return {
+		traceId: spanContext.traceId,
+		spanId: spanContext.spanId,
+		traceFlags: spanContext.traceFlags.toString(16).padStart(2, "0")
+	};
+}
 function createDiagnosticsOtelService() {
-	let sdk = null;
+	let traceProvider = null;
+	let meterProvider = null;
 	let logProvider = null;
 	let unsubscribe = null;
+	let unregisterTracePropagationBridge = null;
 	let stopActiveTrustedSpans = null;
+	let unregisterOwnedSdkRuntime = null;
 	let unregisterUnhandledRejectionHandler = null;
-	const stopStarted = async () => {
+	let retireExporterRoutes = null;
+	let preserveExporterRoutesOnNextStop = false;
+	const stopStarted = async (options) => {
 		const currentUnsubscribe = unsubscribe;
+		const currentUnregisterTracePropagationBridge = unregisterTracePropagationBridge;
 		const currentLogProvider = logProvider;
-		const currentSdk = sdk;
+		const currentTraceProvider = traceProvider;
+		const currentMeterProvider = meterProvider;
 		const currentStopActiveTrustedSpans = stopActiveTrustedSpans;
+		const currentUnregisterOwnedSdkRuntime = unregisterOwnedSdkRuntime;
 		const currentUnregisterUnhandledRejectionHandler = unregisterUnhandledRejectionHandler;
+		const currentRetireExporterRoutes = retireExporterRoutes;
 		unsubscribe = null;
+		unregisterTracePropagationBridge = null;
 		logProvider = null;
-		sdk = null;
+		traceProvider = null;
+		meterProvider = null;
 		stopActiveTrustedSpans = null;
+		unregisterOwnedSdkRuntime = null;
 		unregisterUnhandledRejectionHandler = null;
-		currentUnregisterUnhandledRejectionHandler?.();
-		currentUnsubscribe?.();
-		currentStopActiveTrustedSpans?.();
-		if (currentLogProvider) await currentLogProvider.shutdown().catch(() => void 0);
-		if (currentSdk) await currentSdk.shutdown().catch(() => void 0);
+		retireExporterRoutes = options?.preserveExporterRoutes ? currentRetireExporterRoutes : null;
+		const settle = async (...stops) => (await Promise.allSettled(stops.map((stop) => Promise.resolve().then(() => stop?.())))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+		const failures = await settle(currentUnregisterTracePropagationBridge, currentUnsubscribe, currentStopActiveTrustedSpans, currentUnregisterOwnedSdkRuntime);
+		const providerFailures = await settle(currentLogProvider ? () => currentLogProvider.shutdown() : null, currentTraceProvider ? () => currentTraceProvider.shutdown() : null, currentMeterProvider ? () => currentMeterProvider.shutdown() : null);
+		failures.push(...providerFailures);
+		if (!options?.preserveExporterRoutes) currentRetireExporterRoutes?.(providerFailures.length > 0);
+		if (providerFailures.length > 0) retireExporterRoutes = currentRetireExporterRoutes;
+		failures.push(...await settle(currentUnregisterUnhandledRejectionHandler));
+		if (failures.length === 1) throw failures[0];
+		if (failures.length > 1) throw new AggregateError(failures, `diagnostics-otel shutdown failed: ${failures.join("; ")}`);
 	};
 	return {
 		id: "diagnostics-otel",
 		async start(ctx) {
+			preserveExporterRoutesOnNextStop = false;
 			await stopStarted();
 			const cfg = ctx.config.diagnostics;
 			const otel = cfg?.otel;
 			if (!cfg || cfg.enabled === false || !otel?.enabled) return;
-			const emitExporterEvent = (event) => {
+			const sdkDisabled = isOtelSdkDisabled(ctx.logger);
+			const sdkPreloaded = hasPreloadedOtelSdk();
+			if (!sdkPreloaded) unregisterOwnedSdkRuntime = registerOwnedSdkRuntime((message) => ctx.logger.warn(message));
+			if (!sdkPreloaded && sdkDisabled) return;
+			const exporterRoutes = /* @__PURE__ */ new Map();
+			const internalDiagnostics = ctx.internalDiagnostics;
+			const exporterHealthReporter = internalDiagnostics;
+			const emitPublicExporterEvent = createPublicExporterHealthEventEmitter((event) => {
+				const publicEvent = publicExporterEventForHealth(event);
+				if (!publicEvent) return;
 				try {
-					ctx.internalDiagnostics?.emit({
+					internalDiagnostics?.emit({
 						type: "telemetry.exporter",
-						...event
+						...publicEvent
 					});
 				} catch {}
-			};
-			const emitForSignals = (signals, event) => {
-				for (const signal of signals) emitExporterEvent({
-					signal,
-					...event
+			});
+			const emitExporterEvent = createExporterHealthEventEmitter((event) => {
+				const key = `${event.signal}\u0000${event.transport}`;
+				if (event.status === "dropped") exporterRoutes.delete(key);
+				else exporterRoutes.set(key, {
+					signal: event.signal,
+					status: event.status,
+					transport: event.transport
 				});
-			};
+				try {
+					const { exporter: _exporter, ...update } = event;
+					exporterHealthReporter?.reportExporterHealth?.(update);
+				} catch {}
+				emitPublicExporterEvent(event);
+			});
 			const tracesEnabled = otel.traces !== false;
 			const metricsEnabled = otel.metrics !== false;
-			const logsEnabled = otel.logs === true;
+			const logsEnabled = otel.logs === true && !sdkDisabled;
 			const logsExporter = otel.logsExporter ?? "otlp";
-			const logsToOtlp = logsEnabled && (logsExporter === "otlp" || logsExporter === "both");
+			const logsToOtlpRequested = logsEnabled && (logsExporter === "otlp" || logsExporter === "both");
 			const logsToStdout = logsEnabled && (logsExporter === "stdout" || logsExporter === "both");
-			const otlpSignals = [
-				...tracesEnabled ? ["traces"] : [],
-				...metricsEnabled ? ["metrics"] : [],
-				...logsToOtlp ? ["logs"] : []
-			];
-			const enabledSignals = [
+			if ([
 				...tracesEnabled ? ["traces"] : [],
 				...metricsEnabled ? ["metrics"] : [],
 				...logsEnabled ? ["logs"] : []
+			].length === 0) return;
+			const subscribe = ctx.internalDiagnostics?.onEvent;
+			if (!subscribe) {
+				ctx.logger.error("diagnostics-otel: internal diagnostics capability unavailable");
+				return;
+			}
+			retireExporterRoutes = (preserveFailures = false) => {
+				for (const route of exporterRoutes.values()) {
+					if (preserveFailures && route.status === "failure") continue;
+					emitExporterEvent({
+						exporter: "diagnostics-otel",
+						signal: route.signal,
+						transport: route.transport,
+						status: "dropped"
+					});
+				}
+			};
+			const ownedOtlpSignals = [
+				...!sdkPreloaded && tracesEnabled ? ["traces"] : [],
+				...!sdkPreloaded && metricsEnabled ? ["metrics"] : [],
+				...logsToOtlpRequested ? ["logs"] : []
 			];
-			if (enabledSignals.length === 0) return;
-			const envProtocol = process.env.OTEL_EXPORTER_OTLP_PROTOCOL;
-			const protocol = otel.protocol ?? (envProtocol?.trim() ? envProtocol : "http/protobuf");
-			if (otlpSignals.length > 0 && protocol !== "http/protobuf") {
-				emitForSignals(otlpSignals, {
+			const supportedOtlpSignals = /* @__PURE__ */ new Set();
+			for (const signal of ownedOtlpSignals) {
+				const protocol = resolveSignalProtocol(signal, otel.protocol);
+				if (protocol === OTLP_HTTP_PROTOBUF_PROTOCOL) {
+					supportedOtlpSignals.add(signal);
+					continue;
+				}
+				emitExporterEvent({
+					signal,
 					exporter: "diagnostics-otel",
+					transport: "otlp-http-protobuf",
 					status: "failure",
 					reason: "unsupported_protocol"
 				});
-				ctx.logger.warn(`diagnostics-otel: unsupported protocol ${protocol}`);
-				return;
+				ctx.logger.warn(`diagnostics-otel: unsupported ${signal} protocol ${protocol}; OTLP export disabled`);
 			}
-			const endpoint = normalizeEndpoint(otel.endpoint ?? process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]);
+			const tracesToOtlp = !sdkPreloaded && tracesEnabled && supportedOtlpSignals.has("traces");
+			const metricsToOtlp = !sdkPreloaded && metricsEnabled && supportedOtlpSignals.has("metrics");
+			const logsToOtlp = logsToOtlpRequested && supportedOtlpSignals.has("logs");
+			const tracesActive = sdkPreloaded ? tracesEnabled : tracesToOtlp;
+			const metricsActive = sdkPreloaded ? metricsEnabled : metricsToOtlp;
+			const logsActive = logsToStdout || logsToOtlp;
+			if (!tracesActive && !metricsActive && !logsActive) return;
+			const hasOwnedOtlpSignal = ownedOtlpSignals.length > 0;
+			const sharedEnvEndpoint = hasOwnedOtlpSignal ? process.env[OTEL_EXPORTER_OTLP_ENDPOINT_ENV] : void 0;
+			const endpoint = hasOwnedOtlpSignal ? normalizeEndpoint(otel.endpoint ?? sharedEnvEndpoint) : void 0;
 			const headers = otel.headers ?? void 0;
 			const serviceName = otel.serviceName?.trim() || process.env.OTEL_SERVICE_NAME || "openclaw";
 			const sampleRate = resolveSampleRate(otel.sampleRate);
 			const contentCapturePolicy = resolveContentCapturePolicy(otel.captureContent);
-			const sdkPreloaded = hasPreloadedOtelSdk();
-			const resource = resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName });
-			const logUrl = resolveSignalOtelUrl({
+			const resource = resources.resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName });
+			const logUrl = logsToOtlp ? resolveSignalOtelUrl({
 				signalEndpoint: otel.logsEndpoint,
 				signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_LOGS_ENDPOINT_ENV],
+				sharedEnvEndpoint,
 				endpoint,
 				path: "v1/logs"
-			});
-			if (!sdkPreloaded && (tracesEnabled || metricsEnabled)) {
-				const traceUrl = resolveSignalOtelUrl({
-					signalEndpoint: otel.tracesEndpoint,
-					signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_TRACES_ENDPOINT_ENV],
-					endpoint,
-					path: "v1/traces"
-				});
-				const metricUrl = resolveSignalOtelUrl({
-					signalEndpoint: otel.metricsEndpoint,
-					signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_METRICS_ENDPOINT_ENV],
-					endpoint,
-					path: "v1/metrics"
-				});
-				const traceHttpAgentOptions = resolveOtelHttpAgentOptions({
-					url: traceUrl,
-					signalIdentifier: "TRACES",
-					logger: ctx.logger
-				});
-				const metricHttpAgentOptions = resolveOtelHttpAgentOptions({
-					url: metricUrl,
-					signalIdentifier: "METRICS",
-					logger: ctx.logger
-				});
-				const traceExporter = tracesEnabled ? new OTLPTraceExporter({
-					...traceUrl ? { url: traceUrl } : {},
-					...headers ? { headers } : {},
-					...traceHttpAgentOptions ? { httpAgentOptions: traceHttpAgentOptions } : {}
-				}) : void 0;
-				const spanProcessors = traceExporter && typeof otel.flushIntervalMs === "number" ? [new BatchSpanProcessor(traceExporter, { scheduledDelayMillis: Math.max(1e3, otel.flushIntervalMs) })] : void 0;
-				const metricExporter = metricsEnabled ? new OTLPMetricExporter({
+			}) : void 0;
+			const traceUrl = tracesToOtlp ? resolveSignalOtelUrl({
+				signalEndpoint: otel.tracesEndpoint,
+				signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_TRACES_ENDPOINT_ENV],
+				sharedEnvEndpoint,
+				endpoint,
+				path: "v1/traces"
+			}) : void 0;
+			const metricUrl = metricsToOtlp ? resolveSignalOtelUrl({
+				signalEndpoint: otel.metricsEndpoint,
+				signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_METRICS_ENDPOINT_ENV],
+				sharedEnvEndpoint,
+				endpoint,
+				path: "v1/metrics"
+			}) : void 0;
+			const logHttpAgentOptions = logsToOtlp ? resolveOtelHttpAgentOptions({
+				url: logUrl,
+				signalIdentifier: "LOGS"
+			}) : void 0;
+			const traceHttpAgentOptions = tracesToOtlp ? resolveOtelHttpAgentOptions({
+				url: traceUrl,
+				signalIdentifier: "TRACES"
+			}) : void 0;
+			const metricHttpAgentOptions = metricsToOtlp ? resolveOtelHttpAgentOptions({
+				url: metricUrl,
+				signalIdentifier: "METRICS"
+			}) : void 0;
+			if (tracesToOtlp || metricsToOtlp) try {
+				const detectedResource = resources.detectResources({ detectors: resolveResourceDetectors() }).merge(resource);
+				const sdkMetricsEnabled = otelCore.getBooleanFromEnv("OTEL_NODE_EXPERIMENTAL_SDK_METRICS");
+				const metricExporter = metricsToOtlp ? observeOtlpExporterHealth(new OTLPMetricExporter({
 					...metricUrl ? { url: metricUrl } : {},
 					...headers ? { headers } : {},
 					...metricHttpAgentOptions ? { httpAgentOptions: metricHttpAgentOptions } : {}
+				}), {
+					emitExporterEvent,
+					signal: "metrics"
 				}) : void 0;
+				const metricInterval = typeof otel.flushIntervalMs === "number" ? Math.max(1e3, otel.flushIntervalMs) : readPositiveOtelNumber("OTEL_METRIC_EXPORT_INTERVAL", 6e4);
+				let metricTimeout = readPositiveOtelNumber("OTEL_METRIC_EXPORT_TIMEOUT", 3e4);
+				if (metricTimeout > metricInterval) {
+					diag.warn(`OTEL_METRIC_EXPORT_TIMEOUT (${metricTimeout}) is greater than the active metric export interval (${metricInterval}). Clamping timeout to interval value.`);
+					metricTimeout = metricInterval;
+				}
 				const metricReader = metricExporter ? new PeriodicExportingMetricReader({
 					exporter: metricExporter,
-					...typeof otel.flushIntervalMs === "number" ? { exportIntervalMillis: Math.max(1e3, otel.flushIntervalMs) } : {}
+					exportIntervalMillis: metricInterval,
+					exportTimeoutMillis: metricTimeout
 				}) : void 0;
-				sdk = new NodeSDK({
-					resource,
-					...spanProcessors ? { spanProcessors } : traceExporter ? { traceExporter } : {},
-					...metricReader ? { metricReader } : {},
-					...sampleRate !== void 0 ? { sampler: new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(sampleRate) }) } : {}
+				if (metricReader) meterProvider = new MeterProvider({
+					resource: detectedResource,
+					readers: [metricReader],
+					sdkMetricsEnabled
 				});
-				try {
-					sdk.start();
-				} catch (err) {
-					emitForSignals([...tracesEnabled ? ["traces"] : [], ...metricsEnabled ? ["metrics"] : []], {
-						exporter: "diagnostics-otel",
-						status: "failure",
-						reason: "start_failed",
-						errorCategory: errorCategory(err)
+				const traceExporter = tracesToOtlp ? observeOtlpExporterHealth(new OTLPTraceExporter({
+					...traceUrl ? { url: traceUrl } : {},
+					...headers ? { headers } : {},
+					...traceHttpAgentOptions ? { httpAgentOptions: traceHttpAgentOptions } : {}
+				}), {
+					emitExporterEvent,
+					signal: "traces"
+				}) : void 0;
+				if (traceExporter) {
+					const maxQueueSize = readPositiveOtelNumber("OTEL_BSP_MAX_QUEUE_SIZE", 2048);
+					traceProvider = new BasicTracerProvider({
+						resource: detectedResource,
+						spanProcessors: [new BatchSpanProcessor(traceExporter, {
+							maxQueueSize,
+							maxExportBatchSize: Math.min(readPositiveOtelNumber("OTEL_BSP_MAX_EXPORT_BATCH_SIZE", 512), maxQueueSize),
+							scheduledDelayMillis: typeof otel.flushIntervalMs === "number" ? Math.max(1e3, otel.flushIntervalMs) : readPositiveOtelNumber("OTEL_BSP_SCHEDULE_DELAY", 5e3),
+							exportTimeoutMillis: readPositiveOtelNumber("OTEL_BSP_EXPORT_TIMEOUT", 3e4),
+							...sdkMetricsEnabled && meterProvider ? { selfObsMeterProvider: meterProvider } : {}
+						})],
+						...sampleRate !== void 0 ? { sampler: new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(sampleRate) }) } : {},
+						...sdkMetricsEnabled && meterProvider ? { meterProvider } : {}
 					});
-					await stopStarted();
-					ctx.logger.error(`diagnostics-otel: failed to start SDK: ${formatError(err)}`);
-					throw err;
 				}
-			} else if (sdkPreloaded && (tracesEnabled || metricsEnabled)) ctx.logger.info("diagnostics-otel: using preloaded OpenTelemetry SDK");
-			const meter = metrics.getMeter("openclaw");
-			const diagnosticsTrace = createDiagnosticsTraceRuntime(trace.getTracer("openclaw"));
+			} catch (err) {
+				for (const [signal, url] of [...tracesToOtlp ? [["traces", traceUrl]] : [], ...metricsToOtlp ? [["metrics", metricUrl]] : []]) emitExporterEvent({
+					exporter: "diagnostics-otel",
+					signal,
+					transport: "otlp-http-protobuf",
+					endpointMode: url ? "configured" : "default_endpoint",
+					status: "failure",
+					reason: "start_failed",
+					errorCategory: errorCategory(err)
+				});
+				ctx.logger.error(`diagnostics-otel: failed to start SDK: ${formatError(err)}`);
+				preserveExporterRoutesOnNextStop = true;
+				try {
+					await stopStarted({ preserveExporterRoutes: true });
+				} catch (cleanupError) {
+					ctx.logger.error(`diagnostics-otel: SDK startup rollback cleanup failed: ${formatError(cleanupError)}`);
+					throw createStartupRollbackError(err, cleanupError);
+				}
+				throw err;
+			}
+			else if (sdkPreloaded && (tracesEnabled || metricsEnabled)) ctx.logger.info("diagnostics-otel: using preloaded OpenTelemetry SDK");
+			const meter = meterProvider ? meterProvider.getMeter("openclaw") : metrics.getMeter("openclaw");
+			const diagnosticsTrace = createDiagnosticsTraceRuntime(traceProvider ? traceProvider.getTracer("openclaw") : trace.getTracer("openclaw"));
 			stopActiveTrustedSpans = diagnosticsTrace.stopActiveTrustedSpans;
-			const diagnosticMetrics = createDiagnosticsMetrics(meter);
+			const diagnosticMetrics = createDiagnosticsMetrics(meter, otel.metricNamePrefix);
 			const diagnosticsLogs = createDiagnosticsLogExporter({
 				contentCapturePolicy,
 				emitExporterEvent,
 				flushIntervalMs: otel.flushIntervalMs,
 				headers,
 				logger: ctx.logger,
-				logsEnabled,
+				logsEnabled: logsActive,
 				logsToOtlp,
 				logsToStdout,
+				logHttpAgentOptions,
 				logUrl,
 				resource,
 				serviceName
@@ -2746,7 +3181,7 @@ function createDiagnosticsOtelService() {
 				contentCapturePolicy,
 				metrics: diagnosticMetrics,
 				traces: diagnosticsTrace,
-				tracesEnabled
+				tracesEnabled: tracesActive
 			});
 			const recorders = {
 				...createUsageRecorders(recorderRuntime),
@@ -2755,36 +3190,57 @@ function createDiagnosticsOtelService() {
 				...createModelRecorders(recorderRuntime),
 				...createToolAndSystemRecorders(recorderRuntime)
 			};
-			const subscribe = ctx.internalDiagnostics?.onEvent;
-			if (!subscribe) {
-				ctx.logger.error("diagnostics-otel: internal diagnostics capability unavailable");
-				return;
-			}
 			unsubscribe = subscribe(createDiagnosticsEventHandler({
 				logger: ctx.logger,
 				recorders,
 				recordLogRecord,
 				recordSecurityEvent
 			}));
-			unregisterUnhandledRejectionHandler = registerUnhandledRejectionHandler((reason) => {
+			if (tracesActive) unregisterTracePropagationBridge = ctx.internalDiagnostics?.registerTracePropagationBridge?.({
+				shouldPrepareEvent(event) {
+					return event.type === "model.call.started" || event.type === "tool.execution.started";
+				},
+				prepareEvent(event, metadata) {
+					if (event.type === "model.call.started") recorders.recordModelCallStarted(event, metadata);
+					else if (event.type === "tool.execution.started") recorders.recordToolExecutionStarted(event, metadata);
+				},
+				resolveTraceContext(traceContext) {
+					const spanContext = diagnosticsTrace.exportedSpanContextForDiagnosticTraceContext(traceContext);
+					return spanContext ? diagnosticTraceContextFromSpanContext(spanContext) : void 0;
+				}
+			}) ?? null;
+			if (hasOwnedOtlpSignal || sdkPreloaded && !sdkDisabled) unregisterUnhandledRejectionHandler = registerUnhandledRejectionHandler((reason) => {
 				const otlpError = findOtlpExporterError(reason);
 				if (!otlpError) return false;
 				const code = readErrorCode(otlpError) ?? "unknown";
 				ctx.logger.warn(`diagnostics-otel: suppressed OTLP exporter unhandled rejection (code=${String(code)})`);
 				return true;
 			});
-			emitForSignals(enabledSignals, {
-				exporter: "diagnostics-otel",
-				status: "started",
-				reason: "configured"
-			});
-			if (logsEnabled) {
-				const label = logsExporter === "both" ? "OTLP/Protobuf + stdout JSONL" : logsExporter === "stdout" ? "stdout JSONL" : "OTLP/Protobuf";
+			const emitStarted = (signal, transport, endpointMode) => {
+				emitExporterEvent({
+					exporter: "diagnostics-otel",
+					signal,
+					transport,
+					...endpointMode ? { endpointMode } : {},
+					status: "started",
+					reason: endpointMode ?? "configured"
+				});
+			};
+			if (sdkPreloaded && tracesEnabled) emitStarted("traces", "external-sdk");
+			else if (tracesToOtlp) emitStarted("traces", "otlp-http-protobuf", traceUrl ? "configured" : "default_endpoint");
+			if (sdkPreloaded && metricsEnabled) emitStarted("metrics", "external-sdk");
+			else if (metricsToOtlp) emitStarted("metrics", "otlp-http-protobuf", metricUrl ? "configured" : "default_endpoint");
+			if (logsToOtlp) emitStarted("logs", "otlp-http-protobuf", logUrl ? "configured" : "default_endpoint");
+			if (logsToStdout) emitStarted("logs", "stdout");
+			if (logsActive) {
+				const label = logsToOtlp && logsToStdout ? "OTLP/Protobuf + stdout JSONL" : logsToStdout ? "stdout JSONL" : "OTLP/Protobuf";
 				ctx.logger.info(`diagnostics-otel: logs exporter enabled (${label})`);
 			}
 		},
 		async stop() {
-			await stopStarted();
+			const preserveExporterRoutes = preserveExporterRoutesOnNextStop;
+			preserveExporterRoutesOnNextStop = false;
+			await stopStarted(preserveExporterRoutes ? { preserveExporterRoutes: true } : void 0);
 		}
 	};
 }