@tloncorp/openclaw 0.6.0 → 0.6.1

package/dist/src/monitor/index.js

@@ -1,4 +1,5 @@
 import { configureGatewayStatus, gatewayStart } from '@tloncorp/api';
+import { randomUUID } from 'node:crypto';
 import { format } from 'node:util';
 import { createTypingCallbacks } from 'openclaw/plugin-sdk/channel-runtime';
 import { getEffectiveOwnerShip, setEffectiveOwnerShip, } from '../effective-owner.js';
@@ -11,7 +12,7 @@ import { setSessionRole } from '../session-roles.js';
 import { DM_INVITE_PREVIEW, createSettingsManager, } from '../settings.js';
 import { sharedSlot } from '../shared-state.js';
 import { canonicalizeNest, normalizeShip, parseChannelNest, } from '../targets.js';
-import { createTlonTelemetry } from '../telemetry.js';
+import { createTlonTelemetry, formatTlonTelemetryErrorText, setErrorTelemetryReporter, setOutboundRouteReporter, setSessionTelemetryReporter, } from '../telemetry.js';
 import { resolveTlonAccount } from '../types.js';
 import { configureTlonApiWithPoke } from '../urbit/api-client.js';
 import { authenticate } from '../urbit/auth.js';
@@ -20,6 +21,7 @@ import { describeError } from '../urbit/errors.js';
 import { sendChannelPost, sendDm } from '../urbit/send.js';
 import { UrbitSSEClient } from '../urbit/sse-client.js';
 import { markdownToStory } from '../urbit/story.js';
+import { formatTlonVersionIdentity, resolveTlonSkillVersion, } from '../version.js';
 import { createPendingApproval, emojiToApprovalAction, findPendingApproval, formatApprovalConfirmation, formatApprovalRequest, formatBlockedList, formatPendingList, isExpired, normalizeNotificationId, pruneExpired, removePendingApproval, } from './approval.js';
 import { removeBridge, setBridge, } from './command-bridge.js';
 import { createComputingPresenceTracker } from './computing-presence.js';
@@ -31,6 +33,7 @@ import { clearShadowsForAccount, getLastNudgeStageShadow, getLastOwnerActivity,
 import { createOwnerReplyPersistenceQueue } from './owner-reply-persistence.js';
 import { createPendingNudgePersistenceQueue } from './pending-nudge-persistence.js';
 import { createProcessedMessageTracker } from './processed-messages.js';
+import { isRouteDebugEnabled, recordTlonRouteAndDispatch, routeUpdateWillSkipByPin, tlonDeliveryContext, } from './session-routing.js';
 import { resolveSettingsMirrorSync } from './settings-sync.js';
 import { extractCites, extractMessageText, formatModelName, isBotMentioned, isDmAllowed, isOwnerListenSlashCommand, isSummarizationRequest, sanitizeMessageText, shouldEngageInGroup, stripBotMention, } from './utils.js';
 // Holds the data needed for any module-loader context to (re)configure its
@@ -41,6 +44,12 @@ const apiClientParamsSlot = sharedSlot(API_CLIENT_PARAMS_SLOT);
 const SETTINGS_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 const GATEWAY_STATUS_ACTIVATION_TIMEOUT_MS = 15_000;
 const GATEWAY_STATUS_ACTIVATION_RETRY_MS = 30_000;
+function classifyPluginError(error) {
+    if (error instanceof Error) {
+        return error.name || 'Error';
+    }
+    return typeof error;
+}
 // Bound an activation poke so a silently-hung promise surfaces as a
 // retryable error instead of leaving gateway-status dead for the process
 // lifetime. The underlying poke may still settle after the timeout; the
@@ -135,10 +144,36 @@ export async function monitorTlonProvider(opts = {}) {
     const accountUrl = account.url;
     const accountCode = account.code;
     const botShipName = normalizeShip(account.ship);
+    const tlonSkillVersion = await resolveTlonSkillVersion();
+    let effectiveOwnerShip = account.ownerShip
+        ? normalizeShip(account.ownerShip)
+        : null;
+    setEffectiveOwnerShip(account.accountId, effectiveOwnerShip);
+    const telemetry = createTlonTelemetry({
+        config: account.telemetry,
+        runtime,
+    });
+    const currentTelemetryOwnerShip = () => getEffectiveOwnerShip(account.accountId) ?? effectiveOwnerShip;
+    const capturePluginError = (pluginErrorSource, error, extra) => {
+        telemetry?.capturePluginError({
+            harness: 'openclaw',
+            pluginErrorSource,
+            accountId: account.accountId,
+            ownerShip: currentTelemetryOwnerShip(),
+            botShip: botShipName,
+            errorKind: extra?.errorKind ?? classifyPluginError(error),
+            errorText: formatTlonTelemetryErrorText(error),
+            attempt: extra?.attempt ?? null,
+        });
+    };
     runtime.log?.(`[tlon] Starting monitor for ${botShipName}`);
+    runtime.log?.(`[tlon] version: ${formatTlonVersionIdentity({
+        markdown: false,
+        tlonSkillVersion,
+    }).replace(/\n/g, ' | ')}`);
     const ssrfPolicy = ssrfPolicyFromAllowPrivateNetwork(account.allowPrivateNetwork);
     // Helper to authenticate with retry logic
-    async function authenticateWithRetry(maxAttempts = 10) {
+    async function authenticateWithRetry(maxAttempts = 10, source = 'auth') {
         for (let attempt = 1;; attempt++) {
             if (opts.abortSignal?.aborted) {
                 throw new Error('Aborted while waiting to authenticate');
@@ -148,6 +183,7 @@ export async function monitorTlonProvider(opts = {}) {
                 return await authenticate(accountUrl, accountCode, { ssrfPolicy });
             }
             catch (error) {
+                capturePluginError(source, error, { attempt });
                 runtime.error?.(`[tlon] Failed to authenticate (attempt ${attempt}): ${error?.message ?? String(error)}`);
                 if (attempt >= maxAttempts) {
                     throw error;
@@ -168,22 +204,29 @@ export async function monitorTlonProvider(opts = {}) {
         }
     }
     let api = null;
-    const cookie = await authenticateWithRetry();
-    api = new UrbitSSEClient(account.url, cookie, {
-        ship: botShipName,
-        ssrfPolicy,
-        logger: {
-            log: (message) => runtime.log?.(message),
-            error: (message) => runtime.error?.(message),
-        },
-        // Re-authenticate on reconnect in case the session expired
-        onReconnect: async (client) => {
-            runtime.log?.('[tlon] Re-authenticating on SSE reconnect...');
-            const newCookie = await authenticateWithRetry(5);
-            client.updateCookie(newCookie);
-            runtime.log?.('[tlon] Re-authentication successful');
-        },
-    });
+    let cookie;
+    try {
+        cookie = await authenticateWithRetry();
+        api = new UrbitSSEClient(account.url, cookie, {
+            ship: botShipName,
+            ssrfPolicy,
+            logger: {
+                log: (message) => runtime.log?.(message),
+                error: (message) => runtime.error?.(message),
+            },
+            // Re-authenticate on reconnect in case the session expired
+            onReconnect: async (client) => {
+                runtime.log?.('[tlon] Re-authenticating on SSE reconnect...');
+                const newCookie = await authenticateWithRetry(5, 're_auth');
+                client.updateCookie(newCookie);
+                runtime.log?.('[tlon] Re-authentication successful');
+            },
+        });
+    }
+    catch (error) {
+        await telemetry?.close();
+        throw error;
+    }
     // Configure @tloncorp/api's global client to use the SSE client's poke for all send operations
     configureTlonApiWithPoke(api.poke.bind(api), botShipName, account.url);
     // Publish the SSE-bound poke + ship coords so other module contexts (e.g.
@@ -251,11 +294,11 @@ export async function monitorTlonProvider(opts = {}) {
         once: true,
     });
     // Outer try/finally wraps everything from slot publication onward.
-    // The reviewer's P2: a synchronous throw between slot publication and
-    // the inner try at ~line 2719 (constructor, queue setup, bridge
-    // setup, channel discovery, future edits in this large pre-try
-    // region) would leave the shared slot orphaned. This outer finally
-    // catches all of those and runs cleanup unconditionally.
+    // A synchronous throw between slot publication and the inner try
+    // (constructor, queue setup, bridge setup, channel discovery, future
+    // edits in this large pre-try region) would leave the shared slot
+    // orphaned. This outer finally catches all of those and runs cleanup
+    // unconditionally.
     try {
         const computingPresence = createComputingPresenceTracker({ runtime });
         const processedTracker = createProcessedMessageTracker(2000);
@@ -279,10 +322,6 @@ export async function monitorTlonProvider(opts = {}) {
         let effectiveAutoAcceptGroupInvites = account.autoAcceptGroupInvites ?? false;
         let effectiveGroupInviteAllowlist = account.groupInviteAllowlist;
         let effectiveAutoDiscoverChannels = account.autoDiscoverChannels ?? false;
-        let effectiveOwnerShip = account.ownerShip
-            ? normalizeShip(account.ownerShip)
-            : null;
-        setEffectiveOwnerShip(account.accountId, effectiveOwnerShip);
         let effectiveOwnerListenEnabled = account.ownerListenEnabled ?? true;
         // Canonicalize on every read so an entry stored from a slightly-off user
         // input (e.g. missing "~" or wrong case) still matches incoming nest events.
@@ -313,9 +352,66 @@ export async function monitorTlonProvider(opts = {}) {
             clearPendingNudge(accountId);
             pendingNudgeRehydrated = true;
         };
-        const telemetry = createTlonTelemetry({
-            config: account.telemetry,
-            runtime,
+        // Bridge route-resolution telemetry from the global `message_sending` hook
+        // to this account's telemetry client. Reports every route-dependent send so
+        // we can measure how often a reply lands on webchat instead of Tlon.
+        setOutboundRouteReporter((event) => telemetry?.captureOutboundRoute({
+            ...event,
+            ownerShip: getEffectiveOwnerShip(account.accountId) ?? effectiveOwnerShip,
+            botShip: botShipName,
+        }));
+        setSessionTelemetryReporter((report) => {
+            switch (report.kind) {
+                case 'lifecycle':
+                    telemetry?.captureSessionLifecycle(report.event);
+                    break;
+                case 'watchdog':
+                    telemetry?.captureSessionWatchdog(report.event);
+                    break;
+                case 'recovery':
+                    telemetry?.captureSessionRecovery(report.event);
+                    break;
+            }
+        });
+        setErrorTelemetryReporter((report) => {
+            switch (report.kind) {
+                case 'harness':
+                    telemetry?.captureHarnessError({
+                        ...report.event,
+                        accountId: report.event.accountId ?? account.accountId,
+                        ownerShip: report.event.ownerShip ?? currentTelemetryOwnerShip(),
+                        botShip: report.event.botShip || botShipName,
+                    });
+                    break;
+                case 'plugin':
+                    telemetry?.capturePluginError({
+                        harness: 'openclaw',
+                        pluginErrorSource: report.event.pluginErrorSource,
+                        accountId: report.event.accountId ?? account.accountId,
+                        ownerShip: report.event.ownerShip ?? currentTelemetryOwnerShip(),
+                        botShip: report.event.botShip ?? botShipName,
+                        errorKind: report.event.errorKind ?? null,
+                        errorText: report.event.errorText,
+                        attempt: report.event.attempt ?? null,
+                    });
+                    break;
+                case 'telemetry':
+                    telemetry?.captureTelemetryError({
+                        harness: 'openclaw',
+                        telemetrySource: report.event.telemetrySource,
+                        sourceEventName: report.event.sourceEventName ?? null,
+                        sessionKey: report.event.sessionKey ?? null,
+                        sessionId: report.event.sessionId ?? null,
+                        runId: report.event.runId ?? null,
+                        accountId: report.event.accountId ?? account.accountId,
+                        agentId: report.event.agentId ?? null,
+                        ownerShip: report.event.ownerShip ?? currentTelemetryOwnerShip(),
+                        botShip: report.event.botShip ?? botShipName,
+                        errorKind: report.event.errorKind ?? null,
+                        errorText: report.event.errorText,
+                    });
+                    break;
+            }
         });
         // Track threads we've participated in (by parentId) - respond without mention requirement
         const participatedThreads = new Set();
@@ -698,12 +794,16 @@ export async function monitorTlonProvider(opts = {}) {
                             return;
                         }
                         catch (err) {
+                            capturePluginError('gateway_status_activation', err, {
+                                attempt,
+                            });
                             runtime.error?.(`[gateway-status] activation attempt ${attempt} failed: ${String(err)} — retrying in ${GATEWAY_STATUS_ACTIVATION_RETRY_MS / 1000}s`);
                         }
                         await abortableDelay(GATEWAY_STATUS_ACTIVATION_RETRY_MS, signal);
                     }
                 }
                 catch (err) {
+                    capturePluginError('gateway_status_activation', err);
                     runtime.error?.(`[gateway-status] start failed: ${String(err)}`);
                 }
             })();
@@ -1671,12 +1771,51 @@ export async function monitorTlonProvider(opts = {}) {
                     ReplyToId: String(parentId),
                 }),
             });
+            // ── Durable session-route persistence ───────────────────────
+            // The streamed reply below goes out through our own `deliver` callback
+            // and does not consult session metadata. But later route-dependent sends
+            // (the shared `message` tool, subagents, system-event turns) resolve
+            // their destination from the session store; without a persisted Tlon
+            // route they fall back to webchat. recordTlonRouteAndDispatch (below)
+            // records the route before dispatch and fails open — never blocks the
+            // reply.
+            const routeDebug = isRouteDebugEnabled()
+                ? (rec) => runtime.log?.(`[tlon][route-debug] inbound ${JSON.stringify({
+                    messageId,
+                    agentId: route.agentId,
+                    sessionKey: route.sessionKey,
+                    mainSessionKey: route.mainSessionKey,
+                    lastRoutePolicy: route.lastRoutePolicy,
+                    matchedBy: route.matchedBy,
+                    provider: ctxPayload.Provider,
+                    surface: ctxPayload.Surface,
+                    originatingChannel: ctxPayload.OriginatingChannel,
+                    originatingTo: ctxPayload.OriginatingTo,
+                    ctxSessionKey: ctxPayload.SessionKey,
+                    isGroup,
+                    groupChannel: groupChannel ?? null,
+                    senderShip,
+                    parentId: parentId ?? null,
+                    deliverParentId: deliverParentId ?? null,
+                    recordSessionKey: rec.recordSessionKey,
+                    lastRouteSessionKey: rec.lastRouteSessionKey,
+                    target: rec.target,
+                    hadUpdateLastRoute: Boolean(rec.updateLastRoute),
+                    pinWillSkip: routeUpdateWillSkipByPin(rec.updateLastRoute),
+                    skippedReason: rec.skippedReason ?? null,
+                })}`)
+                : undefined;
             const dispatchStartTime = Date.now();
+            const runId = randomUUID();
             const replyTelemetry = telemetry?.startReply({
                 sessionKey: route.sessionKey,
+                runId,
+                accountId: account.accountId,
+                agentId: route.agentId,
                 ownerShip: effectiveOwnerShip,
                 botShip: botShipName,
                 chatType: isGroup ? 'groupChannel' : 'dm',
+                destinationKind: isGroup ? 'groupChannel' : 'dm',
                 isThreadReply: Boolean(isThreadReply),
                 senderRole,
                 attachmentCount,
@@ -1685,9 +1824,16 @@ export async function monitorTlonProvider(opts = {}) {
             let selectedModel = null;
             let selectedThinkLevel = null;
             let deliveredMessageCount = 0;
+            let sendAttemptCount = 0;
+            let sendErrorCount = 0;
+            let sendErrorKind = null;
             let replyCharCount = 0;
             let replyWordCount = 0;
             let replyMediaCount = 0;
+            let deliverySkipReason = null;
+            const recordDeliverySkip = (reason) => {
+                deliverySkipReason ??= reason;
+            };
             const responsePrefix = core.channel.reply.resolveEffectiveMessagesConfig(cfg, route.agentId).responsePrefix;
             const humanDelay = core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId);
             const presenceConversationId = isGroup
@@ -1726,6 +1872,7 @@ export async function monitorTlonProvider(opts = {}) {
                 })
                 : undefined;
             const replyOptions = {
+                runId,
                 onModelSelected: ({ provider, model, thinkLevel }) => {
                     selectedProvider = provider;
                     selectedModel = model;
@@ -1752,8 +1899,29 @@ export async function monitorTlonProvider(opts = {}) {
             let dispatchResult;
             let dispatchError;
             try {
-                dispatchResult =
-                    await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                dispatchResult = await recordTlonRouteAndDispatch({
+                    session: core.channel.session,
+                    cfg,
+                    route,
+                    ctxPayload,
+                    ctxSessionKey: ctxPayload.SessionKey,
+                    isGroup,
+                    groupChannel,
+                    senderShip,
+                    parentId,
+                    deliverParentId,
+                    effectiveOwnerShip,
+                    effectiveDmAllowlist,
+                    messageId,
+                    sessionStore: cfg.session?.store,
+                    logError: (msg) => runtime.error?.(msg),
+                    // Routine skip / pin-skip diagnostics are debug-gated to avoid
+                    // high-volume logs for expected policy cases.
+                    logDebug: isRouteDebugEnabled()
+                        ? (msg) => runtime.log?.(msg)
+                        : undefined,
+                    onRecord: routeDebug,
+                    dispatch: () => core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                         ctx: ctxPayload,
                         cfg,
                         replyOptions,
@@ -1761,14 +1929,24 @@ export async function monitorTlonProvider(opts = {}) {
                             responsePrefix,
                             humanDelay,
                             typingCallbacks,
+                            onSkip: (_payload, info) => {
+                                recordDeliverySkip(info.reason);
+                            },
                             deliver: async (payload) => {
                                 let replyText = payload.text;
                                 if (!replyText) {
+                                    const hasMedia = Array.isArray(payload.mediaUrls)
+                                        ? payload.mediaUrls.length > 0
+                                        : Boolean(payload.mediaUrl);
+                                    recordDeliverySkip(hasMedia
+                                        ? 'media_only_payload_not_sent'
+                                        : 'empty_payload_text');
                                     return;
                                 }
                                 // Process any block directives in the response (strips them from text)
                                 replyText = await processBlockDirectives(replyText, senderShip);
                                 if (!replyText) {
+                                    recordDeliverySkip('block_directive_only');
                                     return;
                                 } // Response was only a directive
                                 // Use settings store value if set, otherwise fall back to file config
@@ -1786,13 +1964,26 @@ export async function monitorTlonProvider(opts = {}) {
                                     replyText = `${replyText}\n\n_[Generated by ${formatModelName(modelInfo)}]_`;
                                 }
                                 // Add addendum if this is the last response before bot rate limit
-                                if (isGroup && groupChannel && knownBotShips.has(senderShip)) {
+                                if (isGroup &&
+                                    groupChannel &&
+                                    knownBotShips.has(senderShip)) {
                                     const count = consecutiveBotMessages.get(groupChannel) ?? 0;
                                     if (maxBotResponses > 0 && count === maxBotResponses) {
                                         const otherBot = formatShipWithNickname(senderShip);
                                         replyText += `\n\n---\n_This is my last response to ${otherBot} for now. To continue our conversation, someone will need to mention me._`;
                                     }
                                 }
+                                if (isRouteDebugEnabled()) {
+                                    runtime.log?.(`[tlon][route-debug] deliver ${JSON.stringify({
+                                        messageId,
+                                        isGroup,
+                                        destination: isGroup
+                                            ? groupChannel ?? null
+                                            : senderShip,
+                                        deliverParentId: deliverParentId ?? null,
+                                    })}`);
+                                }
+                                sendAttemptCount += 1;
                                 if (isGroup && groupChannel) {
                                     // Send to any channel type (chat, heap, diary) using the nest directly
                                     await sendChannelPost({
@@ -1819,12 +2010,6 @@ export async function monitorTlonProvider(opts = {}) {
                                             : undefined,
                                     });
                                 }
-                                if (presenceConversationId) {
-                                    await computingPresence.stopRun({
-                                        conversationId: presenceConversationId,
-                                        runId: presenceRunId,
-                                    });
-                                }
                                 deliveredMessageCount += 1;
                                 replyCharCount += replyText.length;
                                 replyWordCount += replyText.trim()
@@ -1835,13 +2020,22 @@ export async function monitorTlonProvider(opts = {}) {
                                     : payload.mediaUrl
                                         ? 1
                                         : 0;
+                                if (presenceConversationId) {
+                                    await computingPresence.stopRun({
+                                        conversationId: presenceConversationId,
+                                        runId: presenceRunId,
+                                    });
+                                }
                             },
                             onError: (err, info) => {
                                 const dispatchDuration = Date.now() - dispatchStartTime;
+                                sendErrorCount += 1;
+                                sendErrorKind = info.kind;
                                 runtime.error?.(`[tlon] ${info.kind} reply failed after ${dispatchDuration}ms: ${String(err)}`);
                             },
                         },
-                    });
+                    }),
+                });
             }
             catch (error) {
                 dispatchError = error;
@@ -1849,6 +2043,9 @@ export async function monitorTlonProvider(opts = {}) {
             }
             finally {
                 await replyTelemetry?.capture({
+                    sendAttemptCount,
+                    sendErrorCount,
+                    sendErrorKind,
                     deliveredMessageCount,
                     replyCharCount,
                     replyWordCount,
@@ -1857,6 +2054,10 @@ export async function monitorTlonProvider(opts = {}) {
                     queuedFinal: dispatchResult?.queuedFinal ?? false,
                     queuedFinalCount: dispatchResult?.counts.final ?? 0,
                     queuedBlockCount: dispatchResult?.counts.block ?? 0,
+                    failedCounts: dispatchResult?.failedCounts,
+                    deliverySkipReason,
+                    sourceReplyDeliveryMode: dispatchResult?.sourceReplyDeliveryMode ?? null,
+                    beforeAgentRunBlocked: dispatchResult?.beforeAgentRunBlocked === true,
                     provider: selectedProvider,
                     model: selectedModel,
                     thinkLevel: selectedThinkLevel,
@@ -1956,6 +2157,8 @@ export async function monitorTlonProvider(opts = {}) {
                                 core.system.enqueueSystemEvent(eventText, {
                                     sessionKey: route.sessionKey,
                                     contextKey: `tlon:reaction:${nest}:${postId}:${reactEmoji}:${ship}`,
+                                    // Route any resulting system/heartbeat turn back to Tlon.
+                                    deliveryContext: tlonDeliveryContext(`tlon:${nest}`, route.accountId),
                                 });
                             }
                         }
@@ -2290,6 +2493,8 @@ export async function monitorTlonProvider(opts = {}) {
                                 core.system.enqueueSystemEvent(eventText, {
                                     sessionKey: route.sessionKey,
                                     contextKey: `tlon:dm-reaction:${messageId}:${reactEmoji}:${reactAuthor}:${action}`,
+                                    // Route any resulting system/heartbeat turn back to Tlon.
+                                    deliveryContext: tlonDeliveryContext(`tlon:${partnerShip || reactAuthor}`, route.accountId),
                                 });
                                 runtime.log?.(`[tlon] DM_REACTION: ${eventText}`);
                             }
@@ -2421,6 +2626,7 @@ export async function monitorTlonProvider(opts = {}) {
                 path: '/v4',
                 event: (data) => handleChannelsFirehose(data),
                 err: (error) => {
+                    capturePluginError('channels_firehose', error);
                     runtime.error?.(`[tlon] Channels firehose error: ${String(error)}`);
                 },
                 quit: () => {
@@ -2434,6 +2640,7 @@ export async function monitorTlonProvider(opts = {}) {
                 path: '/v4',
                 event: (data) => handleChatFirehose(data),
                 err: (error) => {
+                    capturePluginError('chat_firehose', error);
                     runtime.error?.(`[tlon] Chat firehose error: ${String(error)}`);
                 },
                 quit: () => {
@@ -2492,6 +2699,7 @@ export async function monitorTlonProvider(opts = {}) {
                     }
                 },
                 err: (error) => {
+                    capturePluginError('contacts_subscription', error);
                     runtime.error?.(`[tlon] Contacts subscription error: ${String(error)}`);
                 },
                 quit: () => {
@@ -2685,7 +2893,11 @@ export async function monitorTlonProvider(opts = {}) {
                                                     });
                                                     if (route?.sessionKey) {
                                                         const memberDisplay = formatShipWithNickname(ship);
-                                                        core.system.enqueueSystemEvent(`[${memberDisplay} joined group ${groupFlag}]`, { sessionKey: route.sessionKey });
+                                                        core.system.enqueueSystemEvent(`[${memberDisplay} joined group ${groupFlag}]`, {
+                                                            sessionKey: route.sessionKey,
+                                                            // Route any resulting system turn back to Tlon.
+                                                            deliveryContext: tlonDeliveryContext(`tlon:${nest}`, route.accountId),
+                                                        });
                                                         runtime.log?.(`[tlon] Member joined: ${ship} → ${groupFlag}`);
                                                         break; // Only inject once per group
                                                     }
@@ -2796,6 +3008,7 @@ export async function monitorTlonProvider(opts = {}) {
                         }
                     },
                     err: (error) => {
+                        capturePluginError('groups_ui_subscription', error);
                         runtime.error?.(`[tlon] Groups-ui subscription error: ${String(error)}`);
                     },
                     quit: () => {
@@ -2806,6 +3019,7 @@ export async function monitorTlonProvider(opts = {}) {
             }
             catch (err) {
                 // Groups-ui subscription is optional - channel discovery will still work via polling
+                capturePluginError('groups_ui_subscription', err);
                 runtime.log?.(`[tlon] Groups-ui subscription failed (will rely on polling): ${String(err)}`);
             }
             // Subscribe to foreigns for auto-accepting group invites
@@ -2925,6 +3139,7 @@ export async function monitorTlonProvider(opts = {}) {
                             })();
                         },
                         err: (error) => {
+                            capturePluginError('foreigns_subscription', error);
                             runtime.error?.(`[tlon] Foreigns subscription error: ${String(error)}`);
                         },
                         quit: () => {
@@ -2934,6 +3149,7 @@ export async function monitorTlonProvider(opts = {}) {
                     runtime.log?.('[tlon] Subscribed to foreigns (/v1/foreigns) for auto-accepting group invites');
                 }
                 catch (err) {
+                    capturePluginError('foreigns_subscription', err);
                     runtime.log?.(`[tlon] Foreigns subscription failed: ${String(err)}`);
                 }
             }
@@ -2952,6 +3168,20 @@ export async function monitorTlonProvider(opts = {}) {
             runtime.log?.('[tlon] All subscriptions registered, connecting to SSE stream...');
             await api.connect();
             runtime.log?.('[tlon] Connected! Firehose subscriptions active');
+            telemetry?.captureGatewayConnected({
+                ownerShip: effectiveOwnerShip,
+                botShip: botShipName,
+                tlonSkillVersion: await resolveTlonSkillVersion(),
+                accountId: account.accountId,
+                configured: account.configured,
+                watchedChannelCount: watchedChannels.size,
+                dmAllowlistCount: effectiveDmAllowlist.length,
+                defaultAuthorizedShipsCount: (currentSettings.defaultAuthorizedShips ??
+                    account.defaultAuthorizedShips).length,
+                pendingApprovalCount: pendingApprovals.length,
+                autoDiscoverChannels: effectiveAutoDiscoverChannels,
+                ownerListenEnabled: effectiveOwnerListenEnabled,
+            });
             // Periodically refresh channel discovery
             const pollInterval = setInterval(async () => {
                 if (!opts.abortSignal?.aborted) {
@@ -2985,6 +3215,7 @@ export async function monitorTlonProvider(opts = {}) {
                     });
                 }
                 catch (err) {
+                    capturePluginError('settings_refresh', err);
                     runtime.error?.(`[tlon] Settings refresh failed: ${String(err)}`);
                 }
             }, SETTINGS_REFRESH_INTERVAL_MS);
@@ -3077,6 +3308,9 @@ export async function monitorTlonProvider(opts = {}) {
             await ownerReplyPersistence.flush();
             await pendingNudgePersistence.flush();
             clearShadowsForAccount(account.accountId);
+            setOutboundRouteReporter(null);
+            setSessionTelemetryReporter(null);
+            setErrorTelemetryReporter(null);
             await telemetry?.close();
             try {
                 await api?.close();