arisa 4.3.5 → 5.1.2

package/src/transport/telegram/bot.js

@@ -3,16 +3,61 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact, formatLocationText } from "./media.js";
 import { buildDeviceCodeTelegramMessage } from "./device-code-message.js";
-import { buildEffortPicker, buildModelPicker, parseEffortPickerAction, parseModelPickerAction } from "./model-picker.js";
+import { buildEffortPicker, buildModelPicker, buildSpeedPicker, parseEffortPickerAction, parseModelPickerAction, parseSpeedPickerAction, reverseModelOrder } from "./model-picker.js";
 import { renderTelegramHtml } from "./text-format.js";
 import { buildPiAuthRecoveryBlockedMessage, buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue, getPiAuthStatus } from "../../core/agent/auth-flow.js";
 import { createPiOAuthLogin } from "../../core/agent/pi-auth-login.js";
-import { resolveChatModel, resolveChatThinkingLevel, selectChatModel, selectChatThinkingLevel } from "../../core/agent/model-selection.js";
+import { getAgentConfig, resolveChatModel, resolveChatSpeed, resolveChatThinkingLevel, selectChatModel, selectChatSpeed, selectChatThinkingLevel } from "../../core/agent/model-selection.js";
 import { clampModelThinkingLevel, createPiRuntime, listModelThinkingLevels, listProviderModels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
+import { clampModelSpeed, MODEL_SPEEDS, modelSupportsSpeed } from "../../core/agent/model-speed.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
+import { formatPortableSessionHistory } from "../../core/agent/agent-manager.js";
+import { ConversationHistoryStore } from "../../core/conversation/conversation-history-store.js";
+import { formatDoctorReport } from "../../runtime/doctor.js";
+import { formatToolUsageReport } from "../../runtime/tool-usage-report.js";
 
 const slowPromptNoticeMs = 300_000;
 
+export const telegramCommands = Object.freeze([
+  { command: "new", description: "New chat context" },
+  { command: "restart", description: "Restart Arisa" },
+  { command: "doctor", description: "Check runtime health" },
+  { command: "update", description: "Check for updates" },
+  { command: "tools", description: "Tool usage counts" },
+  { command: "model", description: "Choose chat model" },
+  { command: "effort", description: "Choose reasoning effort" },
+  { command: "speed", description: "Choose model speed" },
+  { command: "auth", description: "Authentication status" }
+]);
+
+export function createTelegramRestartHandler({ authorize, requestRestart, logger }) {
+  if (typeof authorize !== "function" || typeof requestRestart !== "function") {
+    throw new Error("Telegram restart requires authorization and restart handoff functions");
+  }
+
+  let restartRequested = false;
+  return async (ctx) => {
+    const auth = await authorize(ctx);
+    if (!auth.ok) return;
+
+    if (restartRequested) {
+      await ctx.reply("An Arisa restart is already in progress.");
+      return;
+    }
+
+    restartRequested = true;
+    try {
+      await ctx.reply("Arisa is restarting. I'll be back shortly.");
+      const handoff = await requestRestart();
+      logger?.log("telegram", `restart handed off to process ${handoff.pid}`);
+    } catch (error) {
+      restartRequested = false;
+      logger?.error("telegram", `restart handoff failed: ${getErrorMessage(error)}`);
+      await ctx.reply(`Arisa could not be restarted: ${getErrorMessage(error)}`);
+    }
+  };
+}
+
 function quotedMessageSummary(message) {
   if (!message) return [];
 
@@ -53,6 +98,67 @@ function getIncomingMessageText(message) {
   return message?.text || message?.caption || formatLocationText(message) || "";
 }
 
+function telegramDisplayName(entity = {}) {
+  if (entity.username) return `@${entity.username}`;
+  return [entity.first_name, entity.last_name].filter(Boolean).join(" ") || entity.title || "unknown";
+}
+
+function forwardedMessageSummary(message) {
+  const origin = message?.forward_origin;
+  if (!origin) return [];
+
+  const parts = ["forwarded: true", `forwardedOriginType: ${origin.type}`];
+  if (origin.type === "user") parts.push(`forwardedFrom: ${telegramDisplayName(origin.sender_user)}`);
+  if (origin.type === "hidden_user") parts.push(`forwardedFrom: ${origin.sender_user_name}`);
+  if (origin.type === "chat" || origin.type === "channel") {
+    parts.push(`forwardedFrom: ${telegramDisplayName(origin.chat)}`);
+  }
+  if (origin.type === "channel" && origin.message_id) parts.push(`forwardedMessageId: ${origin.message_id}`);
+  if (origin.author_signature) parts.push(`forwardedAuthorSignature: ${origin.author_signature}`);
+  if (origin.date) parts.push(`forwardedAt: ${new Date(origin.date * 1000).toISOString()}`);
+  return parts;
+}
+
+function reactionLabel(reaction = {}) {
+  if (reaction.type === "emoji") return reaction.emoji || "emoji";
+  if (reaction.type === "custom_emoji") return `custom:${reaction.custom_emoji_id || "unknown"}`;
+  if (reaction.type === "paid") return "paid";
+  return reaction.type || "unknown";
+}
+
+function reactionDifference(left = [], right = []) {
+  const remaining = right.map(reactionLabel);
+  return left.map(reactionLabel).filter((label) => {
+    const index = remaining.indexOf(label);
+    if (index < 0) return true;
+    remaining.splice(index, 1);
+    return false;
+  });
+}
+
+export function buildReactionPrompt({ reaction, reactedMessageText = "" }) {
+  const oldReactions = reaction.old_reaction || [];
+  const newReactions = reaction.new_reaction || [];
+  const added = reactionDifference(newReactions, oldReactions);
+  const removed = reactionDifference(oldReactions, newReactions);
+  const actor = reaction.user || reaction.actor_chat || {};
+  const actorId = reaction.user?.id || reaction.actor_chat?.id || "unknown";
+
+  return [
+    "Incoming Telegram reaction.",
+    `chatId: ${reaction.chat.id}`,
+    `userId: ${actorId}`,
+    `username: ${reaction.user?.username || "(no username)"}`,
+    `reactedMessageId: ${reaction.message_id}`,
+    reactedMessageText ? `reactedMessageText: ${reactedMessageText}` : null,
+    added.length ? `addedReactions: ${added.join(" ")}` : null,
+    removed.length ? `removedReactions: ${removed.join(" ")}` : null,
+    `currentReactions: ${newReactions.map(reactionLabel).join(" ") || "none"}`,
+    `actor: ${telegramDisplayName(actor)}`,
+    "Treat this as lightweight feedback on the referenced message. Respond only if the reaction clearly requests action; otherwise stay silent."
+  ].filter(Boolean).join("\n");
+}
+
 function baseMimeType(mimeType = "") {
   return mimeType.split(";")[0].trim().toLowerCase();
 }
@@ -80,6 +186,7 @@ export function buildPrompt({ ctx, artifact, transcript, toolResult }) {
 
   const messageText = getIncomingMessageText(ctx.message);
   if (messageText) parts.push(`text: ${messageText}`);
+  parts.push(...forwardedMessageSummary(ctx.message));
   parts.push(...quotedMessageSummary(ctx.message?.reply_to_message));
   if (shouldIncludeArtifactReference({ artifact, messageText })) {
     if (artifact?.path) parts.push(`artifactPath: ${artifact.path}`);
@@ -219,12 +326,13 @@ function buildStartupMessage(chatMeta = {}) {
   return "Arisa is back online.";
 }
 
-async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {}) {
+export async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {}) {
   let text = "";
   let assistantErrorMessage = "";
   let shouldSeparateAssistantMessage = false;
   let slowPromptTimer = null;
   const unsubscribe = session.subscribe((event) => {
+    if (event.arisaPromptScoped === false) return;
     if (event.type === "message_start" && event.message.role === "assistant") {
       shouldSeparateAssistantMessage = text.trim().length > 0;
     }
@@ -235,8 +343,13 @@ async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {
       }
       text += event.assistantMessageEvent.delta;
     }
-    if (event.type === "message_end" && event.message?.stopReason === "error") {
-      assistantErrorMessage = event.message.errorMessage || "assistant message ended with error";
+    if (event.type === "message_end" && event.message?.role === "assistant") {
+      if (event.message.stopReason === "error") {
+        assistantErrorMessage = event.message.errorMessage || "assistant message ended with error";
+      } else if (event.message.stopReason !== "aborted") {
+        // Auto-compaction and retry can emit a transient error before a successful continuation.
+        assistantErrorMessage = "";
+      }
     }
     const logMessage = sessionEventLogMessage(event);
     if (logMessage) logger?.log("agent", `chat ${chatId} ${logMessage}`);
@@ -265,6 +378,32 @@ async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {
   return text.trim();
 }
 
+export function isSilentReply(text) {
+  return /^(?:NO_REPLY|No reply needed\.|No action needed\.)(?:\s+(?:NO_REPLY|No reply needed\.|No action needed\.))*$/.test(String(text || "").trim());
+}
+
+function buildSessionHandoffPrompt() {
+  return [
+    "Prepare a concise handoff for the next Arisa session.",
+    "Review the entire active session, including any previous compaction summaries and the latest messages.",
+    "Keep only durable context: current goals or projects, decisions, user preferences, unresolved tasks, and important facts needed to continue.",
+    "Use at most 8 short bullets and at most 1600 characters.",
+    "Exclude secrets, tokens, passwords, cookies, API keys, private file paths, full transcripts, and stale chatter.",
+    "Do not take actions, call tools, send messages, or explain the process.",
+    "Return only the handoff."
+  ].join("\n");
+}
+
+function sanitizeSessionHandoff(text) {
+  const sanitized = String(text || "")
+    .replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi, "[redacted private key]")
+    .replace(/\b(?:sk-[A-Za-z0-9_-]{12,}|gh[opsu]_[A-Za-z0-9_-]{12,}|Bearer\s+[A-Za-z0-9._-]+)\b/gi, "[redacted credential]")
+    .replace(/(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|client[_ -]?secret|password|cookie|secret)\s*[:=]\s*[^\s,;]+/gi, "[redacted credential]")
+    .trim();
+  if (sanitized.length <= 4000) return sanitized;
+  return `${sanitized.slice(0, 3997).trim()}...`;
+}
+
 async function withTyping(ctx, work) {
   await ctx.api.sendChatAction(ctx.chat.id, "typing");
   const timer = setInterval(() => {
@@ -278,14 +417,152 @@ async function withTyping(ctx, work) {
   }
 }
 
-export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger }) {
+export function createChatStateStore() {
+  const states = new Map();
+
+  function reset(chatId) {
+    const state = {
+      processing: false,
+      pendingPrompts: [],
+      continueAfterClose: false,
+      historyRevision: 0,
+      beforeNextPrompt: null,
+      activeSession: null,
+      activeSteers: [],
+      assistantMessages: new Map()
+    };
+    states.set(String(chatId), state);
+    return state;
+  }
+
+  return {
+    get(chatId) {
+      const key = String(chatId);
+      return states.get(key) || reset(key);
+    },
+    reset,
+    anyProcessing() {
+      return [...states.values()].some((state) => state.processing);
+    }
+  };
+}
+
+export function queueChatPrompt(chatState, prompt, { replace = false } = {}) {
+  if (replace) chatState.pendingPrompts = [];
+  chatState.pendingPrompts.push(prompt);
+}
+
+function takeQueuedPrompt(chatState) {
+  return chatState.pendingPrompts.shift() || "";
+}
+
+export function resolveTelegramBusyMessageMode(config, chatId) {
+  const chatMode = config.telegram?.chatMeta?.[String(chatId)]?.busyMessageMode;
+  const mode = chatMode || config.telegram?.busyMessageMode;
+  return mode === "steer" ? "steer" : "queue";
+}
+
+export async function routeBusyPrompt({ chatState, prompt, mode = "queue", replaceQueued = false }) {
+  const session = chatState.activeSession;
+  if (
+    mode === "steer"
+    && !replaceQueued
+    && !chatState.continueAfterClose
+    && !chatState.beforeNextPrompt
+    && session?.isStreaming
+    && typeof session.steer === "function"
+  ) {
+    try {
+      await session.steer(prompt);
+      chatState.activeSteers.push(prompt);
+      return { disposition: "steered" };
+    } catch (error) {
+      queueChatPrompt(chatState, prompt);
+      return { disposition: "queued", steerError: error };
+    }
+  }
+
+  queueChatPrompt(chatState, prompt, { replace: replaceQueued });
+  return { disposition: "queued" };
+}
+
+export async function drainChatPromptQueue({
+  chatState,
+  initialPrompt,
+  initialCtx = null,
+  processPrompt,
+  onPromptFailure,
+  onPromptInterrupted,
+  beforeInitialPrompt
+}) {
+  let currentPrompt = initialPrompt;
+  let currentCtx = initialCtx;
+
+  try {
+    await beforeInitialPrompt?.();
+    while (currentPrompt) {
+      while (chatState.beforeNextPrompt) {
+        const gate = chatState.beforeNextPrompt;
+        await gate;
+        if (chatState.beforeNextPrompt === gate) chatState.beforeNextPrompt = null;
+      }
+      if (chatState.continueAfterClose && chatState.pendingPrompts.length) {
+        currentPrompt = takeQueuedPrompt(chatState);
+        chatState.continueAfterClose = false;
+        currentCtx = null;
+      }
+      try {
+        await processPrompt({ prompt: currentPrompt, ctx: currentCtx });
+      } catch (error) {
+        if (chatState.continueAfterClose && chatState.pendingPrompts.length) {
+          await onPromptInterrupted?.(error);
+        } else {
+          await onPromptFailure?.(error);
+          throw error;
+        }
+      } finally {
+        currentCtx = null;
+      }
+
+      currentPrompt = takeQueuedPrompt(chatState);
+      chatState.continueAfterClose = false;
+    }
+  } finally {
+    chatState.processing = false;
+    chatState.activeSession = null;
+    chatState.activeSteers = [];
+  }
+}
+
+export async function closeModelPicker(ctx, { messageText, callbackText }) {
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    ctx.callbackQuery.message.message_id,
+    messageText
+  );
+  await ctx.answerCallbackQuery({ text: callbackText });
+}
+
+export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, doctor, checkUpdates, requestRestart, logger }) {
   const bot = new Bot(config.telegram.token);
-  const perChatState = new Map();
+  const perChatState = createChatStateStore();
+  const conversationHistory = new ConversationHistoryStore();
   const notifiedPromptErrors = new WeakSet();
   const authRenewals = new Map();
   let piAuthIssue = null;
   let taskTimer = null;
 
+  const handleRestartCommand = createTelegramRestartHandler({
+    authorize: (ctx) => authorizeChat({
+      config,
+      chatId: ctx.chat.id,
+      saveConfig,
+      chatMeta: getIncomingChatMeta(ctx)
+    }),
+    requestRestart,
+    logger
+  });
+
   function chatKey(chatId) {
     return String(chatId);
   }
@@ -309,7 +586,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     if (!issue) return false;
 
     try {
-      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, issue }));
+      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, chatId, issue }));
       markPromptErrorNotified(error);
       return true;
     } catch (notifyError) {
@@ -328,16 +605,16 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   async function finishAuthRenewal(chatId, renewal) {
     try {
       await renewal.promise;
-      await agentManager.validatePiAgent();
+      await agentManager.validateAgent();
       agentManager.clearSessionCache(chatId);
       piAuthIssue = null;
       logger?.log("telegram", `Pi auth renewal completed for chat ${chatId}`);
-      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, verified: true }));
+      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, chatId, verified: true }));
     } catch (error) {
       const issue = rememberPiAuthIssue(error) || { kind: "validation-failed", message: getErrorMessage(error) };
       piAuthIssue = issue;
       logger?.error("telegram", `Pi auth renewal failed for chat ${chatId}: ${getErrorMessage(error)}`);
-      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, issue })).catch((notifyError) => {
+      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, chatId, issue })).catch((notifyError) => {
         logger?.error("telegram", `auth renewal failure notice failed for chat ${chatId}: ${getErrorMessage(notifyError)}`);
       });
     } finally {
@@ -407,26 +684,25 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   }
 
   function getChatState(chatId) {
-    if (!perChatState.has(chatId)) {
-      perChatState.set(chatId, { processing: false, nextPrompt: "" });
-    }
     return perChatState.get(chatId);
   }
 
-  function getProviderModels() {
+  async function getProviderModels(chatId) {
     const runtime = createPiRuntime({
       provider: config.pi.provider,
       apiKey: config.pi.apiKey
     });
-    return listProviderModels(config.pi.provider, runtime);
+    return reverseModelOrder(listProviderModels(config.pi.provider, runtime));
   }
 
   async function showModelPicker(ctx, page = 0) {
+    const agentConfig = getAgentConfig(config);
     const picker = buildModelPicker({
-      provider: config.pi.provider,
-      models: getProviderModels(),
+      provider: agentConfig.provider,
+      models: await getProviderModels(ctx.chat.id),
       selectedModelId: resolveChatModel(config, ctx.chat.id),
       selectedThinkingLevel: resolveChatThinkingLevel(config, ctx.chat.id),
+      selectedSpeed: resolveChatSpeed(config, ctx.chat.id),
       page,
       pageSize: config.telegram.modelPickerPageSize
     });
@@ -439,10 +715,11 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   }
 
   async function showEffortPicker(ctx, { model, modelIndex, selectedThinkingLevel } = {}) {
-    const models = getProviderModels();
+    const agentConfig = getAgentConfig(config);
+    const models = await getProviderModels(ctx.chat.id);
     const resolvedModel = model || models.find((item) => item.id === resolveChatModel(config, ctx.chat.id));
     if (!resolvedModel) {
-      throw new Error(`Model not found for provider ${config.pi.provider}`);
+      throw new Error(`Model not found for provider ${agentConfig.provider}`);
     }
     if (!modelSupportsThinking(resolvedModel)) {
       const text = `${resolvedModel.provider}/${resolvedModel.id} does not support effort levels.`;
@@ -468,20 +745,46 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     return ctx.reply(picker.text, extra);
   }
 
+  async function showSpeedPicker(ctx) {
+    const agentConfig = getAgentConfig(config);
+    const models = await getProviderModels(ctx.chat.id);
+    const model = models.find((item) => item.id === resolveChatModel(config, ctx.chat.id));
+    if (!model) throw new Error(`Model not found for provider ${agentConfig.provider}`);
+    if (!modelSupportsSpeed(model)) {
+      const text = `${model.provider}/${model.id} does not support speed 1.5x.`;
+      if (ctx.callbackQuery?.message?.message_id) {
+        return ctx.api.editMessageText(ctx.chat.id, ctx.callbackQuery.message.message_id, text);
+      }
+      return ctx.reply(text);
+    }
+    const picker = buildSpeedPicker({
+      provider: model.provider,
+      modelId: model.id,
+      speeds: MODEL_SPEEDS,
+      selectedSpeed: resolveChatSpeed(config, ctx.chat.id)
+    });
+    const extra = { reply_markup: picker.replyMarkup };
+    const messageId = ctx.callbackQuery?.message?.message_id;
+    if (messageId) return ctx.api.editMessageText(ctx.chat.id, messageId, picker.text, extra);
+    return ctx.reply(picker.text, extra);
+  }
+
   async function persistChatModel(chatId, model, thinkingLevel) {
+    const agentConfig = getAgentConfig(config);
     const key = chatKey(chatId);
-    const hadSelections = Boolean(config.pi.chatModels);
-    const previousSelection = config.pi.chatModels?.[key];
+    const hadSelections = Boolean(agentConfig.chatModels);
+    const previousSelection = agentConfig.chatModels?.[key];
     const level = clampModelThinkingLevel(model, thinkingLevel ?? resolveChatThinkingLevel(config, chatId));
-    selectChatModel(config, chatId, model, { thinkingLevel: level });
+    const speed = clampModelSpeed(model, resolveChatSpeed(config, chatId));
+    selectChatModel(config, chatId, model, { thinkingLevel: level, speed });
     try {
       await saveConfig(config);
     } catch (error) {
       if (previousSelection) {
-        config.pi.chatModels[key] = previousSelection;
+        agentConfig.chatModels[key] = previousSelection;
       } else {
-        delete config.pi.chatModels[key];
-        if (!hadSelections) delete config.pi.chatModels;
+        delete agentConfig.chatModels[key];
+        if (!hadSelections) delete agentConfig.chatModels;
       }
       throw error;
     }
@@ -490,20 +793,44 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   }
 
   async function persistChatEffort(chatId, model, thinkingLevel) {
+    const agentConfig = getAgentConfig(config);
     const key = chatKey(chatId);
-    const hadSelections = Boolean(config.pi.chatModels);
-    const previousSelection = config.pi.chatModels?.[key];
+    const hadSelections = Boolean(agentConfig.chatModels);
+    const previousSelection = agentConfig.chatModels?.[key];
     const level = clampModelThinkingLevel(model, thinkingLevel);
     selectChatThinkingLevel(config, chatId, level);
     try {
       await saveConfig(config);
     } catch (error) {
       if (previousSelection) {
-        config.pi.chatModels[key] = previousSelection;
+        agentConfig.chatModels[key] = previousSelection;
+      } else {
+        delete agentConfig.chatModels[key];
+        if (!hadSelections) delete agentConfig.chatModels;
+      }
+      throw error;
+    }
+    return level;
+  }
+
+  async function persistChatSpeed(chatId, model, speed) {
+    const agentConfig = getAgentConfig(config);
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(agentConfig.chatModels);
+    const previousSelection = agentConfig.chatModels?.[key];
+    const level = clampModelSpeed(model, speed);
+    await agentManager.setModelSpeed(chatId, level);
+    selectChatSpeed(config, chatId, level);
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      if (previousSelection) {
+        agentConfig.chatModels[key] = previousSelection;
       } else {
-        delete config.pi.chatModels[key];
-        if (!hadSelections) delete config.pi.chatModels;
+        delete agentConfig.chatModels[key];
+        if (!hadSelections) delete agentConfig.chatModels;
       }
+      agentManager.clearSessionCache(chatId);
       throw error;
     }
     return level;
@@ -526,6 +853,11 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   async function sendTextReply({ sendText, sendDocument, chatId, text }) {
     const maxInlineReplyLength = 3500;
 
+    if (isSilentReply(text)) {
+      logger?.log("telegram", `suppressing silent reply for chat ${chatId}`);
+      return;
+    }
+
     if (text.length > maxInlineReplyLength) {
       logger?.log("telegram", `sending long reply as markdown attachment for chat ${chatId}`);
       const chatArtifactStore = artifactStore.forChat(chatId);
@@ -544,7 +876,12 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     }
 
     logger?.log("telegram", `sending text reply for chat ${chatId}`);
-    await sendText(renderTelegramHtml(text), { parse_mode: "HTML" });
+    const sent = await sendText(renderTelegramHtml(text), { parse_mode: "HTML" });
+    if (sent?.message_id) {
+      const messages = getChatState(chatId).assistantMessages;
+      messages.set(sent.message_id, text);
+      while (messages.size > 50) messages.delete(messages.keys().next().value);
+    }
   }
 
   function createTelegramSessionBridge(chatId) {
@@ -561,10 +898,35 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     };
   }
 
+  agentManager.setArtifactDeliveryHandler?.(async ({ chatId, artifact, caption, method }) => {
+    const resolvedMethod = method
+      || artifact.metadata?.delivery?.method
+      || (artifact.kind === "audio" || artifact.mimeType?.startsWith("audio/") ? "audio"
+        : artifact.kind === "image" || artifact.mimeType?.startsWith("image/") ? "photo"
+          : artifact.kind === "video" || artifact.mimeType?.startsWith("video/") ? "video"
+            : "document");
+    const safeCaption = caption && !/(^|\s)(\/[^\s]|[A-Za-z]:[\\/])/.test(caption) ? caption : undefined;
+    await createTelegramSessionBridge(chatId).sendMedia(artifact.path, {
+      method: resolvedMethod,
+      caption: safeCaption,
+      filename: path.basename(artifact.path)
+    });
+    return { ok: true, artifactId: artifact.id, method: resolvedMethod };
+  });
+
   async function processPromptForChat({ chatId, prompt, ctx = null }) {
     const work = async () => {
       const { session } = await agentManager.getSessionContext(chatId, createTelegramSessionBridge(chatId));
+      const historyRevision = getChatState(chatId).historyRevision;
+      await conversationHistory.ensureSeed(chatId, {
+        runtime: "pi",
+        history: formatPortableSessionHistory(session.messages)
+      });
       let text = "";
+      let steeredPrompts = [];
+      const chatState = getChatState(chatId);
+      chatState.activeSession = session;
+      chatState.activeSteers = [];
       try {
         text = await collectText(session, prompt, {
           logger,
@@ -577,6 +939,20 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       } catch (error) {
         agentManager.resetSession(chatId);
         throw error;
+      } finally {
+        steeredPrompts = [...chatState.activeSteers];
+        if (chatState.activeSession === session) chatState.activeSession = null;
+        chatState.activeSteers = [];
+      }
+      if (getChatState(chatId).historyRevision === historyRevision) {
+        const historyPrompt = steeredPrompts.length
+          ? [prompt, ...steeredPrompts.map((message) => `[Steering message]\n${message}`)].join("\n\n")
+          : prompt;
+        await conversationHistory.appendTurn(chatId, {
+          runtime: "pi",
+          prompt: historyPrompt,
+          response: text
+        });
       }
       if (text) {
         await sendTextReply({
@@ -592,46 +968,53 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     return work();
   }
 
-  async function enqueuePrompt({ chatId, prompt, label, ctx = null }) {
+  async function enqueuePrompt({ chatId, prompt, label, ctx = null, replaceQueued = false, busyMessageMode = "queue" }) {
     const chatState = getChatState(chatId);
 
     if (chatState.processing) {
-      logger?.log("telegram", `chat ${chatId} busy, queueing ${label}`);
-      chatState.nextPrompt = chatState.nextPrompt
-        ? `${chatState.nextPrompt}\n\n${prompt}`
-        : prompt;
+      const routed = await routeBusyPrompt({
+        chatState,
+        prompt,
+        mode: busyMessageMode,
+        replaceQueued
+      });
+      if (routed.disposition === "steered") {
+        logger?.log("telegram", `chat ${chatId} busy, steering ${label}`);
+      } else {
+        logger?.log("telegram", `chat ${chatId} busy, queueing ${label}`);
+        if (routed.steerError) {
+          logger?.log("telegram", `steer failed for chat ${chatId}, queued instead: ${getErrorMessage(routed.steerError)}`);
+        }
+      }
+      if (replaceQueued) chatState.continueAfterClose = true;
       return;
     }
 
     chatState.processing = true;
     logger?.log("telegram", `processing ${label} in chat ${chatId}`);
-    let currentPrompt = prompt;
-    let currentCtx = ctx;
-
-    try {
-      while (currentPrompt) {
-        try {
-          logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
-          await processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx });
-        } catch (error) {
-          const message = getErrorMessage(error);
-          logger?.error("telegram", `${label} failed for chat ${chatId}: ${message}`);
-          await notifyPiAuthIssueIfNeeded(chatId, error);
-          throw error;
-        } finally {
-          currentCtx = null;
-        }
+    return processChatPromptQueue({ chatId, prompt, label, ctx });
+  }
 
-        if (chatState.nextPrompt) {
-          currentPrompt = chatState.nextPrompt;
-          chatState.nextPrompt = "";
-        } else {
-          currentPrompt = "";
-        }
+  function processChatPromptQueue({ chatId, prompt, label, ctx = null, beforeInitialPrompt }) {
+    const chatState = getChatState(chatId);
+    return drainChatPromptQueue({
+      chatState,
+      initialPrompt: prompt,
+      initialCtx: ctx,
+      beforeInitialPrompt,
+      processPrompt: ({ prompt: currentPrompt, ctx: currentCtx }) => {
+        logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
+        return processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx });
+      },
+      onPromptInterrupted: (error) => {
+        logger?.log("telegram", `${label} interrupted by queued /new for chat ${chatId}: ${getErrorMessage(error)}`);
+      },
+      onPromptFailure: async (error) => {
+        const message = getErrorMessage(error);
+        logger?.error("telegram", `${label} failed for chat ${chatId}: ${message}`);
+        await notifyPiAuthIssueIfNeeded(chatId, error);
       }
-    } finally {
-      chatState.processing = false;
-    }
+    });
   }
 
   async function enqueueOrProcess(ctx) {
@@ -639,10 +1022,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
 
     if (chatState.processing) {
       const incomingPrompt = await buildIncomingPrompt(ctx);
+      const busyMessageMode = typeof ctx.message?.text === "string"
+        ? resolveTelegramBusyMessageMode(config, ctx.chat.id)
+        : "queue";
       return enqueuePrompt({
         chatId: ctx.chat.id,
         prompt: incomingPrompt,
-        label: `message ${ctx.msg.message_id}`
+        label: `message ${ctx.msg.message_id}`,
+        busyMessageMode
       });
     }
 
@@ -747,14 +1134,61 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     }
   }
 
+  async function summarizeSessionBeforeReset(chatId) {
+    try {
+      const context = await agentManager.getSessionContext(chatId, createTelegramSessionBridge(chatId));
+      const parentSession = context.session.sessionFile || "";
+      if (!context.session.messages.length) return { handoff: "", parentSession: "" };
+
+      const summary = await collectText(context.session, buildSessionHandoffPrompt(), { logger, chatId });
+      return { handoff: sanitizeSessionHandoff(summary), parentSession };
+    } catch (error) {
+      logger?.log("agent", `session handoff summary failed for chat ${chatId}: ${getErrorMessage(error)}`);
+      return { handoff: "", parentSession: "" };
+    }
+  }
+
   async function handleNewCommand(ctx) {
-    agentManager.resetSession(ctx.chat.id);
-    perChatState.set(ctx.chat.id, { processing: false, nextPrompt: "" });
-    await enqueuePrompt({
+    const chatState = getChatState(ctx.chat.id);
+    const wasProcessing = chatState.processing;
+    chatState.historyRevision += 1;
+    const commandRevision = chatState.historyRevision;
+    const prompt = buildNewSessionPrompt(ctx);
+
+    if (wasProcessing) {
+      logger?.log("telegram", `chat ${ctx.chat.id} busy, queueing new-session command`);
+      queueChatPrompt(chatState, prompt, { replace: true });
+      chatState.continueAfterClose = true;
+      const reset = (async () => {
+        await conversationHistory.reset(ctx.chat.id, { runtime: "pi" });
+        agentManager.resetSession(ctx.chat.id);
+      })();
+      chatState.beforeNextPrompt = reset;
+      try {
+        await reset;
+      } finally {
+        if (chatState.beforeNextPrompt === reset) chatState.beforeNextPrompt = null;
+      }
+      return;
+    }
+
+    chatState.processing = true;
+    logger?.log("telegram", `processing new-session command in chat ${ctx.chat.id}`);
+    await processChatPromptQueue({
       chatId: ctx.chat.id,
-      prompt: buildNewSessionPrompt(ctx),
+      prompt,
       label: "new-session command",
-      ctx
+      ctx,
+      beforeInitialPrompt: async () => {
+        const handoff = await withTyping(ctx, () => summarizeSessionBeforeReset(ctx.chat.id));
+        if (chatState.historyRevision !== commandRevision) return;
+        await conversationHistory.reset(ctx.chat.id, {
+          runtime: "pi",
+          history: handoff.handoff
+        });
+        if (chatState.historyRevision !== commandRevision) return;
+        agentManager.resetSession(ctx.chat.id, handoff);
+      }
     });
   }
 
@@ -775,6 +1209,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     if (piAuthIssue) {
       await ctx.reply(buildPiAuthRecoveryBlockedMessage({
         config,
+        chatId: ctx.chat.id,
         issue: piAuthIssue,
         renewalActive: authRenewals.has(chatKey(ctx.chat.id))
       }));
@@ -783,6 +1218,48 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     await handleNewCommand(ctx);
   });
 
+  bot.command("restart", handleRestartCommand);
+
+  bot.command("doctor", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    const pending = await ctx.reply(renderTelegramHtml("```text\nRunning Arisa Doctor…\n```"), { parse_mode: "HTML" });
+    try {
+      await ctx.api.editMessageText(
+        ctx.chat.id,
+        pending.message_id,
+        renderTelegramHtml(formatDoctorReport(await doctor())),
+        { parse_mode: "HTML" }
+      );
+    } catch (error) {
+      logger?.error("doctor", `doctor command failed: ${getErrorMessage(error)}`);
+      await ctx.api.editMessageText(ctx.chat.id, pending.message_id, `Arisa Doctor failed: ${getErrorMessage(error)}`);
+    }
+  });
+
+  bot.command("update", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    const pending = await ctx.reply(renderTelegramHtml("```text\nChecking Arisa and official tool updates…\n```"), { parse_mode: "HTML" });
+    try {
+      await ctx.api.editMessageText(
+        ctx.chat.id,
+        pending.message_id,
+        renderTelegramHtml(await checkUpdates(ctx.chat.id)),
+        { parse_mode: "HTML" }
+      );
+    } catch (error) {
+      logger?.error("update", `update check failed: ${getErrorMessage(error)}`);
+      await ctx.api.editMessageText(ctx.chat.id, pending.message_id, `Arisa update check failed: ${getErrorMessage(error)}`);
+    }
+  });
+
+  bot.command("tools", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await ctx.reply(renderTelegramHtml(formatToolUsageReport(await toolRegistry.usage(ctx.chat.id))), { parse_mode: "HTML" });
+  });
+
   bot.command("model", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -795,22 +1272,28 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     await showEffortPicker(ctx);
   });
 
+  bot.command("speed", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await showSpeedPicker(ctx);
+  });
+
   bot.command("auth", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
 
-    const status = getPiAuthStatus(config);
+    const status = getPiAuthStatus(config, ctx.chat.id);
     if (status.hasApiKey || !status.supportsOAuth) {
       await withTyping(ctx, async () => {
         try {
-          await agentManager.validatePiAgent();
+          await agentManager.validateAgent();
           agentManager.clearSessionCache(ctx.chat.id);
           piAuthIssue = null;
-          await ctx.reply(buildPiAuthTelegramMessage({ config, verified: true }));
+          await ctx.reply(buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, verified: true }));
         } catch (error) {
           const issue = rememberPiAuthIssue(error) || { kind: "validation-failed", message: getErrorMessage(error) };
           piAuthIssue = issue;
-          await ctx.reply(buildPiAuthTelegramMessage({ config, issue }));
+          await ctx.reply(buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue }));
         }
       });
       return;
@@ -824,14 +1307,15 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     } catch (error) {
       const issue = rememberPiAuthIssue(error) || { kind: "validation-failed", message: getErrorMessage(error) };
       piAuthIssue = issue;
-      await ctx.reply(buildPiAuthTelegramMessage({ config, issue }));
+      await ctx.reply(buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue }));
     }
   });
 
   bot.on("callback_query:data", async (ctx, next) => {
     const modelAction = parseModelPickerAction(ctx.callbackQuery.data);
     const effortAction = modelAction ? null : parseEffortPickerAction(ctx.callbackQuery.data);
-    const action = modelAction || effortAction;
+    const speedAction = modelAction || effortAction ? null : parseSpeedPickerAction(ctx.callbackQuery.data);
+    const action = modelAction || effortAction || speedAction;
     if (!action) return next();
     if (action.type === "noop") {
       await ctx.answerCallbackQuery();
@@ -851,7 +1335,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         return;
       }
 
-      const models = getProviderModels();
+      const models = await getProviderModels(ctx.chat.id);
       const chatBusy = getChatState(ctx.chat.id).processing;
 
       if (action.type === "select") {
@@ -886,7 +1370,10 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         const currentModelId = resolveChatModel(config, ctx.chat.id);
         const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
         if (model.id === currentModelId && currentEffort === "off") {
-          await ctx.answerCallbackQuery({ text: `Already using ${model.id}.` });
+          await closeModelPicker(ctx, {
+            messageText: `Already using ${model.provider}/${model.id}.`,
+            callbackText: `Already using ${model.id}.`
+          });
           return;
         }
 
@@ -921,7 +1408,10 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         const currentModelId = resolveChatModel(config, ctx.chat.id);
         const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
         if (model.id === currentModelId && action.level === currentEffort) {
-          await ctx.answerCallbackQuery({ text: `Already using ${model.id} at ${action.level}.` });
+          await closeModelPicker(ctx, {
+            messageText: `Already using ${model.provider}/${model.id} (effort: ${action.level}).`,
+            callbackText: `Already using ${model.id} at ${action.level}.`
+          });
           return;
         }
 
@@ -981,7 +1471,10 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         }
         const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
         if (action.level === currentEffort) {
-          await ctx.answerCallbackQuery({ text: `Already using effort ${action.level}.` });
+          await closeModelPicker(ctx, {
+            messageText: `Already using effort ${action.level} for ${model.provider}/${model.id}.`,
+            callbackText: `Already using effort ${action.level}.`
+          });
           return;
         }
         await persistChatEffort(ctx.chat.id, model, action.level);
@@ -991,16 +1484,69 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
           `Effort set to ${action.level} for ${model.provider}/${model.id}.`
         );
         await ctx.answerCallbackQuery({ text: `Effort: ${action.level}.` });
+        return;
+      }
+
+      if (action.type === "speed") {
+        const model = models.find((item) => item.id === resolveChatModel(config, ctx.chat.id));
+        if (!model) {
+          await ctx.answerCallbackQuery({
+            text: "Current model is unavailable. Run /model again.",
+            show_alert: true
+          });
+          return;
+        }
+        if (!modelSupportsSpeed(model)) {
+          await ctx.answerCallbackQuery({
+            text: "This model does not support speed 1.5x.",
+            show_alert: true
+          });
+          return;
+        }
+        const currentSpeed = resolveChatSpeed(config, ctx.chat.id);
+        if (action.speed === currentSpeed) {
+          await closeModelPicker(ctx, {
+            messageText: `Already using speed ${action.speed.toFixed(1)}x for ${model.provider}/${model.id}.`,
+            callbackText: `Already using speed ${action.speed.toFixed(1)}x.`
+          });
+          return;
+        }
+        await persistChatSpeed(ctx.chat.id, model, action.speed);
+        await ctx.api.editMessageText(
+          ctx.chat.id,
+          ctx.callbackQuery.message.message_id,
+          `Speed set to ${action.speed.toFixed(1)}x for ${model.provider}/${model.id}.`
+        );
+        await ctx.answerCallbackQuery({ text: `Speed: ${action.speed.toFixed(1)}x.` });
       }
     } catch (error) {
       logger?.error("telegram", `model selection failed for chat ${ctx.chat.id}: ${getErrorMessage(error)}`);
       await ctx.answerCallbackQuery({
-        text: "Could not change the model or effort.",
+        text: "Could not change the model, effort, or speed.",
         show_alert: true
       }).catch(() => {});
     }
   });
 
+  bot.on("message_reaction", async (ctx) => {
+    const reaction = ctx.messageReaction;
+    const chatId = reaction.chat.id;
+    const auth = await authorizeChat({ config, chatId, saveConfig });
+    if (!auth.ok || piAuthIssue) return;
+
+    const reactedMessageText = getChatState(chatId).assistantMessages.get(reaction.message_id) || "";
+    const prompt = buildReactionPrompt({ reaction, reactedMessageText });
+    enqueuePrompt({
+      chatId,
+      prompt,
+      label: `reaction to message ${reaction.message_id}`,
+      busyMessageMode: "queue"
+    }).catch((error) => {
+      getChatState(chatId).processing = false;
+      logger?.error("telegram", `reaction handling failed for chat ${chatId}: ${getErrorMessage(error)}`);
+    });
+  });
+
   bot.on("message", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -1013,34 +1559,30 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     if (piAuthIssue) {
       await ctx.reply(buildPiAuthRecoveryBlockedMessage({
         config,
+        chatId: ctx.chat.id,
         issue: piAuthIssue,
         renewalActive: authRenewals.has(chatKey(ctx.chat.id))
       }));
       return;
     }
 
-    try {
-      await enqueueOrProcess(ctx);
-    } catch (error) {
+    // grammY long polling awaits each middleware. Keep prompt execution in the background so
+    // the next Telegram update can reach the active session as a steer or queued message.
+    enqueueOrProcess(ctx).catch(async (error) => {
       const chatState = getChatState(ctx.chat.id);
       chatState.processing = false;
       if (wasPromptErrorNotified(error)) return;
       const issue = getPiAuthIssue(error);
       await ctx.reply(issue
-        ? buildPiAuthTelegramMessage({ config, issue })
+        ? buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue })
         : getErrorMessage(error));
-    }
+    });
   });
 
   return {
     async start({ skipAgentStartupPrompts = false } = {}) {
       config.telegram.chatMeta ||= {};
-      await bot.api.setMyCommands([
-        { command: "new", description: "Start a new chat context" },
-        { command: "model", description: "Choose the model for this chat" },
-        { command: "effort", description: "Choose reasoning effort for this chat" },
-        { command: "auth", description: "Show Pi authentication status" }
-      ]);
+      await bot.api.setMyCommands(telegramCommands);
       if (!taskTimer) {
         taskTimer = setInterval(() => {
           dispatchDueTasks().catch((error) => {
@@ -1052,7 +1594,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       await bot.api.deleteWebhook({ drop_pending_updates: true });
       logger?.log("telegram", "bot polling started");
       scheduleStartupMessages({ skipAgentStartupPrompts });
-      await bot.start();
+      await bot.start({ allowed_updates: ["message", "callback_query", "message_reaction"] });
     },
 
     async stop() {