@llblab/pi-telegram 0.51.5 → 0.52.0

package/dist/lib/commands.d.ts

@@ -6,7 +6,7 @@
 import { type TelegramConfigStore } from "./config.ts";
 import type * as Pi from "./pi.ts";
 import type { ExtensionAPI, ExtensionCommandContext } from "./pi.ts";
-import type { TelegramBridgeStatusLineOptions } from "./status.ts";
+import { type TelegramBridgeStatusLineOptions } from "./status.ts";
 import type { TelegramSessionReplacementIntent } from "./threads.ts";
 import { type PendingTelegramControlItem, type TelegramQueueAdmissionReceipt } from "./queue.ts";
 export interface ParsedTelegramCommand {
@@ -43,10 +43,7 @@ interface RegisteredTelegramExtensionCommand {
     emoji?: string;
     handler: TelegramExtensionCommandRegistration["handler"];
 }
-export declare function normalizeTelegramExtensionCommandName(name: string): string;
-export declare function isTelegramExtensionCommandName(name: string): boolean;
 export declare function registerTelegramCommand(registration: TelegramExtensionCommandRegistration): () => void;
-export declare function getTelegramExtensionCommands(): RegisteredTelegramExtensionCommand[];
 export declare function findTelegramExtensionCommand(name: string | undefined): RegisteredTelegramExtensionCommand | undefined;
 export declare function clearTelegramExtensionCommands(): void;
 export declare const TELEGRAM_COMMAND_EMOJI: {
@@ -65,18 +62,14 @@ export declare const TELEGRAM_COMMAND_EMOJI: {
     readonly new: "🆕";
 };
 export type TelegramCommandEmojiName = keyof typeof TELEGRAM_COMMAND_EMOJI;
-export declare function getTelegramCommandEmoji(command: TelegramCommandEmojiName): string;
 export declare function formatTelegramCommandEmojiPrefix(command: TelegramCommandEmojiName): string;
 export declare function formatTelegramPiCommandHtml(command: string): string;
 export declare function formatTelegramInformationHeading(emoji: string, text: string): string;
 export declare function formatTelegramInvalidInstanceName(validationError: string): string;
 export declare function formatTelegramThreadDisplayNameSavedHeading(name: string): string;
 export declare function formatTelegramAutomaticThreadDisplayNameRestoredHeading(name: string): string;
-export declare const TELEGRAM_COMPACTION_STARTED_TEXT: string;
-export declare const TELEGRAM_COMPACTION_COMPLETED_TEXT: string;
 export declare const TELEGRAM_COMPACTION_STARTED_MARKDOWN: string;
 export declare const TELEGRAM_COMPACTION_COMPLETED_MARKDOWN = "**\u2705 Compaction completed.**";
-export declare const TELEGRAM_BUILTIN_BOT_COMMANDS: readonly TelegramBotCommandDefinition[];
 export declare const TELEGRAM_BOT_COMMANDS: readonly TelegramBotCommandDefinition[];
 export declare function getTelegramReservedCommandNames(): string[];
 export interface TelegramBotCommandRegistrationDeps {
@@ -112,12 +105,21 @@ export interface TelegramBridgeCommandRegistrationDeps {
     startPolling: (ctx: ExtensionCommandContext, options?: TelegramBridgeCommandStartPollingOptions) => void | Promise<void | TelegramBridgeCommandStartPollingResult> | TelegramBridgeCommandStartPollingResult;
     stopPolling: () => Promise<void | string>;
     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>;
-    activateProfileConfig?: (ctx: ExtensionCommandContext, profileName: string) => Promise<boolean>;
+    activateDefaultProfileConfig?: (ctx: ExtensionCommandContext, isCurrent: () => boolean) => Promise<void>;
+    activateProfileConfig?: (ctx: ExtensionCommandContext, profileName: string, isCurrent: () => boolean) => Promise<boolean>;
 }
 export type TelegramThreadDisplayNameRenamePort = (target: {
     chatId: number;
@@ -533,16 +535,8 @@ export declare function handleTelegramNextCommand(deps: {
         parseMode?: "HTML";
     }) => Promise<void>) | undefined;
 }): Promise<void>;
-export declare function handleTelegramContinueCommand<TMessage, TContext>(message: TMessage, ctx: TContext, deps: {
-    enqueueContinueTurn: (message: TMessage, ctx: TContext) => Promise<void>;
-}): Promise<void>;
-export declare function buildTelegramNewConfirmationReplyMarkup(): TelegramCompactConfirmationReplyMarkup;
-export declare function getTelegramNewConfirmationHtml(): string;
 export declare function openTelegramNewConfirmation(target: TelegramCommandMessageTarget, deps: TelegramCompactConfirmationDeps): Promise<void>;
 export declare function handleTelegramNewConfirmationCallback<TContext>(query: TelegramCompactConfirmationCallbackQuery, deps: TelegramNewConfirmationCallbackDeps<TContext>): Promise<boolean>;
-export declare function buildTelegramCompactConfirmationReplyMarkup(): TelegramCompactConfirmationReplyMarkup;
-export declare function getTelegramCompactConfirmationHtml(): string;
-export declare function openTelegramCompactConfirmation(target: TelegramCommandMessageTarget, deps: TelegramCompactConfirmationDeps): Promise<void>;
 export declare function handleTelegramCompactConfirmationCallback<TContext>(query: TelegramCompactConfirmationCallbackQuery, deps: TelegramCompactConfirmationCallbackDeps<TContext>): Promise<boolean>;
 export interface TelegramNewCommandDeps extends TelegramRuntimeEventRecorderPort {
     isIdle: () => boolean;
@@ -579,7 +573,6 @@ export declare function createTelegramCommandOrPromptRuntime<TMessage, TContext>
 export declare const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
 export declare const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION = "Internal Telegram command cannot be run manually";
 export declare const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE = "This internal Telegram command cannot be run manually.";
-export declare function delayTelegramSessionAction(delayMs: number): Promise<void>;
 export interface TelegramSessionActionRuntimeDeps {
     registerCommand: Pi.ExtensionAPI["registerCommand"];
     sendUserMessage: Pi.ExtensionAPI["sendUserMessage"];
@@ -612,13 +605,6 @@ export interface TelegramSessionReplacementSettlementDeps {
     isCurrent?: () => boolean;
 }
 export declare function settleTelegramSessionReplacement(deps: TelegramSessionReplacementSettlementDeps): Promise<"none" | "settled" | "expired" | "failed" | "stale">;
-export declare function createTelegramSessionReplacementSettlementRuntime<TContext>(deps: {
-    resolve: (ctx: TContext) => TelegramSessionReplacementSettlementDeps | undefined;
-    onResult?: (result: "none" | "settled" | "expired" | "failed" | "stale") => void;
-    onError?: (error: unknown) => void;
-}): {
-    onSessionStart: (ctx: TContext) => void;
-};
 export interface TelegramSessionActionAssemblyDeps {
     registerCommand: Pi.ExtensionAPI["registerCommand"];
     sendUserMessage: Pi.ExtensionAPI["sendUserMessage"];

package/dist/lib/commands.js

@@ -6,6 +6,7 @@
 import { randomUUID } from "node:crypto";
 import { pairTelegramUserIfNeeded, TELEGRAM_DEFAULT_PROFILE_NAME, } from "./config.js";
 import { escapeHtml } from "./rendering.js";
+import { formatTelegramConnectionFailure } from "./status.js";
 import { createTelegramControlItemBuilder, createTelegramControlQueueController, createTelegramQueueAdmissionReceipt, } from "./queue.js";
 const TELEGRAM_EXTENSION_COMMAND_REGISTRY_KEY = "__piTelegramCommandRegistry__";
 const TELEGRAM_BOT_COMMAND_NAME_PATTERN = /^[a-z0-9_]{1,32}$/;
@@ -22,10 +23,10 @@ function getOrCreateTelegramCommandRegistry() {
     globalThis[TELEGRAM_EXTENSION_COMMAND_REGISTRY_KEY] = registry;
     return registry;
 }
-export function normalizeTelegramExtensionCommandName(name) {
+function normalizeTelegramExtensionCommandName(name) {
     return name.trim().replace(/^\/+/, "").toLowerCase();
 }
-export function isTelegramExtensionCommandName(name) {
+function isTelegramExtensionCommandName(name) {
     return TELEGRAM_BOT_COMMAND_NAME_PATTERN.test(name);
 }
 function normalizeTelegramExtensionCommandEmoji(emoji) {
@@ -66,7 +67,7 @@ export function registerTelegramCommand(registration) {
             registry.commands.delete(name);
     };
 }
-export function getTelegramExtensionCommands() {
+function getTelegramExtensionCommands() {
     return Array.from(getOrCreateTelegramCommandRegistry().commands.values()).sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
 }
 export function findTelegramExtensionCommand(name) {
@@ -92,7 +93,7 @@ export const TELEGRAM_COMMAND_EMOJI = {
     name: "🏷️",
     new: "🆕",
 };
-export function getTelegramCommandEmoji(command) {
+function getTelegramCommandEmoji(command) {
     return TELEGRAM_COMMAND_EMOJI[command];
 }
 export function formatTelegramCommandEmojiPrefix(command) {
@@ -123,14 +124,14 @@ export function formatTelegramThreadDisplayNameSavedHeading(name) {
 export function formatTelegramAutomaticThreadDisplayNameRestoredHeading(name) {
     return `<b>✅ Automatic Thread display name restored as <i>${escapeHtml(name)}</i>.</b>`;
 }
-export const TELEGRAM_COMPACTION_STARTED_TEXT = formatTelegramInformationHeading(getTelegramCommandEmoji("compact"), "Compaction started.");
-export const TELEGRAM_COMPACTION_COMPLETED_TEXT = formatTelegramInformationHeading("✅", "Compaction completed.");
+const TELEGRAM_COMPACTION_STARTED_TEXT = formatTelegramInformationHeading(getTelegramCommandEmoji("compact"), "Compaction started.");
+const TELEGRAM_COMPACTION_COMPLETED_TEXT = formatTelegramInformationHeading("✅", "Compaction completed.");
 export const TELEGRAM_COMPACTION_STARTED_MARKDOWN = `**${formatTelegramCommandEmojiPrefix("compact")}Compaction started.**`;
 export const TELEGRAM_COMPACTION_COMPLETED_MARKDOWN = "**✅ Compaction completed.**";
 function formatTelegramBotCommandDescription(command, description) {
     return `${formatTelegramCommandEmojiPrefix(command)}${description}`;
 }
-export const TELEGRAM_BUILTIN_BOT_COMMANDS = [
+const TELEGRAM_BUILTIN_BOT_COMMANDS = [
     {
         command: "start",
         description: formatTelegramBotCommandDescription("start", "Open menu / Pair bridge"),
@@ -270,121 +271,174 @@ export function registerTelegramBridgeCommands(pi, deps) {
     pi.registerCommand("telegram-connect", {
         description: "<profile> — Start Telegram bridge",
         handler: async (args, ctx) => {
+            const sessionGeneration = deps.getSessionGeneration?.();
+            let intentId;
+            // 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.", "warning");
                 deps.updateStatus(ctx);
                 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;
-                }
-                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);
-                    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");
                 }
-                await deps.promptForConfig(ctx, profileName);
-                return;
-            }
-            let recoveryUsed = false;
-            const startWithRecovery = async (options) => {
-                try {
-                    return await deps.startPolling(ctx, options);
+                else {
+                    await (deps.activateDefaultProfileConfig?.(ctx, isCurrent) ?? deps.reloadConfig());
+                    if (!isCurrent())
+                        return;
                 }
-                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 };
+                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;
                     }
-                    recoveryUsed = true;
+                    await deps.promptForConfig(ctx, profileName);
+                    return;
+                }
+                let recoveryUsed = false;
+                const startWithRecovery = async (options) => {
                     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");
                 }
-                result = await startWithRecovery({
-                    force: true,
-                    forceFreshLeaderThread: true,
-                });
+                else if (result?.message) {
+                    ctx.ui.notify(result.message, "info");
+                }
+                if (!result || result.ok)
+                    deps.queueAgentConnectionContext?.(true);
+                deps.updateStatus(ctx);
             }
-            if (result?.message) {
-                ctx.ui.notify(result.message, result.ok ? "info" : "warning");
+            catch (error) {
+                if (!isCurrent())
+                    return;
+                deps.recordConnectionEvent?.(error, "connect");
+                ctx.ui.notify(formatTelegramConnectionFailure(error), "warning");
+                deps.updateStatus(ctx);
             }
-            if (!result || result.ok) {
-                deps.queueAgentConnectionContext?.(true);
+            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);
             }
         },
     });
@@ -684,7 +738,7 @@ export async function handleTelegramNextCommand(deps) {
     deps.dispatchNextQueuedTurn();
     deps.updateStatus();
 }
-export async function handleTelegramContinueCommand(message, ctx, deps) {
+async function handleTelegramContinueCommand(message, ctx, deps) {
     await deps.enqueueContinueTurn(message, ctx);
 }
 function dispatchNextQueuedTelegramTurnAfterCompact(deps) {
@@ -694,7 +748,7 @@ function dispatchNextQueuedTelegramTurnAfterCompact(deps) {
     }
     deps.dispatchNextQueuedTelegramTurn();
 }
-export function buildTelegramNewConfirmationReplyMarkup() {
+function buildTelegramNewConfirmationReplyMarkup() {
     return {
         inline_keyboard: [
             [
@@ -704,7 +758,7 @@ export function buildTelegramNewConfirmationReplyMarkup() {
         ],
     };
 }
-export function getTelegramNewConfirmationHtml() {
+function getTelegramNewConfirmationHtml() {
     return "<b>Start a new session?</b>";
 }
 export async function openTelegramNewConfirmation(target, deps) {
@@ -731,7 +785,7 @@ export async function handleTelegramNewConfirmationCallback(query, deps) {
     await deps.runNew(deps.ctx);
     return true;
 }
-export function buildTelegramCompactConfirmationReplyMarkup() {
+function buildTelegramCompactConfirmationReplyMarkup() {
     return {
         inline_keyboard: [
             [
@@ -741,10 +795,10 @@ export function buildTelegramCompactConfirmationReplyMarkup() {
         ],
     };
 }
-export function getTelegramCompactConfirmationHtml() {
+function getTelegramCompactConfirmationHtml() {
     return "<b>Compact session?</b>";
 }
-export async function openTelegramCompactConfirmation(target, deps) {
+async function openTelegramCompactConfirmation(target, deps) {
     await deps.sendInteractiveMessage(target.chatId, getTelegramCompactConfirmationHtml(), "html", buildTelegramCompactConfirmationReplyMarkup(), target.threadId !== undefined
         ? { target: { chatId: target.chatId, threadId: target.threadId } }
         : undefined);
@@ -1223,7 +1277,7 @@ async function handleTelegramCommandRuntime(commandName, message, ctx, deps, com
 export const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
 export const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION = "Internal Telegram command cannot be run manually";
 export const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE = "This internal Telegram command cannot be run manually.";
-export function delayTelegramSessionAction(delayMs) {
+function delayTelegramSessionAction(delayMs) {
     return new Promise((resolve) => setTimeout(resolve, delayMs));
 }
 export async function settleTelegramSessionReplacement(deps) {
@@ -1255,7 +1309,7 @@ export async function settleTelegramSessionReplacement(deps) {
     }
     return "stale";
 }
-export function createTelegramSessionReplacementSettlementRuntime(deps) {
+function createTelegramSessionReplacementSettlementRuntime(deps) {
     let generation = 0;
     return {
         onSessionStart(ctx) {

package/dist/lib/config.d.ts

@@ -16,17 +16,10 @@ export type TelegramBotTokenReference = {
 } | {
     kind: "malformed";
 };
-/**
- * Parse a persisted bot-token value. `$NAME` and `${NAME}` are exact
- * environment-variable references. Any other `$`-prefixed value is malformed
- * rather than a literal secret so a broken reference fails closed.
- */
-export declare function getTelegramBotTokenReference(value: string | undefined): TelegramBotTokenReference | undefined;
 /** Resolve a persisted token at a validation/activation boundary. */
 export declare function resolveTelegramBotToken(value: string | undefined, env?: NodeJS.ProcessEnv): string | undefined;
 /** Redacted diagnostic for an unresolved or malformed token reference. */
 export declare function getTelegramBotTokenDiagnostic(value: string | undefined, env?: NodeJS.ProcessEnv): string | undefined;
-export type TelegramOutboundCommandTemplateConfig = string | CommandTemplateObjectConfig;
 export interface TelegramOutboundHandlerConfig extends CommandTemplateObjectConfig {
     type?: string;
     match?: string | string[];
@@ -179,13 +172,6 @@ export declare function normalizeTelegramDefaultProfileConfig(config: TelegramCo
     changed: boolean;
 };
 export declare function createTelegramConfigStore(options?: TelegramConfigStoreOptions): TelegramConfigStore;
-export declare function createTelegramDraftPreviewsChecker(configStore: Pick<TelegramConfigStore, "get">): () => boolean;
-export declare function createTelegramDraftPreviewsSetter(configStore: TelegramMutableConfigStore): (enabled: boolean) => Promise<void>;
-export declare function createTelegramAssistantRenderingModeGetter(configStore: Pick<TelegramConfigStore, "get">): () => TelegramAssistantRenderingMode;
-export declare function createTelegramAssistantRenderingModeSetter(configStore: TelegramMutableConfigStore): (mode: TelegramAssistantRenderingMode) => Promise<void>;
-export declare function createTelegramActivityVerbosityGetter(configStore: Pick<TelegramConfigStore, "get">): () => TelegramActivityVerbosity;
-export declare function createTelegramActivityVerbosityRefresher(configStore: TelegramMutableConfigStore): () => Promise<void>;
-export declare function createTelegramActivityVerbositySetter(configStore: TelegramMutableConfigStore): (verbosity: TelegramActivityVerbosity) => Promise<void>;
 export declare function createTelegramVoiceReplyModeGetter(configStore: Pick<TelegramConfigStore, "get">): () => "manual" | "mirror" | "always";
 export declare function createTelegramVoiceReplyModeConfiguredChecker(configStore: Pick<TelegramConfigStore, "get">): () => boolean;
 export declare function createTelegramVoiceReplyModeSetter(configStore: TelegramMutableConfigStore): (replyMode: "manual" | "hidden" | "mirror" | "always" | undefined) => Promise<void>;
@@ -203,9 +189,6 @@ export declare function createTelegramProactivePushTargetGetter(deps: {
     getAssignedTarget: () => TelegramProactivePushTarget | undefined;
     getAllowedUserId: () => number | undefined;
 }): () => TelegramProactivePushTarget | undefined;
-export declare function createTelegramAutomaticThreadCleanupChecker(configStore: Pick<TelegramConfigStore, "get">): () => boolean;
-export declare function createTelegramAutomaticThreadCleanupResolver(configStore: TelegramMutableConfigStore): () => Promise<boolean>;
-export declare function createTelegramAutomaticThreadCleanupSetter(configStore: TelegramMutableConfigStore): (enabled: boolean) => Promise<void>;
 export declare function createTelegramConfigControls(configStore: TelegramMutableConfigStore): {
     areDraftPreviewsEnabled: () => boolean;
     setDraftPreviewsEnabled: (enabled: boolean) => Promise<void>;

package/dist/lib/config.js

@@ -8,6 +8,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, u
 import { chmod, mkdir, rename, writeFile } from "node:fs/promises";
 import { resolveAgentDir, resolveTelegramConfigPath, TELEGRAM_DEFAULT_PROFILE_NAME, } from "./paths.js";
 export { TELEGRAM_DEFAULT_PROFILE_NAME } from "./paths.js";
+import { isWireRecord as isPlainConfigRecord } from "./wire.js";
 import { withTelegramFileTransaction } from "./locks.js";
 const CONFIG_RUNTIME_KEY = "__piTelegramConfigRuntime__";
 const CONFIG_REPLACE_RETRY_ATTEMPTS = 5;
@@ -45,7 +46,7 @@ const TELEGRAM_BOT_TOKEN_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
  * environment-variable references. Any other `$`-prefixed value is malformed
  * rather than a literal secret so a broken reference fails closed.
  */
-export function getTelegramBotTokenReference(value) {
+function getTelegramBotTokenReference(value) {
     const trimmed = value?.trim();
     if (!trimmed)
         return undefined;
@@ -211,9 +212,6 @@ export async function writeTelegramConfig(agentDir, configPath, config) {
     await rename(tempConfigPath, configPath);
     await chmod(configPath, 0o600);
 }
-function isPlainConfigRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
 function cloneTelegramConfig(value) {
     return structuredClone(value);
 }
@@ -628,7 +626,7 @@ export function createTelegramConfigStore(options = {}) {
         },
     };
 }
-export function createTelegramDraftPreviewsChecker(configStore) {
+function createTelegramDraftPreviewsChecker(configStore) {
     return () => {
         const config = configStore.get();
         return (config.assistant?.draftPreviews ??
@@ -637,7 +635,7 @@ export function createTelegramDraftPreviewsChecker(configStore) {
             true);
     };
 }
-export function createTelegramDraftPreviewsSetter(configStore) {
+function createTelegramDraftPreviewsSetter(configStore) {
     return async (enabled) => {
         await loadLatestTelegramConfig(configStore);
         const { draftPreviews: _legacyDraftPreviews, richDraftPreviews: _legacyRichDraftPreviews, ...current } = configStore.get();
@@ -649,14 +647,14 @@ export function createTelegramDraftPreviewsSetter(configStore) {
         await configStore.persist(config);
     };
 }
-export function createTelegramAssistantRenderingModeGetter(configStore) {
+function createTelegramAssistantRenderingModeGetter(configStore) {
     return () => {
         const config = configStore.get();
         const mode = config.assistant?.rendering ?? config.assistantRendering;
         return mode === "html" ? "html" : "rich";
     };
 }
-export function createTelegramAssistantRenderingModeSetter(configStore) {
+function createTelegramAssistantRenderingModeSetter(configStore) {
     return async (mode) => {
         await loadLatestTelegramConfig(configStore);
         const { assistantRendering: _legacyAssistantRendering, ...current } = configStore.get();
@@ -668,7 +666,7 @@ export function createTelegramAssistantRenderingModeSetter(configStore) {
         await configStore.persist(config);
     };
 }
-export function createTelegramActivityVerbosityGetter(configStore) {
+function createTelegramActivityVerbosityGetter(configStore) {
     return () => {
         const assistant = configStore.get().assistant;
         if (assistant?.activity !== undefined) {
@@ -685,10 +683,10 @@ export function createTelegramActivityVerbosityGetter(configStore) {
         return "verbose";
     };
 }
-export function createTelegramActivityVerbosityRefresher(configStore) {
+function createTelegramActivityVerbosityRefresher(configStore) {
     return () => loadLatestTelegramConfig(configStore);
 }
-export function createTelegramActivityVerbositySetter(configStore) {
+function createTelegramActivityVerbositySetter(configStore) {
     return async (verbosity) => {
         await loadLatestTelegramConfig(configStore);
         const current = configStore.get();
@@ -801,10 +799,10 @@ export function createTelegramProactivePushTargetGetter(deps) {
         return typeof chatId === "number" ? { chatId } : undefined;
     };
 }
-export function createTelegramAutomaticThreadCleanupChecker(configStore) {
+function createTelegramAutomaticThreadCleanupChecker(configStore) {
     return () => configStore.get().threads?.automaticCleanup ?? true;
 }
-export function createTelegramAutomaticThreadCleanupResolver(configStore) {
+function createTelegramAutomaticThreadCleanupResolver(configStore) {
     return async () => {
         await loadLatestTelegramConfig(configStore);
         if (configStore.didLastLoadRecoverInvalidConfig?.()) {
@@ -813,7 +811,7 @@ export function createTelegramAutomaticThreadCleanupResolver(configStore) {
         return createTelegramAutomaticThreadCleanupChecker(configStore)();
     };
 }
-export function createTelegramAutomaticThreadCleanupSetter(configStore) {
+function createTelegramAutomaticThreadCleanupSetter(configStore) {
     return async (enabled) => {
         await loadLatestTelegramConfig(configStore);
         const current = configStore.get();

package/dist/lib/delivery.d.ts

@@ -108,10 +108,6 @@ export declare function createTelegramBridgeDeliveryLifecycleHooks<TTransportSta
     getTransportStamp?: () => TTransportStamp;
     isTransportStampActive?: (stamp: TTransportStamp) => boolean;
 }): ReturnType<typeof createTelegramDeliveryLifecycleHooks>;
-export declare function classifyTelegramDeliveryTransportError(error: unknown): {
-    reason: Extract<TelegramDeliveryFailureReason, "commit-unknown" | "message-unavailable" | "rate-limited" | "transport-retryable" | "transport-failed">;
-    retryAfterMs?: number;
-};
 /** @internal */
 export interface TelegramDeliveryTargetPolicyView {
     canDeliver: boolean;