@tloncorp/openclaw 0.4.3 → 0.6.1

package/dist/src/telemetry.js

@@ -1,11 +1,26 @@
-import { PostHog } from "posthog-node";
-const TLON_TELEMETRY_EVENT_NAME = "TlonBot Reply Handled";
-const TLON_HEARTBEAT_NUDGE_EVENT = "TlonBot Heartbeat Nudge Sent";
-const TLON_HEARTBEAT_REENGAGED_EVENT = "TlonBot Heartbeat Nudge Reengaged";
-const TLON_TELEMETRY_LOG_SOURCE = "openclawPlugin";
+import { PostHog } from 'posthog-node';
+import { sharedMap, sharedSlot } from './shared-state.js';
+import { getTlonVersionIdentity } from './version.js';
+const TLON_TELEMETRY_EVENT_NAME = 'TlonBot Reply Handled';
+const TLON_GATEWAY_CONNECTED_EVENT = 'TlonBot Gateway Connected';
+const TLON_OUTBOUND_ROUTED_EVENT = 'TlonBot Outbound Routed';
+const TLON_SESSION_LIFECYCLE_EVENT = 'TlonBot Session Lifecycle';
+const TLON_SESSION_WATCHDOG_EVENT = 'TlonBot Session Watchdog';
+const TLON_SESSION_RECOVERY_EVENT = 'TlonBot Session Recovery';
+const TLON_HARNESS_ERROR_EVENT = 'TlonBot Harness Error';
+const TLON_PLUGIN_ERROR_EVENT = 'TlonBot Plugin Error';
+const TLON_TELEMETRY_ERROR_EVENT = 'TlonBot Telemetry Error';
+const TLON_HEARTBEAT_NUDGE_EVENT = 'TlonBot Heartbeat Nudge Sent';
+const TLON_HEARTBEAT_REENGAGED_EVENT = 'TlonBot Heartbeat Nudge Reengaged';
+const TLON_TELEMETRY_LOG_SOURCE = 'openclawPlugin';
 const TOOL_TRACE_TTL_MS = 60 * 60 * 1000;
 const MAX_TOOL_CALLS_PER_SESSION = 200;
-const toolCallsBySession = new Map();
+const REPLY_TRACE_TTL_MS = 60 * 60 * 1000;
+const MAX_ACTIVE_REPLY_TRACES = 50;
+const SESSION_CONTEXT_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+const MAX_SESSION_CONTEXTS = 5_000;
+const toolCallsBySession = sharedMap('telemetry.toolCallsBySession');
+const sessionContextsBySessionKey = sharedMap('telemetry.sessionContextsBySessionKey');
 function cleanupToolCalls(now = Date.now()) {
     for (const [sessionKey, trace] of toolCallsBySession) {
         if (now - trace.updatedAt > TOOL_TRACE_TTL_MS) {
@@ -28,7 +43,7 @@ export function recordToolCall(params) {
     trace.updatedAt = now;
     trace.calls.push({
         toolName: params.toolName,
-        durationMs: typeof params.durationMs === "number" ? params.durationMs : null,
+        durationMs: typeof params.durationMs === 'number' ? params.durationMs : null,
         error: params.error ?? null,
         recordedAt: now,
     });
@@ -58,16 +73,141 @@ function collectToolUsageSince(sessionKey, cursor) {
         errorCount: calls.filter((call) => call.error).length,
     };
 }
+function cleanupSessionContexts(now = Date.now()) {
+    for (const [sessionKey, context] of sessionContextsBySessionKey) {
+        if (now - context.updatedAt > SESSION_CONTEXT_TTL_MS) {
+            sessionContextsBySessionKey.delete(sessionKey);
+        }
+    }
+    while (sessionContextsBySessionKey.size > MAX_SESSION_CONTEXTS) {
+        const oldestKey = [...sessionContextsBySessionKey.entries()].sort((a, b) => a[1].updatedAt - b[1].updatedAt)[0]?.[0];
+        if (!oldestKey) {
+            break;
+        }
+        sessionContextsBySessionKey.delete(oldestKey);
+    }
+}
+function rememberTlonSessionContext(params) {
+    const sessionKey = params.sessionKey.trim();
+    if (!sessionKey) {
+        return;
+    }
+    const now = Date.now();
+    cleanupSessionContexts(now);
+    const existing = sessionContextsBySessionKey.get(sessionKey);
+    sessionContextsBySessionKey.set(sessionKey, {
+        sessionKey,
+        sessionId: optionalString(params.sessionId) ?? existing?.sessionId ?? null,
+        runId: optionalString(params.runId) ?? existing?.runId ?? null,
+        ownerShip: params.ownerShip,
+        botShip: params.botShip,
+        accountId: params.accountId ?? null,
+        agentId: params.agentId ?? null,
+        destinationKind: params.destinationKind,
+        updatedAt: now,
+    });
+}
+function lookupTlonSessionContext(sessionKey) {
+    const normalized = sessionKey?.trim();
+    if (!normalized) {
+        return null;
+    }
+    cleanupSessionContexts();
+    const context = sessionContextsBySessionKey.get(normalized);
+    if (!context) {
+        return null;
+    }
+    context.updatedAt = Date.now();
+    sessionContextsBySessionKey.set(normalized, context);
+    return context;
+}
+function updateTlonSessionContextSessionId(context, sessionId) {
+    const normalizedSessionId = optionalString(sessionId);
+    if (!normalizedSessionId || context.sessionId === normalizedSessionId) {
+        return context;
+    }
+    const updated = {
+        ...context,
+        sessionId: normalizedSessionId,
+        updatedAt: Date.now(),
+    };
+    sessionContextsBySessionKey.set(updated.sessionKey, updated);
+    return updated;
+}
+function updateTlonSessionContextRuntime(context, params) {
+    const normalizedSessionId = optionalString(params.sessionId);
+    const normalizedRunId = optionalString(params.runId);
+    const normalizedAgentId = optionalString(params.agentId);
+    if ((!normalizedSessionId || context.sessionId === normalizedSessionId) &&
+        (!normalizedRunId || context.runId === normalizedRunId) &&
+        (!normalizedAgentId || context.agentId === normalizedAgentId)) {
+        return context;
+    }
+    const updated = {
+        ...context,
+        sessionId: normalizedSessionId ?? context.sessionId,
+        runId: normalizedRunId ?? context.runId,
+        agentId: normalizedAgentId ?? context.agentId,
+        updatedAt: Date.now(),
+    };
+    sessionContextsBySessionKey.set(updated.sessionKey, updated);
+    return updated;
+}
+function countDispatchFailures(counts, kind) {
+    const value = counts?.[kind];
+    return typeof value === 'number' && Number.isFinite(value)
+        ? Math.max(0, value)
+        : 0;
+}
+function classifyError(error) {
+    if (!error) {
+        return null;
+    }
+    if (error instanceof Error) {
+        return error.name || 'Error';
+    }
+    if (typeof error === 'object' && error !== null) {
+        const code = error.code;
+        if (typeof code === 'string' && code.trim()) {
+            return code.trim().slice(0, 80);
+        }
+        const name = error.name;
+        if (typeof name === 'string' && name.trim()) {
+            return name.trim().slice(0, 80);
+        }
+        return 'object';
+    }
+    return typeof error;
+}
 function resolveReplyOutcome(params) {
     if (params.deliveredMessageCount > 0) {
-        return "responded";
+        return 'responded';
     }
-    return params.dispatchError ? "error" : "no_reply";
+    const failedReplyCount = countDispatchFailures(params.failedCounts, 'tool') +
+        countDispatchFailures(params.failedCounts, 'block') +
+        countDispatchFailures(params.failedCounts, 'final');
+    return params.dispatchError || params.sendError || failedReplyCount > 0
+        ? 'error'
+        : 'no_reply';
+}
+function resolveDeliverySkipReason(params) {
+    if (params.outcome !== 'no_reply') {
+        return null;
+    }
+    if (params.deliverySkipReason) {
+        return params.deliverySkipReason;
+    }
+    if (params.sourceReplyDeliveryMode === 'message_tool_only') {
+        return 'source_reply_delivery_mode_message_tool_only';
+    }
+    return null;
 }
 class PostHogTlonTelemetry {
     client;
     runtime;
+    versionIdentity = getTlonVersionIdentity();
     identifiedOwners = new Set();
+    activeReplyTraces = new Map();
     missingOwnerWarningLogged = false;
     constructor(params) {
         this.runtime = params.runtime;
@@ -80,23 +220,109 @@ class PostHogTlonTelemetry {
             disableRemoteConfig: true,
         });
     }
+    properties(props) {
+        return {
+            logSource: TLON_TELEMETRY_LOG_SOURCE,
+            ...this.versionIdentity,
+            ...props,
+        };
+    }
+    captureGatewayConnected(event) {
+        const ownerShip = event.ownerShip ?? '';
+        if (!this.ensureIdentified(ownerShip, event.botShip)) {
+            return;
+        }
+        this.client.capture({
+            distinctId: ownerShip,
+            event: TLON_GATEWAY_CONNECTED_EVENT,
+            properties: this.properties({
+                botShip: event.botShip,
+                ownerShip: event.ownerShip,
+                tlonSkillVersion: event.tlonSkillVersion,
+                accountId: event.accountId,
+                configured: event.configured,
+                watchedChannelCount: event.watchedChannelCount,
+                dmAllowlistCount: event.dmAllowlistCount,
+                defaultAuthorizedShipsCount: event.defaultAuthorizedShipsCount,
+                pendingApprovalCount: event.pendingApprovalCount,
+                autoDiscoverChannels: event.autoDiscoverChannels,
+                ownerListenEnabled: event.ownerListenEnabled,
+            }),
+        });
+    }
     startReply(params) {
+        const normalizedParams = {
+            ...params,
+            sessionId: optionalString(params.sessionId),
+            runId: params.runId ?? null,
+            accountId: params.accountId ?? null,
+            agentId: params.agentId ?? null,
+            destinationKind: params.destinationKind ?? params.chatType,
+        };
         const toolTraceCursor = createToolTraceCursor(params.sessionKey);
+        rememberTlonSessionContext({
+            sessionKey: normalizedParams.sessionKey,
+            sessionId: normalizedParams.sessionId,
+            runId: normalizedParams.runId,
+            ownerShip: normalizedParams.ownerShip,
+            botShip: normalizedParams.botShip,
+            accountId: normalizedParams.accountId,
+            agentId: normalizedParams.agentId,
+            destinationKind: normalizedParams.destinationKind,
+        });
+        this.pruneActiveReplyTraces();
+        const token = Symbol(normalizedParams.sessionKey);
+        const trace = {
+            params: normalizedParams,
+            startedAt: Date.now(),
+            toolTraceCursor,
+            timeout: setTimeout(() => {
+                this.captureAbandonedReplyTrace(token, 'stale');
+            }, REPLY_TRACE_TTL_MS),
+        };
+        trace.timeout.unref?.();
+        this.activeReplyTraces.set(token, trace);
+        this.pruneActiveReplyTraces();
         return {
             capture: async (result) => {
+                const activeTrace = this.activeReplyTraces.get(token);
+                if (!activeTrace) {
+                    return;
+                }
+                this.activeReplyTraces.delete(token);
+                clearTimeout(activeTrace.timeout);
                 // Yield once so after_tool_call hooks for the just-finished reply have time to run.
                 await new Promise((resolve) => setTimeout(resolve, 0));
+                const failedToolCount = countDispatchFailures(result.failedCounts, 'tool');
+                const failedBlockCount = countDispatchFailures(result.failedCounts, 'block');
+                const failedFinalCount = countDispatchFailures(result.failedCounts, 'final');
+                const sendErrorCount = Math.max(0, result.sendErrorCount ?? 0);
+                const sessionContext = lookupTlonSessionContext(activeTrace.params.sessionKey);
+                const outcome = resolveReplyOutcome({
+                    deliveredMessageCount: result.deliveredMessageCount,
+                    sendError: sendErrorCount > 0,
+                    failedCounts: result.failedCounts,
+                    dispatchError: result.dispatchError,
+                });
+                const sourceReplyDeliveryMode = result.sourceReplyDeliveryMode ?? null;
                 this.captureReplyOutcome({
-                    ownerShip: params.ownerShip,
-                    botShip: params.botShip,
-                    outcome: resolveReplyOutcome({
-                        deliveredMessageCount: result.deliveredMessageCount,
-                        dispatchError: result.dispatchError,
-                    }),
-                    chatType: params.chatType,
-                    isThreadReply: params.isThreadReply,
-                    senderRole: params.senderRole,
-                    attachmentCount: params.attachmentCount,
+                    sessionKey: activeTrace.params.sessionKey,
+                    sessionId: sessionContext?.sessionId ?? activeTrace.params.sessionId,
+                    runId: activeTrace.params.runId,
+                    accountId: activeTrace.params.accountId,
+                    agentId: activeTrace.params.agentId,
+                    ownerShip: activeTrace.params.ownerShip,
+                    botShip: activeTrace.params.botShip,
+                    outcome,
+                    chatType: activeTrace.params.chatType,
+                    destinationKind: activeTrace.params.destinationKind,
+                    isThreadReply: activeTrace.params.isThreadReply,
+                    senderRole: activeTrace.params.senderRole,
+                    attachmentCount: activeTrace.params.attachmentCount,
+                    sendAttemptCount: Math.max(0, result.sendAttemptCount ?? 0),
+                    sendError: sendErrorCount > 0,
+                    sendErrorCount,
+                    sendErrorKind: result.sendErrorKind ?? null,
                     deliveredMessageCount: result.deliveredMessageCount,
                     replyCharCount: result.replyCharCount,
                     replyWordCount: result.replyWordCount,
@@ -105,32 +331,119 @@ class PostHogTlonTelemetry {
                     queuedFinal: result.queuedFinal,
                     queuedFinalCount: result.queuedFinalCount,
                     queuedBlockCount: result.queuedBlockCount,
+                    failedToolCount,
+                    failedBlockCount,
+                    failedFinalCount,
+                    failedReplyCount: failedToolCount + failedBlockCount + failedFinalCount,
+                    deliverySkipReason: resolveDeliverySkipReason({
+                        outcome,
+                        deliverySkipReason: result.deliverySkipReason,
+                        sourceReplyDeliveryMode,
+                    }),
+                    sourceReplyDeliveryMode,
+                    beforeAgentRunBlocked: result.beforeAgentRunBlocked === true,
+                    dispatchError: Boolean(result.dispatchError),
+                    dispatchErrorKind: classifyError(result.dispatchError),
+                    abandonedReason: null,
                     provider: result.provider,
                     model: result.model,
                     thinkLevel: result.thinkLevel,
-                    toolUsage: collectToolUsageSince(params.sessionKey, toolTraceCursor),
+                    toolUsage: collectToolUsageSince(activeTrace.params.sessionKey, activeTrace.toolTraceCursor),
                 });
             },
         };
     }
+    captureAbandonedReplyTrace(token, reason) {
+        const trace = this.activeReplyTraces.get(token);
+        if (!trace) {
+            return;
+        }
+        this.activeReplyTraces.delete(token);
+        clearTimeout(trace.timeout);
+        const sessionContext = lookupTlonSessionContext(trace.params.sessionKey);
+        this.captureReplyOutcome({
+            sessionKey: trace.params.sessionKey,
+            sessionId: sessionContext?.sessionId ?? trace.params.sessionId,
+            runId: trace.params.runId,
+            accountId: trace.params.accountId,
+            agentId: trace.params.agentId,
+            ownerShip: trace.params.ownerShip,
+            botShip: trace.params.botShip,
+            outcome: 'abandoned',
+            chatType: trace.params.chatType,
+            destinationKind: trace.params.destinationKind,
+            isThreadReply: trace.params.isThreadReply,
+            senderRole: trace.params.senderRole,
+            attachmentCount: trace.params.attachmentCount,
+            sendAttemptCount: 0,
+            sendError: false,
+            sendErrorCount: 0,
+            sendErrorKind: null,
+            deliveredMessageCount: 0,
+            replyCharCount: 0,
+            replyWordCount: 0,
+            replyMediaCount: 0,
+            dispatchDurationMs: Date.now() - trace.startedAt,
+            queuedFinal: false,
+            queuedFinalCount: 0,
+            queuedBlockCount: 0,
+            failedToolCount: 0,
+            failedBlockCount: 0,
+            failedFinalCount: 0,
+            failedReplyCount: 0,
+            deliverySkipReason: null,
+            sourceReplyDeliveryMode: null,
+            beforeAgentRunBlocked: false,
+            dispatchError: false,
+            dispatchErrorKind: null,
+            abandonedReason: reason,
+            provider: null,
+            model: null,
+            thinkLevel: null,
+            toolUsage: collectToolUsageSince(trace.params.sessionKey, trace.toolTraceCursor),
+        });
+    }
+    pruneActiveReplyTraces(now = Date.now()) {
+        for (const [token, trace] of this.activeReplyTraces) {
+            if (now - trace.startedAt > REPLY_TRACE_TTL_MS) {
+                this.captureAbandonedReplyTrace(token, 'stale');
+            }
+        }
+        while (this.activeReplyTraces.size > MAX_ACTIVE_REPLY_TRACES) {
+            const oldest = [...this.activeReplyTraces.entries()].sort((a, b) => a[1].startedAt - b[1].startedAt)[0];
+            if (!oldest) {
+                break;
+            }
+            this.captureAbandonedReplyTrace(oldest[0], 'max_traces');
+        }
+    }
     captureReplyOutcome(event) {
-        const ownerShip = event.ownerShip ?? "";
+        const ownerShip = event.ownerShip ?? '';
         if (!this.ensureIdentified(ownerShip, event.botShip)) {
             return;
         }
         this.client.capture({
             distinctId: ownerShip,
             event: TLON_TELEMETRY_EVENT_NAME,
-            properties: {
-                logSource: TLON_TELEMETRY_LOG_SOURCE,
+            properties: this.properties({
+                sessionKey: event.sessionKey,
+                sessionId: event.sessionId,
+                runId: event.runId,
+                accountId: event.accountId,
+                agentId: event.agentId,
                 botShip: event.botShip,
                 ownerShip: event.ownerShip,
                 outcome: event.outcome,
                 chatType: event.chatType,
+                destinationKind: event.destinationKind,
                 isThreadReply: event.isThreadReply,
                 senderRole: event.senderRole,
                 attachmentCount: event.attachmentCount,
                 hasAttachments: event.attachmentCount > 0,
+                sendAttemptCount: event.sendAttemptCount,
+                sendError: event.sendError,
+                sendErrorCount: event.sendErrorCount,
+                sendErrorKind: event.sendErrorKind,
                 deliveredMessageCount: event.deliveredMessageCount,
                 replyCharCount: event.replyCharCount,
                 replyWordCount: event.replyWordCount,
@@ -139,6 +452,16 @@ class PostHogTlonTelemetry {
                 queuedFinal: event.queuedFinal,
                 queuedFinalCount: event.queuedFinalCount,
                 queuedBlockCount: event.queuedBlockCount,
+                failedToolCount: event.failedToolCount,
+                failedBlockCount: event.failedBlockCount,
+                failedFinalCount: event.failedFinalCount,
+                failedReplyCount: event.failedReplyCount,
+                deliverySkipReason: event.deliverySkipReason,
+                sourceReplyDeliveryMode: event.sourceReplyDeliveryMode,
+                beforeAgentRunBlocked: event.beforeAgentRunBlocked,
+                dispatchError: event.dispatchError,
+                dispatchErrorKind: event.dispatchErrorKind,
+                abandonedReason: event.abandonedReason,
                 provider: event.provider,
                 model: event.model,
                 thinkLevel: event.thinkLevel,
@@ -151,14 +474,195 @@ class PostHogTlonTelemetry {
                     durationMs: call.durationMs,
                     error: call.error,
                 })),
-            },
+            }),
+        });
+    }
+    captureSessionLifecycle(event) {
+        const ownerShip = event.ownerShip ?? '';
+        if (!this.ensureIdentified(ownerShip, event.botShip)) {
+            return;
+        }
+        this.client.capture({
+            distinctId: ownerShip,
+            event: TLON_SESSION_LIFECYCLE_EVENT,
+            properties: this.properties({
+                botShip: event.botShip,
+                ownerShip: event.ownerShip,
+                accountId: event.accountId,
+                agentId: event.agentId,
+                sessionKey: event.sessionKey,
+                sessionId: event.sessionId,
+                lifecycleEvent: event.lifecycleEvent,
+                destinationKind: event.destinationKind,
+                reason: event.reason,
+                messageCount: event.messageCount,
+                durationMs: event.durationMs,
+                transcriptArchived: event.transcriptArchived,
+                hasNextSession: event.hasNextSession,
+            }),
+        });
+    }
+    captureSessionWatchdog(event) {
+        const ownerShip = event.ownerShip ?? '';
+        if (!this.ensureIdentified(ownerShip, event.botShip)) {
+            return;
+        }
+        this.client.capture({
+            distinctId: ownerShip,
+            event: TLON_SESSION_WATCHDOG_EVENT,
+            properties: this.properties({
+                botShip: event.botShip,
+                ownerShip: event.ownerShip,
+                accountId: event.accountId,
+                agentId: event.agentId,
+                sessionKey: event.sessionKey,
+                sessionId: event.sessionId,
+                diagnosticType: event.diagnosticType,
+                destinationKind: event.destinationKind,
+                state: event.state,
+                ageMs: event.ageMs,
+                queueDepth: event.queueDepth,
+                reason: event.reason,
+                classification: event.classification,
+                activeWorkKind: event.activeWorkKind,
+                lastProgressAgeMs: event.lastProgressAgeMs,
+                lastProgressReason: event.lastProgressReason,
+                activeToolName: event.activeToolName,
+                activeToolAgeMs: event.activeToolAgeMs,
+                terminalProgressStale: event.terminalProgressStale,
+            }),
+        });
+    }
+    captureSessionRecovery(event) {
+        const ownerShip = event.ownerShip ?? '';
+        if (!this.ensureIdentified(ownerShip, event.botShip)) {
+            return;
+        }
+        this.client.capture({
+            distinctId: ownerShip,
+            event: TLON_SESSION_RECOVERY_EVENT,
+            properties: this.properties({
+                botShip: event.botShip,
+                ownerShip: event.ownerShip,
+                accountId: event.accountId,
+                agentId: event.agentId,
+                sessionKey: event.sessionKey,
+                sessionId: event.sessionId,
+                diagnosticType: event.diagnosticType,
+                destinationKind: event.destinationKind,
+                state: event.state,
+                stateGeneration: event.stateGeneration,
+                ageMs: event.ageMs,
+                queueDepth: event.queueDepth,
+                reason: event.reason,
+                activeWorkKind: event.activeWorkKind,
+                allowActiveAbort: event.allowActiveAbort,
+                status: event.status,
+                action: event.action,
+                outcomeReason: event.outcomeReason,
+                released: event.released,
+                stale: event.stale,
+            }),
+        });
+    }
+    captureOutboundRoute(event) {
+        const ownerShip = event.ownerShip ?? '';
+        if (!this.ensureIdentified(ownerShip, event.botShip)) {
+            return;
+        }
+        this.client.capture({
+            distinctId: ownerShip,
+            event: TLON_OUTBOUND_ROUTED_EVENT,
+            properties: this.properties({
+                botShip: event.botShip,
+                ownerShip: event.ownerShip,
+                resolvedChannel: event.resolvedChannel,
+                routedToTlon: event.routedToTlon,
+                targetKind: event.targetKind,
+            }),
+        });
+    }
+    captureHarnessError(event) {
+        const ownerShip = event.ownerShip ?? '';
+        if (!this.ensureIdentified(ownerShip, event.botShip)) {
+            return;
+        }
+        this.client.capture({
+            distinctId: ownerShip,
+            event: TLON_HARNESS_ERROR_EVENT,
+            properties: this.properties({
+                harness: event.harness,
+                harnessEventType: event.harnessEventType,
+                errorScope: event.errorScope,
+                sessionKey: event.sessionKey,
+                sessionId: event.sessionId,
+                runId: event.runId,
+                accountId: event.accountId,
+                agentId: event.agentId,
+                ownerShip: event.ownerShip,
+                botShip: event.botShip,
+                destinationKind: event.destinationKind,
+                provider: event.provider,
+                model: event.model,
+                toolName: event.toolName,
+                phase: event.phase,
+                outcome: event.outcome,
+                errorCategory: event.errorCategory,
+                failureKind: event.failureKind,
+                durationMs: event.durationMs,
+                errorText: event.errorText,
+            }),
+        });
+    }
+    capturePluginError(event) {
+        const ownerShip = event.ownerShip ?? '';
+        if (!this.ensureIdentified(ownerShip, event.botShip)) {
+            return;
+        }
+        this.client.capture({
+            distinctId: ownerShip,
+            event: TLON_PLUGIN_ERROR_EVENT,
+            properties: this.properties({
+                harness: event.harness,
+                pluginErrorSource: event.pluginErrorSource,
+                accountId: event.accountId,
+                ownerShip: event.ownerShip,
+                botShip: event.botShip,
+                errorKind: event.errorKind,
+                errorText: event.errorText,
+                attempt: event.attempt,
+            }),
+        });
+    }
+    captureTelemetryError(event) {
+        const ownerShip = event.ownerShip ?? '';
+        if (!this.ensureIdentified(ownerShip, event.botShip)) {
+            return;
+        }
+        this.client.capture({
+            distinctId: ownerShip,
+            event: TLON_TELEMETRY_ERROR_EVENT,
+            properties: this.properties({
+                harness: event.harness,
+                telemetrySource: event.telemetrySource,
+                sourceEventName: event.sourceEventName,
+                sessionKey: event.sessionKey,
+                sessionId: event.sessionId,
+                runId: event.runId,
+                accountId: event.accountId,
+                agentId: event.agentId,
+                ownerShip: event.ownerShip,
+                botShip: event.botShip,
+                errorKind: event.errorKind,
+                errorText: event.errorText,
+            }),
         });
     }
     ensureIdentified(ownerShip, botShip) {
         if (!ownerShip) {
             if (!this.missingOwnerWarningLogged) {
                 this.missingOwnerWarningLogged = true;
-                this.runtime?.log?.("[tlon] Telemetry is enabled but ownerShip is not configured; skipping telemetry events");
+                this.runtime?.log?.('[tlon] Telemetry is enabled but ownerShip is not configured; skipping telemetry events');
             }
             return false;
         }
@@ -168,6 +672,7 @@ class PostHogTlonTelemetry {
                 distinctId: ownerShip,
                 properties: {
                     logSource: TLON_TELEMETRY_LOG_SOURCE,
+                    ...this.versionIdentity,
                     tlonOwnerShip: ownerShip,
                     tlonBotShip: botShip,
                 },
@@ -182,17 +687,18 @@ class PostHogTlonTelemetry {
         this.client.capture({
             distinctId: event.ownerShip,
             event: TLON_HEARTBEAT_NUDGE_EVENT,
-            properties: {
-                logSource: TLON_TELEMETRY_LOG_SOURCE,
+            properties: this.properties({
                 botShip: event.botShip,
                 ownerShip: event.ownerShip,
-                trigger: "heartbeat",
+                trigger: 'heartbeat',
                 nudgeStage: event.nudgeStage,
                 nudgeTarget: event.nudgeTarget,
                 channel: event.channel,
                 success: event.success,
                 accountId: event.accountId,
-            },
+                messageId: event.messageId,
+                nudgeSentAtMs: event.nudgeSentAtMs,
+            }),
         });
     }
     captureHeartbeatReengagement(event) {
@@ -202,8 +708,7 @@ class PostHogTlonTelemetry {
         this.client.capture({
             distinctId: event.ownerShip,
             event: TLON_HEARTBEAT_REENGAGED_EVENT,
-            properties: {
-                logSource: TLON_TELEMETRY_LOG_SOURCE,
+            properties: this.properties({
                 botShip: event.botShip,
                 ownerShip: event.ownerShip,
                 nudgeStage: event.nudgeStage,
@@ -212,10 +717,13 @@ class PostHogTlonTelemetry {
                 reengagementDelayMs: event.reengagementDelayMs,
                 channel: event.channel,
                 accountId: event.accountId,
-            },
+            }),
         });
     }
     async close() {
+        for (const token of [...this.activeReplyTraces.keys()]) {
+            this.captureAbandonedReplyTrace(token, 'telemetry_close');
+        }
         try {
             await this.client.flush();
         }
@@ -235,18 +743,240 @@ export function createTlonTelemetry(params) {
         return null;
     }
     if (!params.config.apiKey) {
-        params.runtime?.log?.("[tlon] Telemetry is enabled but telemetry.apiKey is missing; telemetry disabled");
+        params.runtime?.log?.('[tlon] Telemetry is enabled but telemetry.apiKey is missing; telemetry disabled');
         return null;
     }
-    params.runtime?.log?.(`[tlon] Telemetry enabled${params.config.host ? ` (${params.config.host})` : ""}`);
+    params.runtime?.log?.(`[tlon] Telemetry enabled${params.config.host ? ` (${params.config.host})` : ''}`);
     return new PostHogTlonTelemetry({
         apiKey: params.config.apiKey,
         host: params.config.host,
         runtime: params.runtime,
     });
 }
+const outboundRouteReporterSlot = sharedSlot('telemetry.outboundRouteReporter');
+const sessionTelemetryReporterSlot = sharedSlot('telemetry.sessionTelemetryReporter');
+const errorTelemetryReporterSlot = sharedSlot('telemetry.errorTelemetryReporter');
+export function setOutboundRouteReporter(reporter) {
+    outboundRouteReporterSlot.set(reporter);
+}
+export function reportOutboundRoute(event) {
+    outboundRouteReporterSlot.get()?.(event);
+}
+export function setSessionTelemetryReporter(reporter) {
+    sessionTelemetryReporterSlot.set(reporter);
+}
+export function setErrorTelemetryReporter(reporter) {
+    errorTelemetryReporterSlot.set(reporter);
+}
+function optionalString(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+}
+function optionalErrorText(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function optionalNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+export function formatTlonTelemetryErrorText(error) {
+    if (error instanceof Error) {
+        return error.stack || error.message || String(error);
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error === null) {
+        return 'null';
+    }
+    if (error === undefined) {
+        return 'undefined';
+    }
+    try {
+        const json = JSON.stringify(error);
+        if (json) {
+            return json;
+        }
+    }
+    catch {
+        // Fall through to String(error).
+    }
+    return String(error);
+}
+export function reportSessionTurnCreated(event) {
+    const context = lookupTlonSessionContext(event.sessionKey);
+    if (!context) {
+        return;
+    }
+    updateTlonSessionContextRuntime(context, {
+        sessionId: event.sessionId,
+        runId: event.runId,
+        agentId: event.agentId,
+    });
+}
+export function reportHarnessError(event) {
+    const rememberedContext = lookupTlonSessionContext(event.sessionKey);
+    const context = rememberedContext
+        ? updateTlonSessionContextRuntime(rememberedContext, {
+            sessionId: event.sessionId,
+            runId: event.runId,
+            agentId: event.agentId,
+        })
+        : null;
+    if (!context && event.sessionKey) {
+        return;
+    }
+    errorTelemetryReporterSlot.get()?.({
+        kind: 'harness',
+        event: {
+            harness: 'openclaw',
+            harnessEventType: event.harnessEventType,
+            errorScope: event.errorScope,
+            sessionKey: context?.sessionKey ?? null,
+            sessionId: context?.sessionId ?? optionalString(event.sessionId),
+            runId: optionalString(event.runId) ?? context?.runId ?? null,
+            accountId: context?.accountId ?? optionalString(event.accountId),
+            agentId: optionalString(event.agentId) ?? context?.agentId ?? null,
+            ownerShip: context?.ownerShip ?? optionalString(event.ownerShip),
+            botShip: context?.botShip ?? optionalString(event.botShip) ?? '',
+            destinationKind: context?.destinationKind ?? event.destinationKind ?? null,
+            provider: optionalString(event.provider),
+            model: optionalString(event.model),
+            toolName: optionalString(event.toolName),
+            phase: optionalString(event.phase),
+            outcome: optionalString(event.outcome),
+            errorCategory: optionalString(event.errorCategory),
+            failureKind: optionalString(event.failureKind),
+            durationMs: optionalNumber(event.durationMs),
+            errorText: optionalErrorText(event.errorText),
+        },
+    });
+}
+export function reportPluginError(event) {
+    errorTelemetryReporterSlot.get()?.({
+        kind: 'plugin',
+        event,
+    });
+}
+export function reportTelemetryError(event) {
+    const rememberedContext = lookupTlonSessionContext(event.sessionKey);
+    const context = rememberedContext
+        ? updateTlonSessionContextRuntime(rememberedContext, {
+            sessionId: event.sessionId,
+            runId: event.runId,
+            agentId: event.agentId,
+        })
+        : null;
+    errorTelemetryReporterSlot.get()?.({
+        kind: 'telemetry',
+        event: {
+            ...event,
+            sessionKey: context?.sessionKey ?? optionalString(event.sessionKey),
+            sessionId: context?.sessionId ?? optionalString(event.sessionId),
+            runId: optionalString(event.runId) ?? context?.runId ?? null,
+            agentId: optionalString(event.agentId) ?? context?.agentId ?? null,
+            accountId: event.accountId ?? context?.accountId ?? null,
+            ownerShip: event.ownerShip ?? context?.ownerShip ?? null,
+            botShip: event.botShip ?? context?.botShip ?? null,
+            sourceEventName: optionalString(event.sourceEventName),
+            errorKind: optionalString(event.errorKind),
+        },
+    });
+}
+export function reportSessionLifecycle(event) {
+    const rememberedContext = lookupTlonSessionContext(event.sessionKey);
+    const context = rememberedContext
+        ? updateTlonSessionContextSessionId(rememberedContext, event.sessionId)
+        : null;
+    if (!context) {
+        return;
+    }
+    sessionTelemetryReporterSlot.get()?.({
+        kind: 'lifecycle',
+        event: {
+            lifecycleEvent: event.lifecycleEvent,
+            sessionKey: context.sessionKey,
+            sessionId: context.sessionId,
+            accountId: context.accountId,
+            agentId: optionalString(event.agentId) ?? context.agentId,
+            ownerShip: context.ownerShip,
+            botShip: context.botShip,
+            destinationKind: context.destinationKind,
+            reason: optionalString(event.reason),
+            messageCount: optionalNumber(event.messageCount),
+            durationMs: optionalNumber(event.durationMs),
+            transcriptArchived: typeof event.transcriptArchived === 'boolean'
+                ? event.transcriptArchived
+                : null,
+            hasNextSession: event.hasNextSession === true,
+        },
+    });
+}
+export function reportSessionDiagnostic(event) {
+    const rememberedContext = lookupTlonSessionContext(event.sessionKey);
+    const context = rememberedContext
+        ? updateTlonSessionContextSessionId(rememberedContext, event.sessionId)
+        : null;
+    if (!context) {
+        return;
+    }
+    if (event.type === 'session.stalled' || event.type === 'session.stuck') {
+        sessionTelemetryReporterSlot.get()?.({
+            kind: 'watchdog',
+            event: {
+                diagnosticType: event.type,
+                sessionKey: context.sessionKey,
+                sessionId: context.sessionId,
+                accountId: context.accountId,
+                agentId: context.agentId,
+                ownerShip: context.ownerShip,
+                botShip: context.botShip,
+                destinationKind: context.destinationKind,
+                state: event.state,
+                ageMs: event.ageMs,
+                queueDepth: optionalNumber(event.queueDepth),
+                reason: optionalString(event.reason),
+                classification: event.classification,
+                activeWorkKind: optionalString(event.activeWorkKind),
+                lastProgressAgeMs: optionalNumber(event.lastProgressAgeMs),
+                lastProgressReason: optionalString(event.lastProgressReason),
+                activeToolName: optionalString(event.activeToolName),
+                activeToolAgeMs: optionalNumber(event.activeToolAgeMs),
+                terminalProgressStale: event.terminalProgressStale === true,
+            },
+        });
+        return;
+    }
+    const recoveryEvent = event;
+    sessionTelemetryReporterSlot.get()?.({
+        kind: 'recovery',
+        event: {
+            diagnosticType: recoveryEvent.type,
+            sessionKey: context.sessionKey,
+            sessionId: context.sessionId,
+            accountId: context.accountId,
+            agentId: context.agentId,
+            ownerShip: context.ownerShip,
+            botShip: context.botShip,
+            destinationKind: context.destinationKind,
+            state: recoveryEvent.state,
+            stateGeneration: optionalNumber(recoveryEvent.stateGeneration),
+            ageMs: recoveryEvent.ageMs,
+            queueDepth: optionalNumber(recoveryEvent.queueDepth),
+            reason: optionalString(recoveryEvent.reason),
+            activeWorkKind: optionalString(recoveryEvent.activeWorkKind),
+            allowActiveAbort: recoveryEvent.allowActiveAbort === true,
+            status: optionalString(recoveryEvent.status),
+            action: optionalString(recoveryEvent.action),
+            outcomeReason: optionalString(recoveryEvent.outcomeReason),
+            released: optionalNumber(recoveryEvent.released),
+            stale: recoveryEvent.stale === true,
+        },
+    });
+}
 export const _testing = {
     clearToolCalls: () => toolCallsBySession.clear(),
+    clearSessionContexts: () => sessionContextsBySessionKey.clear(),
+    getReplyTraceTtlMs: () => REPLY_TRACE_TTL_MS,
     getToolTraceTtlMs: () => TOOL_TRACE_TTL_MS,
 };
 //# sourceMappingURL=telemetry.js.map