@openclaw/diagnostics-otel 2026.9.6 → 2026.9.8

package/dist/.setup/{runtime-api-D5Sze_rR.mjs → runtime-api-ButGOVne.mjs}

@@ -1,4 +1,3 @@
-import { isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, redactSensitiveText } from "../api.js";
 import { ROOT_CONTEXT, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, createNoopMeter, diag, isSpanContextValid, metrics, propagation, trace } from "@opentelemetry/api";
 import * as otelCore from "@opentelemetry/core";
 import { CompositePropagator, ExportResultCode, W3CBaggagePropagator, W3CTraceContextPropagator, getStringListFromEnv } from "@opentelemetry/core";
@@ -8,11 +7,14 @@ 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 { asFiniteNumberInRange, asNonNegativeFiniteNumber, asPositiveFiniteNumber } from "openclaw/plugin-sdk/number-runtime";
 import { registerUnhandledRejectionHandler } from "openclaw/plugin-sdk/runtime-env";
+import { asFiniteNumber, isRecord, normalizeOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { isInternalDiagnosticEventMetadata, normalizeDiagnosticLane, normalizeDiagnosticValue } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { readFileSync } from "node:fs";
 import nodePath from "node:path";
+import { isInternalDiagnosticEventMetadata, isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, normalizeDiagnosticLane, normalizeDiagnosticValue } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { collectErrorGraphCandidates } from "openclaw/plugin-sdk/error-runtime";
 import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
@@ -21,7 +23,6 @@ import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-ho
 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 { asFiniteNumber, asFiniteNumberInRange, isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 const DROPPED_OTEL_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
 	"openclaw.callId",
 	"openclaw.call_id",
@@ -308,9 +309,6 @@ function describeJsonValue(value) {
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service-exporter.ts
-function normalizeEndpoint(endpoint) {
-	return endpoint?.trim() || void 0;
-}
 const SIGNAL_QUALIFIED_OTLP_PATH_PATTERN = /\/v1\/(traces|metrics|logs)$/iu;
 function appendOrReplaceSignalPath(value, path) {
 	const base = value.replace(/\/+$/u, "");
@@ -330,10 +328,10 @@ function resolveSharedOtelUrl(endpoint, path) {
 	return appendOrReplaceSignalPath(endpoint, path);
 }
 function resolveSignalOtelUrl(params) {
-	const signalEndpoint = normalizeEndpoint(params.signalEndpoint ?? params.signalEnvEndpoint);
+	const signalEndpoint = normalizeOptionalString(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 signalEnvEndpoint = readNonBlankString(params.signalEnvEndpoint);
+	const sharedEnvEndpoint = readNonBlankString(params.sharedEnvEndpoint);
 	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;
@@ -347,7 +345,7 @@ function resolveSignalOtelUrl(params) {
 }
 function readOtelEnvFile(params) {
 	const signalEnvName = `OTEL_EXPORTER_OTLP_${params.signalIdentifier}_${params.signalSuffix}`;
-	const filePath = normalizeOtelEnvValue(process.env[signalEnvName]) ?? normalizeOtelEnvValue(process.env[params.sharedEnvName]);
+	const filePath = readNonBlankString(process.env[signalEnvName]) ?? readNonBlankString(process.env[params.sharedEnvName]);
 	if (!filePath) return;
 	try {
 		const material = readFileSync(nodePath.resolve(process.cwd(), filePath));
@@ -355,9 +353,6 @@ function readOtelEnvFile(params) {
 	} catch {}
 	throw new Error(`Configured OpenTelemetry ${params.label} file is missing, empty, or unreadable; refusing insecure export`);
 }
-function normalizeOtelEnvValue(value) {
-	return value?.trim() ? value : void 0;
-}
 function resolveOtelHttpAgentOptions(params) {
 	const { url, signalIdentifier } = params;
 	const ca = readOtelEnvFile({
@@ -398,11 +393,6 @@ function resolveOtelHttpAgentOptions(params) {
 	}
 	return (ca || cert || key) && new URL(url).protocol === "https:" ? agentOptions : void 0;
 }
-function resolveSampleRate(value) {
-	if (typeof value !== "number" || !Number.isFinite(value)) return;
-	if (value < 0 || value > 1) return;
-	return value;
-}
 function formatError(err) {
 	if (err instanceof Error) return err.stack ?? err.message;
 	if (typeof err === "string") return err;
@@ -443,163 +433,71 @@ function findOtlpExporterError(reason) {
 //#region extensions/diagnostics-otel/src/service-events.ts
 function createDiagnosticsEventHandler(params) {
 	const { logger, recorders, recordLogRecord, recordSecurityEvent } = params;
-	const { recordGcDuration, recordGatewayEventLoopSample, recordGatewayRpc, recordModelUsage, recordWebhookReceived, recordWebhookProcessed, recordWebhookError, recordMessageQueued, recordMessageReceived, recordMessageDispatchStarted, recordMessageDispatchCompleted, recordMessageProcessed, recordMessageDeliveryStarted, recordMessageDeliveryCompleted, recordMessageDeliveryError, recordTalkEvent, recordLaneEnqueue, recordLaneDequeue, recordSessionState, recordSessionTurnCreated, recordSessionStuck, recordSessionRecoveryRequested, recordSessionRecoveryCompleted, recordRunAttempt, recordHeartbeat, recordLivenessWarning, recordDiagnosticPhaseCompleted, recordRunStarted, recordRunCompleted, recordHarnessRunStarted, recordHarnessRunCompleted, recordHarnessRunError, recordContextAssembled, recordModelCallStarted, recordModelCallFinished, recordToolExecutionStarted, recordToolExecutionFinished, recordToolExecutionBlocked, recordSkillUsed, recordExecProcessCompleted, recordToolLoop, recordMemorySample, recordMemoryPressure, recordAsyncQueueDropped, recordTelemetryExporter, recordPayloadLarge, recordModelFailover } = recorders;
 	return (evt, metadata, privateData) => {
 		try {
 			switch (evt.type) {
 				case "diagnostic.child_process.spawn": return;
-				case "diagnostic.gc":
-					recordGcDuration(evt, metadata);
-					return;
-				case "gateway.event_loop.sample":
-					recordGatewayEventLoopSample(evt, metadata);
-					return;
-				case "gateway.rpc":
-					recordGatewayRpc(evt, metadata);
-					return;
-				case "model.usage":
-					recordModelUsage(evt, metadata, privateData.hostPluginId);
-					return;
-				case "webhook.received":
-					recordWebhookReceived(evt);
-					return;
-				case "webhook.processed":
-					recordWebhookProcessed(evt);
-					return;
-				case "webhook.error":
-					recordWebhookError(evt);
-					return;
-				case "message.queued":
-					recordMessageQueued(evt);
-					return;
-				case "message.received":
-					recordMessageReceived(evt);
-					return;
-				case "message.dispatch.started":
-					recordMessageDispatchStarted(evt, metadata);
-					return;
-				case "message.dispatch.completed":
-					recordMessageDispatchCompleted(evt);
-					return;
-				case "message.processed":
-					recordMessageProcessed(evt, metadata);
-					return;
-				case "message.delivery.started":
-					recordMessageDeliveryStarted(evt);
-					return;
-				case "message.delivery.completed":
-					recordMessageDeliveryCompleted(evt, metadata);
-					return;
-				case "message.delivery.error":
-					recordMessageDeliveryError(evt, metadata);
-					return;
-				case "talk.event":
-					recordTalkEvent(evt, metadata);
-					return;
-				case "queue.lane.enqueue":
-					recordLaneEnqueue(evt);
-					return;
-				case "queue.lane.dequeue":
-					recordLaneDequeue(evt);
-					return;
-				case "session.state":
-					recordSessionState(evt);
-					break;
+				case "diagnostic.gc": return recorders.recordGcDuration(evt, metadata);
+				case "gateway.event_loop.sample": return recorders.recordGatewayEventLoopSample(evt, metadata);
+				case "gateway.rpc": return recorders.recordGatewayRpc(evt, metadata);
+				case "model.usage": return recorders.recordModelUsage(evt, metadata, privateData.hostPluginId);
+				case "webhook.received": return recorders.recordWebhookReceived(evt);
+				case "webhook.processed": return recorders.recordWebhookProcessed(evt);
+				case "webhook.error": return recorders.recordWebhookError(evt);
+				case "message.queued": return recorders.recordMessageQueued(evt);
+				case "message.received": return recorders.recordMessageReceived(evt);
+				case "message.dispatch.started": return recorders.recordMessageDispatchStarted(evt, metadata);
+				case "message.dispatch.completed": return recorders.recordMessageDispatchCompleted(evt);
+				case "message.processed": return recorders.recordMessageProcessed(evt, metadata);
+				case "message.delivery.started": return recorders.recordMessageDeliveryStarted(evt);
+				case "message.delivery.completed": return recorders.recordMessageDeliveryCompleted(evt, metadata);
+				case "message.delivery.error": return recorders.recordMessageDeliveryError(evt, metadata);
+				case "talk.event": return recorders.recordTalkEvent(evt, metadata);
+				case "queue.lane.enqueue": return recorders.recordLaneEnqueue(evt);
+				case "queue.lane.dequeue": return recorders.recordLaneDequeue(evt);
+				case "session.state": return recorders.recordSessionState(evt);
 				case "session.long_running":
 				case "session.stalled": break;
-				case "session.turn.created":
-					recordSessionTurnCreated(evt);
-					return;
-				case "session.stuck":
-					recordSessionStuck(evt);
-					return;
-				case "session.recovery.requested":
-					recordSessionRecoveryRequested(evt);
-					return;
-				case "session.recovery.completed":
-					recordSessionRecoveryCompleted(evt);
-					return;
-				case "run.attempt":
-					recordRunAttempt(evt);
-					break;
+				case "session.turn.created": return recorders.recordSessionTurnCreated(evt);
+				case "session.stuck": return recorders.recordSessionStuck(evt);
+				case "session.recovery.requested": return recorders.recordSessionRecoveryRequested(evt);
+				case "session.recovery.completed": return recorders.recordSessionRecoveryCompleted(evt);
+				case "run.attempt": return recorders.recordRunAttempt(evt);
 				case "run.progress": break;
 				case "run.execution_phase": break;
-				case "diagnostic.heartbeat":
-					recordHeartbeat(evt);
-					return;
-				case "diagnostic.liveness.warning":
-					recordLivenessWarning(evt);
-					return;
-				case "diagnostic.phase.completed":
-					recordDiagnosticPhaseCompleted(evt);
-					return;
-				case "run.started":
-					recordRunStarted(evt, metadata);
-					return;
-				case "run.completed":
-					recordRunCompleted(evt, metadata, privateData);
-					return;
-				case "harness.run.started":
-					recordHarnessRunStarted(evt, metadata);
-					return;
+				case "diagnostic.heartbeat": return recorders.recordHeartbeat(evt);
+				case "diagnostic.liveness.warning": return recorders.recordLivenessWarning(evt);
+				case "diagnostic.phase.completed": return recorders.recordDiagnosticPhaseCompleted(evt, metadata);
+				case "run.started": return recorders.recordRunStarted(evt, metadata);
+				case "run.completed": return recorders.recordRunCompleted(evt, metadata, privateData);
+				case "harness.run.started": return recorders.recordHarnessRunStarted(evt, metadata);
+				case "agent.commentary": return recorders.recordAgentCommentary(evt, metadata, privateData);
 				case "harness.run.completed":
-					recordHarnessRunCompleted(evt, metadata, privateData);
-					return;
-				case "harness.run.error":
-					recordHarnessRunError(evt, metadata, privateData);
-					return;
-				case "context.assembled":
-					recordContextAssembled(evt, metadata);
-					return;
+				case "harness.run.error": return recorders.recordHarnessRunFinished(evt, metadata, privateData);
+				case "context.assembled": return recorders.recordContextAssembled(evt, metadata);
 				case "model.call.started":
-					recordModelCallStarted(evt, metadata);
+					recorders.recordModelCallStarted(evt, metadata);
 					return;
 				case "model.call.completed":
-				case "model.call.error":
-					recordModelCallFinished(evt, metadata, privateData.modelContent);
-					return;
+				case "model.call.error": return recorders.recordModelCallFinished(evt, metadata, privateData.modelContent);
 				case "tool.execution.started":
-					recordToolExecutionStarted(evt, metadata);
+					recorders.recordToolExecutionStarted(evt, metadata);
 					return;
 				case "tool.execution.completed":
-				case "tool.execution.error":
-					recordToolExecutionFinished(evt, metadata, privateData.toolContent);
-					return;
-				case "tool.execution.blocked":
-					recordToolExecutionBlocked(evt, metadata);
-					return;
-				case "skill.used":
-					recordSkillUsed(evt, metadata);
-					return;
-				case "exec.process.completed":
-					recordExecProcessCompleted(evt, metadata);
-					break;
+				case "tool.execution.error": return recorders.recordToolExecutionFinished(evt, metadata, privateData.toolContent);
+				case "tool.execution.blocked": return recorders.recordToolExecutionBlocked(evt, metadata);
+				case "skill.used": return recorders.recordSkillUsed(evt, metadata);
+				case "exec.process.completed": return recorders.recordExecProcessCompleted(evt, metadata);
 				case "exec.approval.followup_suppressed": break;
-				case "log.record":
-					recordLogRecord?.(evt, metadata);
-					return;
-				case "security.event":
-					recordSecurityEvent?.(evt, metadata);
-					return;
-				case "tool.loop":
-					recordToolLoop(evt);
-					return;
-				case "diagnostic.memory.sample":
-					recordMemorySample(evt);
-					return;
-				case "diagnostic.memory.pressure":
-					recordMemoryPressure(evt);
-					return;
-				case "diagnostic.async_queue.dropped":
-					recordAsyncQueueDropped(evt);
-					return;
-				case "telemetry.exporter":
-					recordTelemetryExporter(evt, metadata);
-					return;
-				case "payload.large":
-					recordPayloadLarge(evt);
-					return;
-				case "model.failover": recordModelFailover(evt, metadata);
+				case "log.record": return recordLogRecord?.(evt, metadata);
+				case "security.event": return recordSecurityEvent?.(evt, metadata);
+				case "tool.loop": return recorders.recordToolLoop(evt);
+				case "diagnostic.memory.sample": return recorders.recordMemoryUsageMetrics(evt);
+				case "diagnostic.memory.pressure": return recorders.recordMemoryPressure(evt);
+				case "diagnostic.async_queue.dropped": return recorders.recordAsyncQueueDropped(evt);
+				case "telemetry.exporter": return recorders.recordTelemetryExporter(evt, metadata);
+				case "payload.large": return recorders.recordPayloadLarge(evt);
+				case "model.failover": return recorders.recordModelFailover(evt, metadata);
 			}
 		} catch (err) {
 			logger.error(`diagnostics-otel: event handler failed (${evt.type}): ${formatError(err)}`);
@@ -756,9 +654,6 @@ function securityTargetNameAttr(value, fallback = "unknown") {
 	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();
@@ -913,7 +808,6 @@ const LOG_SEVERITY_MAP = {
 function createDiagnosticsLogExporter(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;
 	let recordSecurityEvent;
 	if (logsEnabled) {
@@ -986,8 +880,8 @@ function createDiagnosticsLogExporter(params) {
 		};
 		const buildDiagnosticLogRecord = (evt, metadata) => {
 			const logLevelName = evt.level || "INFO";
-			const severityNumber = logSeverityMap[logLevelName] ?? 9;
-			const body = shouldCaptureOtelLogBody(contentCapturePolicy) ? normalizeOtelLogString(evt.message || "log", MAX_OTEL_LOG_BODY_CHARS) : "log";
+			const severityNumber = LOG_SEVERITY_MAP[logLevelName] ?? 9;
+			const body = contentCapturePolicy.logBodies ? normalizeOtelLogString(evt.message || "log", MAX_OTEL_LOG_BODY_CHARS) : "log";
 			const attributes = Object.create(null);
 			assignOtelLogAttribute(attributes, "openclaw.log.level", logLevelName);
 			if (evt.loggerName) assignOtelLogAttribute(attributes, "openclaw.logger", evt.loggerName);
@@ -1019,7 +913,7 @@ function createDiagnosticsLogExporter(params) {
 			const logRecord = {
 				body: "openclaw.security.event",
 				severityText,
-				severityNumber: logSeverityMap[severityText] ?? 9,
+				severityNumber: LOG_SEVERITY_MAP[severityText] ?? 9,
 				attributes: redactOtelAttributes(attributes),
 				timestamp: evt.ts
 			};
@@ -1438,247 +1332,6 @@ function createDiagnosticsRecorderRuntime(params) {
 	};
 }
 //#endregion
-//#region extensions/diagnostics-otel/src/service-recorders-harness.ts
-function createHarnessRecorders(runtime) {
-	const { harnessDurationHistogram, modelFailoverCounter, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, trackTrustedSpan, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
-	const harnessRunMetricAttrs = (evt) => ({
-		"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": 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;
-		trackTrustedSpan(evt, metadata, spanWithDuration("openclaw.harness.run", harnessRunMetricAttrs(evt), void 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			startTimeMs: evt.ts
-		}));
-	};
-	const recordHarnessRunCompleted = (evt, metadata, privateData) => {
-		harnessDurationHistogram.record(evt.durationMs, harnessRunMetricAttrs(evt));
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...harnessRunMetricAttrs(evt) };
-		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;
-			spanAttrs["openclaw.harness.items.completed"] = evt.itemLifecycle.completedCount;
-			spanAttrs["openclaw.harness.items.active"] = evt.itemLifecycle.activeCount;
-		}
-		const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
-		if (redactedError) spanAttrs["openclaw.error"] = redactedError;
-		const trustedTrace = trustedTraceContext(evt, metadata);
-		const trackedSpan = trustedTrace?.spanId ? activeTrustedSpans.get(trustedTrace.spanId) : void 0;
-		const span = trackedSpan ?? spanWithDuration("openclaw.harness.run", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		if (evt.outcome === "error") span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactedError ?? "error"
-		});
-		if (trackedSpan && trustedTrace?.spanId) {
-			completeTrackedLifecycleSpan(trustedTrace, trackedSpan, evt.ts);
-			return;
-		}
-		span.end(evt.ts);
-	};
-	const recordHarnessRunError = (evt, metadata, privateData) => {
-		const errorType = normalizeDiagnosticValue(evt.errorCategory, "other");
-		const attrs = {
-			...harnessRunMetricAttrs(evt),
-			"openclaw.harness.phase": evt.phase,
-			"openclaw.errorCategory": errorType
-		};
-		harnessDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
-		const spanAttrs = {
-			...attrs,
-			"error.type": errorType,
-			...redactedError ? { "openclaw.error": redactedError } : {},
-			...evt.cleanupFailed ? { "openclaw.harness.cleanup_failed": true } : {}
-		};
-		const trustedTrace = trustedTraceContext(evt, metadata);
-		const trackedSpan = trustedTrace?.spanId ? activeTrustedSpans.get(trustedTrace.spanId) : void 0;
-		const span = trackedSpan ?? spanWithDuration("openclaw.harness.run", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: redactedError ?? errorType
-		});
-		if (trackedSpan && trustedTrace?.spanId) {
-			completeTrackedLifecycleSpan(trustedTrace, trackedSpan, evt.ts);
-			return;
-		}
-		span.end(evt.ts);
-	};
-	const recordContextAssembled = (evt, metadata) => {
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			"openclaw.context.message_count": evt.messageCount,
-			"openclaw.context.history_text_chars": evt.historyTextChars,
-			"openclaw.context.history_image_blocks": evt.historyImageBlocks,
-			"openclaw.context.max_message_text_chars": evt.maxMessageTextChars,
-			"openclaw.context.system_prompt_chars": evt.systemPromptChars,
-			"openclaw.context.prompt_chars": evt.promptChars,
-			"openclaw.context.prompt_images": evt.promptImages
-		};
-		addRunAttrs(spanAttrs, evt);
-		if (evt.contextTokenBudget !== void 0) spanAttrs["openclaw.context.token_budget"] = evt.contextTokenBudget;
-		if (evt.reserveTokens !== void 0) spanAttrs["openclaw.context.reserve_tokens"] = evt.reserveTokens;
-		spanWithDuration("openclaw.context.assembled", spanAttrs, 0, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		}).end(evt.ts);
-	};
-	const recordModelFailover = (evt, metadata) => {
-		const metricAttrs = {
-			"openclaw.failover.reason": normalizeDiagnosticValue(evt.reason, "unknown"),
-			"openclaw.failover.suspended": evt.suspended === void 0 ? "unknown" : String(evt.suspended),
-			"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": 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"] = 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, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		}).end(evt.ts);
-	};
-	return {
-		recordHarnessRunStarted,
-		recordHarnessRunCompleted,
-		recordHarnessRunError,
-		recordContextAssembled,
-		recordModelFailover
-	};
-}
-//#endregion
-//#region extensions/diagnostics-otel/src/service-genai-attributes.ts
-function hasOtelSemconvOptIn(value, optIn) {
-	return value?.split(",").map((part) => part.trim()).includes(optIn) ?? false;
-}
-function emitLatestGenAiSemconv() {
-	return hasOtelSemconvOptIn(process.env[OTEL_SEMCONV_STABILITY_OPT_IN_ENV], GEN_AI_LATEST_EXPERIMENTAL_OPT_IN);
-}
-function genAiOperationName(api, observationUnit) {
-	if (observationUnit === "turn") return GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT;
-	const normalized = api?.trim().toLowerCase();
-	if (!normalized) return "chat";
-	if (normalized === "completions" || normalized.endsWith("-completions")) return "text_completion";
-	if (normalized === "generate_content" || normalized.includes("generative-ai")) return "generate_content";
-	return "chat";
-}
-function positiveFiniteNumber(value) {
-	return asFiniteNumberInRange(value, {
-		min: 0,
-		minExclusive: true
-	});
-}
-function nonNegativeFiniteNumber(value) {
-	return asFiniteNumberInRange(value, { min: 0 });
-}
-function assignPositiveNumberAttr(attrs, key, value) {
-	const normalized = positiveFiniteNumber(value);
-	if (normalized !== void 0) attrs[key] = normalized;
-}
-function assignModelCallSizeTimingAttrs(attrs, evt) {
-	assignPositiveNumberAttr(attrs, "openclaw.model_call.request_bytes", evt.requestPayloadBytes);
-	assignPositiveNumberAttr(attrs, "openclaw.model_call.response_bytes", evt.responseStreamBytes);
-	assignPositiveNumberAttr(attrs, "openclaw.model_call.time_to_first_byte_ms", evt.timeToFirstByteMs);
-}
-function assignNumberAttr(attrs, key, value) {
-	const normalized = asFiniteNumber(value);
-	if (normalized !== void 0) attrs[key] = normalized;
-}
-function modelCallPromptTokens(usage) {
-	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;
-	if (!stats) return;
-	for (const [key, value] of [
-		["openclaw.model_call.prompt.input_messages_count", stats.inputMessagesCount],
-		["openclaw.model_call.prompt.input_messages_chars", stats.inputMessagesChars],
-		["openclaw.model_call.prompt.system_prompt_chars", stats.systemPromptChars],
-		["openclaw.model_call.prompt.tool_definitions_count", stats.toolDefinitionsCount],
-		["openclaw.model_call.prompt.tool_definitions_chars", stats.toolDefinitionsChars],
-		["openclaw.model_call.prompt.total_chars", stats.totalChars]
-	]) assignNumberAttr(attrs, key, value);
-}
-function assignModelCallUsageAttrs(attrs, evt) {
-	const usage = evt.usage;
-	if (!usage) return;
-	const promptTokens = modelCallPromptTokens(usage);
-	for (const [key, value] of [
-		["openclaw.model_call.usage.input_tokens", usage.input],
-		["openclaw.model_call.usage.output_tokens", usage.output],
-		["openclaw.model_call.usage.cache_read_input_tokens", usage.cacheRead],
-		["openclaw.model_call.usage.cache_creation_input_tokens", usage.cacheWrite],
-		["openclaw.model_call.usage.reasoning_output_tokens", usage.reasoningTokens],
-		["openclaw.model_call.usage.prompt_tokens", promptTokens],
-		["openclaw.model_call.usage.total_tokens", usage.total],
-		["gen_ai.usage.input_tokens", promptTokens],
-		["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]
-	]) {
-		const normalized = nonNegativeFiniteNumber(value);
-		if (normalized !== void 0) attrs[key] = normalized;
-	}
-}
-function assignGenAiSpanIdentityAttrs(attrs, input) {
-	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);
-}
-function assignGenAiModelCallAttrs(attrs, evt) {
-	assignGenAiSpanIdentityAttrs(attrs, evt);
-	attrs["openclaw.model_call.observation_unit"] = modelCallObservationUnit(evt);
-}
-function modelCallObservationUnit(evt) {
-	return evt.observationUnit ?? "request";
-}
-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} ${normalizeDiagnosticValue(evt.model)}`;
-}
-function modelCallSpanKind() {
-	return SpanKind.CLIENT;
-}
-function addUpstreamRequestIdSpanEvent(span, upstreamRequestIdHash) {
-	if (!upstreamRequestIdHash) return;
-	const boundedHash = normalizeDiagnosticValue(upstreamRequestIdHash);
-	if (boundedHash === "unknown") return;
-	span.addEvent?.("openclaw.provider.request", { "openclaw.upstreamRequestIdHash": boundedHash });
-}
-//#endregion
 //#region extensions/diagnostics-otel/src/service-genai-content.ts
 function textPart(content) {
 	return {
@@ -1906,9 +1559,234 @@ function assignOtelToolContentAttributes(attributes, content, policy) {
 	}
 }
 //#endregion
+//#region extensions/diagnostics-otel/src/service-recorders-harness.ts
+function createHarnessRecorders(runtime) {
+	const { harnessDurationHistogram, modelFailoverCounter, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, trackTrustedSpan, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled, getTrackedInternalOrTrustedSpan, contentCapturePolicy } = runtime;
+	const recordAgentCommentary = (evt, metadata, privateData) => {
+		if (!tracesEnabled || !metadata.trusted) return;
+		const span = getTrackedInternalOrTrustedSpan(evt, metadata);
+		if (!span) return;
+		const attrs = {
+			"openclaw.harness.id": normalizeDiagnosticValue(evt.harnessId, "unknown"),
+			"openclaw.commentary.sequence": evt.sourceSequence,
+			"openclaw.commentary.text_length": evt.textLength,
+			"openclaw.commentary.content_truncated": evt.contentTruncated
+		};
+		assignOtelModelContentAttributes(attrs, privateData.modelContent, contentCapturePolicy);
+		span.addEvent("openclaw.agent.commentary", redactOtelAttributes(attrs), evt.sourceTimestampMs);
+	};
+	const harnessRunMetricAttrs = (evt) => ({
+		"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": 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;
+		const spanAttrs = { ...harnessRunMetricAttrs(evt) };
+		addRunAttrs(spanAttrs, evt);
+		trackTrustedSpan(evt, metadata, spanWithDuration("openclaw.harness.run", spanAttrs, void 0, {
+			parentContext: activeTrustedParentContext(evt, metadata),
+			startTimeMs: evt.ts
+		}));
+	};
+	const recordHarnessRunFinished = (evt, metadata, privateData) => {
+		const errorType = evt.type === "harness.run.error" ? normalizeDiagnosticValue(evt.errorCategory, "other") : "error";
+		const attrs = {
+			...harnessRunMetricAttrs(evt),
+			...evt.type === "harness.run.error" ? {
+				"openclaw.harness.phase": evt.phase,
+				"openclaw.errorCategory": errorType
+			} : {}
+		};
+		harnessDurationHistogram.record(evt.durationMs, attrs);
+		if (!tracesEnabled) return;
+		const spanAttrs = { ...attrs };
+		addRunAttrs(spanAttrs, evt);
+		if (evt.type === "harness.run.completed") {
+			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;
+				spanAttrs["openclaw.harness.items.completed"] = evt.itemLifecycle.completedCount;
+				spanAttrs["openclaw.harness.items.active"] = evt.itemLifecycle.activeCount;
+			}
+		} else {
+			spanAttrs["error.type"] = errorType;
+			if (evt.cleanupFailed) spanAttrs["openclaw.harness.cleanup_failed"] = true;
+		}
+		const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
+		if (redactedError) spanAttrs["openclaw.error"] = redactedError;
+		const trustedTrace = trustedTraceContext(evt, metadata);
+		const trackedSpan = trustedTrace?.spanId ? activeTrustedSpans.get(trustedTrace.spanId) : void 0;
+		const span = trackedSpan ?? spanWithDuration("openclaw.harness.run", spanAttrs, evt.durationMs, {
+			parentContext: activeTrustedParentContext(evt, metadata),
+			endTimeMs: evt.ts
+		});
+		setSpanAttrs(span, spanAttrs);
+		if (evt.type === "harness.run.error" || evt.outcome === "error") span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: redactedError ?? errorType
+		});
+		if (trackedSpan && trustedTrace?.spanId) {
+			completeTrackedLifecycleSpan(trustedTrace, trackedSpan, evt.ts);
+			return;
+		}
+		span.end(evt.ts);
+	};
+	const recordContextAssembled = (evt, metadata) => {
+		if (!tracesEnabled) return;
+		const spanAttrs = {
+			"openclaw.context.message_count": evt.messageCount,
+			"openclaw.context.history_text_chars": evt.historyTextChars,
+			"openclaw.context.history_image_blocks": evt.historyImageBlocks,
+			"openclaw.context.max_message_text_chars": evt.maxMessageTextChars,
+			"openclaw.context.system_prompt_chars": evt.systemPromptChars,
+			"openclaw.context.prompt_chars": evt.promptChars,
+			"openclaw.context.prompt_images": evt.promptImages
+		};
+		addRunAttrs(spanAttrs, evt);
+		if (evt.contextTokenBudget !== void 0) spanAttrs["openclaw.context.token_budget"] = evt.contextTokenBudget;
+		if (evt.reserveTokens !== void 0) spanAttrs["openclaw.context.reserve_tokens"] = evt.reserveTokens;
+		spanWithDuration("openclaw.context.assembled", spanAttrs, 0, {
+			parentContext: activeTrustedParentContext(evt, metadata),
+			endTimeMs: evt.ts
+		}).end(evt.ts);
+	};
+	const recordModelFailover = (evt, metadata) => {
+		const metricAttrs = {
+			"openclaw.failover.reason": normalizeDiagnosticValue(evt.reason, "unknown"),
+			"openclaw.failover.suspended": evt.suspended === void 0 ? "unknown" : String(evt.suspended),
+			"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": 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"] = 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, {
+			parentContext: activeTrustedParentContext(evt, metadata),
+			endTimeMs: evt.ts
+		}).end(evt.ts);
+	};
+	return {
+		recordAgentCommentary,
+		recordHarnessRunStarted,
+		recordHarnessRunFinished,
+		recordContextAssembled,
+		recordModelFailover
+	};
+}
+//#endregion
+//#region extensions/diagnostics-otel/src/service-genai-attributes.ts
+function hasOtelSemconvOptIn(value, optIn) {
+	return value?.split(",").map((part) => part.trim()).includes(optIn) ?? false;
+}
+function emitLatestGenAiSemconv() {
+	return hasOtelSemconvOptIn(process.env[OTEL_SEMCONV_STABILITY_OPT_IN_ENV], GEN_AI_LATEST_EXPERIMENTAL_OPT_IN);
+}
+function genAiOperationName(api, observationUnit) {
+	if (observationUnit === "turn") return GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT;
+	const normalized = api?.trim().toLowerCase();
+	if (!normalized) return "chat";
+	if (normalized === "completions" || normalized.endsWith("-completions")) return "text_completion";
+	if (normalized === "generate_content" || normalized.includes("generative-ai")) return "generate_content";
+	return "chat";
+}
+function assignPositiveNumberAttr(attrs, key, value) {
+	const normalized = asPositiveFiniteNumber(value);
+	if (normalized !== void 0) attrs[key] = normalized;
+}
+function assignModelCallSizeTimingAttrs(attrs, evt) {
+	assignPositiveNumberAttr(attrs, "openclaw.model_call.request_bytes", evt.requestPayloadBytes);
+	assignPositiveNumberAttr(attrs, "openclaw.model_call.response_bytes", evt.responseStreamBytes);
+	assignPositiveNumberAttr(attrs, "openclaw.model_call.time_to_first_byte_ms", evt.timeToFirstByteMs);
+}
+function assignNumberAttr(attrs, key, value) {
+	const normalized = asFiniteNumber(value);
+	if (normalized !== void 0) attrs[key] = normalized;
+}
+function modelCallPromptTokens(usage) {
+	const promptTokens = asNonNegativeFiniteNumber(usage.promptTokens);
+	if (promptTokens !== void 0) return promptTokens;
+	const input = asNonNegativeFiniteNumber(usage.input);
+	const cacheRead = asNonNegativeFiniteNumber(usage.cacheRead);
+	const cacheWrite = asNonNegativeFiniteNumber(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;
+	if (!stats) return;
+	for (const [key, value] of [
+		["openclaw.model_call.prompt.input_messages_count", stats.inputMessagesCount],
+		["openclaw.model_call.prompt.input_messages_chars", stats.inputMessagesChars],
+		["openclaw.model_call.prompt.system_prompt_chars", stats.systemPromptChars],
+		["openclaw.model_call.prompt.tool_definitions_count", stats.toolDefinitionsCount],
+		["openclaw.model_call.prompt.tool_definitions_chars", stats.toolDefinitionsChars],
+		["openclaw.model_call.prompt.total_chars", stats.totalChars]
+	]) assignNumberAttr(attrs, key, value);
+}
+function assignModelCallUsageAttrs(attrs, evt) {
+	const usage = evt.usage;
+	if (!usage) return;
+	const promptTokens = modelCallPromptTokens(usage);
+	for (const [key, value] of [
+		["openclaw.model_call.usage.input_tokens", usage.input],
+		["openclaw.model_call.usage.output_tokens", usage.output],
+		["openclaw.model_call.usage.cache_read_input_tokens", usage.cacheRead],
+		["openclaw.model_call.usage.cache_creation_input_tokens", usage.cacheWrite],
+		["openclaw.model_call.usage.reasoning_output_tokens", usage.reasoningTokens],
+		["openclaw.model_call.usage.prompt_tokens", promptTokens],
+		["openclaw.model_call.usage.total_tokens", usage.total],
+		["gen_ai.usage.input_tokens", promptTokens],
+		["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]
+	]) {
+		const normalized = asNonNegativeFiniteNumber(value);
+		if (normalized !== void 0) attrs[key] = normalized;
+	}
+}
+function assignGenAiSpanIdentityAttrs(attrs, input) {
+	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);
+}
+function assignGenAiModelCallAttrs(attrs, evt) {
+	assignGenAiSpanIdentityAttrs(attrs, evt);
+	attrs["openclaw.model_call.observation_unit"] = modelCallObservationUnit(evt);
+}
+function modelCallObservationUnit(evt) {
+	return evt.observationUnit ?? "request";
+}
+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} ${normalizeDiagnosticValue(evt.model)}`;
+}
+function addUpstreamRequestIdSpanEvent(span, upstreamRequestIdHash) {
+	if (!upstreamRequestIdHash) return;
+	const boundedHash = normalizeDiagnosticValue(upstreamRequestIdHash);
+	if (boundedHash === "unknown") return;
+	span.addEvent?.("openclaw.provider.request", { "openclaw.upstreamRequestIdHash": boundedHash });
+}
+//#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-model.ts
 function createModelRecorders(runtime) {
-	const { genAiOperationDurationHistogram, modelCallDurationHistogram, modelCallRequestBytesHistogram, modelCallResponseBytesHistogram, modelCallTimeToFirstByteHistogram, spanWithDuration, activeTrustedParentContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, contentCapturePolicy, tracesEnabled } = runtime;
+	const { genAiOperationDurationHistogram, modelCallDurationHistogram, modelCallRequestBytesHistogram, modelCallResponseBytesHistogram, modelCallTimeToFirstByteHistogram, spanWithDuration, activeTrustedParentContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, contentCapturePolicy, tracesEnabled } = runtime;
 	const modelCallMetricAttrs = (evt) => ({
 		"openclaw.provider": evt.provider,
 		"openclaw.model": evt.model,
@@ -1917,11 +1795,11 @@ function createModelRecorders(runtime) {
 		"openclaw.model_call.observation_unit": modelCallObservationUnit(evt)
 	});
 	const recordModelCallSizeTimingMetrics = (evt, attrs) => {
-		const requestPayloadBytes = positiveFiniteNumber(evt.requestPayloadBytes);
+		const requestPayloadBytes = asPositiveFiniteNumber(evt.requestPayloadBytes);
 		if (requestPayloadBytes !== void 0) modelCallRequestBytesHistogram.record(requestPayloadBytes, attrs);
-		const responseStreamBytes = positiveFiniteNumber(evt.responseStreamBytes);
+		const responseStreamBytes = asPositiveFiniteNumber(evt.responseStreamBytes);
 		if (responseStreamBytes !== void 0) modelCallResponseBytesHistogram.record(responseStreamBytes, attrs);
-		const timeToFirstByteMs = positiveFiniteNumber(evt.timeToFirstByteMs);
+		const timeToFirstByteMs = asPositiveFiniteNumber(evt.timeToFirstByteMs);
 		if (timeToFirstByteMs !== void 0) modelCallTimeToFirstByteHistogram.record(timeToFirstByteMs, attrs);
 	};
 	const recordModelCallStarted = (evt, metadata) => {
@@ -1932,12 +1810,13 @@ function createModelRecorders(runtime) {
 			"openclaw.provider": evt.provider,
 			"openclaw.model": evt.model
 		};
+		addRunAttrs(spanAttrs, evt);
 		assignGenAiModelCallAttrs(spanAttrs, evt);
 		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
 		if (evt.transport) spanAttrs["openclaw.transport"] = evt.transport;
 		assignModelCallPromptStatsAttrs(spanAttrs, evt);
 		return trackTrustedSpan(evt, metadata, spanWithDuration(modelCallSpanName(evt), spanAttrs, void 0, {
-			kind: modelCallSpanKind(),
+			kind: SpanKind.CLIENT,
 			parentContext: activeTrustedParentContext(evt, metadata),
 			startTimeMs: evt.ts
 		})).spanContext();
@@ -1966,6 +1845,7 @@ function createModelRecorders(runtime) {
 				"error.type": errorType
 			} : {}
 		};
+		addRunAttrs(spanAttrs, evt);
 		if (evt.type === "model.call.error" && evt.failureKind) spanAttrs["openclaw.failureKind"] = normalizeDiagnosticValue(evt.failureKind, "other");
 		assignGenAiModelCallAttrs(spanAttrs, evt);
 		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
@@ -1975,7 +1855,7 @@ function createModelRecorders(runtime) {
 		assignModelCallUsageAttrs(spanAttrs, evt);
 		assignOtelModelContentAttributes(spanAttrs, modelContent, contentCapturePolicy);
 		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration(modelCallSpanName(evt), spanAttrs, evt.durationMs, {
-			kind: modelCallSpanKind(),
+			kind: SpanKind.CLIENT,
 			parentContext: activeTrustedParentContext(evt, metadata),
 			endTimeMs: evt.ts
 		});
@@ -2118,7 +1998,9 @@ function createOperationsRecorders(runtime) {
 		const attrs = toolLoopAttrs(evt);
 		toolLoopCounter.add(1, attrs);
 		if (!tracesEnabled) return;
-		const span = spanWithDuration("openclaw.tool.loop", attrs, 0, { endTimeMs: evt.ts });
+		const spanAttrs = { ...attrs };
+		addRunAttrs(spanAttrs, evt);
+		const span = spanWithDuration("openclaw.tool.loop", spanAttrs, 0, { endTimeMs: evt.ts });
 		if (evt.level === "critical" || evt.action === "block") span.setStatus({
 			code: SpanStatusCode.ERROR,
 			message: `${evt.detector}:${evt.action}`
@@ -2132,9 +2014,6 @@ function createOperationsRecorders(runtime) {
 		memoryExternalHistogram.record(evt.memory.externalBytes, attrs);
 		memoryArrayBuffersHistogram.record(evt.memory.arrayBuffersBytes, attrs);
 	};
-	const recordMemorySample = (evt) => {
-		recordMemoryUsageMetrics(evt);
-	};
 	const recordMemoryPressure = (evt) => {
 		const attrs = {
 			"openclaw.memory.level": evt.level,
@@ -2163,9 +2042,11 @@ function createOperationsRecorders(runtime) {
 	};
 	const recordAsyncQueueDropped = (evt) => {
 		asyncQueueDroppedCounter.add(evt.droppedEvents, { "openclaw.diagnostic.async_queue.drop_class": "total" });
-		if (evt.droppedTrustedEvents !== void 0) asyncQueueDroppedCounter.add(evt.droppedTrustedEvents, { "openclaw.diagnostic.async_queue.drop_class": "trusted" });
-		if (evt.droppedUntrustedEvents !== void 0) asyncQueueDroppedCounter.add(evt.droppedUntrustedEvents, { "openclaw.diagnostic.async_queue.drop_class": "untrusted" });
-		if (evt.droppedPriorityEvents !== void 0) asyncQueueDroppedCounter.add(evt.droppedPriorityEvents, { "openclaw.diagnostic.async_queue.drop_class": "priority" });
+		for (const [dropClass, field] of [
+			["trusted", "droppedTrustedEvents"],
+			["untrusted", "droppedUntrustedEvents"],
+			["priority", "droppedPriorityEvents"]
+		]) if (evt[field] !== void 0) asyncQueueDroppedCounter.add(evt[field], { "openclaw.diagnostic.async_queue.drop_class": dropClass });
 	};
 	const recordRunCompleted = (evt, metadata, privateData) => {
 		const attrs = {
@@ -2216,7 +2097,6 @@ function createOperationsRecorders(runtime) {
 		recordRunAttempt,
 		recordToolLoop,
 		recordMemoryUsageMetrics,
-		recordMemorySample,
 		recordMemoryPressure,
 		recordAsyncQueueDropped,
 		recordRunCompleted
@@ -2225,7 +2105,7 @@ function createOperationsRecorders(runtime) {
 //#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-tools.ts
 function createToolAndSystemRecorders(runtime) {
-	const { gcDurationHistogram, gatewayEventLoopDelayMaxHistogram, gatewayEventLoopObservedCounter, 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 { gcDurationHistogram, gatewayEventLoopDelayMaxHistogram, gatewayEventLoopObservedCounter, queueDepthHistogram, skillUsedCounter, toolExecutionDurationHistogram, toolExecutionBlockedCounter, execProcessDurationHistogram, payloadLargeCounter, payloadLargeBytesHistogram, livenessWarningCounter, livenessEventLoopDelayP99Histogram, livenessEventLoopDelayMaxHistogram, livenessEventLoopUtilizationHistogram, livenessCpuCoreRatioHistogram, telemetryExporterCounter, spanWithDuration, activeTrustedParentContext, internalOrTrustedExplicitParentContext, exportedInternalOrTrustedContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, paramsSummaryAttrs, contentCapturePolicy, tracesEnabled } = runtime;
 	const toolExecutionBaseAttrs = (evt) => ({
 		"openclaw.toolName": evt.toolName,
 		"openclaw.tool.source": normalizeDiagnosticValue(evt.toolSource, "core"),
@@ -2316,7 +2196,7 @@ function createToolAndSystemRecorders(runtime) {
 			"openclaw.reason": normalizeDiagnosticValue(evt.reason, "none")
 		};
 		payloadLargeCounter.add(1, attrs);
-		const bytes = positiveFiniteNumber(evt.bytes);
+		const bytes = asPositiveFiniteNumber(evt.bytes);
 		if (bytes !== void 0) payloadLargeBytesHistogram.record(bytes, attrs);
 	};
 	const recordExecProcessCompleted = (evt, metadata) => {
@@ -2388,7 +2268,7 @@ function createToolAndSystemRecorders(runtime) {
 		});
 		span.end(evt.ts);
 	};
-	const recordDiagnosticPhaseCompleted = (evt) => {
+	const recordDiagnosticPhaseCompleted = (evt, metadata) => {
 		if (!tracesEnabled) return;
 		const spanAttrs = {
 			"openclaw.phase": normalizeDiagnosticValue(evt.name, "unknown"),
@@ -2398,7 +2278,10 @@ function createToolAndSystemRecorders(runtime) {
 			...evt.cpuCoreRatio !== void 0 ? { "openclaw.phase.cpu_core_ratio": evt.cpuCoreRatio } : {}
 		};
 		for (const [key, value] of Object.entries(evt.details ?? {})) spanAttrs[`openclaw.phase.detail.${key}`] = typeof value === "boolean" ? String(value) : value;
-		spanWithDuration("openclaw.diagnostic.phase", spanAttrs, evt.durationMs, { endTimeMs: evt.ts }).end(evt.ts);
+		spanWithDuration("openclaw.diagnostic.phase", spanAttrs, evt.durationMs, {
+			endTimeMs: evt.ts,
+			...metadata.trusted ? { parentContext: internalOrTrustedExplicitParentContext(evt, metadata) ?? ROOT_CONTEXT } : {}
+		}).end(evt.ts);
 	};
 	const recordTelemetryExporter = (evt, metadata) => {
 		if (!metadata.trusted) return;
@@ -2442,52 +2325,34 @@ function createUsageRecorders(runtime) {
 			"gen_ai.request.model": normalizeDiagnosticValue(evt.model)
 		};
 		const usage = evt.usage;
-		if (usage.input) {
-			tokensCounter.add(usage.input, {
+		for (const [tokenType, field] of [
+			["input", "input"],
+			["output", "output"],
+			["cache_read", "cacheRead"],
+			["cache_write", "cacheWrite"],
+			["prompt", "promptTokens"],
+			["total", "total"]
+		]) {
+			const amount = usage[field];
+			if (!amount) continue;
+			tokensCounter.add(amount, {
 				...attrs,
-				"openclaw.token": "input"
+				"openclaw.token": tokenType
 			});
-			genAiTokenUsageHistogram.record(usage.input, {
+			if (tokenType === "input" || tokenType === "output") genAiTokenUsageHistogram.record(amount, {
 				...genAiAttrs,
-				"gen_ai.token.type": "input"
+				"gen_ai.token.type": tokenType
 			});
 		}
-		if (usage.output) {
-			tokensCounter.add(usage.output, {
+		if (evt.costUsd) costCounter.add(evt.costUsd, attrs);
+		if (evt.durationMs) durationHistogram.record(evt.durationMs, attrs);
+		for (const kind of ["limit", "used"]) {
+			const amount = evt.context?.[kind];
+			if (amount) contextHistogram.record(amount, {
 				...attrs,
-				"openclaw.token": "output"
-			});
-			genAiTokenUsageHistogram.record(usage.output, {
-				...genAiAttrs,
-				"gen_ai.token.type": "output"
+				"openclaw.context": kind
 			});
 		}
-		if (usage.cacheRead) tokensCounter.add(usage.cacheRead, {
-			...attrs,
-			"openclaw.token": "cache_read"
-		});
-		if (usage.cacheWrite) tokensCounter.add(usage.cacheWrite, {
-			...attrs,
-			"openclaw.token": "cache_write"
-		});
-		if (usage.promptTokens) tokensCounter.add(usage.promptTokens, {
-			...attrs,
-			"openclaw.token": "prompt"
-		});
-		if (usage.total) tokensCounter.add(usage.total, {
-			...attrs,
-			"openclaw.token": "total"
-		});
-		if (evt.costUsd) costCounter.add(evt.costUsd, attrs);
-		if (evt.durationMs) durationHistogram.record(evt.durationMs, attrs);
-		if (evt.context?.limit) contextHistogram.record(evt.context.limit, {
-			...attrs,
-			"openclaw.context": "limit"
-		});
-		if (evt.context?.used) contextHistogram.record(evt.context.used, {
-			...attrs,
-			"openclaw.context": "used"
-		});
 		if (!tracesEnabled) return;
 		const genAiInputTokens = usage.promptTokens ?? (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
 		const spanAttrs = {
@@ -2500,6 +2365,7 @@ function createUsageRecorders(runtime) {
 		};
 		if (metadata.trusted && metadata.internal && hostPluginId) spanAttrs["openclaw.plugin"] = normalizeDiagnosticValue(hostPluginId);
 		assignGenAiSpanIdentityAttrs(spanAttrs, evt);
+		addRunAttrs(spanAttrs, evt);
 		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.input_tokens", genAiInputTokens);
 		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.output_tokens", usage.output);
 		assignPositiveNumberAttr(spanAttrs, "gen_ai.usage.cache_read.input_tokens", usage.cacheRead);
@@ -2592,6 +2458,7 @@ function createUsageRecorders(runtime) {
 		if (typeof evt.durationMs === "number") messageDurationHistogram.record(evt.durationMs, attrs);
 		if (!tracesEnabled) return;
 		const spanAttrs = { ...attrs };
+		addRunAttrs(spanAttrs, evt);
 		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, {
@@ -2703,12 +2570,11 @@ function createDiagnosticsTraceRuntime(tracer) {
 	const spanWithDuration = (name, attributes, durationMs, options = {}) => {
 		const endTimeMs = options.endTimeMs ?? Date.now();
 		const startTime = typeof options.startTimeMs === "number" ? options.startTimeMs : typeof durationMs === "number" && durationMs >= 0 ? endTimeMs - durationMs : void 0;
-		const parentContext = "parentContext" in options ? options.parentContext ?? void 0 : void 0;
 		return tracer.startSpan(name, {
 			attributes: redactOtelAttributes(attributes),
 			...options.kind !== void 0 ? { kind: options.kind } : {},
 			...startTime !== void 0 ? { startTime } : {}
-		}, parentContext);
+		}, options.parentContext ?? void 0);
 	};
 	const trustedTraceContext = (evt, metadata) => metadata.trusted ? normalizeTraceContext(evt.trace) : void 0;
 	const internalOrTrustedTraceContext = (evt, metadata) => metadata.internal ? normalizeTraceContext(evt.trace) : normalizedTrustedTraceContext(evt, metadata);
@@ -2837,6 +2703,7 @@ function createDiagnosticsTraceRuntime(tracer) {
 		if (evt.model) spanAttrs["openclaw.model"] = evt.model;
 		if (evt.channel) spanAttrs["openclaw.channel"] = evt.channel;
 		if (evt.trigger) spanAttrs["openclaw.trigger"] = evt.trigger;
+		if (evt.agentId) spanAttrs["openclaw.agent"] = normalizeDiagnosticValue(evt.agentId);
 	};
 	const paramsSummaryAttrs = (summary) => {
 		if (!summary) return {};
@@ -2893,10 +2760,6 @@ function isOtelSdkDisabled(logger) {
 	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) {
@@ -2921,7 +2784,7 @@ function resolveResourceDetectors() {
 	});
 }
 function resolveSignalProtocol(signal, configuredProtocol) {
-	return configuredProtocol ?? readNonblankOtelEnv(OTEL_SIGNAL_PROTOCOL_ENV[signal]) ?? readNonblankOtelEnv("OTEL_EXPORTER_OTLP_PROTOCOL") ?? OTLP_HTTP_PROTOBUF_PROTOCOL;
+	return configuredProtocol ?? readNonBlankString(process.env[OTEL_SIGNAL_PROTOCOL_ENV[signal]]) ?? readNonBlankString(process.env["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 });
@@ -3070,10 +2933,13 @@ function createDiagnosticsOtelService() {
 			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 endpoint = hasOwnedOtlpSignal ? normalizeOptionalString(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 sampleRate = asFiniteNumberInRange(otel.sampleRate, {
+				min: 0,
+				max: 1
+			});
 			const contentCapturePolicy = resolveContentCapturePolicy(otel.captureContent);
 			const resource = resources.resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName });
 			const logUrl = logsToOtlp ? resolveSignalOtelUrl({
@@ -3219,7 +3085,7 @@ function createDiagnosticsOtelService() {
 				recorders,
 				recordLogRecord,
 				recordSecurityEvent
-			}), metricsActive ? void 0 : tracesActive ? { exclude: ["gateway.event_loop.sample", "diagnostic.gc"] } : { include: ["log.record", "security.event"] });
+			}), metricsActive ? tracesActive ? void 0 : { exclude: ["diagnostic.phase.completed"] } : tracesActive ? { exclude: ["gateway.event_loop.sample", "diagnostic.gc"] } : { include: ["log.record", "security.event"] });
 			if (tracesActive) active.unregisterTracePropagationBridge = ctx.internalDiagnostics?.registerTracePropagationBridge?.({
 				shouldPrepareEvent(event) {
 					return event.type === "model.call.started" || event.type === "tool.execution.started";

package/dist/api.js

@@ -1,4 +1,4 @@
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk/plugin-entry";
-import { createChildDiagnosticTraceContext, createDiagnosticTraceContext, emitDiagnosticEvent, formatDiagnosticTraceparent, isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, onDiagnosticEvent, parseDiagnosticTraceparent } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
+import { createChildDiagnosticTraceContext, createDiagnosticTraceContext, emitDiagnosticEvent, formatDiagnosticTraceparent, isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, onDiagnosticEvent, parseDiagnosticTraceparent } from "openclaw/plugin-sdk/diagnostic-runtime";
 export { createChildDiagnosticTraceContext, createDiagnosticTraceContext, emitDiagnosticEvent, emptyPluginConfigSchema, formatDiagnosticTraceparent, isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, onDiagnosticEvent, parseDiagnosticTraceparent, redactSensitiveText };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-D5Sze_rR.mjs";
+import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-ButGOVne.mjs";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/diagnostics-otel/index.ts
 var diagnostics_otel_default = definePluginEntry({

package/dist/runtime-api.js

@@ -1,2 +1,2 @@
-import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-D5Sze_rR.mjs";
+import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-ButGOVne.mjs";
 export { createDiagnosticsOtelService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/diagnostics-otel",
-  "version": "2026.9.6",
+  "version": "2026.9.8",
   "description": "OpenClaw diagnostics OpenTelemetry exporter for metrics, traces, and logs.",
   "repository": {
     "type": "git",
@@ -34,10 +34,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.9.6"
+      "pluginApi": ">=2026.9.8"
     },
     "build": {
-      "openclawVersion": "2026.9.6"
+      "openclawVersion": "2026.9.8"
     },
     "release": {
       "publishToClawHub": true,
@@ -55,7 +55,7 @@
     "assets/activity.svg"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.9.6"
+    "openclaw": ">=2026.9.8"
   },
   "peerDependenciesMeta": {
     "openclaw": {