@nordbyte/nordrelay 0.4.1 → 0.5.1

package/dist/bot.js

@@ -1,105 +1,59 @@
 import { randomUUID } from "node:crypto";
-import { readFile, unlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { readFile, unlink } from "node:fs/promises";
 import path from "node:path";
 import { autoRetry } from "@grammyjs/auto-retry";
 import { Bot, InlineKeyboard, InputFile } from "grammy";
-import { hasTelegramPermission, permissionForCallbackData, permissionForCommand, } from "./access-control.js";
+import { ADMIN_GROUP_ID } from "./access-control.js";
 import { buildFileInstructions, outboxPath, stageFile, } from "./attachments.js";
-import { collectArtifactReport, collectRecentWorkspaceArtifacts, createArtifactZipBundle, ensureOutDir, formatArtifactSummary, getArtifactTurnReport, isTelegramImagePreview, listRecentArtifactReports, persistWorkspaceArtifactReport, pruneConnectorTurnDirs, removeArtifactTurn, telegramArtifactFilename, totalArtifactSize, } from "./artifacts.js";
-import { listAgentAdapterDescriptors } from "./agent-adapter.js";
+import { collectArtifactReport, collectRecentWorkspaceArtifacts, createArtifactZipBundle, ensureOutDir, formatArtifactSummary, isTelegramImagePreview, persistWorkspaceArtifactReport, pruneConnectorTurnDirs, telegramArtifactFilename, totalArtifactSize, } from "./artifacts.js";
 import { AgentUpdateManager } from "./agent-updates.js";
 import { AuditLogStore } from "./audit-log.js";
-import { formatSessionLabel, renderHelpMessage, renderWelcomeFirstTime, renderWelcomeReturning, } from "./bot-ui.js";
-import { BotPreferencesStore, formatQuietHours, isQuietNow, parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
-import { logTailRequests, parseAgentUpdateId, parseLogsCommand, renderAgentUpdateJobAction, renderAgentUpdateJobsAction, renderAgentUpdateLogAction, renderAgentUpdatePickerAction, renderAgentsAction, renderArtifactReportsAction, renderChannelsAction, renderLogTailsAction, renderQueueListAction, renderQueuedPromptDetailAction, renderSelfUpdateStartedAction, } from "./channel-actions.js";
-import { listChannelDescriptors } from "./channel-adapter.js";
-import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
-import { getAgentActivityLog, getAgentDiagnostics, getExternalActivityForSession, getExternalSnapshotForSession, } from "./agent-activity.js";
-import { enabledAgents } from "./agent-factory.js";
+import { formatSessionLabel } from "./bot-ui.js";
+import { BotPreferencesStore, isQuietNow, } from "./bot-preferences.js";
+import { renderAgentUpdateJobAction } from "./channel-actions.js";
+import { deliverChannelAction } from "./channel-runtime.js";
+import { agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
+import { getExternalActivityForSession, getExternalSnapshotForSession, } from "./agent-activity.js";
 import { checkAuthStatus, clearAuthCache, startLogin as startCodexLogin, startLogout as startCodexLogout } from "./codex-auth.js";
 import { checkClaudeCodeAuthStatus, startClaudeCodeLogin, startClaudeCodeLogout } from "./claude-code-auth.js";
 import { formatLaunchProfileBehavior } from "./codex-launch.js";
 import { contextKeyFromCtx, isTelegramContextKey, isTopicContextKey, parseContextKey } from "./context-key.js";
 import { friendlyErrorText } from "./error-messages.js";
-import { escapeHTML, formatTelegramHTML } from "./format.js";
-import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate, } from "./operations.js";
+import { escapeHTML } from "./format.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
 import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
 import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { configureRedaction, redactText } from "./redaction.js";
 import { canWriteWithLock, SessionLockStore } from "./session-locks.js";
-import { renderLaunchSummaryHTML, renderLaunchSummaryPlain, renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
+import { renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
 import { SessionRegistry } from "./session-registry.js";
-import { getAvailableBackends, transcribeAudio } from "./voice.js";
-import { getTelegramRateLimitMetrics, telegramRateLimiter } from "./telegram-rate-limit.js";
+import { transcribeAudio } from "./voice.js";
+import { telegramRateLimiter } from "./telegram-rate-limit.js";
+import { chatBucket, downloadTelegramFile, isMessageNotModifiedError, renderMarkdownChunkWithinLimit, safeEditMessage, safeEditReplyMarkup, safeReply, sendChatActionSafe, sendTextMessage, splitMarkdownForTelegram, } from "./telegram-output.js";
+import { NOOP_PAGE_CALLBACK_DATA, TelegramBotChannelRuntime, paginateKeyboard, telegramChannelContextFromCtx, } from "./telegram-channel-runtime.js";
+import { createTelegramAccessMiddleware } from "./telegram-access-middleware.js";
+import { registerTelegramAccessCommands } from "./telegram-access-commands.js";
+import { registerTelegramAgentCommands } from "./telegram-agent-commands.js";
+import { registerTelegramArtifactCommands } from "./telegram-artifact-commands.js";
+import { registerTelegramDiagnosticsCommands } from "./telegram-diagnostics-command.js";
+import { registerTelegramGeneralCommands } from "./telegram-general-commands.js";
+import { registerTelegramOperationalCommands } from "./telegram-operational-commands.js";
+import { registerTelegramPreferenceCommands } from "./telegram-preference-commands.js";
+import { createQueuedPromptCancelKeyboard, registerTelegramQueueCommands, } from "./telegram-queue-commands.js";
+import { registerTelegramSupportCommands } from "./telegram-support-command.js";
+import { registerTelegramUpdateCommands } from "./telegram-update-commands.js";
+import { appendWithCap, authHelpText, buildStreamingPreview, capabilitiesOf, filterSessions, formatAgentLaunchProfileLabel, formatAgentSettingScope, formatDurationSeconds, formatError, formatLocalDateTime, formatLockOwner, formatModelButtonLabel, formatRelativeTime, formatTelegramName, formatToolSummaryLine, formatTurnUsageLine, getWorkspaceShortName, idOf, isEmptyArtifactReport, isPromptEnvelopeLike, isQueuedPromptLike, labelOf, orderPinnedSessions, parseFastModeArgument, renderExternalMirrorEvent, renderExternalMirrorStatus, renderPromptFailure, renderTodoList, renderToolEndMessage, renderToolStartMessage, requiresTurnApproval, trimLine, } from "./bot-rendering.js";
+import { UserStore } from "./user-management.js";
 import { evaluateWorkspacePolicy, filterAllowedWorkspaces, renderWorkspacePolicyLine, } from "./workspace-policy.js";
-const TELEGRAM_MESSAGE_LIMIT = 4000;
+export { formatToolSummaryLine, formatTurnUsageLine, summarizeToolName } from "./bot-rendering.js";
+export { registerCommands } from "./telegram-command-menu.js";
 const EDIT_DEBOUNCE_MS = 1500;
 const TYPING_INTERVAL_MS = 4500;
 const TOOL_OUTPUT_PREVIEW_LIMIT = 500;
-const STREAMING_PREVIEW_LIMIT = 3800;
-const FORMATTED_CHUNK_TARGET = 3000;
 const MAX_AUDIO_FILE_SIZE = 25 * 1024 * 1024;
 const MEDIA_GROUP_FLUSH_MS = 1200;
-const KEYBOARD_PAGE_SIZE = 6;
-const NOOP_PAGE_CALLBACK_DATA = "noop_page";
 const LAUNCH_PROFILES_COMMAND = "/launch_profiles";
-function paginateKeyboard(items, page, prefix) {
-    const totalPages = Math.max(1, Math.ceil(items.length / KEYBOARD_PAGE_SIZE));
-    const currentPage = Math.min(Math.max(page, 0), totalPages - 1);
-    const start = currentPage * KEYBOARD_PAGE_SIZE;
-    const pageItems = items.slice(start, start + KEYBOARD_PAGE_SIZE);
-    const keyboard = new InlineKeyboard();
-    pageItems.forEach((item, index) => {
-        keyboard.text(item.label, item.callbackData);
-        if (index < pageItems.length - 1 || totalPages > 1) {
-            keyboard.row();
-        }
-    });
-    if (totalPages > 1) {
-        if (currentPage > 0) {
-            keyboard.text("◀️ Prev", `${prefix}_page_${currentPage - 1}`);
-        }
-        keyboard.text(`${currentPage + 1}/${totalPages}`, NOOP_PAGE_CALLBACK_DATA);
-        if (currentPage < totalPages - 1) {
-            keyboard.text("Next ▶️", `${prefix}_page_${currentPage + 1}`);
-        }
-    }
-    return keyboard;
-}
-function actionKeyboard(rows) {
-    if (!rows || rows.length === 0) {
-        return undefined;
-    }
-    const keyboard = new InlineKeyboard();
-    for (const row of rows) {
-        for (const button of row) {
-            keyboard.text(button.label, telegramActionData(button.action));
-        }
-        keyboard.row();
-    }
-    return keyboard;
-}
-function telegramActionData(action) {
-    if (action === "agent-update:jobs") {
-        return "upd_jobs";
-    }
-    const agentUpdateStart = action.match(/^agent-update:start:(.+)$/);
-    if (agentUpdateStart?.[1]) {
-        return `upd_agent:${agentUpdateStart[1]}`;
-    }
-    const agentUpdateLog = action.match(/^agent-update:log:(.+)$/);
-    if (agentUpdateLog?.[1]) {
-        return `upd_log:${agentUpdateLog[1]}`;
-    }
-    const agentUpdateCancel = action.match(/^agent-update:cancel:(.+)$/);
-    if (agentUpdateCancel?.[1]) {
-        return `upd_cancel:${agentUpdateCancel[1]}`;
-    }
-    return action;
-}
 export function createBot(config, registry) {
     configureRedaction(config.telegramRedactPatterns);
     telegramRateLimiter.configure({
@@ -109,6 +63,7 @@ export function createBot(config, registry) {
     });
     const bot = new Bot(config.telegramBotToken);
     bot.api.config.use(autoRetry({ maxRetryAttempts: 3, maxDelaySeconds: 10 }));
+    const telegramChannelRuntime = new TelegramBotChannelRuntime(bot);
     const contextBusy = new Map();
     const pendingApprovals = new Map();
     const pendingSessionPicks = new Map();
@@ -127,7 +82,10 @@ export function createBot(config, registry) {
     const preferencesStore = new BotPreferencesStore(config.workspace, config.stateBackend);
     const auditLog = new AuditLogStore(config.workspace, config.stateBackend, config.auditMaxEvents);
     const lockStore = new SessionLockStore(config.workspace, config.stateBackend);
+    const userStore = new UserStore();
+    const contextUsers = new WeakMap();
     const agentUpdates = new AgentUpdateManager();
+    const linkAttempts = new Map();
     const drainingQueues = new Set();
     const externalQueueTimers = new Map();
     const externalMirrors = new Map();
@@ -254,15 +212,22 @@ export function createBot(config, registry) {
         }
         return checkAuthStatus(config.codexApiKey);
     };
+    const replyChannelAction = async (ctx, rendered) => {
+        const channelContext = telegramChannelContextFromCtx(ctx);
+        if (!channelContext) {
+            return;
+        }
+        await deliverChannelAction(telegramChannelRuntime, channelContext, rendered);
+    };
     const agentUpdateContext = () => ({
         piCliPath: config.piCliPath,
         hermesCliPath: config.hermesCliPath,
         openClawCliPath: config.openClawCliPath,
         claudeCodeCliPath: config.claudeCodeCliPath,
     });
-    const startTelegramAgentUpdate = async (ctx, agentId) => {
+    const startTelegramAgentUpdate = async (ctx, agentId, operation = "update") => {
         try {
-            const job = agentUpdates.start(agentId, agentUpdateContext());
+            const job = agentUpdates.start(agentId, agentUpdateContext(), operation);
             const contextKey = contextKeyFromCtx(ctx);
             if (contextKey) {
                 audit({
@@ -270,19 +235,17 @@ export function createBot(config, registry) {
                     status: "ok",
                     contextKey,
                     agentId,
-                    description: `update ${agentId}`,
+                    description: `${operation} ${agentId}`,
                     detail: job.summary,
                 });
             }
             const rendered = renderAgentUpdateJobAction(job);
-            await safeReply(ctx, rendered.html, {
-                fallbackText: rendered.plain,
-                replyMarkup: actionKeyboard(rendered.buttons),
-            });
+            await replyChannelAction(ctx, rendered);
         }
         catch (error) {
-            const message = `Failed to start ${agentLabel(agentId)} update: ${friendlyErrorText(error)}`;
-            await safeReply(ctx, `<b>Update failed:</b> ${escapeHTML(message)}`, { fallbackText: message });
+            const message = `Failed to start ${agentLabel(agentId)} ${operation}: ${friendlyErrorText(error)}`;
+            const label = operation === "install" ? "Install" : "Update";
+            await safeReply(ctx, `<b>${label} failed:</b> ${escapeHTML(message)}`, { fallbackText: message });
         }
     };
     const startAgentLogin = (info) => {
@@ -385,28 +348,6 @@ export function createBot(config, registry) {
             fallbackText: "Still working on previous message...",
         });
     };
-    const queueCancelCallbackData = (action, contextKey, queueId) => `queue_${action}:${contextKey}:${queueId}`;
-    const createQueuedPromptCancelKeyboard = (contextKey, queueId, label = "Cancel queued message") => new InlineKeyboard().text(label, queueCancelCallbackData("cancel", contextKey, queueId));
-    const renderQueueList = (contextKey, queue) => {
-        const paused = promptStore.isPaused(contextKey);
-        const rendered = renderQueueListAction(queue, paused);
-        if (queue.length === 0) {
-            return rendered;
-        }
-        const keyboard = new InlineKeyboard();
-        queue.forEach((item, index) => {
-            keyboard
-                .text(`Run ${index + 1}`, queueCancelCallbackData("run", contextKey, item.id))
-                .text("Top", queueCancelCallbackData("top", contextKey, item.id))
-                .text("Cancel", queueCancelCallbackData("remove", contextKey, item.id))
-                .row();
-            keyboard
-                .text("Up", queueCancelCallbackData("up", contextKey, item.id))
-                .text("Down", queueCancelCallbackData("down", contextKey, item.id))
-                .row();
-        });
-        return { ...rendered, keyboard };
-    };
     const createSystemContext = (contextKey) => {
         const parsed = parseContextKey(contextKey);
         return {
@@ -416,6 +357,9 @@ export function createBot(config, registry) {
         };
     };
     const updateQueueStatusMessage = async (contextKey, text) => {
+        if (!canSendSystemMessagesToContext(contextKey)) {
+            return;
+        }
         const parsed = parseContextKey(contextKey);
         const html = escapeHTML(text);
         const state = queueStatusMessages.get(contextKey) ?? {};
@@ -458,6 +402,9 @@ export function createBot(config, registry) {
         if (!isTelegramContextKey(contextKey)) {
             return;
         }
+        if (!canSendSystemMessagesToContext(contextKey)) {
+            return;
+        }
         const session = await registry.getOrCreate(contextKey, { deferThreadStart: true }).catch(() => null);
         if (!session) {
             return;
@@ -606,7 +553,20 @@ export function createBot(config, registry) {
         }
         state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
     };
+    const canSendSystemMessagesToContext = (contextKey) => {
+        if (!userStore.hasAdminUser()) {
+            return false;
+        }
+        const parsed = parseContextKey(contextKey);
+        if (parsed.chatId > 0) {
+            return Boolean(userStore.resolveTelegramUser(parsed.chatId));
+        }
+        return userStore.snapshot().telegramChats.some((chat) => chat.chatId === parsed.chatId && chat.enabled);
+    };
     const deliverCliGeneratedArtifacts = async (contextKey, chatId, session, startedAt, turnId, messageThreadId) => {
+        if (!canSendSystemMessagesToContext(contextKey)) {
+            return;
+        }
         if (!startedAt || !turnId) {
             return;
         }
@@ -658,6 +618,9 @@ export function createBot(config, registry) {
                 if (promptStore.list(contextKey).length === 0) {
                     return;
                 }
+                if (!canSendSystemMessagesToContext(contextKey)) {
+                    return;
+                }
                 const busy = getBusyReason(contextKey);
                 if (busy.kind === "external") {
                     const label = busy.activity.agentLabel;
@@ -677,37 +640,12 @@ export function createBot(config, registry) {
         timer.unref?.();
         externalQueueTimers.set(contextKey, timer);
     };
+    const getAuthenticatedUser = (ctx) => contextUsers.get(ctx) ?? null;
     const getUserRole = (ctx) => {
-        const fromId = ctx.from?.id;
-        if (fromId !== undefined && config.telegramAdminUserIdSet.has(fromId)) {
-            return "admin";
-        }
-        if (fromId !== undefined && config.telegramReadOnlyUserIdSet.has(fromId)) {
-            return "readonly";
-        }
-        return "operator";
-    };
-    const getRequiredPermission = (ctx) => {
-        if (ctx.callbackQuery?.data) {
-            return permissionForCallbackData(ctx.callbackQuery.data);
-        }
-        if (ctx.message?.voice || ctx.message?.audio || ctx.message?.photo || ctx.message?.document) {
-            return "files";
-        }
-        const text = ctx.message?.text?.trim();
-        if (!text) {
-            return "inspect";
-        }
-        if (!text.startsWith("/")) {
-            return "prompt";
-        }
-        const command = extractCommandName(text);
-        if (command === "queue") {
-            const argument = text.replace(/^\/queue(?:@\w+)?\s*/i, "").trim();
-            return argument ? "prompt" : "inspect";
-        }
-        return permissionForCommand(command);
+        const authUser = getAuthenticatedUser(ctx);
+        return authUser?.groups.map((group) => group.name).join(", ") || "unauthenticated";
     };
+    const isAdminUser = (ctx) => Boolean(getAuthenticatedUser(ctx)?.groups.some((group) => group.id === ADMIN_GROUP_ID));
     const audit = (event) => {
         try {
             auditLog.append(event);
@@ -730,7 +668,7 @@ export function createBot(config, registry) {
     };
     const denyIfLocked = async (ctx, contextKey, session) => {
         const lock = lockStore.get(contextKey);
-        const isAdmin = getUserRole(ctx) === "admin";
+        const isAdmin = isAdminUser(ctx);
         if (canWriteWithLock(lock, ctx.from?.id, isAdmin)) {
             return false;
         }
@@ -801,6 +739,9 @@ export function createBot(config, registry) {
             }
             pendingApprovals.delete(approvalId);
             getBusyState(contextKey).approving = false;
+            if (!canSendSystemMessagesToContext(contextKey)) {
+                return;
+            }
             const parsed = parseContextKey(contextKey);
             void sendTextMessage(bot.api, parsed.chatId, `Approval timed out for prompt ${approvalId}.`, {
                 messageThreadId: parsed.messageThreadId,
@@ -831,6 +772,9 @@ export function createBot(config, registry) {
         await safeReply(ctx, html, { fallbackText: plain, replyMarkup: keyboard });
     };
     const handleUserPrompt = async (ctx, contextKey, chatId, session, prompt, options = {}) => {
+        if (!canSendSystemMessagesToContext(contextKey)) {
+            return;
+        }
         const parsed = parseContextKey(contextKey);
         const messageThreadId = parsed.messageThreadId;
         const envelope = isPromptEnvelopeLike(prompt) ? prompt : toPromptEnvelope(prompt);
@@ -1374,6 +1318,9 @@ export function createBot(config, registry) {
         if (drainingQueues.has(contextKey)) {
             return;
         }
+        if (!canSendSystemMessagesToContext(contextKey)) {
+            return;
+        }
         drainingQueues.add(contextKey);
         try {
             while (true) {
@@ -1536,16 +1483,25 @@ export function createBot(config, registry) {
         clearTimeout(pending.timer);
         pendingMediaGroups.delete(key);
         try {
+            if (!canSendSystemMessagesToContext(pending.contextKey)) {
+                return;
+            }
             await processMediaGroup(pending);
         }
         catch (error) {
             console.error("Failed to process media group:", error);
+            if (!canSendSystemMessagesToContext(pending.contextKey)) {
+                return;
+            }
             await safeReply(pending.ctx, `<b>Failed to process media group:</b> ${escapeHTML(friendlyErrorText(error))}`, {
                 fallbackText: `Failed to process media group: ${friendlyErrorText(error)}`,
             });
         }
     };
     const processMediaGroup = async (pending) => {
+        if (!canSendSystemMessagesToContext(pending.contextKey)) {
+            return;
+        }
         const busyState = getBusyState(pending.contextKey);
         busyState.transcribing = true;
         const turnId = randomUUID().slice(0, 12);
@@ -1596,10 +1552,16 @@ export function createBot(config, registry) {
             busyState.transcribing = false;
         }
         if (stagedFiles.length === 0) {
+            if (!canSendSystemMessagesToContext(pending.contextKey)) {
+                return;
+            }
             const text = skippedCount > 0 ? "No media group files could be staged." : "Media group was empty.";
             await safeReply(pending.ctx, escapeHTML(text), { fallbackText: text });
             return;
         }
+        if (!canSendSystemMessagesToContext(pending.contextKey)) {
+            return;
+        }
         const receivedText = `Received ${stagedFiles.length} media group file${stagedFiles.length === 1 ? "" : "s"}${skippedCount > 0 ? ` (${skippedCount} skipped)` : ""}.`;
         await safeReply(pending.ctx, escapeHTML(receivedText), { fallbackText: receivedText });
         await sendChatActionSafe(pending.ctx.api, pending.chatId, "typing", pending.messageThreadId).catch(() => { });
@@ -1621,1165 +1583,304 @@ export function createBot(config, registry) {
             await clearReaction(pending.ctx);
         }
     };
-    bot.use(async (ctx, next) => {
-        const fromId = ctx.from?.id;
+    bot.use(createTelegramAccessMiddleware({ userStore, contextUsers, audit }));
+    registerTelegramAccessCommands({ bot, userStore, contextUsers, linkAttempts, audit, getUserRole });
+    registerTelegramGeneralCommands({
+        bot,
+        config,
+        registry,
+        getContextSession,
+        checkAgentAuthStatus,
+        isTopicContext,
+        replyChannelAction,
+    });
+    registerTelegramAgentCommands({
+        bot,
+        config,
+        registry,
+        pendingAgentPicks,
+        getContextSession,
+        isBusy,
+        checkAgentAuthStatus,
+        checkLoginAuthStatus,
+        agentIdForAuth,
+        labelForAuth,
+        startAgentLogin,
+        startAgentLogout,
+        hostLoginCommand,
+        hostLogoutCommand,
+    });
+    registerTelegramPreferenceCommands({
+        bot,
+        config,
+        preferencesStore,
+        getContextSession,
+        getEffectiveMirrorMode,
+        getEffectiveNotifyMode,
+        getEffectiveQuietHours,
+        getEffectiveVoiceBackend,
+        getEffectiveVoiceLanguage,
+        isVoiceTranscribeOnly,
+    });
+    registerTelegramDiagnosticsCommands({
+        bot,
+        config,
+        registry,
+        promptStore,
+        turnProgress,
+        externalMirrors,
+        externalQueueTimers,
+        queueStatusMessages,
+        getContextSession,
+        checkAgentAuthStatus,
+        getUserRole,
+        getEffectiveMirrorMode,
+        getEffectiveNotifyMode,
+        getEffectiveQuietHours,
+        getEffectiveVoiceBackend,
+        getEffectiveVoiceLanguage,
+        isVoiceTranscribeOnly,
+        replyChannelAction,
+    });
+    registerTelegramOperationalCommands({
+        bot,
+        config,
+        promptStore,
+        auditLog,
+        lockStore,
+        turnProgress,
+        getContextSession,
+        getBusyState,
+        getExternalActivity,
+        isAdminUser,
+        auditContext,
+        updateSessionMetadata,
+    });
+    registerTelegramSupportCommands({ bot, config, auditLog, agentUpdates, getUserRole, audit });
+    registerTelegramUpdateCommands({ bot, agentUpdates, replyChannelAction, startTelegramAgentUpdate });
+    bot.command("new", async (ctx) => {
         const chatId = ctx.chat?.id;
-        const authorized = config.telegramAllowAnyChat ||
-            (fromId !== undefined && config.telegramAllowedUserIdSet.has(fromId)) ||
-            (chatId !== undefined && config.telegramAllowedChatIdSet.has(chatId));
-        if (!authorized) {
-            if (ctx.callbackQuery) {
-                await ctx.answerCallbackQuery({ text: "Unauthorized" }).catch(() => { });
-            }
-            else if (ctx.chat) {
-                await safeReply(ctx, escapeHTML("Unauthorized"), { fallbackText: "Unauthorized" });
-            }
-            return;
-        }
-        const role = getUserRole(ctx);
-        const permission = getRequiredPermission(ctx);
-        if (!hasTelegramPermission(config.telegramRolePolicies, role, permission)) {
-            const message = `Access denied: ${permission} permission required.`;
-            if (ctx.callbackQuery) {
-                await ctx.answerCallbackQuery({ text: message }).catch(() => { });
-            }
-            else {
-                await safeReply(ctx, escapeHTML(message), { fallbackText: message });
-            }
+        if (!chatId) {
             return;
         }
-        await next();
-    });
-    bot.command("start", async (ctx) => {
         const contextSession = await getContextSession(ctx, { deferThreadStart: true });
         if (!contextSession) {
             return;
         }
         const { contextKey, session } = contextSession;
-        const info = session.getInfo();
-        const authStatus = capabilitiesOf(info).auth ? await checkAgentAuthStatus(info) : null;
-        const authWarning = authStatus && !authStatus.authenticated
-            ? [`${labelOf(info)} is not authenticated.`, authStatus.detail, authHelpText(info)].filter(Boolean).join(" ")
-            : undefined;
-        const isReturning = registry.hasMetadata(contextKey);
-        if (isReturning) {
-            const welcome = renderWelcomeReturning(renderSessionInfoHTML(info), renderSessionInfoPlain(info), isTopicContext(contextKey), authWarning);
-            await safeReply(ctx, welcome.html, { fallbackText: welcome.plain });
+        if (isBusy(contextKey)) {
+            await safeReply(ctx, escapeHTML("Cannot create a new thread while a prompt is running."), {
+                fallbackText: "Cannot create a new thread while a prompt is running.",
+            });
+            return;
         }
-        else {
-            const welcome = renderWelcomeFirstTime(authWarning);
-            await safeReply(ctx, [welcome.html, "", renderLaunchSummaryHTML(info)].join("\n"), {
-                fallbackText: [welcome.plain, "", renderLaunchSummaryPlain(info)].join("\n"),
+        const currentPolicy = evaluateWorkspacePolicy(session.getCurrentWorkspace(), config);
+        if (!currentPolicy.allowed) {
+            await safeReply(ctx, escapeHTML(currentPolicy.warning ?? "Current workspace is blocked by workspace policy."), {
+                fallbackText: currentPolicy.warning ?? "Current workspace is blocked by workspace policy.",
             });
+            return;
         }
+        const workspaces = filterAllowedWorkspaces(session.listWorkspaces(), config);
+        if (workspaces.length <= 1) {
+            try {
+                const info = await session.newThread();
+                updateSessionMetadata(contextKey, session);
+                const label = isTopicContext(contextKey) ? "New thread created for this topic." : "New thread created.";
+                const policyLine = renderWorkspacePolicyLine(info.workspace, config);
+                const plainText = [label, policyLine, "", renderSessionInfoPlain(info)].filter((line) => line !== undefined).join("\n");
+                const html = [`<b>${escapeHTML(label)}</b>`, policyLine ? `<i>${escapeHTML(policyLine)}</i>` : undefined, "", renderSessionInfoHTML(info)].filter((line) => line !== undefined).join("\n");
+                await safeReply(ctx, html, { fallbackText: plainText });
+            }
+            catch (error) {
+                await safeReply(ctx, `<b>Failed:</b> ${escapeHTML(friendlyErrorText(error))}`, {
+                    fallbackText: `Failed: ${friendlyErrorText(error)}`,
+                });
+            }
+            return;
+        }
+        pendingWorkspacePicks.set(contextKey, workspaces);
+        const currentWorkspace = session.getCurrentWorkspace();
+        const workspaceButtons = workspaces.map((workspace, index) => ({
+            label: `${workspace === currentWorkspace ? "📂" : "📁"} ${getWorkspaceShortName(workspace)}`,
+            callbackData: `ws_${index}`,
+        }));
+        pendingWorkspaceButtons.set(contextKey, workspaceButtons);
+        const keyboard = paginateKeyboard(workspaceButtons, 0, "ws");
+        await safeReply(ctx, "<b>Select workspace for new thread:</b>", {
+            fallbackText: "Select workspace for new thread:",
+            replyMarkup: keyboard,
+        });
     });
-    bot.command("help", async (ctx) => {
-        const help = renderHelpMessage();
-        await safeReply(ctx, help.html, { fallbackText: help.plain });
-    });
-    bot.command("channels", async (ctx) => {
-        const rendered = renderChannelsAction(listChannelDescriptors());
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.command("agents", async (ctx) => {
-        const rendered = renderAgentsAction(listAgentAdapterDescriptors(), enabledAgents(config));
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.command("agent", async (ctx) => {
+    bot.command(["abort", "stop"], async (ctx) => {
         const contextSession = await getContextSession(ctx, { deferThreadStart: true });
         if (!contextSession) {
             return;
         }
         const { contextKey, session } = contextSession;
-        if (isBusy(contextKey)) {
-            await safeReply(ctx, escapeHTML("Cannot switch agent while a prompt is running."), {
-                fallbackText: "Cannot switch agent while a prompt is running.",
+        try {
+            const busy = getBusyReason(contextKey);
+            if (busy.kind === "external") {
+                const text = `Cannot abort the external ${busy.activity.agentLabel} CLI task from NordRelay. Stop it in the terminal where it is running; queued Telegram messages will wait.`;
+                await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+                return;
+            }
+            await session.abort();
+            await safeReply(ctx, escapeHTML("Aborted current operation"), {
+                fallbackText: "Aborted current operation",
             });
-            return;
         }
-        const availableAgents = enabledAgents(config);
-        const currentAgent = idOf(session.getInfo());
-        if (availableAgents.length <= 1) {
-            const only = agentLabel(availableAgents[0] ?? currentAgent);
-            await safeReply(ctx, `<b>Current agent:</b> <code>${escapeHTML(only)}</code>\nNo other agents are enabled.`, {
-                fallbackText: `Current agent: ${only}\nNo other agents are enabled.`,
+        catch (error) {
+            await safeReply(ctx, `<b>Failed:</b> ${escapeHTML(friendlyErrorText(error))}`, {
+                fallbackText: `Failed: ${friendlyErrorText(error)}`,
             });
-            return;
-        }
-        pendingAgentPicks.set(contextKey, availableAgents);
-        const keyboard = new InlineKeyboard();
-        for (const availableAgent of availableAgents) {
-            keyboard.text(`${agentLabel(availableAgent)}${availableAgent === currentAgent ? " ✓" : ""}`, `agent_${availableAgent}`).row();
         }
-        await safeReply(ctx, `<b>Current agent:</b> <code>${escapeHTML(agentLabel(currentAgent))}</code>\nSelect agent for this Telegram context:`, {
-            fallbackText: `Current agent: ${agentLabel(currentAgent)}\nSelect agent for this Telegram context:`,
-            replyMarkup: keyboard,
-        });
     });
-    bot.command("auth", async (ctx) => {
-        if (!ctx.chat) {
-            return;
-        }
+    bot.command("retry", async (ctx) => {
         const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        const info = contextSession?.session.getInfo();
-        if (info && !capabilitiesOf(info).auth) {
-            const text = `${labelOf(info)} uses its local CLI authentication. Run its login flow on the host if needed.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+        if (!contextSession) {
             return;
         }
-        const authStatus = info ? await checkAgentAuthStatus(info) : await checkAuthStatus(config.codexApiKey);
-        const icon = authStatus.authenticated ? "✅" : "❌";
-        const html = [
-            `<b>${icon} Auth status:</b> ${authStatus.authenticated ? "authenticated" : "not authenticated"}`,
-            `<b>Method:</b> <code>${escapeHTML(authStatus.method)}</code>`,
-            `<b>Detail:</b> <code>${escapeHTML(authStatus.detail)}</code>`,
-        ].join("\n");
-        const plain = [
-            `${icon} Auth status: ${authStatus.authenticated ? "authenticated" : "not authenticated"}`,
-            `Method: ${authStatus.method}`,
-            `Detail: ${authStatus.detail}`,
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command("login", async (ctx) => {
-        if (!ctx.chat) {
+        const { contextKey, session } = contextSession;
+        const chatId = ctx.chat?.id;
+        if (!chatId) {
             return;
         }
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        const info = contextSession?.session.getInfo();
-        if (info && !capabilitiesOf(info).login) {
-            const text = `${labelOf(info)} login is not managed by NordRelay. Run the CLI login flow on the host.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+        if (isBusy(contextKey)) {
+            await sendBusyReply(ctx);
             return;
         }
-        const authStatus = await checkLoginAuthStatus(info);
-        if (agentIdForAuth(info) !== "hermes" && authStatus.authenticated) {
-            await safeReply(ctx, `<b>✅ Already authenticated</b> via <code>${escapeHTML(authStatus.method)}</code>.`, {
-                fallbackText: `✅ Already authenticated via ${authStatus.method}.`,
+        const cached = promptStore.getLastPrompt(contextKey);
+        if (!cached) {
+            await safeReply(ctx, escapeHTML("Nothing to retry. Send a message first."), {
+                fallbackText: "Nothing to retry. Send a message first.",
             });
             return;
         }
-        if (!config.enableTelegramLogin) {
-            await safeReply(ctx, [
-                "<b>Telegram-initiated login is disabled.</b>",
-                "",
-                `Run <code>${escapeHTML(hostLoginCommand(info))}</code> on the host.`,
-            ].join("\n"), {
-                fallbackText: [
-                    "Telegram-initiated login is disabled.",
-                    "",
-                    `Run '${hostLoginCommand(info)}' on the host.`,
-                ].join("\n"),
-            });
-            return;
+        await setReaction(ctx, "👀");
+        try {
+            await handleUserPrompt(ctx, contextKey, chatId, session, cached);
+            await setReaction(ctx, "👍");
         }
-        const result = await startAgentLogin(info);
-        if (result.success) {
-            await safeReply(ctx, `<b>🔑 Login initiated.</b>\n\n<code>${escapeHTML(result.message)}</code>`, {
-                fallbackText: `🔑 Login initiated.\n\n${result.message}`,
-            });
+        catch {
+            await clearReaction(ctx);
+        }
+    });
+    registerTelegramQueueCommands({
+        bot,
+        promptStore,
+        getContextSession,
+        getBusyReason,
+        getSession: (contextKey) => registry.get(contextKey),
+        updateQueueStatusMessage,
+        scheduleExternalQueueDrain,
+        drainQueuedPrompts,
+        handleUserPrompt,
+        auditContext,
+    });
+    registerTelegramArtifactCommands({
+        bot,
+        config,
+        getContextSession,
+        deliverArtifactReport,
+        deliverArtifactReportZip,
+    });
+    bot.command("session", async (ctx) => {
+        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
+        if (!contextSession) {
             return;
         }
-        await safeReply(ctx, `<b>❌ Login failed.</b>\n\n<code>${escapeHTML(result.message)}</code>`, {
-            fallbackText: `❌ Login failed.\n\n${result.message}`,
-        });
+        const { contextKey, session } = contextSession;
+        const info = session.getInfo();
+        const contextLabel = isTopicContext(contextKey) ? "Topic session" : "Chat session";
+        const policyLine = renderWorkspacePolicyLine(info.workspace, config);
+        const plainLines = [`${contextLabel}:`, policyLine, renderSessionInfoPlain(info)].filter((line) => line !== undefined);
+        const htmlLines = [`<b>${escapeHTML(contextLabel)}:</b>`, policyLine ? `<i>${escapeHTML(policyLine)}</i>` : undefined, renderSessionInfoHTML(info)].filter((line) => line !== undefined);
+        await safeReply(ctx, htmlLines.join("\n"), { fallbackText: plainLines.join("\n") });
     });
-    bot.command("logout", async (ctx) => {
-        if (!ctx.chat) {
+    const openLaunchProfilesPicker = async (ctx) => {
+        const chatId = ctx.chat?.id;
+        if (!chatId) {
             return;
         }
         const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        const info = contextSession?.session.getInfo();
-        if (info && !capabilitiesOf(info).logout) {
-            const text = `${labelOf(info)} logout is not managed by NordRelay. Run the CLI logout flow on the host.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+        if (!contextSession) {
             return;
         }
-        const authStatus = await checkLoginAuthStatus(info);
-        if (authStatus.method === "api-key") {
-            await safeReply(ctx, [
-                `<b>Cannot logout via Telegram when ${escapeHTML(labelForAuth(info))} uses API-key authentication.</b>`,
-                "",
-                "Remove the API key from .env to use CLI-based auth instead.",
-            ].join("\n"), {
-                fallbackText: [
-                    `Cannot logout via Telegram when ${labelForAuth(info)} uses API-key authentication.`,
-                    "",
-                    "Remove the API key from .env to use CLI-based auth instead.",
-                ].join("\n"),
-            });
+        const { contextKey, session } = contextSession;
+        const info = session.getInfo();
+        if (!capabilitiesOf(info).launchProfiles) {
+            const text = `Launch profiles are not supported for ${labelOf(info)}.`;
+            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
             return;
         }
-        if (!config.enableTelegramLogin) {
-            await safeReply(ctx, [
-                "<b>Telegram-initiated auth management is disabled.</b>",
-                "",
-                `Run <code>${escapeHTML(hostLogoutCommand(info))}</code> on the host.`,
-            ].join("\n"), {
-                fallbackText: [
-                    "Telegram-initiated auth management is disabled.",
-                    "",
-                    `Run '${hostLogoutCommand(info)}' on the host.`,
-                ].join("\n"),
+        if (isBusy(contextKey)) {
+            await safeReply(ctx, escapeHTML("Cannot change launch profile while a prompt is running."), {
+                fallbackText: "Cannot change launch profile while a prompt is running.",
             });
             return;
         }
-        if (agentIdForAuth(info) !== "hermes" && !authStatus.authenticated) {
-            await safeReply(ctx, escapeHTML("Not currently authenticated."), {
-                fallbackText: "Not currently authenticated.",
-            });
-            return;
+        const profiles = session.listLaunchProfiles();
+        const selectedLaunchProfile = session.getInfo();
+        const launchButtons = profiles.map((profile, index) => ({
+            label: formatAgentLaunchProfileLabel(profile, profile.id === selectedLaunchProfile.launchProfileId),
+            callbackData: `launch_${index}`,
+        }));
+        pendingLaunchPicks.set(contextKey, profiles.map((profile) => profile.id));
+        pendingLaunchButtons.set(contextKey, launchButtons);
+        pendingUnsafeLaunchConfirmations.delete(contextKey);
+        const keyboard = paginateKeyboard(launchButtons, 0, "launch");
+        const htmlLines = [
+            `<b>Selected launch profile:</b> <code>${escapeHTML(selectedLaunchProfile.launchProfileLabel)}</code>`,
+            `<b>Behavior:</b> <code>${escapeHTML(selectedLaunchProfile.launchProfileBehavior)}</code>`,
+            "",
+            "Select a profile for new or reattached threads:",
+        ];
+        const plainLines = [
+            `Selected launch profile: ${selectedLaunchProfile.launchProfileLabel}`,
+            `Behavior: ${selectedLaunchProfile.launchProfileBehavior}`,
+            "",
+            "Select a profile for new or reattached threads:",
+        ];
+        if (selectedLaunchProfile.unsafeLaunch) {
+            htmlLines.splice(2, 0, "⚠️ <i>Selected profile uses danger-full-access.</i>");
+            plainLines.splice(2, 0, "⚠️ Selected profile uses danger-full-access.");
         }
-        const result = await startAgentLogout(info);
-        if (result.success) {
-            await safeReply(ctx, `<b>🔓 Logged out.</b>\n\n${escapeHTML(result.message)}`, {
-                fallbackText: `🔓 Logged out.\n\n${result.message}`,
-            });
-            return;
+        if (info.nextLaunchProfileId) {
+            htmlLines.splice(2, 0, `<b>Active thread still uses:</b> <code>${escapeHTML(info.launchProfileLabel)}</code>`);
+            plainLines.splice(2, 0, `Active thread still uses: ${info.launchProfileLabel}`);
         }
-        await safeReply(ctx, `<b>❌ Logout failed.</b>\n\n<code>${escapeHTML(result.message)}</code>`, {
-            fallbackText: `❌ Logout failed.\n\n${result.message}`,
+        await safeReply(ctx, htmlLines.join("\n"), {
+            fallbackText: plainLines.join("\n"),
+            replyMarkup: keyboard,
         });
-    });
-    bot.command("mirror", async (ctx) => {
+    };
+    bot.command(["launch", "launch_profiles"], openLaunchProfilesPicker);
+    bot.hears(/^\/launch-profiles(?:@\w+)?$/i, openLaunchProfilesPicker);
+    bot.command("handback", async (ctx) => {
         const contextSession = await getContextSession(ctx, { deferThreadStart: true });
         if (!contextSession) {
             return;
         }
         const { contextKey, session } = contextSession;
-        if (!capabilitiesOf(session.getInfo()).cliMirror) {
-            const text = `CLI mirroring is not supported for ${labelOf(session.getInfo())} yet.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+        if (isBusy(contextKey)) {
+            await safeReply(ctx, escapeHTML("Cannot hand back while a prompt is running. Use /abort first."), {
+                fallbackText: "Cannot hand back while a prompt is running. Use /abort first.",
+            });
             return;
         }
-        const argument = (ctx.message?.text ?? "").replace(/^\/mirror(?:@\w+)?\s*/i, "").trim();
-        if (argument) {
-            const mode = parseMirrorMode(argument, getEffectiveMirrorMode(contextKey));
-            if (!["off", "status", "final", "full"].includes(argument.toLowerCase())) {
-                await safeReply(ctx, escapeHTML("Usage: /mirror [off|status|final|full]"), {
-                    fallbackText: "Usage: /mirror [off|status|final|full]",
-                });
-                return;
-            }
-            preferencesStore.update(contextKey, { mirrorMode: mode });
-        }
-        const mode = getEffectiveMirrorMode(contextKey);
-        const plain = [
-            `CLI mirroring: ${mode}`,
-            `Minimum update interval: ${config.telegramMirrorMinUpdateMs} ms`,
-            "Modes: off, status, final, full",
-        ].join("\n");
-        const html = [
-            `<b>CLI mirroring:</b> <code>${escapeHTML(mode)}</code>`,
-            `<b>Minimum update interval:</b> <code>${config.telegramMirrorMinUpdateMs} ms</code>`,
-            "<b>Modes:</b> <code>off</code>, <code>status</code>, <code>final</code>, <code>full</code>",
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command("notify", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey } = contextSession;
-        const argument = (ctx.message?.text ?? "").replace(/^\/notify(?:@\w+)?\s*/i, "").trim();
-        if (argument) {
-            const quietMatch = argument.match(/^quiet\s+(.+)$/i);
-            if (quietMatch) {
-                let quietHours;
-                try {
-                    quietHours = quietMatch[1].toLowerCase() === "off" ? null : parseQuietHours(quietMatch[1]);
-                }
-                catch (error) {
-                    await safeReply(ctx, escapeHTML(`Invalid quiet hours: ${friendlyErrorText(error)}`), {
-                        fallbackText: `Invalid quiet hours: ${friendlyErrorText(error)}`,
-                    });
-                    return;
-                }
-                preferencesStore.update(contextKey, { quietHours });
-            }
-            else {
-                const mode = parseNotifyMode(argument, getEffectiveNotifyMode(contextKey));
-                if (!["off", "minimal", "all"].includes(argument.toLowerCase())) {
-                    await safeReply(ctx, escapeHTML("Usage: /notify [off|minimal|all] or /notify quiet HH-HH"), {
-                        fallbackText: "Usage: /notify [off|minimal|all] or /notify quiet HH-HH",
-                    });
-                    return;
-                }
-                preferencesStore.update(contextKey, { notifyMode: mode });
-            }
-        }
-        const mode = getEffectiveNotifyMode(contextKey);
-        const quietHours = getEffectiveQuietHours(contextKey);
-        const plain = [
-            `Notifications: ${mode}`,
-            `Quiet hours: ${formatQuietHours(quietHours)}`,
-            `Currently quiet: ${isQuietNow(quietHours) ? "yes" : "no"}`,
-        ].join("\n");
-        const html = [
-            `<b>Notifications:</b> <code>${escapeHTML(mode)}</code>`,
-            `<b>Quiet hours:</b> <code>${escapeHTML(formatQuietHours(quietHours))}</code>`,
-            `<b>Currently quiet:</b> <code>${isQuietNow(quietHours) ? "yes" : "no"}</code>`,
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command("workspaces", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { session } = contextSession;
-        const agentName = labelOf(session.getInfo());
-        const workspaces = filterAllowedWorkspaces(session.listWorkspaces(), config);
-        const currentWorkspace = session.getInfo().workspace;
-        const lines = workspaces.slice(0, 20).map((workspace, index) => {
-            const prefix = workspace === currentWorkspace ? "*" : `${index + 1}.`;
-            const policy = renderWorkspacePolicyLine(workspace, config);
-            return `${prefix} ${workspace}${policy ? ` (${policy})` : ""}`;
-        });
-        const currentPolicy = evaluateWorkspacePolicy(currentWorkspace, config);
-        const header = [
-            "Workspaces:",
-            `Current: ${currentWorkspace}`,
-            currentPolicy.warning ? `Current warning: ${currentPolicy.warning}` : undefined,
-            config.workspaceAllowedRoots.length > 0 ? `Allowed roots: ${config.workspaceAllowedRoots.join(", ")}` : "Allowed roots: unrestricted",
-            "",
-        ].filter((line) => Boolean(line));
-        const plain = [...header, ...(lines.length > 0 ? lines : [`No workspaces found in ${agentName} state.`])].join("\n");
-        const html = [
-            "<b>Workspaces:</b>",
-            `<b>Current:</b> <code>${escapeHTML(currentWorkspace)}</code>`,
-            currentPolicy.warning ? `<b>Current warning:</b> <code>${escapeHTML(currentPolicy.warning)}</code>` : undefined,
-            `<b>Allowed roots:</b> <code>${escapeHTML(config.workspaceAllowedRoots.length > 0 ? config.workspaceAllowedRoots.join(", ") : "unrestricted")}</code>`,
-            "",
-            ...(lines.length > 0 ? lines.map((line) => `<code>${escapeHTML(line)}</code>`) : [`<code>No workspaces found in ${escapeHTML(agentName)} state.</code>`]),
-        ].filter((line) => Boolean(line)).join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command("voice", async (ctx) => {
-        if (!ctx.chat) {
-            return;
-        }
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey } = contextSession;
-        const argument = (ctx.message?.text ?? "").replace(/^\/voice(?:@\w+)?\s*/i, "").trim();
-        if (argument) {
-            const parts = argument.split(/\s+/);
-            const key = parts[0]?.toLowerCase();
-            const value = parts.slice(1).join(" ").trim();
-            if (key === "backend" && value) {
-                preferencesStore.update(contextKey, { voiceBackend: parseVoiceBackendPreference(value) });
-            }
-            else if (key === "language") {
-                preferencesStore.update(contextKey, { voiceLanguage: value && value.toLowerCase() !== "auto" ? value : null });
-            }
-            else if (key === "transcribe_only" || key === "transcribe-only") {
-                const enabled = parseToggle(value);
-                if (enabled === undefined) {
-                    await safeReply(ctx, escapeHTML("Usage: /voice transcribe_only on|off"), {
-                        fallbackText: "Usage: /voice transcribe_only on|off",
-                    });
-                    return;
-                }
-                preferencesStore.update(contextKey, { voiceTranscribeOnly: enabled });
-            }
-            else {
-                await safeReply(ctx, escapeHTML("Usage: /voice, /voice backend auto|parakeet|faster-whisper|openai, /voice language auto|<code>, /voice transcribe_only on|off"), {
-                    fallbackText: "Usage: /voice, /voice backend auto|parakeet|faster-whisper|openai, /voice language auto|<code>, /voice transcribe_only on|off",
-                });
-                return;
-            }
-        }
-        const backends = await getAvailableBackends().catch(() => []);
-        if (backends.length === 0) {
-            await safeReply(ctx, [
-                "<b>Voice transcription is not available.</b>",
-                "",
-                "Install <code>faster-whisper</code> + ffmpeg, install <code>parakeet-coreml</code> on macOS Apple Silicon, or set <code>OPENAI_API_KEY</code>.",
-                "<i>Cloud transcription uses OPENAI_API_KEY, not CODEX_API_KEY.</i>",
-            ].join("\n"), {
-                fallbackText: [
-                    "Voice transcription is not available.",
-                    "",
-                    "Install faster-whisper + ffmpeg, install parakeet-coreml on macOS Apple Silicon, or set OPENAI_API_KEY.",
-                    "Cloud transcription uses OPENAI_API_KEY, not CODEX_API_KEY.",
-                ].join("\n"),
-            });
-            return;
-        }
-        const joined = backends.join(" + ");
-        const backendPreference = getEffectiveVoiceBackend(contextKey);
-        const language = getEffectiveVoiceLanguage(contextKey);
-        const transcribeOnly = isVoiceTranscribeOnly(contextKey);
-        const plain = [
-            `Voice backends: ${joined}`,
-            `Preferred backend: ${backendPreference}`,
-            `Language: ${language ?? "auto"}`,
-            `Transcribe only: ${transcribeOnly ? "on" : "off"}`,
-        ].join("\n");
-        const html = [
-            `<b>Voice backends:</b> <code>${escapeHTML(joined)}</code>`,
-            `<b>Preferred backend:</b> <code>${escapeHTML(backendPreference)}</code>`,
-            `<b>Language:</b> <code>${escapeHTML(language ?? "auto")}</code>`,
-            `<b>Transcribe only:</b> <code>${transcribeOnly ? "on" : "off"}</code>`,
-        ].join("\n");
-        await safeReply(ctx, html, {
-            fallbackText: plain,
-        });
-    });
-    bot.command(["status", "health"], async (ctx) => {
-        const health = await getConnectorHealth({ piCliPath: config.piCliPath, hermesCliPath: config.hermesCliPath, openClawCliPath: config.openClawCliPath, claudeCodeCliPath: config.claudeCodeCliPath });
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        const authStatus = contextSession
-            ? await checkAgentAuthStatus(contextSession.session.getInfo())
-            : await checkAuthStatus(config.codexApiKey);
-        const html = renderHealthHTML(health, authStatus.authenticated, getUserRole(ctx));
-        const plain = renderHealthPlain(health, authStatus.authenticated, getUserRole(ctx));
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command("version", async (ctx) => {
-        const health = await getConnectorHealth({ piCliPath: config.piCliPath, hermesCliPath: config.hermesCliPath, openClawCliPath: config.openClawCliPath, claudeCodeCliPath: config.claudeCodeCliPath });
-        const state = await readConnectorState();
-        const versions = await getVersionChecks({ piCliPath: config.piCliPath, hermesCliPath: config.hermesCliPath, openClawCliPath: config.openClawCliPath, claudeCodeCliPath: config.claudeCodeCliPath });
-        const plain = [
-            renderVersionCheckPlain(versions.nordrelay),
-            `Runtime status: ${state.status ?? "unknown"}`,
-            formatCliPathPlain("Codex CLI", health.codexCliPath, health.codexCli),
-            renderVersionCheckPlain(versions.codex),
-            formatCliPathPlain("Pi CLI", health.piCliPath, health.piCli),
-            renderVersionCheckPlain(versions.pi),
-            formatCliPathPlain("Hermes CLI", health.hermesCliPath, health.hermesCli),
-            renderVersionCheckPlain(versions.hermes),
-            formatCliPathPlain("OpenClaw CLI", health.openClawCliPath, health.openClawCli),
-            renderVersionCheckPlain(versions.openclaw),
-            formatCliPathPlain("Claude Code CLI", health.claudeCodeCliPath, health.claudeCodeCli),
-            renderVersionCheckPlain(versions.claudeCode),
-        ].join("\n");
-        const html = [
-            renderVersionCheckHTML(versions.nordrelay),
-            `<b>Runtime status:</b> <code>${escapeHTML(state.status ?? "unknown")}</code>`,
-            formatCliPathHTML("Codex CLI", health.codexCliPath, health.codexCli),
-            renderVersionCheckHTML(versions.codex),
-            formatCliPathHTML("Pi CLI", health.piCliPath, health.piCli),
-            renderVersionCheckHTML(versions.pi),
-            formatCliPathHTML("Hermes CLI", health.hermesCliPath, health.hermesCli),
-            renderVersionCheckHTML(versions.hermes),
-            formatCliPathHTML("OpenClaw CLI", health.openClawCliPath, health.openClawCli),
-            renderVersionCheckHTML(versions.openclaw),
-            formatCliPathHTML("Claude Code CLI", health.claudeCodeCliPath, health.claudeCodeCli),
-            renderVersionCheckHTML(versions.claudeCode),
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command(["tasks", "progress"], async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const progress = turnProgress.get(contextSession.contextKey);
-        const queue = promptStore.list(contextSession.contextKey);
-        const externalActivity = getExternalActivity(contextSession.session);
-        const busyState = {
-            ...getBusyState(contextSession.contextKey),
-            external: Boolean(externalActivity?.active),
-        };
-        const info = contextSession.session.getInfo();
-        const plain = renderProgressPlain(progress, queue.length, busyState, info);
-        const html = renderProgressHTML(progress, queue.length, busyState, info);
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command("activity", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const info = contextSession.session.getInfo();
-        if (!capabilitiesOf(info).activityLog) {
-            const text = `${labelOf(info)} activity timelines are not available yet.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-            return;
-        }
-        const threadId = contextSession.session.getActiveThreadId();
-        if (!threadId) {
-            await safeReply(ctx, escapeHTML("No active thread yet."), { fallbackText: "No active thread yet." });
-            return;
-        }
-        const options = parseActivityOptions((ctx.message?.text ?? "").replace(/^\/activity(?:@\w+)?\s*/i, "").trim());
-        const events = filterActivityEvents(getAgentActivityLog(contextSession.session, config, options.exportFile ? 200 : options.limit), options);
-        const rendered = renderActivityTimeline(threadId, events, options);
-        if (options.exportFile && ctx.chat) {
-            const exportPath = path.join(tmpdir(), `nordrelay-activity-${threadId}-${randomUUID().slice(0, 8)}.txt`);
-            await writeFile(exportPath, rendered.plain, "utf8");
-            try {
-                await telegramRateLimiter.run(chatBucket(ctx.chat.id), "sendDocument", () => ctx.api.sendDocument(ctx.chat.id, new InputFile(exportPath, path.basename(exportPath)), {
-                    ...(ctx.message?.message_thread_id ? { message_thread_id: ctx.message.message_thread_id } : {}),
-                }));
-            }
-            finally {
-                await unlink(exportPath).catch(() => { });
-            }
-            return;
-        }
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.command("audit", async (ctx) => {
-        const rawText = ctx.message?.text ?? "";
-        const limitArg = rawText.replace(/^\/audit(?:@\w+)?\s*/i, "").trim();
-        const limit = /^\d+$/.test(limitArg) ? Number(limitArg) : 20;
-        const events = auditLog.list(limit);
-        const rendered = renderAuditEvents(events);
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.command("lock", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession || !ctx.from) {
-            return;
-        }
-        const { contextKey, session } = contextSession;
-        const existing = lockStore.get(contextKey);
-        if (existing && existing.ownerId !== ctx.from.id && getUserRole(ctx) !== "admin") {
-            const text = `Session is already locked by ${formatLockOwner(existing)}.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-            return;
-        }
-        const lock = lockStore.set(contextKey, ctx.from.id, formatTelegramName(ctx), config.sessionLockTtlMs);
-        auditContext(ctx, contextKey, session, {
-            action: "lock_updated",
-            status: "ok",
-            detail: `locked by ${lock.ownerId}`,
-        });
-        const text = `Session locked by ${formatLockOwner(lock)}${lock.expiresAt ? ` until ${formatLocalDateTime(new Date(lock.expiresAt))}` : ""}.`;
-        await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-    });
-    bot.command("unlock", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey, session } = contextSession;
-        const lock = lockStore.get(contextKey);
-        if (lock && lock.ownerId !== ctx.from?.id && getUserRole(ctx) !== "admin") {
-            const text = `Only ${formatLockOwner(lock)} or an admin can unlock this session.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-            return;
-        }
-        const removed = lockStore.clear(contextKey);
-        auditContext(ctx, contextKey, session, {
-            action: "lock_updated",
-            status: "ok",
-            detail: removed ? "unlocked" : "no lock",
-        });
-        const text = removed ? "Session lock released." : "No active lock for this session.";
-        await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-    });
-    bot.command("locks", async (ctx) => {
-        const locks = lockStore.list();
-        const rendered = renderSessionLocks(locks);
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.command("diagnostics", async (ctx) => {
-        const health = await getConnectorHealth({ piCliPath: config.piCliPath, hermesCliPath: config.hermesCliPath, openClawCliPath: config.openClawCliPath, claudeCodeCliPath: config.claudeCodeCliPath });
-        const contextKey = contextKeyFromCtx(ctx);
-        const queueLength = contextKey ? promptStore.list(contextKey).length : 0;
-        const progress = contextKey ? turnProgress.get(contextKey) : undefined;
-        const contextSession = contextKey ? await getContextSession(ctx, { deferThreadStart: true }) : null;
-        const authStatus = contextSession
-            ? await checkAgentAuthStatus(contextSession.session.getInfo())
-            : await checkAuthStatus(config.codexApiKey);
-        const agentDiagnostics = contextSession
-            ? renderAgentDiagnostics(getAgentDiagnostics(contextSession.session, config))
-            : { plain: "Agent state: no context", html: "<b>Agent state:</b> <code>no context</code>" };
-        const runtime = {
-            rateLimit: getTelegramRateLimitMetrics(),
-            externalMirrors: externalMirrors.size,
-            externalQueueTimers: externalQueueTimers.size,
-            queueStatusMessages: queueStatusMessages.size,
-            mirrorMode: contextKey ? getEffectiveMirrorMode(contextKey) : config.telegramMirrorMode,
-            notifyMode: contextKey ? getEffectiveNotifyMode(contextKey) : config.telegramNotifyMode,
-            quietHours: formatQuietHours(contextKey ? getEffectiveQuietHours(contextKey) : config.telegramQuietHours),
-            voiceBackend: contextKey ? getEffectiveVoiceBackend(contextKey) : config.voicePreferredBackend,
-            voiceLanguage: contextKey ? getEffectiveVoiceLanguage(contextKey) ?? "auto" : config.voiceDefaultLanguage ?? "auto",
-            voiceTranscribeOnly: contextKey ? isVoiceTranscribeOnly(contextKey) : config.voiceTranscribeOnly,
-        };
-        const plain = `${renderDiagnosticsPlain(config, registry, health, authStatus.authenticated, getUserRole(ctx), queueLength, progress, runtime)}\n${agentDiagnostics.plain}`;
-        const html = `${renderDiagnosticsHTML(config, registry, health, authStatus.authenticated, getUserRole(ctx), queueLength, progress, runtime)}\n${agentDiagnostics.html}`;
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command("sync", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const sessionInfo = contextSession.session.getInfo();
-        if (!capabilitiesOf(sessionInfo).externalActivity) {
-            const plain = [`${labelOf(sessionInfo)} has no external CLI state watcher to sync.`, "", renderSessionInfoPlain(sessionInfo)].join("\n");
-            const html = [`<b>${escapeHTML(labelOf(sessionInfo))} has no external CLI state watcher to sync.</b>`, "", renderSessionInfoHTML(sessionInfo)].join("\n");
-            await safeReply(ctx, html, { fallbackText: plain });
-            return;
-        }
-        const result = contextSession.session.syncFromAgentState({ reattach: true });
-        if (result.changed) {
-            updateSessionMetadata(contextSession.contextKey, contextSession.session);
-        }
-        const fields = result.changedFields.length > 0 ? result.changedFields.join(", ") : "none";
-        const plain = [
-            result.changed ? `Synced from ${labelOf(sessionInfo)} state.` : "Already in sync.",
-            `Changed: ${fields}`,
-            `Reattached: ${result.reattached ? "yes" : "no"}`,
-            "",
-            renderSessionInfoPlain(result.info),
-        ].join("\n");
-        const html = [
-            result.changed ? `<b>Synced from ${escapeHTML(labelOf(sessionInfo))} state.</b>` : "<b>Already in sync.</b>",
-            `<b>Changed:</b> <code>${escapeHTML(fields)}</code>`,
-            `<b>Reattached:</b> <code>${result.reattached ? "yes" : "no"}</code>`,
-            "",
-            renderSessionInfoHTML(result.info),
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
-    });
-    bot.command("logs", async (ctx) => {
-        const rawText = ctx.message?.text ?? "";
-        const argument = rawText.replace(/^\/logs(?:@\w+)?\s*/i, "").trim();
-        const logRequest = parseLogsCommand(argument);
-        const logs = await Promise.all(logTailRequests(logRequest.target).map(async (request) => ({
-            title: request.title,
-            tail: await readFormattedLogTail(logRequest.lines, request.path),
-        })));
-        const rendered = renderLogTailsAction(logs);
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.command("restart", async (ctx) => {
-        await safeReply(ctx, escapeHTML("Restarting connector..."), {
-            fallbackText: "Restarting connector...",
-        });
-        setTimeout(() => {
-            spawnConnectorRestart();
-        }, 300);
-    });
-    bot.command("update", async (ctx) => {
-        const rawText = ctx.message?.text ?? "";
-        const argument = rawText.replace(/^\/update(?:@\w+)?\s*/i, "").trim();
-        const tokens = argument.split(/\s+/).filter(Boolean);
-        const subcommand = tokens[0]?.toLowerCase();
-        if (subcommand === "agents" || subcommand === "agent") {
-            const rendered = renderAgentUpdatePickerAction(listAgentAdapterDescriptors());
-            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain, replyMarkup: actionKeyboard(rendered.buttons) });
-            return;
-        }
-        if (subcommand === "jobs" || subcommand === "status") {
-            const rendered = renderAgentUpdateJobsAction(agentUpdates.list());
-            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-            return;
-        }
-        if (subcommand === "log" && tokens[1]) {
-            const rendered = renderAgentUpdateLogAction(agentUpdates.readLog(tokens[1]));
-            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-            return;
-        }
-        if (subcommand === "cancel" && tokens[1]) {
-            const job = agentUpdates.cancel(tokens[1]);
-            const rendered = renderAgentUpdateJobAction(job);
-            await safeReply(ctx, rendered.html, {
-                fallbackText: rendered.plain,
-                replyMarkup: actionKeyboard(rendered.buttons),
-            });
-            return;
-        }
-        if ((subcommand === "input" || subcommand === "send") && tokens[1] && tokens.slice(2).join(" ").trim()) {
-            const job = agentUpdates.sendInput(tokens[1], tokens.slice(2).join(" "));
-            const rendered = renderAgentUpdateJobAction(job);
-            await safeReply(ctx, rendered.html, {
-                fallbackText: rendered.plain,
-                replyMarkup: actionKeyboard(rendered.buttons),
-            });
-            return;
-        }
-        const requestedAgent = parseAgentUpdateId(subcommand);
-        if (requestedAgent) {
-            await startTelegramAgentUpdate(ctx, requestedAgent);
-            return;
-        }
-        if (subcommand) {
-            const usage = "Unknown update target. Use /update, /update agents, /update jobs, /update <agent>, /update log <id>, /update cancel <id>, or /update input <id> <text>.";
-            await safeReply(ctx, escapeHTML(usage), { fallbackText: usage });
-            return;
-        }
-        const update = spawnSelfUpdate();
-        const rendered = renderSelfUpdateStartedAction(update);
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.callbackQuery("upd_jobs", async (ctx) => {
-        await ctx.answerCallbackQuery();
-        const rendered = renderAgentUpdateJobsAction(agentUpdates.list());
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.callbackQuery(/^upd_agent:(codex|pi|hermes|openclaw|claude-code)$/, async (ctx) => {
-        const agentId = ctx.match?.[1];
-        if (!agentId) {
-            await ctx.answerCallbackQuery();
-            return;
-        }
-        await ctx.answerCallbackQuery({ text: `Starting ${agentLabel(agentId)} update...` });
-        await startTelegramAgentUpdate(ctx, agentId);
-    });
-    bot.callbackQuery(/^upd_log:(.+)$/, async (ctx) => {
-        const id = ctx.match?.[1];
-        await ctx.answerCallbackQuery();
-        if (!id) {
-            return;
-        }
-        const rendered = renderAgentUpdateLogAction(agentUpdates.readLog(id));
-        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-    });
-    bot.callbackQuery(/^upd_cancel:(.+)$/, async (ctx) => {
-        const id = ctx.match?.[1];
-        await ctx.answerCallbackQuery({ text: "Cancelling update..." });
-        if (!id) {
-            return;
-        }
-        const job = agentUpdates.cancel(id);
-        const rendered = renderAgentUpdateJobAction(job);
-        await safeReply(ctx, rendered.html, {
-            fallbackText: rendered.plain,
-            replyMarkup: actionKeyboard(rendered.buttons),
-        });
-    });
-    bot.command("new", async (ctx) => {
-        const chatId = ctx.chat?.id;
-        if (!chatId) {
-            return;
-        }
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey, session } = contextSession;
-        if (isBusy(contextKey)) {
-            await safeReply(ctx, escapeHTML("Cannot create a new thread while a prompt is running."), {
-                fallbackText: "Cannot create a new thread while a prompt is running.",
-            });
-            return;
-        }
-        const currentPolicy = evaluateWorkspacePolicy(session.getCurrentWorkspace(), config);
-        if (!currentPolicy.allowed) {
-            await safeReply(ctx, escapeHTML(currentPolicy.warning ?? "Current workspace is blocked by workspace policy."), {
-                fallbackText: currentPolicy.warning ?? "Current workspace is blocked by workspace policy.",
-            });
-            return;
-        }
-        const workspaces = filterAllowedWorkspaces(session.listWorkspaces(), config);
-        if (workspaces.length <= 1) {
-            try {
-                const info = await session.newThread();
-                updateSessionMetadata(contextKey, session);
-                const label = isTopicContext(contextKey) ? "New thread created for this topic." : "New thread created.";
-                const policyLine = renderWorkspacePolicyLine(info.workspace, config);
-                const plainText = [label, policyLine, "", renderSessionInfoPlain(info)].filter((line) => line !== undefined).join("\n");
-                const html = [`<b>${escapeHTML(label)}</b>`, policyLine ? `<i>${escapeHTML(policyLine)}</i>` : undefined, "", renderSessionInfoHTML(info)].filter((line) => line !== undefined).join("\n");
-                await safeReply(ctx, html, { fallbackText: plainText });
-            }
-            catch (error) {
-                await safeReply(ctx, `<b>Failed:</b> ${escapeHTML(friendlyErrorText(error))}`, {
-                    fallbackText: `Failed: ${friendlyErrorText(error)}`,
-                });
-            }
-            return;
-        }
-        pendingWorkspacePicks.set(contextKey, workspaces);
-        const currentWorkspace = session.getCurrentWorkspace();
-        const workspaceButtons = workspaces.map((workspace, index) => ({
-            label: `${workspace === currentWorkspace ? "📂" : "📁"} ${getWorkspaceShortName(workspace)}`,
-            callbackData: `ws_${index}`,
-        }));
-        pendingWorkspaceButtons.set(contextKey, workspaceButtons);
-        const keyboard = paginateKeyboard(workspaceButtons, 0, "ws");
-        await safeReply(ctx, "<b>Select workspace for new thread:</b>", {
-            fallbackText: "Select workspace for new thread:",
-            replyMarkup: keyboard,
-        });
-    });
-    bot.command(["abort", "stop"], async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey, session } = contextSession;
-        try {
-            const busy = getBusyReason(contextKey);
-            if (busy.kind === "external") {
-                const text = `Cannot abort the external ${busy.activity.agentLabel} CLI task from NordRelay. Stop it in the terminal where it is running; queued Telegram messages will wait.`;
-                await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-                return;
-            }
-            await session.abort();
-            await safeReply(ctx, escapeHTML("Aborted current operation"), {
-                fallbackText: "Aborted current operation",
-            });
-        }
-        catch (error) {
-            await safeReply(ctx, `<b>Failed:</b> ${escapeHTML(friendlyErrorText(error))}`, {
-                fallbackText: `Failed: ${friendlyErrorText(error)}`,
-            });
-        }
-    });
-    bot.command("retry", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey, session } = contextSession;
-        const chatId = ctx.chat?.id;
-        if (!chatId) {
-            return;
-        }
-        if (isBusy(contextKey)) {
-            await sendBusyReply(ctx);
-            return;
-        }
-        const cached = promptStore.getLastPrompt(contextKey);
-        if (!cached) {
-            await safeReply(ctx, escapeHTML("Nothing to retry. Send a message first."), {
-                fallbackText: "Nothing to retry. Send a message first.",
-            });
-            return;
-        }
-        await setReaction(ctx, "👀");
-        try {
-            await handleUserPrompt(ctx, contextKey, chatId, session, cached);
-            await setReaction(ctx, "👍");
-        }
-        catch {
-            await clearReaction(ctx);
-        }
-    });
-    bot.command("queue", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const chatId = ctx.chat?.id;
-        const { contextKey, session } = contextSession;
-        const rawText = ctx.message?.text ?? "";
-        const argument = rawText.replace(/^\/queue(?:@\w+)?\s*/i, "").trim();
-        const laterMatch = argument.match(/^later\s+(\d+)(?:m|min|minutes?)?\s+([\s\S]+)$/i);
-        if (laterMatch) {
-            const minutes = Math.min(7 * 24 * 60, Math.max(1, Number(laterMatch[1])));
-            const text = laterMatch[2].trim();
-            const notBefore = Date.now() + minutes * 60 * 1000;
-            const item = promptStore.enqueue(contextKey, toPromptEnvelope(text), { notBefore });
-            const message = `Queued prompt ${item.id} for ${formatLocalDateTime(new Date(notBefore))}.`;
-            await safeReply(ctx, escapeHTML(message), {
-                fallbackText: message,
-                replyMarkup: createQueuedPromptCancelKeyboard(contextKey, item.id),
-            });
-            auditContext(ctx, contextKey, session, {
-                action: "prompt_queued",
-                status: "ok",
-                promptId: item.id,
-                description: item.description,
-                detail: "scheduled",
-            });
-            return;
-        }
-        const inspectMatch = argument.match(/^inspect\s+([a-z0-9]+)$/i);
-        if (inspectMatch) {
-            const item = promptStore.get(contextKey, inspectMatch[1]);
-            if (!item) {
-                await safeReply(ctx, escapeHTML(`No queued prompt found with id ${inspectMatch[1]}.`), {
-                    fallbackText: `No queued prompt found with id ${inspectMatch[1]}.`,
-                });
-                return;
-            }
-            const rendered = renderQueuedPromptDetailAction(item);
-            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-            return;
-        }
-        if (/^pause$/i.test(argument)) {
-            promptStore.pause(contextKey);
-            const message = `Queue paused. ${promptStore.list(contextKey).length} queued.`;
-            await safeReply(ctx, escapeHTML(message), { fallbackText: message });
-            await updateQueueStatusMessage(contextKey, message);
-            return;
-        }
-        if (/^resume$/i.test(argument)) {
-            promptStore.resume(contextKey);
-            const message = `Queue resumed. ${promptStore.list(contextKey).length} queued.`;
-            await safeReply(ctx, escapeHTML(message), { fallbackText: message });
-            if (chatId) {
-                void drainQueuedPrompts(ctx, contextKey, chatId, session).catch((error) => {
-                    console.error("Failed to drain queue after resume:", error);
-                });
-            }
-            return;
-        }
-        const moveMatch = argument.match(/^move\s+([a-z0-9]+)\s+(top|up|down)$/i);
-        if (moveMatch) {
-            const direction = moveMatch[2].toLowerCase();
-            const item = direction === "top"
-                ? promptStore.moveToTop(contextKey, moveMatch[1])
-                : direction === "up"
-                    ? promptStore.moveUp(contextKey, moveMatch[1])
-                    : promptStore.moveDown(contextKey, moveMatch[1]);
-            if (!item) {
-                await safeReply(ctx, escapeHTML(`No queued prompt found with id ${moveMatch[1]}.`), {
-                    fallbackText: `No queued prompt found with id ${moveMatch[1]}.`,
-                });
-                return;
-            }
-            const message = `Moved queued prompt ${item.id} ${direction}.`;
-            await safeReply(ctx, escapeHTML(message), { fallbackText: message });
-            return;
-        }
-        const runMatch = argument.match(/^run\s+([a-z0-9]+)$/i);
-        if (runMatch) {
-            const item = promptStore.remove(contextKey, runMatch[1]);
-            if (!item) {
-                await safeReply(ctx, escapeHTML(`No queued prompt found with id ${runMatch[1]}.`), {
-                    fallbackText: `No queued prompt found with id ${runMatch[1]}.`,
-                });
-                return;
-            }
-            promptStore.enqueueFront(contextKey, item);
-            promptStore.resume(contextKey);
-            if (!chatId) {
-                return;
-            }
-            const busy = getBusyReason(contextKey);
-            if (busy.busy) {
-                const message = `Queued prompt ${item.id} moved to top and will run when the current task finishes.`;
-                await safeReply(ctx, escapeHTML(message), { fallbackText: message });
-                if (busy.kind === "external") {
-                    scheduleExternalQueueDrain(ctx, contextKey, chatId, session);
-                }
-                return;
-            }
-            const next = promptStore.dequeue(contextKey);
-            if (next) {
-                await handleUserPrompt(ctx, contextKey, chatId, session, next, { fromQueue: true });
-            }
-            return;
-        }
-        if (argument) {
-            await safeReply(ctx, escapeHTML("Usage: /queue, /queue pause, /queue resume, /queue later <minutes> <prompt>, /queue inspect <id>, /queue move <id> top|up|down, /queue run <id>"), {
-                fallbackText: "Usage: /queue, /queue pause, /queue resume, /queue later <minutes> <prompt>, /queue inspect <id>, /queue move <id> top|up|down, /queue run <id>",
-            });
-            return;
-        }
-        const queue = promptStore.list(contextKey);
-        if (queue.length === 0) {
-            const rendered = renderQueueList(contextKey, queue);
-            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
-            return;
-        }
-        const rendered = renderQueueList(contextKey, queue);
-        await safeReply(ctx, rendered.html, {
-            fallbackText: rendered.plain,
-            replyMarkup: rendered.keyboard,
-        });
-    });
-    bot.command("clearqueue", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const count = promptStore.clear(contextSession.contextKey);
-        const message = `Cleared ${count} queued prompt${count === 1 ? "" : "s"}.`;
-        await safeReply(ctx, escapeHTML(message), { fallbackText: message });
-    });
-    bot.command("cancel", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const rawText = ctx.message?.text ?? "";
-        const id = rawText.replace(/^\/cancel(?:@\w+)?\s*/i, "").trim();
-        if (!id) {
-            await safeReply(ctx, escapeHTML("Usage: /cancel <queue-id>"), {
-                fallbackText: "Usage: /cancel <queue-id>",
-            });
-            return;
-        }
-        const removed = promptStore.remove(contextSession.contextKey, id);
-        if (!removed) {
-            await safeReply(ctx, escapeHTML(`No queued prompt found with id ${id}.`), {
-                fallbackText: `No queued prompt found with id ${id}.`,
-            });
-            return;
-        }
-        await safeReply(ctx, escapeHTML(`Cancelled queued prompt ${removed.id}.`), {
-            fallbackText: `Cancelled queued prompt ${removed.id}.`,
-        });
-    });
-    bot.command("artifacts", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession || !ctx.chat) {
-            return;
-        }
-        const workspace = contextSession.session.getInfo().workspace;
-        const rawText = ctx.message?.text ?? "";
-        const argument = rawText.replace(/^\/artifacts(?:@\w+)?\s*/i, "").trim();
-        const reports = await listRecentArtifactReports(workspace, 10, config.maxFileSize);
-        if (reports.length === 0) {
-            await safeReply(ctx, escapeHTML("No generated artifacts found for this workspace."), {
-                fallbackText: "No generated artifacts found for this workspace.",
-            });
-            return;
-        }
-        if (argument) {
-            const parts = argument.split(/\s+/).filter(Boolean);
-            if (parts[0]?.toLowerCase() === "delete" && parts[1]) {
-                const selected = reports.find((report) => report.turnId === parts[1] || report.turnId.startsWith(parts[1]));
-                if (!selected) {
-                    await safeReply(ctx, escapeHTML(`No artifact turn found for "${parts[1]}".`), {
-                        fallbackText: `No artifact turn found for "${parts[1]}".`,
-                    });
-                    return;
-                }
-                const removed = await removeArtifactTurn(workspace, selected.turnId);
-                const text = removed ? `Deleted artifact turn: ${selected.turnId}` : `Artifact turn not found: ${selected.turnId}`;
-                await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-                return;
-            }
-            const filtered = filterArtifactReports(reports, argument);
-            if (filtered) {
-                if (filtered.length === 0) {
-                    await safeReply(ctx, escapeHTML(`No artifacts matched "${argument}".`), {
-                        fallbackText: `No artifacts matched "${argument}".`,
-                    });
-                    return;
-                }
-                const rendered = renderArtifactReportsAction(filtered);
-                await safeReply(ctx, rendered.html, {
-                    fallbackText: rendered.plain,
-                    replyMarkup: buildArtifactActionsKeyboard(filtered),
-                });
-                return;
-            }
-            const shouldZip = parts[0]?.toLowerCase() === "zip";
-            const requestedTurn = shouldZip ? parts[1] : parts[0];
-            const selected = !requestedTurn || requestedTurn.toLowerCase() === "latest"
-                ? reports[0]
-                : reports.find((report) => report.turnId === requestedTurn || report.turnId.startsWith(requestedTurn));
-            if (!selected) {
-                await safeReply(ctx, escapeHTML(`No artifact turn found for "${argument}".`), {
-                    fallbackText: `No artifact turn found for "${argument}".`,
-                });
-                return;
-            }
-            if (shouldZip) {
-                await deliverArtifactReportZip(ctx, ctx.chat.id, selected, ctx.message?.message_thread_id);
-            }
-            else {
-                await deliverArtifactReport(ctx, ctx.chat.id, selected, ctx.message?.message_thread_id);
-            }
-            return;
-        }
-        const { html, plain } = renderArtifactReportsAction(reports);
-        await safeReply(ctx, html, {
-            fallbackText: plain,
-            replyMarkup: buildArtifactActionsKeyboard(reports),
-        });
-    });
-    bot.command("session", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey, session } = contextSession;
-        const info = session.getInfo();
-        const contextLabel = isTopicContext(contextKey) ? "Topic session" : "Chat session";
-        const policyLine = renderWorkspacePolicyLine(info.workspace, config);
-        const plainLines = [`${contextLabel}:`, policyLine, renderSessionInfoPlain(info)].filter((line) => line !== undefined);
-        const htmlLines = [`<b>${escapeHTML(contextLabel)}:</b>`, policyLine ? `<i>${escapeHTML(policyLine)}</i>` : undefined, renderSessionInfoHTML(info)].filter((line) => line !== undefined);
-        await safeReply(ctx, htmlLines.join("\n"), { fallbackText: plainLines.join("\n") });
-    });
-    const openLaunchProfilesPicker = async (ctx) => {
-        const chatId = ctx.chat?.id;
-        if (!chatId) {
-            return;
-        }
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey, session } = contextSession;
-        const info = session.getInfo();
-        if (!capabilitiesOf(info).launchProfiles) {
-            const text = `Launch profiles are not supported for ${labelOf(info)}.`;
-            await safeReply(ctx, escapeHTML(text), { fallbackText: text });
-            return;
-        }
-        if (isBusy(contextKey)) {
-            await safeReply(ctx, escapeHTML("Cannot change launch profile while a prompt is running."), {
-                fallbackText: "Cannot change launch profile while a prompt is running.",
-            });
-            return;
-        }
-        const profiles = session.listLaunchProfiles();
-        const selectedLaunchProfile = session.getInfo();
-        const launchButtons = profiles.map((profile, index) => ({
-            label: formatAgentLaunchProfileLabel(profile, profile.id === selectedLaunchProfile.launchProfileId),
-            callbackData: `launch_${index}`,
-        }));
-        pendingLaunchPicks.set(contextKey, profiles.map((profile) => profile.id));
-        pendingLaunchButtons.set(contextKey, launchButtons);
-        pendingUnsafeLaunchConfirmations.delete(contextKey);
-        const keyboard = paginateKeyboard(launchButtons, 0, "launch");
-        const htmlLines = [
-            `<b>Selected launch profile:</b> <code>${escapeHTML(selectedLaunchProfile.launchProfileLabel)}</code>`,
-            `<b>Behavior:</b> <code>${escapeHTML(selectedLaunchProfile.launchProfileBehavior)}</code>`,
-            "",
-            "Select a profile for new or reattached threads:",
-        ];
-        const plainLines = [
-            `Selected launch profile: ${selectedLaunchProfile.launchProfileLabel}`,
-            `Behavior: ${selectedLaunchProfile.launchProfileBehavior}`,
-            "",
-            "Select a profile for new or reattached threads:",
-        ];
-        if (selectedLaunchProfile.unsafeLaunch) {
-            htmlLines.splice(2, 0, "⚠️ <i>Selected profile uses danger-full-access.</i>");
-            plainLines.splice(2, 0, "⚠️ Selected profile uses danger-full-access.");
-        }
-        if (info.nextLaunchProfileId) {
-            htmlLines.splice(2, 0, `<b>Active thread still uses:</b> <code>${escapeHTML(info.launchProfileLabel)}</code>`);
-            plainLines.splice(2, 0, `Active thread still uses: ${info.launchProfileLabel}`);
-        }
-        await safeReply(ctx, htmlLines.join("\n"), {
-            fallbackText: plainLines.join("\n"),
-            replyMarkup: keyboard,
-        });
-    };
-    bot.command(["launch", "launch_profiles"], openLaunchProfilesPicker);
-    bot.hears(/^\/launch-profiles(?:@\w+)?$/i, openLaunchProfilesPicker);
-    bot.command("handback", async (ctx) => {
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            return;
-        }
-        const { contextKey, session } = contextSession;
-        if (isBusy(contextKey)) {
-            await safeReply(ctx, escapeHTML("Cannot hand back while a prompt is running. Use /abort first."), {
-                fallbackText: "Cannot hand back while a prompt is running. Use /abort first.",
-            });
-            return;
-        }
-        if (!session.hasActiveThread()) {
-            await safeReply(ctx, escapeHTML("No active thread to hand back."), {
-                fallbackText: "No active thread to hand back.",
-            });
-            return;
-        }
-        try {
-            const info = session.handback();
-            updateSessionMetadata(contextKey, session);
-            if (!info.threadId) {
-                await safeReply(ctx, escapeHTML("This thread has not started yet, so there is no resumable thread ID. Send a message to create one, or use /new to start fresh."), {
-                    fallbackText: "This thread has not started yet, so there is no resumable thread ID. Send a message to create one, or use /new to start fresh.",
+        if (!session.hasActiveThread()) {
+            await safeReply(ctx, escapeHTML("No active thread to hand back."), {
+                fallbackText: "No active thread to hand back.",
+            });
+            return;
+        }
+        try {
+            const info = session.handback();
+            updateSessionMetadata(contextKey, session);
+            if (!info.threadId) {
+                await safeReply(ctx, escapeHTML("This thread has not started yet, so there is no resumable thread ID. Send a message to create one, or use /new to start fresh."), {
+                    fallbackText: "This thread has not started yet, so there is no resumable thread ID. Send a message to create one, or use /new to start fresh.",
                 });
                 return;
             }
@@ -3199,49 +2300,6 @@ export function createBot(config, registry) {
         });
     };
     bot.command(["effort", "reasoning"], openReasoningPicker);
-    bot.callbackQuery(/^agent_(codex|pi|hermes|openclaw|claude-code)$/, async (ctx) => {
-        const chatId = ctx.chat?.id;
-        const messageId = ctx.callbackQuery.message?.message_id;
-        const selectedAgent = ctx.match?.[1];
-        const contextKey = contextKeyFromCtx(ctx);
-        if (!chatId || !contextKey || !selectedAgent) {
-            await ctx.answerCallbackQuery();
-            return;
-        }
-        const picks = pendingAgentPicks.get(contextKey);
-        if (!picks?.includes(selectedAgent)) {
-            await ctx.answerCallbackQuery({ text: "Expired, run /agent again" });
-            return;
-        }
-        if (isBusy(contextKey)) {
-            await ctx.answerCallbackQuery({ text: "Wait for the current prompt to finish" });
-            return;
-        }
-        await ctx.answerCallbackQuery({ text: `Switching to ${agentLabel(selectedAgent)}...` });
-        pendingAgentPicks.delete(contextKey);
-        try {
-            const session = await registry.switchAgent(contextKey, selectedAgent);
-            const info = session.getInfo();
-            const html = [`<b>Agent switched to ${escapeHTML(labelOf(info))}.</b>`, "", renderSessionInfoHTML(info)].join("\n");
-            const plain = [`Agent switched to ${labelOf(info)}.`, "", renderSessionInfoPlain(info)].join("\n");
-            if (messageId) {
-                await safeEditMessage(bot, chatId, messageId, html, { fallbackText: plain });
-            }
-            else {
-                await safeReply(ctx, html, { fallbackText: plain });
-            }
-        }
-        catch (error) {
-            const html = `<b>Failed:</b> ${escapeHTML(friendlyErrorText(error))}`;
-            const plain = `Failed: ${friendlyErrorText(error)}`;
-            if (messageId) {
-                await safeEditMessage(bot, chatId, messageId, html, { fallbackText: plain });
-            }
-            else {
-                await safeReply(ctx, html, { fallbackText: plain });
-            }
-        }
-    });
     bot.callbackQuery(NOOP_PAGE_CALLBACK_DATA, async (ctx) => {
         await ctx.answerCallbackQuery();
     });
@@ -3264,94 +2322,6 @@ export function createBot(config, registry) {
         await ctx.answerCallbackQuery({ text: "Aborting..." });
         await session.abort();
     });
-    bot.callbackQuery(/^queue_(cancel|remove|top|up|down|run):(-?\d+(?::\d+)?):([a-z0-9]+)$/, async (ctx) => {
-        const action = ctx.match?.[1];
-        const contextKey = ctx.match?.[2];
-        const queueId = ctx.match?.[3];
-        if (!action || !contextKey || !queueId) {
-            await ctx.answerCallbackQuery();
-            return;
-        }
-        const currentContextKey = contextKeyFromCtx(ctx);
-        if (currentContextKey && currentContextKey !== contextKey) {
-            await ctx.answerCallbackQuery({ text: "This queue button belongs to another chat or topic." });
-            return;
-        }
-        const chatId = ctx.chat?.id;
-        const messageId = ctx.callbackQuery.message?.message_id;
-        if (action === "top" || action === "up" || action === "down") {
-            const item = action === "top"
-                ? promptStore.moveToTop(contextKey, queueId)
-                : action === "up"
-                    ? promptStore.moveUp(contextKey, queueId)
-                    : promptStore.moveDown(contextKey, queueId);
-            await ctx.answerCallbackQuery({ text: item ? `Moved ${queueId} ${action}.` : "Queued prompt not found." });
-            if (chatId && messageId) {
-                const rendered = renderQueueList(contextKey, promptStore.list(contextKey));
-                await safeEditMessage(bot, chatId, messageId, rendered.html, {
-                    fallbackText: rendered.plain,
-                    replyMarkup: rendered.keyboard,
-                });
-            }
-            return;
-        }
-        if (action === "run") {
-            const item = promptStore.remove(contextKey, queueId);
-            if (!item) {
-                await ctx.answerCallbackQuery({ text: "Queued prompt already started or was cancelled." });
-                return;
-            }
-            promptStore.enqueueFront(contextKey, item);
-            promptStore.resume(contextKey);
-            await ctx.answerCallbackQuery({ text: `Queued prompt ${queueId} moved to next.` });
-            if (chatId && messageId) {
-                const rendered = renderQueueList(contextKey, promptStore.list(contextKey));
-                await safeEditMessage(bot, chatId, messageId, rendered.html, {
-                    fallbackText: rendered.plain,
-                    replyMarkup: rendered.keyboard,
-                });
-            }
-            const session = registry.get(contextKey);
-            if (chatId && session && !getBusyReason(contextKey).busy) {
-                void drainQueuedPrompts(ctx, contextKey, chatId, session).catch((error) => {
-                    console.error("Failed to drain queue after run-now callback:", error);
-                });
-            }
-            return;
-        }
-        const removed = promptStore.remove(contextKey, queueId);
-        if (!removed) {
-            await ctx.answerCallbackQuery({ text: "Queued prompt already started or was cancelled." });
-            if (chatId && messageId) {
-                if (action === "remove") {
-                    const rendered = renderQueueList(contextKey, promptStore.list(contextKey));
-                    await safeEditMessage(bot, chatId, messageId, rendered.html, {
-                        fallbackText: rendered.plain,
-                        replyMarkup: rendered.keyboard,
-                    });
-                }
-                else {
-                    const message = `Queued prompt ${queueId} is no longer queued.`;
-                    await safeEditMessage(bot, chatId, messageId, escapeHTML(message), { fallbackText: message });
-                }
-            }
-            return;
-        }
-        const message = `Cancelled queued prompt ${removed.id}.`;
-        await ctx.answerCallbackQuery({ text: message });
-        if (!chatId || !messageId) {
-            return;
-        }
-        if (action === "remove") {
-            const rendered = renderQueueList(contextKey, promptStore.list(contextKey));
-            await safeEditMessage(bot, chatId, messageId, rendered.html, {
-                fallbackText: rendered.plain,
-                replyMarkup: rendered.keyboard,
-            });
-            return;
-        }
-        await safeEditMessage(bot, chatId, messageId, escapeHTML(message), { fallbackText: message });
-    });
     bot.callbackQuery(/^approval_(yes|no):([a-z0-9]+)$/, async (ctx) => {
         const action = ctx.match?.[1];
         const approvalId = ctx.match?.[2];
@@ -3364,8 +2334,7 @@ export function createBot(config, registry) {
             await ctx.answerCallbackQuery({ text: "Approval expired" });
             return;
         }
-        const role = getUserRole(ctx);
-        if (pending.requestedBy !== undefined && ctx.from?.id !== pending.requestedBy && role !== "admin") {
+        if (pending.requestedBy !== undefined && ctx.from?.id !== pending.requestedBy && !isAdminUser(ctx)) {
             await ctx.answerCallbackQuery({ text: "Only the requester or an admin can approve" });
             return;
         }
@@ -3762,65 +2731,6 @@ export function createBot(config, registry) {
             fallbackText: `⚡ ${label} set to ${effort} — ${scope}.`,
         });
     });
-    bot.callbackQuery(/^artifact_(send|zip|delete|delete_confirm):([a-zA-Z0-9._-]+)$/, async (ctx) => {
-        const action = ctx.match?.[1];
-        const turnId = ctx.match?.[2];
-        const chatId = ctx.chat?.id;
-        const messageId = ctx.callbackQuery.message?.message_id;
-        if (!action || !turnId || !chatId) {
-            await ctx.answerCallbackQuery();
-            return;
-        }
-        const contextSession = await getContextSession(ctx, { deferThreadStart: true });
-        if (!contextSession) {
-            await ctx.answerCallbackQuery({ text: "No context" });
-            return;
-        }
-        const workspace = contextSession.session.getInfo().workspace;
-        if (action === "delete") {
-            await ctx.answerCallbackQuery({ text: "Confirm deletion" });
-            const keyboard = new InlineKeyboard()
-                .text("Delete artifacts", `artifact_delete_confirm:${turnId}`)
-                .row()
-                .text("Cancel", NOOP_PAGE_CALLBACK_DATA);
-            const html = `<b>Delete artifact turn?</b>\n<code>${escapeHTML(turnId)}</code>`;
-            const plain = `Delete artifact turn?\n${turnId}`;
-            if (messageId) {
-                await safeEditMessage(bot, chatId, messageId, html, { fallbackText: plain, replyMarkup: keyboard });
-            }
-            else {
-                await safeReply(ctx, html, { fallbackText: plain, replyMarkup: keyboard });
-            }
-            return;
-        }
-        if (action === "delete_confirm") {
-            const removed = await removeArtifactTurn(workspace, turnId);
-            await ctx.answerCallbackQuery({ text: removed ? "Deleted" : "Already gone" });
-            const html = removed
-                ? `<b>Deleted artifact turn:</b> <code>${escapeHTML(turnId)}</code>`
-                : `<b>Artifact turn not found:</b> <code>${escapeHTML(turnId)}</code>`;
-            const plain = removed ? `Deleted artifact turn: ${turnId}` : `Artifact turn not found: ${turnId}`;
-            if (messageId) {
-                await safeEditMessage(bot, chatId, messageId, html, { fallbackText: plain });
-            }
-            else {
-                await safeReply(ctx, html, { fallbackText: plain });
-            }
-            return;
-        }
-        const report = await getArtifactTurnReport(workspace, turnId, config.maxFileSize);
-        if (!report) {
-            await ctx.answerCallbackQuery({ text: "Artifact turn not found" });
-            return;
-        }
-        await ctx.answerCallbackQuery({ text: action === "zip" ? "Sending ZIP..." : "Sending artifacts..." });
-        if (action === "zip") {
-            await deliverArtifactReportZip(ctx, chatId, report, ctx.callbackQuery.message?.message_thread_id);
-        }
-        else {
-            await deliverArtifactReport(ctx, chatId, report, ctx.callbackQuery.message?.message_thread_id);
-        }
-    });
     bot.on("message:text", async (ctx) => {
         const contextSession = await getContextSession(ctx);
         if (!contextSession) {
@@ -4081,1069 +2991,3 @@ export function createBot(config, registry) {
     });
     return bot;
 }
-export async function registerCommands(bot) {
-    await bot.api.setMyCommands([
-        { command: "start", description: "Welcome & status" },
-        { command: "help", description: "Command reference" },
-        { command: "channels", description: "Messaging adapter status" },
-        { command: "agents", description: "Agent adapter status" },
-        { command: "agent", description: "Select agent" },
-        { command: "new", description: "Start a new thread" },
-        { command: "session", description: "Current thread details" },
-        { command: "sessions", description: "Browse & switch threads" },
-        { command: "sync", description: "Sync active session from CLI state" },
-        { command: "pinned", description: "Show pinned threads" },
-        { command: "pin", description: "Pin current or given thread" },
-        { command: "unpin", description: "Unpin current or given thread" },
-        { command: "retry", description: "Resend the last prompt" },
-        { command: "queue", description: "Show queued prompts" },
-        { command: "cancel", description: "Cancel a queued prompt" },
-        { command: "clearqueue", description: "Clear queued prompts" },
-        { command: "artifacts", description: "List or resend generated files" },
-        { command: "workspaces", description: "List allowed workspaces" },
-        { command: "abort", description: "Cancel current operation" },
-        { command: "stop", description: "Cancel current operation" },
-        { command: "launch_profiles", description: "Select launch profile" },
-        { command: "fast", description: "Toggle fast mode" },
-        { command: "model", description: "View & change model" },
-        { command: "reasoning", description: "Set reasoning effort" },
-        { command: "mirror", description: "Control CLI mirroring" },
-        { command: "notify", description: "Control notifications" },
-        { command: "auth", description: "Check auth status" },
-        { command: "login", description: "Start authentication" },
-        { command: "logout", description: "Sign out" },
-        { command: "voice", description: "Voice transcription status" },
-        { command: "tasks", description: "Current turn progress" },
-        { command: "progress", description: "Current turn progress" },
-        { command: "activity", description: "Thread activity timeline" },
-        { command: "audit", description: "Admin: recent audit events" },
-        { command: "status", description: "Connector runtime status" },
-        { command: "health", description: "Connector health report" },
-        { command: "version", description: "Connector version" },
-        { command: "logs", description: "Admin: show connector logs" },
-        { command: "diagnostics", description: "Admin: connector diagnostics" },
-        { command: "lock", description: "Lock session writes to you" },
-        { command: "unlock", description: "Release session write lock" },
-        { command: "locks", description: "List session write locks" },
-        { command: "restart", description: "Admin: restart connector" },
-        { command: "update", description: "Admin: update connector or agents" },
-        { command: "handback", description: "Hand session back to CLI" },
-        { command: "attach", description: "Bind a session to this topic" },
-        { command: "switch", description: "Switch to a thread by ID" },
-    ]);
-}
-function renderVersionCheckPlain(check) {
-    const icon = versionStatusIcon(check);
-    const label = check.label === "NordRelay" ? "NordRelay" : `${check.label} version`;
-    return `${label}: ${icon} ${formatVersionCheckDetailPlain(check)}`;
-}
-function renderVersionCheckHTML(check) {
-    const icon = versionStatusIcon(check);
-    const label = check.label === "NordRelay" ? "NordRelay" : `${check.label} version`;
-    return `<b>${escapeHTML(label)}:</b> ${icon} ${formatVersionCheckDetailHTML(check)}`;
-}
-function formatCliPathPlain(label, cliPath, fallback) {
-    return cliPath ? `${label} path: ${cliPath}` : `${label}: ${fallback}`;
-}
-function formatCliPathHTML(label, cliPath, fallback) {
-    return cliPath
-        ? `<b>${escapeHTML(label)} path:</b> <code>${escapeHTML(cliPath)}</code>`
-        : `<b>${escapeHTML(label)}:</b> <code>${escapeHTML(fallback)}</code>`;
-}
-function formatVersionCheckDetailPlain(check) {
-    if (check.status === "not-installed") {
-        return "not installed";
-    }
-    if (check.status === "outdated") {
-        return `${check.installedLabel} (latest ${check.latestVersion ?? "unknown"})`;
-    }
-    if (check.status === "current") {
-        return `${check.installedLabel} (latest)`;
-    }
-    return `${check.installedLabel} (latest unknown${check.detail ? `: ${check.detail}` : ""})`;
-}
-function formatVersionCheckDetailHTML(check) {
-    if (check.status === "not-installed") {
-        return "<code>not installed</code>";
-    }
-    if (check.status === "outdated") {
-        return `<code>${escapeHTML(check.installedLabel)}</code> <i>(latest ${escapeHTML(check.latestVersion ?? "unknown")})</i>`;
-    }
-    if (check.status === "current") {
-        return `<code>${escapeHTML(check.installedLabel)}</code> <i>(latest)</i>`;
-    }
-    return `<code>${escapeHTML(check.installedLabel)}</code> <i>(latest unknown${check.detail ? `: ${escapeHTML(check.detail)}` : ""})</i>`;
-}
-function versionStatusIcon(check) {
-    return check.status === "current" ? "✅" : "⚠️";
-}
-function renderAuditEvents(events) {
-    if (events.length === 0) {
-        return {
-            plain: "Audit log is empty.",
-            html: escapeHTML("Audit log is empty."),
-        };
-    }
-    const lines = events.map((event) => {
-        const time = formatLocalDateTime(new Date(event.timestamp));
-        const actor = event.actorId ? `user ${event.actorId}` : "system";
-        const prompt = event.promptId ? ` · ${event.promptId}` : "";
-        const detail = event.detail ? ` · ${trimLine(event.detail, 90)}` : "";
-        const description = event.description ? ` · ${trimLine(event.description, 90)}` : "";
-        return `${time} · ${event.status.toUpperCase()} · ${event.action} · ${actor}${prompt}${description}${detail}`;
-    });
-    return {
-        plain: ["Audit:", ...lines].join("\n"),
-        html: [
-            "<b>Audit:</b>",
-            ...lines.map((line) => escapeHTML(line)),
-        ].join("\n"),
-    };
-}
-function renderSessionLocks(locks) {
-    if (locks.length === 0) {
-        return {
-            plain: "No active session locks.",
-            html: escapeHTML("No active session locks."),
-        };
-    }
-    const lines = locks.map((lock) => {
-        const expires = lock.expiresAt ? ` · expires ${formatLocalDateTime(new Date(lock.expiresAt))}` : "";
-        return `${lock.contextKey} · ${formatLockOwner(lock)}${expires}`;
-    });
-    return {
-        plain: ["Session locks:", ...lines].join("\n"),
-        html: ["<b>Session locks:</b>", ...lines.map((line) => escapeHTML(line))].join("\n"),
-    };
-}
-function formatLockOwner(lock) {
-    if (!lock) {
-        return "nobody";
-    }
-    return lock.ownerName ? `${lock.ownerName} (${lock.ownerId})` : `user ${lock.ownerId}`;
-}
-function formatTelegramName(ctx) {
-    const firstName = ctx.from?.first_name?.trim();
-    const lastName = ctx.from?.last_name?.trim();
-    const username = ctx.from?.username?.trim();
-    const fullName = [firstName, lastName].filter(Boolean).join(" ").trim();
-    return fullName || (username ? `@${username}` : undefined);
-}
-function formatLocalDateTime(date) {
-    if (Number.isNaN(date.getTime())) {
-        return "-";
-    }
-    return [
-        `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`,
-        `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`,
-    ].join(" ");
-}
-function pad2(value) {
-    return String(value).padStart(2, "0");
-}
-function buildArtifactActionsKeyboard(reports) {
-    const keyboard = new InlineKeyboard();
-    for (const [index, report] of reports.slice(0, 5).entries()) {
-        const label = `${index + 1}`;
-        keyboard
-            .text(`${label} Send`, `artifact_send:${report.turnId}`)
-            .text(`${label} ZIP`, `artifact_zip:${report.turnId}`)
-            .text(`${label} Delete`, `artifact_delete:${report.turnId}`)
-            .row();
-    }
-    return keyboard;
-}
-function filterArtifactReports(reports, argument) {
-    const normalized = argument.trim().toLowerCase();
-    if (!normalized) {
-        return null;
-    }
-    let predicate = null;
-    if (normalized === "images" || normalized === "image" || normalized === "photos") {
-        predicate = (artifact) => isTelegramImagePreview(artifact);
-    }
-    else if (normalized === "docs" || normalized === "documents" || normalized === "files") {
-        predicate = (artifact) => !isTelegramImagePreview(artifact);
-    }
-    else if (normalized.startsWith("search ")) {
-        const query = normalized.slice("search ".length).trim();
-        if (!query) {
-            return [];
-        }
-        predicate = (artifact) => artifact.name.toLowerCase().includes(query);
-    }
-    if (!predicate) {
-        return null;
-    }
-    return reports
-        .map((report) => ({
-        ...report,
-        artifacts: report.artifacts.filter(predicate),
-    }))
-        .filter((report) => report.artifacts.length > 0);
-}
-function renderProgressPlain(progress, queueLength, busyState, info) {
-    const busyFlags = formatBusyFlags(busyState);
-    if (!progress) {
-        return [
-            "Progress:",
-            "Status: idle",
-            `Thread: ${info.threadId ?? "(not started yet)"}`,
-            `Queue: ${queueLength}`,
-            `Busy: ${busyFlags || "no"}`,
-        ].join("\n");
-    }
-    const lines = [
-        "Progress:",
-        `Status: ${progress.status}`,
-        `Prompt: ${progress.promptDescription}`,
-        `Elapsed: ${formatDurationSeconds(((progress.completedAt ?? Date.now()) - progress.startedAt) / 1000)}`,
-        `Current tool: ${progress.currentTool ?? "-"}`,
-        `Last tool: ${progress.lastTool ?? "-"}`,
-        `Tools: ${formatToolSummaryLine(progress.toolCounts) || "-"}`,
-        `Output chars: ${progress.textCharacters}`,
-        `Queue: ${queueLength}`,
-        `Busy: ${busyFlags || "no"}`,
-    ];
-    if (progress.error) {
-        lines.push(`Error: ${progress.error}`);
-    }
-    return lines.join("\n");
-}
-function renderProgressHTML(progress, queueLength, busyState, info) {
-    const busyFlags = formatBusyFlags(busyState);
-    if (!progress) {
-        return [
-            "<b>Progress:</b>",
-            "<b>Status:</b> <code>idle</code>",
-            `<b>Thread:</b> <code>${escapeHTML(info.threadId ?? "(not started yet)")}</code>`,
-            `<b>Queue:</b> <code>${queueLength}</code>`,
-            `<b>Busy:</b> <code>${escapeHTML(busyFlags || "no")}</code>`,
-        ].join("\n");
-    }
-    const lines = [
-        "<b>Progress:</b>",
-        `<b>Status:</b> <code>${escapeHTML(progress.status)}</code>`,
-        `<b>Prompt:</b> <code>${escapeHTML(progress.promptDescription)}</code>`,
-        `<b>Elapsed:</b> <code>${escapeHTML(formatDurationSeconds(((progress.completedAt ?? Date.now()) - progress.startedAt) / 1000))}</code>`,
-        `<b>Current tool:</b> <code>${escapeHTML(progress.currentTool ?? "-")}</code>`,
-        `<b>Last tool:</b> <code>${escapeHTML(progress.lastTool ?? "-")}</code>`,
-        `<b>Tools:</b> <code>${escapeHTML(formatToolSummaryLine(progress.toolCounts) || "-")}</code>`,
-        `<b>Output chars:</b> <code>${progress.textCharacters}</code>`,
-        `<b>Queue:</b> <code>${queueLength}</code>`,
-        `<b>Busy:</b> <code>${escapeHTML(busyFlags || "no")}</code>`,
-    ];
-    if (progress.error) {
-        lines.push(`<b>Error:</b> <code>${escapeHTML(progress.error)}</code>`);
-    }
-    return lines.join("\n");
-}
-function renderExternalMirrorStatus(snapshot, queueLength) {
-    const prompt = trimLine(snapshot.latestUserMessage ?? "-", 180);
-    const elapsed = snapshot.activity.startedAt
-        ? formatDurationSeconds((Date.now() - snapshot.activity.startedAt.getTime()) / 1000)
-        : "-";
-    const lines = [
-        `${snapshot.agentLabel} CLI task running.`,
-        `Thread: ${snapshot.threadId}`,
-        `Elapsed: ${elapsed}`,
-        `Prompt: ${prompt}`,
-        `Last tool: ${snapshot.latestToolName ?? "-"}`,
-        `Queue: ${queueLength}`,
-    ];
-    return {
-        plain: lines.join("\n"),
-        html: [
-            `<b>${escapeHTML(snapshot.agentLabel)} CLI task running.</b>`,
-            `<b>Thread:</b> <code>${escapeHTML(snapshot.threadId)}</code>`,
-            `<b>Elapsed:</b> <code>${escapeHTML(elapsed)}</code>`,
-            `<b>Prompt:</b> <code>${escapeHTML(prompt)}</code>`,
-            `<b>Last tool:</b> <code>${escapeHTML(snapshot.latestToolName ?? "-")}</code>`,
-            `<b>Queue:</b> <code>${queueLength}</code>`,
-        ].join("\n"),
-    };
-}
-function renderExternalMirrorEvent(event) {
-    if (event.kind === "task") {
-        const status = event.status ?? event.type;
-        const plain = `CLI task: ${status}`;
-        return {
-            plain,
-            html: `<b>CLI task:</b> <code>${escapeHTML(status)}</code>`,
-        };
-    }
-    if (event.kind !== "tool") {
-        return null;
-    }
-    const status = event.status ?? event.type;
-    const tool = event.toolName ?? "tool";
-    const detail = event.text ? `\n${trimLine(event.text.replace(/\s+/g, " "), 180)}` : "";
-    const plain = `CLI tool ${status}: ${tool}${detail}`;
-    return {
-        plain,
-        html: `<b>CLI tool ${escapeHTML(status)}:</b> <code>${escapeHTML(tool)}</code>${detail ? `\n<code>${escapeHTML(detail.trim())}</code>` : ""}`,
-    };
-}
-function renderActivityTimeline(threadId, events, options = { limit: 16, filter: "all", exportFile: false }) {
-    if (events.length === 0) {
-        return {
-            plain: `Activity:\nThread: ${threadId}\nFilter: ${options.filter}\nNo activity events found.`,
-            html: `<b>Activity:</b>\n<b>Thread:</b> <code>${escapeHTML(threadId)}</code>\n<b>Filter:</b> <code>${escapeHTML(options.filter)}</code>\n<code>No activity events found.</code>`,
-        };
-    }
-    const lines = events.map((event) => {
-        const time = event.timestamp ? event.timestamp.toISOString().slice(11, 19) : "--:--:--";
-        const label = activityEventLabel(event);
-        const detail = event.text ? ` · ${trimLine(event.text.replace(/\s+/g, " ").trim(), 120)}` : "";
-        const tool = event.toolName ? ` · ${event.toolName}` : "";
-        return `${time} · ${label}${tool}${detail}`;
-    });
-    return {
-        plain: ["Activity:", `Thread: ${threadId}`, `Filter: ${options.filter}`, `Events: ${events.length}`, ...lines].join("\n"),
-        html: [
-            "<b>Activity:</b>",
-            `<b>Thread:</b> <code>${escapeHTML(threadId)}</code>`,
-            `<b>Filter:</b> <code>${escapeHTML(options.filter)}</code>`,
-            `<b>Events:</b> <code>${events.length}</code>`,
-            ...lines.map((line) => `<code>${escapeHTML(line)}</code>`),
-        ].join("\n"),
-    };
-}
-function parseActivityOptions(argument) {
-    const options = {
-        limit: 16,
-        filter: "all",
-        exportFile: false,
-    };
-    const parts = argument.split(/\s+/).filter(Boolean);
-    for (let index = 0; index < parts.length; index += 1) {
-        const part = parts[index].toLowerCase();
-        if (/^\d+$/.test(part)) {
-            options.limit = Math.min(200, Math.max(1, Number(part)));
-            continue;
-        }
-        if (part === "export") {
-            options.exportFile = true;
-            continue;
-        }
-        if (isActivityFilter(part)) {
-            options.filter = part;
-            continue;
-        }
-        if (part === "since" && parts[index + 1]) {
-            options.sinceMs = parseDurationToMs(parts[index + 1]);
-            index += 1;
-        }
-    }
-    return options;
-}
-function filterActivityEvents(events, options) {
-    const cutoff = options.sinceMs ? Date.now() - options.sinceMs : undefined;
-    return events
-        .filter((event) => {
-        if (cutoff && event.timestamp && event.timestamp.getTime() < cutoff) {
-            return false;
-        }
-        switch (options.filter) {
-            case "tools":
-                return event.kind === "tool";
-            case "errors":
-                return event.status === "failed" || event.status === "error" || /error|failed/i.test(event.text ?? "");
-            case "user":
-                return event.kind === "user";
-            case "agent":
-                return event.kind === "agent";
-            case "tasks":
-                return event.kind === "task";
-            default:
-                return true;
-        }
-    })
-        .slice(-options.limit);
-}
-function isActivityFilter(value) {
-    return value === "all" || value === "tools" || value === "errors" || value === "user" || value === "agent" || value === "tasks";
-}
-function formatAgentLaunchProfileLabel(profile, selected) {
-    const prefix = selected ? "✅" : profile.unsafe ? "⚠️" : "🚀";
-    return `${prefix} ${profile.label} · ${trimLine(profile.behavior, 24)}`;
-}
-function formatModelButtonLabel(model, selected) {
-    const meta = [
-        model.contextWindow ? formatCompactNumber(model.contextWindow) : undefined,
-        model.supportsImages === true ? "img" : model.supportsImages === false ? "text" : undefined,
-        model.supportsThinking === true ? "think" : undefined,
-    ].filter(Boolean).join(" ");
-    return trimLine(`${selected ? "✅ " : ""}${model.displayName}${meta ? ` · ${meta}` : ""}`, 58);
-}
-function formatCompactNumber(value) {
-    if (value >= 1_000_000_000)
-        return `${Math.round(value / 100_000_000) / 10}B`;
-    if (value >= 1_000_000)
-        return `${Math.round(value / 100_000) / 10}M`;
-    if (value >= 1_000)
-        return `${Math.round(value / 100) / 10}K`;
-    return String(value);
-}
-function renderAgentDiagnostics(diagnostics) {
-    return {
-        plain: [
-            `${diagnostics.agentLabel} state:`,
-            ...diagnostics.lines.map((line) => `${line.label}: ${line.value}`),
-        ].join("\n"),
-        html: [
-            `<b>${escapeHTML(diagnostics.agentLabel)} state:</b>`,
-            ...diagnostics.lines.map((line) => `<b>${escapeHTML(line.label)}:</b> <code>${escapeHTML(line.value)}</code>`),
-        ].join("\n"),
-    };
-}
-function activityEventLabel(event) {
-    if (event.kind === "task") {
-        return `task ${event.status ?? event.type}`;
-    }
-    if (event.kind === "user") {
-        return "user";
-    }
-    if (event.kind === "agent") {
-        return event.phase ? `agent ${event.phase}` : "agent";
-    }
-    return event.status ? `tool ${event.status}` : "tool";
-}
-function isEmptyArtifactReport(report) {
-    return report.artifacts.length === 0 && report.skippedCount === 0 && !(report.omittedCount && report.omittedCount > 0);
-}
-function formatBusyFlags(state) {
-    return Object.entries(state)
-        .filter(([, enabled]) => enabled)
-        .map(([name]) => name)
-        .join(", ");
-}
-function renderDiagnosticsPlain(config, registry, health, authenticated, role, queueLength, progress, runtime) {
-    const contexts = registry.listContexts();
-    return [
-        "Diagnostics:",
-        `Status: ${health.state.status ?? "unknown"}`,
-        `Version: ${health.version}`,
-        `Role: ${role}`,
-        `Auth: ${authenticated ? "yes" : "no"} (${health.state.authMethod ?? "-"})`,
-        `PID: ${health.state.pid ?? "-"} (${health.pidRunning ? "running" : "not running"})`,
-        `App PID: ${health.state.appPid ?? "-"} (${health.appPidRunning ? "running" : "not running"})`,
-        `Workspace: ${config.workspace}`,
-        `State backend: ${config.stateBackend}`,
-        `Telegram transport: ${config.telegramTransport}`,
-        `Codex CLI: ${health.codexCli}`,
-        `Pi CLI: ${health.piCli}`,
-        `Hermes CLI: ${health.hermesCli}`,
-        `OpenClaw CLI: ${health.openClawCli}`,
-        `Claude Code CLI: ${health.claudeCodeCli}`,
-        `Hermes API: ${config.hermesApiBaseUrl}`,
-        `OpenClaw Gateway: ${config.openClawGatewayUrl}`,
-        `Enabled agents/default: ${enabledAgents(config).join(", ")} / ${config.defaultAgent}`,
-        `State DB: ${health.databasePath ?? "-"}`,
-        `Log file: ${health.logFile}`,
-        `Log format: ${config.logFormat}`,
-        `Tool verbosity: ${config.toolVerbosity}`,
-        `Telegram rate limit queued/running/retries/429: ${runtime.rateLimit.queued}/${runtime.rateLimit.running}/${runtime.rateLimit.retries}/${runtime.rateLimit.rateLimitHits}`,
-        `Telegram last retry_after: ${runtime.rateLimit.lastRetryAfterSeconds ?? "-"}s`,
-        `CLI mirror mode/update: ${runtime.mirrorMode} / ${config.telegramMirrorMinUpdateMs} ms`,
-        `Notify/quiet: ${runtime.notifyMode} / ${runtime.quietHours}`,
-        `Voice: ${runtime.voiceBackend} / ${runtime.voiceLanguage} / transcribe-only ${runtime.voiceTranscribeOnly ? "on" : "off"}`,
-        `Sync interval: ${config.codexSyncIntervalMs} ms`,
-        `External busy check/stale: ${config.codexExternalBusyCheckMs} ms / ${config.codexExternalBusyStaleMs} ms`,
-        `External mirrors/timers/status messages: ${runtime.externalMirrors}/${runtime.externalQueueTimers}/${runtime.queueStatusMessages}`,
-        `Auto-send artifacts: ${config.telegramAutoSendArtifacts ? "yes" : "no"}`,
-        `Artifact ignore dirs/globs: ${config.artifactIgnoreDirs.length}/${config.artifactIgnoreGlobs.length}`,
-        `Artifact retention: ${config.artifactRetentionDays}d / ${config.artifactMaxTurnDirs} turns / ${config.artifactMaxInboxDirs} inbox dirs`,
-        `Workspace allowed/warn roots: ${config.workspaceAllowedRoots.length}/${config.workspaceWarnRoots.length}`,
-        `Allowed users/chats/admins/readonly: ${config.telegramAllowedUserIds.length}/${config.telegramAllowedChatIds.length}/${config.telegramAdminUserIds.length}/${config.telegramReadOnlyUserIds.length}`,
-        `Session lock TTL: ${config.sessionLockTtlMs} ms`,
-        `Audit max events: ${config.auditMaxEvents}`,
-        `Loaded sessions: ${contexts.length}`,
-        `Current queue: ${queueLength}`,
-        `Current progress: ${progress?.status ?? "idle"}`,
-    ].join("\n");
-}
-function renderDiagnosticsHTML(config, registry, health, authenticated, role, queueLength, progress, runtime) {
-    const contexts = registry.listContexts();
-    return [
-        "<b>Diagnostics:</b>",
-        `<b>Status:</b> <code>${escapeHTML(health.state.status ?? "unknown")}</code>`,
-        `<b>Version:</b> <code>${escapeHTML(health.version)}</code>`,
-        `<b>Role:</b> <code>${escapeHTML(role)}</code>`,
-        `<b>Auth:</b> <code>${authenticated ? "yes" : "no"} (${escapeHTML(health.state.authMethod ?? "-")})</code>`,
-        `<b>PID:</b> <code>${escapeHTML(String(health.state.pid ?? "-"))} (${health.pidRunning ? "running" : "not running"})</code>`,
-        `<b>App PID:</b> <code>${escapeHTML(String(health.state.appPid ?? "-"))} (${health.appPidRunning ? "running" : "not running"})</code>`,
-        `<b>Workspace:</b> <code>${escapeHTML(config.workspace)}</code>`,
-        `<b>State backend:</b> <code>${escapeHTML(config.stateBackend)}</code>`,
-        `<b>Telegram transport:</b> <code>${escapeHTML(config.telegramTransport)}</code>`,
-        `<b>Codex CLI:</b> <code>${escapeHTML(health.codexCli)}</code>`,
-        `<b>Pi CLI:</b> <code>${escapeHTML(health.piCli)}</code>`,
-        `<b>Hermes CLI:</b> <code>${escapeHTML(health.hermesCli)}</code>`,
-        `<b>OpenClaw CLI:</b> <code>${escapeHTML(health.openClawCli)}</code>`,
-        `<b>Claude Code CLI:</b> <code>${escapeHTML(health.claudeCodeCli)}</code>`,
-        `<b>Hermes API:</b> <code>${escapeHTML(config.hermesApiBaseUrl)}</code>`,
-        `<b>OpenClaw Gateway:</b> <code>${escapeHTML(config.openClawGatewayUrl)}</code>`,
-        `<b>Enabled agents/default:</b> <code>${escapeHTML(`${enabledAgents(config).join(", ")} / ${config.defaultAgent}`)}</code>`,
-        `<b>State DB:</b> <code>${escapeHTML(health.databasePath ?? "-")}</code>`,
-        `<b>Log file:</b> <code>${escapeHTML(health.logFile)}</code>`,
-        `<b>Log format:</b> <code>${escapeHTML(config.logFormat)}</code>`,
-        `<b>Tool verbosity:</b> <code>${escapeHTML(config.toolVerbosity)}</code>`,
-        `<b>Telegram rate limit queued/running/retries/429:</b> <code>${runtime.rateLimit.queued}/${runtime.rateLimit.running}/${runtime.rateLimit.retries}/${runtime.rateLimit.rateLimitHits}</code>`,
-        `<b>Telegram last retry_after:</b> <code>${escapeHTML(String(runtime.rateLimit.lastRetryAfterSeconds ?? "-"))}s</code>`,
-        `<b>CLI mirror mode/update:</b> <code>${escapeHTML(runtime.mirrorMode)} / ${config.telegramMirrorMinUpdateMs} ms</code>`,
-        `<b>Notify/quiet:</b> <code>${escapeHTML(runtime.notifyMode)} / ${escapeHTML(runtime.quietHours)}</code>`,
-        `<b>Voice:</b> <code>${escapeHTML(runtime.voiceBackend)} / ${escapeHTML(runtime.voiceLanguage)} / transcribe-only ${runtime.voiceTranscribeOnly ? "on" : "off"}</code>`,
-        `<b>Sync interval:</b> <code>${config.codexSyncIntervalMs} ms</code>`,
-        `<b>External busy check/stale:</b> <code>${config.codexExternalBusyCheckMs} ms / ${config.codexExternalBusyStaleMs} ms</code>`,
-        `<b>External mirrors/timers/status messages:</b> <code>${runtime.externalMirrors}/${runtime.externalQueueTimers}/${runtime.queueStatusMessages}</code>`,
-        `<b>Auto-send artifacts:</b> <code>${config.telegramAutoSendArtifacts ? "yes" : "no"}</code>`,
-        `<b>Artifact ignore dirs/globs:</b> <code>${config.artifactIgnoreDirs.length}/${config.artifactIgnoreGlobs.length}</code>`,
-        `<b>Artifact retention:</b> <code>${config.artifactRetentionDays}d / ${config.artifactMaxTurnDirs} turns / ${config.artifactMaxInboxDirs} inbox dirs</code>`,
-        `<b>Workspace allowed/warn roots:</b> <code>${config.workspaceAllowedRoots.length}/${config.workspaceWarnRoots.length}</code>`,
-        `<b>Allowed users/chats/admins/readonly:</b> <code>${config.telegramAllowedUserIds.length}/${config.telegramAllowedChatIds.length}/${config.telegramAdminUserIds.length}/${config.telegramReadOnlyUserIds.length}</code>`,
-        `<b>Session lock TTL:</b> <code>${config.sessionLockTtlMs} ms</code>`,
-        `<b>Audit max events:</b> <code>${config.auditMaxEvents}</code>`,
-        `<b>Loaded sessions:</b> <code>${contexts.length}</code>`,
-        `<b>Current queue:</b> <code>${queueLength}</code>`,
-        `<b>Current progress:</b> <code>${escapeHTML(progress?.status ?? "idle")}</code>`,
-    ].join("\n");
-}
-function renderHealthPlain(health, authenticated, role) {
-    return [
-        `Status: ${health.state.status ?? "unknown"}`,
-        `Version: ${health.version}`,
-        `Role: ${role}`,
-        `Auth: ${authenticated ? "yes" : "no"}`,
-        `PID: ${health.state.pid ?? "-"} (${health.pidRunning ? "running" : "not running"})`,
-        `App PID: ${health.state.appPid ?? "-"} (${health.appPidRunning ? "running" : "not running"})`,
-        `Uptime: ${formatDuration(health.uptimeSeconds)}`,
-        `Workspace: ${health.state.workspace ?? "-"}`,
-        `Codex CLI: ${health.codexCli}`,
-        `Pi CLI: ${health.piCli}`,
-        `Hermes CLI: ${health.hermesCli}`,
-        `OpenClaw CLI: ${health.openClawCli}`,
-        `Claude Code CLI: ${health.claudeCodeCli}`,
-        `Codex state DB: ${health.databasePath ?? "-"}`,
-        `Log: ${health.logFile}`,
-    ].join("\n");
-}
-function renderHealthHTML(health, authenticated, role) {
-    return [
-        `<b>Status:</b> <code>${escapeHTML(health.state.status ?? "unknown")}</code>`,
-        `<b>Version:</b> <code>${escapeHTML(health.version)}</code>`,
-        `<b>Role:</b> <code>${escapeHTML(role)}</code>`,
-        `<b>Auth:</b> <code>${authenticated ? "yes" : "no"}</code>`,
-        `<b>PID:</b> <code>${escapeHTML(String(health.state.pid ?? "-"))} (${health.pidRunning ? "running" : "not running"})</code>`,
-        `<b>App PID:</b> <code>${escapeHTML(String(health.state.appPid ?? "-"))} (${health.appPidRunning ? "running" : "not running"})</code>`,
-        `<b>Uptime:</b> <code>${escapeHTML(formatDuration(health.uptimeSeconds))}</code>`,
-        `<b>Workspace:</b> <code>${escapeHTML(health.state.workspace ?? "-")}</code>`,
-        `<b>Codex CLI:</b> <code>${escapeHTML(health.codexCli)}</code>`,
-        `<b>Pi CLI:</b> <code>${escapeHTML(health.piCli)}</code>`,
-        `<b>Hermes CLI:</b> <code>${escapeHTML(health.hermesCli)}</code>`,
-        `<b>OpenClaw CLI:</b> <code>${escapeHTML(health.openClawCli)}</code>`,
-        `<b>Claude Code CLI:</b> <code>${escapeHTML(health.claudeCodeCli)}</code>`,
-        `<b>Codex state DB:</b> <code>${escapeHTML(health.databasePath ?? "-")}</code>`,
-        `<b>Log:</b> <code>${escapeHTML(health.logFile)}</code>`,
-    ].join("\n");
-}
-function parseFastModeArgument(argument, currentValue) {
-    if (!argument) {
-        return !currentValue;
-    }
-    const normalized = argument.toLowerCase();
-    if (["on", "enable", "enabled", "true", "1"].includes(normalized)) {
-        return true;
-    }
-    if (["off", "disable", "disabled", "false", "0"].includes(normalized)) {
-        return false;
-    }
-    return undefined;
-}
-function parseToggle(argument) {
-    const normalized = argument.trim().toLowerCase();
-    if (["on", "enable", "enabled", "true", "1", "yes"].includes(normalized)) {
-        return true;
-    }
-    if (["off", "disable", "disabled", "false", "0", "no"].includes(normalized)) {
-        return false;
-    }
-    return undefined;
-}
-function parseDurationToMs(value) {
-    const match = value.trim().match(/^(\d+)(s|m|h|d)?$/i);
-    if (!match) {
-        return undefined;
-    }
-    const amount = Number(match[1]);
-    const unit = (match[2] ?? "m").toLowerCase();
-    const multiplier = unit === "s"
-        ? 1000
-        : unit === "h"
-            ? 60 * 60 * 1000
-            : unit === "d"
-                ? 24 * 60 * 60 * 1000
-                : 60 * 1000;
-    return amount * multiplier;
-}
-function extractCommandName(text) {
-    const match = text.trim().match(/^\/([a-zA-Z0-9_-]+)(?:@\w+)?(?:\s|$)/);
-    return match?.[1]?.toLowerCase();
-}
-function isPromptEnvelopeLike(value) {
-    return typeof value === "object" && value !== null && "input" in value && "description" in value;
-}
-function isQueuedPromptLike(value) {
-    return "id" in value &&
-        "contextKey" in value &&
-        "createdAt" in value &&
-        typeof value.id === "string" &&
-        typeof value.contextKey === "string" &&
-        typeof value.createdAt === "number";
-}
-function capabilitiesOf(info) {
-    return info.capabilities ?? CODEX_AGENT_CAPABILITIES;
-}
-function labelOf(info) {
-    return info.agentLabel ?? agentLabel(info.agentId ?? "codex");
-}
-function idOf(info) {
-    return info.agentId ?? "codex";
-}
-function authHelpText(info) {
-    const agentId = idOf(info);
-    if (agentId === "pi") {
-        return "Configure the required Pi provider environment variable on the host.";
-    }
-    if (agentId === "hermes") {
-        return "Start the Hermes API Server, configure HERMES_API_KEY when required, or use /login to start Hermes CLI auth.";
-    }
-    if (agentId === "openclaw") {
-        return "Start the OpenClaw Gateway and configure OPENCLAW_GATEWAY_TOKEN or OPENCLAW_GATEWAY_PASSWORD when the gateway requires one.";
-    }
-    if (agentId === "claude-code") {
-        return "Use /login to start Claude Code CLI auth, or run 'claude auth login' on the host.";
-    }
-    return "Use /login to start authentication, or set CODEX_API_KEY on the host.";
-}
-function formatAgentSettingScope(info, appliedToActiveThread) {
-    const agentId = idOf(info);
-    if (agentId === "hermes") {
-        return appliedToActiveThread
-            ? "applies to the next Hermes run in this session"
-            : "applies to new Hermes sessions";
-    }
-    if (agentId === "pi") {
-        return appliedToActiveThread
-            ? "applied to the current idle Pi session and future turns"
-            : "applies to new Pi sessions";
-    }
-    if (agentId === "openclaw") {
-        return appliedToActiveThread
-            ? "applies to the next OpenClaw run in this session"
-            : "applies to new OpenClaw sessions";
-    }
-    if (agentId === "claude-code") {
-        return appliedToActiveThread
-            ? "applies to the next Claude Code run in this session"
-            : "applies to new Claude Code sessions";
-    }
-    return appliedToActiveThread
-        ? "applied to the current idle thread and future threads"
-        : "applies to new threads";
-}
-function requiresTurnApproval(info) {
-    return info.unsafeLaunch || info.approvalPolicy !== "never";
-}
-function formatDuration(totalSeconds) {
-    const seconds = Math.max(0, Math.floor(totalSeconds));
-    const days = Math.floor(seconds / 86400);
-    const hours = Math.floor((seconds % 86400) / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-    if (days > 0) {
-        return `${days}d ${hours}h`;
-    }
-    if (hours > 0) {
-        return `${hours}h ${minutes}m`;
-    }
-    return `${minutes}m`;
-}
-function formatDurationSeconds(totalSeconds) {
-    const seconds = Math.max(0, Math.floor(totalSeconds));
-    if (seconds < 60) {
-        return `${seconds}s`;
-    }
-    const minutes = Math.floor(seconds / 60);
-    const remainingSeconds = seconds % 60;
-    if (minutes < 60) {
-        return `${minutes}m ${remainingSeconds}s`;
-    }
-    const hours = Math.floor(minutes / 60);
-    return `${hours}h ${minutes % 60}m`;
-}
-function renderToolStartMessage(toolName) {
-    return {
-        text: `<b>🔧 Running:</b> <code>${escapeHTML(toolName)}</code>`,
-        fallbackText: `🔧 Running: ${toolName}`,
-        parseMode: "HTML",
-    };
-}
-function renderToolEndMessage(toolName, partialResult, isError) {
-    const preview = summarizeToolOutput(partialResult);
-    const icon = isError ? "❌" : "✅";
-    const htmlLines = [`<b>${icon}</b> <code>${escapeHTML(toolName)}</code>`];
-    const plainLines = [`${icon} ${toolName}`];
-    if (preview) {
-        htmlLines.push(`<pre>${escapeHTML(preview)}</pre>`);
-        plainLines.push(preview);
-    }
-    return {
-        text: htmlLines.join("\n"),
-        fallbackText: plainLines.join("\n"),
-        parseMode: "HTML",
-    };
-}
-export function formatToolSummaryLine(toolCounts) {
-    if (toolCounts.size === 0) {
-        return "";
-    }
-    const summarizedCounts = new Map();
-    for (const [toolName, count] of toolCounts.entries()) {
-        const summaryName = summarizeToolName(toolName);
-        summarizedCounts.set(summaryName, (summarizedCounts.get(summaryName) ?? 0) + count);
-    }
-    const entries = [...summarizedCounts.entries()].sort((left, right) => {
-        const countDelta = right[1] - left[1];
-        return countDelta !== 0 ? countDelta : left[0].localeCompare(right[0]);
-    });
-    const tools = entries
-        .map(([name, count]) => formatSummaryEntry(name, count))
-        .join(", ");
-    return `Tools used: ${tools}`;
-}
-function renderTodoList(items) {
-    const lines = items.map((item) => {
-        const icon = item.completed ? "✅" : "⬜";
-        return `${icon} ${escapeHTML(item.text)}`;
-    });
-    return `📋 <b>Plan</b>\n${lines.join("\n")}`;
-}
-export function formatTurnUsageLine(usage) {
-    return `🪙 in: ${usage.inputTokens} · cached: ${usage.cachedInputTokens} · out: ${usage.outputTokens}`;
-}
-export function summarizeToolName(toolName) {
-    if (toolName.startsWith("🔍 ")) {
-        return "web_fetch";
-    }
-    if (toolName === "file_change") {
-        return "file_change";
-    }
-    if (toolName === "⚠️ error") {
-        return "error";
-    }
-    if (toolName.startsWith("mcp:")) {
-        const tool = toolName.split("/").at(-1) ?? toolName;
-        if (SUBAGENT_TOOL_NAMES.has(tool)) {
-            return "subagent";
-        }
-        return tool;
-    }
-    return "bash";
-}
-function formatSummaryEntry(name, count) {
-    if (count <= 1) {
-        return name;
-    }
-    const label = name === "subagent" ? "subagents" : name;
-    return `${count}x ${label}`;
-}
-const SUBAGENT_TOOL_NAMES = new Set(["spawn_agent", "send_input", "wait_agent", "close_agent", "resume_agent"]);
-async function safeReply(ctx, text, options = {}) {
-    const chatId = ctx.chat?.id;
-    if (!chatId) {
-        return;
-    }
-    const parseMode = options.parseMode !== undefined ? options.parseMode : "HTML";
-    const messageThreadId = options.messageThreadId ?? ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id;
-    const chunks = splitTelegramText(redactText(text));
-    const fallbackChunks = options.fallbackText ? splitTelegramText(redactText(options.fallbackText)) : [];
-    for (const [index, chunk] of chunks.entries()) {
-        await sendTextMessage(ctx.api, chatId, chunk, {
-            parseMode,
-            fallbackText: fallbackChunks[index] ?? chunk,
-            replyMarkup: index === 0 ? options.replyMarkup : undefined,
-            messageThreadId,
-        });
-    }
-}
-async function sendTextMessage(api, chatId, text, options = {}) {
-    const parseMode = Object.prototype.hasOwnProperty.call(options, "parseMode") ? options.parseMode : "HTML";
-    const safeText = redactText(text);
-    const safeFallbackText = options.fallbackText === undefined ? undefined : redactText(options.fallbackText);
-    const bucket = chatBucket(chatId);
-    try {
-        return await telegramRateLimiter.run(bucket, "sendMessage", () => api.sendMessage(chatId, safeText, {
-            ...(parseMode ? { parse_mode: parseMode } : {}),
-            ...(options.messageThreadId ? { message_thread_id: options.messageThreadId } : {}),
-            reply_markup: options.replyMarkup,
-        }));
-    }
-    catch (error) {
-        if (parseMode && safeFallbackText !== undefined && isTelegramParseError(error)) {
-            return await telegramRateLimiter.run(bucket, "sendMessage", () => api.sendMessage(chatId, safeFallbackText, {
-                ...(options.messageThreadId ? { message_thread_id: options.messageThreadId } : {}),
-                reply_markup: options.replyMarkup,
-            }));
-        }
-        throw error;
-    }
-}
-async function safeEditMessage(bot, chatId, messageId, text, options = {}) {
-    const parseMode = Object.prototype.hasOwnProperty.call(options, "parseMode") ? options.parseMode : "HTML";
-    const safeText = redactText(text);
-    const safeFallbackText = options.fallbackText === undefined ? undefined : redactText(options.fallbackText);
-    const bucket = `${chatBucket(chatId)}:${messageId}`;
-    try {
-        await telegramRateLimiter.run(bucket, "editMessageText", () => bot.api.editMessageText(chatId, messageId, safeText, {
-            ...(parseMode ? { parse_mode: parseMode } : {}),
-            reply_markup: options.replyMarkup,
-        }));
-    }
-    catch (error) {
-        if (isMessageNotModifiedError(error)) {
-            return;
-        }
-        if (parseMode && safeFallbackText !== undefined && isTelegramParseError(error)) {
-            await telegramRateLimiter.run(bucket, "editMessageText", () => bot.api.editMessageText(chatId, messageId, safeFallbackText, {
-                reply_markup: options.replyMarkup,
-            }));
-            return;
-        }
-        throw error;
-    }
-}
-async function safeEditReplyMarkup(bot, chatId, messageId, replyMarkup) {
-    try {
-        await telegramRateLimiter.run(`${chatBucket(chatId)}:${messageId}`, "editMessageReplyMarkup", () => bot.api.editMessageReplyMarkup(chatId, messageId, {
-            reply_markup: replyMarkup ?? new InlineKeyboard(),
-        }));
-    }
-    catch (error) {
-        if (!isMessageNotModifiedError(error)) {
-            throw error;
-        }
-    }
-}
-async function sendChatActionSafe(api, chatId, action, messageThreadId) {
-    await telegramRateLimiter.run(chatBucket(chatId), "sendChatAction", () => api.sendChatAction(chatId, action, {
-        ...(messageThreadId ? { message_thread_id: messageThreadId } : {}),
-    }));
-}
-function chatBucket(chatId) {
-    return `chat:${String(chatId)}`;
-}
-async function downloadTelegramFile(api, token, fileId, maxBytes = MAX_AUDIO_FILE_SIZE) {
-    const file = await api.getFile(fileId);
-    if (!file.file_path) {
-        throw new Error("Telegram did not return a file path");
-    }
-    if (file.file_size && file.file_size > maxBytes) {
-        throw new Error(`Telegram file too large (${Math.round(file.file_size / 1024 / 1024)} MB, max ${Math.round(maxBytes / 1024 / 1024)} MB)`);
-    }
-    const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to download Telegram file: ${response.status}`);
-    }
-    const buffer = Buffer.from(await response.arrayBuffer());
-    const extension = path.extname(file.file_path) || ".bin";
-    const tempPath = path.join(tmpdir(), `nordrelay-file-${randomUUID()}${extension}`);
-    await writeFile(tempPath, buffer);
-    return tempPath;
-}
-function splitTelegramText(text) {
-    if (text.length <= TELEGRAM_MESSAGE_LIMIT) {
-        return [text];
-    }
-    const chunks = [];
-    let remaining = text;
-    while (remaining.length > TELEGRAM_MESSAGE_LIMIT) {
-        let cut = remaining.lastIndexOf("\n", TELEGRAM_MESSAGE_LIMIT);
-        if (cut < TELEGRAM_MESSAGE_LIMIT * 0.5) {
-            cut = remaining.lastIndexOf(" ", TELEGRAM_MESSAGE_LIMIT);
-        }
-        if (cut < TELEGRAM_MESSAGE_LIMIT * 0.5) {
-            cut = TELEGRAM_MESSAGE_LIMIT;
-        }
-        chunks.push(remaining.slice(0, cut).trimEnd());
-        remaining = remaining.slice(cut).trimStart();
-    }
-    if (remaining) {
-        chunks.push(remaining);
-    }
-    return chunks.length > 0 ? chunks : [""];
-}
-function splitMarkdownForTelegram(markdown) {
-    if (!markdown) {
-        return [];
-    }
-    const chunks = [];
-    let remaining = markdown;
-    while (remaining) {
-        const maxLength = Math.min(remaining.length, FORMATTED_CHUNK_TARGET);
-        const initialCut = findPreferredSplitIndex(remaining, maxLength);
-        const candidate = remaining.slice(0, initialCut) || remaining.slice(0, 1);
-        const rendered = renderMarkdownChunkWithinLimit(candidate);
-        chunks.push(rendered);
-        remaining = remaining.slice(rendered.sourceText.length).trimStart();
-    }
-    return chunks;
-}
-function renderMarkdownChunkWithinLimit(markdown) {
-    if (!markdown) {
-        return {
-            text: "",
-            fallbackText: "",
-            parseMode: "HTML",
-            sourceText: "",
-        };
-    }
-    let sourceText = markdown;
-    let rendered = formatMarkdownMessage(sourceText);
-    while (rendered.text.length > TELEGRAM_MESSAGE_LIMIT && sourceText.length > 1) {
-        const nextLength = Math.max(1, sourceText.length - Math.max(100, Math.ceil(sourceText.length * 0.1)));
-        sourceText = sourceText.slice(0, nextLength).trimEnd() || sourceText.slice(0, nextLength);
-        rendered = formatMarkdownMessage(sourceText);
-    }
-    return {
-        ...rendered,
-        sourceText,
-    };
-}
-function formatMarkdownMessage(markdown) {
-    try {
-        return {
-            text: formatTelegramHTML(markdown),
-            fallbackText: markdown,
-            parseMode: "HTML",
-        };
-    }
-    catch (error) {
-        console.error("Failed to format Telegram HTML, falling back to plain text", error);
-        return {
-            text: markdown,
-            fallbackText: markdown,
-            parseMode: undefined,
-        };
-    }
-}
-function findPreferredSplitIndex(text, maxLength) {
-    if (text.length <= maxLength) {
-        return Math.max(1, text.length);
-    }
-    const newlineIndex = text.lastIndexOf("\n", maxLength);
-    if (newlineIndex >= maxLength * 0.5) {
-        return Math.max(1, newlineIndex);
-    }
-    const spaceIndex = text.lastIndexOf(" ", maxLength);
-    if (spaceIndex >= maxLength * 0.5) {
-        return Math.max(1, spaceIndex);
-    }
-    return Math.max(1, maxLength);
-}
-function buildStreamingPreview(text) {
-    if (text.length <= STREAMING_PREVIEW_LIMIT) {
-        return text;
-    }
-    return `${text.slice(0, STREAMING_PREVIEW_LIMIT)}\n\n… streaming (preview truncated)`;
-}
-function appendWithCap(base, addition, cap) {
-    const combined = `${base}${addition}`;
-    return combined.length <= cap ? combined : combined.slice(-cap);
-}
-function summarizeToolOutput(text) {
-    const trimmed = text.trim();
-    if (!trimmed) {
-        return "";
-    }
-    return trimmed.length <= TOOL_OUTPUT_PREVIEW_LIMIT ? trimmed : `${trimmed.slice(-TOOL_OUTPUT_PREVIEW_LIMIT)}\n…`;
-}
-function trimLine(text, maxLength) {
-    const singleLine = text.replace(/\s+/g, " ").trim();
-    if (singleLine.length <= maxLength) {
-        return singleLine;
-    }
-    return `${singleLine.slice(0, maxLength - 1)}…`;
-}
-function getWorkspaceShortName(workspace) {
-    return workspace.split(/[\\/]/).filter(Boolean).pop() ?? workspace;
-}
-function formatRelativeTime(date) {
-    const deltaMs = Date.now() - date.getTime();
-    const deltaSeconds = Math.max(0, Math.floor(deltaMs / 1000));
-    if (deltaSeconds < 60) {
-        return "just now";
-    }
-    const deltaMinutes = Math.floor(deltaSeconds / 60);
-    if (deltaMinutes < 60) {
-        return `${deltaMinutes}m ago`;
-    }
-    const deltaHours = Math.floor(deltaMinutes / 60);
-    if (deltaHours < 48) {
-        return `${deltaHours}h ago`;
-    }
-    const deltaDays = Math.floor(deltaHours / 24);
-    if (deltaDays < 14) {
-        return `${deltaDays}d ago`;
-    }
-    const deltaWeeks = Math.floor(deltaDays / 7);
-    return `${deltaWeeks}w ago`;
-}
-function filterSessions(sessions, query) {
-    const normalized = query.trim().toLowerCase();
-    if (!normalized) {
-        return sessions;
-    }
-    return sessions.filter((session) => [
-        session.id,
-        session.title ?? "",
-        session.cwd,
-        session.model ?? "",
-        session.firstUserMessage ?? "",
-    ].some((value) => value.toLowerCase().includes(normalized)));
-}
-function orderPinnedSessions(sessions, pinnedThreadIds) {
-    const pinnedIndex = new Map(pinnedThreadIds.map((threadId, index) => [threadId, index]));
-    return [...sessions].sort((left, right) => {
-        const leftPinned = pinnedIndex.get(left.id);
-        const rightPinned = pinnedIndex.get(right.id);
-        if (leftPinned !== undefined && rightPinned !== undefined) {
-            return leftPinned - rightPinned;
-        }
-        if (leftPinned !== undefined) {
-            return -1;
-        }
-        if (rightPinned !== undefined) {
-            return 1;
-        }
-        return 0;
-    });
-}
-function isMessageNotModifiedError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.includes("message is not modified");
-}
-function isTelegramParseError(error) {
-    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
-    return (message.includes("can't parse entities") ||
-        message.includes("unsupported start tag") ||
-        message.includes("unexpected end tag") ||
-        message.includes("entity name") ||
-        message.includes("parse entities"));
-}
-function renderPromptFailure(accumulatedText, error) {
-    const message = friendlyErrorText(error);
-    return accumulatedText.trim() ? `${accumulatedText.trim()}\n\n⚠️ ${message}` : `⚠️ ${message}`;
-}
-function formatError(error) {
-    return error instanceof Error ? error.message : String(error);
-}