appback-remoteagent 0.16.0 → 0.17.1

package/README.md

@@ -123,6 +123,9 @@ Current command surface implemented in `src/bot.ts`:
 | `/batch done` | Alias for `/batch send` |
 | `/batch cancel` | Discards the current batch |
 | `/batch status` | Shows current batch state |
+| `/queue` | Lists instructions waiting behind the active session work |
+| `/queue remove <id>` | Removes one waiting instruction by its `Q001`-style id |
+| `/queue del` | Removes the most recently queued instruction |
 
 Multi-bot polling is tiered by recent activity and active provider work. See [docs/BOT_POLLING_POLICY.md](./docs/BOT_POLLING_POLICY.md).
 

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

@@ -24,6 +24,7 @@ const HELP_TEXT = [
     "/attach codex <thread_id>",
     "/attach claude <session_id>",
     "/model [name]",
+    "/queue [remove <id>|del]",
     "/stop",
     "/sandbox codex <read-only|workspace-write|danger-full-access>",
     "/status",
@@ -80,6 +81,7 @@ const RECOGNIZED_COMMANDS = new Set([
     "batch",
     "attach",
     "model",
+    "queue",
     "stop",
     "sandbox",
     "status",
@@ -100,6 +102,8 @@ const TELEGRAM_STALE_UPDATE_GRACE_SECONDS = 10;
 const TELEGRAM_PROCESS_STARTED_AT_SECONDS = Math.floor(Date.now() / 1000);
 const workLoopTails = new Map();
 const workLoopGenerations = new Map();
+const queuedWorkLoops = new Map();
+let nextQueuedWorkSequence = 1;
 const REPORT_CONTINUE_PROMPT = [
     "Continue the same task now.",
     "Do more concrete work before replying again.",
@@ -225,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.");
@@ -453,17 +469,39 @@ ${bridge.formatStatus(mapping)}`);
         const mapping = await bridge.setModel(botId, chatId, model);
         await reply(ctx, `Set ${mapping.session.mode} model to ${model}.\n\n${bridge.formatStatus(mapping)}`);
     });
+    bot.command("queue", async (ctx) => {
+        const botId = getBotId();
+        const chatId = String(ctx.chat.id);
+        const mapping = await bridge.status(botId, chatId);
+        const activeKey = workLoopKey(botId, chatId, mapping?.session.sessionId);
+        const { args, rest } = parseCommand(ctx.message?.text, 2);
+        const action = args[0]?.toLowerCase();
+        const selector = args[1];
+        if (rest?.trim() || (action && action !== "list" && action !== "remove" && action !== "rm" && action !== "del")) {
+            await reply(ctx, "Usage: `/queue`, `/queue remove <id>`, or `/queue del`", { parse_mode: "Markdown" });
+            return;
+        }
+        if (!action || action === "list") {
+            await reply(ctx, formatQueuedWorkLoops(activeKey, mapping?.session.publicId));
+            return;
+        }
+        if ((action === "remove" || action === "rm") && !selector) {
+            await reply(ctx, "Usage: `/queue remove <id>`", { parse_mode: "Markdown" });
+            return;
+        }
+        await reply(ctx, await removeQueuedInstruction(botId, chatId, selector));
+    });
     bot.command("stop", async (ctx) => {
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
         const mapping = await bridge.status(botId, chatId);
         const sessionId = mapping?.session.sessionId;
         autoContinue.requestStop(botId, chatId, sessionId);
-        cancelQueuedWorkLoops(botId, chatId, sessionId);
+        const queuedWorkCount = cancelQueuedWorkLoops(botId, chatId, sessionId);
         const pendingBatch = messageBatcher.cancelPending(botId, chatId);
         const manualBatch = messageBatcher.cancelManual(botId, chatId);
         if (!autoContinue.beginStop(botId, chatId, sessionId)) {
-            const batchCount = pendingBatch.count + manualBatch.count;
+            const batchCount = queuedWorkCount + pendingBatch.count + manualBatch.count;
             if (batchCount > 0) {
                 await bridge.logSystem(botId, chatId, `Duplicate stop discarded ${batchCount} queued message(s).`);
             }
@@ -472,7 +510,7 @@ ${bridge.formatStatus(mapping)}`);
         try {
             const result = await bridge.stopActiveRun(botId, chatId);
             await bridge.logSystem(botId, chatId, "Stop requested for auto-continue.");
-            const batchCount = pendingBatch.count + manualBatch.count;
+            const batchCount = queuedWorkCount + pendingBatch.count + manualBatch.count;
             await reply(ctx, result.stopped
                 ? `Stop requested. Active work for ${result.sessionPublicId ?? "this session"} was interrupted, further automatic continuation will stop, and ${batchCount} queued message(s) were discarded.`
                 : `Stop requested. No active provider process was running, but further automatic continuation will stop, and ${batchCount} queued message(s) were discarded.`);
@@ -866,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);
@@ -1163,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)}`);
@@ -1228,12 +1291,50 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
         .catch(() => undefined)
         .then(() => gate);
     workLoopTails.set(activeKey, currentTail);
+    let queuedEntry;
     if (previousTail) {
-        await bridge.logSystem(botId, chatId, `Queued overlapping Telegram work loop for ${activeKey}.`);
-        await helpers.reportProgress([`Queued instruction for ${currentSession?.session.publicId ?? "this session"}. It will run after the active work finishes.`]);
-        await previousTail.catch(() => undefined);
-        if ((workLoopGenerations.get(activeKey) ?? 0) !== generation || autoContinue.isStopRequested(botId, chatId, sessionId)) {
-            await bridge.logSystem(botId, chatId, `Discarded queued Telegram work loop for ${activeKey}.`);
+        queuedEntry = registerQueuedWorkLoop({
+            activeKey,
+            botId,
+            chatId,
+            sessionId,
+            publicSessionId: currentSession?.session.publicId,
+            message,
+            release,
+        });
+        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\`.`,
+                ].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) {
+            queuedWorkLoops.delete(queuedEntry.id);
+            release();
+            if (workLoopTails.get(activeKey) === currentTail) {
+                workLoopTails.delete(activeKey);
+            }
+            throw error;
+        }
+        queuedWorkLoops.delete(queuedEntry.id);
+        if (queuedEntry.canceled || (workLoopGenerations.get(activeKey) ?? 0) !== generation || autoContinue.isStopRequested(botId, chatId, sessionId)) {
+            await bridge.logSystem(botId, chatId, `Discarded queued Telegram work loop ${queuedEntry.id} for ${activeKey}.`);
             release();
             if (workLoopTails.get(activeKey) === currentTail) {
                 workLoopTails.delete(activeKey);
@@ -1270,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;
@@ -1281,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);
     }
@@ -1303,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}.`);
@@ -1313,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);
@@ -1460,9 +1583,82 @@ function cancelQueuedWorkLoops(botId, chatId, sessionId) {
     if (sessionId) {
         keys.push(workLoopKey(botId, chatId));
     }
+    const keySet = new Set(keys);
+    let removed = 0;
+    for (const entry of queuedWorkLoops.values()) {
+        if (!keySet.has(entry.activeKey)) {
+            continue;
+        }
+        entry.canceled = true;
+        entry.release();
+        queuedWorkLoops.delete(entry.id);
+        removed += 1;
+    }
     for (const key of keys) {
         workLoopGenerations.set(key, (workLoopGenerations.get(key) ?? 0) + 1);
     }
+    return removed;
+}
+function registerQueuedWorkLoop(input) {
+    const sequence = nextQueuedWorkSequence;
+    nextQueuedWorkSequence += 1;
+    const entry = {
+        id: `Q${String(sequence).padStart(3, "0")}`,
+        sequence,
+        activeKey: input.activeKey,
+        botId: input.botId,
+        chatId: input.chatId,
+        sessionId: input.sessionId,
+        publicSessionId: input.publicSessionId,
+        messagePreview: summarizeQueuedInstruction(input.message),
+        createdAt: new Date().toISOString(),
+        canceled: false,
+        release: input.release,
+    };
+    queuedWorkLoops.set(entry.id, entry);
+    return entry;
+}
+function listQueuedWorkLoops(activeKey) {
+    return [...queuedWorkLoops.values()]
+        .filter((entry) => entry.activeKey === activeKey && !entry.canceled)
+        .sort((left, right) => left.sequence - right.sequence);
+}
+function removeQueuedWorkLoop(activeKey, selector) {
+    const entries = listQueuedWorkLoops(activeKey);
+    const target = selector
+        ? queuedWorkLoops.get(normalizeQueueId(selector))
+        : entries.at(-1);
+    if (!target || target.activeKey !== activeKey || target.canceled) {
+        return undefined;
+    }
+    target.canceled = true;
+    target.release();
+    queuedWorkLoops.delete(target.id);
+    return target;
+}
+function normalizeQueueId(value) {
+    const normalized = value.trim().toUpperCase();
+    if (/^\d+$/.test(normalized)) {
+        return `Q${normalized.padStart(3, "0")}`;
+    }
+    return normalized;
+}
+function summarizeQueuedInstruction(message) {
+    const normalized = message.replace(/\s+/g, " ").trim();
+    return normalized.length > 100 ? `${normalized.slice(0, 97)}...` : normalized;
+}
+function formatQueuedWorkLoops(activeKey, publicSessionId) {
+    const entries = listQueuedWorkLoops(activeKey);
+    if (entries.length === 0) {
+        return `No queued instructions for ${publicSessionId ?? "this chat"}.`;
+    }
+    return [
+        `Queued instructions for ${publicSessionId ?? "this chat"} (${entries.length})`,
+        ...entries.map((entry) => `${entry.id}: ${entry.messagePreview || "(empty instruction)"}`),
+        "",
+        `Remove one: /queue remove ${entries[0].id}`,
+        "Remove latest: /queue del",
+    ].join("\n");
 }
 class SilentTelegramAbort extends Error {
     constructor(message) {
@@ -1509,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 };
@@ -2614,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) {
@@ -2624,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/index.js

@@ -20,6 +20,7 @@ import { ProviderRecoveryService } from "./services/provider-recovery-service.js
 import { computePolicyPollIntervalMs, computeRecentMessageRanks } from "./services/polling-policy.js";
 import { terminateAllSpawnedExecutions } from "./adapters/windows-shell.js";
 import { setTelegramCommandMenu } from "./telegram-command-menu.js";
+import { buildBotInfoFromIdentity, buildFallbackBotInfo } from "./telegram-bot-identity.js";
 const execFileAsync = promisify(execFile);
 const TELEGRAM_GET_UPDATES_HTTP_TIMEOUT_SECONDS = 30;
 const TELEGRAM_GET_UPDATES_CURL_TIMEOUT_SECONDS = 60;
@@ -68,7 +69,7 @@ async function main() {
             console.error("Local UI failed to start:", error);
         });
     }
-    const botInfos = await Promise.all(config.telegramBotTokens.map((token, index) => resolveBotInfo(token, index)));
+    const botInfos = await Promise.all(config.telegramBotTokens.map((token, index) => resolveBotInfo(token, index, config.telegramBotUsernames[index])));
     const bots = config.telegramBotTokens.map((token, index) => createBot(token, bridge, botManagement, botInfos[index]));
     if (config.telegramCommandMenuEnabled) {
         for (const bot of bots) {
@@ -484,7 +485,7 @@ class AsyncSemaphore {
         }
     }
 }
-async function resolveBotInfo(token, index) {
+async function resolveBotInfo(token, index, configuredUsername) {
     try {
         const { stdout } = await execFileAsync("curl", [
             "-sS",
@@ -502,32 +503,7 @@ async function resolveBotInfo(token, index) {
     catch (error) {
         console.warn(`Telegram getMe failed for bot ${tokenIdLabel(token)}: ${summarizeTelegramIdentityError(error)}`);
     }
-    return buildFallbackBotInfo(token, index);
-}
-function buildBotInfoFromIdentity(id, username, firstName) {
-    return {
-        id,
-        is_bot: true,
-        first_name: firstName || username,
-        username,
-        can_join_groups: false,
-        can_read_all_group_messages: false,
-        supports_inline_queries: false,
-    };
-}
-function buildFallbackBotInfo(token, index) {
-    const id = Number.parseInt(token.split(":", 1)[0] ?? "", 10);
-    const fallbackUsername = knownBotUsername(id);
-    const username = fallbackUsername || `bot_${Number.isFinite(id) ? id : index + 1}`;
-    return {
-        id: Number.isFinite(id) ? id : index + 1,
-        is_bot: true,
-        first_name: username,
-        username,
-        can_join_groups: false,
-        can_read_all_group_messages: false,
-        supports_inline_queries: false,
-    };
+    return buildFallbackBotInfo(token, index, configuredUsername);
 }
 function tokenIdLabel(token) {
     return token.split(":", 1)[0] || "unknown";
@@ -543,15 +519,6 @@ function summarizeTelegramIdentityError(error) {
         .filter(Boolean)
         .join(" ");
 }
-function knownBotUsername(id) {
-    if (id === 8369496408) {
-        return "codex_remoteagent_bot";
-    }
-    if (id === 8429712341) {
-        return "sqream_bot";
-    }
-    return undefined;
-}
 function commandExists(command) {
     const trimmed = command.trim();
     if (!trimmed) {

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/dist/telegram-bot-identity.js

@@ -0,0 +1,36 @@
+export function buildBotInfoFromIdentity(id, username, firstName) {
+    return {
+        id,
+        is_bot: true,
+        first_name: firstName || username,
+        username,
+        can_join_groups: false,
+        can_read_all_group_messages: false,
+        supports_inline_queries: false,
+    };
+}
+export function buildFallbackBotInfo(token, index, configuredUsername) {
+    const id = Number.parseInt(token.split(":", 1)[0] ?? "", 10);
+    const persistedUsername = configuredUsername?.trim().replace(/^@/, "");
+    const username = persistedUsername
+        || knownBotUsername(id)
+        || `bot_${Number.isFinite(id) ? id : index + 1}`;
+    return {
+        id: Number.isFinite(id) ? id : index + 1,
+        is_bot: true,
+        first_name: username,
+        username,
+        can_join_groups: false,
+        can_read_all_group_messages: false,
+        supports_inline_queries: false,
+    };
+}
+function knownBotUsername(id) {
+    if (id === 8369496408) {
+        return "codex_remoteagent_bot";
+    }
+    if (id === 8429712341) {
+        return "sqream_bot";
+    }
+    return undefined;
+}

package/dist/telegram-command-menu.js

@@ -15,6 +15,7 @@ export const TELEGRAM_COMMAND_MENU = [
     { command: "docs", description: "Pin or find session documents" },
     { command: "macro", description: "Save or run reusable instructions" },
     { command: "model", description: "Show or change provider model" },
+    { command: "queue", description: "List or remove queued instructions" },
     { command: "stop", description: "Stop active work and clear queued messages" },
     { command: "sandbox", description: "Set Codex sandbox mode" },
     { command: "batch", description: "Collect and send a multi-message batch" },

package/docs/OPERATIONS.md

@@ -44,6 +44,10 @@ Current production bot ownership is intentionally split:
 Assign each Telegram bot token to one runtime at a time.
 Bot polling conflicts are treated as incidents, not harmless warnings.
 
+`TELEGRAM_BOT_TOKENS` and `TELEGRAM_BOT_USERNAMES` are parallel persisted lists.
+At startup, Telegram `getMe` is the preferred identity source, but a temporary DNS or Telegram failure must fall back to the persisted username at the same list position.
+Using a generated `bot_<numeric-id>` identity when a persisted username exists breaks the existing `<username>:<chat-id>` session binding.
+
 When a runtime has several configured Telegram bots, polling pressure can become operationally visible.
 RemoteAgent reduces that pressure with rank-based polling intervals instead of deep sleep or a special main bot.
 See [BOT_POLLING_POLICY.md](./BOT_POLLING_POLICY.md).

package/docs/RELEASING.md

@@ -174,3 +174,49 @@ Runtime targets:
 server 30: 0.15.5 active
 server 26: 0.15.5 running
 ```
+
+## Release 0.17.0
+
+Date: 2026-07-29
+
+Changes:
+
+- Queued instructions receive runtime-unique `Q001`-style ids.
+- `/queue` lists instructions waiting behind the current session work.
+- `/queue remove <id>` removes one selected waiting instruction.
+- `/queue del` removes the most recently queued instruction.
+- `/stop` reports and clears queued work-loop instructions as well as pending message batches.
+- Telegram startup preserves the configured bot username when `getMe` temporarily fails, preventing existing chat/session bindings from being bypassed by a generated numeric bot identity.
+
+Validated:
+
+```bash
+npm run check
+npm run build
+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.16.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)
@@ -69,6 +73,7 @@ const [
   { FileStore },
   { AgentMemoryService },
   { WorkspaceCleanupService },
+  { buildFallbackBotInfo },
 ] = await Promise.all([
   import(path.join(root, "dist", "bot.js")),
   import(path.join(root, "dist", "services", "bridge-service.js")),
@@ -76,12 +81,27 @@ const [
   import(path.join(root, "dist", "store", "file-store.js")),
   import(path.join(root, "dist", "services", "agent-memory-service.js")),
   import(path.join(root, "dist", "services", "workspace-cleanup-service.js")),
+  import(path.join(root, "dist", "telegram-bot-identity.js")),
 ]);
 
+const persistedBotIdentity = buildFallbackBotInfo(
+  "8966593034:test-token",
+  0,
+  "@appbackadmin_bot",
+);
+if (persistedBotIdentity.username !== "appbackadmin_bot") {
+  throw new Error(`Configured bot username was not preserved during getMe fallback: ${persistedBotIdentity.username}`);
+}
+
 const providerCalls = [];
 let providerMode = "success";
 let untaggedIntentCalls = 0;
 let missingEvidenceCalls = 0;
+let streamingFinalProgressCalls = 0;
+let queueHoldStartedResolve;
+let queueHoldReleaseResolve;
+let queueHoldStartedPromise = Promise.resolve();
+let queueHoldReleasePromise = Promise.resolve();
 const provider = {
   async send(request) {
     providerCalls.push(request);
@@ -112,6 +132,49 @@ const provider = {
           : "REPORT:result\n수정 완료했습니다.\n\n근거:\n- 변경 파일: `src/example.ts`\n- 검증: `npm run check` 통과",
       };
     }
+    if (providerMode === "queue-hold") {
+      queueHoldStartedResolve?.();
+      await queueHoldReleasePromise;
+      return {
+        provider: "codex",
+        sessionId: request.sessionId || "mock-thread",
+        publicSessionId: request.publicSessionId,
+        cwd: request.cwd,
+        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",
@@ -165,10 +228,61 @@ 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 = "", replyMarkupB64 = ""] = line.split("\t");
+      return {
+        method,
+        chat_id: chatId,
+        text: Buffer.from(textB64, "base64").toString("utf8"),
+        reply_markup: Buffer.from(replyMarkupB64, "base64").toString("utf8"),
+      };
+    });
+}
+
+async function waitForTelegramCall(predicate, timeoutMs = 3000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const calls = await readTelegramCalls();
+    const match = [...calls].reverse().find(predicate);
+    if (match) {
+      return match;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  throw new Error("Timed out waiting for Telegram self-test call.");
+}
+
 await send("/start codex");
 await send("/option retry 6");
 await send("/option timeout 600");
@@ -407,6 +521,100 @@ 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) => {
+  queueHoldStartedResolve = resolve;
+});
+queueHoldReleasePromise = new Promise((resolve) => {
+  queueHoldReleaseResolve = resolve;
+});
+
+await send("/batch start");
+await send("active queue regression test");
+const activeQueueSend = send("/batch send");
+await queueHoldStartedPromise;
+
+await send("/batch start");
+await send("first queued instruction");
+const firstQueuedSend = send("/batch send");
+const firstQueueNotice = await waitForTelegramCall((call) => /Queued instruction Q\d+/.test(call.text));
+const firstQueueId = firstQueueNotice.text.match(/Queued instruction (Q\d+)/)?.[1];
+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");
+const secondQueuedSend = send("/batch send");
+const secondQueueNotice = await waitForTelegramCall((call) => {
+  const queueId = call.text.match(/Queued instruction (Q\d+)/)?.[1];
+  return Boolean(queueId && queueId !== firstQueueId);
+});
+const secondQueueId = secondQueueNotice.text.match(/Queued instruction (Q\d+)/)?.[1];
+if (!secondQueueId) {
+  throw new Error(`Second queued instruction did not receive an id: ${secondQueueNotice.text}`);
+}
+
+await send("/queue");
+const queueListCall = await waitForTelegramCall((call) =>
+  call.text.includes(firstQueueId) && call.text.includes(secondQueueId)
+);
+if (!/Queued instructions for S001 \(2\)/.test(queueListCall.text)) {
+  throw new Error(`Queue list did not report both entries: ${queueListCall.text}`);
+}
+
+await click(`remoteagent:queue:remove:${firstQueueId}`);
+await waitForTelegramCall((call) => call.text.includes(`Removed queued instruction ${firstQueueId}`));
+await click("remoteagent:queue:del");
+await waitForTelegramCall((call) => call.text.includes(`Removed queued instruction ${secondQueueId}`));
+
+queueHoldReleaseResolve?.();
+await Promise.all([activeQueueSend, firstQueuedSend, secondQueuedSend]);
+if (providerCalls.length !== queueProviderCallsBefore + 1) {
+  throw new Error(`Removed queued instructions reached the provider: ${providerCalls.length - queueProviderCallsBefore} calls`);
+}
+
 console.log(JSON.stringify({
   ok: true,
   dataDir,
@@ -419,6 +627,10 @@ console.log(JSON.stringify({
   providerCalls: providerCalls.length,
   untaggedIntentCalls,
   missingEvidenceCalls,
+  streamingProgress: true,
+  streamingFinalProgressDeduplicated: true,
+  queueRemoveById: firstQueueId,
+  queueRemoveLatest: secondQueueId,
   timeoutFinalMessage: true,
   telegramSendMessages: evidenceCalls.filter((call) => call.method === "sendMessage").length,
 }, null, 2));