koishi-plugin-anime-schedule 1.1.2 → 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/data/anilist-match.js

@@ -59,7 +59,11 @@ function matchByTitle(target, candidates) {
             continue;
         const startMs = startMsOf(candidate);
         const dayGap = startMs !== null && beginMs !== null ? Math.abs(startMs - beginMs) / DAY : null;
-        if (dayGap !== null && dayGap > exports.MAX_DAY_GAP)
+        // 标题相等只说明是同一部作品，不能排除同名续作；首播日期缺失时无法校验，直接放弃，
+        // 否则「第 2 期」这类同名条目会被错配到前一季。
+        if (dayGap === null)
+            continue;
+        if (dayGap > exports.MAX_DAY_GAP)
             continue;
         const nodes = (candidate.airingSchedule?.nodes ?? []).filter((node) => typeof node.airingAt === 'number');
         const first = nodes.length

package/lib/handlers.js

@@ -380,13 +380,9 @@ async function commandSubList(deps, session) {
         const upcoming = await digest.upcomingAirings(tids, 31);
         // `upcomingAirings` 会滤掉已播完的作品，故单独查询一次用于标注「已播完」
         const finished = new Set(await digest.finishedSubscriptionTids(tids));
-        const names = new Map();
+        const names = await digest.resolveSubscriptionNames(tids);
         const nextOf = new Map();
         const todayOf = new Map();
-        for (const row of rows) {
-            const resolved = await digest.resolveSubscriptionName(row.tid);
-            names.set(row.tid, resolved ?? row.title ?? row.tid);
-        }
         for (const item of upcoming) {
             if (!nextOf.has(item.tid))
                 nextOf.set(item.tid, item);
@@ -508,7 +504,8 @@ async function commandSubClear(deps, session) {
 /** 查询订阅作品未来若干天的播出计划 */
 async function commandNext(deps, session, daysText) {
     const { config, digest } = deps;
-    const days = (0, utils_1.clamp)(Number.parseInt(daysText ?? '7', 10) || 7, 1, 31);
+    const parsed = Number.parseInt(daysText ?? '7', 10);
+    const days = (0, utils_1.clamp)(Number.isFinite(parsed) ? parsed : 7, 1, 31);
     try {
         const rows = await digest.listSubscriptions(platformOf(session), channelOf(session));
         if (!rows.length)
@@ -545,7 +542,7 @@ function commandOff(deps, session, kindText) {
     return togglePush(deps, session, kindText, false);
 }
 async function togglePush(deps, session, kindText, enabled) {
-    const { config, digest } = deps;
+    const { ctx, config, digest } = deps;
     if (!session.guildId)
         return constants_1.RESPONSES.needGuild;
     const raw = (kindText ?? '').trim().toLowerCase();
@@ -569,6 +566,13 @@ async function togglePush(deps, session, kindText, enabled) {
                 enabled: true,
             });
         }
+        else if (existing.botId !== session.selfId || existing.guildId !== session.guildId) {
+            // 机器人换号或频道迁移后，开播提醒要能找到当前机器人；顺手刷新归属信息
+            await ctx.database.set('anime_channel', {
+                platform: platformOf(session),
+                channelId: channelOf(session),
+            }, { botId: session.selfId, guildId: session.guildId });
+        }
         await digest.setKinds(platformOf(session), channelOf(session), kind === 'daily' ? { dailyEnabled: enabled }
             : kind === 'night' ? { nightEnabled: enabled }
                 : kind === 'weekly' ? { weeklyEnabled: enabled }
@@ -592,11 +596,13 @@ async function commandStatus(deps, session) {
     try {
         const channel = await digest.getChannel(platformOf(session), channelOf(session));
         const subscriptions = await digest.listSubscriptions(platformOf(session), channelOf(session));
+        const dayStart = (0, time_1.getDayStartMs)((0, time_1.today)(digest.timeZone), digest.timeZone);
+        // 只取今天的记录；以前是全量取回再在内存里过滤，推送记录攒久后会越来越慢
         const dispatches = await ctx.database.get('anime_dispatch', {
             platform: platformOf(session),
             channelId: channelOf(session),
+            dispatchedAt: { $gte: dayStart, $lt: dayStart + 86400000 },
         });
-        const dayStart = (0, time_1.getDayStartMs)((0, time_1.today)(digest.timeZone), digest.timeZone);
         const formatText = config.output.format === 'image'
             ? `图片 (${config.output.layout === 'list' ? '卡片列表' : '时间表'})`
             : `纯文本${config.output.useForward ? ' (合并转发)' : ''}`;
@@ -611,7 +617,7 @@ async function commandStatus(deps, session) {
             `订阅番剧: ${subscriptions.length} 部${config.subscription.maxPerChannel > 0 ? ` (上限 ${config.subscription.maxPerChannel})` : ''}`,
             `开播提醒: ${config.push.updateReminderEnabled ? `开，提前 ${config.push.updateLookaheadMinutes} 分钟` : '关'}`,
             // 按记录时间统计：`sub`（开播提醒）的去重键里带的是时刻而不是日期，不能靠键判断
-            `今日推送记录: ${dispatches.filter((row) => row.dispatchedAt >= dayStart && row.dispatchedAt < dayStart + 86400000).length} 条`,
+            `今日推送记录: ${dispatches.length} 条`,
         ].join('\n');
     }
     catch (error) {

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/airing.d.ts

@@ -44,6 +44,14 @@ export declare class AiringStatusService {
     /** 无需预热（缓存只在内存里），保留此方法让调用方写法统一 */
     ensure(): Promise<void>;
     private isFresh;
+    /**
+     * 标题缓存键。
+     *
+     * 不能只用折叠标题：`normalizeTitle` 会删掉「第 2 期」这类季别，不同季的同名作品
+     * 会命中同一个 ID。把开播日期（取 `beginMs`，缺失时用 `broadcastMs`）按天拼进去，
+     * 同名但不同季/不同年的作品就能区分开。
+     */
+    private titleKey;
     /**
      * 按标题给缺失 `aniList` ID 的条目补一个 ID：补上就用 AniList 的逐話時刻排期，搜不到返回
      * null 让调用方退回周期推算。结果（含「搜不到」）在进程内缓存。

package/lib/services/airing.js

@@ -79,8 +79,22 @@ class AiringStatusService {
     ensure() {
         return Promise.resolve();
     }
-    isFresh(entry, ttlDays) {
-        return Date.now() - entry.cachedAt < ttlDays * 24 * 60 * 60 * 1000;
+    isFresh(entry, ttlDays, now = Date.now()) {
+        return now - entry.cachedAt < Math.max(0, ttlDays) * 24 * 60 * 60 * 1000;
+    }
+    /**
+     * 标题缓存键。
+     *
+     * 不能只用折叠标题：`normalizeTitle` 会删掉「第 2 期」这类季别，不同季的同名作品
+     * 会命中同一个 ID。把开播日期（取 `beginMs`，缺失时用 `broadcastMs`）按天拼进去，
+     * 同名但不同季/不同年的作品就能区分开。
+     */
+    titleKey(target) {
+        const title = (0, anilist_match_1.normalizeTitle)(target.title);
+        if (!title)
+            return '';
+        const anchor = target.beginMs ?? target.broadcastMs ?? null;
+        return anchor === null ? title : `${title}@${Math.floor(anchor / 86400000)}`;
     }
     /**
      * 按标题给缺失 `aniList` ID 的条目补一个 ID：补上就用 AniList 的逐話時刻排期，搜不到返回
@@ -88,7 +102,7 @@ class AiringStatusService {
      * 校验交给 `matchByTitle`：标题相等 + 首播日期相近，缺一不可。
      */
     async resolveByTitle(target) {
-        const key = (0, anilist_match_1.normalizeTitle)(target.title);
+        const key = this.titleKey(target);
         if (!key)
             return null;
         const cached = this.idByTitle.get(key);
@@ -123,7 +137,10 @@ class AiringStatusService {
             return payload?.data?.Page?.media ?? [];
         }
         catch (error) {
-            return this.handleRequestError(error) ? null : [];
+            // 只有「成功响应但没有候选」才是 []；网络/解析失败必须返回 null，
+            // 否则会被 resolveByTitle 当成「确定搜不到」永久写入 idByTitle。
+            this.handleRequestError(error);
+            return null;
         }
     }
     /**
@@ -147,7 +164,7 @@ class AiringStatusService {
             }
             // 过期条目先返回旧值，避免一次请求失败就没有数据可用
             result.set(id, cached);
-            if (!this.isFresh(cached, ttlDays))
+            if (!this.isFresh(cached, ttlDays, now))
                 wanted.push(id);
         }
         if (!wanted.length)

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`。
@@ -280,6 +290,8 @@ export declare class DigestService {
      * @param limit 返回条数上限，`<= 0` 表示不限制
      */
     search(keyword: string, limit?: number): Promise<DigestItem[]>;
+    /** 按条目 ID 批量解析作品名；订阅列表一次取完，避免逐条串行请求 */
+    resolveSubscriptionNames(tids: string[]): Promise<Map<string, string | null>>;
     /** 按条目 ID 解析作品名；同时接受 `253104` 与 `bgm:253104` 两种写法 */
     resolveSubscriptionName(tid: string): Promise<string | null>;
 }

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)
@@ -1328,19 +1415,36 @@ class DigestService {
             return this.toItem(candidate, entry.bangumiId !== null ? subjects.get(entry.bangumiId) : undefined);
         });
     }
+    /** 按条目 ID 批量解析作品名；订阅列表一次取完，避免逐条串行请求 */
+    async resolveSubscriptionNames(tids) {
+        await this.prepare();
+        const result = new Map();
+        const entries = new Map();
+        const idByTid = new Map();
+        for (const tid of new Set(tids)) {
+            const matched = BGM_TID_RE.exec(tid) ?? BGM_ID_RE.exec(tid);
+            if (!matched) {
+                result.set(tid, null);
+                continue;
+            }
+            const id = Number(matched[1]);
+            const entry = this.index.bySubjectId(id);
+            if (!entry) {
+                result.set(tid, null);
+                continue;
+            }
+            entries.set(tid, entry);
+            idByTid.set(tid, id);
+        }
+        const subjects = await this.localizer.localizeByIds([...new Set(idByTid.values())], false);
+        for (const [tid, entry] of entries) {
+            result.set(tid, this.toItem({ entry, atMs: this.nextAirMs(entry, Date.now()), episode: 1 }, subjects.get(idByTid.get(tid))).name);
+        }
+        return result;
+    }
     /** 按条目 ID 解析作品名；同时接受 `253104` 与 `bgm:253104` 两种写法 */
     async resolveSubscriptionName(tid) {
-        await this.prepare();
-        const matched = BGM_TID_RE.exec(tid) ?? BGM_ID_RE.exec(tid);
-        if (!matched)
-            return null;
-        const id = Number(matched[1]);
-        const entry = this.index.bySubjectId(id);
-        if (!entry)
-            return null;
-        // 只是为了拿一个展示用的名字，不需要逐集档期
-        const subjects = await this.localizer.localizeByIds([id]);
-        return this.toItem({ entry, atMs: this.nextAirMs(entry, Date.now()), episode: 1 }, subjects.get(id)).name;
+        return (await this.resolveSubscriptionNames([tid])).get(tid) ?? null;
     }
 }
 exports.DigestService = DigestService;

package/lib/services/info.js

@@ -398,10 +398,16 @@ exports.InfoService = InfoService;
 function flattenSummary(summary) {
     if (!summary)
         return '';
-    return summary
+    const lines = summary
         .replace(/\r\n?/g, '\n')
         .split('\n')
         .map((line) => line.trim())
-        .filter(Boolean)
-        .join('');
+        .filter(Boolean);
+    // 中文/日文换行处不需要空格；英文单词在源文本里被折行时则需要补一个，
+    // 否则「the story」会被拼成「thestory」。
+    return lines.reduce((text, line) => {
+        if (!text)
+            return line;
+        return `${text}${/[!-~]$/.test(text) && /^[A-Za-z0-9]/.test(line) ? ' ' : ''}${line}`;
+    }, '');
 }

package/lib/services/localizer.d.ts

@@ -45,6 +45,10 @@ export declare class Localizer {
     private loadPromise;
     private dirty;
     private flushTimer;
+    /** 正在进行的写盘；并发调用共享同一个 Promise，避免两个 tmp 文件互相覆盖 */
+    private flushing;
+    /** 上一次写盘是否失败：失败后不立即重排定时器，避免磁盘故障时每 3 秒刷一条警告 */
+    private writeFailed;
     /** 本次构建里评分过期、等出图之后在后台补取的条目 */
     private readonly pendingScores;
     private refreshingScores;
@@ -54,8 +58,15 @@ export declare class Localizer {
     /** 确保磁盘缓存已读取（重复调用只读一次） */
     ensure(): Promise<void>;
     load(): Promise<void>;
-    /** 把缓存写回磁盘，写入前按时间淘汰最旧的一半 */
+    /**
+     * 把缓存写回磁盘。
+     *
+     * 同一时刻只允许一个写盘：`save()` 与 3 秒防抖可能同时触发，两个写操作会争用同一个
+     * `.tmp` 文件。`dirty` 只在写入成功后才保持 `false`；失败时重新置位，等下一次
+     * `scheduleFlush()` 或 `save()` 再试，避免一次磁盘抖动就让本次更新永久丢失。
+     */
     private flush;
+    private writeCache;
     /** 延迟合并写入，避免每次命中都落盘 */
     private scheduleFlush;
     /** 主动落盘，插件卸载与调度结束后调用 */

package/lib/services/localizer.js

@@ -60,6 +60,10 @@ class Localizer {
     loadPromise = null;
     dirty = false;
     flushTimer = null;
+    /** 正在进行的写盘；并发调用共享同一个 Promise，避免两个 tmp 文件互相覆盖 */
+    flushing = null;
+    /** 上一次写盘是否失败：失败后不立即重排定时器，避免磁盘故障时每 3 秒刷一条警告 */
+    writeFailed = false;
     /** 本次构建里评分过期、等出图之后在后台补取的条目 */
     pendingScores = new Set();
     refreshingScores = false;
@@ -115,10 +119,27 @@ class Localizer {
         })();
         return this.loadPromise;
     }
-    /** 把缓存写回磁盘，写入前按时间淘汰最旧的一半 */
-    async flush() {
+    /**
+     * 把缓存写回磁盘。
+     *
+     * 同一时刻只允许一个写盘：`save()` 与 3 秒防抖可能同时触发，两个写操作会争用同一个
+     * `.tmp` 文件。`dirty` 只在写入成功后才保持 `false`；失败时重新置位，等下一次
+     * `scheduleFlush()` 或 `save()` 再试，避免一次磁盘抖动就让本次更新永久丢失。
+     */
+    flush() {
+        if (this.flushing)
+            return this.flushing;
         if (!this.dirty)
-            return;
+            return Promise.resolve();
+        this.flushing = this.writeCache().finally(() => {
+            this.flushing = null;
+            // 写盘快照之后又有新条目：补一次合并写盘；失败时不自动重排，等下一次 save/schedule
+            if (this.dirty && !this.writeFailed)
+                this.scheduleFlush();
+        });
+        return this.flushing;
+    }
+    async writeCache() {
         this.dirty = false;
         if (this.memory.size > constants_1.LOCALIZE_CACHE_MAX_ENTRIES) {
             const sorted = [...this.memory.entries()].sort((a, b) => a[1].cachedAt - b[1].cachedAt);
@@ -134,8 +155,12 @@ class Localizer {
             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) {
+            // 写入期间可能又有新条目进来；失败后也保持 dirty，交给下一次写盘重试
+            this.dirty = true;
+            this.writeFailed = true;
             this.logger.warn('[localize] 写入本地化缓存失败:', error);
             await fs_1.promises.rm(temp, { force: true }).catch(() => undefined);
         }
@@ -157,6 +182,9 @@ class Localizer {
             this.flushTimer = null;
         }
         await this.flush();
+        // 写盘期间又产生了新条目：等当前写盘结束后再补一次
+        if (this.dirty && !this.flushing)
+            await this.flush();
     }
     /**
      * 标题、封面与首末集日期是否还能用。这几项基本不变，只受 `cacheTtlDays` 管。
@@ -204,8 +232,10 @@ class Localizer {
             result.set(id, cached);
             if (this.needsScoreRefresh(cached))
                 this.pendingScores.add(id);
-            // 只有展示数据过期、或这次要档期而缓存里没有档期时才阻塞构建
-            if (!this.isDisplayFresh(cached) || (wantEpisodeTimes && cached.hasEpisodeTimes === false)) {
+            // 只有展示数据过期、或这次要档期而缓存里没有档期时才阻塞构建。
+            // 404 占位记录带 `hasEpisodeTimes:false`，但它的 TTL 内不该反复重试，由 isDisplayFresh 决定。
+            if (!this.isDisplayFresh(cached)
+                || (wantEpisodeTimes && !cached.missing && cached.hasEpisodeTimes === false)) {
                 wanted.push(id);
                 previous.set(id, cached);
             }
@@ -219,7 +249,7 @@ class Localizer {
             //
             // 已经取过档期的条目**不重复取**——评分每天刷新，而档期是另一笔请求，跟着一起重发
             // 会让请求量凭空翻倍。只有「没取过」或「这次确实缺它」才补。
-            const needsTimes = wantEpisodeTimes && !(stale && stale.hasEpisodeTimes !== false);
+            const needsTimes = wantEpisodeTimes && !(stale && stale.hasEpisodeTimes === true);
             const subject = await this.fetchSubject(id);
             const times = needsTimes && subject && resolveEpisodeTotal(subject)
                 ? await this.fetchEpisodeTimes(id)
@@ -291,17 +321,22 @@ class Localizer {
             const subject = await this.fetchSubject(id);
             if (!subject)
                 return;
+            // fetchSubject 是 await 点：期间 `localizeByIds` 可能刚写入更完整的档期字段。
+            // 这里必须基于「最新的一份」合并，不能拿请求前的快照整体覆盖。
+            const current = this.memory.get(id);
+            if (!current || current.missing || !this.needsScoreRefresh(current))
+                return;
             ok++;
             this.memory.set(id, {
-                ...stale,
+                ...current,
                 title: subject.name_cn?.trim() || subject.name,
                 coverUrl: subject.images?.large ?? subject.images?.common ?? '',
                 score: computeScore(subject.rating),
                 ratingTotal: typeof subject.rating?.total === 'number' ? subject.rating.total : null,
                 totalEpisodes: resolveEpisodeTotal(subject),
-                hasEpisodeTimes: stale.hasEpisodeTimes,
-                firstAirMs: stale.firstAirMs,
-                lastAirMs: stale.lastAirMs,
+                hasEpisodeTimes: current.hasEpisodeTimes,
+                firstAirMs: current.firstAirMs,
+                lastAirMs: current.lastAirMs,
                 cachedAt: Date.now(),
                 scoreCachedAt: Date.now(),
             });

package/lib/services/scheduler.js

@@ -63,7 +63,8 @@ class Scheduler {
         try {
             const due = this.dueKinds(now);
             const reminder = this.config.push.updateReminderEnabled && this.reminderDue(now);
-            // 没有到期的推送就不碰数据库：清理与落盘每天各跑一次即可，否则 tick 每分钟一次 DELETE
+            // 没有到期的推送就不碰数据库：清理与落盘只在真正有推送/提醒的轮次里跑。
+            // 提醒默认每 10 分钟轮询一次，因此缓存落盘与过期记录清理也随之变成约 10 分钟一次。
             if (!due.length && !reminder)
                 return;
             for (const kind of due)
@@ -200,7 +201,9 @@ class Scheduler {
             : kind === 'night' ? 'nightEnabled'
                 : kind === 'weekly' ? 'weeklyEnabled'
                     : 'seasonEnabled';
-        return this.ctx.database.get('anime_channel', { [field]: true });
+        const rows = await this.ctx.database.get('anime_channel', { [field]: true });
+        // `enabled` 是后加的字段，老数据的 null 不能被当成「已关闭」；显式 false 才跳过。
+        return rows.filter((row) => row.enabled !== false);
     }
     /**
      * 订阅作品的开播提醒。场次由周期规则推算，与定时列表推送面向不同时间点，也不受频道的列表

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/lib/utils/index.d.ts

@@ -7,7 +7,7 @@ import type { Logger } from 'koishi';
  * 不展开就只能看到「fetch failed」，无法判断是 DNS、连接超时还是被重置。
  */
 export declare function errorMessage(error: unknown): string;
-/** 读取 HTTP 错误的状态码，取不到时返回 null */
+/** 读取 HTTP 错误的状态码，取不到时返回 null。兼容 `response.status`、直接 `status` 与 `cause` 链 */
 export declare function errorStatus(error: unknown): number | null;
 /**
  * 这个错误是不是「超时」（包括 undici 的连接超时与响应超时）。

package/lib/utils/index.js

@@ -57,13 +57,22 @@ function errorName(error) {
         return String(error.name ?? '');
     return '';
 }
-/** 读取 HTTP 错误的状态码，取不到时返回 null */
+/** 读取 HTTP 错误的状态码，取不到时返回 null。兼容 `response.status`、直接 `status` 与 `cause` 链 */
 function errorStatus(error) {
-    if (!error || typeof error !== 'object')
-        return null;
-    const response = error.response;
-    const status = response?.status;
-    return typeof status === 'number' ? status : null;
+    let current = error;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH; depth++) {
+        if (!current || typeof current !== 'object')
+            break;
+        const direct = current.status;
+        if (typeof direct === 'number')
+            return direct;
+        const response = current.response;
+        const status = response?.status;
+        if (typeof status === 'number')
+            return status;
+        current = current.cause;
+    }
+    return null;
 }
 /**
  * 这个错误是不是「超时」（包括 undici 的连接超时与响应超时）。

package/package.json

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

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 记录的时刻为准，查不到时按放送周期推算。
 - **去重**：每类推送按「类型 + 目标 + 日期」去重，重启或补发都只发一次。