tailii-host 0.12.0 → 0.14.0

package/dist/hub/sessionHub.js

@@ -5,8 +5,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { bumpHeartbeat, listHeartbeatSessions, readHeartbeat, writeHeartbeat } from "../sessions/heartbeat.js";
 import { ensureDirectory0700 } from "../shared/paths.js";
+import { encodeControlMessage } from "../protocol.js";
 import { decodeHubClientLine, encodeHubMessage, } from "./hubProtocol.js";
 import { HISTORY_DONE_STREAM_ID, findTrailingTurnEndMarkerMs, findTrailingUserPromptText, } from "../chat/transcriptTailer.js";
+import { sliceHistoryPage } from "./historyPage.js";
 import { sameUsageLimitWait } from "../shared/usageLimitWait.js";
 import { PROTOCOL_V1, PROTOCOL_V2 } from "../protocol.js";
 import { ChatInjectionRejectedError, LoginCodeError, SEND_NOW_BLOCKED_BY_DIALOG, SEND_NOW_EXPIRED_IN_QUEUE, } from "../backend/tmux.js";
@@ -14,12 +16,19 @@ import { CodexAppServerManager } from "../codex/codexAppServer.js";
 import { CodexNativeTurnController, chatContentKey, } from "../codex/codexNativeTurnController.js";
 import { COLLABORATION_MODE_STREAM_ID as CODEX_COLLABORATION_MODE_STREAM_ID, CONTEXT_STREAM_ID as CODEX_CONTEXT_STREAM_ID, CONTEXT_WINDOW_STREAM_ID as CODEX_CONTEXT_WINDOW_STREAM_ID, MODEL_STREAM_ID as CODEX_MODEL_STREAM_ID, } from "../codex/codexRolloutTailer.js";
 import { claudeTranscriptPathFor } from "../sessions/transcriptPath.js";
+import { isNonBlockingQuestionId } from "../codex/codexAsyncQuestion.js";
 /**
  * backfilling 中の購読者は publishConversationEvent が丸ごと飛ばす。旗が立ちっぱなしになると
  * 「接続は健全なのに会話だけ永久に更新されない」実障害になるため、履歴が一定時間 1 行も進まな
  * ければ強制的に live へ切り替える。進捗があるうちは延長するので、巨大な transcript の再生を
  * 途中で打ち切ることはない。
  */
+/** 履歴ページ用に transcript を読み切るまでの上限（画像の多い巨大な会話でも返事を返す）。 */
+const HISTORY_PAGE_READ_TIMEOUT_MS = 20_000;
+/** 履歴ページ用に全履歴を覚えておく会話の数。 */
+const HISTORY_PAGE_CACHE_LIMIT = 3;
+/** 履歴ページ用に覚えた全履歴を使い回す期間（遡り中の連続要求だけを速くし、メモリに長く残さない）。 */
+const HISTORY_PAGE_CACHE_TTL_MS = 10 * 60_000;
 const BACKFILL_STALL_TIMEOUT_MS = 15_000;
 const DELIVERED_RECEIPT_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
 const MAX_DELIVERED_RECEIPTS_PER_SESSION = 10_000;
@@ -46,11 +55,20 @@ function isContinuationHookEvent(event) {
 function defaultTranscriptPathFor(meta) {
     return claudeTranscriptPathFor(meta);
 }
+/** 設問の回答時に TUI へ設問ダイアログが出ていなかった（question-stale）。キーは 1 つも打っていない。 */
+class StaleQuestionError extends Error {
+    constructor() {
+        super("AskUserQuestion dialog is not on screen");
+        this.name = "StaleQuestionError";
+    }
+}
 export class SessionHub {
     options;
     clients = new Map();
     /** 一覧 Mission Control の watcher（処理中会話全体の pane_preview 配信先）。 */
     previewWatchers = new Set();
+    /** `stale` で捨てた設問の再確認タイマー（会話ごとに 1 本, question-stale）。 */
+    staleQuestionRechecks = new Map();
     actors = new Map();
     now;
     nowMs;
@@ -59,6 +77,13 @@ export class SessionHub {
     codexStartsInFlight = 0;
     modePushSeq = 0;
     chatReceiptsDirty = false;
+    /**
+     * 片付け（retire）・世代不一致で actor ごと消えた会話の Claude 配送済み receipt（clientMessageId →
+     * 配送時刻）。clientMessageId は UUID で会話をまたいで一意なので、actor が消えても「配送済み」の
+     * 事実は変わらない。`chat_receipt_query` がこれを見て、ACK を取りこぼした iOS の Outbox を
+     * 安全に解決できるようにする（restored-receipt-probe）。保持は通常の receipt と同じ 30 日。
+     */
+    retiredChatDeliveries = new Map();
     activeCodexTurns = new Set();
     codexTurnController = null;
     constructor(options) {
@@ -176,12 +201,19 @@ export class SessionHub {
     /** daemon 再起動前に durable enqueue 済みだった chat_send と receipt を復元する。 */
     restoreChatReceipts() {
         const persisted = this.readChatReceipts();
+        const restoredLedgerAt = Date.now();
+        for (const [clientMessageId, deliveredAt] of Object.entries(this.readRetiredChatDeliveries())) {
+            this.retiredChatDeliveries.set(clientMessageId, deliveredAt);
+        }
+        compactRetiredChatDeliveries(this.retiredChatDeliveries, restoredLedgerAt);
         let discardedStaleSession = false;
         for (const [session, state] of Object.entries(persisted)) {
             const currentSessionIdentity = receiptSessionIdentity(this.options.metadataStore.get(session));
             if (state.sessionIdentity !== undefined && state.sessionIdentity !== currentSessionIdentity) {
                 // session 名は再利用される。旧世代の durable queue を同名の新 pane へ注入しない。
                 // metadata が消失・破損した場合も identity を証明できないため安全側で破棄する。
+                // 配送済みの事実（UUID の clientMessageId）だけは照会用の台帳へ残す。
+                adoptRetiredChatDeliveries(this.retiredChatDeliveries, new Map(state.delivered.map((id) => [id, state.deliveredAtMs?.[id] ?? restoredLedgerAt])), restoredLedgerAt);
                 discardedStaleSession = true;
                 this.options.log?.(`stale chat receipt 破棄 session=${session}`);
                 continue;
@@ -288,6 +320,10 @@ export class SessionHub {
     }
     handleRelayMessage(message) {
         if (message.type === "question_event") {
+            // 新しい設問が来た / CLI 側でその設問が片付いた（PostToolUse）なら、捨てた設問の再確認は要らない。
+            if (message.event === "prompt" || this.staleQuestionRechecks.get(message.session)?.id === message.id) {
+                this.cancelStaleQuestionRecheck(message.session);
+            }
             const actor = this.actor(message.session);
             this.setPendingQuestion(message.session, actor, message.event === "prompt"
                 ? { id: message.id, questions: message.questions ?? [], answerRoute: "tui" } : null);
@@ -335,6 +371,10 @@ export class SessionHub {
             }
             return;
         }
+        if (message.type === "conversation_history_page_request") {
+            void this.answerHistoryPage(client, message);
+            return;
+        }
         if (message.type === "conversation_subagent_transcript_request") {
             const actor = this.actors.get(message.session);
             const transcript = actor?.tail?.subagentTranscript?.(message.nodeId) ?? {
@@ -397,8 +437,8 @@ export class SessionHub {
                 const restoreSnapshot = actor.pendingQuestion;
                 this.setPendingQuestion(message.session, actor, null);
                 this.broadcast({ type: "question_event", session: message.session, event: "dismiss", id: message.questionId });
-                this.sendTo(client, { type: "question_answer_result", id: message.id, status: "accepted" });
                 if (answerRoute === "codex_native") {
+                    this.sendTo(client, { type: "question_answer_result", id: message.id, status: "accepted" });
                     try {
                         if (this.codexTurnController?.answerQuestion?.(message.questionId, message.answers) !== true) {
                             this.options.log?.(`Codex native 設問回答失敗: pending 不在 (${message.questionId})`);
@@ -415,15 +455,39 @@ export class SessionHub {
                     actor.questionAnswerInjections += 1;
                     // 同期 throw でも `.finally` を必ず通す（通らないと回答注入中の件数が戻らず、chat が
                     // 永久に保留される）。
+                    // 回答キーは TUI に設問ダイアログが出ているときだけ打つ（question-stale）。出ていなければ
+                    // 数字キーは入力欄へ落ち、Enter の無い単一選択では「1」が入ったまま会話が止まる
+                    // （実機 2026-10-05: 設問カードに答えたら CLI の入力欄に 1 が残り、アプリは処理中のまま）。
+                    // 判定できない（pane を読めない）ときは従来どおり打つ。確認しない構成では従来どおり即受理。
+                    const dialogVisible = this.options.questionDialogVisible;
+                    const accept = () => {
+                        this.sendTo(client, { type: "question_answer_result", id: message.id, status: "accepted" });
+                    };
+                    if (dialogVisible === undefined)
+                        accept();
                     let injection;
                     try {
-                        injection = this.options.questionInjector?.(message.answers, message.session) ?? Promise.resolve();
+                        injection = (async () => {
+                            if (dialogVisible !== undefined) {
+                                if (await dialogVisible(message.session) === false)
+                                    throw new StaleQuestionError();
+                                accept();
+                            }
+                            await this.options.questionInjector?.(message.answers, message.session);
+                        })();
                     }
                     catch (error) {
                         injection = Promise.reject(error);
                     }
                     void injection
                         .catch((error) => {
+                        if (error instanceof StaleQuestionError) {
+                            // 設問はもう TUI に無い（回答済み・取り消し済み・表示されなかった）。復元も再提示もしない。
+                            this.sendTo(client, { type: "question_answer_result", id: message.id, status: "stale" });
+                            this.options.log?.(`audit question-stale session=${auditValue(message.session)} question=${auditValue(message.questionId)}`);
+                            this.recheckStaleQuestion(message.session, actor, restoreSnapshot);
+                            return;
+                        }
                         this.options.log?.(`設問回答注入失敗: ${String(error)}`);
                         // 自己修復（question-answer-retry）: pendingQuestion を失ったまま TUI ダイアログが
                         // 残ると、アプリから再回答する手段が無く会話が詰む。失敗の度に必ず復元し、
@@ -678,6 +742,13 @@ export class SessionHub {
             void this.runSendNow(message.session, actor);
             return;
         }
+        if (message.type === "chat_receipt_query") {
+            this.sendTo(client, {
+                type: "chat_receipt_query_result", id: message.id,
+                status: this.chatReceiptStatus(message.session, message.clientMessageId),
+            });
+            return;
+        }
         if (message.type === "pending_message_delete") {
             // 対象不在も成功だが、client 保存前 crash で同じ Outbox が復元されても実行しないよう
             // 削除 tombstone は durable に残す。actor 不在でもここだけは軽量 actor を作る。
@@ -761,6 +832,9 @@ export class SessionHub {
         return result;
     }
     close() {
+        for (const recheck of this.staleQuestionRechecks.values())
+            clearTimeout(recheck.timer);
+        this.staleQuestionRechecks.clear();
         for (const actor of this.actors.values()) {
             if (actor.tailRetryTimer !== null)
                 clearTimeout(actor.tailRetryTimer);
@@ -827,6 +901,7 @@ export class SessionHub {
         }
         // drain が injector / App Server の await 中でも、復帰後に同じ actor 参照から次の旧入力へ
         // 進めないよう durable queue の実体も空にする。現在実行中の1件は復帰時のidentity検査で捨てる。
+        adoptRetiredChatDeliveries(this.retiredChatDeliveries, actor.deliveredChatMessageIds);
         actor.chatQueue.length = 0;
         actor.chatOrder.length = 0;
         actor.pendingChatMessages.clear();
@@ -890,6 +965,22 @@ export class SessionHub {
                 actor.previewPump?.resendLastIfInteractive?.();
                 actor.previewPump?.armJumpToLatest?.();
             }
+            // 開き直し（reattach-since）は iOS のキャッシュが追いついていた時刻以降を transcript から
+            // 読み直す。背景購読の replay buffer だけでは履歴完了マーカーが届かず、iOS の
+            // 「最新分を取り込み中」が解けない。
+            if (!existing.backfilling && newerThanMs !== undefined) {
+                if (this.options.tailFactory === undefined || this.options.metadataStore.get(session) === null) {
+                    // 読み直せない会話でも完了を知らせる（iOS の「最新分を取り込み中」と遡りの待ちを解く）。
+                    this.sendTo(client, {
+                        type: "conversation_event", session, serverSeq: 0,
+                        payload: { type: "chat_output", v: PROTOCOL_V1, streamId: "pc:history-cancelled",
+                            role: "system", text: "", eof: true },
+                    });
+                    return;
+                }
+                this.startBackfill(client, session, actor, newerThanMs);
+                return;
+            }
             // preview=false 中に engine が route できなかった image/subagent event を、同じ
             // subscriber の前面昇格時にも afterSeq から回収する。既存購読だからと no-op にしない。
             if (!existing.backfilling && afterSeq !== undefined) {
@@ -1463,6 +1554,114 @@ export class SessionHub {
         if (!finished)
             armStallTimer(BACKFILL_STALL_TIMEOUT_MS);
     }
+    // ---- 履歴ページ（history-page） ----
+    /** 直近に読んだ会話の全履歴（ページを遡るたびに transcript を頭から読み直さない）。 */
+    historyPageCache = new Map();
+    /** 会話ごとの読み取り中の Promise（同じ会話の全履歴を並行して二重に読まない）。 */
+    historyPageReads = new Map();
+    async answerHistoryPage(client, message) {
+        const anchor = message.beforeStreamId !== undefined || message.beforeToolId !== undefined
+            ? { ...(message.beforeStreamId !== undefined ? { streamId: message.beforeStreamId } : {}),
+                ...(message.beforeToolId !== undefined ? { toolId: message.beforeToolId } : {}) }
+            : null;
+        let response;
+        try {
+            // 最新のページは常に読み直す（新しい行が増えている）。遡るページは直近の読み取りを使い、
+            // 終端の行がそこに無いときだけ読み直す。
+            // 期限切れの全履歴は要求のたびに捨てる（常駐 daemon に base64 サムネごと残し続けない）。
+            for (const [session, cached] of this.historyPageCache) {
+                if (Date.now() - cached.hostNowMs > HISTORY_PAGE_CACHE_TTL_MS)
+                    this.historyPageCache.delete(session);
+            }
+            let history = anchor === null ? undefined : this.historyPageCache.get(message.session);
+            let slice = history === undefined ? null : sliceHistoryPage(history.events, anchor, message.limit);
+            if (slice === null || !slice.anchorFound) {
+                history = await this.readFullHistory(message.session);
+                slice = sliceHistoryPage(history.events, anchor, message.limit);
+            }
+            response = {
+                type: "conversation_history_page_response", id: message.id, session: message.session,
+                lines: slice.events.map((event) => encodeControlMessage(event)),
+                hasMore: slice.hasMore, hostNowMs: history.hostNowMs,
+                ...(slice.anchorFound ? {} : { anchorMissing: true }),
+            };
+        }
+        catch (error) {
+            this.options.log?.(`audit history-page-failed session=${message.session} error=${String(error)}`);
+            response = {
+                type: "conversation_history_page_response", id: message.id, session: message.session,
+                lines: [], hasMore: false, hostNowMs: Date.now(), failed: true,
+            };
+        }
+        this.sendTo(client, response);
+    }
+    /** 全履歴の再送と同じ tail で transcript を最後まで読み、出力を集める（購読者へは流さない）。 */
+    readFullHistory(session) {
+        const inFlight = this.historyPageReads.get(session);
+        if (inFlight !== undefined)
+            return inFlight;
+        const read = new Promise((resolve, reject) => {
+            const factory = this.options.tailFactory;
+            const meta = this.options.metadataStore.get(session);
+            if (factory === undefined || meta === null) {
+                reject(new Error(factory === undefined ? "tail unavailable" : "session metadata not found"));
+                return;
+            }
+            const hostNowMs = Date.now();
+            const events = [];
+            let settled = false;
+            let tail = null;
+            let timer = null;
+            const settle = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer !== null)
+                    clearTimeout(timer);
+                tail?.stop();
+                if (error !== null) {
+                    reject(error);
+                    return;
+                }
+                const history = { events, hostNowMs };
+                // 直近数件だけ持つ（会話を行き来しても読み直しを減らし、メモリは際限なく持たない）。
+                this.historyPageCache.delete(session);
+                this.historyPageCache.set(session, history);
+                while (this.historyPageCache.size > HISTORY_PAGE_CACHE_LIMIT) {
+                    this.historyPageCache.delete(this.historyPageCache.keys().next().value);
+                }
+                resolve(history);
+            };
+            tail = factory((payload) => {
+                if (settled)
+                    return;
+                if (payload.type === "chat_output" && payload.streamId === HISTORY_DONE_STREAM_ID) {
+                    settle(null);
+                    return;
+                }
+                events.push(payload);
+            });
+            if (settled) {
+                tail.stop();
+                return;
+            }
+            timer = setTimeout(() => settle(new Error("history read timed out")), HISTORY_PAGE_READ_TIMEOUT_MS);
+            timer.unref();
+            try {
+                tail.open(meta.cwd, meta.providerSessionId ?? meta.claudeSessionId ?? null, null, meta.agent ?? "claude");
+            }
+            catch (error) {
+                settle(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        this.historyPageReads.set(session, read);
+        const clear = () => {
+            if (this.historyPageReads.get(session) === read)
+                this.historyPageReads.delete(session);
+        };
+        read.then(clear, clear);
+        return read;
+    }
     canReplay(actor, afterSeq) {
         const first = actor.replayBuffer[0]?.serverSeq ?? actor.nextServerSeq;
         const last = actor.nextServerSeq - 1;
@@ -1541,7 +1740,11 @@ export class SessionHub {
             if (actor.usageLimitWatch !== null)
                 return 5000;
             return 1000;
-        }, (state) => this.handleUsageLimitWait(session, actor, state));
+        }, (state) => this.handleUsageLimitWait(session, actor, state), 
+        // 入力欄に残った文字の通知（input-residue）は処理中でない間だけ。hub 自身が発話・設問の回答・
+        // 今すぐ送信を打っている最中の入力欄も、残り文字とみなさない。
+        () => actor.processingSince === null && !actor.chatDrainRunning && actor.questionAnswerInjections === 0 &&
+            !actor.sendNowRunning);
         actor.previewPump = pump;
         pump.start(session, this.options.metadataStore.get(session)?.agent === "codex" ? "codex_terminal" : "claude_status", 
         // 処理中の pump 起動（=一覧 watch 起因が典型）は初回フレームから送る。静止 pane
@@ -2372,7 +2575,9 @@ export class SessionHub {
         catch (error) {
             this.options.log?.(`heartbeat 書込失敗: ${String(error)}`);
         }
-        if (state === "done" && actor.pendingQuestion !== null) {
+        // turn を止めない設問（Codex の非同期質問）は turn controller が turn の終わりに締め切る。処理中表示の
+        // done（steer の不確定失敗などでも来る）で消すと、controller は提示済みのままで出し直さない。
+        if (state === "done" && actor.pendingQuestion !== null && !isNonBlockingQuestionId(actor.pendingQuestion.id)) {
             const id = actor.pendingQuestion.id;
             this.setPendingQuestion(session, actor, null);
             this.broadcast({ type: "question_event", session, event: "dismiss", id });
@@ -2388,6 +2593,63 @@ export class SessionHub {
             this.options.log?.(`heartbeat 書込失敗: ${String(error)}`);
         }
     }
+    /**
+     * `stale` で捨てた設問を、少し後に確かめ直す（question-stale）。設問の通知は PreToolUse hook が allow を
+     * 返す前に届くので、利用者の他の遅い hook があるとダイアログはまだ描かれていないことがある。その窓で
+     * 答えられた設問は、ダイアログが出てきたら戻して再提示する。間隔を広げて数回まで確かめ、別の設問が来た・
+     * CLI 側で片付いた（PostToolUse の dismiss）・会話が入れ替わった・hub を閉じたら止める。
+     */
+    recheckStaleQuestion(session, actor, snapshot) {
+        const dialogVisible = this.options.questionDialogVisible;
+        if (dialogVisible === undefined)
+            return;
+        this.cancelStaleQuestionRecheck(session);
+        const delays = this.options.staleQuestionRecheckMs !== undefined
+            ? [this.options.staleQuestionRecheckMs, this.options.staleQuestionRecheckMs * 2, this.options.staleQuestionRecheckMs * 4]
+            : [1_500, 3_000, 6_000];
+        const schedule = (attempt) => {
+            const delay = delays[attempt];
+            if (delay === undefined) {
+                this.cancelStaleQuestionRecheck(session);
+                return;
+            }
+            const timer = setTimeout(() => {
+                void (async () => {
+                    const mine = () => this.staleQuestionRechecks.get(session)?.timer === timer;
+                    const alive = () => mine() && this.actors.get(session) === actor && actor.pendingQuestion === null;
+                    const settle = () => { if (mine())
+                        this.staleQuestionRechecks.delete(session); };
+                    if (!alive()) {
+                        settle();
+                        return;
+                    }
+                    const visible = await dialogVisible(session);
+                    if (!alive()) {
+                        settle();
+                        return;
+                    }
+                    if (visible !== true) {
+                        schedule(attempt + 1);
+                        return;
+                    }
+                    this.cancelStaleQuestionRecheck(session);
+                    this.setPendingQuestion(session, actor, snapshot);
+                    this.broadcast({ type: "question_event", session, event: "prompt", id: snapshot.id, questions: snapshot.questions });
+                    this.options.log?.(`audit question-stale-restored session=${auditValue(session)} question=${auditValue(snapshot.id)}`);
+                })().catch(() => { });
+            }, delay);
+            timer.unref?.();
+            this.staleQuestionRechecks.set(session, { id: snapshot.id, timer });
+        };
+        schedule(0);
+    }
+    cancelStaleQuestionRecheck(session) {
+        const recheck = this.staleQuestionRechecks.get(session);
+        if (recheck === undefined)
+            return;
+        clearTimeout(recheck.timer);
+        this.staleQuestionRechecks.delete(session);
+    }
     setPendingQuestion(session, actor, pending) {
         actor.pendingQuestion = pending;
         this.persistPendingQuestions();
@@ -2491,7 +2753,12 @@ export class SessionHub {
             };
         }
         try {
-            const contents = JSON.stringify({ version: 1, sessions });
+            compactRetiredChatDeliveries(this.retiredChatDeliveries);
+            const contents = JSON.stringify({
+                version: 1, sessions,
+                ...(this.retiredChatDeliveries.size > 0
+                    ? { retiredChatDeliveredAtMs: Object.fromEntries(this.retiredChatDeliveries) } : {}),
+            });
             if (this.options.chatReceiptsWriter !== undefined) {
                 this.options.chatReceiptsWriter(target, contents);
             }
@@ -2510,6 +2777,49 @@ export class SessionHub {
             return false;
         }
     }
+    readRetiredChatDeliveries() {
+        const target = this.options.chatReceiptsPath;
+        if (target === undefined)
+            return {};
+        try {
+            const parsed = JSON.parse(fs.readFileSync(target, "utf8"));
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+                return {};
+            const ledger = parsed["retiredChatDeliveredAtMs"];
+            if (typeof ledger !== "object" || ledger === null || Array.isArray(ledger))
+                return {};
+            const result = {};
+            for (const [clientMessageId, deliveredAt] of Object.entries(ledger)) {
+                if (typeof deliveredAt === "number" && Number.isFinite(deliveredAt))
+                    result[clientMessageId] = deliveredAt;
+            }
+            return result;
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Claude 発話の配送状態を、何も登録せずに答える（`chat_receipt_query`, restored-receipt-probe）。
+     * `chat_send` と違い、どの記録にも無い ID を新規として受け付けない（unknown を返すだけ）。
+     * 会話が片付いた後も配送済みは台帳から答える。actor が無ければ作らない。
+     */
+    chatReceiptStatus(session, clientMessageId) {
+        const actor = this.actors.get(session);
+        if (actor !== undefined) {
+            if (hasDeliveredReceipt(actor.deletedChatMessageIds, clientMessageId))
+                return "deleted";
+            if (hasDeliveredReceipt(actor.deliveredChatMessageIds, clientMessageId))
+                return "delivered";
+            if (actor.uncertainChatMessages.has(clientMessageId))
+                return "uncertain";
+            if (actor.pendingChatMessages.has(clientMessageId))
+                return "pending";
+        }
+        if (hasDeliveredReceipt(this.retiredChatDeliveries, clientMessageId))
+            return "delivered";
+        return "unknown";
+    }
     readChatReceipts() {
         const target = this.options.chatReceiptsPath;
         if (target === undefined)
@@ -2677,6 +2987,27 @@ function compactDeliveredReceipts(receipts, now = Date.now()) {
         receipts.delete(oldest);
     }
 }
+/** 片付けた会話の配送済み receipt の上限（全会話合計）。 */
+const MAX_RETIRED_CHAT_DELIVERIES = 20_000;
+function adoptRetiredChatDeliveries(ledger, delivered, now = Date.now()) {
+    for (const [clientMessageId, deliveredAt] of delivered) {
+        ledger.delete(clientMessageId);
+        ledger.set(clientMessageId, deliveredAt);
+    }
+    compactRetiredChatDeliveries(ledger, now);
+}
+function compactRetiredChatDeliveries(ledger, now = Date.now()) {
+    for (const [id, deliveredAt] of ledger) {
+        if (now - deliveredAt > DELIVERED_RECEIPT_TTL_MS)
+            ledger.delete(id);
+    }
+    while (ledger.size > MAX_RETIRED_CHAT_DELIVERIES) {
+        const oldest = ledger.keys().next().value;
+        if (oldest === undefined)
+            break;
+        ledger.delete(oldest);
+    }
+}
 function removeOrderedID(order, id) {
     const index = order.indexOf(id);
     if (index >= 0)