appback-remoteagent 0.13.21 → 0.14.0

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,6 +159,8 @@ async function startManualPollingScheduler(bots) {
     while (true) {
         const now = Date.now();
         let activePolls = [...runtimeStates.values()].filter((state) => state.inFlight).length;
+        const pollingStates = await botPollingState.list();
+        const rankByBotId = computeRecentMessageRanks(botIds, pollingStates);
         for (const bot of pollingBots) {
             if (activePolls >= config.telegramPollingMaxConcurrency) {
                 break;
@@ -172,10 +171,6 @@ async function startManualPollingScheduler(bots) {
                 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;
@@ -183,9 +178,9 @@ async function startManualPollingScheduler(bots) {
             runtime.inFlight = true;
             activePolls += 1;
             void pollTelegramBot(bot, runtime, {
-                isMain,
                 totalBots: pollingBots.length,
-                lastMessageAt: state.lastMessageAt,
+                botRank: rankByBotId.get(botId) ?? pollingBots.length,
+                state,
             }).finally(() => {
                 runtime.inFlight = false;
             });
@@ -233,8 +228,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 +278,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);
 }

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

@@ -29,57 +29,30 @@ export class BotManagementService {
         if (bots.length === 0) {
             return "No Telegram bots are configured.";
         }
-        return this.formatBots(bots, env.mainBotId, await this.pollingState.list());
+        return this.formatBots(bots, await this.pollingState.list());
     }
     async formatCurrentBotSummary(currentBotId) {
         const env = await this.readEnvConfig();
         const bots = this.zipBots(env.tokens, env.usernames);
         const current = this.resolveBotSelector(bots, currentBotId);
-        const main = this.resolveMainBot(bots, env.mainBotId);
         const currentLabel = current ? `@${current.username} (${current.id})` : currentBotId;
-        const mainLabel = main ? `@${main.username} (${main.id})` : "not configured";
-        const role = current && main && current.id === main.id ? "main" : "sub";
         const states = await this.pollingState.list();
         const currentState = current ? states[String(current.id)] : undefined;
         return [
-            `bot: ${currentLabel}${current ? ` [${role}]` : ""}`,
-            `mainBot: ${mainLabel}`,
+            `bot: ${currentLabel}`,
             `botCount: ${bots.length}`,
-            `sleep: ${this.pollingState.formatMode(String(current?.id ?? currentBotId), role === "main", currentState)}`,
+            `pollingState: ${this.pollingState.formatMode(currentState)}`,
         ].join("\n");
     }
-    async sleepBot(selector, currentBotId) {
-        const env = await this.readEnvConfig();
-        const bots = this.zipBots(env.tokens, env.usernames);
-        if (bots.length === 0) {
-            throw new Error("No Telegram bots are configured.");
-        }
-        const mainBotId = this.resolveMainBotId(bots, env.mainBotId);
-        const target = selector.trim()
-            ? this.resolveBotSelector(bots, selector)
-            : this.resolveBotSelector(bots, currentBotId);
-        if (!target) {
-            throw new Error("Usage: /sleep <bot>");
-        }
-        if (String(target.id) === mainBotId) {
-            throw new Error(`@${target.username} is the main bot and cannot enter deep sleep.`);
-        }
-        await this.pollingState.setSleepMode(String(target.id), "deep", target.username);
-        return {
-            message: `Set @${target.username} to deep sleep.\n\nIt remains configured. RemoteAgent will stop polling it until /wake is used from an awake bot.`,
-        };
+    async markProviderRunning(botId, sessionId) {
+        const bot = await this.findConfiguredBot(botId);
+        const pollingBotId = bot ? String(bot.id) : botId;
+        await this.pollingState.markRunning(pollingBotId, sessionId, bot?.username);
     }
-    async wakeBot(selector) {
-        const env = await this.readEnvConfig();
-        const bots = this.zipBots(env.tokens, env.usernames);
-        const target = this.resolveBotSelector(bots, selector);
-        if (!target) {
-            throw new Error("Usage: /wake <bot>");
-        }
-        await this.pollingState.setSleepMode(String(target.id), "awake", target.username);
-        return {
-            message: `Woke @${target.username}. It will be polled again.`,
-        };
+    async markProviderIdle(botId, sessionId) {
+        const bot = await this.findConfiguredBot(botId);
+        const pollingBotId = bot ? String(bot.id) : botId;
+        await this.pollingState.markIdle(pollingBotId, sessionId, bot?.username);
     }
     async getPendingOperationNotice() {
         const pending = await this.readPendingOperation();
@@ -109,7 +82,6 @@ export class BotManagementService {
         }
         const tokens = [...env.tokens, trimmed];
         const usernames = [...env.usernames, target.username];
-        const mainBotId = this.resolveMainBotId(this.zipBots(tokens, usernames), env.mainBotId);
         const backupEnvPath = await this.backupEnv();
         const pending = {
             version: 1,
@@ -128,7 +100,7 @@ export class BotManagementService {
         };
         try {
             await this.writePendingOperation(pending);
-            await this.writeEnvConfig(env.lines, tokens, usernames, mainBotId);
+            await this.writeEnvConfig(env.lines, tokens, usernames);
             await this.launchRestartJob();
         }
         catch (error) {
@@ -162,10 +134,6 @@ export class BotManagementService {
         const remainingBots = bots.filter((value) => value.token !== target.token);
         const tokens = remainingBots.map((value) => value.token);
         const usernames = remainingBots.map((value) => value.username);
-        const currentMain = this.resolveMainBot(bots, env.mainBotId);
-        const nextMainBotId = currentMain?.token === target.token
-            ? this.promoteMainBotAfterRemoval(bots, target)?.id.toString()
-            : this.resolveMainBotId(remainingBots, env.mainBotId);
         const replyToken = tokens.includes(sourceBotToken) ? sourceBotToken : tokens[0];
         const notifyViaUsername = remainingBots.find((bot) => bot.token === replyToken)?.username;
         const backupEnvPath = await this.backupEnv();
@@ -186,7 +154,7 @@ export class BotManagementService {
         };
         try {
             await this.writePendingOperation(pending);
-            await this.writeEnvConfig(env.lines, tokens, usernames, nextMainBotId);
+            await this.writeEnvConfig(env.lines, tokens, usernames);
             await this.launchRestartJob();
         }
         catch (error) {
@@ -194,43 +162,16 @@ export class BotManagementService {
             await this.clearPendingOperation().catch(() => undefined);
             throw error;
         }
-        const promoted = nextMainBotId ? remainingBots.find((bot) => String(bot.id) === nextMainBotId) : undefined;
-        const mainLine = promoted && currentMain?.token === target.token
-            ? `Main bot will be promoted to @${promoted.username} (${promoted.id}).`
-            : undefined;
         const notifyLine = replyToken === sourceBotToken || !notifyViaUsername
             ? "The runtime will restart once and then report the result here."
             : `The runtime will restart once and then report the result through @${notifyViaUsername}.`;
         return {
             message: [
                 `Applying bot removal for @${target.username} (${target.id}).`,
-                mainLine,
                 notifyLine,
             ].filter(Boolean).join("\n\n"),
         };
     }
-    async setMainBot(selector) {
-        await this.ensureSupported();
-        await this.assertNoPendingOperation();
-        const trimmed = selector.trim();
-        if (!trimmed) {
-            throw new Error("Usage: /bot main <number|@username|id>");
-        }
-        const env = await this.readEnvConfig();
-        const bots = this.zipBots(env.tokens, env.usernames);
-        const target = this.resolveBotSelector(bots, trimmed);
-        if (!target) {
-            throw new Error(`Bot was not found: ${trimmed}`);
-        }
-        await this.writeEnvConfig(env.lines, env.tokens, env.usernames, String(target.id));
-        return {
-            message: [
-                `Set main bot to @${target.username} (${target.id}).`,
-                "",
-                this.formatBots(bots, String(target.id)),
-            ].join("\n"),
-        };
-    }
     async doctorBots(sourceBotId, sourceBotToken, chatId) {
         await this.ensureSupported();
         await this.assertNoPendingOperation();
@@ -273,7 +214,6 @@ export class BotManagementService {
         }
         const tokens = alive.map((bot) => bot.token);
         const usernames = alive.map((bot) => bot.username);
-        const mainBotId = this.resolveMainBotId(alive, env.mainBotId);
         const replyToken = tokens.includes(sourceBotToken) ? sourceBotToken : tokens[0];
         const notifyViaUsername = alive.find((bot) => bot.token === replyToken)?.username;
         const backupEnvPath = await this.backupEnv();
@@ -294,7 +234,7 @@ export class BotManagementService {
         };
         try {
             await this.writePendingOperation(pending);
-            await this.writeEnvConfig(env.lines, tokens, usernames, mainBotId);
+            await this.writeEnvConfig(env.lines, tokens, usernames);
             await this.launchRestartJob();
         }
         catch (error) {
@@ -345,9 +285,8 @@ export class BotManagementService {
         }
         const env = await this.readEnvConfig().catch(() => undefined);
         const bots = env ? this.zipBots(env.tokens, env.usernames) : [];
-        const mainBotId = this.resolveMainBotId(bots, env?.mainBotId);
         const listLines = bots.length > 0
-            ? this.formatBotListLines(bots, mainBotId).map((line) => `- ${line.replace(/^\d+\.\s*/, "")}`)
+            ? this.formatBotListLines(bots).map((line) => `- ${line.replace(/^\d+\.\s*/, "")}`)
             : ["- none"];
         const lines = pending.status === "rolled_back"
             ? [
@@ -485,7 +424,6 @@ export class BotManagementService {
         const tokenLine = lines.find((line) => line.startsWith("TELEGRAM_BOT_TOKENS="));
         const singleTokenLine = lines.find((line) => line.startsWith("TELEGRAM_BOT_TOKEN="));
         const usernameLine = lines.find((line) => line.startsWith("TELEGRAM_BOT_USERNAMES="));
-        const mainBotLine = lines.find((line) => line.startsWith("TELEGRAM_MAIN_BOT_ID="));
         const tokens = tokenLine
             ? this.parseCsv(tokenLine.slice("TELEGRAM_BOT_TOKENS=".length))
             : singleTokenLine
@@ -497,17 +435,14 @@ export class BotManagementService {
             lines,
             tokens,
             usernames,
-            mainBotId: mainBotLine?.slice("TELEGRAM_MAIN_BOT_ID=".length).trim() || undefined,
         };
     }
-    async writeEnvConfig(originalLines, tokens, usernames, mainBotId) {
+    async writeEnvConfig(originalLines, tokens, usernames) {
         const normalizedUsernames = await this.normalizeUsernamesFromTelegram(tokens, usernames);
-        const normalizedMainBotId = this.resolveMainBotId(this.zipBots(tokens, normalizedUsernames), mainBotId);
         const nextLines = [];
         let hasMulti = false;
         let hasSingle = false;
         let hasUsernames = false;
-        let hasMainBot = false;
         for (const line of originalLines) {
             if (line.startsWith("TELEGRAM_BOT_TOKENS=")) {
                 nextLines.push(`TELEGRAM_BOT_TOKENS=${tokens.join(",")}`);
@@ -525,10 +460,6 @@ export class BotManagementService {
                 continue;
             }
             if (line.startsWith("TELEGRAM_MAIN_BOT_ID=")) {
-                if (normalizedMainBotId) {
-                    nextLines.push(`TELEGRAM_MAIN_BOT_ID=${normalizedMainBotId}`);
-                }
-                hasMainBot = true;
                 continue;
             }
             nextLines.push(line);
@@ -542,9 +473,6 @@ export class BotManagementService {
         if (!hasUsernames) {
             nextLines.unshift(`TELEGRAM_BOT_USERNAMES=${normalizedUsernames.join(",")}`);
         }
-        if (!hasMainBot && normalizedMainBotId) {
-            nextLines.unshift(`TELEGRAM_MAIN_BOT_ID=${normalizedMainBotId}`);
-        }
         const output = `${nextLines.filter((line, index, all) => !(index === all.length - 1 && line === "")).join("\n")}\n`;
         await fs.writeFile(this.envPath, output, "utf8");
     }
@@ -589,27 +517,24 @@ export class BotManagementService {
             || String(bot.id) === withoutAt
             || bot.token === normalized);
     }
-    formatBots(bots, mainBotId, states = {}) {
+    formatBots(bots, states = {}) {
         if (bots.length === 0) {
             return "No Telegram bots are configured.";
         }
         return [
             `Configured bots (${bots.length})`,
-            ...this.formatBotListLines(bots, mainBotId, states),
+            ...this.formatBotListLines(bots, states),
         ].join("\n");
     }
-    formatBotListLines(bots, explicitMainBotId, states = {}) {
-        const mainBotId = this.resolveMainBotId(bots, explicitMainBotId);
+    formatBotListLines(bots, states = {}) {
         return bots.map((bot, index) => {
             const botId = String(bot.id);
-            const isMain = botId === mainBotId;
             const state = states[botId];
             const details = [
-                `[${isMain ? "main" : "sub"}]`,
-                this.pollingState.formatMode(botId, isMain, state),
+                this.pollingState.formatMode(state),
                 state?.lastMessageAt ? `lastMessage=${this.formatAge(state.lastMessageAt)}` : undefined,
                 state?.lastPollAt ? `lastPoll=${this.formatAge(state.lastPollAt)}` : undefined,
-                state?.nextPollAt && state.sleepMode !== "deep" ? `nextPoll=${this.formatAge(state.nextPollAt)}` : undefined,
+                state?.nextPollAt ? `nextPoll=${this.formatAge(state.nextPollAt)}` : undefined,
                 state?.consecutiveFailures ? `failures=${state.consecutiveFailures}` : undefined,
             ].filter(Boolean).join(" ");
             return `${index + 1}. @${bot.username} (${bot.id}) ${details}`;
@@ -634,24 +559,13 @@ export class BotManagementService {
         }
         return `${Math.round(absMs / 86_400_000)}d ${suffix}`;
     }
-    resolveMainBot(bots, mainBotId) {
-        if (bots.length === 0) {
-            return undefined;
-        }
-        const explicit = mainBotId ? bots.find((bot) => String(bot.id) === mainBotId) : undefined;
-        return explicit ?? bots[0];
-    }
-    resolveMainBotId(bots, mainBotId) {
-        return this.resolveMainBot(bots, mainBotId)?.id.toString();
-    }
-    promoteMainBotAfterRemoval(bots, removed) {
-        const remaining = bots.filter((bot) => bot.token !== removed.token);
-        return remaining[removed.index] ?? remaining[0];
-    }
     async listConfiguredBots() {
         const env = await this.readEnvConfig();
         return this.zipBots(env.tokens, env.usernames);
     }
+    async findConfiguredBot(botId) {
+        return this.resolveBotSelector(await this.listConfiguredBots(), botId);
+    }
     tokenId(token) {
         return Number.parseInt(token.split(":", 1)[0] ?? "0", 10);
     }

package/dist/services/bot-polling-state-service.js

@@ -19,7 +19,6 @@ export class BotPollingStateService {
         const current = state.bots[botId] ?? {
             botId,
             username,
-            sleepMode: "awake",
             consecutiveFailures: 0,
         };
         if (username && current.username !== username) {
@@ -32,30 +31,49 @@ export class BotPollingStateService {
     async list() {
         return { ...(await this.read()).bots };
     }
-    async setSleepMode(botId, sleepMode, username) {
+    async markRunning(botId, sessionId, username) {
         const state = await this.read();
         const current = state.bots[botId] ?? {
             botId,
             username,
-            sleepMode,
             consecutiveFailures: 0,
         };
-        current.sleepMode = sleepMode;
         if (username) {
             current.username = username;
         }
-        if (sleepMode === "awake") {
-            current.nextPollAt = new Date().toISOString();
+        const sessions = new Set(current.runningSessionIds ?? []);
+        sessions.add(sessionId || "__unknown__");
+        current.runningSessionIds = [...sessions];
+        current.lastProviderStartedAt = new Date().toISOString();
+        state.bots[botId] = current;
+        await this.writeNow();
+    }
+    async markIdle(botId, sessionId, username) {
+        const state = await this.read();
+        const current = state.bots[botId] ?? {
+            botId,
+            username,
+            consecutiveFailures: 0,
+        };
+        if (username) {
+            current.username = username;
+        }
+        const runningSessionIds = current.runningSessionIds ?? [];
+        if (runningSessionIds.length > 0) {
+            const key = sessionId || "__unknown__";
+            current.runningSessionIds = runningSessionIds.filter((value) => value !== key);
+        }
+        if (!current.runningSessionIds || current.runningSessionIds.length === 0) {
+            delete current.runningSessionIds;
+            current.lastProviderFinishedAt = new Date().toISOString();
         }
         state.bots[botId] = current;
         await this.writeNow();
-        return current;
     }
     async recordPoll(botId, patch) {
         const state = await this.read();
         const current = state.bots[botId] ?? {
             botId,
-            sleepMode: "awake",
             consecutiveFailures: 0,
         };
         state.bots[botId] = {
@@ -79,11 +97,8 @@ export class BotPollingStateService {
             await this.writeNow();
         }
     }
-    formatMode(botId, isMain, state) {
-        if (isMain) {
-            return "awake";
-        }
-        return state?.sleepMode === "deep" ? "deep sleep" : "awake";
+    formatMode(state) {
+        return state?.runningSessionIds && state.runningSessionIds.length > 0 ? "running" : "idle";
     }
     async flush() {
         if (this.pendingWrite) {

package/dist/services/polling-policy.js

@@ -0,0 +1,34 @@
+export function computeRecentMessageRanks(botIds, states) {
+    const ranked = botIds
+        .map((botId) => ({
+        botId,
+        timestamp: parseStateTime(states[botId]?.lastMessageAt)
+            ?? parseStateTime(states[botId]?.lastUpdateAt)
+            ?? parseStateTime(states[botId]?.lastPollAt)
+            ?? 0,
+    }))
+        .sort((left, right) => right.timestamp - left.timestamp);
+    return new Map(ranked.map((entry, index) => [entry.botId, index + 1]));
+}
+export function computePolicyPollIntervalMs(totalBots, botRank, state, policy) {
+    if (state?.runningSessionIds && state.runningSessionIds.length > 0) {
+        return policy.runningPollIntervalMs;
+    }
+    if (totalBots < policy.tieredPollingMinBots) {
+        return policy.activePollIntervalMs;
+    }
+    if (botRank <= 4) {
+        return policy.activePollIntervalMs;
+    }
+    if (botRank <= 8) {
+        return policy.secondaryPollIntervalMs;
+    }
+    return policy.tertiaryPollIntervalMs;
+}
+function parseStateTime(value) {
+    if (!value) {
+        return undefined;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : undefined;
+}

package/dist/telegram-command-menu.js

@@ -13,8 +13,6 @@ export const TELEGRAM_COMMAND_MENU = [
     { command: "batch", description: "Collect and send a multi-message batch" },
     { command: "bots", description: "List configured Telegram bots" },
     { command: "bot", description: "Manage Telegram bots" },
-    { command: "sleep", description: "Deep sleep a sub bot" },
-    { command: "wake", description: "Wake a sleeping sub bot" },
     { command: "install", description: "Install or update Codex or Claude" },
     { command: "login", description: "Run provider login flow" },
     { command: "reset", description: "Clear this chat binding" },

package/docs/BOT_POLLING_POLICY.md

@@ -0,0 +1,32 @@
+# Telegram bot polling policy
+
+RemoteAgent can run multiple Telegram bots in one runtime. Polling is the loop that asks Telegram whether each bot has new updates.
+
+## Policy
+
+When 4 or fewer bots are configured:
+
+- every bot polls every 3 seconds
+
+When 5 or more bots are configured:
+
+- the 4 most recently messaged idle bots poll every 3 seconds
+- the next 4 idle bots poll every 60 seconds
+- all remaining idle bots poll every 180 seconds
+
+When a bot has active provider work:
+
+- that bot polls every 60 seconds
+- `REPORT:progress` keeps it running
+- `REPORT:result`, `REPORT:blocked`, timeout, fatal error, or `/stop` completion returns it to idle
+
+## Removed concepts
+
+RemoteAgent no longer uses deep sleep, wake, or a special main bot for polling control. All configured bots remain reachable through polling, just at different intervals.
+
+## Operational notes
+
+- `/bots` shows each configured bot and its polling state.
+- `/bot doctor` removes bots that Telegram reports as permanently dead.
+- `/bot remove <username|id>` removes a configured bot from the runtime.
+- Polling state is stored by Telegram bot id, not by display order.

package/docs/OPERATIONS.md

@@ -35,9 +35,9 @@ Current production bot ownership is intentionally split:
 Do not run the same Telegram bot token from multiple runtimes at the same time.
 Bot polling conflicts are treated as incidents, not harmless warnings.
 
-When a runtime has more than three configured Telegram bots, polling pressure can become operationally visible.
-Bot sleep is the planned mitigation: keep one main bot reachable and let long-idle sub bots stop polling without removing their configuration.
-See [BOT_SLEEP.md](./BOT_SLEEP.md).
+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).
 
 ## Workspace policy
 

package/docs/POLLING_POLICY_TODO.md

@@ -0,0 +1,43 @@
+# Telegram polling policy TODO
+
+## Goal
+
+Simplify multi-bot polling so RemoteAgent can keep many Telegram bots configured without deep sleep, wake commands, or a special main bot.
+
+## Required policy
+
+- If configured bot count is 4 or less, every bot polls every 3 seconds.
+- If configured bot count is 5 or more:
+  - the 4 most recently messaged idle bots poll every 3 seconds
+  - the next 4 idle bots poll every 60 seconds
+  - all remaining idle bots poll every 180 seconds
+- A bot with active provider work polls every 60 seconds.
+- `REPORT:progress` keeps the bot in running state.
+- Running state ends only after final result, blocked result, fatal error, timeout, or `/stop` completion.
+
+## Removed concepts
+
+- No deep sleep state.
+- No wake command.
+- No main bot requirement.
+- No separate sleep registry.
+
+## Steps
+
+1. Remove user-facing `/sleep`, `/wake`, and `/bot main` commands from help and command menu.
+2. Remove main/deep-sleep logic from bot management output and environment writing.
+3. Track bot provider activity as idle/running in the polling state file.
+4. Replace idle-threshold polling with rank-based polling.
+5. Update README, operations docs, and `.env.example`.
+6. Run local checks only. Do not deploy to server 30 until explicitly requested.
+
+## Local validation
+
+- `npm run check`
+- `npm run build`
+- Confirm `/bots` output no longer shows main/sub or deep sleep.
+- Confirm rank-based interval calculation is covered by a local test or deterministic helper check.
+
+## Deployment rule
+
+Server 30 deployment is intentionally out of scope for this change until the operator explicitly requests it.

package/package.json

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

package/docs/BOT_SLEEP.md

@@ -1,78 +0,0 @@
-# Telegram Bot Sleep
-
-## Why this exists
-
-RemoteAgent can run multiple Telegram bots in one runtime.
-Each active bot needs Telegram polling.
-
-Operationally, up to three active polling bots has been stable enough.
-When more than three bots are active, polling pressure and Telegram transport errors become more likely.
-
-Sleep exists to reduce polling load without deleting bot configuration.
-
-## Definitions
-
-- main bot: the control bot that stays reachable
-- sub bot: any configured bot that is not the main bot
-- awake: the bot is polled normally
-- deep sleep: the bot is configured but not polled
-
-Sleep is not removal.
-Removing a bot deletes it from runtime configuration.
-Sleeping a bot keeps the bot registered and preserves its sessions.
-
-## Policy
-
-1. The main bot must not enter deep sleep.
-2. Sub bots may enter deep sleep.
-3. The main bot can wake a sleeping sub bot.
-4. Bot doctor and sleep are separate features.
-5. Bot doctor may remove permanently invalid Telegram bots.
-6. Sleep must never remove a bot token or session state.
-7. User-facing list output should show bot role and sleep state.
-
-## Polling Strategy
-
-The intended strategy is tiered:
-
-1. recently used bots poll normally
-2. idle bots poll less often
-3. manually sleeping bots do not poll
-
-This lets frequently used agents stay responsive while long-idle agents stop consuming polling capacity.
-
-## Commands
-
-Command surface:
-
-```text
-/sleep <bot>
-/wake <bot>
-/bot main <bot>
-/bots
-/list
-```
-
-Expected behavior:
-
-- `/sleep <bot>` puts a sub bot into deep sleep
-- `/sleep` without a target may sleep the current bot only when it is not the main bot
-- `/wake <bot>` wakes a sleeping sub bot
-- `/bots` shows main/sub and awake/sleeping state
-- `/list` shows session state and bot state where relevant
-
-## Non-goals
-
-- Do not infer sleep from natural-language provider replies.
-- Do not treat sleep as `/bot remove`.
-- Do not let Codex or Claude decide which bot should be removed.
-- Do not create a separate sleep-only bot registry that can drift from configured bots.
-
-## Implementation Notes
-
-Sleep state should be keyed by stable Telegram bot id, not by display index.
-
-Display indexes are only for user convenience.
-Internal actions must resolve to bot id.
-
-The runtime should still keep one always-awake control path through the main bot.