appback-remoteagent 0.13.21 → 0.14.1

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,31 @@
+export function computeRecentMessageRanks(botIds, states) {
+    const ranked = botIds
+        .map((botId) => ({
+        botId,
+        timestamp: parseStateTime(states[botId]?.lastMessageAt) ?? 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/docs/RELEASING.md

@@ -28,7 +28,7 @@ A release is only considered complete when all of the following are done in orde
 4. Run `npm run build`
 5. Commit the completed work
 6. Push `main` to `origin/main`
-7. Publish `appback-remoteagent@<version>` to npm
+7. Publish `appback-remoteagent@<version>` to npm from server 30's npm credentials
 8. Install that exact npm version on server 30 and server 26
 9. Restart `remoteagent.service` on each target if runtime code changed
 10. Verify the relevant runtime path, logs, or Telegram behavior on each target
@@ -64,18 +64,65 @@ git status
 git add -A
 git commit -m "Release 0.12.3"
 git push origin main
-npm publish
+npm pack
 ```
 
-Typical target deployment sequence for server 30 and server 26:
+## npm publish procedure
+
+Use this package-specific path for `appback-remoteagent`.
+
+Do not publish this package from machine 21 with the `21token`. That token is scoped for `@appbackhub` packages and cannot publish the unscoped `appback-remoteagent` package. It can authenticate but `npm publish` fails with:
+
+```text
+403 Forbidden - You may not perform that action with these credentials.
+```
+
+The successful publish path is:
 
 ```bash
-VERSION=0.13.0
+VERSION=0.14.0
+npm pack
+scp appback-remoteagent-$VERSION.tgz au2223@192.168.0.30:/tmp/appback-remoteagent-$VERSION.tgz
+ssh au2223@192.168.0.30 "bash -lc 'npm publish /tmp/appback-remoteagent-$VERSION.tgz'"
+npm view appback-remoteagent version
+ssh au2223@192.168.0.30 'bash -lc "npm view appback-remoteagent version"'
+rm -f appback-remoteagent-$VERSION.tgz
+ssh au2223@192.168.0.30 "rm -f /tmp/appback-remoteagent-$VERSION.tgz"
+```
+
+If registry caching briefly returns the previous version after publish, wait a few seconds and rerun `npm view appback-remoteagent version` before installing to servers.
+
+## Target deployment sequence
+
+Server 30 uses a systemd service:
+
+```bash
+VERSION=0.14.0
+ssh au2223@192.168.0.30 "VERSION=$VERSION bash -s" <<'REMOTE'
+set -euo pipefail
+sudo -n env "PATH=$PATH" npm install -g appback-remoteagent@$VERSION
+/home/au2223/.nvm/versions/node/v22.22.0/bin/remoteagent-install
+sudo -n systemctl restart remoteagent
+systemctl is-active remoteagent
+journalctl -u remoteagent --since '2 minutes ago' --no-pager
+REMOTE
+```
+
+Server 26 currently uses user-level start/stop scripts, not a systemd `remoteagent.service`:
+
+```bash
+VERSION=0.14.0
+ssh ospadmin@192.168.0.26 "VERSION=$VERSION bash -s" <<'REMOTE'
+set -euo pipefail
 npm install -g appback-remoteagent@$VERSION
 remoteagent-install
-sudo systemctl restart remoteagent
-systemctl is-active remoteagent
-journalctl -u remoteagent --since "2 minutes ago" --no-pager
+~/.remoteagent/stop-remoteagent.sh || true
+sleep 2
+~/.remoteagent/start-remoteagent.sh
+sleep 3
+pgrep -af "appback-remoteagent/dist/index.js"
+tail -80 ~/.remoteagent/logs/agent.log
+REMOTE
 ```
 
 ## Other Runtime Follow-up

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.13.21",
+  "version": "0.14.1",
   "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.