@latitude-data/openclaw-telemetry 0.0.9 → 0.1.0

package/dist/plugin.js

@@ -1,34 +1,8 @@
+import { createRequire } from "node:module";
 import { arch, hostname, platform, release } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
-//#region src/client.ts
-async function postTraces({ baseUrl, apiKey, project, payload, logger, timeoutMs = 1e4 }) {
-	const url = `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
-	const bodyText = JSON.stringify(payload);
-	logger.debug(`POST ${url} (project=${project}, ${bodyText.length} bytes)`);
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), timeoutMs);
-	try {
-		const res = await fetch(url, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`,
-				"X-Latitude-Project": project
-			},
-			body: bodyText,
-			signal: controller.signal
-		});
-		if (!res.ok) {
-			const text = await res.text().catch(() => "");
-			logger.warn(`ingest HTTP ${res.status}: ${text.slice(0, 500)}`);
-		} else logger.debug(`ingest HTTP ${res.status}`);
-	} catch (err) {
-		logger.warn(`ingest failed: ${String(err)}`);
-	} finally {
-		clearTimeout(timer);
-	}
-}
-//#endregion
+import { readFileSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 //#region src/redaction.ts
 function parseRedactConfig(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -82,24 +56,14 @@ function redactedAttr(key, mask) {
 //#endregion
 //#region src/config.ts
 const DEFAULT_BASE_URL = "https://ingest.latitude.so";
+const DEFAULT_SERVICE_NAME = "openclaw";
+const DEFAULT_MAX_CONTENT_CHARS = 262144;
 /**
 * Build a `Config` from OpenClaw's per-plugin config bucket. The plugin SDK
 * passes `api.pluginConfig` (the user's `plugins.entries[id].config` block)
-* to the registration function — that's the only source.
-*
-* Earlier 0.0.x versions also fell back to environment variables when keys
-* were missing from pluginConfig. That fallback is gone deliberately:
-* OpenClaw 2026.4.25's `openclaw plugins install` runs a static-analysis
-* security scan that flags any runtime source combining environment-variable
-* access with a network-send call (we have `fetch(` in postTraces). With
-* the fallback our bundled runtime tripped the scanner. The installer
-* writes credentials to `plugins.entries[id].config` anyway, so the
-* fallback was polish-not-feature — its removal also gives a cleaner
-* privacy story (the runtime can't pick up credentials the operator
-* didn't put in openclaw.json).
-*
-* For dev-time testing with debug logs, set `config.debug = true` in
-* openclaw.json directly.
+* to the registration function; that is the only source. There is no
+* environment fallback: the runtime must not combine env reads with the
+* network send, and the installer always writes credentials here.
 */
 function loadConfig(pluginConfig = void 0) {
 	const fromOpts = pluginConfig ?? {};
@@ -117,7 +81,14 @@ function loadConfig(pluginConfig = void 0) {
 		debug,
 		allowConversationAccess,
 		redact: parseRedactConfig(fromOpts.redact),
-		enabled: hasCreds && !explicitlyDisabled
+		enabled: hasCreds && !explicitlyDisabled,
+		serviceName: pickString(fromOpts.serviceName) ?? DEFAULT_SERVICE_NAME,
+		tags: pickStringList(fromOpts.tags),
+		metadata: pickStringMap(fromOpts.metadata),
+		memory: pickBool(fromOpts.memory) ?? true,
+		memoryContent: pickBool(fromOpts.memoryContent) ?? true,
+		toolDefinitions: pickBool(fromOpts.toolDefinitions) ?? true,
+		maxContentChars: pickPositiveInt(fromOpts.maxContentChars) ?? DEFAULT_MAX_CONTENT_CHARS
 	};
 }
 function pickString(value) {
@@ -126,24 +97,44 @@ function pickString(value) {
 function pickBool(value) {
 	return typeof value === "boolean" ? value : void 0;
 }
+function pickPositiveInt(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function pickStringList(value) {
+	if (typeof value === "string") return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+	if (!Array.isArray(value)) return [];
+	return value.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim());
+}
+function pickStringMap(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const out = {};
+	for (const [k, v] of Object.entries(value)) if (typeof v === "string") out[k] = v;
+	else if (typeof v === "number" || typeof v === "boolean") out[k] = String(v);
+	return out;
+}
 //#endregion
 //#region src/logger.ts
 const PREFIX = "[latitude-openclaw]";
-function createLogger(debugEnabled) {
+function createLogger(debugEnabled, host) {
 	return {
-		debug: debugEnabled ? (msg) => process.stderr.write(`${PREFIX} ${msg}\n`) : () => {},
-		warn: (msg) => process.stderr.write(`${PREFIX} ${msg}\n`)
+		debug: debugEnabled ? host ? (msg) => host.info(`${PREFIX} ${msg}`) : (msg) => writeStderr(msg) : () => {},
+		warn: host ? (msg) => host.warn(`${PREFIX} ${msg}`) : (msg) => writeStderr(msg)
 	};
 }
+function writeStderr(msg) {
+	process.stderr.write(`${PREFIX} ${msg}\n`);
+}
 //#endregion
 //#region src/otlp.ts
 const SCOPE_NAME = "@latitude-data/openclaw-telemetry";
-const SCOPE_VERSION = "0.0.9";
-/** Build an OTLP export request for a single completed agent run. */
-function buildOtlpRequest(result, options) {
-	const spans = result.spans.map((span) => toOtlpSpan(span, options));
+const SCOPE_VERSION = "0.1.0";
+const GATED_SUFFIX = ":gated";
+const ARRAY_VALUE_KEYS = new Set(["gen_ai.response.finish_reasons"]);
+const TRUNCATION_MARKER = "\n…[truncated by latitude-openclaw]…\n";
+function buildOtlpRequest(results, options) {
+	const spans = results.flatMap((result) => result.spans.map((span) => toOtlpSpan(span, options)));
 	return { resourceSpans: [{
-		resource: { attributes: resourceAttrs() },
+		resource: { attributes: resourceAttrs(options.serviceName ?? "openclaw") },
 		scopeSpans: [{
 			scope: {
 				name: SCOPE_NAME,
@@ -154,53 +145,128 @@ function buildOtlpRequest(result, options) {
 	}] };
 }
 function toOtlpSpan(span, options) {
-	const startNs = msToNs(span.startMs);
-	const endNs = msToNs(span.endMs ?? span.startMs);
 	const attrs = [];
 	for (const [rawKey, value] of Object.entries(span.attrs)) {
 		if (value === void 0 || value === null) continue;
-		const isGated = rawKey.endsWith(":gated");
+		const isGated = rawKey.endsWith(GATED_SUFFIX);
 		if (isGated && !options.allowConversationAccess) continue;
-		const kv = encodeAttr(isGated ? rawKey.slice(0, -6) : rawKey, value);
+		const kv = encodeAttr(isGated ? rawKey.slice(0, -6) : rawKey, value, options.maxContentChars);
 		if (kv !== void 0) attrs.push(kv);
 	}
 	attrs.push(bool("latitude.captured.content", options.allowConversationAccess));
-	if (span.endMs !== void 0) attrs.push(int("openclaw.duration_ms.computed", Math.max(0, span.endMs - span.startMs)));
-	const redactedAttrs = redactAttributes(attrs, options.redact);
-	const statusCode = span.outcome === "error" ? 2 : 1;
 	return {
 		traceId: span.traceId,
 		spanId: span.spanId,
 		parentSpanId: span.parentSpanId,
 		name: span.name,
-		kind: 1,
-		startTimeUnixNano: startNs,
-		endTimeUnixNano: endNs,
-		attributes: redactedAttrs,
-		status: { code: statusCode }
+		kind: span.kind,
+		startTimeUnixNano: msToNs(span.startMs),
+		endTimeUnixNano: msToNs(span.endMs ?? span.startMs),
+		attributes: redactAttributes(attrs, options.redact),
+		status: { code: span.outcome === "error" ? 2 : 1 }
 	};
 }
-function encodeAttr(key, value) {
+function encodeAttr(key, value, maxChars) {
 	if (value === void 0 || value === null) return void 0;
-	if (typeof value === "string") return str(key, value);
+	if (typeof value === "string") return str$1(key, budget(value, maxChars));
 	if (typeof value === "boolean") return bool(key, value);
 	if (typeof value === "number") return Number.isInteger(value) ? int(key, value) : {
 		key,
 		value: { doubleValue: value }
 	};
-	return str(key, safeJson$1(value));
+	if (ARRAY_VALUE_KEYS.has(key) && Array.isArray(value)) return {
+		key,
+		value: { arrayValue: { values: value.map((v) => ({ stringValue: String(v) })) } }
+	};
+	return str$1(key, budgetJson(value, maxChars));
+}
+function budget(value, maxChars) {
+	if (!maxChars || value.length <= maxChars) return value;
+	const keep = Math.max(0, Math.floor((maxChars - 36) / 2));
+	let headEnd = keep;
+	if (headEnd > 0 && isHighSurrogate(value.charCodeAt(headEnd - 1))) headEnd--;
+	let tailStart = value.length - keep;
+	if (tailStart < value.length && isLowSurrogate(value.charCodeAt(tailStart))) tailStart++;
+	return `${value.slice(0, headEnd)}${TRUNCATION_MARKER}${value.slice(tailStart)}`;
+}
+function isHighSurrogate(code) {
+	return code >= 55296 && code <= 56319;
+}
+function isLowSurrogate(code) {
+	return code >= 56320 && code <= 57343;
+}
+/**
+* A structured value must still parse after the budget, since Latitude reads
+* messages, tool definitions and memory records as JSON: long strings inside
+* it are truncated first, then whole items are shed from the middle of an
+* array. Slicing the serialized text is the last resort, for a lone object.
+*/
+function budgetJson(value, maxChars) {
+	const json = safeJson$1(value);
+	if (!maxChars || json.length <= maxChars) return json;
+	const trimmed = budgetStrings(value, Math.max(1, Math.floor(maxChars / 4)));
+	const trimmedJson = safeJson$1(trimmed);
+	if (trimmedJson.length <= maxChars) return trimmedJson;
+	if (Array.isArray(trimmed)) return safeJson$1(shedItems(trimmed, maxChars));
+	return budget(trimmedJson, maxChars);
+}
+function budgetStrings(value, maxChars) {
+	if (typeof value === "string") return budget(value, maxChars);
+	if (Array.isArray(value)) return value.map((item) => budgetStrings(item, maxChars));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, budgetStrings(v, maxChars)]));
+	return value;
+}
+const OMISSION_RESERVE = 160;
+/** Keeps the head and tail of an array within the budget; a message list gets a marker for what was dropped. */
+function shedItems(items, maxChars) {
+	const sizes = items.map((item) => safeJson$1(item).length + 1);
+	const head = [];
+	const tail = [];
+	let budgetLeft = maxChars - OMISSION_RESERVE;
+	let low = 0;
+	let high = items.length - 1;
+	while (low <= high) {
+		const fromHead = head.length <= tail.length;
+		const size = fromHead ? sizes[low] : sizes[high];
+		if (budgetLeft - size < 0) break;
+		budgetLeft -= size;
+		if (fromHead) head.push(items[low++]);
+		else tail.unshift(items[high--]);
+	}
+	const omitted = items.length - head.length - tail.length;
+	if (omitted <= 0) return [...items];
+	const marker = isMessageList(items) ? [omissionMessage(omitted)] : [];
+	return [
+		...head,
+		...marker,
+		...tail
+	];
+}
+function isMessageList(items) {
+	const first = items[0];
+	return !!first && typeof first === "object" && typeof first.role === "string";
+}
+function omissionMessage(count) {
+	return {
+		role: "system",
+		parts: [{
+			type: "text",
+			content: `[… ${count} message(s) omitted by latitude-openclaw …]`
+		}]
+	};
 }
-function resourceAttrs() {
+function resourceAttrs(serviceName) {
 	return [
-		str("service.name", "openclaw"),
-		str("service.version", SCOPE_VERSION),
-		str("host.name", hostname()),
-		str("host.arch", arch()),
-		str("os.type", platform()),
-		str("os.version", release())
+		str$1("service.name", serviceName),
+		str$1("service.version", SCOPE_VERSION),
+		str$1("telemetry.sdk.name", SCOPE_NAME),
+		str$1("host.name", hostname()),
+		str$1("host.arch", arch()),
+		str$1("os.type", platform()),
+		str$1("os.version", release())
 	];
 }
-function str(key, value) {
+function str$1(key, value) {
 	return {
 		key,
 		value: { stringValue: value }
@@ -230,6 +296,113 @@ function safeJson$1(value) {
 	}
 }
 //#endregion
+//#region src/context.ts
+const TAG_MAX_CHARS = 64;
+const METADATA_VALUE_MAX_CHARS = 1024;
+const METADATA_MAX_KEYS = 64;
+/**
+* Derived tags: `openclaw`, the channel, the agent id, `cron:<job>` (or the
+* bare trigger for other non-user triggers) and `subagent:<agent>` on a run
+* that spawned one. Operator tags are appended. Tags are what `queryAnalytics`
+* can break down on, so they stay low-cardinality; ids go in metadata.
+*/
+function deriveEnrichment(run, operator) {
+	const { ctx } = run;
+	const tags = ["openclaw"];
+	if (ctx.channel) tags.push(ctx.channel);
+	if (ctx.agentId) tags.push(ctx.agentId);
+	if (ctx.trigger === "cron") tags.push(run.cron ? `cron:${run.cron.id}` : "cron");
+	else if (ctx.trigger && ctx.trigger !== "user") tags.push(ctx.trigger);
+	for (const id of run.subagentIds) tags.push(`subagent:${id}`);
+	for (const tag of operator.tags) tags.push(tag);
+	const metadata = {};
+	for (const [k, v] of Object.entries(operator.metadata)) {
+		if (k.startsWith("openclaw.")) continue;
+		metadata[k] = v;
+	}
+	const derived = {
+		"openclaw.run.id": ctx.runId,
+		"openclaw.session.id": ctx.sessionId,
+		"openclaw.session.key": ctx.sessionKey,
+		"openclaw.agent.id": ctx.agentId,
+		"openclaw.workspace.dir": ctx.workspaceDir,
+		"openclaw.channel": ctx.channel,
+		"openclaw.channel.id": ctx.channelId,
+		"openclaw.account.id": ctx.accountId,
+		"openclaw.message.provider": ctx.messageProvider,
+		"openclaw.trigger": ctx.trigger,
+		"openclaw.model.provider.id": ctx.modelProviderId,
+		"openclaw.model.id": ctx.modelId,
+		"openclaw.cron.job.id": run.cron?.id,
+		"openclaw.cron.job.name": run.cron?.name,
+		"openclaw.sender.id": run.sender?.id,
+		"openclaw.sender.name": run.sender?.name,
+		"openclaw.sender.username": run.sender?.username,
+		"openclaw.trace.id": ctx.trace?.traceId,
+		"openclaw.plugin.version": run.pluginVersion
+	};
+	for (const [k, v] of Object.entries(derived)) if (v !== void 0 && v !== "") metadata[k] = v;
+	return {
+		tags: capTags(tags),
+		metadata: capMetadata(metadata)
+	};
+}
+function capTags(tags) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const tag of tags) {
+		const trimmed = tag.trim();
+		if (trimmed.length === 0 || trimmed.length > TAG_MAX_CHARS || seen.has(trimmed)) continue;
+		seen.add(trimmed);
+		out.push(trimmed);
+		if (out.length >= 32) break;
+	}
+	return out;
+}
+function capMetadata(metadata) {
+	const out = {};
+	let count = 0;
+	for (const [k, v] of Object.entries(metadata)) {
+		if (v.length > METADATA_VALUE_MAX_CHARS) continue;
+		out[k] = v;
+		count++;
+		if (count >= METADATA_MAX_KEYS) break;
+	}
+	return out;
+}
+const CTX_MARKER = "⟦openclaw:ctx⟧";
+/**
+* OpenClaw prefixes channel prompts with a fenced JSON block after
+* `⟦openclaw:ctx⟧` that carries the sender's id and display name; the only
+* place the name reaches a run when `message_received` did not.
+*/
+function senderFromPrompt(prompt) {
+	if (!prompt) return void 0;
+	const marker = prompt.indexOf(CTX_MARKER);
+	if (marker < 0) return void 0;
+	const fenceStart = prompt.indexOf("```json", marker);
+	if (fenceStart < 0) return void 0;
+	const bodyStart = prompt.indexOf("\n", fenceStart);
+	const fenceEnd = prompt.indexOf("```", bodyStart + 1);
+	if (bodyStart < 0 || fenceEnd < 0) return void 0;
+	try {
+		const sender = JSON.parse(prompt.slice(bodyStart + 1, fenceEnd)).sender;
+		if (!sender || typeof sender.id !== "string" || sender.id.length === 0) return void 0;
+		return {
+			id: sender.id,
+			name: typeof sender.name === "string" && sender.name.length > 0 ? sender.name : void 0,
+			username: typeof sender.username === "string" && sender.username.length > 0 ? sender.username : void 0
+		};
+	} catch {
+		return;
+	}
+}
+/** `agent:<agentId>:cron:<jobId>[:run:<runId>]` is the isolated cron session key shape. */
+function cronJobFromSessionKey(sessionKey) {
+	if (!sessionKey) return void 0;
+	return /^agent:[^:]+:cron:([^:]+)/.exec(sessionKey)?.[1];
+}
+//#endregion
 //#region src/messages.ts
 const ALLOWED_ROLES = new Set([
 	"system",
@@ -237,26 +410,24 @@ const ALLOWED_ROLES = new Set([
 	"assistant",
 	"tool"
 ]);
-/**
-* Normalize a single message of any of the provider shapes we know about.
-* Returns `undefined` for non-objects so the caller can skip them.
-*/
 function normalizeMessage(raw) {
 	if (!raw || typeof raw !== "object") return void 0;
 	const obj = raw;
-	const role = coerceRole(obj.role);
 	if (Array.isArray(obj.parts)) {
 		const parts = [];
 		for (const p of obj.parts) if (p && typeof p === "object") parts.push(p);
 		return {
-			role,
+			role: coerceRole(obj.role),
 			parts: parts.length > 0 ? parts : [{
 				type: "text",
 				content: safeJson(raw)
 			}]
 		};
 	}
+	if (obj.role === "toolResult") return normalizeToolResult(obj);
+	if (obj.role === "custom") return normalizeCustom(obj);
 	const content = obj.content ?? obj.text ?? obj.message;
+	const role = isRuntimeContext(obj, content) ? "system" : coerceRole(obj.role);
 	if (role === "tool" && obj.tool_call_id !== void 0) return {
 		role,
 		parts: [{
@@ -266,11 +437,16 @@ function normalizeMessage(raw) {
 		}]
 	};
 	if (typeof content === "string") {
-		const parts = [{
+		const parts = [];
+		if (content.length > 0) parts.push({
 			type: "text",
 			content
-		}];
+		});
 		appendToolCalls(parts, obj.tool_calls);
+		if (parts.length === 0) parts.push({
+			type: "text",
+			content: ""
+		});
 		return {
 			role,
 			parts
@@ -300,7 +476,6 @@ function normalizeMessage(raw) {
 		}]
 	};
 }
-/** Normalize an array of provider messages. */
 function normalizeMessages(raw) {
 	const out = [];
 	for (const m of raw) {
@@ -309,7 +484,6 @@ function normalizeMessages(raw) {
 	}
 	return out;
 }
-/** Build a single user message from a string prompt. */
 function userMessageFromPrompt(prompt) {
 	return {
 		role: "user",
@@ -319,44 +493,73 @@ function userMessageFromPrompt(prompt) {
 		}]
 	};
 }
-/** Build a single assistant message from `assistantTexts` + `lastAssistant` fallback. */
-function assistantMessageFromOutput(assistantTexts, lastAssistant) {
-	if (lastAssistant !== void 0) {
-		const norm = normalizeMessage(lastAssistant);
-		if (norm) return {
-			...norm,
-			role: "assistant"
-		};
-	}
-	const parts = [];
-	for (const text of assistantTexts) if (text.length > 0) parts.push({
-		type: "text",
-		content: text
-	});
-	if (parts.length === 0) parts.push({
-		type: "text",
-		content: ""
-	});
-	return {
-		role: "assistant",
-		parts
-	};
-}
-/**
-* Wrap a system prompt string into the parts-array shape expected for
-* `gen_ai.system_instructions`. Empty string in → single empty text part out
-* (still a valid array, never `undefined`).
-*/
 function systemInstructionsParts(prompt) {
 	return [{
 		type: "text",
 		content: prompt
 	}];
 }
+const RUNTIME_CONTEXT_PREFIX = "[openclaw.runtime-context]";
+/**
+* OpenClaw injects its per-turn context as an extra user message right before
+* the prompt. It is instructions rather than the user's words, so it renders
+* as a system message instead of a second user bubble.
+*/
+function isRuntimeContext(obj, content) {
+	if (obj.role !== "user") return false;
+	if (obj.runtimeContext) return true;
+	const text = typeof content === "string" ? content : Array.isArray(content) ? blockText(content[0]) : void 0;
+	return typeof text === "string" && text.trimStart().startsWith(RUNTIME_CONTEXT_PREFIX);
+}
 function coerceRole(raw) {
 	if (typeof raw !== "string") return "user";
 	return ALLOWED_ROLES.has(raw) ? raw : "user";
 }
+function normalizeToolResult(obj) {
+	const content = obj.content;
+	let response;
+	if (typeof content === "string") response = content;
+	else if (Array.isArray(content)) {
+		const texts = [];
+		let hasNonText = false;
+		for (const block of content) {
+			const text = blockText(block);
+			if (text !== void 0) texts.push(text);
+			else hasNonText = true;
+		}
+		response = hasNonText ? content.map(normalizeBlock).filter(Boolean) : texts.join("\n");
+	} else response = content ?? "";
+	return {
+		role: "tool",
+		parts: [{
+			type: "tool_call_response",
+			id: typeof obj.toolCallId === "string" ? obj.toolCallId : "",
+			name: typeof obj.toolName === "string" ? obj.toolName : void 0,
+			response,
+			...obj.isError === true ? { is_error: true } : {}
+		}]
+	};
+}
+/** Text of a plain text block, or of the `toolResult` block the Codex harness wraps tool output in. */
+function blockText(block) {
+	if (!block || typeof block !== "object") return void 0;
+	const b = block;
+	if (b.type === "text" && typeof b.text === "string") return b.text;
+	if (b.type === "toolResult") {
+		if (typeof b.text === "string") return b.text;
+		if (typeof b.content === "string") return b.content;
+	}
+}
+function normalizeCustom(obj) {
+	const text = typeof obj.content === "string" ? obj.content : safeJson(obj);
+	return {
+		role: "user",
+		parts: [{
+			type: "text",
+			content: `[${typeof obj.customType === "string" ? obj.customType : "custom"}] ${text}`
+		}]
+	};
+}
 function normalizeBlock(raw) {
 	if (typeof raw === "string") return {
 		type: "text",
@@ -364,24 +567,22 @@ function normalizeBlock(raw) {
 	};
 	if (!raw || typeof raw !== "object") return void 0;
 	const obj = raw;
-	if (typeof obj.type === "string" && (typeof obj.content === "string" || obj.content === void 0)) {
-		if (obj.type === "text" && typeof obj.content === "string") return {
+	const type = typeof obj.type === "string" ? obj.type : "text";
+	if (type === "text") {
+		if (typeof obj.content === "string") return {
 			type: "text",
 			content: obj.content
 		};
+		if (typeof obj.text === "string") return {
+			type: "text",
+			content: obj.text
+		};
 	}
-	const type = typeof obj.type === "string" ? obj.type : "text";
-	if (type === "text" && typeof obj.text === "string") return {
+	if (type === "toolResult") return {
 		type: "text",
-		content: obj.text
-	};
-	if (type === "tool_use") return {
-		type: "tool_call",
-		id: typeof obj.id === "string" ? obj.id : "",
-		name: typeof obj.name === "string" ? obj.name : "",
-		arguments: obj.input ?? {}
+		content: blockText(obj) ?? safeJson(raw)
 	};
-	if (type === "tool_call") return {
+	if (type === "toolCall" || type === "tool_use" || type === "tool_call") return {
 		type: "tool_call",
 		id: typeof obj.id === "string" ? obj.id : "",
 		name: typeof obj.name === "string" ? obj.name : "",
@@ -397,33 +598,46 @@ function normalizeBlock(raw) {
 		id: typeof obj.id === "string" ? obj.id : "",
 		response: obj.response ?? ""
 	};
-	if (type === "thinking" && typeof obj.thinking === "string") return {
-		type: "reasoning",
-		content: obj.thinking
-	};
+	if (type === "thinking") {
+		if (typeof obj.thinking === "string" && obj.thinking.length > 0) return {
+			type: "reasoning",
+			content: obj.thinking
+		};
+		if (obj.redacted === true) return {
+			type: "reasoning",
+			content: "[redacted]"
+		};
+		return;
+	}
 	if (type === "reasoning" && typeof obj.content === "string") return {
 		type: "reasoning",
 		content: obj.content
 	};
-	if (type === "image" && obj.source && typeof obj.source === "object") {
-		const src = obj.source;
-		const uri = src.url ?? (src.data ? `data:${src.media_type ?? "image/unknown"};base64,${src.data}` : "");
+	if (type === "image") {
+		const uri = imageUri(obj);
 		if (uri) return {
 			type: "uri",
 			modality: "image",
 			uri
 		};
+		return {
+			type: "text",
+			content: "[image]"
+		};
 	}
 	return {
 		type,
 		content: safeJson(raw)
 	};
 }
-/**
-* OpenAI assistant messages put tool calls in a separate `tool_calls` array
-* alongside string content. Append them as parts so the trace shows what the
-* model emitted in that turn.
-*/
+function imageUri(obj) {
+	if (typeof obj.data === "string" && obj.data.length > 0) return `data:${typeof obj.mimeType === "string" ? obj.mimeType : "image/unknown"};base64,${obj.data}`;
+	if (obj.source && typeof obj.source === "object") {
+		const src = obj.source;
+		if (src.url) return src.url;
+		if (src.data) return `data:${src.media_type ?? "image/unknown"};base64,${src.data}`;
+	}
+}
 function appendToolCalls(parts, raw) {
 	if (!Array.isArray(raw)) return;
 	for (const tc of raw) {
@@ -451,301 +665,1093 @@ function safeJson(value) {
 	}
 }
 //#endregion
-//#region src/span-builder.ts
-const SUBAGENT_LINK_TTL_MS = 3600 * 1e3;
-const SUBAGENT_LINK_MAX = 1e3;
-var SpanBuilder = class {
-	runs = /* @__PURE__ */ new Map();
-	subagentLinks = /* @__PURE__ */ new Map();
-	inflightCount() {
-		return this.runs.size;
+//#region src/history.ts
+/**
+* Conversation history for harnesses that do not hand it to plugins. The
+* embedded runner passes the whole session on `llm_input.historyMessages` and
+* on `agent_end.messages`; the Codex harness owns the thread itself and passes
+* an empty history and a per-turn transcript. The plugin then rebuilds the
+* session from the turns it has seen, and on a cold start from OpenClaw's own
+* transcript store: the per-agent SQLite database (2026.9+) or the older
+* JSONL file under `<stateDir>/agents/<agent>/sessions/`.
+*/
+const MAX_MESSAGES = 400;
+const MAX_SESSIONS = 200;
+const SESSION_TTL_MS = 1440 * 60 * 1e3;
+const MAX_FILE_BYTES$1 = 8 * 1024 * 1024;
+const CURRENT_PROMPT_WINDOW_MS = 6e4;
+const defaultTranscriptReader = (path) => {
+	try {
+		if (statSync(path).size > MAX_FILE_BYTES$1) return void 0;
+		return readFileSync(path, "utf8");
+	} catch {
+		return;
 	}
-	/**
-	* Open the root `agent` span. If the runId was previously registered as a
-	* subagent's child, propagate the parent's traceId and parent the new span
-	* under the parent's `subagent` span — so the entire subagent's work nests
-	* inside the parent's trace as one waterfall.
-	*/
-	onBeforeAgentStart(evt, ctx) {
-		const runId = ctx.runId;
-		if (!runId) return;
-		if (this.runs.has(runId)) return;
-		const link = this.subagentLinks.get(runId);
-		const traceId = link?.traceId ?? hashHex(runId, 32);
-		const parentSpanId = link?.subagentSpanId ?? "";
-		const agent = {
-			spanId: hashHex(`${traceId}:${runId}:agent`, 16),
-			traceId,
-			parentSpanId,
-			name: "agent",
-			startMs: Date.now(),
-			endMs: void 0,
-			attrs: {
-				...flattenCtx(ctx),
-				...latitudeAttrs(ctx),
-				...sessionAttrs(ctx),
-				"openclaw.run.id": runId,
-				"before_agent_start.prompt:gated": evt.prompt,
-				"before_agent_start.messages:gated": evt.messages ? normalizeMessages(evt.messages) : void 0
-			}
-		};
-		this.runs.set(runId, {
-			agent,
-			history: [],
-			openModelCalls: /* @__PURE__ */ new Map(),
-			openToolCalls: /* @__PURE__ */ new Map(),
-			openCompaction: void 0,
-			closed: [],
-			childSubagentSpans: /* @__PURE__ */ new Map()
-		});
+};
+var SessionHistoryStore = class {
+	sessions = /* @__PURE__ */ new Map();
+	now;
+	constructor(now = () => Date.now()) {
+		this.now = now;
 	}
-	/**
-	* Enrich the open `agent` span with content + identity from the LLM input.
-	* Also seeds the rolling history snapshot used by per-call `model_call`
-	* input attributes.
-	*
-	* Provider-specific message shapes get normalized into the parts-based
-	* GenAI format here — that's the contract Latitude's downstream parser
-	* expects on `gen_ai.input.messages` and `gen_ai.system_instructions`.
-	*/
-	onLlmInput(evt, ctx) {
-		const run = this.runs.get(ctx.runId ?? evt.runId);
-		if (!run) return;
-		const inputMessages = [...normalizeMessages(evt.historyMessages)];
-		if (evt.prompt) inputMessages.push(userMessageFromPrompt(evt.prompt));
-		Object.assign(run.agent.attrs, {
-			"gen_ai.system_instructions:gated": evt.systemPrompt ? systemInstructionsParts(evt.systemPrompt) : void 0,
-			"user_prompt:gated": evt.prompt,
-			"gen_ai.input.messages:gated": inputMessages,
-			"openclaw.images.count": evt.imagesCount,
-			"gen_ai.request.model": evt.model,
-			"gen_ai.system": evt.provider,
-			"openclaw.provider": evt.provider
-		});
-		run.history = inputMessages;
+	get(sessionId) {
+		const entry = this.sessions.get(sessionId);
+		if (!entry) return void 0;
+		entry.updatedAt = this.now();
+		return entry.messages;
 	}
-	/**
-	* Enrich the agent span with attempt-aggregate output + token usage.
-	* (Per-call usage isn't surfaced by OpenClaw today — see PR #2986.)
-	*/
-	onLlmOutput(evt, ctx) {
-		const run = this.runs.get(ctx.runId ?? evt.runId);
-		if (!run) return;
-		const assistantMessage = assistantMessageFromOutput(evt.assistantTexts, evt.lastAssistant);
-		Object.assign(run.agent.attrs, {
-			"gen_ai.output.messages:gated": [assistantMessage],
-			"openclaw.resolved.ref": evt.resolvedRef,
-			"openclaw.harness.id": evt.harnessId,
-			"gen_ai.response.model": evt.model,
-			...usageAttrs(evt.usage)
-		});
+	/** Replace the session's history with a full transcript the harness supplied. */
+	replace(sessionId, messages) {
+		this.set(sessionId, messages.slice(-MAX_MESSAGES));
 	}
-	onModelCallStarted(evt, ctx) {
-		const run = this.runs.get(evt.runId);
-		if (!run) return;
-		const span = {
-			spanId: hashHex(`${run.agent.traceId}:model_call:${evt.callId}`, 16),
-			traceId: run.agent.traceId,
-			parentSpanId: run.agent.spanId,
-			name: "model_call",
-			startMs: Date.now(),
-			endMs: void 0,
-			attrs: {
-				...latitudeAttrs(ctx),
-				...sessionAttrs(ctx),
-				"openclaw.run.id": evt.runId,
-				"openclaw.call.id": evt.callId,
-				"gen_ai.system": evt.provider,
-				"openclaw.provider": evt.provider,
-				"gen_ai.request.model": evt.model,
-				"openclaw.api": evt.api,
-				"openclaw.transport": evt.transport,
-				"gen_ai.input.messages:gated": [...run.history]
-			}
-		};
-		run.openModelCalls.set(evt.callId, span);
+	/** Extend the session's history with one turn's new messages. */
+	append(sessionId, base, turn) {
+		this.set(sessionId, [...base, ...turn].slice(-MAX_MESSAGES));
 	}
-	onModelCallEnded(evt, _ctx) {
-		const run = this.runs.get(evt.runId);
-		if (!run) return;
-		const span = run.openModelCalls.get(evt.callId);
-		if (!span) return;
-		span.endMs = Date.now();
-		span.outcome = evt.outcome === "completed" ? "ok" : "error";
-		span.errorMessage = evt.errorCategory;
-		Object.assign(span.attrs, {
-			"openclaw.duration_ms": evt.durationMs,
-			"openclaw.outcome": evt.outcome,
-			"openclaw.error.category": evt.errorCategory,
-			"openclaw.failure.kind": evt.failureKind,
-			"openclaw.request.payload_bytes": evt.requestPayloadBytes,
-			"openclaw.response.stream_bytes": evt.responseStreamBytes,
-			"openclaw.ttfb_ms": evt.timeToFirstByteMs,
-			"openclaw.upstream.request_id_hash": evt.upstreamRequestIdHash
-		});
-		run.openModelCalls.delete(evt.callId);
-		run.closed.push(span);
+	forget(sessionId) {
+		this.sessions.delete(sessionId);
 	}
-	/**
-	* Open a `tool_call` span as a sibling of the agent span. Also append a
-	* synthetic assistant `tool_call` part to the rolling history so the NEXT
-	* model_call's input snapshot reflects what the model emitted.
-	*
-	* IMPORTANT: this runs as a `runModifyingHook` in OpenClaw — returning
-	* anything other than `undefined`/falsy from this handler blocks the tool.
-	* The plugin-side handler enforces a void return; this method's signature
-	* already returns `void`.
-	*/
-	onBeforeToolCall(evt, ctx) {
-		if (!evt.runId) return;
-		const run = this.runs.get(evt.runId);
-		if (!run) return;
-		const toolCallId = evt.toolCallId ?? `${evt.toolName}:${randomUUID()}`;
-		const span = {
-			spanId: hashHex(`${run.agent.traceId}:tool_call:${toolCallId}`, 16),
-			traceId: run.agent.traceId,
-			parentSpanId: run.agent.spanId,
-			name: `tool_call:${evt.toolName}`,
-			startMs: Date.now(),
-			endMs: void 0,
-			attrs: {
-				...latitudeAttrs(ctx),
-				...sessionAttrs(ctx),
-				"openclaw.run.id": evt.runId,
-				"gen_ai.tool.name": evt.toolName,
-				"gen_ai.tool.call.id": toolCallId,
-				"gen_ai.tool.call.arguments:gated": evt.params
-			}
-		};
-		run.openToolCalls.set(toolCallId, span);
-		run.history.push({
-			role: "assistant",
-			parts: [{
-				type: "tool_call",
-				id: toolCallId,
-				name: evt.toolName,
-				arguments: evt.params
-			}]
+	set(sessionId, messages) {
+		this.evict();
+		this.sessions.set(sessionId, {
+			messages,
+			updatedAt: this.now()
 		});
 	}
-	onAfterToolCall(evt, _ctx) {
-		if (!evt.runId) return;
-		const run = this.runs.get(evt.runId);
-		if (!run) return;
-		let resolvedId = evt.toolCallId && run.openToolCalls.has(evt.toolCallId) ? evt.toolCallId : void 0;
-		if (!resolvedId) resolvedId = this.findOpenToolCallByName(run, evt.toolName);
-		if (!resolvedId) return;
-		const span = run.openToolCalls.get(resolvedId);
-		if (!span) return;
-		const toolCallId = resolvedId;
-		span.endMs = Date.now();
-		span.outcome = Boolean(evt.error) ? "error" : "ok";
-		span.errorMessage = evt.error;
-		Object.assign(span.attrs, {
-			"gen_ai.tool.call.result:gated": evt.result,
-			"openclaw.error.message:gated": evt.error,
-			"openclaw.duration_ms": evt.durationMs
-		});
-		run.openToolCalls.delete(toolCallId);
-		run.closed.push(span);
-		run.history.push({
-			role: "tool",
-			parts: [{
-				type: "tool_call_response",
-				id: toolCallId,
-				response: evt.result ?? evt.error ?? ""
-			}]
-		});
+	evict() {
+		const now = this.now();
+		for (const [id, entry] of this.sessions) if (now - entry.updatedAt > SESSION_TTL_MS) this.sessions.delete(id);
+		if (this.sessions.size < MAX_SESSIONS) return;
+		const oldest = Array.from(this.sessions.entries()).sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+		for (const [id] of oldest.slice(0, this.sessions.size - MAX_SESSIONS + 1)) this.sessions.delete(id);
 	}
-	onBeforeCompaction(evt, ctx) {
-		const runId = ctx.runId;
+};
+/** The default workspace is `<stateDir>/workspace`, which is the only structural clue a run carries. */
+function stateDirFromWorkspace(workspaceDir) {
+	if (!workspaceDir) return void 0;
+	return basename(workspaceDir) === "workspace" ? dirname(workspaceDir) : void 0;
+}
+function sessionTranscriptPath(stateDir, agentId, sessionId) {
+	return join(stateDir, "agents", agentId, "sessions", `${sessionId}.jsonl`);
+}
+function agentDatabasePath(stateDir, agentId) {
+	return join(stateDir, "agents", agentId, "agent", "openclaw-agent.sqlite");
+}
+/**
+* Reads through `node:sqlite` (Node 22.13+), loaded lazily so a host without
+* it degrades to "no history" instead of failing to load the plugin. The
+* database is opened read-only; the gateway keeps its own writer open.
+*/
+const defaultTranscriptRowsReader = (dbPath, sessionId) => {
+	let db;
+	try {
+		db = new (createRequire(import.meta.url)("node:sqlite")).DatabaseSync(dbPath, { readOnly: true });
+	} catch {
+		return;
+	}
+	try {
+		const active = db.prepare(`SELECT e.event_json AS event_json
+           FROM session_transcript_active_events a
+           JOIN transcript_events e ON e.session_id = a.session_id AND e.seq = a.event_seq
+          WHERE a.session_id = ?
+          ORDER BY a.active_position`).all(sessionId);
+		return (active.length > 0 ? active : db.prepare("SELECT event_json FROM transcript_events WHERE session_id = ? ORDER BY seq").all(sessionId)).map((row) => row && typeof row === "object" ? row.event_json : void 0).filter((v) => typeof v === "string");
+	} catch {
+		return;
+	} finally {
+		try {
+			db.close();
+		} catch {}
+	}
+};
+/**
+* The latest compaction entry of a session. `after_compaction` reports only
+* counts; the summary that replaced the compacted messages lives in the
+* transcript store, written before the hook fires.
+*/
+function readLatestCompaction(dbPath, sessionId, readRows = defaultTranscriptRowsReader) {
+	const rows = readRows(dbPath, sessionId);
+	return rows ? latestCompactionFromEntries(rows) : void 0;
+}
+function readLatestCompactionFromFile(path, read = defaultTranscriptReader) {
+	const raw = read(path);
+	return raw === void 0 ? void 0 : latestCompactionFromEntries(raw.split("\n"));
+}
+function latestCompactionFromEntries(lines) {
+	let latest;
+	for (const line of lines) {
+		if (!line.includes("\"compaction\"")) continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (!entry || entry.type !== "compaction" || typeof entry.summary !== "string") continue;
+		latest = {
+			summary: entry.summary,
+			tokensBefore: typeof entry.tokensBefore === "number" ? entry.tokensBefore : void 0,
+			tokensAfter: typeof entry.tokensAfter === "number" ? entry.tokensAfter : void 0
+		};
+	}
+	return latest;
+}
+/** The session's visible conversation from the agent database, oldest first. */
+function readSessionTranscriptFromDatabase(dbPath, sessionId, readRows = defaultTranscriptRowsReader) {
+	const rows = readRows(dbPath, sessionId);
+	if (!rows) return void 0;
+	return messagesFromEntries(rows);
+}
+/**
+* The current prompt is usually persisted before `llm_input` fires, so the
+* stored transcript ends with it. Channels wrap the prompt in an envelope
+* (conversation info, system lines) before the model sees it, so the stored
+* text is matched by containment; a very recent trailing user message with no
+* text match is dropped as well.
+*/
+function withoutCurrentPrompt(stored, prompt, runStartMs) {
+	const kept = [...stored];
+	for (let i = 0; i < 3 && kept.length > 0; i++) {
+		const last = kept[kept.length - 1];
+		if (last.message.role !== "user") break;
+		const text = last.message.parts.map((p) => typeof p.content === "string" ? p.content : "").join("\n").trim();
+		const textMatches = text.length > 0 && prompt !== void 0 && (prompt === text || prompt.includes(text));
+		const recent = last.timestamp !== void 0 && Math.abs(runStartMs - last.timestamp) <= CURRENT_PROMPT_WINDOW_MS;
+		if (!textMatches && !recent) break;
+		kept.pop();
+	}
+	return kept.map((m) => m.message);
+}
+/**
+* OpenClaw's transcript is a JSONL tree of entries; the visible conversation is
+* the parent chain of the last message entry (compaction and reset entries
+* branch it). Returns the normalized messages, oldest first.
+*/
+function readSessionTranscript(path, read = defaultTranscriptReader) {
+	const raw = read(path);
+	if (raw === void 0) return void 0;
+	return messagesFromEntries(raw.split("\n"));
+}
+function messagesFromEntries(lines) {
+	const byId = /* @__PURE__ */ new Map();
+	let last;
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (!entry || typeof entry !== "object") continue;
+		if (typeof entry.id === "string") byId.set(entry.id, entry);
+		if (entry.type === "message" && entry.message) last = entry;
+	}
+	if (!last) return [];
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let cursor = last;
+	while (cursor && chain.length < MAX_MESSAGES) {
+		if (cursor.type === "message" && cursor.message) chain.push(cursor);
+		if (cursor.type === "compaction") {
+			if (typeof cursor.summary === "string" && cursor.summary.length > 0) chain.push({
+				type: "message",
+				message: {
+					role: "user",
+					content: `[compaction summary] ${cursor.summary}`
+				}
+			});
+			break;
+		}
+		const parentId = cursor.parentId;
+		if (!parentId || seen.has(parentId)) break;
+		seen.add(parentId);
+		cursor = byId.get(parentId);
+	}
+	chain.reverse();
+	const out = [];
+	for (const entry of chain) {
+		const [message] = normalizeMessages([entry.message]);
+		if (message) out.push({
+			message,
+			timestamp: entryTimestamp(entry)
+		});
+	}
+	return out;
+}
+function entryTimestamp(entry) {
+	const inner = entry.message?.timestamp;
+	if (typeof inner === "number") return inner;
+	if (typeof entry.timestamp === "string") {
+		const parsed = Date.parse(entry.timestamp);
+		if (!Number.isNaN(parsed)) return parsed;
+	}
+}
+//#endregion
+//#region src/memory.ts
+const MAX_FILE_BYTES = 1024 * 1024;
+const MEMORY_ROOT_FILES = new Set([
+	"MEMORY.md",
+	"memory.md",
+	"USER.md",
+	"user.md"
+]);
+const MEMORY_DIR = "memory";
+function memoryStoreId(agentId) {
+	return `openclaw/${agentId ?? "main"}`;
+}
+const defaultFileReader = (path) => {
+	try {
+		if (statSync(path).size > MAX_FILE_BYTES) return void 0;
+		return readFileSync(path, "utf8");
+	} catch {
+		return;
+	}
+};
+/** Workspace-relative record id for a path inside the memory scope, else undefined. */
+function memoryRecordId(path, workspaceDir) {
+	if (!path) return void 0;
+	const abs = workspaceDir ? resolve(workspaceDir, path) : isAbsolute(path) ? path : void 0;
+	if (!abs) return void 0;
+	const rel = workspaceDir ? relative(workspaceDir, abs) : abs;
+	if (rel.startsWith("..")) return void 0;
+	const normalized = rel.split(sep).join("/");
+	if (MEMORY_ROOT_FILES.has(normalized)) return normalized;
+	if (normalized.startsWith(`${MEMORY_DIR}/`) && normalized.endsWith(".md")) return normalized;
+}
+/** Classify a finished tool call as memory operations; empty when it touched none. */
+function memoryEventsFromToolCall(call, readFile = defaultFileReader) {
+	if (call.error) return [];
+	if (call.toolName === "apply_patch") return patchEvents(call, memoryStoreId(call.agentId), readFile);
+	const single = singleMemoryEvent(call, readFile);
+	return single ? [single] : [];
+}
+function singleMemoryEvent(call, readFile) {
+	const storeId = memoryStoreId(call.agentId);
+	switch (call.toolName) {
+		case "memory_search": return {
+			operation: "search_memory",
+			storeId,
+			queryText: str(call.params.query),
+			records: searchRecords(call.result)
+		};
+		case "memory_get": {
+			const path = str(call.params.path);
+			const text = resultText(call.result);
+			return {
+				operation: "search_memory",
+				storeId,
+				recordId: path,
+				records: text !== void 0 ? [{
+					id: path,
+					content: text
+				}] : []
+			};
+		}
+		case "memory_recall": return {
+			operation: "search_memory",
+			storeId,
+			queryText: str(call.params.query),
+			records: searchRecords(call.result)
+		};
+		case "memory_store": {
+			const text = str(call.params.text) ?? str(call.params.content);
+			return {
+				operation: "upsert_memory",
+				storeId,
+				records: text !== void 0 ? [{ content: text }] : []
+			};
+		}
+		case "memory_forget": return {
+			operation: "delete_memory",
+			storeId,
+			recordId: str(call.params.id) ?? str(call.params.query),
+			records: []
+		};
+		case "write":
+		case "edit": return fileWriteEvent(call, storeId, readFile);
+		default: return;
+	}
+}
+function fileWriteEvent(call, storeId, readFile) {
+	const path = str(call.params.path);
+	const recordId = memoryRecordId(path, call.workspaceDir);
+	if (!recordId || !path) return void 0;
+	const abs = call.workspaceDir ? resolve(call.workspaceDir, path) : path;
+	return writeEvent(storeId, recordId, call.toolName === "write" ? str(call.params.content) : readFile(abs));
+}
+function writeEvent(storeId, recordId, body) {
+	if (body === void 0) return {
+		operation: "upsert_memory",
+		storeId,
+		recordId,
+		records: [],
+		bodyUnavailable: true
+	};
+	if (body.trim().length === 0) return {
+		operation: "delete_memory",
+		storeId,
+		recordId,
+		records: []
+	};
+	return {
+		operation: "upsert_memory",
+		storeId,
+		recordId,
+		records: [{
+			id: recordId,
+			content: body
+		}]
+	};
+}
+const PATCH_FILE_LINE = /^\*\*\* (Update|Add|Delete) File: (.+)$/gm;
+/**
+* Codex's `apply_patch` takes one patch text touching any number of files
+* (`*** Update File: <path>`). Each memory-scoped file becomes its own event,
+* with the body read back from disk after the patch landed.
+*/
+function patchEvents(call, storeId, readFile) {
+	const patch = str(call.params.command) ?? str(call.params.input) ?? str(call.params.patch);
+	if (!patch) return [];
+	const events = [];
+	for (const match of patch.matchAll(PATCH_FILE_LINE)) {
+		const action = match[1];
+		const path = match[2]?.trim();
+		const recordId = memoryRecordId(path, call.workspaceDir);
+		if (!recordId || !path) continue;
+		if (action === "Delete") {
+			events.push({
+				operation: "delete_memory",
+				storeId,
+				recordId,
+				records: []
+			});
+			continue;
+		}
+		const abs = call.workspaceDir ? resolve(call.workspaceDir, path) : path;
+		events.push(writeEvent(storeId, recordId, readFile(abs)));
+	}
+	return events;
+}
+/**
+* The frozen snapshot injected at session start: every non-empty built-in
+* store file, read once per session. Returns undefined when nothing exists.
+*/
+function memorySnapshot(workspaceDir, agentId, readFile = defaultFileReader, today = /* @__PURE__ */ new Date()) {
+	if (!workspaceDir) return void 0;
+	const candidates = [
+		"MEMORY.md",
+		"USER.md",
+		`${MEMORY_DIR}/${today.toISOString().slice(0, 10)}.md`
+	];
+	const records = [];
+	for (const rel of candidates) {
+		const body = readFile(resolve(workspaceDir, rel));
+		if (body !== void 0 && body.trim().length > 0) records.push({
+			id: rel,
+			content: body
+		});
+	}
+	if (records.length === 0) return void 0;
+	return {
+		operation: "search_memory",
+		storeId: memoryStoreId(agentId),
+		records
+	};
+}
+function searchRecords(result) {
+	const details = detailsOf(result);
+	const list = Array.isArray(details?.results) ? details.results : void 0;
+	if (list) {
+		const out = [];
+		for (const item of list) {
+			if (!item || typeof item !== "object") continue;
+			const r = item;
+			const path = str(r.path);
+			const line = typeof r.startLine === "number" ? `#${r.startLine}` : "";
+			out.push({
+				...path ? { id: `${path}${line}` } : {},
+				content: str(r.snippet) ?? str(r.text) ?? str(r.content) ?? "",
+				...typeof r.score === "number" ? { score: r.score } : {}
+			});
+		}
+		return out;
+	}
+	const text = resultText(result);
+	return text !== void 0 && text.length > 0 ? [{ content: text }] : [];
+}
+function detailsOf(result) {
+	if (!result || typeof result !== "object") return void 0;
+	const details = result.details;
+	return details && typeof details === "object" ? details : void 0;
+}
+function resultText(result) {
+	if (typeof result === "string") return result;
+	if (!result || typeof result !== "object") return void 0;
+	const details = detailsOf(result);
+	if (details && typeof details.text === "string") return details.text;
+	const content = result.content;
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		const texts = content.map((b) => b && typeof b === "object" && typeof b.text === "string" ? b.text : "").filter((t) => t.length > 0);
+		if (texts.length > 0) return texts.join("\n");
+	}
+}
+function str(value) {
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+//#region src/tools.ts
+/**
+* `llm_input.tools` is the post-policy tool list offered to the model, as
+* pi-ai `Tool` objects (`name`, `description`, `parameters` JSON schema) plus
+* runtime fields such as `execute` that never leave the process.
+*/
+function toolDefinitionsFrom(raw) {
+	if (!raw || raw.length === 0) return void 0;
+	const out = [];
+	for (const item of raw) {
+		if (!item || typeof item !== "object") continue;
+		const obj = item;
+		const fn = obj.function && typeof obj.function === "object" ? obj.function : obj;
+		if (typeof fn.name !== "string" || fn.name.length === 0) continue;
+		const parameters = fn.parameters ?? fn.inputSchema ?? fn.input_schema;
+		out.push({
+			type: "function",
+			name: fn.name,
+			description: typeof fn.description === "string" ? fn.description : "",
+			...parameters !== void 0 ? { parameters: plainSchema(parameters) } : {}
+		});
+	}
+	return out.length > 0 ? out : void 0;
+}
+function plainSchema(schema) {
+	try {
+		return JSON.parse(JSON.stringify(schema));
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/usage.ts
+function isTranscriptAssistant(raw) {
+	return !!raw && typeof raw === "object" && raw.role === "assistant";
+}
+const FINISH_REASONS = {
+	stop: "stop",
+	length: "length",
+	toolUse: "tool_calls",
+	error: "error",
+	aborted: "cancelled"
+};
+function finishReason(stopReason) {
+	if (!stopReason) return void 0;
+	return FINISH_REASONS[stopReason] ?? stopReason;
+}
+/**
+* `gen_ai.usage.*` from a transcript message. `output_tokens` stays inclusive
+* of reasoning: Latitude's resolver subtracts `reasoning_tokens` itself.
+*/
+function usageAttrsFromTranscript(usage) {
+	if (!usage) return {};
+	const input = num(usage.input);
+	const output = num(usage.output);
+	const cacheRead = num(usage.cacheRead);
+	const cacheWrite = num(usage.cacheWrite);
+	const total = num(usage.totalTokens) ?? sumDefined(input, output, cacheRead, cacheWrite);
+	return {
+		"gen_ai.usage.input_tokens": input,
+		"gen_ai.usage.output_tokens": output,
+		"gen_ai.usage.cache_read.input_tokens": cacheRead,
+		"gen_ai.usage.cache_creation.input_tokens": cacheWrite,
+		"gen_ai.usage.reasoning_tokens": num(usage.reasoningTokens),
+		"gen_ai.usage.total_tokens": total,
+		...costAttrs(usage.cost)
+	};
+}
+/** Attempt-aggregate usage from `llm_output`, same keys. */
+function usageAttrsFromAggregate(usage) {
+	if (!usage) return {};
+	const input = num(usage.input);
+	const output = num(usage.output);
+	const cacheRead = num(usage.cacheRead);
+	const cacheWrite = num(usage.cacheWrite);
+	return {
+		"gen_ai.usage.input_tokens": input,
+		"gen_ai.usage.output_tokens": output,
+		"gen_ai.usage.cache_read.input_tokens": cacheRead,
+		"gen_ai.usage.cache_creation.input_tokens": cacheWrite,
+		"gen_ai.usage.total_tokens": num(usage.total) ?? sumDefined(input, output, cacheRead, cacheWrite)
+	};
+}
+/**
+* OpenClaw prices every call from its own model catalog (or the provider's
+* bill when `totalOrigin` says so). A positive total is reported as the span's
+* cost so a model missing from Latitude's catalog still carries a price.
+*/
+function costAttrs(cost) {
+	if (!cost) return {};
+	const total = num(cost.total);
+	if (total === void 0 || total <= 0) return {};
+	return {
+		"gen_ai.usage.cost": total,
+		"gen_ai.usage.input_cost": sumDefined(num(cost.input), num(cost.cacheRead), num(cost.cacheWrite)),
+		"gen_ai.usage.output_cost": num(cost.output),
+		"openclaw.cost.origin": cost.totalOrigin === "provider-billed" ? "provider-billed" : "catalog"
+	};
+}
+function num(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function sumDefined(...values) {
+	const defined = values.filter((v) => v !== void 0);
+	if (defined.length === 0) return void 0;
+	return defined.reduce((a, b) => a + b, 0);
+}
+//#endregion
+//#region src/span-builder.ts
+const GRACE_MS = 1500;
+const RUN_TTL_MS = 7200 * 1e3;
+const LINK_TTL_MS = 3600 * 1e3;
+const LINK_MAX = 1e3;
+const SESSION_INDEX_MAX = 2e3;
+const STANDALONE_COMPACTION_MAX = 100;
+const SPAWN_TOOL_PATTERN = /spawn/i;
+const MAX_DELTAS = 256;
+const MAX_THINKING_CHARS = 64 * 1024;
+const KIND_INTERNAL = 1;
+const KIND_CLIENT = 3;
+var SpanBuilder = class {
+	runs = /* @__PURE__ */ new Map();
+	runsBySession = /* @__PURE__ */ new Map();
+	subagentLinks = /* @__PURE__ */ new Map();
+	pendingSubagents = /* @__PURE__ */ new Map();
+	sessionIds = /* @__PURE__ */ new Map();
+	modelBySession = /* @__PURE__ */ new Map();
+	workspaceBySession = /* @__PURE__ */ new Map();
+	memorySnapshotSessions = /* @__PURE__ */ new Set();
+	senders = /* @__PURE__ */ new Map();
+	sendersById = /* @__PURE__ */ new Map();
+	cronStarted = /* @__PURE__ */ new Map();
+	sessionHistory;
+	standaloneCompactions = /* @__PURE__ */ new Map();
+	emit;
+	now;
+	schedule;
+	readFile;
+	readTranscript;
+	readTranscriptRows;
+	stateDir;
+	log;
+	pluginVersion;
+	operatorTags;
+	operatorMetadata;
+	memoryEnabled;
+	memoryContent;
+	toolDefinitionsEnabled;
+	constructor(options) {
+		this.emit = options.emit;
+		this.now = options.now ?? (() => Date.now());
+		this.schedule = options.schedule ?? ((fn, ms) => {
+			const timer = setTimeout(fn, ms);
+			timer.unref?.();
+			return () => clearTimeout(timer);
+		});
+		this.readFile = options.readFile;
+		this.readTranscript = options.readTranscript;
+		this.readTranscriptRows = options.readTranscriptRows;
+		this.stateDir = options.stateDir;
+		this.sessionHistory = new SessionHistoryStore(this.now);
+		this.log = options.log ?? (() => {});
+		this.pluginVersion = options.pluginVersion;
+		this.operatorTags = options.tags ?? [];
+		this.operatorMetadata = options.metadata ?? {};
+		this.memoryEnabled = options.memory ?? true;
+		this.memoryContent = options.memoryContent ?? true;
+		this.toolDefinitionsEnabled = options.toolDefinitions ?? true;
+	}
+	inflightCount() {
+		return this.runs.size;
+	}
+	subagentLinkCount() {
+		return this.subagentLinks.size;
+	}
+	onLlmInput(evt, ctx) {
+		const run = this.ensureRun(evt.runId, ctx);
+		if (!run) return;
+		const harnessHistory = normalizeMessages(evt.historyMessages);
+		if (harnessHistory.length > 0) {
+			run.inheritedHistory = [];
+			run.historySource = "harness";
+		} else this.inheritHistory(run, evt.prompt);
+		run.history = [...run.inheritedHistory, ...harnessHistory];
+		if (evt.prompt) run.history.push(userMessageFromPrompt(evt.prompt));
+		run.inputMessages = [...run.history];
+		run.prompt = evt.prompt;
+		run.systemPrompt = evt.systemPrompt;
+		if (run.ctx.sessionKey) {
+			remember(this.modelBySession, run.ctx.sessionKey, {
+				provider: evt.provider,
+				model: evt.model
+			}, SESSION_INDEX_MAX);
+			if (run.ctx.workspaceDir) remember(this.workspaceBySession, run.ctx.sessionKey, run.ctx.workspaceDir, SESSION_INDEX_MAX);
+		}
+		if (this.toolDefinitionsEnabled) run.toolDefinitions = toolDefinitionsFrom(evt.tools) ?? run.toolDefinitions;
+		Object.assign(run.root.attrs, {
+			"gen_ai.request.model": evt.model,
+			"openclaw.provider": evt.provider,
+			"openclaw.images.count": evt.imagesCount,
+			"openclaw.tool_count": evt.tools?.length
+		});
+		this.recordMemorySnapshot(run);
+	}
+	onLlmOutput(evt, ctx) {
+		const run = this.runs.get(ctx.runId ?? evt.runId);
+		if (!run) return;
+		this.mergeCtx(run, ctx);
+		run.outputSeen = true;
+		run.aggregateUsage = usageAttrsFromAggregate(evt.usage);
+		run.output = {
+			resolvedRef: evt.resolvedRef,
+			harnessId: evt.harnessId,
+			reasoningEffort: evt.reasoningEffort,
+			lastAssistant: evt.lastAssistant
+		};
+		Object.assign(run.root.attrs, {
+			"gen_ai.response.model": evt.model,
+			"openclaw.resolved.ref": evt.resolvedRef,
+			"openclaw.harness.id": evt.harnessId,
+			"openclaw.reasoning.effort": evt.reasoningEffort
+		});
+		if (run.endEvent) this.finalize(run);
+	}
+	onAgentEnd(evt, ctx) {
+		const runId = ctx.runId ?? evt.runId;
+		if (!runId) return;
+		const run = this.runs.get(runId);
+		if (!run) {
+			this.subagentLinks.delete(runId);
+			return;
+		}
+		this.mergeCtx(run, ctx);
+		run.endEvent = evt;
+		if (run.outputSeen) {
+			this.finalize(run);
+			return;
+		}
+		run.cancelGrace = this.schedule(() => this.finalize(run), GRACE_MS);
+	}
+	onModelCallStarted(evt, ctx) {
+		const run = this.ensureRun(evt.runId, {
+			...ctx,
+			sessionId: ctx.sessionId ?? evt.sessionId,
+			sessionKey: ctx.sessionKey ?? evt.sessionKey
+		});
+		if (!run) return;
+		const span = {
+			spanId: hashHex(`${run.runId}:llm_request:${evt.callId}`, 16),
+			traceId: run.traceId,
+			parentSpanId: run.root.spanId,
+			name: "llm_request",
+			kind: KIND_INTERNAL,
+			startMs: this.now(),
+			endMs: void 0,
+			attrs: {
+				"gen_ai.operation.name": "chat",
+				"gen_ai.provider.name": evt.provider,
+				"gen_ai.system": evt.provider,
+				"gen_ai.request.model": evt.model,
+				"gen_ai.request.stream": true,
+				"openclaw.call.id": evt.callId,
+				"openclaw.api": evt.api,
+				"openclaw.transport": evt.transport,
+				"openclaw.context.token_budget": evt.contextTokenBudget,
+				"llm_request.call_index": run.llmCalls.length + run.openModelCalls.size,
+				"gen_ai.input.messages:gated": [...run.history],
+				"gen_ai.system_instructions:gated": run.systemPrompt ? systemInstructionsParts(run.systemPrompt) : void 0,
+				"gen_ai.tool.definitions:gated": run.toolDefinitions
+			}
+		};
+		run.openModelCalls.set(evt.callId, span);
+	}
+	onModelCallEnded(evt, _ctx) {
+		const run = this.runs.get(evt.runId);
+		if (!run) return;
+		const span = run.openModelCalls.get(evt.callId);
+		if (!span) return;
+		span.endMs = this.now();
+		span.outcome = evt.outcome === "completed" ? "ok" : "error";
+		span.errorMessage = evt.errorCategory;
+		Object.assign(span.attrs, {
+			"openclaw.duration_ms": evt.durationMs,
+			"openclaw.outcome": evt.outcome,
+			"openclaw.error.category": evt.errorCategory,
+			"openclaw.failure.kind": evt.failureKind,
+			"error.type": evt.outcome === "error" ? evt.errorCategory ?? evt.failureKind ?? "error" : void 0,
+			"openclaw.request.payload_bytes": evt.requestPayloadBytes,
+			"openclaw.response.stream_bytes": evt.responseStreamBytes,
+			"openclaw.ttfb_ms": evt.timeToFirstByteMs,
+			"gen_ai.server.time_to_first_token": evt.timeToFirstByteMs !== void 0 && evt.timeToFirstByteMs > 0 ? Math.round(evt.timeToFirstByteMs * 1e6) : void 0,
+			"openclaw.upstream.request_id_hash": evt.upstreamRequestIdHash
+		});
+		run.openModelCalls.delete(evt.callId);
+		run.llmCalls.push(span);
+	}
+	onBeforeToolCall(evt, ctx) {
+		const runId = evt.runId ?? ctx.runId;
+		if (!runId) return;
+		const run = this.ensureRun(runId, toolCtxToAgentCtx(ctx, runId));
+		if (!run) return;
+		const toolCallId = evt.toolCallId ?? ctx.toolCallId ?? `${evt.toolName}:${randomUUID()}`;
+		const span = {
+			spanId: hashHex(`${run.runId}:tool_call:${toolCallId}`, 16),
+			traceId: run.traceId,
+			parentSpanId: run.root.spanId,
+			name: `tool_call:${evt.toolName}`,
+			kind: KIND_CLIENT,
+			startMs: this.now(),
+			endMs: void 0,
+			attrs: {
+				"gen_ai.operation.name": "execute_tool",
+				"gen_ai.tool.name": evt.toolName,
+				"gen_ai.tool.call.id": toolCallId,
+				"gen_ai.tool.call.arguments:gated": evt.params
+			}
+		};
+		run.openToolCalls.set(toolCallId, span);
+		run.history.push({
+			role: "assistant",
+			parts: [{
+				type: "tool_call",
+				id: toolCallId,
+				name: evt.toolName,
+				arguments: evt.params
+			}]
+		});
+		if (SPAWN_TOOL_PATTERN.test(evt.toolName)) run.lastSpawnToolSpanId = span.spanId;
+	}
+	onAfterToolCall(evt, ctx) {
+		const runId = evt.runId ?? ctx.runId;
 		if (!runId) return;
 		const run = this.runs.get(runId);
 		if (!run) return;
-		run.openCompaction = {
-			spanId: hashHex(`${run.agent.traceId}:compaction:${run.closed.length}`, 16),
-			traceId: run.agent.traceId,
-			parentSpanId: run.agent.spanId,
+		let resolvedId = evt.toolCallId && run.openToolCalls.has(evt.toolCallId) ? evt.toolCallId : void 0;
+		if (!resolvedId) resolvedId = this.findOpenToolCallByName(run, evt.toolName);
+		if (!resolvedId) return;
+		const span = run.openToolCalls.get(resolvedId);
+		if (!span) return;
+		span.endMs = this.now();
+		const isError = Boolean(evt.error);
+		span.outcome = isError ? "error" : "ok";
+		span.errorMessage = evt.error;
+		Object.assign(span.attrs, {
+			"gen_ai.tool.call.result:gated": evt.result,
+			"tool.is_error": isError,
+			"error.type": isError ? "tool_error" : void 0,
+			"error.message:gated": evt.error,
+			"openclaw.duration_ms": evt.durationMs
+		});
+		run.openToolCalls.delete(resolvedId);
+		run.closed.push(span);
+		run.history.push({
+			role: "tool",
+			parts: [{
+				type: "tool_call_response",
+				id: resolvedId,
+				name: evt.toolName,
+				response: evt.result ?? evt.error ?? ""
+			}]
+		});
+		if (this.memoryEnabled) {
+			const events = memoryEventsFromToolCall({
+				toolName: evt.toolName,
+				params: evt.params,
+				result: evt.result,
+				error: evt.error,
+				workspaceDir: run.ctx.workspaceDir,
+				agentId: run.ctx.agentId
+			}, this.readFile);
+			for (const memory of events) run.closed.push(this.memorySpan(run, memory, span));
+		}
+	}
+	/**
+	* A compaction is a model call of its own: the compacted messages go in and
+	* a summary comes out, so it is exported as a `chat` span. OpenClaw fires no
+	* per-call hooks for the summarizer, so its usage is unreported.
+	*/
+	onBeforeCompaction(evt, ctx) {
+		const run = this.openRunForSession(ctx.sessionKey);
+		const startMs = this.now();
+		const traceId = run?.traceId ?? hashHex(`${ctx.sessionKey ?? "unknown"}:compaction:${startMs}`, 32);
+		const model = ctx.sessionKey ? this.modelBySession.get(ctx.sessionKey) : void 0;
+		const span = {
+			spanId: hashHex(`${traceId}:compaction:${startMs}`, 16),
+			traceId,
+			parentSpanId: run?.root.spanId ?? "",
 			name: "compaction",
-			startMs: Date.now(),
+			kind: KIND_INTERNAL,
+			startMs,
 			endMs: void 0,
 			attrs: {
-				...latitudeAttrs(ctx),
-				...sessionAttrs(ctx),
-				"openclaw.run.id": runId,
+				"gen_ai.operation.name": "chat",
+				"gen_ai.provider.name": model?.provider,
+				"gen_ai.system": model?.provider,
+				"gen_ai.request.model": model?.model,
+				"openclaw.usage.state": "unreported",
 				"openclaw.compaction.message_count.before": evt.messageCount,
+				"openclaw.compaction.compacting_count": evt.compactingCount,
+				"openclaw.compaction.token_count.before": evt.tokenCount,
 				"openclaw.compaction.session_file": evt.sessionFile,
-				"before_compaction.messages:gated": evt.messages ? normalizeMessages(evt.messages) : void 0
+				"openclaw.session.key": ctx.sessionKey,
+				"gen_ai.input.messages:gated": evt.messages ? normalizeMessages(evt.messages) : void 0
 			}
 		};
+		if (run) {
+			run.openCompaction = span;
+			return;
+		}
+		remember(this.standaloneCompactions, ctx.sessionKey ?? "", span, STANDALONE_COMPACTION_MAX);
 	}
 	onAfterCompaction(evt, ctx) {
-		const runId = ctx.runId;
-		if (!runId) return;
-		const run = this.runs.get(runId);
-		if (!run?.openCompaction) return;
-		const span = run.openCompaction;
-		span.endMs = Date.now();
+		const run = this.openRunForSession(ctx.sessionKey);
+		const span = run?.openCompaction ?? this.standaloneCompactions.get(ctx.sessionKey ?? "");
+		if (!span) return;
+		const endMs = this.now();
+		span.endMs = endMs;
 		span.outcome = "ok";
+		const sessionId = ctx.sessionId ?? run?.ctx.sessionId ?? (ctx.sessionKey ? this.sessionIds.get(ctx.sessionKey) : void 0);
+		const agentId = ctx.agentId ?? run?.ctx.agentId ?? agentIdFromSessionKey(ctx.sessionKey);
+		const workspaceDir = run?.ctx.workspaceDir ?? (ctx.sessionKey ? this.workspaceBySession.get(ctx.sessionKey) : void 0);
+		const record = this.latestCompaction(sessionId, agentId, workspaceDir);
 		Object.assign(span.attrs, {
 			"openclaw.compaction.message_count.after": evt.messageCount,
 			"openclaw.compaction.compacted_count": evt.compactedCount,
-			"openclaw.compaction.token_count": evt.tokenCount
+			"openclaw.compaction.token_count.after": evt.tokenCount ?? record?.tokensAfter,
+			"openclaw.compaction.token_count.before": span.attrs["openclaw.compaction.token_count.before"] ?? record?.tokensBefore,
+			"openclaw.compaction.previous_session_id": evt.previousSessionId,
+			"openclaw.compaction.summary_chars": record?.summary.length,
+			"gen_ai.output.messages:gated": record ? [{
+				role: "assistant",
+				parts: [{
+					type: "text",
+					content: record.summary
+				}]
+			}] : void 0
 		});
-		run.openCompaction = void 0;
-		run.closed.push(span);
+		if (run?.openCompaction === span) {
+			run.openCompaction = void 0;
+			run.closed.push(span);
+			return;
+		}
+		this.standaloneCompactions.delete(ctx.sessionKey ?? "");
+		const enrichment = deriveEnrichment({
+			ctx: {
+				agentId,
+				sessionKey: ctx.sessionKey,
+				sessionId,
+				workspaceDir
+			},
+			subagentIds: [],
+			pluginVersion: this.pluginVersion
+		}, {
+			tags: this.operatorTags,
+			metadata: this.operatorMetadata
+		});
+		const compacted = evt.compactedCount ?? 0;
+		const root = {
+			spanId: hashHex(`${span.traceId}:compaction-root`, 16),
+			traceId: span.traceId,
+			parentSpanId: "",
+			name: "compaction",
+			kind: KIND_INTERNAL,
+			startMs: span.startMs,
+			endMs,
+			outcome: "ok",
+			attrs: {
+				"gen_ai.operation.name": "invoke_agent",
+				"interaction.kind": "compaction",
+				"interaction.duration_ms": endMs - span.startMs,
+				"user_prompt:gated": `[compaction] ${compacted} messages summarized, ${evt.messageCount} kept`,
+				"gen_ai.output.messages:gated": span.attrs["gen_ai.output.messages:gated"],
+				"openclaw.outcome": "completed",
+				"openclaw.llm_calls": 1,
+				"openclaw.tool_calls": 0
+			}
+		};
+		span.parentSpanId = root.spanId;
+		const common = {
+			...sessionAttrs(sessionId),
+			"openclaw.session.id": sessionId,
+			"openclaw.session.key": ctx.sessionKey,
+			"openclaw.agent.id": agentId,
+			"gen_ai.agent.name": agentId,
+			"openclaw.workspace.dir": workspaceDir,
+			"latitude.tags": enrichment.tags,
+			"latitude.metadata": enrichment.metadata
+		};
+		for (const target of [root, span]) for (const [k, v] of Object.entries(common)) if (target.attrs[k] === void 0) target.attrs[k] = v;
+		this.emit({
+			runId: `compaction:${span.spanId}`,
+			spans: [root, span]
+		});
+	}
+	latestCompaction(sessionId, agentId, workspaceDir) {
+		const stateDir = this.stateDir ?? stateDirFromWorkspace(workspaceDir);
+		if (!sessionId || !agentId || !stateDir) return void 0;
+		return readLatestCompaction(agentDatabasePath(stateDir, agentId), sessionId, this.readTranscriptRows) ?? readLatestCompactionFromFile(sessionTranscriptPath(stateDir, agentId, sessionId), this.readTranscript);
+	}
+	onSessionStart(evt, _ctx) {
+		if (evt.sessionKey) {
+			remember(this.sessionIds, evt.sessionKey, evt.sessionId, SESSION_INDEX_MAX);
+			this.memorySnapshotSessions.delete(evt.sessionKey);
+		}
+	}
+	onSessionEnd(sessionKey, sessionId) {
+		if (sessionId) this.sessionHistory.forget(sessionId);
+		if (!sessionKey) return;
+		this.memorySnapshotSessions.delete(sessionKey);
+		this.senders.delete(sessionKey);
+	}
+	onMessageReceived(evt, ctx) {
+		const sessionKey = evt.sessionKey ?? ctx.sessionKey;
+		const id = evt.senderId ?? evt.metadata?.senderId ?? ctx.senderId;
+		if (!sessionKey || !id) return;
+		let bySender = this.senders.get(sessionKey);
+		if (!bySender) {
+			bySender = /* @__PURE__ */ new Map();
+			this.senders.set(sessionKey, bySender);
+		}
+		const sender = {
+			id,
+			name: evt.metadata?.senderName,
+			username: evt.metadata?.senderUsername
+		};
+		bySender.set(id, sender);
+		if (sender.name || sender.username) this.sendersById.set(id, sender);
 	}
 	/**
-	* Open a `subagent` span on the parent run AND register the cross-run link
-	* so the child's `before_agent_start` can find us.
+	* Streamed agent events: `lifecycle` start gives the run's true start before
+	* any hook fires, and the first `assistant` / `thinking` delta after a model
+	* call started is its time to first token, which the Codex harness reports
+	* nowhere else.
 	*/
+	onAgentEvent(evt) {
+		if (!evt.runId || !evt.stream) return;
+		if (evt.stream === "lifecycle") {
+			if (evt.data?.phase !== "start") return;
+			const startedAt = typeof evt.data.startedAt === "number" ? evt.data.startedAt : evt.ts;
+			const run = this.ensureRun(evt.runId, {
+				runId: evt.runId,
+				sessionKey: evt.sessionKey,
+				sessionId: evt.sessionId,
+				agentId: evt.agentId
+			});
+			if (run && startedAt !== void 0 && startedAt < run.startedAt) {
+				run.startedAt = startedAt;
+				run.root.startMs = startedAt;
+			}
+			return;
+		}
+		if (evt.stream !== "assistant" && evt.stream !== "thinking") return;
+		const delta = evt.data?.delta;
+		if (typeof delta !== "string" || delta.length === 0) return;
+		const run = this.runs.get(evt.runId);
+		if (!run) return;
+		const ts = evt.ts ?? this.now();
+		if (run.deltas.length < MAX_DELTAS) run.deltas.push(ts);
+		if (evt.stream === "thinking" && run.thinkingChars < MAX_THINKING_CHARS) {
+			run.thinking.push({
+				ts,
+				text: delta
+			});
+			run.thinkingChars += delta.length;
+		}
+	}
+	onCronChanged(evt) {
+		const agentId = evt.agentId ?? evt.job?.agentId ?? "main";
+		const job = {
+			id: evt.jobId,
+			name: evt.job?.name
+		};
+		if (evt.action === "started" || evt.action === "added" || evt.action === "updated") this.cronStarted.set(`job:${evt.jobId}`, job);
+		if (evt.action === "started") {
+			this.cronStarted.set(agentId, job);
+			if (evt.sessionKey) this.cronStarted.set(`session:${evt.sessionKey}`, job);
+			return;
+		}
+		if (evt.action === "finished") {
+			if (this.cronStarted.get(agentId)?.id === evt.jobId) this.cronStarted.delete(agentId);
+			if (evt.sessionKey) this.cronStarted.delete(`session:${evt.sessionKey}`);
+		}
+		if (evt.action === "removed") this.cronStarted.delete(`job:${evt.jobId}`);
+	}
 	onSubagentSpawned(evt, ctx) {
-		const parentRunId = ctx.runId;
-		if (!parentRunId) return;
-		const parent = this.runs.get(parentRunId);
-		if (!parent) return;
+		const parent = this.openRunForSession(ctx.requesterSessionKey);
+		const childRunId = evt.runId ?? ctx.runId;
+		if (!childRunId) return;
+		this.evictStale();
+		const traceId = parent?.traceId ?? hashHex(childRunId, 32);
+		const parentSpanId = parent ? parent.lastSpawnToolSpanId ?? parent.root.spanId : "";
+		const agentName = evt.label ?? evt.agentId;
 		const span = {
-			spanId: hashHex(`${parent.agent.traceId}:subagent:${evt.runId}`, 16),
-			traceId: parent.agent.traceId,
-			parentSpanId: parent.agent.spanId,
+			spanId: hashHex(`${childRunId}:subagent`, 16),
+			traceId,
+			parentSpanId,
 			name: "subagent",
-			startMs: Date.now(),
+			kind: KIND_INTERNAL,
+			startMs: this.now(),
 			endMs: void 0,
 			attrs: {
-				...latitudeAttrs(ctx),
-				...sessionAttrs(ctx),
-				"openclaw.parent.run.id": parentRunId,
-				"openclaw.run.id": evt.runId,
+				...parent ? this.commonAttrs(parent) : {},
+				"gen_ai.agent.name": agentName,
+				"subagent.name": agentName,
+				"subagent.type": evt.agentId,
+				"subagent.id": `${evt.agentId}:${childRunId}`,
+				"openclaw.run.id": childRunId,
+				"openclaw.parent.run.id": parent?.runId,
 				"openclaw.subagent.child_session_key": evt.childSessionKey,
 				"openclaw.subagent.agent_id": evt.agentId,
 				"openclaw.subagent.label": evt.label,
 				"openclaw.subagent.mode": evt.mode,
 				"openclaw.subagent.thread_requested": evt.threadRequested,
+				"openclaw.subagent.resolved_model": evt.resolvedModel,
+				"openclaw.subagent.resolved_provider": evt.resolvedProvider,
 				"openclaw.subagent.requester.channel": evt.requester?.channel,
 				"openclaw.subagent.requester.account_id": evt.requester?.accountId,
 				"openclaw.subagent.requester.to": evt.requester?.to,
-				"openclaw.subagent.requester.thread_id": typeof evt.requester?.threadId === "string" || typeof evt.requester?.threadId === "number" ? String(evt.requester.threadId) : void 0
+				"openclaw.subagent.requester.thread_id": evt.requester?.threadId !== void 0 ? String(evt.requester.threadId) : void 0,
+				...sessionAttrs(parent?.ctx.sessionId)
 			}
 		};
-		parent.childSubagentSpans.set(evt.runId, span);
-		this.evictStaleSubagentLinks();
-		this.subagentLinks.set(evt.runId, {
-			traceId: parent.agent.traceId,
-			subagentSpanId: span.spanId,
-			createdAt: Date.now()
+		if (parent) {
+			parent.subagentIds.push(evt.agentId);
+			parent.lastSpawnToolSpanId = void 0;
+		}
+		this.pendingSubagents.set(childRunId, {
+			span,
+			parentRunId: parent?.runId ?? "",
+			createdAt: this.now()
 		});
+		this.subagentLinks.set(childRunId, {
+			traceId,
+			parentSpanId: span.spanId,
+			parentRunId: parent?.runId ?? "",
+			sessionId: parent?.ctx.sessionId,
+			agentName,
+			createdAt: this.now()
+		});
+		const child = this.runs.get(childRunId);
+		if (child) this.applyLink(child);
 	}
 	onSubagentEnded(evt, ctx) {
-		const parentRunId = ctx.runId;
-		if (!parentRunId) return;
-		const parent = this.runs.get(parentRunId);
-		if (!parent) return;
-		const childRunId = evt.runId;
+		const childRunId = evt.runId ?? ctx.runId;
 		if (!childRunId) return;
-		const span = parent.childSubagentSpans.get(childRunId);
-		if (!span) return;
-		span.endMs = Date.now();
-		span.outcome = evt.outcome === "error" || Boolean(evt.error) ? "error" : "ok";
+		const pending = this.pendingSubagents.get(childRunId);
+		if (!pending) return;
+		const span = pending.span;
+		span.endMs = evt.endedAt ?? this.now();
+		const isError = evt.outcome === "error" || evt.outcome === "timeout" || Boolean(evt.error);
+		span.outcome = isError ? "error" : "ok";
 		span.errorMessage = evt.error;
 		Object.assign(span.attrs, {
 			"openclaw.subagent.target_session_key": evt.targetSessionKey,
@@ -753,93 +1759,512 @@ var SpanBuilder = class {
 			"openclaw.subagent.reason": evt.reason,
 			"openclaw.subagent.outcome": evt.outcome,
 			"openclaw.subagent.send_farewell": evt.sendFarewell,
-			"openclaw.subagent.account_id": evt.accountId
+			"openclaw.subagent.account_id": evt.accountId,
+			"error.type": isError ? evt.outcome ?? "error" : void 0,
+			"error.message:gated": evt.error
 		});
-		parent.childSubagentSpans.delete(childRunId);
-		parent.closed.push(span);
+		this.pendingSubagents.delete(childRunId);
+		this.emitSubagentSpan(span, pending.parentRunId);
+	}
+	ensureRun(runId, ctx) {
+		const existing = this.runs.get(runId);
+		if (existing) {
+			this.mergeCtx(existing, ctx);
+			return existing;
+		}
+		this.evictStale();
+		const startedAt = this.now();
+		const link = this.subagentLinks.get(runId);
+		const traceId = link?.traceId ?? hashHex(runId, 32);
+		const root = {
+			spanId: hashHex(`${runId}:interaction`, 16),
+			traceId,
+			parentSpanId: link?.parentSpanId ?? "",
+			name: "interaction",
+			kind: KIND_INTERNAL,
+			startMs: startedAt,
+			endMs: void 0,
+			attrs: {
+				"gen_ai.operation.name": "invoke_agent",
+				"openclaw.run.id": runId
+			}
+		};
+		const run = {
+			runId,
+			ctx: {
+				...ctx,
+				runId
+			},
+			traceId,
+			root,
+			startedAt,
+			history: [],
+			inputMessages: [],
+			inheritedHistory: [],
+			historySource: "none",
+			deltas: [],
+			thinking: [],
+			thinkingChars: 0,
+			prompt: void 0,
+			systemPrompt: void 0,
+			toolDefinitions: void 0,
+			llmCalls: [],
+			openModelCalls: /* @__PURE__ */ new Map(),
+			openToolCalls: /* @__PURE__ */ new Map(),
+			openCompaction: void 0,
+			closed: [],
+			lastSpawnToolSpanId: void 0,
+			subagentIds: [],
+			sender: void 0,
+			cron: void 0,
+			link,
+			aggregateUsage: {},
+			output: void 0,
+			endEvent: void 0,
+			outputSeen: false,
+			finalized: false,
+			cancelGrace: void 0
+		};
+		this.runs.set(runId, run);
+		this.indexSession(run);
+		this.resolveSender(run);
+		this.resolveCron(run);
+		return run;
+	}
+	mergeCtx(run, ctx) {
+		let changed = false;
+		for (const [key, value] of Object.entries(ctx)) {
+			if (value === void 0 || value === null || value === "") continue;
+			if (run.ctx[key] === void 0) {
+				run.ctx[key] = value;
+				changed = true;
+			}
+		}
+		if (!changed) return;
+		this.indexSession(run);
+		this.resolveSender(run);
+		this.resolveCron(run);
+	}
+	indexSession(run) {
+		const key = run.ctx.sessionKey;
+		if (!key) return;
+		if (run.ctx.sessionId) remember(this.sessionIds, key, run.ctx.sessionId, SESSION_INDEX_MAX);
+		const list = this.runsBySession.get(key) ?? [];
+		if (!list.includes(run.runId)) {
+			list.push(run.runId);
+			this.runsBySession.set(key, list);
+		}
+	}
+	resolveSender(run) {
+		if (run.sender?.name) return;
+		const id = run.ctx.senderId;
+		if (!id) return;
+		const cached = (run.ctx.sessionKey ? this.senders.get(run.ctx.sessionKey)?.get(id) : void 0) ?? this.sendersById.get(id);
+		if (cached?.name) {
+			run.sender = cached;
+			return;
+		}
+		const fromPrompt = senderFromPrompt(run.prompt);
+		run.sender = fromPrompt && fromPrompt.id === id ? fromPrompt : cached ?? { id };
+		if (run.sender.name) this.sendersById.set(id, run.sender);
+	}
+	resolveCron(run) {
+		if (run.cron?.name || run.ctx.trigger !== "cron") return;
+		const fromKey = cronJobFromSessionKey(run.ctx.sessionKey);
+		const bySession = run.ctx.sessionKey ? this.cronStarted.get(`session:${run.ctx.sessionKey}`) : void 0;
+		const job = fromKey ? this.cronStarted.get(`job:${fromKey}`) ?? { id: fromKey } : bySession ?? this.cronStarted.get(run.ctx.agentId ?? "main");
+		if (!job) return;
+		run.cron = job.name ? job : {
+			id: job.id,
+			name: cronNameFromPrompt(run.prompt, job.id)
+		};
 	}
 	/**
-	* Close out the run: finish the agent span, abandon any still-open
-	* model_calls / tool_calls / compactions, and return everything ready to
-	* emit. Removes the subagent link if this was a child run.
+	* History the harness withheld. The Codex harness passes an empty history
+	* and only this turn's transcript, so the session is rebuilt from the turns
+	* this process has seen, or from OpenClaw's transcript mirror on a cold start.
 	*/
-	onAgentEnd(evt, ctx) {
-		const runId = ctx.runId;
-		if (!runId) return void 0;
-		const run = this.runs.get(runId);
-		if (!run) {
-			this.subagentLinks.delete(runId);
+	inheritHistory(run, prompt) {
+		const sessionId = run.ctx.sessionId;
+		if (!sessionId) return;
+		const remembered = this.sessionHistory.get(sessionId);
+		if (remembered) {
+			run.inheritedHistory = [...remembered];
+			run.historySource = "memory";
 			return;
 		}
-		const now = Date.now();
-		run.agent.endMs = now;
-		run.agent.outcome = evt.success ? "ok" : "error";
-		run.agent.errorMessage = evt.error;
-		Object.assign(run.agent.attrs, {
-			"openclaw.duration_ms": evt.durationMs,
-			"openclaw.run.success": evt.success,
-			"openclaw.error.message:gated": evt.error,
-			"agent_end.messages:gated": normalizeMessages(evt.messages)
+		const stateDir = this.stateDir ?? stateDirFromWorkspace(run.ctx.workspaceDir);
+		const agentId = run.ctx.agentId;
+		if (!stateDir || !agentId) return;
+		const fromDatabase = readSessionTranscriptFromDatabase(agentDatabasePath(stateDir, agentId), sessionId, this.readTranscriptRows);
+		const stored = fromDatabase && fromDatabase.length > 0 ? {
+			messages: fromDatabase,
+			source: "sqlite"
+		} : {
+			messages: readSessionTranscript(sessionTranscriptPath(stateDir, agentId, sessionId), this.readTranscript),
+			source: "file"
+		};
+		if (!stored.messages) return;
+		run.inheritedHistory = withoutCurrentPrompt(stored.messages, prompt, run.startedAt);
+		run.historySource = stored.source;
+	}
+	openRunForSession(sessionKey) {
+		if (!sessionKey) return void 0;
+		const ids = this.runsBySession.get(sessionKey);
+		if (!ids) return void 0;
+		for (let i = ids.length - 1; i >= 0; i--) {
+			const run = this.runs.get(ids[i]);
+			if (run && !run.finalized) return run;
+		}
+	}
+	recordMemorySnapshot(run) {
+		if (!this.memoryEnabled) return;
+		const key = run.ctx.sessionKey ?? run.ctx.sessionId;
+		if (!key || this.memorySnapshotSessions.has(key)) return;
+		this.memorySnapshotSessions.add(key);
+		const snapshot = memorySnapshot(run.ctx.workspaceDir, run.ctx.agentId, this.readFile);
+		if (!snapshot) return;
+		const span = this.memorySpan(run, snapshot, void 0);
+		span.attrs["openclaw.memory.source"] = "session_snapshot";
+		run.closed.push(span);
+	}
+	memorySpan(run, memory, parent) {
+		const at = this.now();
+		return {
+			spanId: hashHex(`${run.runId}:memory:${memory.operation}:${memory.recordId ?? ""}:${at}:${run.closed.length}`, 16),
+			traceId: run.traceId,
+			parentSpanId: parent?.spanId ?? run.root.spanId,
+			name: memory.operation,
+			kind: KIND_CLIENT,
+			startMs: parent?.startMs ?? at,
+			endMs: parent?.endMs ?? at,
+			outcome: "ok",
+			attrs: {
+				"gen_ai.operation.name": memory.operation,
+				"gen_ai.provider.name": "openclaw",
+				"gen_ai.memory.store.id": memory.storeId,
+				"gen_ai.memory.record.id": memory.recordId,
+				"gen_ai.memory.record.count": memory.records.length,
+				"gen_ai.memory.query.text:gated": this.memoryContent ? memory.queryText : void 0,
+				"gen_ai.memory.records:gated": this.memoryContent && memory.records.length > 0 ? memory.records : void 0,
+				"openclaw.memory.body_unavailable": memory.bodyUnavailable ? true : void 0
+			}
+		};
+	}
+	applyLink(run) {
+		const link = this.subagentLinks.get(run.runId);
+		if (!link) return;
+		run.link = link;
+		run.traceId = link.traceId;
+		run.root.parentSpanId = link.parentSpanId;
+		for (const span of [
+			run.root,
+			...run.llmCalls,
+			...run.closed,
+			...run.openModelCalls.values(),
+			...run.openToolCalls.values()
+		]) span.traceId = link.traceId;
+		if (run.openCompaction) run.openCompaction.traceId = link.traceId;
+	}
+	finalize(run) {
+		if (run.finalized) return;
+		run.finalized = true;
+		run.cancelGrace?.();
+		run.cancelGrace = void 0;
+		this.applyLink(run);
+		const evt = run.endEvent;
+		const now = this.now();
+		const endMs = now;
+		const startMs = evt?.durationMs !== void 0 ? Math.min(run.startedAt, endMs - evt.durationMs) : run.startedAt;
+		run.root.startMs = startMs;
+		run.root.endMs = endMs;
+		const transcript = evt?.messages ?? [];
+		this.resolveSender(run);
+		this.resolveCron(run);
+		const assistants = this.attributeCalls(run, transcript, startMs);
+		this.applyTimeToFirstToken(run);
+		this.applyStreamedReasoning(run);
+		this.rememberHistory(run, transcript, startMs);
+		const lastAssistant = assistants[assistants.length - 1]?.message ?? run.output?.lastAssistant;
+		const outputMessage = lastAssistant !== void 0 ? normalizeMessage(lastAssistant) : void 0;
+		const success = evt ? evt.success : false;
+		run.root.outcome = success ? "ok" : "error";
+		run.root.errorMessage = evt?.error ?? (evt ? void 0 : "abandoned");
+		Object.assign(run.root.attrs, {
+			"user_prompt:gated": run.prompt,
+			"gen_ai.input.messages:gated": run.inputMessages.length > 0 ? run.inputMessages : void 0,
+			"gen_ai.output.messages:gated": outputMessage ? [{
+				...outputMessage,
+				role: "assistant"
+			}] : void 0,
+			"gen_ai.system_instructions:gated": run.systemPrompt ? systemInstructionsParts(run.systemPrompt) : void 0,
+			"openclaw.run.success": success,
+			"openclaw.duration_ms": evt?.durationMs,
+			"openclaw.outcome": evt ? success ? "completed" : "error" : "abandoned",
+			"error.type": success ? void 0 : evt ? "run_error" : "abandoned",
+			"error.message:gated": evt?.error,
+			"openclaw.llm_calls": run.llmCalls.length,
+			"openclaw.tool_calls": run.closed.filter((s) => s.name.startsWith("tool_call:")).length,
+			"interaction.kind": interactionKind(run),
+			"interaction.duration_ms": endMs - startMs,
+			"openclaw.history.source": run.historySource,
+			"openclaw.history.messages": run.inheritedHistory.length
 		});
-		for (const span of run.openModelCalls.values()) {
-			span.endMs = now;
-			span.outcome = "error";
-			span.attrs["openclaw.outcome"] = "abandoned";
-			run.closed.push(span);
+		for (const span of run.openModelCalls.values()) abandon(span, now);
+		for (const span of run.openToolCalls.values()) abandon(span, now);
+		if (run.openCompaction) abandon(run.openCompaction, now);
+		const spans = [
+			run.root,
+			...run.llmCalls,
+			...run.closed,
+			...run.openModelCalls.values(),
+			...run.openToolCalls.values()
+		];
+		if (run.openCompaction) spans.push(run.openCompaction);
+		const common = this.commonAttrs(run);
+		for (const span of spans) for (const [k, v] of Object.entries(common)) if (span.attrs[k] === void 0) span.attrs[k] = v;
+		this.runs.delete(run.runId);
+		this.subagentLinks.delete(run.runId);
+		const key = run.ctx.sessionKey;
+		if (key) {
+			const ids = (this.runsBySession.get(key) ?? []).filter((id) => id !== run.runId);
+			if (ids.length === 0) this.runsBySession.delete(key);
+			else this.runsBySession.set(key, ids);
 		}
-		for (const span of run.openToolCalls.values()) {
-			span.endMs = now;
-			span.outcome = "error";
-			span.attrs["openclaw.outcome"] = "abandoned";
-			run.closed.push(span);
+		this.log(`run ${run.runId}: ${spans.length} spans, ${run.llmCalls.length} calls, history=${run.historySource}:${run.inheritedHistory.length}, transcript=${transcript.length}, deltas=${run.deltas.length}, thinking=${run.thinkingChars}`);
+		this.emit({
+			runId: run.runId,
+			spans
+		});
+	}
+	/**
+	* Keep the session's conversation for the next turn of a harness that does
+	* not pass history. A harness that passes the whole session on `agent_end`
+	* replaces the remembered copy outright.
+	*/
+	rememberHistory(run, transcript, runStartMs) {
+		const sessionId = run.ctx.sessionId;
+		if (!sessionId || transcript.length === 0) return;
+		if (run.historySource === "harness") {
+			this.sessionHistory.replace(sessionId, normalizeMessages(transcript));
+			return;
 		}
-		if (run.openCompaction) {
-			run.openCompaction.endMs = now;
-			run.openCompaction.outcome = "error";
-			run.openCompaction.attrs["openclaw.outcome"] = "abandoned";
-			run.closed.push(run.openCompaction);
+		const turn = transcript.filter((m) => {
+			const ts = m.timestamp;
+			return typeof ts !== "number" || ts >= runStartMs - 5e3;
+		});
+		this.sessionHistory.append(sessionId, run.inheritedHistory, normalizeMessages(turn));
+	}
+	/** Reasoning streamed during a call's window, when its transcript message carries none. */
+	applyStreamedReasoning(run) {
+		if (run.thinking.length === 0) return;
+		for (const call of run.llmCalls) {
+			const endMs = call.endMs ?? call.startMs;
+			const text = run.thinking.filter((t) => t.ts > call.startMs - 1e3 && t.ts <= endMs + 1e3).map((t) => t.text).join("").trim();
+			if (text.length === 0) continue;
+			const message = call.attrs["gen_ai.output.messages:gated"]?.[0];
+			if (!message || message.parts.some((p) => p.type === "reasoning")) continue;
+			message.parts.unshift({
+				type: "reasoning",
+				content: text
+			});
+			call.attrs["openclaw.reasoning.source"] = "stream";
 		}
-		for (const span of run.childSubagentSpans.values()) {
-			span.endMs = now;
-			span.outcome = "error";
-			span.attrs["openclaw.subagent.outcome"] = "abandoned";
-			run.closed.push(span);
+	}
+	/** The first streamed delta inside a call's window, when the harness reported no TTFB. */
+	applyTimeToFirstToken(run) {
+		if (run.deltas.length === 0) return;
+		for (const call of run.llmCalls) {
+			if (call.attrs["gen_ai.server.time_to_first_token"] !== void 0) continue;
+			const endMs = call.endMs ?? call.startMs;
+			const first = run.deltas.find((ts) => ts > call.startMs && ts <= endMs + 1e3);
+			if (first === void 0) continue;
+			call.attrs["gen_ai.server.time_to_first_token"] = (first - call.startMs) * 1e6;
+			call.attrs["openclaw.ttft.source"] = "stream";
 		}
-		const spans = [run.agent, ...run.closed];
-		this.runs.delete(runId);
-		this.subagentLinks.delete(runId);
-		return {
-			runId,
-			spans
-		};
 	}
-	/** Drop a run without emitting — used on errors from the emit path. */
-	abandon(runId) {
-		this.runs.delete(runId);
-		this.subagentLinks.delete(runId);
+	/**
+	* Per-call usage, cost and output come from the transcript's assistant
+	* messages, each of which is one provider response. Calls and messages are
+	* both chronological, so a message is matched to the call whose window
+	* contains its timestamp, falling back to order when the counts line up.
+	* A harness that never fires the per-call hooks still leaves its responses
+	* in the transcript, so those become `llm_request` spans of their own.
+	*/
+	attributeCalls(run, transcript, runStartMs) {
+		const assistants = [];
+		transcript.forEach((m, index) => {
+			if (!isTranscriptAssistant(m)) return;
+			const ts = typeof m.timestamp === "number" ? m.timestamp : void 0;
+			if (ts !== void 0 && ts < runStartMs - 5e3) return;
+			assistants.push({
+				message: m,
+				index
+			});
+		});
+		if (run.llmCalls.length === 0) {
+			for (const [i, entry] of assistants.entries()) run.llmCalls.push(this.synthesizeCall(run, entry, i, transcript, runStartMs));
+			this.applyAggregateIfUnreported(run);
+			return assistants;
+		}
+		const unmatched = [...assistants];
+		let matchedAny = false;
+		for (const [callIndex, call] of run.llmCalls.entries()) {
+			const remainingCalls = run.llmCalls.length - callIndex;
+			let picked = unmatched.findIndex(({ message }) => {
+				const ts = message.timestamp;
+				return ts !== void 0 && ts >= call.startMs - 2e3 && ts <= (call.endMs ?? call.startMs) + 2e3;
+			});
+			if (picked < 0 && unmatched.length === remainingCalls) picked = 0;
+			if (picked < 0) continue;
+			const [entry] = unmatched.splice(picked, 1);
+			if (!entry) continue;
+			matchedAny = true;
+			this.enrichCall(call, entry.message, this.inputBefore(run, transcript, entry.index));
+		}
+		if (!matchedAny) {
+			const last = run.llmCalls[run.llmCalls.length - 1];
+			if (last) Object.assign(last.attrs, run.aggregateUsage, { "openclaw.usage.scope": "attempt" });
+		}
+		this.applyAggregateIfUnreported(run);
+		return assistants;
 	}
-	/** Test-only: how many cross-run subagent links we're holding. */
-	subagentLinkCount() {
-		return this.subagentLinks.size;
+	/** Everything the model saw before a given transcript index, including history the harness withheld. */
+	inputBefore(run, transcript, index) {
+		return [...run.inheritedHistory, ...transcript.slice(0, index)];
 	}
 	/**
-	* Drop any subagent links whose child run never reached `agent_end`. Called
-	* before every `subagent_spawned` insert so the map stays bounded even when
-	* children crash mid-spawn or the plugin reloads.
-	*
-	* Two passes: TTL eviction (anything older than `SUBAGENT_LINK_TTL_MS`),
-	* then a hard size cap (when we're past `SUBAGENT_LINK_MAX`, drop the
-	* oldest until we're under).
+	* A harness that reports usage only on the turn's final message leaves a
+	* turn ending in a tool call with no usage at all; the attempt aggregate
+	* from `llm_output` then goes on the last call.
 	*/
-	evictStaleSubagentLinks() {
-		const now = Date.now();
-		for (const [runId, link] of this.subagentLinks) if (now - link.createdAt > SUBAGENT_LINK_TTL_MS) this.subagentLinks.delete(runId);
-		if (this.subagentLinks.size <= SUBAGENT_LINK_MAX) return;
-		const sorted = Array.from(this.subagentLinks.entries()).sort((a, b) => a[1].createdAt - b[1].createdAt);
-		const toRemove = this.subagentLinks.size - SUBAGENT_LINK_MAX;
-		for (let i = 0; i < toRemove; i++) {
-			const entry = sorted[i];
-			if (entry) this.subagentLinks.delete(entry[0]);
+	applyAggregateIfUnreported(run) {
+		const last = run.llmCalls[run.llmCalls.length - 1];
+		if (!last || run.aggregateUsage["gen_ai.usage.total_tokens"] === void 0) return;
+		if (run.llmCalls.some((call) => Number(call.attrs["gen_ai.usage.total_tokens"] ?? 0) > 0)) return;
+		Object.assign(last.attrs, run.aggregateUsage, { "openclaw.usage.scope": "attempt" });
+	}
+	synthesizeCall(run, entry, index, transcript, runStartMs) {
+		const endMs = entry.message.timestamp ?? run.startedAt;
+		const previous = transcript[entry.index - 1];
+		const previousTs = typeof previous?.timestamp === "number" ? previous.timestamp : void 0;
+		const startMs = previousTs !== void 0 && previousTs <= endMs ? Math.max(previousTs, runStartMs) : Math.min(runStartMs, endMs);
+		const span = {
+			spanId: hashHex(`${run.runId}:llm_request:transcript:${index}`, 16),
+			traceId: run.traceId,
+			parentSpanId: run.root.spanId,
+			name: "llm_request",
+			kind: KIND_INTERNAL,
+			startMs,
+			endMs,
+			outcome: "ok",
+			attrs: {
+				"gen_ai.operation.name": "chat",
+				"gen_ai.provider.name": entry.message.provider ?? run.root.attrs["openclaw.provider"],
+				"gen_ai.system": entry.message.provider ?? run.root.attrs["openclaw.provider"],
+				"gen_ai.request.model": entry.message.model ?? run.root.attrs["gen_ai.request.model"],
+				"llm_request.call_index": index,
+				"openclaw.call.source": "transcript",
+				"gen_ai.system_instructions:gated": run.systemPrompt ? systemInstructionsParts(run.systemPrompt) : void 0,
+				"gen_ai.tool.definitions:gated": run.toolDefinitions
+			}
+		};
+		this.enrichCall(span, entry.message, this.inputBefore(run, transcript, entry.index));
+		return span;
+	}
+	enrichCall(call, message, before) {
+		const output = normalizeMessage(message);
+		const usage = message.usage;
+		const reason = finishReason(message.stopReason);
+		Object.assign(call.attrs, {
+			"gen_ai.input.messages:gated": before.length > 0 ? normalizeMessages(before) : call.attrs["gen_ai.input.messages:gated"],
+			"gen_ai.output.messages:gated": output ? [{
+				...output,
+				role: "assistant"
+			}] : void 0,
+			"gen_ai.response.model": message.responseModel ?? message.model,
+			"gen_ai.response.id": message.responseId,
+			"gen_ai.response.finish_reasons": reason ? [reason] : void 0,
+			"openclaw.stop_reason": message.stopReason,
+			...usageAttrsFromTranscript(usage)
+		});
+		if (message.stopReason === "error" && message.errorMessage) {
+			call.outcome = "error";
+			call.errorMessage = message.errorMessage;
+			call.attrs["error.type"] = call.attrs["error.type"] ?? "provider_error";
+			call.attrs["error.message:gated"] = message.errorMessage;
+		}
+	}
+	commonAttrs(run) {
+		const sessionId = run.link?.sessionId ?? run.ctx.sessionId;
+		const enrichment = deriveEnrichment({
+			ctx: run.ctx,
+			sender: run.sender,
+			cron: run.cron,
+			subagentIds: run.subagentIds,
+			pluginVersion: this.pluginVersion
+		}, {
+			tags: this.operatorTags,
+			metadata: this.operatorMetadata
+		});
+		return {
+			...sessionAttrs(sessionId),
+			"openclaw.session.id": run.ctx.sessionId,
+			"openclaw.session.key": run.ctx.sessionKey,
+			"openclaw.run.id": run.runId,
+			"openclaw.agent.id": run.ctx.agentId,
+			"gen_ai.agent.name": run.link?.agentName ?? run.ctx.agentId,
+			"openclaw.workspace.dir": run.ctx.workspaceDir,
+			"openclaw.channel": run.ctx.channel,
+			"openclaw.channel.id": run.ctx.channelId,
+			"openclaw.message.provider": run.ctx.messageProvider,
+			"openclaw.trigger": run.ctx.trigger,
+			"openclaw.cron.job.id": run.cron?.id,
+			"openclaw.parent.run.id": run.link?.parentRunId || void 0,
+			"user.id": run.sender?.id,
+			"latitude.tags": enrichment.tags,
+			"latitude.metadata": enrichment.metadata
+		};
+	}
+	emitSubagentSpan(span, parentRunId) {
+		const parent = this.runs.get(parentRunId);
+		if (parent && !parent.finalized) {
+			parent.closed.push(span);
+			return;
+		}
+		if (span.attrs["latitude.tags"] === void 0) {
+			const enrichment = deriveEnrichment({
+				ctx: {},
+				subagentIds: [],
+				pluginVersion: this.pluginVersion
+			}, {
+				tags: this.operatorTags,
+				metadata: this.operatorMetadata
+			});
+			span.attrs["latitude.tags"] = enrichment.tags;
+			span.attrs["latitude.metadata"] = enrichment.metadata;
+		}
+		this.emit({
+			runId: `subagent:${span.spanId}`,
+			spans: [span]
+		});
+	}
+	evictStale() {
+		const now = this.now();
+		for (const [runId, link] of this.subagentLinks) if (now - link.createdAt > LINK_TTL_MS) this.subagentLinks.delete(runId);
+		if (this.subagentLinks.size > LINK_MAX) {
+			const sorted = Array.from(this.subagentLinks.entries()).sort((a, b) => a[1].createdAt - b[1].createdAt);
+			for (const [runId] of sorted.slice(0, this.subagentLinks.size - LINK_MAX)) this.subagentLinks.delete(runId);
+		}
+		for (const [runId, pending] of this.pendingSubagents) if (now - pending.createdAt > LINK_TTL_MS) {
+			abandon(pending.span, now);
+			pending.span.attrs["openclaw.subagent.outcome"] = "abandoned";
+			this.pendingSubagents.delete(runId);
+			this.emitSubagentSpan(pending.span, pending.parentRunId);
+		}
+		for (const run of Array.from(this.runs.values())) if (now - run.startedAt > RUN_TTL_MS) {
+			this.log(`run ${run.runId} never ended; exporting as abandoned`);
+			this.finalize(run);
 		}
 	}
 	findOpenToolCallByName(run, toolName) {
@@ -847,119 +2272,202 @@ var SpanBuilder = class {
 		const entries = Array.from(run.openToolCalls.entries());
 		for (let i = entries.length - 1; i >= 0; i--) {
 			const entry = entries[i];
-			if (!entry) continue;
-			const [id, span] = entry;
-			if (span.name === target) return id;
+			if (entry && entry[1].name === target) return entry[0];
 		}
 	}
 };
-function flattenCtx(ctx) {
+function toolCtxToAgentCtx(ctx, runId) {
 	return {
-		"openclaw.run.id": ctx.runId,
-		"openclaw.session.id": ctx.sessionId,
-		"openclaw.session.key": ctx.sessionKey,
-		"openclaw.agent.id": ctx.agentId,
-		"openclaw.agent.name": ctx.agentId,
-		"openclaw.workspace.dir": ctx.workspaceDir,
-		"openclaw.message.provider": ctx.messageProvider,
-		"openclaw.trigger": ctx.trigger,
-		"openclaw.channel.id": ctx.channelId,
-		"openclaw.cron.job.id": ctx.jobId,
-		"openclaw.model.provider.id": ctx.modelProviderId,
-		"openclaw.model.id": ctx.modelId
+		runId,
+		agentId: ctx.agentId,
+		sessionKey: ctx.sessionKey,
+		sessionId: ctx.sessionId,
+		channelId: ctx.channelId,
+		channel: ctx.requester?.channel,
+		accountId: ctx.requester?.accountId,
+		senderId: ctx.requester?.senderId
 	};
 }
-/**
-* Mirror OpenClaw's session id onto the OTEL-standard keys Latitude's
-* resolver looks for. `gen_ai.session.id` and `session.id` are both in
-* `sessionIdCandidates` (domain/spans/src/otlp/resolvers/identity.ts), so
-* traces can be grouped by session in the Latitude UI without an
-* openclaw-specific code path. Emitted on every span, not just `agent`,
-* so child spans (model_call / tool_call / etc.) inherit the same grouping.
-*/
-function sessionAttrs(ctx) {
-	if (!ctx.sessionId) return {};
-	return {
-		"session.id": ctx.sessionId,
-		"gen_ai.session.id": ctx.sessionId
-	};
+function interactionKind(run) {
+	if (run.link) return "subagent";
+	if (run.runId.startsWith("announce:")) return "announce";
+	if (run.ctx.trigger === "cron") return "cron";
+	return run.ctx.trigger ?? "user";
 }
-/**
-* Build `latitude.tags` and `latitude.metadata` attrs from the hook context.
-* The OTLP encoder JSON-stringifies arrays/objects, which is the encoding
-* Latitude's resolver expects:
-*
-*   - `latitude.tags` is a JSON-encoded string array (`fromJsonStringArray`
-*     in domain/spans/src/otlp/resolvers/enrichment.ts).
-*   - `latitude.metadata` is a JSON-encoded string object (`fromJsonString`).
-*
-* Tags = the agent id, the channel id, and the trigger. When trigger is
-* `cron`, the tag becomes `cron:<jobId>` so dashboards can pivot on the
-* specific cron job. Each tag is conditionally included so absent ctx
-* fields don't produce empty entries.
-*
-* Metadata = every ctx field that's set, namespaced under `openclaw.*` so
-* it can't collide with metadata keys other plugins might emit.
-*/
-function latitudeAttrs(ctx) {
-	const tags = [];
-	if (ctx.agentId) tags.push(ctx.agentId);
-	if (ctx.channelId) tags.push(ctx.channelId);
-	if (ctx.trigger) tags.push(ctx.trigger === "cron" && ctx.jobId ? `cron:${ctx.jobId}` : ctx.trigger);
-	const metadata = {};
-	if (ctx.runId) metadata["openclaw.run.id"] = ctx.runId;
-	if (ctx.sessionId) metadata["openclaw.session.id"] = ctx.sessionId;
-	if (ctx.sessionKey) metadata["openclaw.session.key"] = ctx.sessionKey;
-	if (ctx.agentId) metadata["openclaw.agent.id"] = ctx.agentId;
-	if (ctx.workspaceDir) metadata["openclaw.workspace.dir"] = ctx.workspaceDir;
-	if (ctx.channelId) metadata["openclaw.channel.id"] = ctx.channelId;
-	if (ctx.messageProvider) metadata["openclaw.message.provider"] = ctx.messageProvider;
-	if (ctx.trigger) metadata["openclaw.trigger"] = ctx.trigger;
-	if (ctx.jobId) metadata["openclaw.cron.job.id"] = ctx.jobId;
-	if (ctx.modelProviderId) metadata["openclaw.model.provider.id"] = ctx.modelProviderId;
-	if (ctx.modelId) metadata["openclaw.model.id"] = ctx.modelId;
-	return {
-		"latitude.tags": tags.length > 0 ? tags : void 0,
-		"latitude.metadata": Object.keys(metadata).length > 0 ? metadata : void 0
-	};
+/** Cron prompts open with `[cron:<jobId> <job name>]`, the only place the name reaches a run. */
+function cronNameFromPrompt(prompt, jobId) {
+	if (!prompt) return void 0;
+	return new RegExp(`^\\[cron:${jobId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} ([^\\]]+)\\]`).exec(prompt)?.[1]?.trim() || void 0;
 }
-function usageAttrs(usage) {
-	if (!usage) return {};
+/** Session keys are `agent:<agentId>:<rest>`. */
+function agentIdFromSessionKey(sessionKey) {
+	return (sessionKey ? /^agent:([^:]+):/.exec(sessionKey) : null)?.[1];
+}
+function sessionAttrs(sessionId) {
+	if (!sessionId) return {};
 	return {
-		"gen_ai.usage.input_tokens": usage.input,
-		"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,
-		"gen_ai.usage.total_tokens": usage.total
+		"session.id": sessionId,
+		"gen_ai.session.id": sessionId
 	};
 }
+function abandon(span, now) {
+	span.endMs = now;
+	span.outcome = "error";
+	span.attrs["openclaw.outcome"] = "abandoned";
+	span.attrs["error.type"] = "abandoned";
+}
+/** Insertion-ordered cache: re-setting a key moves it to the back, and the oldest keys go once `max` is exceeded. */
+function remember(map, key, value, max) {
+	map.delete(key);
+	map.set(key, value);
+	for (const oldest of map.keys()) {
+		if (map.size <= max) break;
+		map.delete(oldest);
+	}
+}
 function hashHex(input, length) {
 	return createHash("sha256").update(input).digest("hex").slice(0, length);
 }
 //#endregion
-//#region src/plugin.ts
+//#region src/transport.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+const DEFAULT_MAX_ATTEMPTS = 3;
+const RETRY_BASE_MS = 500;
+const RETRY_AFTER_MAX_MS = 3e4;
 /**
-* Register the Latitude plugin against an OpenClaw plugin API. OpenClaw calls
-* this once at plugin activation; we wire up the granular paired hooks
-* (model_call_started/_ended, before_/after_tool_call, before_/after_compaction,
-* subagent_spawned/_ended, before_agent_start/agent_end) plus the
-* data-only feeds (llm_input/llm_output) that enrich the agent span.
-*
-* Every typed hook on OpenClaw's side fires fire-and-forget for non-modifying
-* hooks; before_tool_call is a `runModifyingHook` where returning anything
-* other than undefined blocks the tool call. Our handler returns nothing —
-* keep it that way.
+* Ships OTLP requests sequentially with bounded retries. Every span is sent
+* exactly once on success: Latitude's trace and session rollups add per
+* insert, so a duplicate would inflate counts; a `4xx` other than `429` is
+* therefore final, while `429`, `5xx` and network errors retry with backoff.
 */
+var Transport = class {
+	url;
+	opts;
+	chain = Promise.resolve();
+	pending = 0;
+	constructor(opts) {
+		this.opts = opts;
+		this.url = `${withoutTrailingSlashes(opts.baseUrl)}/v1/traces`;
+	}
+	enqueue(payload) {
+		this.pending++;
+		this.chain = this.chain.then(() => this.send(payload)).catch((err) => this.opts.logger.warn(`export failed: ${String(err)}`)).finally(() => {
+			this.pending--;
+		});
+	}
+	/** Resolves when everything queued so far has been sent or given up on, or the budget elapses. */
+	async flush(budgetMs) {
+		if (this.pending === 0) return;
+		await Promise.race([this.chain, sleep(budgetMs)]);
+	}
+	async send(payload) {
+		const body = JSON.stringify(payload);
+		const spanCount = payload.resourceSpans.reduce((n, rs) => n + rs.scopeSpans.reduce((m, ss) => m + ss.spans.length, 0), 0);
+		const maxAttempts = this.opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+		const doFetch = this.opts.fetchImpl ?? fetch;
+		const wait = this.opts.sleep ?? sleep;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+			try {
+				const res = await doFetch(this.url, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Bearer ${this.opts.apiKey}`,
+						"X-Latitude-Project": this.opts.project
+					},
+					body,
+					signal: controller.signal
+				});
+				if (res.ok) {
+					this.opts.logger.debug(`exported ${spanCount} spans (${body.length} bytes) HTTP ${res.status}`);
+					return;
+				}
+				const text = await res.text().catch(() => "");
+				if (!(res.status === 429 || res.status >= 500) || attempt === maxAttempts) {
+					this.opts.logger.warn(`ingest HTTP ${res.status} (final): ${text.slice(0, 300)}`);
+					return;
+				}
+				const retryAfter = Number(res.headers.get("retry-after"));
+				await wait((Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter * 1e3, RETRY_AFTER_MAX_MS) : 0) || backoff(attempt));
+			} catch (err) {
+				if (attempt === maxAttempts) {
+					this.opts.logger.warn(`ingest unreachable after ${attempt} attempts: ${String(err)}`);
+					return;
+				}
+				await wait(backoff(attempt));
+			} finally {
+				clearTimeout(timer);
+			}
+		}
+	}
+};
+function backoff(attempt) {
+	return RETRY_BASE_MS * 2 ** (attempt - 1) + Math.random() * RETRY_BASE_MS;
+}
+function withoutTrailingSlashes(url) {
+	let end = url.length;
+	while (end > 0 && url[end - 1] === "/") end--;
+	return url.slice(0, end);
+}
+function sleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref?.();
+	});
+}
+//#endregion
+//#region src/plugin.ts
+const STOP_FLUSH_BUDGET_MS = 4e3;
+const PLUGIN_ID = "@latitude-data/openclaw-telemetry";
 function registerLatitudePlugin(api, opts = {}) {
 	const config = opts.config ?? loadConfig(api.pluginConfig);
-	const logger = opts.logger ?? createLogger(config.debug);
+	const logger = opts.logger ?? createLogger(config.debug, api.logger);
 	if (!config.enabled) {
-		if (config.apiKey === "") logger.debug("disabled: apiKey is empty (set plugins.entries[id].config.apiKey)");
-		if (config.project === "") logger.debug("disabled: project is empty (set plugins.entries[id].config.project)");
+		if (config.apiKey === "") logger.warn("disabled: apiKey is empty (set plugins.entries[id].config.apiKey)");
+		if (config.project === "") logger.warn("disabled: project is empty (set plugins.entries[id].config.project)");
 		return;
 	}
-	logger.debug(`enabled: project=${config.project} base=${config.baseUrl} allowConversationAccess=${config.allowConversationAccess}`);
-	const builder = new SpanBuilder();
+	logger.debug(`enabled v${SCOPE_VERSION}: project=${config.project} base=${config.baseUrl} content=${config.allowConversationAccess}`);
+	if (api.config?.plugins?.entries && api.config.plugins.entries[PLUGIN_ID]?.hooks?.allowConversationAccess !== true) logger.warn(`plugins.entries["${PLUGIN_ID}"].hooks.allowConversationAccess is not true; OpenClaw will not deliver the conversation hooks and no traces will be exported. Run: openclaw config set 'plugins.entries["${PLUGIN_ID}"].hooks.allowConversationAccess' true && openclaw gateway restart`);
+	const transport = opts.transport ?? new Transport({
+		baseUrl: config.baseUrl,
+		apiKey: config.apiKey,
+		project: config.project,
+		logger
+	});
+	let stateDir;
+	try {
+		stateDir = api.runtime?.state?.resolveStateDir?.();
+	} catch {
+		stateDir = void 0;
+	}
+	const builder = new SpanBuilder({
+		pluginVersion: SCOPE_VERSION,
+		stateDir,
+		tags: config.tags,
+		metadata: config.metadata,
+		memory: config.memory,
+		memoryContent: config.memoryContent,
+		toolDefinitions: config.toolDefinitions,
+		now: opts.now,
+		schedule: opts.schedule,
+		log: (msg) => logger.debug(msg),
+		emit: (result) => {
+			try {
+				opts.onEmit?.(result);
+				logger.debug(`run ${result.runId}: ${result.spans.length} spans ready`);
+				transport.enqueue(buildOtlpRequest([result], {
+					allowConversationAccess: config.allowConversationAccess,
+					redact: config.redact,
+					serviceName: config.serviceName,
+					maxContentChars: config.maxContentChars
+				}));
+			} catch (err) {
+				logger.warn(`export of run ${result.runId} failed: ${String(err)}`);
+			}
+		}
+	});
 	const wrap = (name, fn) => {
 		return (evt, ctx) => {
 			try {
@@ -969,64 +2477,33 @@ function registerLatitudePlugin(api, opts = {}) {
 			}
 		};
 	};
-	api.on("before_agent_start", wrap("before_agent_start", (evt, ctx) => {
-		builder.onBeforeAgentStart(evt, ctx);
-	}));
-	api.on("model_call_started", wrap("model_call_started", (evt, ctx) => {
-		builder.onModelCallStarted(evt, ctx);
-	}));
-	api.on("model_call_ended", wrap("model_call_ended", (evt, ctx) => {
-		builder.onModelCallEnded(evt, ctx);
-	}));
-	api.on("before_tool_call", wrap("before_tool_call", (evt, ctx) => {
-		builder.onBeforeToolCall(evt, ctx);
-	}));
-	api.on("after_tool_call", wrap("after_tool_call", (evt, ctx) => {
-		builder.onAfterToolCall(evt, ctx);
-	}));
-	api.on("before_compaction", wrap("before_compaction", (evt, ctx) => {
-		builder.onBeforeCompaction(evt, ctx);
-	}));
-	api.on("after_compaction", wrap("after_compaction", (evt, ctx) => {
-		builder.onAfterCompaction(evt, ctx);
-	}));
-	api.on("subagent_spawned", wrap("subagent_spawned", (evt, ctx) => {
-		builder.onSubagentSpawned(evt, ctx);
-	}));
-	api.on("subagent_ended", wrap("subagent_ended", (evt, ctx) => {
-		builder.onSubagentEnded(evt, ctx);
-	}));
-	api.on("llm_input", wrap("llm_input", (evt, ctx) => {
-		builder.onLlmInput(evt, ctx);
-	}));
-	api.on("llm_output", wrap("llm_output", (evt, ctx) => {
-		builder.onLlmOutput(evt, ctx);
-	}));
-	api.on("agent_end", wrap("agent_end", (evt, ctx) => {
-		queueMicrotask(() => {
+	api.on("llm_input", wrap("llm_input", (e, c) => builder.onLlmInput(e, c)));
+	api.on("llm_output", wrap("llm_output", (e, c) => builder.onLlmOutput(e, c)));
+	api.on("agent_end", wrap("agent_end", (e, c) => builder.onAgentEnd(e, c)));
+	api.on("model_call_started", wrap("model_call_started", (e, c) => builder.onModelCallStarted(e, c)));
+	api.on("model_call_ended", wrap("model_call_ended", (e, c) => builder.onModelCallEnded(e, c)));
+	api.on("before_tool_call", wrap("before_tool_call", (e, c) => builder.onBeforeToolCall(e, c)));
+	api.on("after_tool_call", wrap("after_tool_call", (e, c) => builder.onAfterToolCall(e, c)));
+	api.on("before_compaction", wrap("before_compaction", (e, c) => builder.onBeforeCompaction(e, c)));
+	api.on("after_compaction", wrap("after_compaction", (e, c) => builder.onAfterCompaction(e, c)));
+	api.on("subagent_spawned", wrap("subagent_spawned", (e, c) => builder.onSubagentSpawned(e, c)));
+	api.on("subagent_ended", wrap("subagent_ended", (e, c) => builder.onSubagentEnded(e, c)));
+	api.on("session_start", wrap("session_start", (e, c) => builder.onSessionStart(e, c)));
+	api.on("session_end", wrap("session_end", (e, c) => builder.onSessionEnd(e.sessionKey ?? c.sessionKey, e.sessionId ?? c.sessionId)));
+	api.on("message_received", wrap("message_received", (e, c) => builder.onMessageReceived(e, c)));
+	api.on("cron_changed", wrap("cron_changed", (e) => builder.onCronChanged(e)));
+	api.on("gateway_stop", (_evt, _ctx) => transport.flush(STOP_FLUSH_BUDGET_MS));
+	try {
+		api.runtime?.events?.onAgentEvent?.((evt) => {
 			try {
-				const result = builder.onAgentEnd(evt, ctx);
-				if (!result) {
-					logger.debug("agent_end fired without a matching run in flight");
-					return;
-				}
-				opts.onEmit?.(result);
-				const payload = buildOtlpRequest(result, {
-					allowConversationAccess: config.allowConversationAccess,
-					redact: config.redact
-				});
-				postTraces({
-					baseUrl: config.baseUrl,
-					apiKey: config.apiKey,
-					project: config.project,
-					payload,
-					logger
-				});
+				builder.onAgentEvent(evt);
 			} catch (err) {
-				logger.warn(`agent_end finalize failed: ${String(err)}`);
+				logger.warn(`agent event handler failed: ${String(err)}`);
 			}
 		});
-	}));
+	} catch (err) {
+		logger.debug(`agent event stream unavailable: ${String(err)}`);
+	}
 }
 //#endregion
 export { registerLatitudePlugin as default };