appback-remoteagent 0.13.21 → 0.14.1

package/.env.example

@@ -1,6 +1,5 @@
 TELEGRAM_BOT_TOKEN=your-telegram-bot-token
 TELEGRAM_BOT_TOKENS=
-TELEGRAM_MAIN_BOT_ID=
 TELEGRAM_OWNER_ID=
 TELEGRAM_MESSAGE_BATCH_MS=1500
 TELEGRAM_AUTO_PROGRESS_MAX_TURNS=6
@@ -9,12 +8,11 @@ TELEGRAM_RETRYABLE_ERROR_RETRIES=2
 TELEGRAM_RETRYABLE_ERROR_DELAY_MS=5000
 TELEGRAM_UNTAGGED_INTENT_RETRIES=2
 TELEGRAM_SCHEDULER_TICK_MS=1000
-TELEGRAM_TIERED_POLLING_MIN_BOTS=4
+TELEGRAM_TIERED_POLLING_MIN_BOTS=5
 TELEGRAM_ACTIVE_POLL_INTERVAL_MS=3000
-TELEGRAM_IDLE_POLL_INTERVAL_MS=30000
-TELEGRAM_COLD_POLL_INTERVAL_MS=300000
-TELEGRAM_ACTIVE_IDLE_MS=1800000
-TELEGRAM_COLD_IDLE_MS=21600000
+TELEGRAM_RUNNING_POLL_INTERVAL_MS=60000
+TELEGRAM_SECONDARY_POLL_INTERVAL_MS=60000
+TELEGRAM_TERTIARY_POLL_INTERVAL_MS=180000
 ARTIFACT_CLEANUP_ENABLED=true
 ARTIFACT_RETENTION_DAYS=30
 ARTIFACT_CLEANUP_INTERVAL_MS=86400000

package/README.md

@@ -112,11 +112,8 @@ Current command surface implemented in `src/bot.ts`:
 | `/bots` | Lists the currently configured Telegram bots |
 | `/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 main <number\|@username\|id>` | Selects the main bot. If no valid main is configured, the oldest configured bot is used |
 | `/bot remove <username\|id>` | Removes a configured Telegram bot, restarts the runtime, and confirms the result after restart |
 | `/bot reload` | Restarts the runtime and confirms the result after restart |
-| `/sleep [bot]` | Puts a sub bot into deep sleep without removing its configuration |
-| `/wake <bot>` | Wakes a sleeping sub bot |
 | `/install codex\|claude` | Runs the configured provider install or update command for the bot owner |
 | `/login codex` | Starts the Codex device-auth login flow and returns a browser URL when available |
 | `/login claude [token]` | Starts or finishes the configured Claude Code login flow for the bot owner |
@@ -127,7 +124,7 @@ Current command surface implemented in `src/bot.ts`:
 | `/batch cancel` | Discards the current batch |
 | `/batch status` | Shows current batch state |
 
-Bot sleep keeps long-idle sub bots configured while stopping their polling load. See [docs/BOT_SLEEP.md](./docs/BOT_SLEEP.md).
+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

@@ -31,7 +31,7 @@ export class CodexAdapter {
                 };
             }
             if (code !== 0) {
-                throw new Error(this.formatProcessError(stdout, stderr, timedOut));
+                throw new Error(this.formatProcessError(stdout, stderr, timedOut, code));
             }
             if (timedOut) {
                 throw new Error(this.formatTimeoutError());
@@ -147,7 +147,7 @@ export class CodexAdapter {
     async readOutput(outputPath) {
         return (await fs.readFile(outputPath, "utf8").catch(() => "")).trim();
     }
-    formatProcessError(stdout, stderr, timedOut = false) {
+    formatProcessError(stdout, stderr, timedOut = false, code) {
         const structured = this.extractStructuredError(stdout, stderr);
         if (structured) {
             return structured;
@@ -158,7 +158,7 @@ export class CodexAdapter {
         }
         return timedOut
             ? this.formatTimeoutError()
-            : "Codex execution failed without any output.";
+            : `Codex process exited with code ${code ?? "unknown"} without stdout/stderr.`;
     }
     extractStructuredError(stdout, stderr) {
         const messages = [];

package/dist/bot.js

@@ -33,11 +33,8 @@ const HELP_TEXT = [
     "/bots",
     "/bot add <token>",
     "/bot doctor",
-    "/bot main <number|@username|id>",
     "/bot remove <username|id>",
     "/bot reload",
-    "/sleep [bot]",
-    "/wake <bot>",
     "/install codex|claude",
     "/login codex",
     "/login claude [token]",
@@ -86,8 +83,6 @@ const RECOGNIZED_COMMANDS = new Set([
     "docs",
     "bots",
     "bot",
-    "sleep",
-    "wake",
     "install",
     "login",
     "reset",
@@ -232,7 +227,7 @@ export function createBot(token, bridge, botManagement, botInfo) {
         await bridge.logSystem(botId, chatId, `Telegram text dispatch (${text.length} chars).`);
         await runWithPendingAnimation(target.botToken, target.telegramChatId, async (helpers) => {
             return {
-                chunks: await routeTelegramWorkLoop(bridge, botId, chatId, text, "Telegram text request", helpers, autoContinue, memoryService),
+                chunks: await routeTelegramWorkLoop(bridge, botId, chatId, text, "Telegram text request", botManagement, helpers, autoContinue, memoryService),
             };
         });
     });
@@ -701,8 +696,8 @@ ${bridge.formatStatus(mapping)}`);
         const sourceBotId = getBotId();
         const { args, rest } = parseCommand(ctx.message?.text, 2);
         const action = args[0]?.toLowerCase();
-        if (!action || !["add", "doctor", "main", "remove", "reload"].includes(action)) {
-            await reply(ctx, "Usage: `/bot add <token>`, `/bot doctor`, `/bot main <number|@username|id>`, `/bot remove <username|id>`, or `/bot reload`", {
+        if (!action || !["add", "doctor", "remove", "reload"].includes(action)) {
+            await reply(ctx, "Usage: `/bot add <token>`, `/bot doctor`, `/bot remove <username|id>`, or `/bot reload`", {
                 parse_mode: "Markdown",
             });
             return;
@@ -725,11 +720,6 @@ ${bridge.formatStatus(mapping)}`);
             await reply(ctx, result.message);
             return;
         }
-        if (action === "main") {
-            const result = await botManagement.setMainBot(commandTarget(args, rest));
-            await reply(ctx, result.message);
-            return;
-        }
         if (action === "remove") {
             const result = await botManagement.removeBot(commandTarget(args, rest), sourceBotId, sourceBotToken, ctx.chat.id);
             await reply(ctx, result.message);
@@ -738,19 +728,6 @@ ${bridge.formatStatus(mapping)}`);
         const result = await botManagement.reloadBots(sourceBotId, sourceBotToken, ctx.chat.id);
         await reply(ctx, result.message);
     });
-    bot.command("sleep", async (ctx) => {
-        await ensureOwnerControlAccess(ctx);
-        const sourceBotId = getBotId();
-        const { args, rest } = parseCommand(ctx.message?.text, 1);
-        const result = await botManagement.sleepBot(commandTarget(args, rest), sourceBotId);
-        await reply(ctx, result.message);
-    });
-    bot.command("wake", async (ctx) => {
-        await ensureOwnerControlAccess(ctx);
-        const { args, rest } = parseCommand(ctx.message?.text, 1);
-        const result = await botManagement.wakeBot(commandTarget(args, rest));
-        await reply(ctx, result.message);
-    });
     bot.command("install", async (ctx) => {
         await ensureOwnerControlAccess(ctx);
         const { args } = parseCommand(ctx.message?.text, 1);
@@ -849,7 +826,7 @@ ${bridge.formatStatus(mapping)}`);
             await bridge.logSystem(botId, chatId, `Telegram image received: ${downloaded.path}`);
             await runWithPendingAnimation(token, ctx.chat.id, async (helpers) => {
                 return {
-                    chunks: await routeTelegramWorkLoop(bridge, botId, chatId, message, "Telegram image request", helpers, autoContinue, memoryService, sanitizeAttachmentResponseBlocks),
+                    chunks: await routeTelegramWorkLoop(bridge, botId, chatId, message, "Telegram image request", botManagement, helpers, autoContinue, memoryService, sanitizeAttachmentResponseBlocks),
                 };
             });
             return;
@@ -874,7 +851,7 @@ ${bridge.formatStatus(mapping)}`);
             await bridge.logSystem(botId, chatId, `Telegram ${attachment.kind} received: ${downloaded.path}`);
             await runWithPendingAnimation(token, ctx.chat.id, async (helpers) => {
                 return {
-                    chunks: await routeTelegramWorkLoop(bridge, botId, chatId, message, `Telegram ${attachment.kind} request`, helpers, autoContinue, memoryService, sanitizeAttachmentResponseBlocks),
+                    chunks: await routeTelegramWorkLoop(bridge, botId, chatId, message, `Telegram ${attachment.kind} request`, botManagement, helpers, autoContinue, memoryService, sanitizeAttachmentResponseBlocks),
                 };
             });
             return;
@@ -895,7 +872,7 @@ ${bridge.formatStatus(mapping)}`);
             await bridge.logSystem(botId, chatId, `Telegram ${attachmentKind} received: ${downloaded.path}`);
             await runWithPendingAnimation(token, ctx.chat.id, async (helpers) => {
                 return {
-                    chunks: await routeTelegramWorkLoop(bridge, botId, chatId, message, `Telegram ${attachmentKind} request`, helpers, autoContinue, memoryService, sanitizeAttachmentResponseBlocks),
+                    chunks: await routeTelegramWorkLoop(bridge, botId, chatId, message, `Telegram ${attachmentKind} request`, botManagement, helpers, autoContinue, memoryService, sanitizeAttachmentResponseBlocks),
                 };
             });
             return;
@@ -1148,7 +1125,7 @@ async function runWithPendingAnimation(botToken, chatId, task) {
         }
     }
 }
-async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, helpers, autoContinue, memoryService, transform = (blocks) => blocks) {
+async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botManagement, helpers, autoContinue, memoryService, transform = (blocks) => blocks) {
     const currentSession = await bridge.status(botId, chatId);
     const sessionId = currentSession?.session.sessionId;
     if (currentSession) {
@@ -1180,154 +1157,164 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, help
         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.`);
     };
-    for (let turn = 1;; turn += 1) {
-        if (typeof maxTurns === "number" && maxTurns > 0 && turn > maxTurns) {
-            const limitMessage = `Automatic continue limit (${maxTurns}) reached before a final result.`;
-            await bridge.logSystem(botId, chatId, limitMessage);
-            autoContinue.clear(botId, chatId, sessionId);
-            return [limitMessage];
-        }
-        if (autoContinue.isStopRequested(botId, chatId, sessionId)) {
-            const stopMessage = "Automatic continuation stopped.";
-            await bridge.logSystem(botId, chatId, stopMessage);
-            autoContinue.clear(botId, chatId, sessionId);
-            return [stopMessage];
-        }
-        await ensureStillBound(`turn ${turn} start`);
-        const turnLabel = `${label} turn ${turn}`;
-        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 ensureStillBound(`${turnLabel} response`);
-            const parsed = parseReportResponses(bridge.formatResponses(responses), transform);
-            await bridge.logSystem(botId, chatId, `${turnLabel} returned ${parsed.kind}.`);
-            emptyResponseRetryCount = 0;
-            retryableErrorCount = 0;
-            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.",
+    if (currentSession) {
+        await botManagement.markProviderRunning(botId, sessionId);
+    }
+    try {
+        for (let turn = 1;; turn += 1) {
+            if (typeof maxTurns === "number" && maxTurns > 0 && turn > maxTurns) {
+                const limitMessage = `Automatic continue limit (${maxTurns}) reached before a final result.`;
+                await bridge.logSystem(botId, chatId, limitMessage);
+                autoContinue.clear(botId, chatId, sessionId);
+                return [limitMessage];
+            }
+            if (autoContinue.isStopRequested(botId, chatId, sessionId)) {
+                const stopMessage = "Automatic continuation stopped.";
+                await bridge.logSystem(botId, chatId, stopMessage);
+                autoContinue.clear(botId, chatId, sessionId);
+                return [stopMessage];
+            }
+            await ensureStillBound(`turn ${turn} start`);
+            const turnLabel = `${label} turn ${turn}`;
+            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 ensureStillBound(`${turnLabel} response`);
+                const parsed = parseReportResponses(bridge.formatResponses(responses), transform);
+                await bridge.logSystem(botId, chatId, `${turnLabel} returned ${parsed.kind}.`);
+                emptyResponseRetryCount = 0;
+                retryableErrorCount = 0;
+                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];
+                        }
+                    }
+                    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);
+                        autoContinue.clear(botId, chatId, sessionId);
+                        return [stopMessage];
+                    }
+                    prompt = appendManagedContext(REPORT_CONTINUE_PROMPT, managedContext);
+                    continue;
+                }
+                if (parsed.kind === "result") {
+                    untaggedIntentRetryCount = 0;
+                    const resultText = parsed.chunks.join("\n");
+                    const evidenceIssue = classifyMissingResultEvidence(resultText);
+                    if (evidenceIssue && missingEvidenceRetryCount < 1) {
+                        missingEvidenceRetryCount += 1;
+                        const retryMessage = `${turnLabel} returned a result without required evidence: ${evidenceIssue}`;
+                        await bridge.logSystem(botId, chatId, retryMessage);
+                        prompt = appendManagedContext(formatMissingEvidenceRetryPrompt(resultText, evidenceIssue), managedContext);
+                        continue;
+                    }
+                    if (evidenceIssue) {
+                        const blockedMessage = [
+                            "Provider reported a completed result without concrete evidence after a retry.",
+                            `Reason: ${evidenceIssue}`,
+                            "Automatic continuation stopped so the work is not accepted on an unsupported claim.",
                         ].join("\n");
-                        await bridge.logSystem(botId, chatId, repeatedMessage);
+                        await bridge.logSystem(botId, chatId, blockedMessage);
                         autoContinue.clear(botId, chatId, sessionId);
-                        return [repeatedMessage];
+                        return [blockedMessage];
+                    }
+                    await ensureStillBound(`${turnLabel} final delivery`);
+                    if (currentSession) {
+                        await memoryService.completeTask(currentSession.session, parsed.chunks.join("\n"));
                     }
+                    autoContinue.clear(botId, chatId, sessionId);
+                    return 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);
+                if (parsed.kind === "blocked") {
+                    untaggedIntentRetryCount = 0;
+                    missingEvidenceRetryCount = 0;
+                    await ensureStillBound(`${turnLabel} final delivery`);
                     autoContinue.clear(botId, chatId, sessionId);
-                    return [stopMessage];
+                    return parsed.chunks;
                 }
-                prompt = appendManagedContext(REPORT_CONTINUE_PROMPT, managedContext);
-                continue;
-            }
-            if (parsed.kind === "result") {
-                untaggedIntentRetryCount = 0;
-                const resultText = parsed.chunks.join("\n");
-                const evidenceIssue = classifyMissingResultEvidence(resultText);
-                if (evidenceIssue && missingEvidenceRetryCount < 1) {
-                    missingEvidenceRetryCount += 1;
-                    const retryMessage = `${turnLabel} returned a result without required evidence: ${evidenceIssue}`;
+                if (looksLikeUntaggedIntentOnlyResponse(parsed.chunks.join("\n")) && untaggedIntentRetryCount < untaggedIntentRetries) {
+                    untaggedIntentRetryCount += 1;
+                    const retryMessage = `${turnLabel} returned an untagged intent-only response; asking provider to do concrete work before replying.`;
                     await bridge.logSystem(botId, chatId, retryMessage);
-                    prompt = appendManagedContext(formatMissingEvidenceRetryPrompt(resultText, evidenceIssue), managedContext);
+                    prompt = appendManagedContext(formatUntaggedIntentRetryPrompt(parsed.chunks.join("\n")), managedContext);
                     continue;
                 }
-                if (evidenceIssue) {
-                    const blockedMessage = [
-                        "Provider reported a completed result without concrete evidence after a retry.",
-                        `Reason: ${evidenceIssue}`,
-                        "Automatic continuation stopped so the work is not accepted on an unsupported claim.",
-                    ].join("\n");
-                    await bridge.logSystem(botId, chatId, blockedMessage);
-                    autoContinue.clear(botId, chatId, sessionId);
-                    return [blockedMessage];
-                }
-                await ensureStillBound(`${turnLabel} final delivery`);
-                if (currentSession) {
-                    await memoryService.completeTask(currentSession.session, parsed.chunks.join("\n"));
-                }
+                await bridge.logSystem(botId, chatId, `${turnLabel} returned an untagged response; treating it as final output.`);
                 autoContinue.clear(botId, chatId, sessionId);
                 return parsed.chunks;
             }
-            if (parsed.kind === "blocked") {
-                untaggedIntentRetryCount = 0;
-                missingEvidenceRetryCount = 0;
-                await ensureStillBound(`${turnLabel} final delivery`);
-                autoContinue.clear(botId, chatId, sessionId);
-                return parsed.chunks;
-            }
-            if (looksLikeUntaggedIntentOnlyResponse(parsed.chunks.join("\n")) && untaggedIntentRetryCount < untaggedIntentRetries) {
-                untaggedIntentRetryCount += 1;
-                const retryMessage = `${turnLabel} returned an untagged intent-only response; asking provider to do concrete work before replying.`;
-                await bridge.logSystem(botId, chatId, retryMessage);
-                prompt = appendManagedContext(formatUntaggedIntentRetryPrompt(parsed.chunks.join("\n")), managedContext);
-                continue;
-            }
-            await bridge.logSystem(botId, chatId, `${turnLabel} returned an untagged response; treating it as final output.`);
-            autoContinue.clear(botId, chatId, sessionId);
-            return parsed.chunks;
-        }
-        catch (error) {
-            if (error instanceof SilentTelegramAbort) {
-                throw error;
-            }
-            const messageText = error instanceof Error ? error.message : "An unexpected error occurred.";
-            const retryable = classifyRetryableProviderIssue(messageText, retryableErrorDelayMs);
-            if (isProviderTimeoutError(messageText)) {
-                const timeoutMessage = formatProviderTimeoutFinalMessage(messageText);
-                console.warn(`[telegram-route] bot=${botId} chat=${chatId} ${turnLabel} timed out: ${messageText}`);
-                await bridge.logSystem(botId, chatId, `${turnLabel} timed out: ${messageText}`);
-                autoContinue.clear(botId, chatId, sessionId);
-                return [timeoutMessage];
-            }
-            if (isEmptyResponseError(messageText) && emptyResponseRetryCount < emptyResponseRetries) {
-                emptyResponseRetryCount += 1;
-                const retryMessage = `${turnLabel} returned an empty response; retrying automatic continuation (${emptyResponseRetryCount}/${emptyResponseRetries}).`;
-                console.warn(`[telegram-route] bot=${botId} chat=${chatId} ${retryMessage}`);
-                await bridge.logSystem(botId, chatId, retryMessage);
-                prompt = appendManagedContext(REPORT_CONTINUE_PROMPT, managedContext);
-                continue;
-            }
-            if (retryable && retryableErrorCount < retryableErrorRetries) {
-                retryableErrorCount += 1;
-                const retryMessage = formatRetryableProviderRetryMessage(retryable, retryableErrorCount, retryableErrorRetries);
-                console.warn(`[telegram-route] bot=${botId} chat=${chatId} ${turnLabel} retrying: ${messageText}`);
-                await bridge.logSystem(botId, chatId, `${turnLabel} retrying after temporary provider issue: ${messageText}`);
-                await helpers.reportProgress([retryMessage]);
-                if (autoContinue.isStopRequested(botId, chatId, sessionId)) {
-                    const stopMessage = "Automatic continuation stopped after the latest retry notice.";
-                    await bridge.logSystem(botId, chatId, stopMessage);
+            catch (error) {
+                if (error instanceof SilentTelegramAbort) {
+                    throw error;
+                }
+                const messageText = error instanceof Error ? error.message : "An unexpected error occurred.";
+                const retryable = classifyRetryableProviderIssue(messageText, retryableErrorDelayMs);
+                if (isProviderTimeoutError(messageText)) {
+                    const timeoutMessage = formatProviderTimeoutFinalMessage(messageText);
+                    console.warn(`[telegram-route] bot=${botId} chat=${chatId} ${turnLabel} timed out: ${messageText}`);
+                    await bridge.logSystem(botId, chatId, `${turnLabel} timed out: ${messageText}`);
                     autoContinue.clear(botId, chatId, sessionId);
-                    return [stopMessage];
+                    return [timeoutMessage];
                 }
-                await sleep(retryable.retryAfterMs);
-                prompt = appendManagedContext(REPORT_CONTINUE_PROMPT, managedContext);
-                continue;
-            }
-            console.error(`[telegram-route] bot=${botId} chat=${chatId} ${turnLabel} failed: ${messageText}`, error);
-            await bridge.logSystem(botId, chatId, `${turnLabel} failed: ${messageText}`);
-            autoContinue.clear(botId, chatId, sessionId);
-            if (retryable) {
-                return [formatRetryableProviderFinalMessage(retryable)];
-            }
-            if (isEmptyResponseError(messageText) && deliveredProgressCount > 0) {
-                return [
-                    "The last progress report was delivered, but the follow-up provider response came back empty. Automatic continuation stopped here.",
-                    "Send a new message such as `continue` to resume the same session from the latest state.",
-                ];
+                if (isEmptyResponseError(messageText) && emptyResponseRetryCount < emptyResponseRetries) {
+                    emptyResponseRetryCount += 1;
+                    const retryMessage = `${turnLabel} returned an empty response; retrying automatic continuation (${emptyResponseRetryCount}/${emptyResponseRetries}).`;
+                    console.warn(`[telegram-route] bot=${botId} chat=${chatId} ${retryMessage}`);
+                    await bridge.logSystem(botId, chatId, retryMessage);
+                    prompt = appendManagedContext(REPORT_CONTINUE_PROMPT, managedContext);
+                    continue;
+                }
+                if (retryable && retryableErrorCount < retryableErrorRetries) {
+                    retryableErrorCount += 1;
+                    const retryMessage = formatRetryableProviderRetryMessage(retryable, retryableErrorCount, retryableErrorRetries);
+                    console.warn(`[telegram-route] bot=${botId} chat=${chatId} ${turnLabel} retrying: ${messageText}`);
+                    await bridge.logSystem(botId, chatId, `${turnLabel} retrying after temporary provider issue: ${messageText}`);
+                    await helpers.reportProgress([retryMessage]);
+                    if (autoContinue.isStopRequested(botId, chatId, sessionId)) {
+                        const stopMessage = "Automatic continuation stopped after the latest retry notice.";
+                        await bridge.logSystem(botId, chatId, stopMessage);
+                        autoContinue.clear(botId, chatId, sessionId);
+                        return [stopMessage];
+                    }
+                    await sleep(retryable.retryAfterMs);
+                    prompt = appendManagedContext(REPORT_CONTINUE_PROMPT, managedContext);
+                    continue;
+                }
+                console.error(`[telegram-route] bot=${botId} chat=${chatId} ${turnLabel} failed: ${messageText}`, error);
+                await bridge.logSystem(botId, chatId, `${turnLabel} failed: ${messageText}`);
+                autoContinue.clear(botId, chatId, sessionId);
+                if (retryable) {
+                    return [formatRetryableProviderFinalMessage(retryable)];
+                }
+                if (isEmptyResponseError(messageText) && deliveredProgressCount > 0) {
+                    return [
+                        "The last progress report was delivered, but the follow-up provider response came back empty. Automatic continuation stopped here.",
+                        "Send a new message such as `continue` to resume the same session from the latest state.",
+                    ];
+                }
+                throw error;
             }
-            throw error;
+        }
+    }
+    finally {
+        if (currentSession) {
+            await botManagement.markProviderIdle(botId, sessionId);
         }
     }
 }
@@ -1542,7 +1529,7 @@ function formatMissingEvidenceRetryPrompt(lastResponse, issue) {
     ].join("\n");
 }
 function isEmptyResponseError(message) {
-    return /empty response/i.test(message);
+    return /empty response|failed without any output|without stdout\/stderr/i.test(message);
 }
 function looksLikeBlockedBody(text) {
     if (!text.trim()) {

package/dist/config.js

@@ -135,12 +135,11 @@ export const config = {
     telegramPollingBackoffMaxMs: readTimeout("TELEGRAM_POLLING_BACKOFF_MAX_MS", 900_000),
     telegramPollingMaxConcurrency: readTimeout("TELEGRAM_POLLING_MAX_CONCURRENCY", 3),
     telegramSchedulerTickMs: readTimeout("TELEGRAM_SCHEDULER_TICK_MS", 1000),
-    telegramTieredPollingMinBots: readTimeout("TELEGRAM_TIERED_POLLING_MIN_BOTS", 4),
+    telegramTieredPollingMinBots: readTimeout("TELEGRAM_TIERED_POLLING_MIN_BOTS", 5),
     telegramActivePollIntervalMs: readTimeout("TELEGRAM_ACTIVE_POLL_INTERVAL_MS", 3000),
-    telegramIdlePollIntervalMs: readTimeout("TELEGRAM_IDLE_POLL_INTERVAL_MS", 30_000),
-    telegramColdPollIntervalMs: readTimeout("TELEGRAM_COLD_POLL_INTERVAL_MS", 300_000),
-    telegramActiveIdleMs: readTimeout("TELEGRAM_ACTIVE_IDLE_MS", 1_800_000),
-    telegramColdIdleMs: readTimeout("TELEGRAM_COLD_IDLE_MS", 21_600_000),
+    telegramRunningPollIntervalMs: readTimeout("TELEGRAM_RUNNING_POLL_INTERVAL_MS", 60_000),
+    telegramSecondaryPollIntervalMs: readTimeout("TELEGRAM_SECONDARY_POLL_INTERVAL_MS", 60_000),
+    telegramTertiaryPollIntervalMs: readTimeout("TELEGRAM_TERTIARY_POLL_INTERVAL_MS", 180_000),
     telegramOwnerId: readOptional("TELEGRAM_OWNER_ID"),
     telegramMessageBatchMs: readNonNegativeTimeout("TELEGRAM_MESSAGE_BATCH_MS", 1500),
     telegramTypingIntervalMs: readTimeout("TELEGRAM_TYPING_INTERVAL_MS", 10_000),

package/dist/index.js

@@ -15,6 +15,7 @@ import { BotManagementService } from "./services/bot-management-service.js";
 import { LocalUiService } from "./services/local-ui-service.js";
 import { AgentMemoryService } from "./services/agent-memory-service.js";
 import { BotPollingStateService } from "./services/bot-polling-state-service.js";
+import { computePolicyPollIntervalMs, computeRecentMessageRanks } from "./services/polling-policy.js";
 import { terminateAllSpawnedExecutions } from "./adapters/windows-shell.js";
 import { setTelegramCommandMenu } from "./telegram-command-menu.js";
 const execFileAsync = promisify(execFile);
@@ -140,10 +141,6 @@ async function startManualPollingScheduler(bots) {
     const runtimeStates = new Map();
     const botIds = pollingBots.map((bot) => String(bot.botInfo.id));
     await botPollingState.prune(botIds);
-    const explicitMainBotId = process.env.TELEGRAM_MAIN_BOT_ID?.trim();
-    const mainBotId = explicitMainBotId && botIds.includes(explicitMainBotId)
-        ? explicitMainBotId
-        : botIds[0];
     for (const [index, bot] of pollingBots.entries()) {
         const botId = String(bot.botInfo.id);
         runtimeStates.set(botId, {
@@ -162,32 +159,37 @@ async function startManualPollingScheduler(bots) {
     while (true) {
         const now = Date.now();
         let activePolls = [...runtimeStates.values()].filter((state) => state.inFlight).length;
-        for (const bot of pollingBots) {
-            if (activePolls >= config.telegramPollingMaxConcurrency) {
-                break;
-            }
+        const pollingStates = await botPollingState.list();
+        const rankByBotId = computeRecentMessageRanks(botIds, pollingStates);
+        const dueBots = pollingBots
+            .map((bot) => {
             const botId = String(bot.botInfo.id);
             const runtime = runtimeStates.get(botId);
-            if (!runtime || runtime.inFlight) {
-                continue;
-            }
-            const state = await botPollingState.get(botId, bot.botInfo.username);
-            const isMain = botId === mainBotId;
-            if (!isMain && state.sleepMode === "deep") {
-                continue;
-            }
-            const nextPollAt = state.nextPollAt ? Date.parse(state.nextPollAt) : 0;
-            if (Number.isFinite(nextPollAt) && nextPollAt > now) {
-                continue;
+            const state = pollingStates[botId];
+            const nextPollAt = state?.nextPollAt ? Date.parse(state.nextPollAt) : 0;
+            return {
+                bot,
+                botId,
+                runtime,
+                state,
+                rank: rankByBotId.get(botId) ?? pollingBots.length,
+                nextPollAt: Number.isFinite(nextPollAt) ? nextPollAt : 0,
+            };
+        })
+            .filter((entry) => entry.runtime && !entry.runtime.inFlight && entry.nextPollAt <= now)
+            .sort((left, right) => left.nextPollAt - right.nextPollAt || left.rank - right.rank);
+        for (const entry of dueBots) {
+            if (activePolls >= config.telegramPollingMaxConcurrency) {
+                break;
             }
-            runtime.inFlight = true;
+            entry.runtime.inFlight = true;
             activePolls += 1;
-            void pollTelegramBot(bot, runtime, {
-                isMain,
+            void pollTelegramBot(entry.bot, entry.runtime, {
                 totalBots: pollingBots.length,
-                lastMessageAt: state.lastMessageAt,
+                botRank: entry.rank,
+                state: entry.state,
             }).finally(() => {
-                runtime.inFlight = false;
+                entry.runtime.inFlight = false;
             });
         }
         await sleep(config.telegramSchedulerTickMs);
@@ -233,8 +235,20 @@ async function pollTelegramBot(pollingBot, runtime, options) {
             }
             runtime.offset = orderedUpdates[orderedUpdates.length - 1].update_id + 1;
         }
-        const lastMessageAt = orderedUpdates.some(hasMessagePayload) ? new Date(now).toISOString() : options.lastMessageAt;
-        const nextPollAt = now + computePolicyPollIntervalMs(options.isMain, options.totalBots, lastMessageAt, now);
+        const receivedMessage = orderedUpdates.some(hasMessagePayload);
+        const lastMessageAt = receivedMessage ? new Date(now).toISOString() : options.state?.lastMessageAt;
+        const nextPollAt = now + computePolicyPollIntervalMs(options.totalBots, receivedMessage ? 1 : options.botRank, {
+            ...options.state,
+            botId,
+            consecutiveFailures: options.state?.consecutiveFailures ?? runtime.consecutiveFailures,
+            lastMessageAt,
+        }, {
+            tieredPollingMinBots: config.telegramTieredPollingMinBots,
+            activePollIntervalMs: config.telegramActivePollIntervalMs,
+            runningPollIntervalMs: config.telegramRunningPollIntervalMs,
+            secondaryPollIntervalMs: config.telegramSecondaryPollIntervalMs,
+            tertiaryPollIntervalMs: config.telegramTertiaryPollIntervalMs,
+        });
         await botPollingState.recordPoll(botId, {
             username: pollingBot.botInfo.username,
             lastPollAt: new Date(now).toISOString(),
@@ -271,22 +285,6 @@ async function pollTelegramBot(pollingBot, runtime, options) {
         });
     }
 }
-function computePolicyPollIntervalMs(isMain, totalBots, lastMessageAt, now) {
-    if (isMain || totalBots < config.telegramTieredPollingMinBots) {
-        return config.telegramActivePollIntervalMs;
-    }
-    const lastMessageTime = lastMessageAt ? Date.parse(lastMessageAt) : undefined;
-    const idleMs = lastMessageTime && Number.isFinite(lastMessageTime)
-        ? now - lastMessageTime
-        : Number.POSITIVE_INFINITY;
-    if (idleMs <= config.telegramActiveIdleMs) {
-        return config.telegramActivePollIntervalMs;
-    }
-    if (idleMs <= config.telegramColdIdleMs) {
-        return config.telegramIdlePollIntervalMs;
-    }
-    return config.telegramColdPollIntervalMs;
-}
 function hasMessagePayload(update) {
     return Boolean(update.message || update.edited_message || update.channel_post);
 }