appback-remoteagent 0.17.0 → 0.17.1

package/dist/adapters/codex-adapter.js

@@ -18,7 +18,7 @@ export class CodexAdapter {
         const args = request.sessionId
             ? this.buildResumeArgs(request, outputPath, sandboxMode)
             : this.buildExecArgs(request, outputPath, sandboxMode);
-        const { stdout, stderr, code, timedOut } = await this.runCodex(args, request.cwd, request.remoteSessionId, request.publicSessionId, request.message);
+        const { stdout, stderr, code, timedOut } = await this.runCodex(args, request.cwd, request.remoteSessionId, request.publicSessionId, request.message, request.onProgress);
         try {
             const sessionId = this.extractThreadId(stdout) ?? request.sessionId;
             const output = await this.readOutput(outputPath) || this.extractAgentMessage(stdout);
@@ -102,12 +102,31 @@ export class CodexAdapter {
             args.push("--dangerously-bypass-approvals-and-sandbox");
         }
     }
-    runCodex(args, cwd, remoteSessionId, publicSessionId, input) {
+    runCodex(args, cwd, remoteSessionId, publicSessionId, input, onProgress) {
         return spawnWithPlatformShell(this.codexBin, args, cwd, this.currentTimeoutMs(), input, remoteSessionId, {
             REMOTEAGENT_SESSION_ID: remoteSessionId,
             REMOTEAGENT_PUBLIC_SESSION_ID: publicSessionId ?? "",
             REMOTEAGENT_WORKSPACE: cwd,
-        });
+        }, (line) => this.handleProgressLine(line, onProgress));
+    }
+    async handleProgressLine(line, onProgress) {
+        if (!onProgress || !line.startsWith("{")) {
+            return;
+        }
+        let text;
+        try {
+            const event = JSON.parse(line);
+            text = event.type === "item.completed" && event.item?.type === "agent_message"
+                ? event.item.text?.trim()
+                : undefined;
+        }
+        catch {
+            // Ignore non-JSON stdout and let the normal final-response parser handle it.
+            return;
+        }
+        if (text && /^REPORT:progress(?:\r?\n|$)/i.test(text)) {
+            await onProgress(text);
+        }
     }
     extractThreadId(stdout) {
         for (const line of stdout.split(/\r?\n/)) {

package/dist/adapters/windows-shell.js

@@ -2,7 +2,7 @@ import process from "node:process";
 import { execFile, spawn } from "node:child_process";
 import { buildProviderEnv } from "./runtime-env.js";
 const activeCommands = new Map();
-export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executionKey, extraEnv) {
+export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executionKey, extraEnv, onStdoutLine) {
     return new Promise((resolve, reject) => {
         const command = process.platform === "win32"
             ? spawn("cmd.exe", ["/d", "/c", "call", bin, ...args], {
@@ -19,13 +19,29 @@ export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executi
         }
         let stdout = "";
         let stderr = "";
+        let stdoutRemainder = "";
+        let stdoutCallbackTail = Promise.resolve();
         let timedOut = false;
         const timer = setTimeout(() => {
             timedOut = true;
             terminateProcessTree(command);
         }, timeoutMs);
         command.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
+            const text = chunk.toString();
+            stdout += text;
+            if (!onStdoutLine) {
+                return;
+            }
+            stdoutRemainder += text;
+            const lines = stdoutRemainder.split(/\r?\n/);
+            stdoutRemainder = lines.pop() ?? "";
+            for (const line of lines) {
+                stdoutCallbackTail = stdoutCallbackTail
+                    .then(() => onStdoutLine(line))
+                    .catch((error) => {
+                    console.warn(`[provider-stream] stdout callback failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
         });
         command.stderr.on("data", (chunk) => {
             stderr += chunk.toString();
@@ -41,11 +57,19 @@ export function spawnWithPlatformShell(bin, args, cwd, timeoutMs, input, executi
             command.stdin.write(input);
         }
         command.stdin.end();
-        command.on("close", (code) => {
+        command.on("close", async (code) => {
             clearTimeout(timer);
             if (executionKey && activeCommands.get(executionKey) === command) {
                 activeCommands.delete(executionKey);
             }
+            if (onStdoutLine && stdoutRemainder) {
+                stdoutCallbackTail = stdoutCallbackTail
+                    .then(() => onStdoutLine(stdoutRemainder))
+                    .catch((error) => {
+                    console.warn(`[provider-stream] stdout callback failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
+            await stdoutCallbackTail;
             resolve({ stdout, stderr, code, timedOut });
         });
     });

package/dist/bot.js

@@ -229,6 +229,18 @@ export function createBot(token, bridge, botManagement, botInfo) {
             throw error;
         }
     };
+    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.");
@@ -477,15 +489,7 @@ ${bridge.formatStatus(mapping)}`);
             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();
@@ -900,6 +904,28 @@ ${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 match = /^remoteagent:queue:(remove:(Q\d+)|del)$/i.exec(ctx.callbackQuery.data);
+        if (!match) {
+            return;
+        }
+        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.",
+            });
+            return;
+        }
+        const botId = getBotId();
+        const chatId = String(callbackChat.id);
+        const result = await removeQueuedInstruction(botId, chatId, match[2]);
+        await callTelegramApi(token, "answerCallbackQuery", {
+            callback_query_id: ctx.callbackQuery.id,
+            text: result.split("\n", 1)[0],
+        });
+        await sendTelegramMessage(token, callbackChat.id, result);
+    });
     bot.on("message", async (ctx) => {
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
@@ -1197,14 +1223,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 +1304,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 +1371,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 +1383,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 +1422,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 +1432,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 +1705,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 };
@@ -2745,6 +2813,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 +2824,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,
                     });
                 }
             }

package/dist/services/bridge-service.js

@@ -284,7 +284,7 @@ export class BridgeService {
         }
         return { stopped, sessionPublicId: session.publicId };
     }
-    async routeMessage(botId, chatId, message) {
+    async routeMessage(botId, chatId, message, onProgress) {
         const chatSession = await this.requireChat(botId, chatId);
         await this.log({
             timestamp: new Date().toISOString(),
@@ -295,7 +295,7 @@ export class BridgeService {
             direction: "in",
             text: message,
         });
-        return this.withSessionLock(chatSession.session.sessionId, () => this.routeSession(chatSession.session, message, "telegram", botId, chatId));
+        return this.withSessionLock(chatSession.session.sessionId, () => this.routeSession(chatSession.session, message, "telegram", botId, chatId, onProgress));
     }
     async routeSessionMessage(sessionId, message) {
         const session = await this.store.getSession(sessionId);
@@ -311,7 +311,7 @@ export class BridgeService {
         });
         return this.withSessionLock(session.sessionId, () => this.routeSession(session, message, "pc-ui"));
     }
-    async routeSessionMessageForChat(sessionId, botId, chatId, message) {
+    async routeSessionMessageForChat(sessionId, botId, chatId, message, onProgress) {
         const session = await this.store.getSession(sessionId);
         if (!session) {
             throw new Error(`Session was not found: ${sessionId}`);
@@ -325,7 +325,7 @@ export class BridgeService {
             direction: "in",
             text: message,
         });
-        return this.withSessionLock(session.sessionId, () => this.routeSession(session, message, "telegram", botId, chatId));
+        return this.withSessionLock(session.sessionId, () => this.routeSession(session, message, "telegram", botId, chatId, onProgress));
     }
     formatStatus(chatSession) {
         if (!chatSession) {
@@ -475,7 +475,7 @@ export class BridgeService {
             }
         }
     }
-    async routeSession(session, message, requestSource, botId, chatId) {
+    async routeSession(session, message, requestSource, botId, chatId, onProgress) {
         const responses = [];
         const providers = this.resolveProviders(session.mode);
         for (const provider of providers) {
@@ -491,6 +491,29 @@ export class BridgeService {
                 message,
                 model: providerSession.model,
                 sandboxMode: providerSession.sandboxMode,
+                onProgress: onProgress
+                    ? async (output) => {
+                        const progressResponse = {
+                            provider,
+                            sessionId: providerSession.sessionId ?? session.sessionId,
+                            publicSessionId: session.publicId,
+                            model: providerSession.model ?? this.defaultModelFor(provider),
+                            cwd: providerSession.cwd,
+                            output,
+                        };
+                        await this.log({
+                            timestamp: new Date().toISOString(),
+                            remoteSessionId: session.sessionId,
+                            botId,
+                            chatId,
+                            provider,
+                            direction: "out",
+                            sessionId: providerSession.sessionId,
+                            text: output,
+                        });
+                        await onProgress(progressResponse);
+                    }
+                    : undefined,
             });
             const updatedProviderSession = {
                 ...providerSession,

package/docs/RELEASING.md

@@ -197,3 +197,26 @@ npm run selftest:telegram
 npm run release:publish
 npm run release:deploy -- 0.17.0 all
 ```
+
+## Release 0.17.1
+
+Date: 2026-08-03
+
+Changes:
+
+- Codex JSON stdout is parsed while the provider process is running.
+- `REPORT:progress` messages are delivered to Telegram immediately without starting another provider turn.
+- A streamed final progress message is deduplicated from the normal post-process response path.
+- Queue instructions are announced in one Telegram message instead of two.
+- Queue notices include inline `/queue remove Qxxx` and `/queue del` buttons that execute the existing queue removal behavior.
+
+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.17.1 30
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",
@@ -19,6 +19,7 @@
     "start": "node dist/index.js",
     "check": "tsc --noEmit -p tsconfig.json",
     "selftest:telegram": "npm run build && node scripts/selftest-telegram-update.mjs",
+    "selftest:codex-stream": "npm run build && node scripts/selftest-codex-stream.mjs",
     "prepare": "npm run build",
     "prepublishOnly": "node scripts/prepublish-guard.mjs",
     "release:version": "bash scripts/release-version.sh",

package/scripts/selftest-codex-stream.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const root = path.resolve(new URL("..", import.meta.url).pathname);
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "remoteagent-codex-stream-"));
+const fakeCodex = path.join(tmp, "codex");
+
+await fs.writeFile(fakeCodex, `#!/usr/bin/env bash
+set -euo pipefail
+output=""
+while [ "$#" -gt 0 ]; do
+  if [ "$1" = "-o" ]; then
+    output="$2"
+    shift 2
+    continue
+  fi
+  shift
+done
+cat >/dev/null
+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"}}'
+sleep 0.05
+printf '%s\\n' '{"type":"item.completed","item":{"type":"agent_message","text":"REPORT:result\\nfinished"}}'
+printf '%s\\n' 'REPORT:result' 'finished' > "$output"
+`, "utf8");
+await fs.chmod(fakeCodex, 0o755);
+
+const { CodexAdapter } = await import(path.join(root, "dist", "adapters", "codex-adapter.js"));
+const adapter = new CodexAdapter(fakeCodex, 5000, "read-only");
+const progress = [];
+let settled = false;
+const responsePromise = adapter.send({
+  chatId: "selftest",
+  remoteSessionId: "remote-session",
+  publicSessionId: "S001",
+  message: "test",
+  cwd: tmp,
+  onProgress: async (output) => {
+    if (settled) {
+      throw new Error("Progress arrived after the provider response settled");
+    }
+    progress.push(output);
+  },
+});
+const response = await responsePromise;
+settled = true;
+
+if (progress.length !== 2 || !progress[0]?.includes("phase one") || !progress[1]?.includes("phase two")) {
+  throw new Error(`Unexpected streamed progress: ${JSON.stringify(progress)}`);
+}
+if (progress.some((item) => item.includes("REPORT:result"))) {
+  throw new Error(`Final result leaked through progress callback: ${JSON.stringify(progress)}`);
+}
+if (response.sessionId !== "stream-thread" || response.output !== "REPORT:result\nfinished") {
+  throw new Error(`Unexpected final response: ${JSON.stringify(response)}`);
+}
+
+console.log(JSON.stringify({ ok: true, streamedProgress: progress.length, final: response.output }, null, 2));

package/scripts/selftest-telegram-update.mjs

@@ -21,23 +21,27 @@ set -euo pipefail
 method="unknown"
 text=""
 chat_id=""
+reply_markup=""
 for arg in "$@"; do
   case "$arg" in
     https://api.telegram.org/bot*/sendMessage) method="sendMessage" ;;
     https://api.telegram.org/bot*/editMessageText) method="editMessageText" ;;
     https://api.telegram.org/bot*/deleteMessage) method="deleteMessage" ;;
     https://api.telegram.org/bot*/sendDocument) method="sendDocument" ;;
+    https://api.telegram.org/bot*/answerCallbackQuery) method="answerCallbackQuery" ;;
     chat_id=*) chat_id="\${arg#chat_id=}" ;;
     text=*) text="\${arg#text=}" ;;
+    reply_markup=*) reply_markup="\${arg#reply_markup=}" ;;
   esac
 done
 text_b64="$(printf '%s' "$text" | base64 -w 0)"
-printf '%s\\t%s\\t%s\\n' "$method" "$chat_id" "$text_b64" >> ${JSON.stringify(telegramCalls)}
+reply_markup_b64="$(printf '%s' "$reply_markup" | base64 -w 0)"
+printf '%s\\t%s\\t%s\\t%s\\n' "$method" "$chat_id" "$text_b64" "$reply_markup_b64" >> ${JSON.stringify(telegramCalls)}
 case "$method" in
   sendMessage|editMessageText)
     printf '{"ok":true,"result":{"message_id":1001}}'
     ;;
-  deleteMessage)
+  deleteMessage|answerCallbackQuery)
     printf '{"ok":true,"result":true}'
     ;;
   sendDocument)
@@ -93,6 +97,7 @@ const providerCalls = [];
 let providerMode = "success";
 let untaggedIntentCalls = 0;
 let missingEvidenceCalls = 0;
+let streamingFinalProgressCalls = 0;
 let queueHoldStartedResolve;
 let queueHoldReleaseResolve;
 let queueHoldStartedPromise = Promise.resolve();
@@ -138,6 +143,38 @@ const provider = {
         output: "REPORT:result\nactive queue test completed",
       };
     }
+    if (providerMode === "streaming-progress") {
+      await request.onProgress?.("REPORT:progress\nstreamed phase one completed");
+      await request.onProgress?.("REPORT:progress\nstreamed phase two completed");
+      return {
+        provider: "codex",
+        sessionId: request.sessionId || "mock-thread",
+        publicSessionId: request.publicSessionId,
+        cwd: request.cwd,
+        output: "REPORT:result\nstreamed provider completed with evidence: `stream-test.log`",
+      };
+    }
+    if (providerMode === "streaming-final-progress") {
+      streamingFinalProgressCalls += 1;
+      if (streamingFinalProgressCalls === 1) {
+        const output = "REPORT:progress\nstreamed final progress completed";
+        await request.onProgress?.(output);
+        return {
+          provider: "codex",
+          sessionId: request.sessionId || "mock-thread",
+          publicSessionId: request.publicSessionId,
+          cwd: request.cwd,
+          output,
+        };
+      }
+      return {
+        provider: "codex",
+        sessionId: request.sessionId || "mock-thread",
+        publicSessionId: request.publicSessionId,
+        cwd: request.cwd,
+        output: "REPORT:result\nstreamed continuation completed with evidence: `stream-final.log`",
+      };
+    }
     return {
       provider: "codex",
       sessionId: request.sessionId || "mock-thread",
@@ -191,21 +228,44 @@ function update(text) {
   };
 }
 
+function callbackUpdate(data, sourceMessageId = messageId++) {
+  return {
+    update_id: updateId++,
+    callback_query: {
+      id: `callback-${updateId}`,
+      from: { id: 111, is_bot: false, first_name: "Tester", username: "tester" },
+      message: {
+        message_id: sourceMessageId,
+        date: now(),
+        chat: { id: 111222333, type: "private", first_name: "Tester", username: "tester" },
+        text: "queue controls",
+      },
+      chat_instance: "selftest",
+      data,
+    },
+  };
+}
+
 async function send(text) {
   await injectedBot.handleUpdates([update(text)]);
 }
 
+async function click(data) {
+  await injectedBot.handleUpdates([callbackUpdate(data)]);
+}
+
 async function readTelegramCalls() {
   return (await fs.readFile(telegramCalls, "utf8"))
     .trim()
     .split("\n")
     .filter(Boolean)
     .map((line) => {
-      const [method, chatId, textB64 = ""] = line.split("\t");
+      const [method, chatId, textB64 = "", replyMarkupB64 = ""] = line.split("\t");
       return {
         method,
         chat_id: chatId,
         text: Buffer.from(textB64, "base64").toString("utf8"),
+        reply_markup: Buffer.from(replyMarkupB64, "base64").toString("utf8"),
       };
     });
 }
@@ -461,6 +521,36 @@ if (evidenceCalls.some((call) => call.method === "sendMessage" && /^수정 완
   throw new Error(`Evidence-free completion leaked as final Telegram message. Calls: ${JSON.stringify(evidenceCalls, null, 2)}`);
 }
 
+providerMode = "streaming-progress";
+await send("/batch start");
+await send("streaming progress regression test");
+await send("/batch send");
+
+const streamingCalls = await readTelegramCalls();
+for (const phase of ["streamed phase one completed", "streamed phase two completed"]) {
+  const matches = streamingCalls.filter((call) => call.method === "sendMessage" && call.text.includes(phase));
+  if (matches.length !== 1) {
+    throw new Error(`Expected exactly one streamed Telegram progress message for ${phase}, got ${matches.length}`);
+  }
+}
+if (!streamingCalls.some((call) => call.method === "sendMessage" && call.text.includes("streamed provider completed"))) {
+  throw new Error("Streaming provider final result was not delivered");
+}
+
+providerMode = "streaming-final-progress";
+await send("/batch start");
+await send("streaming final progress deduplication test");
+await send("/batch send");
+const streamingFinalCalls = await readTelegramCalls();
+const streamedFinalProgressMessages = streamingFinalCalls.filter((call) =>
+  call.method === "sendMessage" && call.text.includes("streamed final progress completed")
+);
+if (streamedFinalProgressMessages.length !== 1 || streamingFinalProgressCalls !== 2) {
+  throw new Error(
+    `Final streamed progress was not deduplicated: messages=${streamedFinalProgressMessages.length} providerCalls=${streamingFinalProgressCalls}`,
+  );
+}
+
 const queueProviderCallsBefore = providerCalls.length;
 providerMode = "queue-hold";
 queueHoldStartedPromise = new Promise((resolve) => {
@@ -483,6 +573,16 @@ const firstQueueId = firstQueueNotice.text.match(/Queued instruction (Q\d+)/)?.[
 if (!firstQueueId) {
   throw new Error(`First queued instruction did not receive an id: ${firstQueueNotice.text}`);
 }
+const firstQueueNotices = (await readTelegramCalls()).filter((call) =>
+  call.method === "sendMessage" && call.text.includes(`Queued instruction ${firstQueueId} for`)
+);
+if (firstQueueNotices.length !== 1) {
+  throw new Error(`Queue notice should be one Telegram message, got ${firstQueueNotices.length}`);
+}
+if (!firstQueueNotice.reply_markup.includes(`remoteagent:queue:remove:${firstQueueId}`)
+  || !firstQueueNotice.reply_markup.includes("remoteagent:queue:del")) {
+  throw new Error(`Queue notice buttons are missing: ${firstQueueNotice.reply_markup}`);
+}
 
 await send("/batch start");
 await send("second queued instruction");
@@ -504,9 +604,9 @@ if (!/Queued instructions for S001 \(2\)/.test(queueListCall.text)) {
   throw new Error(`Queue list did not report both entries: ${queueListCall.text}`);
 }
 
-await send(`/queue remove ${firstQueueId}`);
+await click(`remoteagent:queue:remove:${firstQueueId}`);
 await waitForTelegramCall((call) => call.text.includes(`Removed queued instruction ${firstQueueId}`));
-await send("/queue del");
+await click("remoteagent:queue:del");
 await waitForTelegramCall((call) => call.text.includes(`Removed queued instruction ${secondQueueId}`));
 
 queueHoldReleaseResolve?.();
@@ -527,6 +627,8 @@ console.log(JSON.stringify({
   providerCalls: providerCalls.length,
   untaggedIntentCalls,
   missingEvidenceCalls,
+  streamingProgress: true,
+  streamingFinalProgressDeduplicated: true,
   queueRemoveById: firstQueueId,
   queueRemoveLatest: secondQueueId,
   timeoutFinalMessage: true,