clawgram 2.21.1 → 2.22.0

package/dist/chat-info.js

@@ -16,8 +16,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseChatInfoParams = parseChatInfoParams;
+exports.markedChatId = markedChatId;
 exports.describeChat = describeChat;
 const helpers_1 = require("./helpers");
+const normalize_1 = require("./normalize");
+const util_1 = require("./util");
 function parseChatInfoParams(params, toolContext) {
     const rawTarget = (0, helpers_1.readChatTargetParam)(params, toolContext);
     const target = typeof rawTarget === "string" ? rawTarget.trim() : "";
@@ -30,23 +33,6 @@ function parseChatInfoParams(params, toolContext) {
  * GramJS carries ids and counts as `big-integer` objects as often as native
  * numbers — the shape that once made `senderId` come back silently undefined.
  */
-function readNumber(value) {
-    if (typeof value === "number") {
-        return Number.isFinite(value) ? value : undefined;
-    }
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    const parsed = Number(String(value));
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
-function readString(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed === "" ? undefined : trimmed;
-}
 function readId(value) {
     if (value === undefined || value === null) {
         return undefined;
@@ -68,21 +54,41 @@ function resolveType(entity) {
 }
 /** A user has no title, so the displayed name is assembled from what exists. */
 function resolveUserTitle(entity) {
-    const parts = [readString(entity?.firstName), readString(entity?.lastName)].filter(Boolean);
+    const parts = [(0, util_1.readString)(entity?.firstName), (0, util_1.readString)(entity?.lastName)].filter(Boolean);
     return parts.length > 0 ? parts.join(" ") : undefined;
 }
+/**
+ * Id в той же форме, в какой его понимают конфиг и все остальные ответы.
+ *
+ * GramJS хранит `Channel.id` голым и положительным, а входящие, `dialogs`,
+ * `read`, `participants` и `topics` возвращают помеченный вид (`-100…`).
+ * `channel-info` отдавал голый, и агент на вопрос «в каком я чате» получал id,
+ * который не совпадает ни с ключами `groups`/`readChats`/`manageChats`, ни с
+ * тем, что надо передать в `send`. Подставленный обратно, он резолвится только
+ * через обход двухсот последних диалогов — а `getInputEntity("1234567890")`
+ * сначала пробуется как id ПОЛЬЗОВАТЕЛЯ (находка A6-09).
+ */
+function markedChatId(entity, raw) {
+    if (!raw)
+        return raw;
+    switch (entity?.className) {
+        case "Channel": return (0, normalize_1.toPeerChannelId)(raw);
+        case "Chat": return (0, normalize_1.toPeerChatId)(raw);
+        default: return raw;
+    }
+}
 function describeChat(entity, full) {
     const raw = entity;
     const fullChat = full;
     const type = resolveType(raw);
     const info = {
-        chatId: readId(raw?.id),
+        chatId: markedChatId(raw, readId(raw?.id)),
         type,
-        title: type === "direct" ? resolveUserTitle(raw) : readString(raw?.title),
+        title: type === "direct" ? resolveUserTitle(raw) : (0, util_1.readString)(raw?.title),
         // Not `raw.username`: an account or chat holding more than one handle keeps
         // them in `usernames[]` and leaves the legacy field empty.
         username: (0, helpers_1.resolveActiveUsername)(raw),
-        about: readString(fullChat?.about),
+        about: (0, util_1.readString)(fullChat?.about),
         pinnedMessageId: readId(fullChat?.pinnedMsgId),
     };
     if (type === "direct") {
@@ -95,6 +101,6 @@ function describeChat(entity, full) {
     }
     // The full object is fetched now; the entity may come from a cache that
     // predates the last few joins, so prefer the fresher number.
-    info.memberCount = readNumber(fullChat?.participantsCount) ?? readNumber(raw?.participantsCount);
+    info.memberCount = (0, util_1.readNumber)(fullChat?.participantsCount) ?? (0, util_1.readNumber)(raw?.participantsCount);
     return info;
 }

package/dist/cli-core.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAccountConfigFragment = buildAccountConfigFragment;
 exports.runTelegramUserbotCliFlags = runTelegramUserbotCliFlags;
 exports.runTelegramUserbotStandaloneCli = runTelegramUserbotStandaloneCli;
 const node_readline_1 = __importDefault(require("node:readline"));
@@ -34,8 +35,49 @@ function createPrompt() {
     const ask = (question) => new Promise((resolve) => {
         rl.question(question, resolve);
     });
+    /**
+     * Ввод без эха: код входа и пароль 2FA печатались в терминал как есть.
+     *
+     * Оба — учётные данные аккаунта: они остаются в прокрутке, в записи сессии
+     * терминала и в снимке экрана, который человек делает, чтобы прислать
+     * ошибку. Ниоткуда, кроме глаз рядом стоящего, они не защищены — и именно
+     * поэтому пароли нигде не эхоятся (находка A5-15).
+     *
+     * `_writeToOutput` — единственная точка, через которую readline печатает
+     * ввод; подменяем её на время вопроса и возвращаем обратно, чтобы
+     * последующие обычные вопросы снова были видны.
+     */
+    const askSecret = (question) => new Promise((resolve) => {
+        const anyRl = rl;
+        const original = anyRl._writeToOutput?.bind(rl);
+        let armed = false;
+        anyRl._writeToOutput = (text) => {
+            if (!armed) {
+                // Сам вопрос печатается — молчащая подсказка означала бы «висит».
+                original?.(text);
+                armed = true;
+                return;
+            }
+            if (text.includes("\n")) {
+                original?.("\n");
+            }
+        };
+        rl.question(question, (answer) => {
+            anyRl._writeToOutput = original;
+            resolve(answer);
+        });
+    });
     return {
         ask,
+        async askSecret(question) {
+            for (;;) {
+                const answer = (await askSecret(question)).trim();
+                if (answer) {
+                    return answer;
+                }
+                console.log("Value is required.");
+            }
+        },
         async askRequired(question) {
             for (;;) {
                 const answer = (await ask(question)).trim();
@@ -88,20 +130,29 @@ function resolveDefaultAccountId(config) {
     const firstAccountId = Object.keys(accounts).find((accountId) => accountId.trim());
     return firstAccountId?.trim() || "default";
 }
+/**
+ * Первый конфиг закрыт, а не открыт.
+ *
+ * Раньше сюда садились `allowFrom: ["*"]` и групповая запись `"*"`, а
+ * `readChats` не задавался вовсе — то есть сразу после `--auth` написать
+ * агенту в личку мог кто угодно, добавить его в группу и позвать по @ — тоже,
+ * а `read` доставал историю любого чата, в котором состоит личный аккаунт.
+ * Первый запуск не должен быть дырой, которую оператор потом закрывает
+ * (находка A5-09).
+ *
+ * `allowFrom` — сам авторизовавшийся. Если его id узнать не удалось, список
+ * пуст: закрыто для всех, и об этом печатается строка. Групповой записи нет:
+ * группы добавляются осознанно. `readChats: []` — пустой массив, а не
+ * отсутствие ключа: у него это разные вещи, и нужен именно запрет.
+ */
 function buildAccountConfigFragment(auth) {
     return {
         enabled: true,
         apiId: auth.apiId,
         apiHash: auth.apiHash,
         sessionString: auth.sessionString,
-        allowFrom: ["*"],
-        groups: {
-            "*": {
-                enabled: true,
-                groupPolicy: "mention",
-                allowFrom: ["*"],
-            },
-        },
+        allowFrom: auth.selfId ? [auth.selfId] : [],
+        readChats: [],
     };
 }
 function buildConfigFragment(accountId, auth) {
@@ -141,16 +192,30 @@ async function runTelegramAuthorization(prompt, proxy) {
     try {
         await client.start({
             phoneNumber: async () => await prompt.askRequired("Please enter your number: "),
-            password: async () => await prompt.askRequired("Please enter your password: "),
-            phoneCode: async () => await prompt.askRequired("Please enter the code you received: "),
+            password: async () => await prompt.askSecret("Please enter your password: "),
+            phoneCode: async () => await prompt.askSecret("Please enter the code you received: "),
             onError: (error) => {
                 console.log(error);
             },
         });
+        // Кто именно авторизовался — чтобы первый конфиг открывал доступ ему,
+        // а не всем. Сбой здесь не повод падать: без id набор будет закрытым,
+        // и оператору об этом скажут.
+        let selfId;
+        try {
+            const me = await client.getMe();
+            const id = me?.id;
+            if (id !== undefined && id !== null)
+                selfId = String(id);
+        }
+        catch {
+            selfId = undefined;
+        }
         return {
             apiId,
             apiHash,
             sessionString: String(client.session.save()),
+            selfId,
         };
     }
     finally {
@@ -196,10 +261,33 @@ async function runTelegramUserbotAuth(config) {
         }
         try {
             const backupPath = await (0, update_config_1.createConfigBackup)(snapshot.path);
-            await (0, update_config_1.updateConfigFileDirectly)(snapshot.path, accountId, auth);
+            const keptRefs = await (0, update_config_1.updateConfigFileDirectly)(snapshot.path, accountId, auth);
             console.log("");
             console.log(`OpenClaw config updated: ${snapshot.path}`);
             console.log(`Configured account id: ${accountId}`);
+            // Кто теперь может к нему обратиться — одной строкой, сразу.
+            // «Настроено» и «настроено так, как думает оператор» — разные вещи,
+            // и вторая проверяется только если её показать.
+            console.log("");
+            if (auth.selfId) {
+                console.log(`Who can talk to it: only telegram id ${auth.selfId} (you). Groups: none yet.`);
+                console.log("Reading chat history: denied everywhere (readChats: []).");
+            }
+            else {
+                console.log("Who can talk to it: nobody — your own id could not be read, so allowFrom is empty.");
+                console.log("Add your telegram id to allowFrom before the first start, or it will answer no one.");
+            }
+            console.log("Widen either list deliberately; the first config is closed on purpose.");
+            if (keptRefs.length > 0) {
+                // Не записали — значит обязаны сказать. Иначе оператор уйдёт в
+                // уверенности, что новые значения в конфиге, и узнает обратное при
+                // следующем старте.
+                console.log("");
+                console.log(`Kept in the secret store, NOT overwritten: ${keptRefs.join(", ")}`);
+                console.log("The freshly issued values are not in the config. Put them into the");
+                console.log("secret store the references point at, or the account will start with");
+                console.log("the previous credentials.");
+            }
             if (backupPath) {
                 console.log(`Config backup created: ${backupPath}`);
             }
@@ -258,13 +346,14 @@ async function runTelegramUserbotStandaloneCli(argv, config) {
         console.log("Usage: clawgram-cli <--hello|--auth>");
         return 1;
     }
-    if (flags.has("--hello") || flags.has("--auth")) {
-        await runTelegramUserbotCliFlags(config, {
-            hello: flags.has("--hello"),
-            auth: flags.has("--auth"),
-        });
-        return 0;
-    }
-    console.log("Specify one flag: --hello or --auth");
-    return 1;
+    // Здесь argv непуст (проверено выше) и не содержит ничего, кроме двух
+    // известных флагов, — значит хотя бы один из них есть. Прежде тут стоял
+    // ещё один `if` и за ним «Specify one flag», недостижимые по построению:
+    // код, который нельзя выполнить, читается как запасной путь и заставляет
+    // держать в голове случай, которого не бывает (находка A6-21).
+    await runTelegramUserbotCliFlags(config, {
+        hello: flags.has("--hello"),
+        auth: flags.has("--auth"),
+    });
+    return 0;
 }

package/dist/expiring-map.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpiringMap = void 0;
+/**
+ * A Map whose entries stop existing on their own.
+ *
+ * Three module-level maps kept per-message state — the address a group reply
+ * greets, when a visible reply went out, when the turn last spoke for itself
+ * — and only one of them ever swept anything. The other two grew by one entry
+ * per dispatched group message and per agent send, and nothing removed an
+ * entry that was never read back: an unanswered mention, a send whose echo
+ * never came. The gateway is restarted rarely by design, so the leak is slow
+ * and permanent rather than dramatic (finding A6-16).
+ *
+ * Two bounds rather than one, because they fail differently:
+ *
+ * - **Time.** An entry is gone once its TTL passes, whether or not anyone
+ *   asks for it. Sweeping happens on write, so a quiet process does no work
+ *   and a busy one pays a little on each message.
+ * - **Count.** A cap covers the case time cannot: many distinct keys inside
+ *   one TTL window. When it is hit the entry expiring soonest goes first —
+ *   it was closest to worthless anyway.
+ *
+ * `now` is a parameter everywhere so tests can move time without sleeping,
+ * the way the callers already did.
+ */
+class ExpiringMap {
+    ttlMs;
+    maxEntries;
+    entries = new Map();
+    constructor(ttlMs, maxEntries = 1000) {
+        this.ttlMs = ttlMs;
+        this.maxEntries = maxEntries;
+    }
+    set(key, value, now = Date.now()) {
+        this.prune(now);
+        this.entries.set(key, { value, expiresAt: now + this.ttlMs });
+        this.evictOverflow();
+    }
+    /** The value while it is still alive; an expired entry is dropped, not returned. */
+    get(key, now = Date.now()) {
+        const stored = this.entries.get(key);
+        if (!stored) {
+            return undefined;
+        }
+        if (stored.expiresAt <= now) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return stored.value;
+    }
+    /** Reads and removes in one step — for state a single consumer owns. */
+    take(key, now = Date.now()) {
+        const value = this.get(key, now);
+        // The delete happens even when the entry was already expired: `get` has
+        // dropped it in that case, and deleting a missing key is a no-op.
+        this.entries.delete(key);
+        return value;
+    }
+    delete(key) {
+        this.entries.delete(key);
+    }
+    /** Test seam: module state must not leak between suites. */
+    clear() {
+        this.entries.clear();
+    }
+    get size() {
+        return this.entries.size;
+    }
+    prune(now = Date.now()) {
+        for (const [key, stored] of this.entries.entries()) {
+            if (stored.expiresAt <= now) {
+                this.entries.delete(key);
+            }
+        }
+    }
+    evictOverflow() {
+        if (this.entries.size <= this.maxEntries) {
+            return;
+        }
+        // Insertion order is not expiry order once a key is rewritten, so the
+        // victim is chosen by expiry rather than by being first in the map.
+        let oldestKey;
+        let oldestExpiry = Infinity;
+        for (const [key, stored] of this.entries.entries()) {
+            if (stored.expiresAt < oldestExpiry) {
+                oldestExpiry = stored.expiresAt;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey !== undefined) {
+            this.entries.delete(oldestKey);
+        }
+    }
+}
+exports.ExpiringMap = ExpiringMap;

package/dist/gramjs-client.js

@@ -16,16 +16,13 @@ const history_1 = require("./history");
 const topics_1 = require("./topics");
 const dialogs_1 = require("./dialogs");
 const manage_1 = require("./manage");
-function toStringId(value) {
-    if (value === null || value === undefined)
-        return undefined;
-    try {
-        return String(value);
-    }
-    catch {
-        return undefined;
-    }
-}
+const core_1 = require("openclaw/plugin-sdk/core");
+const expiring_map_1 = require("./expiring-map");
+const normalize_1 = require("./normalize");
+/** Ten minutes: long enough to spare the repeat lookups of one turn,
+ *  short enough that a replaced session or a vanished peer is re-resolved. */
+const PEER_CACHE_TTL_MS = 10 * 60 * 1000;
+const peerLog = (0, core_1.createSubsystemLogger)("channels/clawgram");
 function inferChatTypeFromRaw(raw) {
     if (raw.startsWith("-100"))
         return "channel";
@@ -34,13 +31,13 @@ function inferChatTypeFromRaw(raw) {
     return "direct";
 }
 function getChatIdFromPeer(peer, fallback) {
-    const userId = toStringId(peer?.userId);
+    const userId = (0, normalize_1.toStringId)(peer?.userId);
     if (userId)
         return userId;
-    const chatId = toStringId(peer?.chatId);
+    const chatId = (0, normalize_1.toStringId)(peer?.chatId);
     if (chatId)
         return `-${chatId.replace(/^-/, "")}`;
-    const channelId = toStringId(peer?.channelId);
+    const channelId = (0, normalize_1.toStringId)(peer?.channelId);
     if (channelId)
         return `-100${channelId.replace(/^-100|-/, "")}`;
     return fallback;
@@ -161,7 +158,7 @@ function buildPeerCandidates(raw, kind) {
 function collectDialogKeys(dialog) {
     const keys = new Set();
     const add = (value) => {
-        const id = toStringId(value);
+        const id = (0, normalize_1.toStringId)(value);
         if (id) {
             keys.add(id);
         }
@@ -171,12 +168,12 @@ function collectDialogKeys(dialog) {
     add(dialog?.entity?.id);
     add(getChatIdFromPeer(dialog?.inputEntity));
     add(getChatIdFromPeer(dialog?.entity));
-    const inputChatId = toStringId(dialog?.inputEntity?.chatId);
+    const inputChatId = (0, normalize_1.toStringId)(dialog?.inputEntity?.chatId);
     if (inputChatId) {
         keys.add(inputChatId);
         keys.add(`-${inputChatId.replace(/^-/, "")}`);
     }
-    const inputChannelId = toStringId(dialog?.inputEntity?.channelId);
+    const inputChannelId = (0, normalize_1.toStringId)(dialog?.inputEntity?.channelId);
     if (inputChannelId) {
         keys.add(inputChannelId);
         keys.add(`-100${inputChannelId.replace(/^-100|-/, "")}`);
@@ -186,7 +183,7 @@ function collectDialogKeys(dialog) {
 function buildTargetKeys(raw, kind) {
     const keys = new Set();
     const add = (value) => {
-        const id = toStringId(value);
+        const id = (0, normalize_1.toStringId)(value);
         if (id) {
             keys.add(id);
         }
@@ -282,11 +279,43 @@ class GramJsClientManager {
     getClient() {
         return this.client;
     }
+    /**
+     * Peers already resolved by this client.
+     *
+     * `resolvePeer` is the entry of every call that touches Telegram — send,
+     * media, history, participants, topics, reactions, read marks, typing — and
+     * a target the session has not seen fell through to a scan of the 200 most
+     * recent dialogs. A DM to an id by number, the standard "write to this
+     * person" flow, paid that scan on the send and again on the read mark and
+     * the typing indicator, over a SOCKS proxy (finding A6-14).
+     *
+     * The TTL is short on purpose: a peer that stops existing, or a session
+     * replaced under the account, should not be remembered for the life of a
+     * process that is restarted rarely.
+     */
+    peerCacheStore;
+    /**
+     * Ленивая инициализация, а не поле класса: тесты собирают менеджер через
+     * `Object.create(GramJsClientManager.prototype)` — конструктор там не
+     * выполняется, и поле осталось бы `undefined` у любого такого объекта.
+     */
+    get peerCache() {
+        this.peerCacheStore ??= new expiring_map_1.ExpiringMap(PEER_CACHE_TTL_MS, 500);
+        return this.peerCacheStore;
+    }
     async getMe() {
         return this.client.getMe();
     }
     async resolveDialogPeer(raw, kind) {
         const targetKeys = buildTargetKeys(raw, kind);
+        // Самый дорогой путь резолва: 200 диалогов по сети, через прокси — секунды.
+        // Он остаётся (без него `@username` без общей истории не находится вовсе),
+        // но теперь виден в логе: если он в логе частый, значит кэш не спасает и
+        // адресация идёт не тем ключом (A6-14).
+        peerLog.info("clawgram peer resolve falling back to dialog scan", {
+            target: raw,
+            kind: kind ?? null,
+        });
         const dialogs = await this.client.getDialogs({ limit: 200 }).catch(() => []);
         for (const dialog of dialogs) {
             if (kind === "user" && !dialog?.isUser) {
@@ -300,7 +329,7 @@ class GramJsClientManager {
             if (!matched) {
                 continue;
             }
-            const chatId = getChatIdFromPeer(dialog?.inputEntity) ?? toStringId(dialog?.id) ?? raw;
+            const chatId = getChatIdFromPeer(dialog?.inputEntity) ?? (0, normalize_1.toStringId)(dialog?.id) ?? raw;
             const chatType = kind === "group"
                 ? "group"
                 : kind === "channel"
@@ -340,6 +369,13 @@ class GramJsClientManager {
                 chatType: "direct"
             };
         }
+        // Кэш спрашивается ПОСЛЕ «me»: тот и так не ходит в сеть, а класть его
+        // в карту значило бы держать запись, которая никогда не понадобится.
+        const cacheKey = `${chatLookupTarget}\u0000${kind ?? ""}`;
+        const cached = this.peerCache.get(cacheKey);
+        if (cached) {
+            return { ...cached, messageThreadId: parsedTarget.messageThreadId };
+        }
         let entity;
         for (const candidate of buildPeerCandidates(chatLookupTarget, kind)) {
             entity = await this.client.getInputEntity(candidate).catch(() => undefined);
@@ -350,6 +386,7 @@ class GramJsClientManager {
         if (!entity) {
             const dialogResolved = await this.resolveDialogPeer(chatLookupTarget, kind);
             if (dialogResolved) {
+                this.peerCache.set(cacheKey, { ...dialogResolved, messageThreadId: undefined });
                 dialogResolved.messageThreadId = parsedTarget.messageThreadId;
                 return dialogResolved;
             }
@@ -358,13 +395,17 @@ class GramJsClientManager {
             entity = await this.client.getInputEntity(chatLookupTarget);
         }
         const chatId = getChatIdFromPeer(entity, chatLookupTarget);
-        return {
+        const resolved = {
             raw,
             peer: entity,
             chatId,
             messageThreadId: parsedTarget.messageThreadId,
             chatType: inferChatTypeFromRaw(chatId ?? raw)
         };
+        // В карту кладётся тема-независимая часть: `messageThreadId` приходит
+        // из адреса конкретного вызова, а пир у всех тем чата один.
+        this.peerCache.set(cacheKey, { ...resolved, messageThreadId: undefined });
+        return resolved;
     }
     /**
      * Reply format for this account, validated once at read time.
@@ -571,19 +612,53 @@ class GramJsClientManager {
      */
     async listTopics(args) {
         const resolved = await this.resolvePeer(args.target, { kind: "channel" });
-        const result = await this.client.invoke(new telegram_1.Api.channels.GetForumTopics({
-            channel: resolved.peer,
-            ...(args.query ? { q: args.query } : {}),
-            offsetDate: 0,
-            offsetId: 0,
-            offsetTopic: 0,
-            limit: args.limit,
-        }));
-        const raw = Array.isArray(result?.topics) ? result.topics : [];
+        // Страницами, а не одним вызовом. `limit` принимался до 500, а сервер
+        // отдаёт страницу и ждёт смещений: всё, что не влезло в первую, просто
+        // терялось, и `truncated` при этом говорил «влезло». Соседние
+        // перечисления (`listMessages`, `listParticipants`, `listDialogs`) идут
+        // через пагинирующие помощники GramJS, а это — нет (находка A6-20).
+        const raw = [];
+        let offsetDate = 0;
+        let offsetId = 0;
+        let offsetTopic = 0;
+        let exhausted = false;
+        while (raw.length < args.limit) {
+            const page = await this.client.invoke(new telegram_1.Api.channels.GetForumTopics({
+                channel: resolved.peer,
+                ...(args.query ? { q: args.query } : {}),
+                offsetDate,
+                offsetId,
+                offsetTopic,
+                limit: args.limit - raw.length,
+            }));
+            const pageTopics = Array.isArray(page?.topics) ? page.topics : [];
+            if (pageTopics.length === 0) {
+                exhausted = true;
+                break;
+            }
+            // Страница может прийти длиннее запрошенного — тогда лишнее режем сами,
+            // иначе `limit` вызывающего перестаёт быть пределом.
+            raw.push(...pageTopics.slice(0, args.limit - raw.length));
+            const last = pageTopics[pageTopics.length - 1];
+            const nextTopic = Number(last?.id ?? 0);
+            const nextId = Number(last?.topMessage ?? 0);
+            const nextDate = Number(last?.date ?? 0);
+            // Страница, не сдвинувшая смещение, сдвинет его и в следующий раз —
+            // выходим, вместо того чтобы просить одно и то же вечно.
+            if (!Number.isFinite(nextTopic) || nextTopic === 0 || nextTopic === offsetTopic) {
+                exhausted = true;
+                break;
+            }
+            offsetTopic = nextTopic;
+            offsetId = Number.isFinite(nextId) ? nextId : 0;
+            offsetDate = Number.isFinite(nextDate) ? nextDate : 0;
+        }
         return {
             chatId: resolved.chatId,
             topics: (0, topics_1.normalizeForumTopics)(raw, { query: args.query }),
-            truncated: raw.length >= args.limit,
+            // «Обрезано» теперь означает именно это: набрали ровно столько,
+            // сколько просили, и форум не сказал, что тем больше нет.
+            truncated: !exhausted && raw.length >= args.limit,
         };
     }
     async markRead(target, messageId, options) {

package/dist/group-reply-address.js

@@ -5,9 +5,12 @@ exports.consumeGroupReplyAddress = consumeGroupReplyAddress;
 exports.peekGroupReplyAddress = peekGroupReplyAddress;
 exports.resetGroupReplyAddresses = resetGroupReplyAddresses;
 exports.buildGroupReplyAddress = buildGroupReplyAddress;
+const expiring_map_1 = require("./expiring-map");
 const helpers_1 = require("./helpers");
-const groupReplyAddresses = new Map();
 const GROUP_REPLY_ADDRESS_TTL_MS = 10 * 60 * 1000;
+// Запись жила до тех пор, пока её не прочитают, а читают не всякую:
+// упоминание без ответа оставляло адрес навсегда (A6-16).
+const groupReplyAddresses = new expiring_map_1.ExpiringMap(GROUP_REPLY_ADDRESS_TTL_MS);
 function normalizeGroupReplyTarget(rawTarget) {
     if (typeof rawTarget !== "string") {
         return String(rawTarget ?? "").trim();
@@ -30,10 +33,7 @@ function rememberGroupReplyAddress(input) {
     if (!key) {
         return;
     }
-    groupReplyAddresses.set(key, {
-        address: input.address,
-        expiresAt: Date.now() + GROUP_REPLY_ADDRESS_TTL_MS,
-    });
+    groupReplyAddresses.set(key, input.address);
 }
 /**
  * The address remembered for one specific incoming message.
@@ -51,17 +51,7 @@ function readGroupReplyAddress(input, consume) {
     if (!key) {
         return undefined;
     }
-    const stored = groupReplyAddresses.get(key);
-    if (!stored) {
-        return undefined;
-    }
-    if (consume) {
-        groupReplyAddresses.delete(key);
-    }
-    if (stored.expiresAt < Date.now()) {
-        return undefined;
-    }
-    return stored.address;
+    return consume ? groupReplyAddresses.take(key) : groupReplyAddresses.get(key);
 }
 function consumeGroupReplyAddress(input) {
     return readGroupReplyAddress(input, true);