appback-remoteagent 0.17.1 → 0.18.0

package/README.md

@@ -103,6 +103,8 @@ Current command surface implemented in `src/bot.ts`:
 | `/new` | Creates and binds a new session using the saved default mode in a new managed workspace |
 | `/switch <session>` | Rebinds this chat to an existing RemoteAgent session |
 | `/status` | Shows current session, workspace, provider, and sandbox state |
+| `/model [name]` | Lists selectable provider models or changes the current session model |
+| `/sandbox [codex <mode>]` | Lists Codex sandbox choices or changes the current session sandbox |
 | `/option retry <count>` | Sets the automatic continuation turn limit and persists it to `~/.remoteagent/.env` |
 | `/option timeout <seconds>` | Sets the provider execution timeout and persists it to `~/.remoteagent/.env` |
 | `/option intent <count>` | Sets retries for untagged intent-only provider replies and persists it to `~/.remoteagent/.env` |
@@ -110,6 +112,7 @@ Current command surface implemented in `src/bot.ts`:
 | `/state clear` | Clears the current session ledger without deleting the session |
 | `/state note <text>` | Adds an operator note to the session ledger |
 | `/bots` | Lists the currently configured Telegram bots |
+| `/macro [alias\|number]` | Lists stored macros or runs one against the current session |
 | `/bot add <token>` | Adds a conversation bot, restarts the runtime, and confirms the result after restart |
 | `/bot doctor` | Checks configured Telegram bots and removes bots that Telegram reports as permanently dead |
 | `/bot remove <username\|id>` | Removes a configured Telegram bot, restarts the runtime, and confirms the result after restart |
@@ -127,6 +130,8 @@ Current command surface implemented in `src/bot.ts`:
 | `/queue remove <id>` | Removes one waiting instruction by its `Q001`-style id |
 | `/queue del` | Removes the most recently queued instruction |
 
+Selection-oriented replies include Telegram inline buttons for sessions, models, macros, runtime option details, sandbox modes, queued instructions, and configured bot links. Text commands remain the canonical compatible interface. Callback actions use short-lived opaque IDs bound to the originating chat and user; they do not expose secrets or rely on visible list positions as internal identity. Selecting `danger-full-access` through a button requires a second confirmation.
+
 Multi-bot polling is tiered by recent activity and active provider work. See [docs/BOT_POLLING_POLICY.md](./docs/BOT_POLLING_POLICY.md).
 
 ### 2. Terminal control

package/dist/adapters/codex-adapter.js

@@ -115,10 +115,7 @@ export class CodexAdapter {
         }
         let text;
         try {
-            const event = JSON.parse(line);
-            text = event.type === "item.completed" && event.item?.type === "agent_message"
-                ? event.item.text?.trim()
-                : undefined;
+            text = this.extractEventAgentText(JSON.parse(line));
         }
         catch {
             // Ignore non-JSON stdout and let the normal final-response parser handle it.
@@ -128,6 +125,27 @@ export class CodexAdapter {
             await onProgress(text);
         }
     }
+    extractEventAgentText(event) {
+        if (!event || typeof event !== "object") {
+            return undefined;
+        }
+        const record = event;
+        if (record.type === "item.completed" && record.item?.type === "agent_message") {
+            return record.item.text?.trim();
+        }
+        if (record.type === "event_msg" && record.payload?.type === "agent_message") {
+            return (record.payload.message ?? record.payload.text)?.trim();
+        }
+        if (record.type === "response_item" && record.payload?.type === "message") {
+            const text = record.payload.content
+                ?.filter((item) => item.type === "output_text" && typeof item.text === "string")
+                .map((item) => item.text)
+                .join("\n")
+                .trim();
+            return text || record.payload.text?.trim();
+        }
+        return undefined;
+    }
     extractThreadId(stdout) {
         for (const line of stdout.split(/\r?\n/)) {
             if (!line.startsWith("{")) {

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,20 @@ 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);
@@ -329,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(),
@@ -345,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);
@@ -361,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) {
@@ -371,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);
@@ -449,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);
@@ -461,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();
@@ -482,7 +557,15 @@ ${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) {
@@ -533,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") {
@@ -543,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;
@@ -762,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") {
@@ -785,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);
@@ -882,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();
@@ -905,26 +1032,86 @@ ${bridge.formatStatus(mapping)}`);
         await reply(ctx, "Cleared all pairings for this chat.");
     });
     bot.on("callback_query:data", async (ctx) => {
-        const match = /^remoteagent:queue:(remove:(Q\d+)|del)$/i.exec(ctx.callbackQuery.data);
-        if (!match) {
-            return;
-        }
+        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 queue action is no longer available.",
+                text: "This action is no longer available.",
             });
             return;
         }
         const botId = getBotId();
         const chatId = String(callbackChat.id);
-        const result = await removeQueuedInstruction(botId, chatId, match[2]);
+        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: result.split("\n", 1)[0],
+            text: action.kind === "macro.run" ? "Macro selected." : "Applying...",
         });
-        await sendTelegramMessage(token, callbackChat.id, result);
+        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();
@@ -2267,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}`;
 }

package/dist/services/agent-memory-service.js

@@ -267,8 +267,7 @@ export class AgentMemoryService {
         return existed;
     }
     async getMacro(aliasOrIndex) {
-        const macros = Object.values(await this.readMacros())
-            .sort((left, right) => left.alias.localeCompare(right.alias, "ko"));
+        const macros = await this.getMacros();
         const trimmed = aliasOrIndex.trim();
         if (/^[0-9]+$/.test(trimmed)) {
             const index = Number.parseInt(trimmed, 10);
@@ -277,9 +276,12 @@ export class AgentMemoryService {
         const normalizedAlias = this.normalizeMacroAlias(trimmed);
         return macros.find((macro) => macro.alias === normalizedAlias);
     }
-    async listMacros() {
-        const macros = Object.values(await this.readMacros())
+    async getMacros() {
+        return Object.values(await this.readMacros())
             .sort((left, right) => left.alias.localeCompare(right.alias, "ko"));
+    }
+    async listMacros() {
+        const macros = await this.getMacros();
         if (macros.length === 0) {
             return "No macros are stored.";
         }

package/dist/services/bot-management-service.js

@@ -31,6 +31,9 @@ export class BotManagementService {
         }
         return this.formatBots(bots, await this.pollingState.list());
     }
+    async listBotChoices() {
+        return (await this.listConfiguredBots()).map(({ id, username }) => ({ id, username }));
+    }
     async formatCurrentBotSummary(currentBotId) {
         const env = await this.readEnvConfig();
         const bots = this.zipBots(env.tokens, env.usernames);

package/dist/services/bridge-service.js

@@ -181,15 +181,12 @@ export class BridgeService {
         }, chatSession.session.workspace);
     }
     async formatModelSelection(botId, chatId) {
-        const chatSession = await this.requireChat(botId, chatId);
-        const provider = chatSession.session.mode;
-        this.ensurePaired(chatSession, provider);
-        const providerSession = chatSession.session[provider];
-        const presets = MODEL_PRESETS[provider] ?? [];
+        const selection = await this.getModelSelection(botId, chatId);
+        const { provider, currentModel, presets } = selection;
         const lines = [
-            `session: ${chatSession.session.publicId}`,
+            `session: ${selection.sessionPublicId}`,
             `mode: ${provider}`,
-            `currentModel: ${providerSession.model ?? this.defaultModelFor(provider)}`,
+            `currentModel: ${currentModel}`,
             "availablePresets:",
             ...presets.map((item, index) => ` ${index + 1}. ${item}`),
             "",
@@ -200,6 +197,18 @@ export class BridgeService {
         }
         return lines.join("\n");
     }
+    async getModelSelection(botId, chatId) {
+        const chatSession = await this.requireChat(botId, chatId);
+        const provider = chatSession.session.mode;
+        this.ensurePaired(chatSession, provider);
+        const providerSession = chatSession.session[provider];
+        return {
+            sessionPublicId: chatSession.session.publicId,
+            provider,
+            currentModel: providerSession.model ?? this.defaultModelFor(provider),
+            presets: [...(MODEL_PRESETS[provider] ?? [])],
+        };
+    }
     async status(botId, chatId) {
         return this.store.getChatSession(botId, chatId);
     }

package/docs/RELEASING.md

@@ -220,3 +220,25 @@ npm run selftest:telegram
 npm run release:publish
 npm run release:deploy -- 0.17.1 30
 ```
+
+## Release 0.18.0
+
+Date: 2026-08-03
+
+Changes:
+
+- Telegram list and option responses provide inline command controls.
+- Queue notices provide inline remove-latest and remove-by-id controls in one message.
+- Codex progress streaming accepts both normalized CLI `item.completed` events and raw `event_msg`/`response_item` agent-message events.
+- The Codex stream self-test covers every supported progress event shape and keeps final results out of the progress callback.
+
+Validated:
+
+```bash
+npm run check
+npm run build
+npm run selftest:codex-stream
+npm run selftest:telegram
+npm run release:publish
+npm run release:deploy -- 0.18.0 30
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",

package/scripts/selftest-codex-stream.mjs

@@ -23,7 +23,9 @@ printf '%s\\n' '{"type":"thread.started","thread_id":"stream-thread"}'
 printf '%s' '{"type":"item.completed","item":{"type":"agent_message","text":"REPORT:progress\\nphase one"}}'
 printf '\\n'
 sleep 0.05
-printf '%s\\n' '{"type":"item.completed","item":{"type":"agent_message","text":"REPORT:progress\\nphase two"}}'
+printf '%s\\n' '{"type":"event_msg","payload":{"type":"agent_message","message":"REPORT:progress\\nphase two"}}'
+sleep 0.05
+printf '%s\\n' '{"type":"response_item","payload":{"type":"message","content":[{"type":"output_text","text":"REPORT:progress\\nphase three"}]}}'
 sleep 0.05
 printf '%s\\n' '{"type":"item.completed","item":{"type":"agent_message","text":"REPORT:result\\nfinished"}}'
 printf '%s\\n' 'REPORT:result' 'finished' > "$output"
@@ -50,7 +52,12 @@ const responsePromise = adapter.send({
 const response = await responsePromise;
 settled = true;
 
-if (progress.length !== 2 || !progress[0]?.includes("phase one") || !progress[1]?.includes("phase two")) {
+if (
+  progress.length !== 3
+  || !progress[0]?.includes("phase one")
+  || !progress[1]?.includes("phase two")
+  || !progress[2]?.includes("phase three")
+) {
   throw new Error(`Unexpected streamed progress: ${JSON.stringify(progress)}`);
 }
 if (progress.some((item) => item.includes("REPORT:result"))) {

package/scripts/selftest-telegram-update.mjs

@@ -254,6 +254,14 @@ async function click(data) {
   await injectedBot.handleUpdates([callbackUpdate(data)]);
 }
 
+function findInlineButton(call, label) {
+  if (!call?.reply_markup) {
+    return undefined;
+  }
+  const markup = JSON.parse(call.reply_markup);
+  return markup.inline_keyboard?.flat().find((button) => button.text === label);
+}
+
 async function readTelegramCalls() {
   return (await fs.readFile(telegramCalls, "utf8"))
     .trim()
@@ -440,6 +448,83 @@ if (calls.some((call) => /미완료 TODO|\/task|새 작업으로 접수/.test(ca
   throw new Error(`Task gate language leaked to Telegram replies. Calls: ${JSON.stringify(calls, null, 2)}`);
 }
 
+await send("/new");
+await send("/list");
+const sessionListCall = await waitForTelegramCall((call) => call.text.includes("Sessions (2/2)"));
+const firstSessionButton = findInlineButton(sessionListCall, `S001 · ${path.basename(session.workspace)}`);
+if (!firstSessionButton?.callback_data?.startsWith("remoteagent:action:")) {
+  throw new Error(`Session switch button is missing: ${sessionListCall.reply_markup}`);
+}
+await click(firstSessionButton.callback_data);
+await waitForTelegramCall((call) => call.text.includes("Switched this chat to session S001."));
+
+await send("/model");
+const modelListCall = await waitForTelegramCall((call) => call.text.includes("availablePresets:"));
+const modelButton = findInlineButton(modelListCall, "gpt-5.6-terra");
+if (!modelButton?.callback_data) {
+  throw new Error(`Model selection button is missing: ${modelListCall.reply_markup}`);
+}
+await click(modelButton.callback_data);
+await waitForTelegramCall((call) => call.text.includes("Set codex model to gpt-5.6-terra."));
+const modelState = JSON.parse(await fs.readFile(path.join(dataDir, "state.json"), "utf8"));
+if (modelState.sessions[session.sessionId]?.codex?.model !== "gpt-5.6-terra") {
+  throw new Error("Model button did not update the bound session model");
+}
+
+await send("/option");
+const optionListCall = await waitForTelegramCall((call) => call.text.startsWith("Runtime options"));
+const timeoutButton = findInlineButton(optionListCall, "Timeout");
+if (!timeoutButton?.callback_data) {
+  throw new Error(`Runtime option button is missing: ${optionListCall.reply_markup}`);
+}
+await click(timeoutButton.callback_data);
+await waitForTelegramCall((call) => call.text.includes("Current provider execution timeout: 600s"));
+
+await send("/sandbox");
+const sandboxListCall = await waitForTelegramCall((call) => call.text.startsWith("Codex sandbox"));
+const readOnlyButton = findInlineButton(sandboxListCall, "read-only");
+const dangerButton = findInlineButton(sandboxListCall, "danger-full-access");
+if (!readOnlyButton?.callback_data || !dangerButton?.callback_data) {
+  throw new Error(`Sandbox selection buttons are missing: ${sandboxListCall.reply_markup}`);
+}
+await click(readOnlyButton.callback_data);
+await waitForTelegramCall((call) => call.text.includes("Set Codex sandbox to read-only."));
+await click(dangerButton.callback_data);
+const sandboxConfirmCall = await waitForTelegramCall((call) => call.text.includes("Confirm Codex sandbox change"));
+if (!findInlineButton(sandboxConfirmCall, "Confirm danger-full-access")?.callback_data) {
+  throw new Error(`Danger sandbox confirmation button is missing: ${sandboxConfirmCall.reply_markup}`);
+}
+
+await send("/macro set button-test inspect the callback path");
+await send("/batch start");
+await send("/macro");
+const macroListCall = await waitForTelegramCall((call) => call.text.includes("Macros (1)"));
+const macroButton = findInlineButton(macroListCall, "button-test");
+if (!macroButton?.callback_data) {
+  throw new Error(`Macro execution button is missing: ${macroListCall.reply_markup}`);
+}
+await click(macroButton.callback_data);
+await send("/batch send");
+await waitForTelegramCall((call) => call.text.includes("mock provider completed"));
+
+await fs.appendFile(path.join(dataDir, ".env"), [
+  "TELEGRAM_BOT_TOKENS=000000:test-token",
+  "TELEGRAM_BOT_USERNAMES=remoteagent_test_bot",
+  "",
+].join("\n"), "utf8");
+await send("/bots");
+const botsCall = await waitForTelegramCall((call) => call.text.includes("Configured bots (1)"));
+const botLink = findInlineButton(botsCall, "@bot_0");
+const refreshButton = findInlineButton(botsCall, "Refresh");
+if (botLink?.url !== "https://t.me/bot_0" || !refreshButton?.callback_data) {
+  throw new Error(`Bot link or refresh button is missing: ${botsCall.reply_markup}`);
+}
+await click(refreshButton.callback_data);
+const refreshedBotsCalls = (await readTelegramCalls()).filter((call) => call.text.includes("Configured bots (1)"));
+if (refreshedBotsCalls.length < 2) {
+  throw new Error("Bot refresh callback did not render the bot list again");
+}
+
 providerMode = "timeout";
 await send("/batch start");
 await send("timeout regression test");