@llblab/pi-telegram 0.51.5 → 0.52.0

package/lib/channel-posts.ts

@@ -8,12 +8,18 @@ import { chmodSync, closeSync, constants, createReadStream, fstatSync, lstatSync
   readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { lstat } from "node:fs/promises";
 import { basename, dirname } from "node:path";
+import { getTelegramJournalPublicationPaths } from "./paths.ts";
 import { createHash, randomUUID } from "node:crypto";
 
 import { Type } from "@sinclair/typebox";
 
 import { renameTelegramPathWithRetry, withTelegramFileTransaction } from "./locks.ts";
 import type { ExtensionAPI } from "./pi.ts";
+import {
+  isWireRecord as isRecord,
+  hasOnlyWireKeys as hasOnlyKeys,
+  isNonNegativeWireInteger as isSafeTime,
+} from "./wire.ts";
 
 const CHANNEL_POST_JOURNAL_VERSION = 1;
 const DEFAULT_MAX_RECORDS = 256;
@@ -31,12 +37,12 @@ export interface TelegramChannelPostMediaIntent {
   sha256: string;
 }
 
-export const TELEGRAM_CHANNEL_POST_MEDIA_MAX_BYTES: Record<TelegramChannelPostMediaKind, number> = {
+const TELEGRAM_CHANNEL_POST_MEDIA_MAX_BYTES: Record<TelegramChannelPostMediaKind, number> = {
   photo: 10 * 1024 * 1024,
   video: 50 * 1024 * 1024,
 };
-export const TELEGRAM_CHANNEL_POST_CAPTION_MAX_LENGTH = 1024;
-export const TELEGRAM_CHANNEL_POST_MEDIA_FILE_NAME_MAX_LENGTH = 255;
+const TELEGRAM_CHANNEL_POST_CAPTION_MAX_LENGTH = 1024;
+const TELEGRAM_CHANNEL_POST_MEDIA_FILE_NAME_MAX_LENGTH = 255;
 
 /** Safe, content-free local validation failure for channel media publication intent. */
 export class TelegramChannelPostValidationError extends Error {
@@ -195,6 +201,7 @@ interface TelegramChannelPostJournalFile {
 
 export interface TelegramChannelPostJournalStoreOptions {
   path: string;
+  runtimeDir?: string;
   profileName: string;
   tokenSha256: string;
   maxRecords?: number;
@@ -329,19 +336,6 @@ export function registerTelegramChannelPostListTool(
   });
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-function hasOnlyKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
-  const allowed = new Set(keys);
-  return Object.keys(value).every(key => allowed.has(key));
-}
-
-function isSafeTime(value: unknown): value is number {
-  return Number.isSafeInteger(value) && (value as number) >= 0;
-}
-
 function normalizeChannel(value: unknown): TelegramChannelPostAddress {
   if (Number.isSafeInteger(value) && (value as number) < 0) return value as number;
   if (typeof value === "string" && /^@[A-Za-z0-9_]{5,32}$/u.test(value)) {
@@ -454,9 +448,24 @@ function validateRecord(value: unknown): TelegramChannelPostRecord {
   throw new TelegramChannelPostJournalError("invalid", "Telegram channel post journal contains an invalid state.");
 }
 
+function parseTelegramChannelPostJournalFile(value: unknown, profileName: string, tokenSha256: string): TelegramChannelPostJournalFile {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["version", "profile", "tokenSha256", "records"]) ||
+      value.version !== CHANNEL_POST_JOURNAL_VERSION || value.profile !== profileName ||
+      value.tokenSha256 !== tokenSha256 || !Array.isArray(value.records)) {
+    throw new TelegramChannelPostJournalError("conflict", "Telegram channel post journal identity or schema does not match.");
+  }
+  const records = value.records.map(validateRecord);
+  if (new Set(records.map(record => record.operationId)).size !== records.length) {
+    throw new TelegramChannelPostJournalError("invalid", "Telegram channel post journal contains duplicate operation IDs.");
+  }
+  return { version: CHANNEL_POST_JOURNAL_VERSION, profile: profileName, tokenSha256, records };
+}
+
 export function createTelegramChannelPostJournalStore(
   options: TelegramChannelPostJournalStoreOptions,
 ): TelegramChannelPostJournalStore {
+  options = { ...options };
+  const publicationPaths = getTelegramJournalPublicationPaths(options.path, options.runtimeDir);
   const maxRecords = options.maxRecords ?? DEFAULT_MAX_RECORDS;
   const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
   const now = options.getNowMs ?? Date.now;
@@ -491,17 +500,7 @@ export function createTelegramChannelPostJournalStore(
         throw new TelegramChannelPostJournalError("conflict", "Telegram channel post journal changed during inspection.");
       }
       const value = JSON.parse(readFileSync(fd, "utf8")) as unknown;
-      if (!isRecord(value) || !hasOnlyKeys(value, ["version", "profile", "tokenSha256", "records"]) ||
-          value.version !== CHANNEL_POST_JOURNAL_VERSION || value.profile !== options.profileName ||
-          value.tokenSha256 !== options.tokenSha256 || !Array.isArray(value.records)) {
-        throw new TelegramChannelPostJournalError("conflict", "Telegram channel post journal identity or schema does not match.");
-      }
-      const records = value.records.map(validateRecord);
-      if (new Set(records.map(record => record.operationId)).size !== records.length) {
-        throw new TelegramChannelPostJournalError("invalid", "Telegram channel post journal contains duplicate operation IDs.");
-      }
-      return { version: CHANNEL_POST_JOURNAL_VERSION, profile: options.profileName,
-        tokenSha256: options.tokenSha256, records };
+      return parseTelegramChannelPostJournalFile(value, options.profileName, options.tokenSha256);
     } catch (error) {
       if (error instanceof TelegramChannelPostJournalError) throw error;
       throw new TelegramChannelPostJournalError("io", "Could not read Telegram channel post journal.", error);
@@ -517,8 +516,9 @@ export function createTelegramChannelPostJournalStore(
     if (Buffer.byteLength(serialized) > maxBytes) {
       throw new TelegramChannelPostJournalError("capacity", "Telegram channel post journal byte limit reached.");
     }
-    const temporaryPath = `${options.path}.${process.pid}.${randomUUID()}.tmp`;
+    const temporaryPath = `${publicationPaths.temporaryBasePath}.${process.pid}.${randomUUID()}.tmp`;
     mkdirSync(dirname(options.path), { recursive: true, mode: 0o700 });
+    mkdirSync(dirname(temporaryPath), { recursive: true, mode: 0o700 });
     try {
       writeFileSync(temporaryPath, serialized, { encoding: "utf8", mode: 0o600 });
       chmodSync(temporaryPath, 0o600);
@@ -532,7 +532,7 @@ export function createTelegramChannelPostJournalStore(
   };
   const mutate = <T>(operation: (file: TelegramChannelPostJournalFile) => T): T => {
     try {
-      return withTelegramFileTransaction(`${options.path}.transaction`, () => operation(read()));
+      return withTelegramFileTransaction(publicationPaths.transactionPath, () => operation(read()));
     } catch (error) {
       if (error instanceof TelegramChannelPostJournalError) throw error;
       throw new TelegramChannelPostJournalError("io", "Telegram channel post journal mutation failed.", error);

package/lib/command-templates.ts

@@ -121,7 +121,7 @@ function normalizeCommandTemplateDefaults(
   return normalized;
 }
 
-export function resolveInheritedDefaultReferences(
+function resolveInheritedDefaultReferences(
   ownDefaults: Record<string, unknown> | undefined,
   inheritedDefaults: Record<string, unknown> | undefined,
   runtimeValues: Record<string, unknown> = {},
@@ -142,7 +142,7 @@ export function resolveInheritedDefaultReferences(
   return resolved;
 }
 
-export function resolveCommandTemplateRepeat(
+function resolveCommandTemplateRepeat(
   value: number | string | undefined,
   values: Record<string, unknown> = {},
 ): number | undefined {
@@ -367,7 +367,7 @@ function pad(value: number, width: number): string {
   return String(value).padStart(width, "0");
 }
 
-export function getCommandTemplateRepeatDefaults(
+function getCommandTemplateRepeatDefaults(
   index: number,
   repeat: number,
 ): Record<string, string> {
@@ -516,7 +516,7 @@ function parseCommandTemplatePlaceholderContent(
   };
 }
 
-export function getCommandTemplateDefaults(
+function getCommandTemplateDefaults(
   config: CommandTemplateConfig | undefined,
 ): Record<string, string> {
   const normalizedConfig = config
@@ -588,7 +588,7 @@ export function splitCommandTemplate(input: string): string[] {
   return words;
 }
 
-export function expandCommandTemplateExecutable(
+function expandCommandTemplateExecutable(
   command: string,
   cwd: string,
 ): string {

package/lib/commands.ts

@@ -14,7 +14,7 @@ import {
 import type * as Pi from "./pi.ts";
 import type { ExtensionAPI, ExtensionCommandContext } from "./pi.ts";
 import { escapeHtml } from "./rendering.ts";
-import type { TelegramBridgeStatusLineOptions } from "./status.ts";
+import { formatTelegramConnectionFailure, type TelegramBridgeStatusLineOptions } from "./status.ts";
 import type { TelegramSessionReplacementIntent } from "./threads.ts";
 import {
   createTelegramControlItemBuilder,
@@ -91,11 +91,11 @@ function getOrCreateTelegramCommandRegistry(): TelegramExtensionCommandRegistry
   return registry;
 }
 
-export function normalizeTelegramExtensionCommandName(name: string): string {
+function normalizeTelegramExtensionCommandName(name: string): string {
   return name.trim().replace(/^\/+/, "").toLowerCase();
 }
 
-export function isTelegramExtensionCommandName(name: string): boolean {
+function isTelegramExtensionCommandName(name: string): boolean {
   return TELEGRAM_BOT_COMMAND_NAME_PATTERN.test(name);
 }
 
@@ -144,7 +144,7 @@ export function registerTelegramCommand(
   };
 }
 
-export function getTelegramExtensionCommands(): RegisteredTelegramExtensionCommand[] {
+function getTelegramExtensionCommands(): RegisteredTelegramExtensionCommand[] {
   return Array.from(
     getOrCreateTelegramCommandRegistry().commands.values(),
   ).sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
@@ -181,7 +181,7 @@ export const TELEGRAM_COMMAND_EMOJI = {
 
 export type TelegramCommandEmojiName = keyof typeof TELEGRAM_COMMAND_EMOJI;
 
-export function getTelegramCommandEmoji(
+function getTelegramCommandEmoji(
   command: TelegramCommandEmojiName,
 ): string {
   return TELEGRAM_COMMAND_EMOJI[command];
@@ -235,12 +235,12 @@ export function formatTelegramAutomaticThreadDisplayNameRestoredHeading(
   return `<b>✅ Automatic Thread display name restored as <i>${escapeHtml(name)}</i>.</b>`;
 }
 
-export const TELEGRAM_COMPACTION_STARTED_TEXT =
+const TELEGRAM_COMPACTION_STARTED_TEXT =
   formatTelegramInformationHeading(
     getTelegramCommandEmoji("compact"),
     "Compaction started.",
   );
-export const TELEGRAM_COMPACTION_COMPLETED_TEXT =
+const TELEGRAM_COMPACTION_COMPLETED_TEXT =
   formatTelegramInformationHeading("✅", "Compaction completed.");
 export const TELEGRAM_COMPACTION_STARTED_MARKDOWN =
   `**${formatTelegramCommandEmojiPrefix("compact")}Compaction started.**`;
@@ -254,7 +254,7 @@ function formatTelegramBotCommandDescription(
   return `${formatTelegramCommandEmojiPrefix(command)}${description}`;
 }
 
-export const TELEGRAM_BUILTIN_BOT_COMMANDS: readonly TelegramBotCommandDefinition[] =
+const TELEGRAM_BUILTIN_BOT_COMMANDS: readonly TelegramBotCommandDefinition[] =
   [
     {
       command: "start",
@@ -399,14 +399,24 @@ export interface TelegramBridgeCommandRegistrationDeps {
   recoverPollingStart?: (
     error: unknown,
   ) => Promise<TelegramPollingStartRecoveryResult>;
+  recordConnectionEvent?: (error: unknown, phase: string) => void;
   getDisconnectThreadName?: () => string | undefined;
   queueAgentConnectionContext?: (connected: boolean) => void;
   updateStatus: (ctx: ExtensionCommandContext) => void;
+  isContextCurrent?: (ctx: ExtensionCommandContext) => boolean;
+  getSessionGeneration?: () => number;
+  connectionIntent?: {
+    begin(cwd: string, profileName?: string): string;
+    finish(id: string): void;
+    isActive(id: string): boolean;
+    cancel(): void;
+  };
   getProfileNames?: () => string[];
-  activateDefaultProfileConfig?: (ctx: ExtensionCommandContext) => Promise<void>;
+  activateDefaultProfileConfig?: (ctx: ExtensionCommandContext, isCurrent: () => boolean) => Promise<void>;
   activateProfileConfig?: (
     ctx: ExtensionCommandContext,
     profileName: string,
+    isCurrent: () => boolean,
   ) => Promise<boolean>;
 }
 
@@ -504,6 +514,14 @@ export function registerTelegramBridgeCommands(
   pi.registerCommand("telegram-connect", {
     description: "<profile> — Start Telegram bridge",
     handler: async (args, ctx) => {
+      const sessionGeneration = deps.getSessionGeneration?.();
+      let intentId: string | undefined;
+      // Pi context getters throw after replacement; check plain intent/generation first.
+      const isCurrent = () =>
+        (!intentId || deps.connectionIntent?.isActive(intentId) !== false) &&
+        (sessionGeneration === undefined || deps.getSessionGeneration?.() === sessionGeneration) &&
+        deps.isContextCurrent?.(ctx) !== false;
+      if (!isCurrent()) return;
       if (args.trim().split(/\s+/).some((word) => /^as=/i.test(word))) {
         ctx.ui.notify(
           "Thread names are configured from Telegram, not from Pi commands.",
@@ -513,121 +531,141 @@ export function registerTelegramBridgeCommands(
         return;
       }
       const profileName = parseTelegramProfileArg(args);
-      if (profileName && deps.activateProfileConfig) {
-        const ok = await deps.activateProfileConfig(ctx, profileName);
-        if (!ok) {
-          ctx.ui.notify(`Profile "${profileName}" not found.`, "error");
-          deps.updateStatus(ctx);
-          return;
+      intentId = deps.connectionIntent?.begin(ctx.cwd, profileName);
+      try {
+        if (profileName && deps.activateProfileConfig) {
+          const ok = await deps.activateProfileConfig(ctx, profileName, isCurrent);
+          if (!isCurrent()) return;
+          if (!ok) {
+            ctx.ui.notify(`Profile "${profileName}" not found.`, "error");
+            deps.updateStatus(ctx);
+            return;
+          }
+          ctx.ui.notify(`Activated profile "${profileName}".`, "info");
+        } else {
+          await (deps.activateDefaultProfileConfig?.(ctx, isCurrent) ?? deps.reloadConfig());
+          if (!isCurrent()) return;
         }
-        ctx.ui.notify(`Activated profile "${profileName}".`, "info");
-      } else {
-        await (deps.activateDefaultProfileConfig?.(ctx) ?? deps.reloadConfig());
-      }
-      if (!deps.hasBotToken()) {
-        const botTokenDiagnostic = deps.getBotTokenDiagnostic?.();
-        if (botTokenDiagnostic) ctx.ui.notify(botTokenDiagnostic, "error");
-        const profileNames = deps.getProfileNames?.() ?? [];
-        if (!profileName && profileNames.length > 0) {
-          ctx.ui.notify(
-            `No default Telegram profile configured. Available profiles: ${profileNames.join(", ")}. Use /telegram-connect <profileName> or /telegram-setup to create a default profile.`,
-            "info",
-          );
-          deps.updateStatus(ctx);
+        if (!deps.hasBotToken()) {
+          const botTokenDiagnostic = deps.getBotTokenDiagnostic?.();
+          if (botTokenDiagnostic) ctx.ui.notify(botTokenDiagnostic, "error");
+          const profileNames = deps.getProfileNames?.() ?? [];
+          if (!profileName && profileNames.length > 0) {
+            ctx.ui.notify(
+              `No default Telegram profile configured. Available profiles: ${profileNames.join(", ")}. Use /telegram-connect <profileName> or /telegram-setup to create a default profile.`,
+              "info",
+            );
+            deps.updateStatus(ctx);
+            return;
+          }
+          await deps.promptForConfig(ctx, profileName);
           return;
         }
-        await deps.promptForConfig(ctx, profileName);
-        return;
-      }
-      let recoveryUsed = false;
-      const startWithRecovery = async (
-        options: TelegramBridgeCommandStartPollingOptions,
-      ): Promise<void | TelegramBridgeCommandStartPollingResult> => {
-        try {
-          return await deps.startPolling(ctx, options);
-        } catch (error) {
-          if (!deps.recoverPollingStart || recoveryUsed) throw error;
-          const recovery = await deps.recoverPollingStart(error);
-          if (recovery.kind === "unhandled") throw error;
-          if (recovery.kind === "blocked") {
-            return { ok: false, message: recovery.message };
-          }
-          recoveryUsed = true;
+        let recoveryUsed = false;
+        const startWithRecovery = async (
+          options: TelegramBridgeCommandStartPollingOptions,
+        ): Promise<void | (TelegramBridgeCommandStartPollingResult & { notice?: string })> => {
           try {
-            const retry = await deps.startPolling(ctx, options);
-            if (!retry) {
-              return { ok: true, message: recovery.message };
+            return await deps.startPolling(ctx, options);
+          } catch (error) {
+            if (!isCurrent()) return;
+            if (!deps.recoverPollingStart || recoveryUsed) throw error;
+            deps.recordConnectionEvent?.(error, "polling-start");
+            const recovery = await deps.recoverPollingStart(error);
+            if (!isCurrent()) return;
+            if (recovery.kind === "unhandled") throw error;
+            if (recovery.kind === "blocked") {
+              return { ok: false, message: recovery.message,
+                notice: "Telegram recovery blocked. Check /telegram-status --debug." };
+            }
+            recoveryUsed = true;
+            deps.recordConnectionEvent?.(recovery.message, "recovery");
+            try {
+              const retry = await deps.startPolling(ctx, options);
+              if (!isCurrent()) return;
+              if (!retry) return { ok: true, message: "Telegram bridge connected; temporary state recovered." };
+              return {
+                ...retry,
+                message: retry.ok
+                  ? "Telegram bridge connected; temporary state recovered."
+                  : retry.message,
+              };
+            } catch (error) {
+              if (!isCurrent()) return;
+              deps.recordConnectionEvent?.(error, "recovery-retry");
+              return {
+                ok: false,
+                notice: "Telegram recovery failed. Restart this Pi instance.",
+              };
             }
-            return {
-              ...retry,
-              message: retry.ok
-                ? `${recovery.message} ${retry.message ?? "Telegram bridge connected."}`
-                : retry.message,
-            };
-          } catch {
-            return {
-              ok: false,
-              message:
-                "Telegram temporary state was recovered, but the bridge could not restart. Restart this Pi instance and run /telegram-connect again.",
-            };
           }
+        };
+        let result = await startWithRecovery({ forceFreshLeaderThread: true });
+        if (!isCurrent()) return;
+        if (result && !result.ok && result.canTakeover) {
+          const confirmed = await ctx.ui.confirm(
+            formatTelegramTakeoverTitle(ctx),
+            formatTelegramTakeoverPrompt(ctx, result.owner),
+          );
+          if (!isCurrent()) return;
+          if (!confirmed) {
+            ctx.ui.notify("Telegram bridge takeover cancelled.", "info");
+            deps.updateStatus(ctx);
+            return;
+          }
+          result = await startWithRecovery({ force: true, forceFreshLeaderThread: true });
+          if (!isCurrent()) return;
         }
-      };
-      let result = await startWithRecovery({
-        forceFreshLeaderThread: true,
-      });
-      if (result && !result.ok && result.canTakeover) {
-        const confirmed = await ctx.ui.confirm(
-          formatTelegramTakeoverTitle(ctx),
-          formatTelegramTakeoverPrompt(ctx, result.owner),
-        );
-        if (!confirmed) {
-          ctx.ui.notify("Telegram bridge takeover cancelled.", "info");
-          deps.updateStatus(ctx);
-          return;
+        if (result && !result.ok) {
+          if (result.message) deps.recordConnectionEvent?.(result.message, "connect-refused");
+          ctx.ui.notify(result.notice ?? formatTelegramConnectionFailure(result.message), "warning");
+        } else if (result?.message) {
+          ctx.ui.notify(result.message, "info");
         }
-        result = await startWithRecovery({
-          force: true,
-          forceFreshLeaderThread: true,
-        });
-      }
-      if (result?.message) {
-        ctx.ui.notify(result.message, result.ok ? "info" : "warning");
-      }
-      if (!result || result.ok) {
-        deps.queueAgentConnectionContext?.(true);
+        if (!result || result.ok) deps.queueAgentConnectionContext?.(true);
+        deps.updateStatus(ctx);
+      } catch (error) {
+        if (!isCurrent()) return;
+        deps.recordConnectionEvent?.(error, "connect");
+        ctx.ui.notify(formatTelegramConnectionFailure(error), "warning");
+        deps.updateStatus(ctx);
+      } finally {
+        if (intentId) deps.connectionIntent?.finish(intentId);
       }
-      deps.updateStatus(ctx);
     },
   });
   pi.registerCommand("telegram-disconnect", {
     description: "Stop Telegram and delete current thread in Threaded Mode",
     handler: async (_args, ctx) => {
-      const threadName = deps.getDisconnectThreadName?.();
-      if (threadName) {
-        const confirmed = await ctx.ui.confirm(
-          ctx.ui.theme.fg("accent", "pi-telegram"),
-          `Delete Telegram thread ${ctx.ui.theme.fg("warning", threadName)} and disconnect this Pi session?`,
-        );
-        if (!confirmed) {
-          ctx.ui.notify("Telegram disconnect cancelled.", "info");
-          deps.updateStatus(ctx);
-          return;
-        }
-      }
+      const generation = deps.getSessionGeneration?.();
+      const isCurrent = () =>
+        (generation === undefined || deps.getSessionGeneration?.() === generation) &&
+        deps.isContextCurrent?.(ctx) !== false;
+      if (!isCurrent()) return;
+      deps.connectionIntent?.cancel();
       try {
+        const threadName = deps.getDisconnectThreadName?.();
+        if (threadName) {
+          const confirmed = await ctx.ui.confirm(
+            ctx.ui.theme.fg("accent", "pi-telegram"),
+            `Delete Telegram thread ${ctx.ui.theme.fg("warning", threadName)} and disconnect this Pi session?`,
+          );
+          if (!isCurrent()) return;
+          if (!confirmed) {
+            ctx.ui.notify("Telegram disconnect cancelled.", "info");
+            return;
+          }
+        }
         const message = await deps.stopPolling();
+        if (!isCurrent()) return;
         if (message) ctx.ui.notify(message, "info");
         deps.queueAgentConnectionContext?.(false);
       } catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        ctx.ui.notify(
-          `Telegram disconnect did not complete: ${detail} Keep this Pi session open, restore leader connectivity, inspect /telegram-status --debug, and retry /telegram-disconnect.`,
-          "warning",
-        );
-        throw error;
+        deps.recordConnectionEvent?.(error, "disconnect");
+        if (!isCurrent()) return;
+        ctx.ui.notify("Telegram disconnect incomplete; keep Pi open. Check /telegram-status --debug.", "warning");
       } finally {
-        deps.updateStatus(ctx);
+        if (isCurrent()) deps.updateStatus(ctx);
       }
     },
   });
@@ -1466,7 +1504,7 @@ export async function handleTelegramNextCommand(deps: {
   deps.updateStatus();
 }
 
-export async function handleTelegramContinueCommand<TMessage, TContext>(
+async function handleTelegramContinueCommand<TMessage, TContext>(
   message: TMessage,
   ctx: TContext,
   deps: {
@@ -1492,7 +1530,7 @@ function dispatchNextQueuedTelegramTurnAfterCompact(
   deps.dispatchNextQueuedTelegramTurn();
 }
 
-export function buildTelegramNewConfirmationReplyMarkup(): TelegramCompactConfirmationReplyMarkup {
+function buildTelegramNewConfirmationReplyMarkup(): TelegramCompactConfirmationReplyMarkup {
   return {
     inline_keyboard: [
       [
@@ -1503,7 +1541,7 @@ export function buildTelegramNewConfirmationReplyMarkup(): TelegramCompactConfir
   };
 }
 
-export function getTelegramNewConfirmationHtml(): string {
+function getTelegramNewConfirmationHtml(): string {
   return "<b>Start a new session?</b>";
 }
 
@@ -1550,7 +1588,7 @@ export async function handleTelegramNewConfirmationCallback<TContext>(
   return true;
 }
 
-export function buildTelegramCompactConfirmationReplyMarkup(): TelegramCompactConfirmationReplyMarkup {
+function buildTelegramCompactConfirmationReplyMarkup(): TelegramCompactConfirmationReplyMarkup {
   return {
     inline_keyboard: [
       [
@@ -1561,11 +1599,11 @@ export function buildTelegramCompactConfirmationReplyMarkup(): TelegramCompactCo
   };
 }
 
-export function getTelegramCompactConfirmationHtml(): string {
+function getTelegramCompactConfirmationHtml(): string {
   return "<b>Compact session?</b>";
 }
 
-export async function openTelegramCompactConfirmation(
+async function openTelegramCompactConfirmation(
   target: TelegramCommandMessageTarget,
   deps: TelegramCompactConfirmationDeps,
 ): Promise<void> {
@@ -2335,7 +2373,7 @@ export const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION =
 export const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE =
   "This internal Telegram command cannot be run manually.";
 
-export function delayTelegramSessionAction(delayMs: number): Promise<void> {
+function delayTelegramSessionAction(delayMs: number): Promise<void> {
   return new Promise<void>((resolve) => setTimeout(resolve, delayMs));
 }
 
@@ -2395,7 +2433,7 @@ export async function settleTelegramSessionReplacement(
   return "stale";
 }
 
-export function createTelegramSessionReplacementSettlementRuntime<TContext>(deps: {
+function createTelegramSessionReplacementSettlementRuntime<TContext>(deps: {
   resolve: (ctx: TContext) => TelegramSessionReplacementSettlementDeps | undefined;
   onResult?: (result: "none" | "settled" | "expired" | "failed" | "stale") => void;
   onError?: (error: unknown) => void;