koishi-plugin-anime-schedule 1.1.3 → 1.1.4

package/lib/config.js

@@ -171,7 +171,7 @@ exports.Config = koishi_1.Schema.intersect([
                 .description('请求失败重试次数')
                 .default(2),
             debug: koishi_1.Schema.boolean()
-                .description('输出调试日志（逐部作品与每次请求的细节，构建结果与推送结果始终输出）')
+                .description('输出调试日志')
                 .default(false),
         }),
     }).description('其他'),

package/lib/constants.d.ts

@@ -95,6 +95,20 @@ export declare const MIN_SCORE_VOTES = 10;
 export declare const LOCALIZE_CACHE_VERSION = 6;
 /** 本地化缓存最大条目数，超出后按写入时间淘汰最旧的一半 */
 export declare const LOCALIZE_CACHE_MAX_ENTRIES = 5000;
+/**
+ * 「不采信 / 已剔除」判定缓存的版本与有效期。
+ *
+ * 这些判定的输入都是慢变量（bangumi-data 的 `aniList` ID、Bangumi 逐集档期），
+ * 但上游偶尔会修数据，因此不设永久缓存：AniList 判定 7 天后复核，Bangumi 档期判定
+ * 30 天后复核（与本地化缓存一致）。
+ */
+export declare const VERDICT_CACHE_VERSION = 1;
+export declare const VERDICT_CACHE_FILE = "verdicts.json";
+export declare const VERDICT_CACHE_MAX_ENTRIES = 5000;
+/** AniList 判定只保留 7 天：它来自外部 API，短周期复核更稳妥 */
+export declare const ANILIST_VERDICT_TTL_MS: number;
+/** Bangumi 逐集档期判定来自本地化缓存，跟它一样保留 30 天 */
+export declare const EPISODE_VERDICT_TTL_MS: number;
 /** 取逐集档期时的单页集数上限；超过这个数的长期番不靠集数判断完结 */
 export declare const EPISODE_QUERY_LIMIT = 100;
 /**

package/lib/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOG_MESSAGES = exports.RESPONSES = exports.MESSAGES = exports.IMAGE_THEME = exports.IMAGE_LAYOUT = exports.DEFAULT_FONT_FAMILY = exports.BUILD_CACHE_MAX_ENTRIES = exports.BUILD_CACHE_TTL_MS = exports.DAILY_OFFSET_MAX = exports.DAILY_OFFSET_MIN = exports.MAX_SUPERSAMPLE = exports.DEFAULT_SUPERSAMPLE = exports.DEFAULT_JPEG_QUALITY = exports.BOLD_FONT_CANDIDATES = exports.FONT_CANDIDATES = exports.COVER_MEMORY_MAX_BYTES = exports.COVER_CACHE_MAX_FILES = exports.COVER_CACHE_TTL_MS = exports.COVER_CACHE_DIR = exports.COVER_MAX_BYTES = exports.COVER_TIMEOUT_MS = exports.COVER_CONCURRENCY = exports.LOCALIZE_TIMEOUT_SECONDS = exports.LOCALIZE_CONCURRENCY = exports.EPISODE_QUERY_LIMIT = exports.LOCALIZE_CACHE_MAX_ENTRIES = exports.LOCALIZE_CACHE_VERSION = exports.MIN_SCORE_VOTES = exports.DEFAULT_SCORE_TTL_HOURS = exports.LOCALIZE_CACHE_FILE = exports.LATE_NIGHT_END_HOUR = exports.IMAGE_LIST_TWO_COLUMN_AT = exports.IMAGE_MAX_CARDS = exports.DIGEST_LABELS = exports.PLUGIN_HOMEPAGE = exports.PLUGIN_VERSION = exports.DATA_DIR = exports.BANGUMI_DATA_FILE = exports.BANGUMI_DATA_FALLBACK_URLS = exports.ANILIST_COOLDOWN_MS = exports.ANILIST_MIN_INTERVAL_MS = exports.ANILIST_BATCH_SIZE = exports.ANILIST_API_URL = exports.BANGUMI_API_HOST = exports.PLUGIN_NAME = void 0;
+exports.LOG_MESSAGES = exports.RESPONSES = exports.MESSAGES = exports.IMAGE_THEME = exports.IMAGE_LAYOUT = exports.DEFAULT_FONT_FAMILY = exports.BUILD_CACHE_MAX_ENTRIES = exports.BUILD_CACHE_TTL_MS = exports.DAILY_OFFSET_MAX = exports.DAILY_OFFSET_MIN = exports.MAX_SUPERSAMPLE = exports.DEFAULT_SUPERSAMPLE = exports.DEFAULT_JPEG_QUALITY = exports.BOLD_FONT_CANDIDATES = exports.FONT_CANDIDATES = exports.COVER_MEMORY_MAX_BYTES = exports.COVER_CACHE_MAX_FILES = exports.COVER_CACHE_TTL_MS = exports.COVER_CACHE_DIR = exports.COVER_MAX_BYTES = exports.COVER_TIMEOUT_MS = exports.COVER_CONCURRENCY = exports.LOCALIZE_TIMEOUT_SECONDS = exports.LOCALIZE_CONCURRENCY = exports.EPISODE_QUERY_LIMIT = exports.EPISODE_VERDICT_TTL_MS = exports.ANILIST_VERDICT_TTL_MS = exports.VERDICT_CACHE_MAX_ENTRIES = exports.VERDICT_CACHE_FILE = exports.VERDICT_CACHE_VERSION = exports.LOCALIZE_CACHE_MAX_ENTRIES = exports.LOCALIZE_CACHE_VERSION = exports.MIN_SCORE_VOTES = exports.DEFAULT_SCORE_TTL_HOURS = exports.LOCALIZE_CACHE_FILE = exports.LATE_NIGHT_END_HOUR = exports.IMAGE_LIST_TWO_COLUMN_AT = exports.IMAGE_MAX_CARDS = exports.DIGEST_LABELS = exports.PLUGIN_HOMEPAGE = exports.PLUGIN_VERSION = exports.DATA_DIR = exports.BANGUMI_DATA_FILE = exports.BANGUMI_DATA_FALLBACK_URLS = exports.ANILIST_COOLDOWN_MS = exports.ANILIST_MIN_INTERVAL_MS = exports.ANILIST_BATCH_SIZE = exports.ANILIST_API_URL = exports.BANGUMI_API_HOST = exports.PLUGIN_NAME = void 0;
 exports.buildUserAgent = buildUserAgent;
 exports.getMessages = getMessages;
 /** 插件名，同时作为日志前缀与 User-Agent 主体 */
@@ -119,6 +119,20 @@ exports.MIN_SCORE_VOTES = 10;
 exports.LOCALIZE_CACHE_VERSION = 6;
 /** 本地化缓存最大条目数，超出后按写入时间淘汰最旧的一半 */
 exports.LOCALIZE_CACHE_MAX_ENTRIES = 5000;
+/**
+ * 「不采信 / 已剔除」判定缓存的版本与有效期。
+ *
+ * 这些判定的输入都是慢变量（bangumi-data 的 `aniList` ID、Bangumi 逐集档期），
+ * 但上游偶尔会修数据，因此不设永久缓存：AniList 判定 7 天后复核，Bangumi 档期判定
+ * 30 天后复核（与本地化缓存一致）。
+ */
+exports.VERDICT_CACHE_VERSION = 1;
+exports.VERDICT_CACHE_FILE = 'verdicts.json';
+exports.VERDICT_CACHE_MAX_ENTRIES = 5000;
+/** AniList 判定只保留 7 天：它来自外部 API，短周期复核更稳妥 */
+exports.ANILIST_VERDICT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/** Bangumi 逐集档期判定来自本地化缓存，跟它一样保留 30 天 */
+exports.EPISODE_VERDICT_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 /** 取逐集档期时的单页集数上限；超过这个数的长期番不靠集数判断完结 */
 exports.EPISODE_QUERY_LIMIT = 100;
 /**

package/lib/index.js

@@ -107,12 +107,13 @@ function apply(ctx, rawConfig) {
     // 立刻开始载入并与插件启动并行：指令与推送在构建前会 await 它，不会出现「索引还没好」的空窗
     const indexReady = index.ensure();
     const localizeReady = digest.localizer.load();
+    const verdictReady = digest.verdicts.load();
     const airingReady = airing.ensure();
     // 免去「未处理的 Promise 拒绝」告警，真实错误在 ready 与构建路径里各自上报
-    Promise.all([indexReady, localizeReady, airingReady]).catch(() => undefined);
+    Promise.all([indexReady, localizeReady, verdictReady, airingReady]).catch(() => undefined);
     const dispatcher = new dispatch_1.Dispatcher(ctx, config, logger, (payload) => renderer.render((0, image_1.toRenderPayload)(payload, (0, constants_1.getMessages)(config.locale))));
     const scheduler = new scheduler_1.Scheduler(ctx, config, logger, digest, dispatcher, guard, async () => {
-        await digest.localizer.save();
+        await Promise.all([digest.localizer.save(), digest.verdicts.save()]);
         // 顺手把已完结的订阅清掉；`pruneFinishedSubscriptions` 自己按天去重
         await digest.pruneFinishedSubscriptions().catch((error) => {
             logger.debug('[lifecycle] 清理已完结订阅失败: %s', (0, utils_1.errorMessage)(error));
@@ -123,7 +124,7 @@ function apply(ctx, rawConfig) {
     ctx.on('ready', async () => {
         try {
             renderer.init();
-            await Promise.all([localizeReady, indexReady]);
+            await Promise.all([localizeReady, indexReady, verdictReady]);
             const anyPushEnabled = config.push.dailyEnabled
                 || config.push.nightEnabled
                 || config.push.weeklyEnabled
@@ -142,9 +143,14 @@ function apply(ctx, rawConfig) {
     });
     ctx.on('dispose', async () => {
         scheduler.stop();
-        await digest.localizer.save().catch((error) => {
-            logger.debug('[lifecycle] 保存本地化缓存失败: %s', (0, utils_1.errorMessage)(error));
-        });
+        await Promise.all([
+            digest.localizer.save().catch((error) => {
+                logger.debug('[lifecycle] 保存本地化缓存失败: %s', (0, utils_1.errorMessage)(error));
+            }),
+            digest.verdicts.save().catch((error) => {
+                logger.debug('[lifecycle] 保存判定缓存失败: %s', (0, utils_1.errorMessage)(error));
+            }),
+        ]);
     });
 }
 function registerCommands(ctx, deps) {

package/lib/services/digest.d.ts

@@ -3,6 +3,7 @@ import type { Config } from '../config';
 import type { AnimeChannel, AnimeSubscription, Digest, DigestItem, DigestKind } from '../types';
 import type { AiringStatusService } from './airing';
 import { Localizer } from './localizer';
+import { VerdictCache } from './verdicts';
 import type { HttpClient } from './network';
 import { BangumiDataIndex } from '../data/bangumi-data';
 /**
@@ -16,6 +17,8 @@ export declare class DigestService {
     /** AniList 播出状态查询；未注入时退化为「按 Bangumi 逐集档期判断」 */
     private airing?;
     readonly localizer: Localizer;
+    /** 「不采信 / 已剔除」的持久化判定，避免每次构建重复请求与判断 */
+    readonly verdicts: VerdictCache;
     /** 已构建结果的短缓存，见 `shared()` */
     private readonly recentBuilds;
     /** 同一份内容正被构建时，后来的调用直接等它，不重复构建 */
@@ -76,6 +79,11 @@ export declare class DigestService {
      * 3. `dropFinishedByEpisodeDates`（Bangumi 逐集档期的末話日期，需 `/v0/subjects` + `/v0/episodes`）
      * 顺序很重要：1、2 不新增请求，先把大部分候选挡掉，3 于是只为**幸存者**付出代价。
      */
+    /**
+     * 闸门 0：上次构建已经得出「这部已完结 / 这条记录不可信」的结论，直接复用，不再请求
+     * AniList，也不再为它取 Bangumi 逐集档期。只影响按播出时刻列作品的表，本季表不走这里。
+     */
+    private dropCachedVerdicts;
     /**
      * 闸门 1：只看本地索引就能判定「已播完」，**不产生任何请求**。依据是 bangumi-data 的 `end`
      * 与「近期开播且后续仍有排期」（当季条目 `end` 几乎为空，靠这条兜住）。
@@ -97,6 +105,8 @@ export declare class DigestService {
      * @param fromMs 以哪个时刻为准：出表闸门用该场的播出时刻，订阅清理用当前时刻。
      */
     private aniListFinished;
+    /** 已确认完结时，下一场从哪个时刻之后可以直接剔除（用于判定缓存） */
+    private aniListDropAfterMs;
     /**
      * 这条 AniList 记录与 `base` 是不是同一季。**只用于「是否已播完」，不用于排期**（`status`
      * 一旦采信就会把作品从各表里剔除）。取逐話时刻时故意不做这个校验，见 `applyAiringSchedule`。

package/lib/services/digest.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigestService = void 0;
 const constants_1 = require("../constants");
 const localizer_1 = require("./localizer");
+const verdicts_1 = require("./verdicts");
 const time_1 = require("../utils/time");
 const utils_1 = require("../utils");
 /** 「本周表」向后覆盖的天数 */
@@ -91,6 +92,8 @@ class DigestService {
     index;
     airing;
     localizer;
+    /** 「不采信 / 已剔除」的持久化判定，避免每次构建重复请求与判断 */
+    verdicts;
     /** 已构建结果的短缓存，见 `shared()` */
     recentBuilds = new Map();
     /** 同一份内容正被构建时，后来的调用直接等它，不重复构建 */
@@ -103,6 +106,7 @@ class DigestService {
         this.index = index;
         this.airing = airing;
         this.localizer = new localizer_1.Localizer(ctx, config, logger, http);
+        this.verdicts = new verdicts_1.VerdictCache(ctx, logger);
     }
     get timeZone() {
         return this.config.timeZone;
@@ -112,7 +116,7 @@ class DigestService {
     }
     /** 等索引与本地化缓存就绪 */
     async prepare() {
-        await Promise.all([this.index.ensure(), this.localizer.ensure()]);
+        await Promise.all([this.index.ensure(), this.localizer.ensure(), this.verdicts.ensure()]);
     }
     // #region 排期推算
     /**
@@ -366,6 +370,22 @@ class DigestService {
      * 3. `dropFinishedByEpisodeDates`（Bangumi 逐集档期的末話日期，需 `/v0/subjects` + `/v0/episodes`）
      * 顺序很重要：1、2 不新增请求，先把大部分候选挡掉，3 于是只为**幸存者**付出代价。
      */
+    /**
+     * 闸门 0：上次构建已经得出「这部已完结 / 这条记录不可信」的结论，直接复用，不再请求
+     * AniList，也不再为它取 Bangumi 逐集档期。只影响按播出时刻列作品的表，本季表不走这里。
+     */
+    dropCachedVerdicts(candidates) {
+        let dropped = 0;
+        const kept = candidates.filter((candidate) => {
+            if (!this.verdicts.shouldDrop(candidate.entry, candidate.atMs))
+                return true;
+            dropped++;
+            return false;
+        });
+        if (dropped > 0)
+            (0, utils_1.debugLog)('[digest] 按判定缓存剔除 %d 场', dropped);
+        return kept;
+    }
     /**
      * 闸门 1：只看本地索引就能判定「已播完」，**不产生任何请求**。依据是 bangumi-data 的 `end`
      * 与「近期开播且后续仍有排期」（当季条目 `end` 几乎为空，靠这条兜住）。
@@ -393,11 +413,24 @@ class DigestService {
         let dropped = 0;
         const kept = candidates.filter((candidate) => {
             const state = candidate.entry.aniListId === null ? undefined : airing.get(candidate.entry.aniListId);
-            // 以「这一场的播出时刻」为准。无法判定（不是同季、终映日异常）时一律保留：
+            // 记录指向别季：以后不必再请求这条 ID，直接跳过（由闸门 3 用 Bangumi 档期兜底）。
+            // 顺手从本次状态表里删掉，免得闸门 3 再校验一次、也免得 `applyAiringSchedule`
+            // 误用别季的逐话时刻。
+            if (state && !this.isSameAniListSeason(state, candidate.entry.broadcastMs)) {
+                this.verdicts.record(candidate.entry, 'anilist-mismatch');
+                if (candidate.entry.aniListId !== null)
+                    airing.delete(candidate.entry.aniListId);
+                return true;
+            }
+            // 以「这一场的播出时刻」为准。无法判定（终映日异常）时一律保留：
             // 表格里多留一部只是不好看，误删一部会让用户以为没更新。
-            const finished = this.aniListFinished(state, candidate.entry.broadcastMs, now, candidate.atMs);
+            const finished = this.aniListFinished(state, candidate.entry.broadcastMs, now, candidate.atMs, true);
             if (finished !== true)
                 return true;
+            this.verdicts.record(candidate.entry, 'anilist-finished', {
+                // 下一场只要晚于末集时刻就必定也已播完，不必再请求 AniList
+                dropAfterMs: this.aniListDropAfterMs(state, candidate.atMs),
+            });
             (0, utils_1.debugLog)('[digest] 剔除 %s：AniList 状态 %s，已播 %s / %s 集，终映 %s', candidate.entry.title, state?.status ?? '?', state?.airedEpisodes ?? '?', state?.episodes ?? '?', state?.endDate ?? '?');
             dropped++;
             return false;
@@ -415,8 +448,8 @@ class DigestService {
      *
      * @param fromMs 以哪个时刻为准：出表闸门用该场的播出时刻，订阅清理用当前时刻。
      */
-    aniListFinished(state, base, now, fromMs) {
-        if (!state || !this.isSameAniListSeason(state, base))
+    aniListFinished(state, base, now, fromMs, seasonChecked = false) {
+        if (!state || (!seasonChecked && !this.isSameAniListSeason(state, base)))
             return null;
         // 还在连载或还没开播，一律不算完结
         if (state.status === 'RELEASING' || state.status === 'NOT_YET_RELEASED')
@@ -440,6 +473,18 @@ class DigestService {
         }
         return null;
     }
+    /** 已确认完结时，下一场从哪个时刻之后可以直接剔除（用于判定缓存） */
+    aniListDropAfterMs(state, fallback) {
+        if (state?.lastAiredMs !== null && state?.lastAiredMs !== undefined)
+            return state.lastAiredMs;
+        if (state?.endDate) {
+            const endMs = Date.parse(`${state.endDate}T00:00:00Z`);
+            if (Number.isFinite(endMs))
+                return endMs;
+        }
+        // 字段不全时退回本次场次：至少之后的场次不会再重复请求
+        return fallback;
+    }
     /**
      * 这条 AniList 记录与 `base` 是不是同一季。**只用于「是否已播完」，不用于排期**（`status`
      * 一旦采信就会把作品从各表里剔除）。取逐話时刻时故意不做这个校验，见 `applyAiringSchedule`。
@@ -496,14 +541,26 @@ class DigestService {
         if (missing.size > pending.length) {
             (0, utils_1.debugLog)('[digest] 还有 %d 部缺 AniList ID 的条目未处理，留待后续构建', missing.size - pending.length);
         }
-        const ids = candidates
-            .map((candidate) => candidate.entry.aniListId)
-            .filter((id) => id !== null);
-        if (!ids.length)
+        const ids = new Set();
+        let cachedSkipped = 0;
+        for (const candidate of candidates) {
+            const { entry } = candidate;
+            if (entry.aniListId === null)
+                continue;
+            // 上次已确认这条 AniList 记录指向别季：不再请求，闸门 3 会改用 Bangumi 逐集档期
+            if (this.verdicts.shouldSkipAniList(entry)) {
+                cachedSkipped++;
+                continue;
+            }
+            ids.add(entry.aniListId);
+        }
+        if (cachedSkipped > 0)
+            (0, utils_1.debugLog)('[digest] 按判定缓存跳过 %d 个 AniList 状态请求', cachedSkipped);
+        if (!ids.size)
             return new Map();
         await this.airing.ensure();
         try {
-            return await this.airing.resolve(ids, this.config.localize.airingTtlHours / 24, now);
+            return await this.airing.resolve([...ids], this.config.localize.airingTtlHours / 24, now);
         }
         catch (error) {
             (0, utils_1.debugLog)('[digest] AniList 状态查询失败，本次按逐集档期判定: %s', (0, utils_1.errorMessage)(error));
@@ -519,11 +576,17 @@ class DigestService {
             return candidates;
         let dropped = 0;
         let skipped = 0;
+        let cached = 0;
         // 这一段的明细一部一行，用有上限的记录器兜住
         const detail = boundedLog();
         const kept = candidates.filter((candidate) => {
             const id = candidate.entry.bangumiId;
             const base = candidate.entry.broadcastMs;
+            // 上次已确认逐集档期与开播日期对不上：不再判断，直接按本地排期保留
+            if (this.verdicts.shouldSkipEpisodeDates(candidate.entry)) {
+                cached++;
+                return true;
+            }
             // AniList 已经对这部作品表态（同一季）→ 由它说了算，逐集档期不得推翻
             const state = candidate.entry.aniListId === null ? undefined : airing?.get(candidate.entry.aniListId);
             if (state && this.isSameAniListSeason(state, base)) {
@@ -540,6 +603,7 @@ class DigestService {
             const apiFirst = entry?.firstAirMs ?? null;
             if (apiFirst !== null && Math.abs(base - apiFirst) > STALE_SEASON_GAP_DAYS * 86400000) {
                 detail.log('[digest] 剔除 %s: 开播日期 %s 与逐集档期首集 %s 相差 %d 天，上游数据不一致', candidate.entry.title, new Date(base).toISOString().slice(0, 10), new Date(apiFirst).toISOString().slice(0, 10), Math.round((base - apiFirst) / 86400000));
+                this.verdicts.record(candidate.entry, 'episode-mismatch');
                 dropped++;
                 return false;
             }
@@ -552,11 +616,13 @@ class DigestService {
             const offsetPeriods = (stated - expectedLast) / period;
             if (Math.abs(offsetPeriods) > FINAL_EPISODE_TOLERANCE_PERIODS) {
                 detail.log('[digest] 不采信 %s 的逐集档期: 第 %d 集推算 %s，档期给出 %s（差 %s 个周期）', candidate.entry.title, total, new Date(expectedLast).toISOString().slice(0, 10), lastLabel, offsetPeriods.toFixed(1));
+                this.verdicts.markEpisodeUntrusted(candidate.entry);
                 return true;
             }
             const spanDays = (stated - base) / 86400000;
             if (spanDays > (total - 1) * periodDays + FINAL_EPISODE_SPAN_SLACK_DAYS) {
                 detail.log('[digest] 不采信 %s 的逐集档期: 跨度 %d 天超出 %d 集的最小跨度', candidate.entry.title, Math.round(spanDays), total);
+                this.verdicts.markEpisodeUntrusted(candidate.entry);
                 return true;
             }
             // 判据：**这一场的 JST 日期已越过末集一天以上**。
@@ -567,6 +633,7 @@ class DigestService {
             const lastDay = Math.floor(stated / 86400000);
             if (candidateDay - lastDay <= FINAL_EPISODE_DAY_GRACE)
                 return true;
+            this.verdicts.record(candidate.entry, 'episode-finished', { dropAfterDay: lastDay });
             detail.log('[digest] 剔除 %s: 末集 %s，本场已在其后 %d 天', candidate.entry.title, lastLabel, candidateDay - lastDay);
             dropped++;
             return false;
@@ -578,6 +645,8 @@ class DigestService {
             (0, utils_1.debugLog)('[digest] 剔除已播完的作品 %d 部（Bangumi 逐集档期）', dropped);
         if (skipped > 0)
             (0, utils_1.debugLog)('[digest] %d 部由 AniList 判定，逐集档期未参与', skipped);
+        if (cached > 0)
+            (0, utils_1.debugLog)('[digest] %d 部按判定缓存跳过逐集档期判断', cached);
         return kept;
     }
     /**
@@ -611,6 +680,9 @@ class DigestService {
      */
     async subjectsForEpisodeDates(candidates, airing) {
         const wanted = candidates.filter((candidate) => {
+            // 上次已判定逐集档期不可信 → 闸门 3 不参与，详情不必为此取
+            if (this.verdicts.shouldSkipEpisodeDates(candidate.entry))
+                return false;
             const state = candidate.entry.aniListId === null ? undefined : airing?.get(candidate.entry.aniListId);
             // AniList 已表态（同一季）→ 闸门 3 不参与，详情不必取
             return !(state && this.isSameAniListSeason(state, candidate.entry.broadcastMs));
@@ -777,12 +849,13 @@ class DigestService {
         const window = this.windowMeta(kind, now, options.fromMs);
         const predicted = this.airingsIn(options);
         (0, utils_1.debugLog)('[digest] %s: 推算 %d 场', kind, predicted.length);
-        // ── 闸门 1 + 2：都不需要新增请求，先把大部分候选挡掉 ──
+        // ── 闸门 0 + 1 + 2：都不需要新增请求，先把大部分候选挡掉 ──
         //
-        // bangumi-data 的 `end` 与「近期仍有排期」是纯本地判定，AniList 状态本来就要取，
-        // 因此下面只为幸存者请求 Bangumi 详情。
+        // 判定缓存复用上次的「已完结 / 记录不可信」结论；bangumi-data 的 `end` 与
+        // 「近期仍有排期」是纯本地判定；AniList 状态本来就要取，因此下面只为幸存者请求 Bangumi 详情。
+        const cached = this.dropCachedVerdicts(predicted);
         const following = this.followingKeys(now);
-        const locallyKept = this.dropLocallyFinished(predicted, options.fromMs, following);
+        const locallyKept = this.dropLocallyFinished(cached, options.fromMs, following);
         const airingStates = await this.airingStatesOf(locallyKept, now);
         const survived = this.dropFinishedByAniList(locallyKept, options.fromMs, airingStates);
         // ── 闸门 3：只为**真正要判的**作品取 Bangumi 详情 ──
@@ -1054,9 +1127,10 @@ class DigestService {
             activeOnly: false,
             onePerTitle: true,
         }).filter((candidate) => wanted.has(defaultTidOf(candidate.entry) ?? candidate.entry.key));
-        // 与 buildAirings 同一套三段闸门：先本地、再 AniList、最后才为幸存者取 Bangumi 逐集档期
+        // 与 buildAirings 同一套闸门：先复用判定缓存与本地依据，再 AniList、最后才为幸存者取 Bangumi 逐集档期
+        const cached = this.dropCachedVerdicts(candidates);
         const following = this.followingKeys(startMs);
-        const locallyKept = this.dropLocallyFinished(candidates, startMs, following);
+        const locallyKept = this.dropLocallyFinished(cached, startMs, following);
         const airingStates = await this.airingStatesOf(locallyKept, now);
         const survived = this.dropFinishedByAniList(locallyKept, startMs, airingStates);
         // 与 `buildAirings` 同一套做法：只为闸门 3 真正要判的作品取详情
@@ -1215,20 +1289,30 @@ class DigestService {
         }
         if (!entries.size)
             return [];
-        const states = await this.resolveAiringStates([...entries.values()], now);
-        return [...entries].filter(([, entry]) => this.isEntryFinished(entry, states, now)).map(([tid]) => tid);
+        // 判定缓存已确认完结的作品不再请求 AniList；其余仍按状态与本地 end 判断
+        const graceNow = now - 86400000;
+        const pending = [...entries.values()].filter((entry) => !this.verdicts.shouldDrop(entry, graceNow));
+        const states = await this.resolveAiringStates(pending, now);
+        return [...entries]
+            .filter(([, entry]) => this.verdicts.shouldDrop(entry, graceNow) || this.isEntryFinished(entry, states, now))
+            .map(([tid]) => tid);
     }
     /** 批量取这批条目对应的 AniList 状态；取不到时返回空表（调用方会退回本地依据） */
     async resolveAiringStates(entries, now) {
         if (!this.airing)
             return new Map();
-        const ids = entries
-            .map((entry) => entry.aniListId)
-            .filter((id) => id !== null);
-        if (!ids.length)
+        const ids = new Set();
+        for (const entry of entries) {
+            if (entry.aniListId === null)
+                continue;
+            if (this.verdicts.shouldSkipAniList(entry))
+                continue;
+            ids.add(entry.aniListId);
+        }
+        if (!ids.size)
             return new Map();
         try {
-            return await this.airing.resolve(ids, this.config.localize.airingTtlHours / 24, now);
+            return await this.airing.resolve([...ids], this.config.localize.airingTtlHours / 24, now);
         }
         catch (error) {
             (0, utils_1.debugLog)('[digest] 取 AniList 状态失败，改用本地依据: %s', (0, utils_1.errorMessage)(error));
@@ -1300,6 +1384,9 @@ class DigestService {
      * 而那一话要到晚上才播，当天就停用订阅会让用户以为漏了最后一集。
      */
     isEntryFinished(entry, states, now) {
+        // 判定缓存已经把「已完结」定论过：不必再请求 AniList；沿用现有的一天宽限
+        if (this.verdicts.shouldDrop(entry, now - 86400000))
+            return true;
         const state = entry.aniListId === null ? undefined : states.get(entry.aniListId);
         const finished = this.aniListFinished(state, entry.broadcastMs, now, now - 86400000);
         if (finished !== null)

package/lib/services/verdicts.d.ts

@@ -0,0 +1,85 @@
+import type { Context, Logger } from 'koishi';
+import type { IndexEntry } from '../data/bangumi-data';
+/**
+ * 判定缓存记录的原因。只保存**下次构建仍会得出同一结论**的判定：
+ *
+ * - `anilist-mismatch`：AniList 记录指向别季，不应再拿它的状态做完结判断；
+ * - `anilist-finished`：AniList 已确认完结，且给出了最后一集的时刻；
+ * - `episode-mismatch`：bangumi-data 的开播日期与 Bangumi 逐集档期首集相差数年，
+ *   这个条目已不可信；
+ * - `episode-untrusted`：Bangumi 逐集档期的末集与开播日期推算差得太远，不能拿来完结判断，
+ *   但作品本身仍应保留；
+ * - `episode-finished`：Bangumi 逐集档期确认末集已过去。
+ *
+ * 与「本次窗口」有关的判定（例如 AniList 排期没覆盖本周）不写入缓存，否则会挡住后续
+ * 真正的更新。
+ */
+export type VerdictReason = 'anilist-mismatch' | 'anilist-finished' | 'episode-mismatch' | 'episode-untrusted' | 'episode-finished';
+export interface VerdictRecord {
+    key: string;
+    title: string;
+    reason: VerdictReason;
+    /** 判定作出时条目的 AniList ID；AniList ID 变了就作废 */
+    aniListId: number | null;
+    /** 精确时刻判定：`atMs` 晚于它才剔除（用于 AniList 的末集时刻） */
+    dropAfterMs: number | null;
+    /** 按日判定：场次的 JST 日期晚于它才剔除（用于 Bangumi 的末集日期） */
+    dropAfterDay: number | null;
+    at: number;
+    expiresAt: number;
+}
+/**
+ * 「不采信 / 已剔除」判定的本地持久化缓存。
+ *
+ * 这些判定的输入（bangumi-data 的 `aniList` ID、逐集档期）很少变化，但原实现每次构建
+ * 都会重新查 AniList、重新算一遍，然后再次得出「这条记录不是这一季」或「这部已经播完」。
+ * 周表一次构建要为此多发几十个请求、多打几十行日志。
+ *
+ * 缓存只影响 daily / night / weekly / sub 的完结闸门，**不影响本季表**：季表本来就要
+ * 展示整季作品，不能因为「已完结」把它们藏起来。
+ */
+export declare class VerdictCache {
+    private ctx;
+    private logger;
+    private readonly records;
+    private readonly cachePath;
+    private loaded;
+    private loadPromise;
+    private dirty;
+    private flushTimer;
+    private flushing;
+    private writeFailed;
+    constructor(ctx: Context, logger: Logger);
+    /** 确保缓存已从磁盘读取；重复调用只读一次 */
+    ensure(): Promise<void>;
+    load(): Promise<void>;
+    /** 这条场次是否已被缓存判定为「应当剔除」 */
+    shouldDrop(entry: IndexEntry, atMs: number): boolean;
+    /** 是否应跳过这条条目的 AniList 状态请求（记录指向别季） */
+    shouldSkipAniList(entry: IndexEntry): boolean;
+    /**
+     * 是否应跳过这条条目的逐集档期完结判断。
+     *
+     * 与 AniList 判定分开存：一部作品可能同时「AniList 指向别季」和「Bangumi 逐集档期不可信」，
+     * 两条判定都要保留，不能互相覆盖，所以逐集档期用独立的 `#episodes` 键。
+     */
+    shouldSkipEpisodeDates(entry: IndexEntry): boolean;
+    /** 记录一次判定；同一部作品后出现的「剔除」记录可以覆盖较轻的「不采信」 */
+    record(entry: IndexEntry, reason: VerdictReason, patch?: {
+        dropAfterMs?: number | null;
+        dropAfterDay?: number | null;
+    }): void;
+    /** Bangumi 逐集档期不可信：只影响闸门 3，不影响是否剔除作品 */
+    markEpisodeUntrusted(entry: IndexEntry): void;
+    private episodeKey;
+    private put;
+    /** 取出仍在有效期内的记录；AniList 判定还要求 ID 没变 */
+    private active;
+    /** 主动落盘，插件卸载与调度结束时调用 */
+    save(): Promise<void>;
+    /** 同 Localizer：串行写盘，失败时保留 dirty 供下次重试 */
+    private flush;
+    private writeCache;
+    private prune;
+    private scheduleFlush;
+}

package/lib/services/verdicts.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerdictCache = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const VERDICT_REASONS = new Set([
+    'anilist-mismatch',
+    'anilist-finished',
+    'episode-mismatch',
+    'episode-untrusted',
+    'episode-finished',
+]);
+const DAY_MS = 86400000;
+/** AniList 与 Bangumi 的末集日期都是 UTC 零点，判断「同一场」时必须换算成 JST 日期 */
+function jstDay(ms) {
+    return Math.floor((ms + 9 * 3600000) / DAY_MS);
+}
+function isDropReason(reason) {
+    return reason === 'anilist-finished'
+        || reason === 'episode-mismatch'
+        || reason === 'episode-finished';
+}
+/**
+ * 「不采信 / 已剔除」判定的本地持久化缓存。
+ *
+ * 这些判定的输入（bangumi-data 的 `aniList` ID、逐集档期）很少变化，但原实现每次构建
+ * 都会重新查 AniList、重新算一遍，然后再次得出「这条记录不是这一季」或「这部已经播完」。
+ * 周表一次构建要为此多发几十个请求、多打几十行日志。
+ *
+ * 缓存只影响 daily / night / weekly / sub 的完结闸门，**不影响本季表**：季表本来就要
+ * 展示整季作品，不能因为「已完结」把它们藏起来。
+ */
+class VerdictCache {
+    ctx;
+    logger;
+    records = new Map();
+    cachePath;
+    loaded = false;
+    loadPromise = null;
+    dirty = false;
+    flushTimer = null;
+    flushing = null;
+    writeFailed = false;
+    constructor(ctx, logger) {
+        this.ctx = ctx;
+        this.logger = logger;
+        this.cachePath = (0, path_1.resolve)(ctx.baseDir, ...constants_1.DATA_DIR, constants_1.VERDICT_CACHE_FILE);
+    }
+    /** 确保缓存已从磁盘读取；重复调用只读一次 */
+    ensure() {
+        if (this.loaded)
+            return Promise.resolve();
+        return this.load();
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        if (this.loadPromise)
+            return this.loadPromise;
+        this.loadPromise = (async () => {
+            try {
+                const text = await fs_1.promises.readFile(this.cachePath, 'utf8');
+                const parsed = JSON.parse(text);
+                if (parsed?.version !== constants_1.VERDICT_CACHE_VERSION || !parsed.entries) {
+                    this.logger.info('[verdict] 缓存版本 %s 与当前 %d 不符，本次重新构建', parsed?.version ?? '(无)', constants_1.VERDICT_CACHE_VERSION);
+                    return;
+                }
+                for (const record of Object.values(parsed.entries)) {
+                    if (!record || typeof record.key !== 'string' || !VERDICT_REASONS.has(record.reason))
+                        continue;
+                    if (typeof record.expiresAt !== 'number' || typeof record.at !== 'number')
+                        continue;
+                    if (record.expiresAt <= Date.now())
+                        continue;
+                    this.records.set(record.key, record);
+                }
+                (0, utils_1.debugLog)('[verdict] 判定缓存载入完成，条目数: %d', this.records.size);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    this.logger.warn('[verdict] 读取判定缓存失败，将从空缓存开始:', error);
+                }
+            }
+            finally {
+                this.loaded = true;
+            }
+        })();
+        return this.loadPromise;
+    }
+    /** 这条场次是否已被缓存判定为「应当剔除」 */
+    shouldDrop(entry, atMs) {
+        const record = this.active(entry);
+        if (!record)
+            return false;
+        if (record.reason === 'episode-mismatch')
+            return true;
+        if (record.reason === 'anilist-finished') {
+            return record.dropAfterMs !== null && atMs > record.dropAfterMs;
+        }
+        if (record.reason === 'episode-finished') {
+            return record.dropAfterDay !== null && jstDay(atMs) > record.dropAfterDay;
+        }
+        return false;
+    }
+    /** 是否应跳过这条条目的 AniList 状态请求（记录指向别季） */
+    shouldSkipAniList(entry) {
+        return this.active(entry)?.reason === 'anilist-mismatch';
+    }
+    /**
+     * 是否应跳过这条条目的逐集档期完结判断。
+     *
+     * 与 AniList 判定分开存：一部作品可能同时「AniList 指向别季」和「Bangumi 逐集档期不可信」，
+     * 两条判定都要保留，不能互相覆盖，所以逐集档期用独立的 `#episodes` 键。
+     */
+    shouldSkipEpisodeDates(entry) {
+        const record = this.records.get(this.episodeKey(entry));
+        return record?.reason === 'episode-untrusted' && record.expiresAt > Date.now();
+    }
+    /** 记录一次判定；同一部作品后出现的「剔除」记录可以覆盖较轻的「不采信」 */
+    record(entry, reason, patch = {}) {
+        this.put(entry.key, entry, reason, patch);
+    }
+    /** Bangumi 逐集档期不可信：只影响闸门 3，不影响是否剔除作品 */
+    markEpisodeUntrusted(entry) {
+        this.put(this.episodeKey(entry), entry, 'episode-untrusted');
+    }
+    episodeKey(entry) {
+        return `${entry.key}#episodes`;
+    }
+    put(cacheKey, entry, reason, patch = {}) {
+        const now = Date.now();
+        const previous = this.records.get(cacheKey);
+        if (previous && previous.expiresAt > now) {
+            // 已经确认剔除的作品，不要再被一次「不采信」降级；反过来则可以
+            if (isDropReason(previous.reason) && !isDropReason(reason))
+                return;
+            // 相同内容不重复写盘
+            if (previous.reason === reason
+                && previous.aniListId === entry.aniListId
+                && previous.dropAfterMs === (patch.dropAfterMs ?? null)
+                && previous.dropAfterDay === (patch.dropAfterDay ?? null)) {
+                return;
+            }
+        }
+        const ttl = reason === 'anilist-mismatch' || reason === 'anilist-finished'
+            ? constants_1.ANILIST_VERDICT_TTL_MS
+            : constants_1.EPISODE_VERDICT_TTL_MS;
+        this.records.set(cacheKey, {
+            key: cacheKey,
+            title: entry.title,
+            reason,
+            aniListId: entry.aniListId,
+            dropAfterMs: patch.dropAfterMs ?? null,
+            dropAfterDay: patch.dropAfterDay ?? null,
+            at: now,
+            expiresAt: now + ttl,
+        });
+        this.dirty = true;
+        (0, utils_1.debugLog)('[verdict] 记录判定: %s → %s', entry.title, reason);
+        this.scheduleFlush();
+    }
+    /** 取出仍在有效期内的记录；AniList 判定还要求 ID 没变 */
+    active(entry) {
+        const record = this.records.get(entry.key);
+        if (!record || record.expiresAt <= Date.now())
+            return undefined;
+        if ((record.reason === 'anilist-mismatch' || record.reason === 'anilist-finished')
+            && record.aniListId !== entry.aniListId) {
+            return undefined;
+        }
+        return record;
+    }
+    /** 主动落盘，插件卸载与调度结束时调用 */
+    async save() {
+        if (this.flushTimer) {
+            this.flushTimer();
+            this.flushTimer = null;
+        }
+        await this.flush();
+        if (this.dirty && !this.flushing)
+            await this.flush();
+    }
+    /** 同 Localizer：串行写盘，失败时保留 dirty 供下次重试 */
+    flush() {
+        if (this.flushing)
+            return this.flushing;
+        if (!this.dirty)
+            return Promise.resolve();
+        this.flushing = this.writeCache().finally(() => {
+            this.flushing = null;
+            if (this.dirty && !this.writeFailed)
+                this.scheduleFlush();
+        });
+        return this.flushing;
+    }
+    async writeCache() {
+        this.dirty = false;
+        this.prune();
+        if (this.records.size > constants_1.VERDICT_CACHE_MAX_ENTRIES) {
+            const sorted = [...this.records.values()].sort((a, b) => a.expiresAt - b.expiresAt);
+            const drop = sorted.slice(0, sorted.length - Math.floor(constants_1.VERDICT_CACHE_MAX_ENTRIES / 2));
+            for (const record of drop)
+                this.records.delete(record.key);
+        }
+        const payload = { version: constants_1.VERDICT_CACHE_VERSION, entries: {} };
+        for (const [key, record] of this.records)
+            payload.entries[key] = record;
+        const temp = `${this.cachePath}.tmp`;
+        try {
+            await fs_1.promises.mkdir((0, path_1.dirname)(this.cachePath), { recursive: true });
+            await fs_1.promises.writeFile(temp, JSON.stringify(payload), 'utf8');
+            await fs_1.promises.rename(temp, this.cachePath);
+            this.writeFailed = false;
+        }
+        catch (error) {
+            this.dirty = true;
+            this.writeFailed = true;
+            this.logger.warn('[verdict] 写入判定缓存失败:', (0, utils_1.errorMessage)(error));
+            await fs_1.promises.rm(temp, { force: true }).catch(() => undefined);
+        }
+    }
+    prune() {
+        const now = Date.now();
+        for (const [key, record] of this.records) {
+            if (record.expiresAt <= now)
+                this.records.delete(key);
+        }
+    }
+    scheduleFlush() {
+        this.dirty = true;
+        if (this.flushTimer)
+            return;
+        this.flushTimer = this.ctx.setTimeout(() => {
+            this.flushTimer = null;
+            void this.flush();
+        }, 3000);
+    }
+}
+exports.VerdictCache = VerdictCache;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-anime-schedule",
   "description": "番剧时间表与订阅提醒：提供日 / 周 / 季三表，支持定时推送、指定订阅、搜索和详情展示",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -42,6 +42,9 @@ npm i koishi-plugin-anime-schedule
   TV / WEB 动画，展示首播时间。
 - **现在时刻**：每日与深夜档的时间轴用一条虚线标出当前时刻，线以上已播出、线以下未播出。
 - **完结判定**：以 AniList 为准，播完的作品自动从各表与订阅列表中移除。
+- **判定缓存**：把「AniList 记录指向别季」「已确认完结」「逐集档期不可信」等稳定判定写入
+  `data/anime-schedule/verdicts.json`，后续构建不再重复请求与判断；AniList 判定 7 天、
+  Bangumi 档期判定 30 天后自动失效，只影响每日 / 深夜 / 本周 / 订阅表，不影响本季表。
 - **时刻**：以 AniList 记录的时刻为准，查不到时按放送周期推算。
 - **去重**：每类推送按「类型 + 目标 + 日期」去重，重启或补发都只发一次。