@llblab/pi-kit 0.35.0 → 0.35.2

package/node_modules/@llblab/pi-telegram/lib/bus-follower.ts

@@ -111,6 +111,7 @@ import * as WorkspaceIdentity from "./workspace-identity.ts";
 const TELEGRAM_BUS_FOLLOWER_PROMOTION_GRACE_MS = 2_500;
 const TELEGRAM_FOLLOWER_SESSION_HANDOFF_TTL_MS = 30_000;
 const TELEGRAM_BUS_FOLLOWER_CLIENT_TIMEOUT_MS = 30_000;
+const TELEGRAM_BUS_FOLLOWER_API_SLOW_CALL_MS = 1_500;
 const TELEGRAM_BUS_FOLLOWER_REGISTRATION_WAIT_MS = 30_000;
 export const TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS =
   TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS;
@@ -326,6 +327,20 @@ export interface TelegramBusFollowerClientRuntimeDeps<TMessage = unknown> {
   timeoutMs?: number;
 }
 
+/** Structural port for run-collapsing diagnostics, implemented by the logging domain. */
+export interface TelegramFailureRunLogPort {
+  record: (error: unknown, details?: Record<string, unknown>) => boolean;
+  settled: () => TelegramFailureRunSummaryPort | undefined;
+  reset: () => void;
+}
+
+export interface TelegramFailureRunSummaryPort {
+  signature: string;
+  failedAttempts: number;
+  suppressedFailures: number;
+  failedForMs: number;
+}
+
 export interface TelegramBusFollowerApiCallerDeps {
   socketPath: TelegramBusSocketPathSource;
   instanceId: string;
@@ -337,11 +352,23 @@ export interface TelegramBusFollowerApiCallerDeps {
   ) => Promise<string | undefined>;
   getNowMs?: () => number;
   timeoutMs?: number;
+  /** Receives one diagnostic per call slower than `slowCallMs`; observation only. */
+  recordRuntimeEvent?: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
+  slowCallMs?: number;
 }
 
 export interface TelegramBusFollowerRegistrationRuntimeDeps<
   TContext extends { cwd?: string },
 > {
+  /**
+   * Collapses one sustained heartbeat failure run. Optional at this unit boundary, where an absent port records
+   * every failure; the runtime assembly requires it so production always supplies the logging domain's owner.
+   */
+  failureLog?: TelegramFailureRunLogPort;
   instanceId: string;
   createRequestId: () => string;
   protocolIdentity: TelegramBusProtocolIdentity;
@@ -673,6 +700,8 @@ export interface TelegramBusFollowerRuntimeAssemblyPorts<
   TContext extends { cwd?: string },
 > {
   instanceId: string;
+  /** Collapses one sustained heartbeat failure run; the composition root supplies the logging domain's owner. */
+  failureLog: TelegramFailureRunLogPort;
   registrationState: TelegramBusFollowerRegistrationState;
   recordRuntimeEvent: (
     category: string,
@@ -789,6 +818,7 @@ export function createTelegramBusFollowerRuntimeAssembly<
   });
   registration = createTelegramBusFollowerRegistrationRuntime({
     ...ports.registration,
+    failureLog: ports.failureLog,
     ...sharedRuntimeDeps,
     startReceiving: receiver.start,
     stopReceiving: receiver.stop,
@@ -1495,6 +1525,7 @@ export function createTelegramBusFollowerClientRuntime<
       instanceId: deps.instanceId,
       getAuthSecret: deps.getApiAuthSecret,
       getRegistrationGeneration: deps.getRegistrationGeneration,
+      recordRuntimeEvent: deps.recordRuntimeEvent,
     }),
     agentMessages: createTelegramBusAgentMessageClient({
       ...sharedClientDeps,
@@ -1881,7 +1912,13 @@ export function createTelegramBusFollowerApiCaller(
 ): (method: string, args: unknown[], localOptions?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<unknown> {
   const getNowMs = deps.getNowMs ?? Date.now;
   const timeoutMs = deps.timeoutMs ?? TELEGRAM_BUS_FOLLOWER_CLIENT_TIMEOUT_MS;
-  return async (method, args, localOptions) => {
+  const slowCallMs = deps.slowCallMs ?? TELEGRAM_BUS_FOLLOWER_API_SLOW_CALL_MS;
+  const caller = async (
+    method: string,
+    args: unknown[],
+    localOptions: Pick<TelegramApiCallOptions, "assertAuthority"> | undefined,
+    timing: { registeredAtMs?: number },
+  ): Promise<unknown> => {
     const assertion = localOptions?.assertAuthority;
     const assertCurrent = () => assertTelegramApiCallAuthority(assertion, false);
     assertCurrent();
@@ -1889,6 +1926,7 @@ export function createTelegramBusFollowerApiCaller(
       deps,
       timeoutMs,
     );
+    timing.registeredAtMs = getNowMs();
     assertCurrent();
     const socketPath = resolveTelegramBusSocketPath(deps.socketPath);
     let response: TelegramBusEnvelope | undefined;
@@ -1950,6 +1988,45 @@ export function createTelegramBusFollowerApiCaller(
     }
     throw new Error(message ?? "Telegram bus API call failed.");
   };
+  return async (method, args, localOptions) => {
+    const startedAtMs = getNowMs();
+    const timing: { registeredAtMs?: number } = {};
+    let outcome = "ok";
+    try {
+      return await caller(method, args, localOptions, timing);
+    } catch (error) {
+      outcome = "error";
+      throw error;
+    } finally {
+      const elapsedMs = getNowMs() - startedAtMs;
+      if (elapsedMs >= slowCallMs) {
+        const apiMethod =
+          (method === "call" || method === "callMultipart") &&
+          typeof args[0] === "string"
+            ? args[0]
+            : method;
+        try {
+          deps.recordRuntimeEvent?.(
+            "bus",
+            `Telegram bus follower API call was slow (${elapsedMs}ms).`,
+            {
+              phase: "follower-api-slow",
+              method: apiMethod,
+              elapsedMs,
+              registrationWaitMs:
+                (timing.registeredAtMs ?? getNowMs()) - startedAtMs,
+              ...(timing.registeredAtMs === undefined
+                ? {}
+                : { transportMs: getNowMs() - timing.registeredAtMs }),
+              outcome,
+            },
+          );
+        } catch {
+          // Diagnostics cannot change the API call outcome.
+        }
+      }
+    }
+  };
 }
 
 async function resolveTelegramBusFollowerRegistration(
@@ -2521,10 +2598,16 @@ export function createTelegramBusFollowerHeartbeatRecoveryHandler<TContext>(
       election: TelegramBusFollowerElection,
     ) => {
       if (!isCurrent()) return;
-      const activeCtx = deps.getActiveContext?.();
-      if (deps.getActiveContext && activeCtx !== ctx) {
-        scheduleRecovery(reason, ctx, binding);
-        return;
+      if (deps.getActiveContext) {
+        // Pi hands every event and command a fresh context object, so a manually connected follower never holds
+        // the stored session object. Promote through the live session context instead of rescheduling: heartbeat
+        // failures re-request recovery faster than the retry grace, so a reschedule-only path never fires.
+        const activeCtx = deps.getActiveContext();
+        if (!activeCtx) {
+          scheduleRecovery(reason, ctx, binding);
+          return;
+        }
+        ctx = activeCtx;
       }
       deps.setLifecyclePhase("electing");
       safeUpdateStatus(ctx);
@@ -2765,6 +2848,8 @@ export function createTelegramBusFollowerRegistrationRuntime<
     (!deps.registrationState ||
       deps.registrationState.getGeneration() === generation);
   const stopHeartbeat = () => {
+    // A stopped heartbeat ends the current failure run, so a later run logs its own first failure.
+    heartbeatFailureLog.reset();
     if (!heartbeatInterval) return;
     clearInterval(heartbeatInterval);
     heartbeatInterval = undefined;
@@ -2793,6 +2878,22 @@ export function createTelegramBusFollowerRegistrationRuntime<
       }
     });
   };
+  /** A sustained leader outage repeats one identical failure every interval; the port collapses the run. */
+  const heartbeatFailureLog: TelegramFailureRunLogPort =
+    deps.failureLog ?? {
+      record(error) {
+        try {
+          deps.recordRuntimeEvent?.("bus", error, {
+            phase: "follower-heartbeat",
+          });
+        } catch {
+          // Diagnostics cannot replace heartbeat recovery.
+        }
+        return true;
+      },
+      settled: () => undefined,
+      reset: () => undefined,
+    };
   const sendHeartbeat = async () => {
     const leaderSocketPath = activeLeaderSocketPath;
     const registrationGeneration = activeRegistrationGeneration;
@@ -2818,6 +2919,7 @@ export function createTelegramBusFollowerRegistrationRuntime<
       );
       if (!isCurrentHeartbeat()) return;
       if (response?.kind === "bus.ack" && response.ok) {
+        heartbeatFailureLog.settled();
         const heartbeatResult = isRecord(response.result)
           ? response.result
           : undefined;
@@ -2850,13 +2952,7 @@ export function createTelegramBusFollowerRegistrationRuntime<
       }
     } catch (error) {
       if (!isCurrentHeartbeat()) return;
-      try {
-        deps.recordRuntimeEvent?.("bus", error, {
-          phase: "follower-heartbeat",
-        });
-      } catch {
-        // Diagnostics cannot replace heartbeat recovery.
-      }
+      heartbeatFailureLog.record(error);
       if (!heartbeatContext) return;
       try {
         await deps.onHeartbeatFailure?.(error, heartbeatContext);
@@ -3120,11 +3216,11 @@ export function createTelegramBusFollowerRegistrationRuntime<
       return false;
     },
     setContext(ctx) {
+      // Pi hands every event a fresh context object. Only a replaced session drops an in-flight attempt.
       if (
         registrationAttempt &&
-        (registrationAttempt.ctx !== ctx ||
-          registrationAttempt.sessionGeneration !==
-            deps.getSessionGeneration?.() ||
+        (registrationAttempt.sessionGeneration !==
+          deps.getSessionGeneration?.() ||
           registrationAttempt.sessionId !== deps.getSessionId?.(ctx))
       )
         registrationAttempt = undefined;

package/node_modules/@llblab/pi-telegram/lib/bus-leader.ts

@@ -167,6 +167,7 @@ export interface TelegramBusFollowerTargetProvisionerDeps {
   callApi: <TResponse>(
     method: string,
     body: Record<string, unknown>,
+    options?: TelegramApiCallOptions,
   ) => Promise<TResponse>;
   getCurrentLeaderEpoch?: () => number | string | undefined;
   getSyncState: () => Sync.TelegramSyncState;
@@ -1925,6 +1926,8 @@ export function createTelegramBusFollowerTargetProvisioner(
               text: connectedAnnouncement.text,
               parse_mode: connectedAnnouncement.parseMode,
             },
+            // A deleted Thread is this probe's expected answer; the recovery below records it.
+            { isExpectedError: Threads.isTelegramTopicTargetStaleError },
           );
           assertRestoreRegistration();
           if (recoverableTarget || probeRequiredRecord) {
@@ -1968,7 +1971,19 @@ export function createTelegramBusFollowerTargetProvisioner(
               error instanceof Error ? error.message : String(error),
             );
             await deps.topicTargetStore.persist();
+            const staleTarget = result.target;
             result = await provisionTarget();
+            deps.recordRuntimeEvent(
+              "telegram",
+              "Telegram follower restore probe found its Thread deleted; re-created it.",
+              {
+                phase: "topic-lifecycle-restore-probe-recreated",
+                instanceId: registration.instanceId,
+                chatId: staleTarget.chatId,
+                staleThreadId: staleTarget.threadId,
+                threadId: result.target.threadId,
+              },
+            );
             connectedAnnouncement =
               createTelegramBusInstanceLifecycleAnnouncement({
                 target: result.target,

package/node_modules/@llblab/pi-telegram/lib/bus.ts

@@ -3297,33 +3297,42 @@ export async function sendTelegramBusLocalEnvelope(
   };
   const attempts = Math.max(1, resolvedOptions.retry?.attempts ?? 1);
   const delayMs = Math.max(0, resolvedOptions.retry?.delayMs ?? 0);
+  // Log the first failure, then only the outcome: a reloading leader would otherwise log every attempt.
   for (let attempt = 1; ; attempt += 1) {
     try {
-      return await sendTelegramBusLocalEnvelopeOnce(resolvedOptions);
+      const response = await sendTelegramBusLocalEnvelopeOnce(resolvedOptions);
+      if (attempt > 1)
+        resolvedOptions.recordTransportEvent?.("client-recovered", {
+          ...getTelegramBusEndpointDiagnostics(resolvedOptions.socketPath),
+          ...getTelegramBusEnvelopeDiagnostics(resolvedOptions.envelope),
+          attempt,
+          attempts,
+        });
+      return response;
     } catch (error) {
       const info = classifyTelegramBusTransportError(error);
-      resolvedOptions.recordTransportEvent?.("client-failed", {
-        ...getTelegramBusEndpointDiagnostics(resolvedOptions.socketPath),
-        ...getTelegramBusEnvelopeDiagnostics(resolvedOptions.envelope),
-        attempt,
-        attempts,
-        ...info,
-      });
-      if (
+      const final =
         error instanceof TelegramBusLocalAuthorityError ||
         attempt >= attempts ||
-        !isRetryableTelegramBusTransportError(error)
-      ) {
-        throw error;
-      }
-      resolvedOptions.recordTransportEvent?.("client-retry", {
-        ...getTelegramBusEndpointDiagnostics(resolvedOptions.socketPath),
-        ...getTelegramBusEnvelopeDiagnostics(resolvedOptions.envelope),
-        attempt,
-        attempts,
-        delayMs,
-        ...info,
-      });
+        !isRetryableTelegramBusTransportError(error);
+      if (attempt === 1 || final)
+        resolvedOptions.recordTransportEvent?.("client-failed", {
+          ...getTelegramBusEndpointDiagnostics(resolvedOptions.socketPath),
+          ...getTelegramBusEnvelopeDiagnostics(resolvedOptions.envelope),
+          attempt,
+          attempts,
+          ...info,
+        });
+      if (final) throw error;
+      if (attempt === 1)
+        resolvedOptions.recordTransportEvent?.("client-retry", {
+          ...getTelegramBusEndpointDiagnostics(resolvedOptions.socketPath),
+          ...getTelegramBusEnvelopeDiagnostics(resolvedOptions.envelope),
+          attempt,
+          attempts,
+          delayMs,
+          ...info,
+        });
       await delayTelegramBusTransportRetry(delayMs);
     }
   }

package/node_modules/@llblab/pi-telegram/lib/commands.ts

@@ -2281,6 +2281,8 @@ export interface TelegramSelectedCommandAdmission {
   /** Independent exact recipient/target lifetime, including inside captured menu transport adapters. */
   assertRecipientCurrent(): void;
   reportCompleted(): boolean;
+  /** Optional recipient release barrier after acceptance; rejection suppresses effects without replay. */
+  beforeEffects?(): Promise<void>;
 }
 
 /**
@@ -3068,7 +3070,8 @@ export function createTelegramCommandHandler<
           ? copySelectedMenuCarrier(original)
           : copySelectedReplyAnchor(original);
     const assertRecipientCurrent = admission.assertRecipientCurrent,
-      report = admission.reportCompleted;
+      report = admission.reportCompleted,
+      beforeEffects = admission.beforeEffects;
     const effects: TelegramHeldCommandEffects<TContext> | undefined =
       parsed.name === "status"
         ? undefined
@@ -3100,8 +3103,11 @@ export function createTelegramCommandHandler<
         throw new Error(`Selected ${parsed.name} plan owner is unavailable.`);
     };
     return issueSelectedOnce(assertCurrent, async () => {
-      if (plan.completion === "before-effect" && !report.call(admission))
-        return false;
+      if (plan.completion === "before-effect") {
+        if (!report.call(admission)) return false;
+        if (beforeEffects) await beforeEffects();
+        assertRecipientCurrent();
+      }
       return prepared.run({
         message,
         command: parsed,
@@ -3137,7 +3143,8 @@ export function createTelegramCommandHandler<
         from: { ...original.from },
       };
       const assertRecipientCurrent = admission.assertRecipientCurrent,
-        reportCompleted = admission.reportCompleted;
+        reportCompleted = admission.reportCompleted,
+        beforeEffects = admission.beforeEffects;
       const assertAdmissionCurrent = createSelectedSemanticGuard(
         admission,
         () => captured.assertExecutionCurrent?.(original),
@@ -3163,7 +3170,7 @@ export function createTelegramCommandHandler<
               );
             },
           },
-          { assertSemanticCurrent, assertRecipientCurrent, reportCompleted },
+          { assertSemanticCurrent, assertRecipientCurrent, reportCompleted, beforeEffects },
         ),
       );
     };
@@ -3607,6 +3614,7 @@ export function createTelegramCommandHandler<
       const assertSourceCurrent = admission.assertSourceCurrent,
         assertRecipientCurrent = admission.assertRecipientCurrent;
       const reportCompleted = admission.reportCompleted,
+        beforeEffects = admission.beforeEffects,
         assertExecutionCurrent = deps.assertExecutionCurrent;
       const assertIssuanceCurrent = () => {
         assertSourceCurrent.call(admission);
@@ -3639,9 +3647,12 @@ export function createTelegramCommandHandler<
       };
       return issueSelectedOnce(
         assertIssuanceCurrent,
-        async () =>
-          reportCompleted.call(admission) &&
-          handleTelegramCommandRuntime(name, message, ctx, recipientDeps, args),
+        async () => {
+          if (!reportCompleted.call(admission)) return false;
+          if (beforeEffects) await beforeEffects();
+          assertRecipientCurrent();
+          return handleTelegramCommandRuntime(name, message, ctx, recipientDeps, args);
+        },
       );
     },
   });
@@ -3766,6 +3777,7 @@ async function handleTelegramHelpCommand<
     assertSemanticCurrent(): void;
     assertRecipientCurrent(): void;
     reportCompleted(): boolean;
+    beforeEffects?(): Promise<void>;
   },
 ): Promise<boolean> {
   const assertSemanticCurrent =
@@ -3788,6 +3800,7 @@ async function handleTelegramHelpCommand<
   if (admission) {
     assertSemanticCurrent();
     if (!admission.reportCompleted()) return false;
+    if (admission.beforeEffects) await admission.beforeEffects();
     admission.assertRecipientCurrent();
   }
   const assertEffectCurrent =

package/node_modules/@llblab/pi-telegram/lib/extension.ts

@@ -861,6 +861,12 @@ export default function (pi: Pi.ExtensionAPI) {
   const promptDispatchRuntime = Runtime.createTelegramPromptDispatchRuntime({
     lifecycle,
     typing,
+    failureLog: runtimeDiagnostics.createFailureLog({
+      category: "typing",
+      failurePhase: "typing-presence",
+      outcomePhase: "typing-presence-recovered",
+      label: "typing presence",
+    }),
     getDefaultChatId: proactivePushChatIdGetter,
     isThreadedMode() {
       return deliveryTargetPolicyRuntime.getTargetPolicyView().threaded === true;
@@ -1302,6 +1308,32 @@ export default function (pi: Pi.ExtensionAPI) {
     delivery: deliveryLifecycleRuntime,
     api: telegramApiTargetActivityRuntime,
   });
+  const prepareTemporaryThreadJournalInspection = function (
+    target: Targets.TelegramTarget,
+    requiredJournalBindingKeys: readonly string[],
+    ownInputs?: readonly Threads.TelegramTemporaryThreadInput[],
+  ): Parameters<typeof Journal.isTelegramThreadCleanupJournalNamespaceClear>[0] | undefined {
+    const binding = resolveTelegramUpdateJournalBinding();
+    const botToken = configStore.getBotToken();
+    if (!binding || !botToken) return undefined;
+    const profile = configStore.getActiveProfileName() ?? "default";
+    const botIdentity = Journal.createTelegramUpdateJournalBotIdentity({ botToken, botId: getTelegramBotId() });
+    return {
+      directory: Paths.resolveTelegramTempDir(), profile, botIdentity,
+      pollingPath: telegramLeaderJournalPath.resolve(configStore.getActiveProfileName()),
+      requiredJournalBindingKeys: [binding.recoveryKey, ...requiredJournalBindingKeys],
+      ...(target.threadId !== undefined && ownInputs
+        ? { cleanup: { target: { chatId: target.chatId, threadId: target.threadId }, ownInputs } } : {}),
+      limits: { maxDirectoryEntries: 10_000, maxFiles: 4096, maxBytes: 64 * 1024 * 1024,
+        maxEntries: 10_000, maxWork: 100_000 },
+      withSourceReference(path, operation) {
+        return telegramJournalReferenceRegistry.withReference({
+          referenceClass: "operator-disposition",
+          recoveryKey: Journal.createTelegramUpdateJournalBindingKey({ path, profileName: profile, botIdentity }),
+        }, operation);
+      },
+    };
+  };
   const inboundRouteRuntime = Routing.createTelegramInboundRouteRuntime({
     configStore,
     callApi: callTelegramApi,
@@ -1407,64 +1439,25 @@ export default function (pi: Pi.ExtensionAPI) {
         },
       );
     },
-    inspectTemporaryThreadSources(
-      target,
-      requiredJournalBindingKeys,
-      ownInputs,
-    ) {
-      const binding = resolveTelegramUpdateJournalBinding();
-      const botToken = configStore.getBotToken();
-      if (!binding || !botToken) return undefined;
-      const profile = configStore.getActiveProfileName() ?? "default";
-      const botIdentity = Journal.createTelegramUpdateJournalBotIdentity({
-        botToken,
-        botId: getTelegramBotId(),
-      });
+    inspectTemporaryThreadSources(target, requiredJournalBindingKeys, ownInputs) {
+      const input = prepareTemporaryThreadJournalInspection(target, requiredJournalBindingKeys, ownInputs);
+      if (!input) return undefined;
       return withTelegramJournalSourceSerialization(function () {
-        return Journal.isTelegramThreadCleanupJournalNamespaceClear({
-          directory: Paths.resolveTelegramTempDir(),
-          profile,
-          botIdentity,
-          pollingPath: telegramLeaderJournalPath.resolve(
-            configStore.getActiveProfileName(),
-          ),
-          requiredJournalBindingKeys: [
-            binding.recoveryKey,
-            ...requiredJournalBindingKeys,
-          ],
-          ...(target.threadId !== undefined && ownInputs
-            ? {
-                cleanup: {
-                  target: { chatId: target.chatId, threadId: target.threadId },
-                  ownInputs,
-                },
-              }
-            : {}),
-          limits: {
-            maxDirectoryEntries: 10_000,
-            maxFiles: 4096,
-            maxBytes: 64 * 1024 * 1024,
-            maxEntries: 10_000,
-            maxWork: 100_000,
-          },
-          withSourceReference(path, operation) {
-            return telegramJournalReferenceRegistry.withReference(
-              {
-                referenceClass: "operator-disposition",
-                recoveryKey: Journal.createTelegramUpdateJournalBindingKey({
-                  path,
-                  profileName: profile,
-                  botIdentity,
-                }),
-              },
-              operation,
-            );
-          },
-        })
-          ? []
-          : undefined;
+        return Journal.isTelegramThreadCleanupJournalNamespaceClear(input) ? [] : undefined;
       });
     },
+    recoverTemporaryThreadDeadQueueOwners(target, requiredJournalBindingKeys, ownInputs, isCurrent) {
+      const input = prepareTemporaryThreadJournalInspection(target, requiredJournalBindingKeys, ownInputs);
+      if (!input || !isCurrent()) return 0;
+      return Journal.recoverTelegramThreadCleanupDeadQueueOwners({
+          ...input, isCurrent, withSourceSerialization: withTelegramJournalSourceSerialization,
+          recoveryOwner: {
+            instanceId: telegramInstanceId, processId: telegramProcessId,
+            processBirthId: telegramQueueProcessBirthId,
+            sessionGeneration: telegramSessionContextStore.getGeneration(),
+          },
+        });
+    },
     hasWorkspaceRestoreAuthority() {
       return (
         lockRuntime.owns() &&
@@ -1589,12 +1582,14 @@ export default function (pi: Pi.ExtensionAPI) {
         target.threadId === undefined
       )
         return undefined;
+      // Pi creates a fresh context object per event and command, so authority follows the session, not the object.
+      const sessionGeneration = telegramSessionContextStore.getGeneration();
       return Threads.createTelegramWorkspaceThreadRenameRecipient({
         store: threadStore,
         instanceId: telegramInstanceId,
         target,
         assertAuthority() {
-          if (telegramSessionContextStore.get() !== ctx)
+          if (!telegramSessionContextStore.isCurrent(ctx, sessionGeneration))
             throw new Error("Telegram Thread name dialog lost Pi context.");
         },
         getAuthority: threadNameRecipientAuthority.getAuthority,
@@ -1981,6 +1976,12 @@ export default function (pi: Pi.ExtensionAPI) {
   const telegramBusFollowerAssembly: BusFollower.TelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext> =
     BusFollower.createTelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext>({
       instanceId: telegramInstanceId,
+      failureLog: runtimeDiagnostics.createFailureLog({
+        category: "bus",
+        failurePhase: "follower-heartbeat",
+        outcomePhase: "follower-heartbeat-recovered",
+        label: "follower heartbeat",
+      }),
       registrationState: telegramBusFollowerRegistrationState,
       recordRuntimeEvent,
       receiver: {
@@ -2383,6 +2384,12 @@ export default function (pi: Pi.ExtensionAPI) {
       Locks.TelegramLockEntry
     >({
       state: telegramThreadCapabilityState,
+      failureLog: runtimeDiagnostics.createFailureLog({
+        category: "bus",
+        failurePhase: "capability-monitor",
+        outcomePhase: "capability-monitor-recovered",
+        label: "Threaded Mode capability probe",
+      }),
       getAllowedUserId: configStore.getAllowedUserId,
       callApi: callTelegramApi,
       topicTargetStore: threadStore,
@@ -3071,6 +3078,7 @@ export default function (pi: Pi.ExtensionAPI) {
     deleteMessage: deleteTelegramMessage,
     sendGuestReply,
     editGuestReply,
+    editGuestInlineMessage: telegramApiRuntime.editGuestInlineMessage,
     stopGuestPlaceholder: guestPlaceholderRuntime.stop,
     finalizeMarkdownPreview,
     preparePreviewDelivery,