@llblab/pi-kit 0.27.6 → 0.28.0

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

@@ -26,7 +26,7 @@ const TELEGRAM_GET_UPDATES_CONFLICT_FAST_RETRY_LIMIT = 3;
 const TELEGRAM_GET_UPDATES_CONFLICT_FAST_RETRY_MS = 1_000;
 const TELEGRAM_GET_UPDATES_CONFLICT_SLOW_RETRY_MS = 3_000;
 const TELEGRAM_POLLING_RETRY_MS = 3_000;
-export const TELEGRAM_GET_UPDATES_GRACE_MS = 10_000;
+const TELEGRAM_GET_UPDATES_GRACE_MS = 10_000;
 
 // Standard Telegram DM polling does not expose ordinary message-deletion events.
 // Business deletions belong to a separate namespace and default routing ignores them.
@@ -163,7 +163,7 @@ export function createTelegramPollingControllerState(): TelegramPollingControlle
   };
 }
 
-export function getTelegramPollingStateSnapshot(
+function getTelegramPollingStateSnapshot(
   state: TelegramPollingControllerState,
 ): TelegramPollingStateSnapshot {
   return {
@@ -906,7 +906,7 @@ export function createTelegramThreadCapabilityOrchestration<TContext, TOwner>(
   };
 }
 
-export async function readTelegramThreadCapability(
+async function readTelegramThreadCapability(
   deps: TelegramThreadCapabilityReaderDeps,
 ): Promise<boolean | undefined> {
   const bot = await deps.callApi<{ has_topics_enabled?: boolean }>("getMe", {});
@@ -915,7 +915,7 @@ export async function readTelegramThreadCapability(
   return undefined;
 }
 
-export async function probeTelegramStartupThreadCapability(
+async function probeTelegramStartupThreadCapability(
   deps: TelegramStartupThreadCapabilityProbeDeps,
   isCurrent: () => boolean = () => true,
 ): Promise<boolean | undefined> {
@@ -1201,7 +1201,7 @@ export function createTelegramThreadAwarePollingPorts<TContext, TOwner>(
   };
 }
 
-export function createTelegramThreadTargetObservationHandler<TContext>(
+function createTelegramThreadTargetObservationHandler<TContext>(
   deps: TelegramThreadCapabilityRuntimeDeps<TContext>,
 ): TelegramThreadTargetObservationHandler<TContext> {
   let transitionPending = false;

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

@@ -397,7 +397,7 @@ export function createTelegramPreviewController(
   };
 }
 
-export function createTelegramAssistantMessagePreviewHooks<TMessage>(
+function createTelegramAssistantMessagePreviewHooks<TMessage>(
   deps: TelegramAssistantMessagePreviewHookDeps<TMessage>,
 ): TelegramAssistantMessagePreviewHooks<TMessage> {
   return {
@@ -425,7 +425,7 @@ export function shouldSuppressPreviewForGuestTurn(
   return !!turn?.guestQueryId;
 }
 
-export async function handleTelegramAssistantMessagePreviewStart<TMessage>(
+async function handleTelegramAssistantMessagePreviewStart<TMessage>(
   message: TMessage,
   deps: TelegramAssistantMessagePreviewStartDeps<TMessage>,
 ): Promise<void> {
@@ -453,7 +453,7 @@ export async function handleTelegramAssistantMessagePreviewStart<TMessage>(
   deps.setState(next);
 }
 
-export async function handleTelegramAssistantMessagePreviewUpdate<TMessage>(
+async function handleTelegramAssistantMessagePreviewUpdate<TMessage>(
   message: TMessage,
   deps: TelegramAssistantMessagePreviewUpdateDeps<TMessage>,
 ): Promise<void> {

package/node_modules/@llblab/pi-telegram/lib/prompt-templates.ts

@@ -79,7 +79,7 @@ export function substitutePromptTemplateArgs(
   return result.replace(/\$ARGUMENTS/g, allArgs).replace(/\$@/g, allArgs);
 }
 
-export function isTelegramPromptTemplateCommandName(name: string): boolean {
+function isTelegramPromptTemplateCommandName(name: string): boolean {
   return TELEGRAM_BOT_COMMAND_NAME_PATTERN.test(name);
 }
 

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

@@ -7,6 +7,7 @@
 import { createHash } from "node:crypto";
 
 import { isVoiceTurn } from "./voice.ts";
+import { isWireRecord as isQueuePayloadRecord } from "./wire.ts";
 import { isTelegramApiCommitUnknownError } from "./telegram-api.ts";
 
 // --- Queue Items ---
@@ -147,7 +148,7 @@ export type TelegramQueueItem<TContext = unknown> =
   PendingTelegramTurn | PendingTelegramControlItem<TContext>;
 
 export const TELEGRAM_QUEUE_HANDOFF_PAYLOAD_MAX_BYTES = 8 * 1024 * 1024;
-export const TELEGRAM_QUEUE_HANDOFF_MAX_RECEIPTS = 256;
+const TELEGRAM_QUEUE_HANDOFF_MAX_RECEIPTS = 256;
 
 export interface TelegramQueueHandoffBase {
   chatId: number;
@@ -191,6 +192,63 @@ export interface TelegramQueueHandoff {
   payload: TelegramQueueHandoffPayload;
 }
 
+function parseQueuePayloadReceipt(value: unknown, kind: TelegramQueueItemKind): TelegramQueueAdmissionReceipt | undefined {
+  if (!isQueuePayloadRecord(value) || value.queueKind !== kind ||
+      typeof value.receiptId !== "string" || !value.receiptId ||
+      (value.journalBindingKey !== undefined && (typeof value.journalBindingKey !== "string" || !value.journalBindingKey.trim())) ||
+      !Array.isArray(value.sourceUpdateIds) || value.sourceUpdateIds.length === 0 ||
+      value.sourceUpdateIds.some((id, index) => !Number.isSafeInteger(id) || id < 0 ||
+        (index > 0 && id <= (value.sourceUpdateIds as number[])[index - 1]!))) return undefined;
+  return { queueKind: kind, receiptId: value.receiptId, sourceUpdateIds: value.sourceUpdateIds as number[],
+    ...(typeof value.journalBindingKey === "string" ? { journalBindingKey: value.journalBindingKey } : {}) };
+}
+
+/** Data decoder shared by authenticated IPC and cold storage; decoding grants no admission. */
+export function parseTelegramQueueHandoffPayload(value: unknown): TelegramQueueHandoffPayload | undefined {
+  if (!isQueuePayloadRecord(value) || (value.kind !== "prompt" && value.kind !== "control")) return undefined;
+  const target = isQueuePayloadRecord(value.target) && typeof value.target.chatId === "number"
+    ? { chatId: value.target.chatId, ...(typeof value.target.threadId === "number" ? { threadId: value.target.threadId } : {}) } : undefined;
+  const transportStamp = isQueuePayloadRecord(value.transportStamp) &&
+    typeof value.transportStamp.profile === "string" && typeof value.transportStamp.generation === "string"
+    ? { profile: value.transportStamp.profile, generation: value.transportStamp.generation } : undefined;
+  if (!Number.isSafeInteger(value.chatId) || (value.target !== undefined && !target) ||
+      (value.transportStamp !== undefined && !transportStamp) || !Number.isSafeInteger(value.replyToMessageId) ||
+      (value.guestQueryId !== undefined && typeof value.guestQueryId !== "string") ||
+      (value.guestInlineMessageId !== undefined && typeof value.guestInlineMessageId !== "string") ||
+      !Number.isSafeInteger(value.queueOrder) || (value.queueLane !== "control" && value.queueLane !== "priority" && value.queueLane !== "default") ||
+      !Number.isSafeInteger(value.laneOrder) || typeof value.statusSummary !== "string" || !Array.isArray(value.admissionReceipts)) return undefined;
+  const admissionReceipts = value.admissionReceipts.map(receipt => parseQueuePayloadReceipt(receipt, value.kind as TelegramQueueItemKind));
+  if (admissionReceipts.length === 0 || admissionReceipts.length > TELEGRAM_QUEUE_HANDOFF_MAX_RECEIPTS ||
+      admissionReceipts.some(receipt => !receipt)) return undefined;
+  const base = { chatId: value.chatId as number, ...(target ? { target } : {}), ...(transportStamp ? { transportStamp } : {}),
+    replyToMessageId: value.replyToMessageId as number,
+    ...(typeof value.guestQueryId === "string" ? { guestQueryId: value.guestQueryId } : {}),
+    ...(typeof value.guestInlineMessageId === "string" ? { guestInlineMessageId: value.guestInlineMessageId } : {}),
+    queueOrder: value.queueOrder as number, queueLane: value.queueLane as TelegramQueueLane,
+    laneOrder: value.laneOrder as number, statusSummary: value.statusSummary,
+    admissionReceipts: admissionReceipts as TelegramQueueAdmissionReceipt[] };
+  if (value.kind === "control") {
+    return value.queueLane === "control" && (value.controlType === "status" || value.controlType === "model")
+      ? { kind: "control", controlType: value.controlType, ...base } : undefined;
+  }
+  if (value.queueLane === "control" || !Array.isArray(value.sourceMessageIds) || value.sourceMessageIds.some(id => !Number.isSafeInteger(id)) ||
+      !Array.isArray(value.queuedAttachments) || value.queuedAttachments.some(attachment => !isQueuePayloadRecord(attachment) ||
+        typeof attachment.path !== "string" || typeof attachment.fileName !== "string") ||
+      !Array.isArray(value.content) || value.content.some(content => !isQueuePayloadRecord(content) ||
+        (content.type === "text" ? typeof content.text !== "string" : content.type === "image"
+          ? typeof content.data !== "string" || typeof content.mimeType !== "string" : true)) ||
+      typeof value.historyText !== "string" || (value.priorityEmoji !== undefined && typeof value.priorityEmoji !== "string") ||
+      (value.reactionSuppressionEmoji !== undefined && typeof value.reactionSuppressionEmoji !== "string") ||
+      (value.voiceReplyPreferred !== undefined && typeof value.voiceReplyPreferred !== "boolean") ||
+      (value.voiceReplyRequired !== undefined && typeof value.voiceReplyRequired !== "boolean")) return undefined;
+  return { kind: "prompt", ...base, sourceMessageIds: value.sourceMessageIds as number[],
+    queuedAttachments: value.queuedAttachments as QueuedAttachment[], content: value.content as TelegramPromptContent[], historyText: value.historyText,
+    ...(typeof value.priorityEmoji === "string" ? { priorityEmoji: value.priorityEmoji } : {}),
+    ...(typeof value.reactionSuppressionEmoji === "string" ? { reactionSuppressionEmoji: value.reactionSuppressionEmoji } : {}),
+    ...(typeof value.voiceReplyPreferred === "boolean" ? { voiceReplyPreferred: value.voiceReplyPreferred } : {}),
+    ...(typeof value.voiceReplyRequired === "boolean" ? { voiceReplyRequired: value.voiceReplyRequired } : {}) };
+}
+
 export interface TelegramQueueHandoffStageReceipt {
   status: "staged";
   receiptId: string;
@@ -367,7 +425,7 @@ function getTelegramQueueLaneRank(lane: TelegramQueueLane): number {
   return getTelegramQueueLaneContract(lane).dispatchRank;
 }
 
-export function isPendingTelegramTurn<TContext = unknown>(
+function isPendingTelegramTurn<TContext = unknown>(
   item: TelegramQueueItem<TContext>,
 ): item is PendingTelegramTurn {
   return item.kind === "prompt";
@@ -434,7 +492,7 @@ export function createTelegramTransportStampedQueueStore<TContext>(
   };
 }
 
-export function isTelegramQueueItemSkipped<TContext = unknown>(
+function isTelegramQueueItemSkipped<TContext = unknown>(
   item: TelegramQueueItem<TContext>,
 ): boolean {
   return item.kind === "prompt" && Boolean(item.reactionSuppressionEmoji);
@@ -936,7 +994,7 @@ export function removeTelegramQueueItemsByMessageIds<TContext = unknown>(
   };
 }
 
-export function removeTelegramQueuedGuestPromptByOrder<TContext = unknown>(
+function removeTelegramQueuedGuestPromptByOrder<TContext = unknown>(
   items: TelegramQueueItem<TContext>[],
   queueOrder: number,
 ): {
@@ -2695,7 +2753,7 @@ function appendTelegramQueueItemRuntime<TContext>(
   commitReorderedTelegramQueueItemsRuntime(nextItems, deps);
 }
 
-export function reorderTelegramQueueItemsRuntime<TContext>(
+function reorderTelegramQueueItemsRuntime<TContext>(
   deps: TelegramQueueMutationRuntimeDeps<TContext>,
 ): void {
   commitReorderedTelegramQueueItemsRuntime(deps.getQueuedItems(), deps);
@@ -2737,7 +2795,7 @@ export function removeTelegramQueueItemsByMessageIdsRuntime<TContext>(
   return removedCount;
 }
 
-export function removeTelegramQueuedGuestPromptByOrderRuntime<TContext>(
+function removeTelegramQueuedGuestPromptByOrderRuntime<TContext>(
   queueOrder: number,
   deps: TelegramQueueMutationRuntimeDeps<TContext>,
 ): boolean {
@@ -2883,7 +2941,7 @@ export interface TelegramControlRuntimeDeps<
     chatId: number,
     replyToMessageId: number,
     text: string,
-    options?: { target?: TelegramQueueTarget },
+    options?: { target?: TelegramQueueTarget; parseMode?: "HTML" },
   ) => Promise<number | undefined>;
   onSettled: (item: PendingTelegramControlItem<TContext>) => void;
 }
@@ -2936,7 +2994,7 @@ export interface TelegramDeferredQueueDispatchRuntime<TContext = unknown> {
  * Production debounce for deferred queue dispatch; the factory defaults to this
  * so the entrypoint wires ports instead of policy constants.
  */
-export const TELEGRAM_DEFERRED_DISPATCH_DELAY_MS = 50;
+const TELEGRAM_DEFERRED_DISPATCH_DELAY_MS = 50;
 
 export function createTelegramDeferredQueueDispatchRuntime<TContext = unknown>(
   deps: TelegramDeferredQueueDispatchRuntimeDeps = {},
@@ -3436,7 +3494,7 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
           dispatchPlan.item.chatId,
           dispatchPlan.item.replyToMessageId,
           "<b>⏩ Dispatching next queued turn.</b>",
-          { target: dispatchPlan.item.target },
+          { target: dispatchPlan.item.target, parseMode: "HTML" },
         ).catch((error) => {
           deps.recordRuntimeEvent?.("dispatch", error, {
             phase: "next-announcement",

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

@@ -4,21 +4,21 @@
  * Owns fail-safe classification of temporary ownership and routing artifacts
  */
 
-import { randomUUID } from "node:crypto";
 import {
   existsSync,
   lstatSync,
-  mkdirSync,
   readFileSync,
   readdirSync,
-  renameSync,
+  rmdirSync,
+  rmSync,
 } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
+import { decodeTelegramSessionDirectoryName, getTelegramProfilePathSuffix } from "./paths.ts";
+
 import {
   isProcessAlive as defaultIsProcessAlive,
   parseTelegramLockEntry,
-  renameTelegramPathWithRetry,
   TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS,
   withTelegramFileTransaction,
   type TelegramFileTransactionOptions,
@@ -59,22 +59,22 @@ export type TelegramRuntimeRecoveryResult =
   | {
       kind: "blocked-live-owner";
       livePids: number[];
-      quarantineDir?: string;
+      deletedPaths?: string[];
     }
   | {
       kind: "recovered";
       artifacts: TelegramRuntimeCorruptArtifact[];
-      quarantineDir: string;
+      /** Damaged disposable artifacts deleted per the approved corruption policy; nothing is quarantined. */
+      deletedPaths: string[];
     };
 
 export interface TelegramRuntimeRecoveryOptions
   extends TelegramRuntimeRecoveryClassificationOptions {
   recoveryTransactionPath?: string;
-  quarantineRoot?: string;
   pid?: number;
   getNowMs?: () => number;
-  quarantineRename?: typeof renameSync;
-  quarantineRenameRetryDelayMs?: number;
+  /** Fault-injection seam; production uses bounded-retry recursive removal. */
+  removePath?: (path: string) => void;
   transactionOptions?: TelegramFileTransactionOptions;
 }
 
@@ -145,6 +145,9 @@ function inspectOwners(
 function inspectState(path: string): ArtifactInspection {
   if (!existsSync(path)) return { source: "state", ownerPids: [] };
   try {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 8 * 1024 * 1024)
+      return corruption("state", path, `${basename(path)} cannot be safely inspected`);
     JSON.parse(readFileSync(path, "utf8"));
     return { source: "state", ownerPids: [] };
   } catch {
@@ -293,24 +296,24 @@ export function classifyTelegramRuntimeRecovery(
 }
 
 /**
- * Quarantine classifier-approved disposable corruption under two guards.
+ * Delete classifier-approved disposable corruption under two guards.
  *
  * A dedicated recovery transaction serializes recoverers. The ownership
  * transaction then prevents a new Telegram owner from appearing between the
- * final classification and mutation. Every artifact is renamed within its
- * filesystem; durable config and diagnostics never enter the candidate set.
+ * final classification and mutation. Damaged ownership debris and canonical
+ * state are deleted (operator policy: unfinished Restores in unreadable state
+ * are acceptable loss). Durable config and diagnostics never enter the set.
  */
 export function recoverTelegramRuntimeState(
   options: TelegramRuntimeRecoveryOptions,
 ): TelegramRuntimeRecoveryResult {
-  const pid = options.pid ?? process.pid;
   const transactionPath =
     options.transactionPath ?? `${options.ownersPath}.transaction`;
   const recoveryTransactionPath =
     options.recoveryTransactionPath ??
     join(dirname(options.ownersPath), "runtime-recovery.transaction");
-  const quarantineRoot =
-    options.quarantineRoot ?? join(dirname(options.ownersPath), "recovery");
+  const removePath = options.removePath ?? ((path: string) =>
+    rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 }));
   const classificationOptions = {
     ownersPath: options.ownersPath,
     statePaths: options.statePaths,
@@ -332,34 +335,19 @@ export function recoverTelegramRuntimeState(
         };
       }
 
-      let quarantineDir: string | undefined;
+      const deletedPaths: string[] = [];
       const recoveredArtifacts: TelegramRuntimeCorruptArtifact[] = [];
-      const ensureQuarantineDir = (): string => {
-        if (quarantineDir) return quarantineDir;
-        quarantineDir = join(
-          quarantineRoot,
-          `${options.getNowMs?.() ?? Date.now()}-${pid}-${randomUUID()}`,
-        );
-        mkdirSync(quarantineDir, { recursive: true, mode: 0o700 });
-        return quarantineDir;
-      };
-      const quarantineArtifact = (
+      const deleteArtifact = (
         artifact: TelegramRuntimeCorruptArtifact,
       ): void => {
         if (!existsSync(artifact.path)) return;
-        const destination = join(ensureQuarantineDir(), basename(artifact.path));
-        if (
-          renameTelegramPathWithRetry(artifact.path, destination, {
-            rename: options.quarantineRename,
-            retryDelayMs: options.quarantineRenameRetryDelayMs,
-          })
-        ) {
-          recoveredArtifacts.push(artifact);
-        }
+        removePath(artifact.path);
+        deletedPaths.push(artifact.path);
+        recoveredArtifacts.push(artifact);
       };
 
       for (const artifact of initial.artifacts) {
-        if (artifact.kind === "transaction") quarantineArtifact(artifact);
+        if (artifact.kind === "transaction") deleteArtifact(artifact);
       }
 
       return withTelegramFileTransaction(
@@ -373,19 +361,19 @@ export function recoverTelegramRuntimeState(
             return {
               kind: "blocked-live-owner",
               livePids: current.livePids,
-              quarantineDir,
+              ...(deletedPaths.length > 0 ? { deletedPaths } : {}),
             };
           }
           if (current.kind === "recoverable-corruption") {
             for (const artifact of current.artifacts) {
-              if (artifact.kind !== "transaction") quarantineArtifact(artifact);
+              if (artifact.kind !== "transaction") deleteArtifact(artifact);
             }
           }
-          return recoveredArtifacts.length > 0 && quarantineDir
+          return recoveredArtifacts.length > 0
             ? {
                 kind: "recovered",
                 artifacts: recoveredArtifacts,
-                quarantineDir,
+                deletedPaths,
               }
             : { kind: "not-needed" };
         },
@@ -396,6 +384,81 @@ export function recoverTelegramRuntimeState(
   );
 }
 
+/**
+ * Remove recovery folders written by earlier releases (runtime root and session folders).
+ * Current releases delete damaged files instead of quarantining them; nothing reads these copies.
+ */
+export function removeTelegramLegacyRecoveryStorage(runtimeDir: string): string[] {
+  const removed: string[] = [];
+  const remove = (path: string): void => {
+    try {
+      if (!lstatSync(path).isDirectory()) return;
+      rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+      removed.push(path);
+    } catch {
+      // Best-effort housekeeping; a later startup retries.
+    }
+  };
+  remove(join(runtimeDir, "recovery"));
+  let sessions: string[] = [];
+  try { sessions = readdirSync(join(runtimeDir, "sessions")); } catch { /* no sessions yet */ }
+  for (const session of sessions) remove(join(runtimeDir, "sessions", session, "recovery"));
+  return removed;
+}
+
+const TELEGRAM_SESSION_SWEEP_INTERVAL_MS = 10 * 60 * 1000;
+
+export interface TelegramSessionFolderSweeperDeps {
+  getSessionsDir: () => string;
+  getProfileName: () => string | undefined;
+  /** Sessions holding a Workspace slot binding, live registrations and this process's own session. */
+  getKeptSessionIds: () => Iterable<string | undefined>;
+  getNowMs?: () => number;
+  intervalMs?: number;
+}
+
+/**
+ * Leader housekeeping (operator policy): a session without a Workspace slot loses its
+ * current-profile journal family; the folder disappears once no profile uses it.
+ */
+export function createTelegramSessionFolderSweeper(deps: TelegramSessionFolderSweeperDeps): { sweep: () => string[] } {
+  const getNowMs = deps.getNowMs ?? Date.now;
+  const intervalMs = deps.intervalMs ?? TELEGRAM_SESSION_SWEEP_INTERVAL_MS;
+  let lastSweepAtMs: number | undefined;
+  return {
+    sweep() {
+      const now = getNowMs();
+      if (lastSweepAtMs !== undefined && now - lastSweepAtMs < intervalMs) return [];
+      lastSweepAtMs = now;
+      const sessionsDir = deps.getSessionsDir();
+      const kept = new Set(deps.getKeptSessionIds());
+      const suffix = getTelegramProfilePathSuffix(deps.getProfileName()).replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+      const family = new RegExp(`^journal\\.[a-f0-9]{16}${suffix}\\.json(?:\\.segments|\\.retained)?$`, "u");
+      const removed: string[] = [];
+      let names: string[];
+      try { names = readdirSync(sessionsDir); } catch { return removed; }
+      for (const name of names) {
+        const sessionId = decodeTelegramSessionDirectoryName(name);
+        if (sessionId === undefined || kept.has(sessionId)) continue;
+        const folder = join(sessionsDir, name);
+        try {
+          if (!lstatSync(folder).isDirectory()) continue;
+          for (const entry of readdirSync(folder)) {
+            if (!family.test(entry)) continue;
+            const path = join(folder, entry);
+            rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+            removed.push(path);
+          }
+          if (readdirSync(folder).length === 0) { rmdirSync(folder); removed.push(folder); }
+        } catch {
+          // Best-effort housekeeping; the next sweep retries.
+        }
+      }
+      return removed;
+    },
+  };
+}
+
 /** Build the `/telegram-connect` recovery boundary around runtime artifacts. */
 export function createTelegramPollingStartRecoveryHandler(
   deps: TelegramPollingStartRecoveryHandlerDeps,
@@ -435,10 +498,7 @@ export function createTelegramPollingStartRecoveryHandler(
       });
     }
     try {
-      const recovery = recoverTelegramRuntimeState({
-        ownersPath,
-        statePaths,
-      });
+      const recovery = recoverTelegramRuntimeState({ ownersPath, statePaths });
       if (recovery.kind === "blocked-live-owner") {
         return {
           kind: "blocked",

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

@@ -750,7 +750,7 @@ export async function sendTelegramNativeMarkdownReply<TReplyMarkup = unknown>(
   return lastMessageId;
 }
 
-export async function sendTelegramNativeRichMessage(
+async function sendTelegramNativeRichMessage(
   chatId: number,
   richMessage: TelegramInputRichMessage,
   deps: {