appback-remoteagent 0.17.0 → 0.18.0

package/dist/bot.js

@@ -104,6 +104,41 @@ const workLoopTails = new Map();
 const workLoopGenerations = new Map();
 const queuedWorkLoops = new Map();
 let nextQueuedWorkSequence = 1;
+class InlineActionRegistry {
+    records = new Map();
+    ttlMs = 6 * 60 * 60 * 1000;
+    maxRecords = 1_000;
+    register(action, chatId, userId) {
+        this.prune();
+        while (this.records.size >= this.maxRecords) {
+            const oldest = this.records.keys().next().value;
+            if (!oldest) {
+                break;
+            }
+            this.records.delete(oldest);
+        }
+        const id = randomUUID().replace(/-/g, "").slice(0, 20);
+        this.records.set(id, { action, chatId, userId, createdAt: Date.now() });
+        return `remoteagent:action:${id}`;
+    }
+    resolve(data, chatId, userId) {
+        this.prune();
+        const match = /^remoteagent:action:([a-f0-9]{20})$/i.exec(data);
+        const record = match ? this.records.get(match[1]) : undefined;
+        if (!record || record.chatId !== chatId || record.userId !== userId) {
+            return undefined;
+        }
+        return record.action;
+    }
+    prune() {
+        const expiresBefore = Date.now() - this.ttlMs;
+        for (const [id, record] of this.records) {
+            if (record.createdAt < expiresBefore) {
+                this.records.delete(id);
+            }
+        }
+    }
+}
 const REPORT_CONTINUE_PROMPT = [
     "Continue the same task now.",
     "Do more concrete work before replying again.",
@@ -185,6 +220,7 @@ class AutoContinueController {
 }
 export function createBot(token, bridge, botManagement, botInfo) {
     const bot = new Bot(token, { botInfo });
+    const inlineActions = new InlineActionRegistry();
     const autoContinue = new AutoContinueController(path.join(config.dataDir, "stop-gates.json"));
     const shellService = new RemoteShellService(config.commandTimeoutMs);
     const memoryService = new AgentMemoryService(config.dataDir);
@@ -229,6 +265,32 @@ export function createBot(token, bridge, botManagement, botInfo) {
             throw error;
         }
     };
+    const actionButton = (ctx, text, action) => {
+        if (!ctx.chat || !ctx.from) {
+            throw new Error("Telegram action button requires chat and user context.");
+        }
+        return {
+            text,
+            callback_data: inlineActions.register(action, String(ctx.chat.id), String(ctx.from.id)),
+        };
+    };
+    const keyboardOptions = (rows) => {
+        return rows.length > 0
+            ? { reply_markup: JSON.stringify({ inline_keyboard: rows }) }
+            : undefined;
+    };
+    const removeQueuedInstruction = async (botId, chatId, selector) => {
+        const mapping = await bridge.status(botId, chatId);
+        const activeKey = workLoopKey(botId, chatId, mapping?.session.sessionId);
+        const removed = removeQueuedWorkLoop(activeKey, selector);
+        if (!removed) {
+            const target = selector ? normalizeQueueId(selector) : "the latest queued instruction";
+            return `Queued instruction was not found: ${target}`;
+        }
+        await bridge.logSystem(botId, chatId, `Removed queued instruction ${removed.id} for ${activeKey}.`);
+        return `Removed queued instruction ${removed.id} from ${removed.publicSessionId ?? "this session"}.\n`
+            + `Remaining queued instructions: ${listQueuedWorkLoops(activeKey).length}`;
+    };
     const runPlanDocumentReinforcement = async (ctx, count) => {
         if (!ctx.chat) {
             throw new Error("Telegram chat context is missing.");
@@ -317,14 +379,14 @@ ${bridge.formatStatus(mapping)}`);
     bot.command("help", async (ctx) => {
         await reply(ctx, HELP_TEXT);
     });
-    const replySessionList = async (ctx) => {
+    const replySessionList = async (ctx, requestedShowAll) => {
         if (!ctx.chat) {
             throw new Error("Telegram chat context is missing.");
         }
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
         const { args } = parseCommand(ctx.message?.text, 1);
-        const showAll = args[0] === "-a" || args[0] === "--all";
+        const showAll = requestedShowAll ?? (args[0] === "-a" || args[0] === "--all");
         const [mapping, sessions] = await Promise.all([
             bridge.status(botId, chatId),
             bridge.listSessions(),
@@ -333,9 +395,33 @@ ${bridge.formatStatus(mapping)}`);
         const sessionList = showAll
             ? await bridge.formatSessionListDetailed(sessions, mapping?.session.sessionId, await bridge.listActiveSessionIds())
             : bridge.formatSessionList(sessions, mapping?.session.sessionId);
-        for (const chunk of flattenChunks([`${sessionList}\n\n${botSummary}`], 3900)) {
-            await reply(ctx, chunk);
+        const sessionButtons = sessions.slice(0, showAll ? 20 : 10).map((session) => [
+            actionButton(ctx, truncateButtonLabel(`${session.sessionId === mapping?.session.sessionId ? "✓ " : ""}${session.publicId} · ${workspaceLeaf(session.workspace)}`), { kind: "session.switch", selector: session.publicId }),
+        ]);
+        if (!showAll && sessions.length > 10) {
+            sessionButtons.push([actionButton(ctx, `Show all ${sessions.length} sessions`, { kind: "session.list", showAll: true })]);
+        }
+        const chunks = flattenChunks([`${sessionList}\n\n${botSummary}`], 3900);
+        for (const [index, chunk] of chunks.entries()) {
+            await reply(ctx, chunk, index === chunks.length - 1 ? keyboardOptions(sessionButtons) : undefined);
+        }
+    };
+    const switchChatSession = async (ctx, selector) => {
+        if (!ctx.chat) {
+            throw new Error("Telegram chat context is missing.");
+        }
+        const botId = getBotId();
+        const chatId = String(ctx.chat.id);
+        const previous = await bridge.status(botId, chatId).catch(() => undefined);
+        const mapping = await bridge.switchSession(botId, chatId, selector);
+        if (previous && previous.session.sessionId !== mapping.session.sessionId) {
+            autoContinue.requestSessionStop(previous.session.sessionId);
+            cancelQueuedWorkLoops(botId, chatId, previous.session.sessionId);
+            messageBatcher.cancelPending(botId, chatId);
+            messageBatcher.cancelManual(botId, chatId);
+            await bridge.stopSessionRun(previous.session.sessionId, botId, chatId, "Chat switched to another session; previous session execution was stopped.");
         }
+        return `Switched this chat to session ${mapping.session.publicId}.\n\n${bridge.formatCurrentSession(mapping)}`;
     };
     bot.command("list", async (ctx) => {
         await replySessionList(ctx);
@@ -349,8 +435,6 @@ ${bridge.formatStatus(mapping)}`);
         await reply(ctx, `Created and bound a new ${mapping.session.mode} session.\n\n${bridge.formatCurrentSession(mapping)}`);
     });
     bot.command("switch", async (ctx) => {
-        const botId = getBotId();
-        const chatId = String(ctx.chat.id);
         const { args } = parseCommand(ctx.message?.text, 1);
         const sessionId = args[0];
         if (!sessionId) {
@@ -359,16 +443,7 @@ ${bridge.formatStatus(mapping)}`);
             });
             return;
         }
-        const previous = await bridge.status(botId, chatId).catch(() => undefined);
-        const mapping = await bridge.switchSession(botId, chatId, sessionId);
-        if (previous && previous.session.sessionId !== mapping.session.sessionId) {
-            autoContinue.requestSessionStop(previous.session.sessionId);
-            cancelQueuedWorkLoops(botId, chatId, previous.session.sessionId);
-            messageBatcher.cancelPending(botId, chatId);
-            messageBatcher.cancelManual(botId, chatId);
-            await bridge.stopSessionRun(previous.session.sessionId, botId, chatId, "Chat switched to another session; previous session execution was stopped.");
-        }
-        await reply(ctx, `Switched this chat to session ${sessionId}.\n\n${bridge.formatCurrentSession(mapping)}`);
+        await reply(ctx, await switchChatSession(ctx, sessionId));
     });
     bot.command("plan", async (ctx) => {
         const { args, rest } = parseCommand(ctx.message?.text, 1);
@@ -437,6 +512,14 @@ ${bridge.formatStatus(mapping)}`);
 
 ${bridge.formatStatus(mapping)}`);
     });
+    const setChatModel = async (ctx, model) => {
+        if (!ctx.chat) {
+            throw new Error("Telegram chat context is missing.");
+        }
+        const mapping = await bridge.setModel(getBotId(), String(ctx.chat.id), model);
+        const selectedModel = mapping.session[mapping.session.mode]?.model ?? model;
+        return `Set ${mapping.session.mode} model to ${selectedModel}.\n\n${bridge.formatStatus(mapping)}`;
+    };
     bot.command("model", async (ctx) => {
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
@@ -449,13 +532,17 @@ ${bridge.formatStatus(mapping)}`);
             return;
         }
         if (!model) {
+            const selection = await bridge.getModelSelection(botId, chatId);
+            const rows = selection.presets.map((preset) => [
+                actionButton(ctx, `${preset === selection.currentModel ? "✓ " : ""}${preset}`, { kind: "model.set", model: preset }),
+            ]);
             await reply(ctx, await bridge.formatModelSelection(botId, chatId), {
                 parse_mode: "Markdown",
+                ...(keyboardOptions(rows) ?? {}),
             });
             return;
         }
-        const mapping = await bridge.setModel(botId, chatId, model);
-        await reply(ctx, `Set ${mapping.session.mode} model to ${model}.\n\n${bridge.formatStatus(mapping)}`);
+        await reply(ctx, await setChatModel(ctx, model));
     });
     bot.command("queue", async (ctx) => {
         const botId = getBotId();
@@ -470,22 +557,22 @@ ${bridge.formatStatus(mapping)}`);
             return;
         }
         if (!action || action === "list") {
-            await reply(ctx, formatQueuedWorkLoops(activeKey, mapping?.session.publicId));
+            const queued = listQueuedWorkLoops(activeKey);
+            const rows = queued.map((entry) => [{
+                    text: `Remove ${entry.id}`,
+                    callback_data: `remoteagent:queue:remove:${entry.id}`,
+                }]);
+            if (queued.length > 0) {
+                rows.push([{ text: "Remove latest", callback_data: "remoteagent:queue:del" }]);
+            }
+            await reply(ctx, formatQueuedWorkLoops(activeKey, mapping?.session.publicId), keyboardOptions(rows));
             return;
         }
         if ((action === "remove" || action === "rm") && !selector) {
             await reply(ctx, "Usage: `/queue remove <id>`", { parse_mode: "Markdown" });
             return;
         }
-        const removed = removeQueuedWorkLoop(activeKey, selector);
-        if (!removed) {
-            const target = selector ? normalizeQueueId(selector) : "the latest queued instruction";
-            await reply(ctx, `Queued instruction was not found: ${target}`);
-            return;
-        }
-        await bridge.logSystem(botId, chatId, `Removed queued instruction ${removed.id} for ${activeKey}.`);
-        await reply(ctx, `Removed queued instruction ${removed.id} from ${removed.publicSessionId ?? "this session"}.\n`
-            + `Remaining queued instructions: ${listQueuedWorkLoops(activeKey).length}`);
+        await reply(ctx, await removeQueuedInstruction(botId, chatId, selector));
     });
     bot.command("stop", async (ctx) => {
         const botId = getBotId();
@@ -529,7 +616,16 @@ ${bridge.formatStatus(mapping)}`);
         const option = args[0]?.toLowerCase();
         const value = args[1];
         if (!option) {
-            await reply(ctx, formatRuntimeOptions());
+            await reply(ctx, formatRuntimeOptions(), keyboardOptions([
+                [
+                    actionButton(ctx, "Retry", { kind: "option.show", option: "retry" }),
+                    actionButton(ctx, "Timeout", { kind: "option.show", option: "timeout" }),
+                ],
+                [
+                    actionButton(ctx, "Intent", { kind: "option.show", option: "intent" }),
+                    actionButton(ctx, "Command menu", { kind: "option.show", option: "command-menu" }),
+                ],
+            ]));
             return;
         }
         if (option !== "retry" && option !== "timeout" && option !== "intent" && option !== "command-menu") {
@@ -539,14 +635,7 @@ ${bridge.formatStatus(mapping)}`);
             return;
         }
         if (!value) {
-            const current = option === "retry"
-                ? `Current automatic continuation retry limit: ${formatRetryLimit(config.telegramAutoProgressMaxTurns)}\n\nUsage: \`/option retry <count>\``
-                : option === "intent"
-                    ? `Current untagged intent retry limit: ${formatRetryLimit(config.telegramUntaggedIntentRetries)}\n\nUsage: \`/option intent <count>\``
-                    : option === "command-menu"
-                        ? `Current Telegram command menu: ${config.telegramCommandMenuEnabled ? "on" : "off"}\n\nUsage: \`/option command-menu on\`, \`/option command-menu off\`, or \`/option command-menu refresh\``
-                        : `Current provider execution timeout: ${formatTimeoutSeconds(config.commandTimeoutMs)}\n\nUsage: \`/option timeout <seconds>\``;
-            await reply(ctx, current, {
+            await reply(ctx, formatRuntimeOptionDetail(option), {
                 parse_mode: "Markdown",
             });
             return;
@@ -758,15 +847,29 @@ ${bridge.formatStatus(mapping)}`);
         }
         await reply(ctx, "Usage: `/docs list`, `/docs find <keyword>`, `/docs pin <keyword> <path>`, `/docs remove <keyword>`, or `/docs reinforce <1-10>`", { parse_mode: "Markdown" });
     });
-    const handleMacroCommand = async (ctx, text) => {
+    const runMacro = async (ctx, target) => {
         if (!ctx.chat) {
             throw new Error("Telegram chat context is missing.");
         }
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
+        const macro = await memoryService.getMacro(target);
+        if (!macro) {
+            return `Macro was not found: ${target}\n\n${await memoryService.listMacros()}`;
+        }
+        await bridge.logSystem(botId, chatId, `Macro executed: ${macro.alias}`);
+        await messageBatcher.enqueue({ botToken: token, telegramChatId: ctx.chat.id }, botId, chatId, macro.prompt);
+        return undefined;
+    };
+    const handleMacroCommand = async (ctx, text) => {
+        const botId = getBotId();
         const parsed = parseMacroCommandText(text, botId);
         if (parsed.kind === "help") {
-            await reply(ctx, await formatMacroHelp(memoryService));
+            const macros = await memoryService.getMacros();
+            const rows = macros.slice(0, 20).map((macro) => [
+                actionButton(ctx, truncateButtonLabel(macro.alias), { kind: "macro.run", alias: macro.alias }),
+            ]);
+            await reply(ctx, await formatMacroHelp(memoryService), keyboardOptions(rows));
             return;
         }
         if (parsed.kind === "set") {
@@ -781,25 +884,34 @@ ${bridge.formatStatus(mapping)}`);
             await reply(ctx, removed ? `Removed macro '${parsed.alias}'.` : `Macro was not found: ${parsed.alias}`);
             return;
         }
-        const macro = await memoryService.getMacro(parsed.target);
-        if (!macro) {
-            await reply(ctx, `Macro was not found: ${parsed.target}\n\n${await memoryService.listMacros()}`);
-            return;
+        const result = await runMacro(ctx, parsed.target);
+        if (result) {
+            await reply(ctx, result);
         }
-        await bridge.logSystem(botId, chatId, `Macro executed: ${macro.alias}`);
-        await messageBatcher.enqueue({ botToken: token, telegramChatId: ctx.chat.id }, botId, chatId, macro.prompt);
     };
     bot.command("macro", async (ctx) => {
         await handleMacroCommand(ctx, ctx.message?.text ?? "/macro");
     });
-    bot.command("bots", async (ctx) => {
+    const replyBotList = async (ctx) => {
         await ensureOwnerControlAccess(ctx);
         const pendingNotice = await botManagement.getPendingOperationNotice();
-        if (pendingNotice?.pending) {
-            await reply(ctx, `${pendingNotice.message}\n\n${await botManagement.listBots()}`);
-            return;
-        }
-        await reply(ctx, await botManagement.listBots());
+        const [botList, choices] = await Promise.all([
+            botManagement.listBots(),
+            botManagement.listBotChoices(),
+        ]);
+        const rows = [];
+        for (let index = 0; index < choices.length; index += 2) {
+            rows.push(choices.slice(index, index + 2).map((choice) => ({
+                text: `@${choice.username}`,
+                url: `https://t.me/${choice.username}`,
+            })));
+        }
+        rows.push([actionButton(ctx, "Refresh", { kind: "bots.refresh" })]);
+        const message = pendingNotice?.pending ? `${pendingNotice.message}\n\n${botList}` : botList;
+        await reply(ctx, message, keyboardOptions(rows));
+    };
+    bot.command("bots", async (ctx) => {
+        await replyBotList(ctx);
     });
     bot.command("bot", async (ctx) => {
         await ensureOwnerControlAccess(ctx);
@@ -878,20 +990,39 @@ ${bridge.formatStatus(mapping)}`);
             return { chunks: flattenChunks([output], 3900) };
         });
     });
+    const setChatSandbox = async (ctx, sandboxMode) => {
+        if (!ctx.chat) {
+            throw new Error("Telegram chat context is missing.");
+        }
+        const mapping = await bridge.setCodexSandboxMode(getBotId(), String(ctx.chat.id), sandboxMode);
+        return `Set Codex sandbox to ${sandboxMode}.\n\n${bridge.formatStatus(mapping)}`;
+    };
     bot.command("sandbox", async (ctx) => {
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
         const { args } = parseCommand(ctx.message?.text, 2);
         const provider = args[0]?.toLowerCase();
         const sandboxMode = args[1]?.toLowerCase();
+        if (!provider && !sandboxMode) {
+            const mapping = await bridge.status(botId, chatId);
+            if (!mapping?.session.codex) {
+                await reply(ctx, "No Codex session is paired with this chat.");
+                return;
+            }
+            const current = mapping.session.codex.sandboxMode ?? config.codexSandboxMode;
+            const modes = ["read-only", "workspace-write", "danger-full-access"];
+            await reply(ctx, `Codex sandbox\ncurrent: ${current}\n\nChoose a mode:`, keyboardOptions(modes.map((mode) => [
+                actionButton(ctx, `${mode === current ? "✓ " : ""}${mode}`, { kind: "sandbox.set", mode }),
+            ])));
+            return;
+        }
         if (provider !== "codex" || !sandboxMode || !isCodexSandboxMode(sandboxMode)) {
             await reply(ctx, "Usage: `/sandbox codex <read-only|workspace-write|danger-full-access>`", {
                 parse_mode: "Markdown",
             });
             return;
         }
-        const mapping = await bridge.setCodexSandboxMode(botId, chatId, sandboxMode);
-        await reply(ctx, `Set Codex sandbox to ${sandboxMode}.\n\n${bridge.formatStatus(mapping)}`);
+        await reply(ctx, await setChatSandbox(ctx, sandboxMode));
     });
     bot.command("reset", async (ctx) => {
         const botId = getBotId();
@@ -900,6 +1031,88 @@ ${bridge.formatStatus(mapping)}`);
         await bridge.reset(botId, chatId);
         await reply(ctx, "Cleared all pairings for this chat.");
     });
+    bot.on("callback_query:data", async (ctx) => {
+        const data = ctx.callbackQuery.data;
+        const callbackChat = ctx.callbackQuery.message?.chat;
+        if (!callbackChat) {
+            await callTelegramApi(token, "answerCallbackQuery", {
+                callback_query_id: ctx.callbackQuery.id,
+                text: "This action is no longer available.",
+            });
+            return;
+        }
+        const botId = getBotId();
+        const chatId = String(callbackChat.id);
+        const queueMatch = /^remoteagent:queue:(remove:(Q\d+)|del)$/i.exec(data);
+        if (queueMatch) {
+            const result = await removeQueuedInstruction(botId, chatId, queueMatch[2]);
+            await callTelegramApi(token, "answerCallbackQuery", {
+                callback_query_id: ctx.callbackQuery.id,
+                text: result.split("\n", 1)[0],
+            });
+            await sendTelegramMessage(token, callbackChat.id, result);
+            return;
+        }
+        if (!data.startsWith("remoteagent:action:")) {
+            return;
+        }
+        const action = inlineActions.resolve(data, chatId, String(ctx.from.id));
+        if (!action) {
+            await callTelegramApi(token, "answerCallbackQuery", {
+                callback_query_id: ctx.callbackQuery.id,
+                text: "This button expired. Open the command list again.",
+            });
+            return;
+        }
+        await callTelegramApi(token, "answerCallbackQuery", {
+            callback_query_id: ctx.callbackQuery.id,
+            text: action.kind === "macro.run" ? "Macro selected." : "Applying...",
+        });
+        try {
+            if (action.kind === "session.switch") {
+                await reply(ctx, await switchChatSession(ctx, action.selector));
+                return;
+            }
+            if (action.kind === "session.list") {
+                await replySessionList(ctx, action.showAll);
+                return;
+            }
+            if (action.kind === "model.set") {
+                await reply(ctx, await setChatModel(ctx, action.model));
+                return;
+            }
+            if (action.kind === "macro.run") {
+                const result = await runMacro(ctx, action.alias);
+                if (result) {
+                    await reply(ctx, result);
+                }
+                return;
+            }
+            if (action.kind === "option.show") {
+                await ensureOwnerControlAccess(ctx);
+                await reply(ctx, formatRuntimeOptionDetail(action.option), { parse_mode: "Markdown" });
+                return;
+            }
+            if (action.kind === "bots.refresh") {
+                await replyBotList(ctx);
+                return;
+            }
+            if (action.mode === "danger-full-access" && !action.confirmed) {
+                await reply(ctx, "Confirm Codex sandbox change to danger-full-access.", keyboardOptions([[
+                        actionButton(ctx, "Confirm danger-full-access", {
+                            kind: "sandbox.set",
+                            mode: "danger-full-access",
+                            confirmed: true,
+                        }),
+                    ]]));
+                return;
+            }
+            await reply(ctx, await setChatSandbox(ctx, action.mode));
+        }
+        catch (error) {
+            await reply(ctx, error instanceof Error ? error.message : String(error));
+        }
+    });
     bot.on("message", async (ctx) => {
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
@@ -1197,14 +1410,17 @@ async function runWithPendingAnimation(botToken, chatId, task) {
     pulseTyping();
     try {
         const helpers = {
-            reportProgress: async (chunks, parseMode) => {
+            reportProgress: async (chunks, parseMode, messageOptions) => {
                 const normalized = await normalizeTelegramDelivery(chunks);
                 const progressChunks = flattenChunks(normalized.chunks, 3900);
                 if (progressChunks.length === 0 && normalized.documents.length === 0) {
                     return;
                 }
                 const rendered = formatProviderTelegramChunks(progressChunks, parseMode);
-                const extra = rendered.parseMode ? { parse_mode: rendered.parseMode } : undefined;
+                const extra = {
+                    ...messageOptions,
+                    ...(rendered.parseMode ? { parse_mode: rendered.parseMode } : {}),
+                };
                 for (const chunk of rendered.chunks) {
                     await sendTelegramMessage(botToken, chatId, chunk, extra).catch((error) => {
                         console.warn(`[telegram-progress-delivery] chat=${chatId} dropped progress message: ${formatTelegramDeliveryError(error)}`);
@@ -1275,10 +1491,24 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
         });
         try {
             await bridge.logSystem(botId, chatId, `Queued overlapping Telegram work loop ${queuedEntry.id} for ${activeKey}.`);
-            await helpers.reportProgress([
-                `Queued instruction ${queuedEntry.id} for ${currentSession?.session.publicId ?? "this session"}. It will run after the active work finishes.`,
-                `Remove it with \`/queue remove ${queuedEntry.id}\`, or remove the latest queued instruction with \`/queue del\`.`,
-            ]);
+            await helpers.reportProgress([[
+                    `Queued instruction ${queuedEntry.id} for ${currentSession?.session.publicId ?? "this session"}. It will run after the active work finishes.`,
+                    "",
+                    `Remove it with \`/queue remove ${queuedEntry.id}\`, or remove the latest queued instruction with \`/queue del\`.`,
+                ].join("\n")], undefined, {
+                reply_markup: JSON.stringify({
+                    inline_keyboard: [[
+                            {
+                                text: `/queue remove ${queuedEntry.id}`,
+                                callback_data: `remoteagent:queue:remove:${queuedEntry.id}`,
+                            },
+                            {
+                                text: "/queue del",
+                                callback_data: "remoteagent:queue:del",
+                            },
+                        ]],
+                }),
+            });
             await previousTail.catch(() => undefined);
         }
         catch (error) {
@@ -1328,6 +1558,7 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
     let missingEvidenceRetryCount = 0;
     let deliveredProgressCount = 0;
     let providerCompleted = false;
+    const streamedProgressKeys = new Set();
     const ensureStillBound = async (phase) => {
         if (!sessionId) {
             return;
@@ -1339,6 +1570,23 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
         await bridge.stopSessionRun(sessionId, botId, chatId, `Telegram work loop stopped during ${phase} because the chat is now bound to another session.`);
         throw new SilentTelegramAbort(`Session ${currentSession?.session.publicId ?? sessionId} is no longer bound to this chat.`);
     };
+    const deliverStreamedProgress = async (response) => {
+        const parsed = parseReportResponses(bridge.formatResponses([response]), transform);
+        if (parsed.kind !== "progress" || parsed.chunks.length === 0) {
+            return;
+        }
+        const key = progressDeliveryKey(parsed.chunks);
+        if (streamedProgressKeys.has(key)) {
+            return;
+        }
+        streamedProgressKeys.add(key);
+        deliveredProgressCount += 1;
+        await ensureStillBound(`${label} streamed progress delivery`);
+        if (currentSession) {
+            await memoryService.recordProgress(currentSession.session, parsed.chunks.join("\n"));
+        }
+        await helpers.reportProgress(parsed.chunks);
+    };
     if (currentSession) {
         await botManagement.markProviderRunning(botId, sessionId);
     }
@@ -1361,8 +1609,8 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
             await bridge.logSystem(botId, chatId, `${turnLabel} started.`);
             try {
                 const responses = sessionId
-                    ? await bridge.routeSessionMessageForChat(sessionId, botId, chatId, prompt)
-                    : await bridge.routeMessage(botId, chatId, prompt);
+                    ? await bridge.routeSessionMessageForChat(sessionId, botId, chatId, prompt, deliverStreamedProgress)
+                    : await bridge.routeMessage(botId, chatId, prompt, deliverStreamedProgress);
                 await ensureStillBound(`${turnLabel} response`);
                 const parsed = parseReportResponses(bridge.formatResponses(responses), transform);
                 await bridge.logSystem(botId, chatId, `${turnLabel} returned ${parsed.kind}.`);
@@ -1371,21 +1619,25 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
                 if (parsed.kind === "progress") {
                     untaggedIntentRetryCount = 0;
                     missingEvidenceRetryCount = 0;
-                    deliveredProgressCount += 1;
-                    if (currentSession) {
-                        const progress = await memoryService.recordProgress(currentSession.session, parsed.chunks.join("\n"));
-                        if (progress.repeated) {
-                            const repeatedMessage = [
-                                "Repeated progress detected. The same work pattern has appeared 3 or more times.",
-                                "Automatic continuation stopped so the task can be inspected instead of looping.",
-                            ].join("\n");
-                            await bridge.logSystem(botId, chatId, repeatedMessage);
-                            autoContinue.clear(botId, chatId, sessionId);
-                            return [repeatedMessage];
+                    const key = progressDeliveryKey(parsed.chunks);
+                    if (!streamedProgressKeys.has(key)) {
+                        streamedProgressKeys.add(key);
+                        deliveredProgressCount += 1;
+                        if (currentSession) {
+                            const progress = await memoryService.recordProgress(currentSession.session, parsed.chunks.join("\n"));
+                            if (progress.repeated) {
+                                const repeatedMessage = [
+                                    "Repeated progress detected. The same work pattern has appeared 3 or more times.",
+                                    "Automatic continuation stopped so the task can be inspected instead of looping.",
+                                ].join("\n");
+                                await bridge.logSystem(botId, chatId, repeatedMessage);
+                                autoContinue.clear(botId, chatId, sessionId);
+                                return [repeatedMessage];
+                            }
                         }
+                        await ensureStillBound(`${turnLabel} progress delivery`);
+                        await helpers.reportProgress(parsed.chunks);
                     }
-                    await ensureStillBound(`${turnLabel} progress delivery`);
-                    await helpers.reportProgress(parsed.chunks);
                     if (autoContinue.isStopRequested(botId, chatId, sessionId)) {
                         const stopMessage = "Automatic continuation stopped after the latest progress report.";
                         await bridge.logSystem(botId, chatId, stopMessage);
@@ -1640,6 +1892,9 @@ function parseReportResponses(formattedBlocks, transform) {
     const chunks = transform(parsedBlocks.map((item) => item.text));
     return { kind, chunks };
 }
+function progressDeliveryKey(chunks) {
+    return chunks.join("\n").replace(/\s+/g, " ").trim();
+}
 function formatProviderTelegramChunks(chunks, explicitParseMode) {
     if (explicitParseMode) {
         return { chunks, parseMode: explicitParseMode };
@@ -2199,6 +2454,26 @@ function formatRuntimeOptions() {
         "`command-menu refresh` reapplies Telegram slash-command autocomplete without changing the saved option.",
     ].join("\n");
 }
+function formatRuntimeOptionDetail(option) {
+    if (option === "retry") {
+        return `Current automatic continuation retry limit: ${formatRetryLimit(config.telegramAutoProgressMaxTurns)}\n\nUsage: \`/option retry <count>\``;
+    }
+    if (option === "intent") {
+        return `Current untagged intent retry limit: ${formatRetryLimit(config.telegramUntaggedIntentRetries)}\n\nUsage: \`/option intent <count>\``;
+    }
+    if (option === "command-menu") {
+        return `Current Telegram command menu: ${config.telegramCommandMenuEnabled ? "on" : "off"}\n\nUsage: \`/option command-menu on\`, \`/option command-menu off\`, or \`/option command-menu refresh\``;
+    }
+    return `Current provider execution timeout: ${formatTimeoutSeconds(config.commandTimeoutMs)}\n\nUsage: \`/option timeout <seconds>\``;
+}
+function truncateButtonLabel(value, maxLength = 48) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3)}...`;
+}
+function workspaceLeaf(workspace) {
+    const normalized = workspace.replace(/[\\/]+$/, "");
+    return normalized.split(/[\\/]/).at(-1) || workspace;
+}
 function formatRetryLimit(value) {
     return value === 0 ? "unlimited" : `${value}`;
 }
@@ -2745,6 +3020,7 @@ async function sendTelegramMessage(botToken, chatId, text, extra) {
                         chat_id: String(chatId),
                         text,
                         parse_mode: extra?.parse_mode,
+                        reply_markup: extra?.reply_markup,
                     });
                 }
                 catch (error) {
@@ -2755,6 +3031,7 @@ async function sendTelegramMessage(botToken, chatId, text, extra) {
                     return await callTelegramApi(botToken, "sendMessage", {
                         chat_id: String(chatId),
                         text: stripTelegramHtml(text),
+                        reply_markup: extra?.reply_markup,
                     });
                 }
             }