@llblab/pi-kit 0.15.0 → 0.17.0

package/node_modules/@llblab/pi-telegram/dist/lib/extension.js

@@ -65,7 +65,7 @@ const telegramBusProtocolIdentity = Bus.createTelegramCurrentBusProtocolIdentity
 export default function (pi) {
     Skills.registerTelegramSkillDiscovery(pi);
     const piRuntime = Pi.createExtensionApiRuntimePorts(pi);
-    const { getActiveTools, getCommands, getThinkingLevel, sendUserMessage, setActiveTools, setModel, setThinkingLevel, } = piRuntime;
+    const { getActiveTools, getCommands, getThinkingLevel, sendUserMessage, registerCommand, setActiveTools, setModel, setThinkingLevel, } = piRuntime;
     const bridgeRuntime = Runtime.createTelegramBridgeRuntime();
     const runtimeDiagnostics = Logging.createTelegramRuntimeDiagnosticsRuntime();
     const runtimeEvents = runtimeDiagnostics.events;
@@ -185,6 +185,23 @@ export default function (pi) {
         canReset: lockRuntime.owns,
         commitReset: lockRuntime.commitIfOwned,
     });
+    const sessionActionAssembly = Commands.createTelegramSessionActionAssembly({
+        registerCommand,
+        sendUserMessage,
+        store: threadStore,
+        getProfileName: configStore.getActiveProfileName,
+        ownsPersistence: lockRuntime.owns,
+        async sendResult(target, html) {
+            const delivery = await Delivery.sendTelegramView({ text: html, parseMode: "html", replyMarkup: { inline_keyboard: [] } }, { scope: { kind: "target", target } });
+            return delivery.ok ? { ok: true } : { ok: false,
+                retryable: delivery.reason === "runtime-unavailable" ||
+                    delivery.reason === "target-unavailable" ||
+                    delivery.reason === "transport-retryable" };
+        },
+        handoffTtlMs: Threads.TELEGRAM_LEADER_SESSION_HANDOFF_TTL_MS,
+        recordRuntimeEvent,
+    });
+    const sessionActionsRuntime = sessionActionAssembly.action;
     const lockOwnershipGuard = Locks.createTelegramLockOwnershipGuard(lockRuntime);
     const getCurrentLeaderEpoch = lockRuntime.getOwnedLeaderEpoch;
     const telegramSessionContextStore = Lifecycle.createTelegramSessionContextStore({
@@ -673,6 +690,23 @@ export default function (pi) {
         updateStatusMessage: menuActions.updateStatusMessage,
         updateStatus,
     });
+    const threadDisplaySettingsRuntime = ThreadDisplay.createTelegramThreadDisplaySettingsRuntime({
+        getTarget() {
+            return telegramBusFollowerRegistrationState.getTarget() ??
+                telegramBusLeaderState.getTarget();
+        },
+        getBinding(target) { return threadStore.getWorkspaceBindingByTarget(target); },
+        apply(mode) {
+            return ThreadDisplay.applyTelegramThreadDisplaySetting(mode, {
+                getProfileKey: configStore.getActiveProfileName,
+                ownsLeader() { return getCurrentLeaderEpoch() !== undefined; },
+                getLeaderSetter() { return telegramBusLeaderRuntime.setThreadDisplayMode; },
+                getFollowerSetter() { return telegramBusFollowerRegistration.setThreadDisplayMode; },
+                reloadConfig: configStore.load,
+            });
+        },
+        reset(target) { return telegramThreadDisplayNameResetBinding.reset(target); },
+    });
     const settingsMenuRuntime = MenuSettings.createTelegramSettingsMenuRuntime({
         reloadConfig: configStore.load,
         getModelMenuState: getQueueMenuState,
@@ -687,15 +721,10 @@ export default function (pi) {
             return threadStore.getBotState().threadMode === "enabled"
                 ? Config.resolveTelegramThreadDisplayMode(configStore.get()) : undefined;
         },
+        isThreadDisplayCustom: threadDisplaySettingsRuntime.isCustom,
         async setThreadDisplayMode(mode) {
             try {
-                await ThreadDisplay.applyTelegramThreadDisplaySetting(mode, {
-                    getProfileKey: configStore.getActiveProfileName,
-                    ownsLeader() { return getCurrentLeaderEpoch() !== undefined; },
-                    getLeaderSetter() { return telegramBusLeaderRuntime.setThreadDisplayMode; },
-                    getFollowerSetter() { return telegramBusFollowerRegistration.setThreadDisplayMode; },
-                    reloadConfig: configStore.load,
-                });
+                await threadDisplaySettingsRuntime.setMode(mode);
             }
             catch (error) {
                 recordRuntimeEvent("bus", error, { phase: "thread-display-setting" });
@@ -767,6 +796,32 @@ export default function (pi) {
         foreignOwnedUpdateForwarder,
         replaceFollowerThreadTarget: restoreFollowerThreadTarget,
         bridgeRuntime,
+        requestNewSession(source) {
+            const updateId = Updates.getTelegramUpdateExecutionFence(source)?.updateId;
+            if (updateId === undefined) {
+                throw new Error("Telegram session replacement requires durable update authority.");
+            }
+            const callbackMessage = source && typeof source === "object" && "message" in source
+                ? source.message
+                : source;
+            const messageTarget = callbackMessage;
+            const target = typeof messageTarget?.chat?.id === "number" &&
+                typeof messageTarget.message_id === "number"
+                ? {
+                    chatId: messageTarget.chat.id,
+                    messageId: messageTarget.message_id,
+                    ...(typeof messageTarget.message_thread_id === "number"
+                        ? { threadId: messageTarget.message_thread_id }
+                        : {}),
+                }
+                : undefined;
+            if (!target) {
+                throw new Error("Telegram session replacement target is unavailable.");
+            }
+            if (!sessionActionsRuntime.scheduleAfterUpdate(updateId, target)) {
+                throw new Error("A Telegram session replacement is already pending.");
+            }
+        },
         activeTurnRuntime,
         mediaGroupRuntime,
         textGroupRuntime,
@@ -856,6 +911,7 @@ export default function (pi) {
             isContextCurrent: telegramSessionContextStore.isCurrent,
             dispatchNext: dispatchNextQueuedTelegramTurn,
             requestQueueHandoffReconciliation: queueHandoffReconciliationBinding.request,
+            afterUpdateCompleted: sessionActionsRuntime.onUpdateCompleted,
         },
         worker: {
             defaultHandle: inboundRouteRuntime.handleUpdate,
@@ -1366,6 +1422,7 @@ export default function (pi) {
             }
         },
     }.reset);
+    sessionActionsRuntime.register();
     Bindings.registerTelegramCommandsAndTools({
         pi,
         agentDir: Paths.resolveAgentDir(),
@@ -1566,6 +1623,9 @@ export default function (pi) {
         disconnectOnQuit: cleanupTelegramThreadForSessionRestart,
         shutdownGenerativeAppLiveSurfaces: generativeAppLiveSurfaceBinding.shutdown,
         resolveAutomaticThreadCleanupEnabled: configControls.resolveAutomaticThreadCleanupEnabled,
+        onSessionStarted(_event, ctx) {
+            sessionActionAssembly.settlement.onSessionStart(ctx);
+        },
         buttonActionStore,
         callMultipart,
         sendChatAction,

package/node_modules/@llblab/pi-telegram/dist/lib/menu-settings.d.ts

@@ -12,6 +12,7 @@ import type { TelegramVoiceReplyMode } from "./voice.ts";
 export type TelegramSettingsMenuReplyMarkup = TelegramInlineKeyboardMarkup;
 export interface TelegramSettingsStateDeps {
     getThreadDisplayMode?: () => TelegramThreadDisplayMode | undefined;
+    isThreadDisplayCustom?: () => boolean;
     areDraftPreviewsEnabled: () => boolean;
     getAssistantRenderingMode: () => TelegramAssistantRenderingMode;
     getActivityVerbosity: () => TelegramActivityVerbosity;
@@ -86,7 +87,7 @@ export declare const TIME_INJECTION_MODE_SETTINGS_TITLE = "<b>\uD83D\uDD52 Time
 export declare const VOICE_REPLY_MODE_SETTINGS_TITLE = "<b>\uD83D\uDC44 Voice reply mode:</b>";
 export declare const THREAD_DISPLAY_SETTINGS_TITLE = "<b>\uD83E\uDDF5 Thread display:</b>";
 export declare function buildTelegramSettingsMenuText(): string;
-export declare function buildThreadDisplaySettingsText(mode: TelegramThreadDisplayMode): string;
+export declare function buildThreadDisplaySettingsText(mode: TelegramThreadDisplayMode, custom?: boolean): string;
 export declare function buildAutomaticThreadCleanupSettingsText(enabled: boolean): string;
 export declare function buildInactiveThreadReviewText(count: number): string;
 export declare function buildInactiveThreadReviewReplyMarkup(operationId?: string, canCleanInactiveThreads?: boolean): TelegramSettingsMenuReplyMarkup;
@@ -95,9 +96,9 @@ export declare function buildAssistantRenderingSettingsText(mode: TelegramAssist
 export declare function buildActivityVerbositySettingsText(verbosity: TelegramActivityVerbosity): string;
 export declare function buildVoiceReplyModeSettingsText(mode: TelegramVoiceReplyMode, configured?: boolean): string;
 export declare function buildTimeInjectionModeSettingsText(mode: TelegramTimeMode): string;
-export declare function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled: boolean, assistantRenderingModeOrVoiceReplyMode: TelegramAssistantRenderingMode | TelegramVoiceReplyMode, voiceReplyModeOrTimeInjectionMode: TelegramVoiceReplyMode | TelegramTimeMode, timeInjectionModeOrSectionRegistry?: TelegramTimeMode | TelegramSectionRegistry, sectionRegistryOrVoiceReplyModeConfigured?: TelegramSectionRegistry | boolean, voiceReplyModeConfigured?: boolean, automaticThreadCleanupEnabled?: boolean, activityVerbosity?: TelegramActivityVerbosity, threadDisplayMode?: TelegramThreadDisplayMode): TelegramSettingsMenuReplyMarkup;
+export declare function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled: boolean, assistantRenderingModeOrVoiceReplyMode: TelegramAssistantRenderingMode | TelegramVoiceReplyMode, voiceReplyModeOrTimeInjectionMode: TelegramVoiceReplyMode | TelegramTimeMode, timeInjectionModeOrSectionRegistry?: TelegramTimeMode | TelegramSectionRegistry, sectionRegistryOrVoiceReplyModeConfigured?: TelegramSectionRegistry | boolean, voiceReplyModeConfigured?: boolean, automaticThreadCleanupEnabled?: boolean, activityVerbosity?: TelegramActivityVerbosity, threadDisplayMode?: TelegramThreadDisplayMode, threadDisplayCustom?: boolean): TelegramSettingsMenuReplyMarkup;
 export declare function openTelegramSettingsMenu<TModel extends MenuModel = MenuModel>(deps: TelegramSettingsMenuOpenDeps<TModel>, sectionRegistry?: TelegramSectionRegistry): Promise<void>;
-export declare function buildThreadDisplaySettingsReplyMarkup(mode: TelegramThreadDisplayMode): TelegramSettingsMenuReplyMarkup;
+export declare function buildThreadDisplaySettingsReplyMarkup(mode: TelegramThreadDisplayMode, custom?: boolean): TelegramSettingsMenuReplyMarkup;
 export declare function buildAutomaticThreadCleanupSettingsReplyMarkup(enabled: boolean, canReviewInactiveThreads?: boolean): TelegramSettingsMenuReplyMarkup;
 export declare function buildDraftPreviewsSettingsReplyMarkup(enabled: boolean): TelegramSettingsMenuReplyMarkup;
 export declare function buildAssistantRenderingSettingsReplyMarkup(mode: TelegramAssistantRenderingMode): TelegramSettingsMenuReplyMarkup;

package/node_modules/@llblab/pi-telegram/dist/lib/menu-settings.js

@@ -25,12 +25,14 @@ function getVoiceReplyModeSetting(mode, configured) {
 export function buildTelegramSettingsMenuText() {
     return SETTINGS_MENU_TITLE;
 }
-export function buildThreadDisplaySettingsText(mode) {
+export function buildThreadDisplaySettingsText(mode, custom = false) {
     return [
-        `${THREAD_DISPLAY_SETTINGS_TITLE} <code>${threadDisplayModeLabel(mode)}</code>`,
+        `${THREAD_DISPLAY_SETTINGS_TITLE} <code>${custom ? "custom" : threadDisplayModeLabel(mode)}</code>`,
         "",
         "Choose how this bot profile labels Telegram tabs and Pi terminal status. Each slot is unique across this bot profile.",
         "",
+        "Set a manual name for the current Thread with /name <code>Name</code>.",
+        "",
         "<code>-</code> <code>letters</code> (default): show the unique slot, such as <b><i>A</i></b> or <b><i>B</i></b>.",
         "<code>-</code> <code>names</code>: show the generated dictionary name for the slot, such as <b><i>Anchor</i></b> or <b><i>Briar</i></b>.",
         "<code>-</code> <code>directory-title</code>: humanize the distinguishing directory path, such as <b><i>Api Tools</i></b> or <b><i>Frontend / Extensions A</i></b>.",
@@ -122,7 +124,7 @@ export function buildTimeInjectionModeSettingsText(mode) {
         "<code>-</code> <code>interval</code> (default): add time at most once per chat interval (1 hour unless configured).",
     ].join("\n");
 }
-export function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled, assistantRenderingModeOrVoiceReplyMode, voiceReplyModeOrTimeInjectionMode, timeInjectionModeOrSectionRegistry, sectionRegistryOrVoiceReplyModeConfigured, voiceReplyModeConfigured = true, automaticThreadCleanupEnabled = true, activityVerbosity = "quiet", threadDisplayMode) {
+export function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled, assistantRenderingModeOrVoiceReplyMode, voiceReplyModeOrTimeInjectionMode, timeInjectionModeOrSectionRegistry, sectionRegistryOrVoiceReplyModeConfigured, voiceReplyModeConfigured = true, automaticThreadCleanupEnabled = true, activityVerbosity = "quiet", threadDisplayMode, threadDisplayCustom = false) {
     const hasRenderingMode = assistantRenderingModeOrVoiceReplyMode === "rich" ||
         assistantRenderingModeOrVoiceReplyMode === "html";
     const assistantRenderingMode = hasRenderingMode ? assistantRenderingModeOrVoiceReplyMode : "rich";
@@ -164,14 +166,13 @@ export function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled, assis
             text: `🕒 Time injection: ${getTelegramSettingsStateValueLabel(timeInjectionMode)}`,
             callback_data: "settings:open:time-injection",
         },
-        {
-            text: `🧹 Thread cleanup: ${automaticThreadCleanupEnabled ? "on" : "off"}`,
-            callback_data: "settings:open:automatic-thread-cleanup",
-        },
     ];
     if (threadDisplayMode)
         settingsButtons.push({
-            text: `🧵 Thread display: ${threadDisplayMode}`,
+            text: `🧹 Thread cleanup: ${automaticThreadCleanupEnabled ? "on" : "off"}`,
+            callback_data: "settings:open:automatic-thread-cleanup",
+        }, {
+            text: `🧵 Thread display: ${threadDisplayCustom ? "custom" : threadDisplayMode}`,
             callback_data: "settings:open:thread-display",
         });
     if (sectionRegistry) {
@@ -186,7 +187,7 @@ export function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled, assis
 }
 export async function openTelegramSettingsMenu(deps, sectionRegistry) {
     const state = await deps.getModelMenuState();
-    const messageId = await deps.sendSettingsMenu(state, buildTelegramSettingsMenuText(), buildTelegramSettingsMenuReplyMarkup(deps.areDraftPreviewsEnabled(), deps.getAssistantRenderingMode(), deps.getVoiceReplyMode(), deps.getTimeInjectionMode(), sectionRegistry, deps.isVoiceReplyModeConfigured(), deps.isAutomaticThreadCleanupEnabled(), deps.getActivityVerbosity(), deps.getThreadDisplayMode?.()));
+    const messageId = await deps.sendSettingsMenu(state, buildTelegramSettingsMenuText(), buildTelegramSettingsMenuReplyMarkup(deps.areDraftPreviewsEnabled(), deps.getAssistantRenderingMode(), deps.getVoiceReplyMode(), deps.getTimeInjectionMode(), sectionRegistry, deps.isVoiceReplyModeConfigured(), deps.isAutomaticThreadCleanupEnabled(), deps.getActivityVerbosity(), deps.getThreadDisplayMode?.(), deps.isThreadDisplayCustom?.() ?? false));
     if (messageId === undefined)
         return;
     state.messageId = messageId;
@@ -202,11 +203,11 @@ function threadDisplayModeLabel(mode) {
         default: return "letters";
     }
 }
-export function buildThreadDisplaySettingsReplyMarkup(mode) {
+export function buildThreadDisplaySettingsReplyMarkup(mode, custom = false) {
     return { inline_keyboard: [
             [{ text: "⬆️ Back", callback_data: "settings:list" }],
             ...["letters", "names", "directory-title", "directory-snake"].map((value) => [{
-                    text: `${mode === value ? "🟢 " : ""}${threadDisplayModeLabel(value)}`,
+                    text: `${!custom && mode === value ? "🟢 " : ""}${threadDisplayModeLabel(value)}`,
                     callback_data: `settings:set:thread-display:${value}`,
                 }]),
         ] };
@@ -307,7 +308,7 @@ export function buildVoiceReplyModeSettingsReplyMarkup(mode, configured = true)
     };
 }
 export async function updateTelegramSettingsMenuMessage(deps, sectionRegistry) {
-    await deps.updateSettingsMessage(buildTelegramSettingsMenuText(), buildTelegramSettingsMenuReplyMarkup(deps.areDraftPreviewsEnabled(), deps.getAssistantRenderingMode(), deps.getVoiceReplyMode(), deps.getTimeInjectionMode(), sectionRegistry, deps.isVoiceReplyModeConfigured(), deps.isAutomaticThreadCleanupEnabled(), deps.getActivityVerbosity(), deps.getThreadDisplayMode?.()));
+    await deps.updateSettingsMessage(buildTelegramSettingsMenuText(), buildTelegramSettingsMenuReplyMarkup(deps.areDraftPreviewsEnabled(), deps.getAssistantRenderingMode(), deps.getVoiceReplyMode(), deps.getTimeInjectionMode(), sectionRegistry, deps.isVoiceReplyModeConfigured(), deps.isAutomaticThreadCleanupEnabled(), deps.getActivityVerbosity(), deps.getThreadDisplayMode?.(), deps.isThreadDisplayCustom?.() ?? false));
 }
 export async function updateAutomaticThreadCleanupSettingsMessage(deps) {
     const enabled = deps.isAutomaticThreadCleanupEnabled();
@@ -362,7 +363,7 @@ export async function handleTelegramSettingsMenuCallbackAction(callbackQueryId,
             await deps.answerCallbackQuery(callbackQueryId, "Threaded Mode is no longer available.");
             return true;
         }
-        await deps.updateSettingsMessage(buildThreadDisplaySettingsText(mode), buildThreadDisplaySettingsReplyMarkup(mode));
+        await deps.updateSettingsMessage(buildThreadDisplaySettingsText(mode, deps.isThreadDisplayCustom?.() ?? false), buildThreadDisplaySettingsReplyMarkup(mode, deps.isThreadDisplayCustom?.() ?? false));
         await deps.answerCallbackQuery(callbackQueryId);
         return true;
     }
@@ -533,6 +534,7 @@ export function createTelegramSettingsMenuRuntime(deps, sectionRegistry) {
                 getTimeInjectionMode: deps.getTimeInjectionMode,
                 isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
                 getThreadDisplayMode: deps.getThreadDisplayMode,
+                isThreadDisplayCustom: deps.isThreadDisplayCustom,
                 sendSettingsMenu: (state, text, replyMarkup) => deps.sendInteractiveMessage(state.chatId, text, "html", replyMarkup),
                 storeModelMenuState: deps.storeModelMenuState,
             }, sectionRegistry);
@@ -548,6 +550,7 @@ export function createTelegramSettingsMenuRuntime(deps, sectionRegistry) {
                 getTimeInjectionMode: deps.getTimeInjectionMode,
                 isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
                 getThreadDisplayMode: deps.getThreadDisplayMode,
+                isThreadDisplayCustom: deps.isThreadDisplayCustom,
                 updateSettingsMessage: (text, replyMarkup) => deps.editInteractiveMessage(state.chatId, state.messageId, text, "html", replyMarkup),
             }, sectionRegistry);
         },
@@ -577,6 +580,7 @@ export function createTelegramSettingsMenuRuntime(deps, sectionRegistry) {
                 getTimeInjectionMode: deps.getTimeInjectionMode,
                 isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
                 getThreadDisplayMode: deps.getThreadDisplayMode,
+                isThreadDisplayCustom: deps.isThreadDisplayCustom,
                 setThreadDisplayMode: deps.setThreadDisplayMode,
                 setDraftPreviewsEnabled: deps.setDraftPreviewsEnabled,
                 setAssistantRenderingMode: deps.setAssistantRenderingMode,

package/node_modules/@llblab/pi-telegram/dist/lib/pi.d.ts

@@ -56,8 +56,9 @@ export interface PiExtensionApiRuntimePorts {
     getActiveTools: ExtensionAPI["getActiveTools"];
     setActiveTools: ExtensionAPI["setActiveTools"];
     setModel: ExtensionAPI["setModel"];
+    registerCommand: ExtensionAPI["registerCommand"];
 }
-export declare function createExtensionApiRuntimePorts(api: Pick<ExtensionAPI, "sendUserMessage" | "exec" | "getCommands" | "getThinkingLevel" | "setThinkingLevel" | "getActiveTools" | "setActiveTools" | "setModel">): PiExtensionApiRuntimePorts;
+export declare function createExtensionApiRuntimePorts(api: Pick<ExtensionAPI, "sendUserMessage" | "exec" | "getCommands" | "getThinkingLevel" | "setThinkingLevel" | "getActiveTools" | "setActiveTools" | "setModel" | "registerCommand">): PiExtensionApiRuntimePorts;
 export declare function normalizeSettingsManager(manager: unknown): PiSettingsManager;
 export declare function createSettingsManager(cwd: string): Promise<PiSettingsManager>;
 export declare function createScopedModelPatternPersister(deps: {

package/node_modules/@llblab/pi-telegram/dist/lib/pi.js

@@ -44,6 +44,7 @@ export function createExtensionApiRuntimePorts(api) {
         getActiveTools: () => api.getActiveTools(),
         setActiveTools: (names) => api.setActiveTools(names),
         setModel: (model) => api.setModel(model),
+        registerCommand: (name, options) => api.registerCommand(name, options),
     };
 }
 function readEnabledModels(value) {

package/node_modules/@llblab/pi-telegram/dist/lib/routing.d.ts

@@ -164,6 +164,7 @@ export interface TelegramInboundRouteRuntimeDeps<TMessage extends TelegramRouted
     sendUserMessage?: (message: string, options?: Queue.TelegramPromptDeliveryOptions) => void;
     isIdle: (ctx: TContext) => boolean;
     hasPendingMessages: (ctx: TContext) => boolean;
+    requestNewSession?: (source: unknown) => void;
     compact: (ctx: TContext, callbacks: {
         onComplete: () => void;
         onError: (error: unknown) => void;

package/node_modules/@llblab/pi-telegram/dist/lib/routing.js

@@ -322,6 +322,7 @@ const TELEGRAM_OWNED_CALLBACK_PREFIXES = [
     "compact:",
     "menu:",
     "model:",
+    "new:",
     "queue:",
     "section:",
     "settings:",
@@ -1216,7 +1217,7 @@ export function createTelegramInboundRouteRuntime(deps) {
                 return;
             }
             if (selected.kind === "cancel") {
-                await deps.editInteractiveMessage?.(chatId, dialogMessageId, "<b>✖ Rename cancelled. Returning to normal agent mode.</b>", "html", { inline_keyboard: [] });
+                await deps.editInteractiveMessage?.(chatId, dialogMessageId, "<b>✖ Rename cancelled.</b>", "html", { inline_keyboard: [] });
                 await deps.answerCallbackQuery(query.id);
                 return;
             }
@@ -1241,6 +1242,36 @@ export function createTelegramInboundRouteRuntime(deps) {
             }
             return;
         }
+        const handledByNew = await Commands.handleTelegramNewConfirmationCallback(query, {
+            ctx,
+            answerCallbackQuery: deps.answerCallbackQuery,
+            editInteractiveMessage: deps.editInteractiveMessage ?? (async () => { }),
+            deleteMessage: deps.deleteMessage ?? (async () => { }),
+            runNew: async (newCtx) => {
+                await Commands.handleTelegramNewCommand({
+                    isIdle: () => deps.isIdle(newCtx),
+                    hasPendingMessages: () => deps.hasPendingMessages(newCtx),
+                    hasActiveTelegramTurn: deps.activeTurnRuntime.has,
+                    hasDispatchPending: deps.bridgeRuntime.lifecycle.hasDispatchPending,
+                    hasQueuedTelegramItems: deps.telegramQueueStore.hasQueuedItems,
+                    isCompactionInProgress: deps.bridgeRuntime.lifecycle.isCompactionInProgress,
+                    requestNewSession: deps.requestNewSession
+                        ? () => deps.requestNewSession(query)
+                        : undefined,
+                    sendTextReply: async (text) => {
+                        const chatId = query.message?.chat?.id;
+                        const messageId = query.message?.message_id;
+                        if (typeof chatId !== "number" || typeof messageId !== "number")
+                            return;
+                        await deps.editInteractiveMessage?.(chatId, messageId, text, "html", { inline_keyboard: [] });
+                    },
+                    recordRuntimeEvent: deps.recordRuntimeEvent,
+                });
+            },
+        });
+        assertExecutionCurrent();
+        if (handledByNew)
+            return;
         const handledByCompact = await Commands.handleTelegramCompactConfirmationCallback(query, {
             ctx,
             answerCallbackQuery: deps.answerCallbackQuery,
@@ -1392,6 +1423,7 @@ export function createTelegramInboundRouteRuntime(deps) {
         stopTypingLoop: deps.stopTypingLoop,
         enqueueContinueTurn,
         compact: deps.compact,
+        requestNewSession: deps.requestNewSession,
         allocateItemOrder: deps.bridgeRuntime.queue.allocateItemOrder,
         allocateControlOrder: deps.bridgeRuntime.queue.allocateControlOrder,
         appendControlItem: deps.queueMutationRuntime.append,
@@ -1652,9 +1684,18 @@ export function createTelegramInboundRouteRuntime(deps) {
                         dialogMessageId: candidate.dialogMessageId,
                     });
                 }
-                await deps.sendTextReply(target.chatId, message.message_id, result.ok && !result.message
+                const replyText = result.ok && !result.message
                     ? Commands.formatTelegramAutomaticThreadDisplayNameRestoredHeading(result.threadName ?? name)
-                    : Commands.formatTelegramInformationHeading(result.ok ? "✅" : "⚠️", result.message ?? "Thread display name reset failed."), { parseMode: "HTML", target });
+                    : Commands.formatTelegramInformationHeading(result.ok ? "✅" : "⚠️", result.message ?? "Thread display name reset failed.");
+                if (result.ok) {
+                    Updates.assertTelegramUpdateExecutionCurrent(message);
+                    Updates.reportTelegramUpdateCompleted(message);
+                    void deps.sendTextReply(target.chatId, message.message_id, replyText, { parseMode: "HTML", target }).catch((error) => deps.recordRuntimeEvent?.("telegram-command", error, {
+                        command: "name", phase: "reset-result",
+                    }));
+                    return true;
+                }
+                await deps.sendTextReply(target.chatId, message.message_id, replyText, { parseMode: "HTML", target });
                 return true;
             }
             const validationError = deps.validateThreadName?.(name);
@@ -1677,9 +1718,18 @@ export function createTelegramInboundRouteRuntime(deps) {
                     dialogMessageId: candidate.dialogMessageId,
                 });
             }
-            await deps.sendTextReply(target.chatId, message.message_id, result?.ok && !result.message
+            const replyText = result?.ok && !result.message
                 ? Commands.formatTelegramThreadDisplayNameSavedHeading(result.threadName ?? consumed.name)
-                : Commands.formatTelegramInformationHeading(result?.ok ? "✅" : "⚠️", result?.message ?? "Thread display name update failed."), { parseMode: "HTML", target });
+                : Commands.formatTelegramInformationHeading(result?.ok ? "✅" : "⚠️", result?.message ?? "Thread display name update failed.");
+            if (result?.ok) {
+                Updates.assertTelegramUpdateExecutionCurrent(message);
+                Updates.reportTelegramUpdateCompleted(message);
+                void deps.sendTextReply(target.chatId, message.message_id, replyText, { parseMode: "HTML", target }).catch((error) => deps.recordRuntimeEvent?.("telegram-command", error, {
+                    command: "name", phase: "rename-result",
+                }));
+                return true;
+            }
+            await deps.sendTextReply(target.chatId, message.message_id, replyText, { parseMode: "HTML", target });
             return true;
         },
         handleCommand: commandHandler,

package/node_modules/@llblab/pi-telegram/dist/lib/thread-display.d.ts

@@ -38,6 +38,29 @@ export interface TelegramThreadDisplayReconcilerDeps {
     captureLiveBindingKeys(bindings: readonly TelegramWorkspaceThreadBinding[]): ReadonlySet<string>;
     callApi<TResponse>(method: string, body: Record<string, unknown>, options?: TelegramApiCallOptions): Promise<TResponse>;
 }
+export declare function createTelegramThreadDisplaySettingsRuntime(deps: {
+    getTarget(): {
+        chatId: number;
+        threadId?: number;
+    } | undefined;
+    getBinding(target: {
+        chatId: number;
+        threadId?: number;
+    }): {
+        manualThreadName?: string;
+    } | undefined;
+    apply(mode: TelegramThreadDisplayMode): Promise<void>;
+    reset(target: {
+        chatId: number;
+        threadId?: number;
+    }): Promise<{
+        ok: boolean;
+        message?: string;
+    }>;
+}): {
+    isCustom(): boolean;
+    setMode(mode: TelegramThreadDisplayMode): Promise<void>;
+};
 /** Caller owns triggering and reporting; no timer or background retry is created. */
 export declare function createTelegramThreadDisplayReconciler(deps: TelegramThreadDisplayReconcilerDeps): {
     reconcile(): Promise<{

package/node_modules/@llblab/pi-telegram/dist/lib/thread-display.js

@@ -192,6 +192,26 @@ export async function applyTelegramThreadDisplaySetting(mode, deps) {
     if (deps.getProfileKey() !== profile)
         throw new Error("Telegram Thread display setting changed profile.");
 }
+export function createTelegramThreadDisplaySettingsRuntime(deps) {
+    return {
+        isCustom() {
+            const target = deps.getTarget();
+            return !!target && typeof deps.getBinding(target)?.manualThreadName === "string";
+        },
+        async setMode(mode) {
+            const target = deps.getTarget();
+            const hadManualName = !!target &&
+                typeof deps.getBinding(target)?.manualThreadName === "string";
+            await deps.apply(mode);
+            if (!hadManualName || !target)
+                return;
+            const reset = await deps.reset(target);
+            if (!reset.ok) {
+                throw new Error(reset.message ?? "Telegram Thread display override reset failed.");
+            }
+        },
+    };
+}
 /** Caller owns triggering and reporting; no timer or background retry is created. */
 export function createTelegramThreadDisplayReconciler(deps) {
     let tail = Promise.resolve();

package/node_modules/@llblab/pi-telegram/dist/lib/threads.d.ts

@@ -175,6 +175,19 @@ export interface TelegramBotStateSnapshot {
     lastSlot?: string;
     lastReconcileAction?: string;
 }
+export interface TelegramSessionReplacementIntent {
+    continuity: "workspace-thread" | "classic-chat";
+    cwd: string;
+    profileName: string;
+    sourceSessionId: string;
+    sourceUpdateId: number;
+    target: TelegramTarget;
+    messageId: number;
+    slot?: string;
+    threadName?: string;
+    createdAtMs: number;
+    expiresAtMs: number;
+}
 export interface TelegramTopicTargetFile {
     version: 1;
     source: "snapshot";
@@ -187,6 +200,7 @@ export interface TelegramTopicTargetFile {
     identities?: TelegramThreadIdentityRecord[];
     workspaceBindings?: TelegramWorkspaceThreadBinding[];
     workspaceRetirements?: TelegramWorkspaceRetirementIntent[];
+    sessionReplacement?: TelegramSessionReplacementIntent;
     reservations?: TelegramThreadReservation[];
     pendingProvisions?: TelegramThreadPendingProvision[];
     pendingCleanups?: TelegramThreadCleanupIntent[];
@@ -227,6 +241,10 @@ export interface TelegramTopicTargetStore {
     getIdentityByProfileKey: (profileKey: string) => TelegramThreadIdentityRecord | undefined;
     forgetIdentityByProfileKey: (profileKey: string) => boolean;
     listWorkspaceBindings: () => TelegramWorkspaceThreadBinding[];
+    getWorkspaceBindingByTarget: (target: TelegramTarget, sessionId?: string) => TelegramWorkspaceThreadBinding | undefined;
+    getSessionReplacementIntent: () => TelegramSessionReplacementIntent | undefined;
+    commitSessionReplacementIntent: (intent: TelegramSessionReplacementIntent, isCurrent: () => boolean) => Promise<boolean>;
+    removeSessionReplacementIntent: (expected: TelegramSessionReplacementIntent, isCurrent: () => boolean) => Promise<boolean>;
     listWorkspaceRetirementIntents: () => TelegramWorkspaceRetirementIntent[];
     commitWorkspaceJournalEvidence: (expected: TelegramWorkspaceThreadBinding, journalBindingKeys: readonly string[], complete: boolean) => TelegramWorkspaceThreadBinding | undefined;
     upsertWorkspaceRetirementIntent: (intent: TelegramWorkspaceRetirementIntent) => boolean;