pixivflow 2.20.3 → 2.20.5

package/README.en.md

@@ -22,7 +22,9 @@ pixivflow --help
 ```
 
 For servers, prefer the Docker Compose setup described in
-[DOCKER.md](docs/DOCKER.md). To build from source:
+[DOCKER.md](docs/DOCKER.md). To compose PixivFlow with TelePost, use the optional
+[pixivflow-telepost-deploy](https://github.com/redtidev1918/pixivflow-telepost-deploy)
+deployment and operations kit. To build from source:
 
 ```bash
 git clone https://github.com/redtidev1918/PixivFlow.git
@@ -92,8 +94,10 @@ conflict.
 
 Each target can use `storageMode: "persistent"` (the default, keep files) or
 `storageMode: "cache"` (send files to a named delivery target and delete them
-only after success). The delivery layer is service-independent; this example
-merely translates an HTTP multipart submission API into configuration:
+only after success). The delivery layer is service-independent;
+[TelePost](https://github.com/redtidev1918/TelePost) and
+[telepress](https://github.com/redtidev1918/telepress) are example downstreams,
+not dependencies. This example merely translates an HTTP multipart submission API into configuration:
 
 ```json
 {

package/README.md

@@ -22,10 +22,9 @@ npm install -g pixivflow
 pixivflow --help
 ```
 
-服务器部署推荐 Docker Compose，见 [DOCKER.md](docs/DOCKER.md)；
-PixivFlow + TelePost 联合部署套件（含可选代理）：
-[redtidev1918/pixivflow-telepost-deploy](https://github.com/redtidev1918/pixivflow-telepost-deploy)
-—— 一套配置，支持国内/海外、有/无公网 IP、VPS/Fly.io 任意场景。
+服务器部署见 [DOCKER.md](docs/DOCKER.md)。需要把 PixivFlow 与 TelePost 组合运行时，再使用
+[pixivflow-telepost-deploy](https://github.com/redtidev1918/pixivflow-telepost-deploy)；
+它是可选的部署与运维套件。
 从源码构建：
 
 ```bash
@@ -111,7 +110,9 @@ pixivflow scheduler             # 按 cron 配置长期挂机自动收集
 - **`cache`**：下载后投给一个「交付目标」（比如投稿机器人），对方确认收到后才删本地文件，省磁盘。
 
 「交付目标」就是一段配置：告诉 PixivFlow 把文件 POST 到哪个地址、带哪些字段。
-它不绑定具体服务，可指向任何 HTTP 投稿接口（TelePost、telepress 等）。示例：
+它不绑定具体服务，可指向任意兼容的 HTTP 接口；
+[TelePost](https://github.com/redtidev1918/TelePost) 与
+[telepress](https://github.com/redtidev1918/telepress) 只是示例下游。示例：
 
 ```json
 {

package/dist/commands/SchedulerCommand.js

@@ -255,6 +255,9 @@ class SchedulerCommand extends Command_1.BaseCommand {
                             // attempts are exhausted, which does not block exit), so this
                             // cannot hold the machine open indefinitely.
                             pendingOutbox: outbox.pending,
+                            // Second belt: never exit underneath an in-flight slot execution
+                            // even if a durable row ever looks a beat early (§idle-inflight).
+                            activeExecutions: runtime.activeExecutionCount(),
                         };
                     },
                     idleGraceMs: scheduling.idleGraceMs,

package/dist/commands/SchedulerIdleLifecycle.d.ts

@@ -41,6 +41,15 @@ export interface IdleSnapshot {
     processingOutbox: number;
     /** Undelivered outbox rows (pending, or waiting on a bounded retry backoff). */
     pendingOutbox: number;
+    /**
+     * In-process slot executions currently awaiting async work (candidate scan,
+     * download, delivery). This is a SECOND belt behind the durable ledger: even
+     * if a DB row is an instant ahead of its awaiting Promise (or a mis-write
+     * ever terminalized a row early), the idle detector must not exit underneath
+     * a live execution. In-memory only — a process crash still resumes from the
+     * durable slot/outbox rows.
+     */
+    activeExecutions: number;
 }
 /** True only when the worker has no work of any kind left. */
 export declare function isIdle(snapshot: IdleSnapshot): boolean;

package/dist/commands/SchedulerIdleLifecycle.js

@@ -38,7 +38,8 @@ const logger_1 = require("../logger");
 function isIdle(snapshot) {
     return (snapshot.activeSlots === 0 &&
         snapshot.processingOutbox === 0 &&
-        snapshot.pendingOutbox === 0);
+        snapshot.pendingOutbox === 0 &&
+        snapshot.activeExecutions === 0);
 }
 /** Default idle grace: long enough to merge two schedules ~10 minutes apart. */
 exports.DEFAULT_IDLE_GRACE_MS = 10 * 60 * 1000;

package/dist/commands/scheduler-runtime.d.ts

@@ -100,6 +100,14 @@ export interface SchedulerRuntime {
     notifyScheduleFailure(snapshot: StandaloneConfig, schedule: ScheduleConfig, failure: JobFailure): Promise<void>;
     /** Start the independent outbox pump (long-running daemon). */
     startOutboxWorker(): void;
+    /**
+     * Number of slot executions currently awaiting async work in THIS process
+     * (candidate scan / download / delivery). Bounded second belt for the idle
+     * lifecycle: exit is only allowed when this is 0 AND the durable ledger is
+     * empty (§idle-inflight). In-memory only; crash recovery still rides the
+     * durable slot/outbox rows.
+     */
+    activeExecutionCount(): number;
     /** Drain due outbox rows once (run-once / watchdog wake). */
     drainOutbox(): Promise<{
         processed: number;

package/dist/commands/scheduler-runtime.js

@@ -252,6 +252,7 @@ async function createSchedulerRuntime(configPathArg) {
     const deliveryDispatcher = new DeliveryDispatcher_1.DeliveryDispatcher(config.delivery, buildProxyUrl(config.network));
     const notificationPolicy = new NotificationPolicy_1.NotificationPolicy(database, config);
     const outboxWorker = new OutboxWorker_1.OutboxWorker(database, deliveryDispatcher, {
+        beforeDrain: () => notificationPolicy.reconcileScheduleSummaries(),
         retryBaseMs: config.delivery?.outboxRetryBaseMs,
         retryMaxMs: config.delivery?.outboxRetryMaxMs,
         // A confirmed ACK settles the owning Slot cell (submitted / duplicate /
@@ -274,6 +275,7 @@ async function createSchedulerRuntime(configPathArg) {
             notificationPolicy.noteTerminalRefetchCell(delivery.slotId, delivery.targetId);
         },
     });
+    let activeExecutions = 0;
     const runJob = async (snapshot, schedule, options = {}) => {
         const { onlyTarget, adhoc = false, slot: providedSlot } = options;
         // A scheduled run is cron by default; an HTTP/manual trigger passes its own.
@@ -462,12 +464,13 @@ async function createSchedulerRuntime(configPathArg) {
         // as a degraded (partial) terminal result.
         const maxFallbackStages = Math.max(0, Math.min(10, Number(runtimeConfig.download?.maxFallbackStages ?? 3)));
         const boostScanLimit = fallbackScanLimit;
-        const boostedTargets = (list, stage) => stage === 0
-            ? list
-            : list.map((t) => ({
+        const boostedTargets = (list) => list.map((t) => {
+            const stage = scheduleSlot && t.id ? coordinator.cellFallbackStage(scheduleSlot.slotId, t.id) : 0;
+            return stage === 0 ? t : {
                 ...t,
                 candidateScanLimit: boostScanLimit(t.candidateScanLimit ?? runtimeConfig.download?.candidateScanLimit, stage),
-            }));
+            };
+        });
         const buildManager = (list) => {
             const scoped = {
                 ...runtimeConfig,
@@ -534,7 +537,7 @@ async function createSchedulerRuntime(configPathArg) {
                 notificationPolicy.noteRefetchOutcome(scheduleSlot, schedule, target, scheduleSlot.manualRequestId, outcome);
             }
         };
-        let downloadManager = buildManager(boostedTargets(runTargets, 0));
+        let downloadManager = buildManager(boostedTargets(runTargets));
         activeDownloadManager = downloadManager;
         await downloadManager.initialise();
         // Apply initial delay if configured
@@ -544,102 +547,115 @@ async function createSchedulerRuntime(configPathArg) {
             });
             await new Promise((resolve) => setTimeout(resolve, runtimeConfig.initialDelay));
         }
-        logger_1.logger.info('='.repeat(60));
-        logger_1.logger.info('Starting scheduled Pixiv download plan', {
-            scheduleId: schedule.id,
-            slot: slotCtx?.slotId ?? '(ad-hoc)',
-            trigger: triggerSource,
-            targets: runTargets.map((target) => target.id ?? target.tag ?? target.filterTag ?? target.type),
-        });
-        logger_1.logger.info('='.repeat(60));
-        const startTime = Date.now();
-        let allTargetsFailed;
-        let releaseLease = () => undefined;
-        if (slotCtx && varReleaseLease)
-            releaseLease = varReleaseLease;
+        // Execution belt (§idle-inflight): this run is live until releaseLease
+        // completes. The idle detector must see it even if a durable row lags.
+        activeExecutions += 1;
         try {
-            // Candidate fallback passes (§schedule-recovery): after each pass, cells
-            // still mid-fallback (advanced stages) are re-selected with expanded,
-            // still-bounded scan limits. Successful sibling cells are NEVER re-run:
-            // pendingTargets only returns unconverged cells of this slot.
-            for (let pass = 0;; pass += 1) {
-                await downloadManager.runAllTargets();
-                if (!slotCtx || pass >= maxFallbackStages - 1)
-                    break;
-                const pendingFallback = coordinator
-                    .pendingTargets(slotCtx.slotId, targets)
-                    .filter((p) => p.cell &&
-                    p.cell.fallback_stage > 0 &&
-                    p.cell.fallback_stage < maxFallbackStages);
-                if (pendingFallback.length === 0)
-                    break;
-                downloadManager = buildManager(boostedTargets(pendingFallback.map((p) => p.target), pass + 1));
-                activeDownloadManager = downloadManager;
-                await downloadManager.initialise();
+            logger_1.logger.info('='.repeat(60));
+            logger_1.logger.info('Starting scheduled Pixiv download plan', {
+                scheduleId: schedule.id,
+                slot: slotCtx?.slotId ?? '(ad-hoc)',
+                trigger: triggerSource,
+                targets: runTargets.map((target) => target.id ?? target.tag ?? target.filterTag ?? target.type),
+            });
+            logger_1.logger.info('='.repeat(60));
+            const startTime = Date.now();
+            let allTargetsFailed;
+            let releaseLease = () => undefined;
+            if (slotCtx && varReleaseLease)
+                releaseLease = varReleaseLease;
+            try {
+                // Candidate fallback passes (§schedule-recovery): after each pass, cells
+                // still mid-fallback (advanced stages) are re-selected with expanded,
+                // still-bounded scan limits. Successful sibling cells are NEVER re-run:
+                // pendingTargets only returns unconverged cells of this slot.
+                for (let pass = 0;; pass += 1) {
+                    await downloadManager.runAllTargets();
+                    if (!slotCtx || pass >= maxFallbackStages - 1)
+                        break;
+                    const pendingFallback = coordinator
+                        .pendingTargets(slotCtx.slotId, targets)
+                        .filter((p) => p.cell &&
+                        p.cell.fallback_stage > 0 &&
+                        p.cell.fallback_stage < maxFallbackStages);
+                    if (pendingFallback.length === 0)
+                        break;
+                    downloadManager = buildManager(boostedTargets(pendingFallback.map((p) => p.target)));
+                    activeDownloadManager = downloadManager;
+                    await downloadManager.initialise();
+                }
             }
-        }
-        catch (error) {
-            if (!slotCtx || !(error instanceof Error) || !/^All \d+ target\(s\) failed\./.test(error.message)) {
-                // Abnormal abort. Two very different situations land here, and treating
-                // them as one is what produced the production loop:
-                //
-                //  - this process cancelled itself (scheduler timeout / watchdog) and is
-                //    still alive. It will never touch the Slot again, so releasing the
-                //    lease while leaving the status `running` makes the Slot look exactly
-                //    like a crashed worker: `recoverableSlots()` matches a NULL lease on
-                //    purpose (its "recorded but never claimed" case), so the recovery
-                //    sweep re-dispatches the SAME occurrence on every tick, forever.
-                //    Terminalise it instead: the occurrence is finished, and failed.
-                //
-                //  - the process is going away (`shutdown`). Deliberately leave the Slot
-                //    non-terminal so recovery resumes the same occurrence after restart.
-                if (slotCtx && shouldTerminaliseAbortedSlot(activeAbortOrigin, slotAbandoned)) {
-                    coordinator.finish(slotCtx, schedule, targets);
-                    for (const target of targets)
-                        if (target.id)
-                            notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
+            catch (error) {
+                if (!slotCtx || !(error instanceof Error) || !/^All \d+ target\(s\) failed\./.test(error.message)) {
+                    // Abnormal abort. Two very different situations land here, and treating
+                    // them as one is what produced the production loop:
+                    //
+                    //  - this process cancelled itself (scheduler timeout / watchdog) and is
+                    //    still alive. It will never touch the Slot again, so releasing the
+                    //    lease while leaving the status `running` makes the Slot look exactly
+                    //    like a crashed worker: `recoverableSlots()` matches a NULL lease on
+                    //    purpose (its "recorded but never claimed" case), so the recovery
+                    //    sweep re-dispatches the SAME occurrence on every tick, forever.
+                    //    Terminalise it instead: the occurrence is finished, and failed.
+                    //
+                    //  - the process is going away (`shutdown`). Deliberately leave the Slot
+                    //    non-terminal so recovery resumes the same occurrence after restart.
+                    if (slotCtx && shouldTerminaliseAbortedSlot(activeAbortOrigin, slotAbandoned)) {
+                        coordinator.finish(slotCtx, schedule, targets);
+                        for (const target of targets)
+                            if (target.id)
+                                notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
+                    }
+                    // Hand the lease back either way: a terminal Slot cannot be re-dispatched,
+                    // and a non-terminal one (shutdown) must not wait for its TTL to expire.
+                    releaseLease?.();
+                    throw error;
                 }
-                // Hand the lease back either way: a terminal Slot cannot be re-dispatched,
-                // and a non-terminal one (shutdown) must not wait for its TTL to expire.
-                releaseLease?.();
-                throw error;
+                // Scheduled Slots treat terminal target failures (failed/no_candidate) as
+                // a finished partial/failed aggregate. Finish before returning so the HTTP
+                // trigger can report the durable state instead of 500 and never roll up.
+                allTargetsFailed = error;
             }
-            // Scheduled Slots treat terminal target failures (failed/no_candidate) as
-            // a finished partial/failed aggregate. Finish before returning so the HTTP
-            // trigger can report the durable state instead of 500 and never roll up.
-            allTargetsFailed = error;
+            finally {
+                if (activeDownloadManager === downloadManager)
+                    activeDownloadManager = null;
+            }
+            const duration = Math.round((Date.now() - startTime) / 1000);
+            if (slotCtx && !slotAbandoned) {
+                const summary = coordinator.finish(slotCtx, schedule, targets);
+                for (const target of targets)
+                    if (target.id)
+                        notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
+                // Terminal summaries are for SCHEDULED occurrences (P0-B). Remote manual
+                // replacements already report through their own verdict channel
+                // (refetchOutcomeUrl); a schedule summary would double-notify the group.
+                if (!slotCtx.manualRequestId) {
+                    notificationPolicy.sendSlotSummary(slotCtx, schedule, summary.cells.map((c) => {
+                        const t = targets.find((x) => x.id === c.targetId);
+                        return {
+                            targetId: c.targetId,
+                            label: c.targetId,
+                            workType: t?.type ?? 'unknown',
+                            status: c.status,
+                            workId: c.workId,
+                            error: c.error ?? null,
+                        };
+                    }));
+                }
+                releaseLease();
+            }
+            if (!slotCtx && allTargetsFailed)
+                throw allTargetsFailed;
+            logger_1.logger.info('='.repeat(60));
+            logger_1.logger.info(`Scheduled download plan finished (took ${duration}s)`, {
+                scheduleId: schedule.id,
+                slot: slotCtx?.slotId ?? '(ad-hoc)',
+            });
+            logger_1.logger.info('='.repeat(60));
         }
         finally {
-            if (activeDownloadManager === downloadManager)
-                activeDownloadManager = null;
+            activeExecutions -= 1;
         }
-        const duration = Math.round((Date.now() - startTime) / 1000);
-        if (slotCtx && !slotAbandoned) {
-            const summary = coordinator.finish(slotCtx, schedule, targets);
-            for (const target of targets)
-                if (target.id)
-                    notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
-            notificationPolicy.sendSlotSummary(slotCtx, schedule, summary.cells.map((c) => {
-                const t = targets.find((x) => x.id === c.targetId);
-                return {
-                    targetId: c.targetId,
-                    label: c.targetId,
-                    workType: t?.type ?? 'unknown',
-                    status: c.status,
-                    workId: c.workId,
-                    error: c.error ?? null,
-                };
-            }));
-            releaseLease();
-        }
-        if (!slotCtx && allTargetsFailed)
-            throw allTargetsFailed;
-        logger_1.logger.info('='.repeat(60));
-        logger_1.logger.info(`Scheduled download plan finished (took ${duration}s)`, {
-            scheduleId: schedule.id,
-            slot: slotCtx?.slotId ?? '(ad-hoc)',
-        });
-        logger_1.logger.info('='.repeat(60));
     };
     const cancelActive = (reason, origin = 'timeout') => {
         activeAbortOrigin = origin;
@@ -673,6 +689,7 @@ async function createSchedulerRuntime(configPathArg) {
         runJob,
         cancelActive,
         abandonActiveRun,
+        activeExecutionCount: () => activeExecutions,
         startOutboxWorker: () => outboxWorker.start(),
         drainOutbox: () => outboxWorker.drainOnce(),
         notifyScheduleFailure: (snapshot, schedule, failure) => notifyScheduleFailure(snapshot, database, schedule, failure),

package/dist/delivery/OutboxWorker.d.ts

@@ -3,6 +3,8 @@ import { OutboxRow } from '../storage/repositories/OutboxRepository';
 import { DeliveryDispatcher } from './DeliveryDispatcher';
 import { DeliveryAck } from './DeliveryAck';
 export interface OutboxWorkerOptions {
+    /** Reconcile durable notification intents before consuming due rows. */
+    beforeDrain?: () => void;
     /** How often to scan for due rows. */
     pollIntervalMs?: number;
     /** Row lease duration while one attempt is in flight. */
@@ -45,6 +47,7 @@ export declare function backoffDelayMs(attempt: number, base: number, max: numbe
 export declare class OutboxWorker {
     private readonly database;
     private readonly dispatcher;
+    private readonly options;
     private timer;
     private running;
     private stopped;

package/dist/delivery/OutboxWorker.js

@@ -23,6 +23,7 @@ function backoffDelayMs(attempt, base, max) {
 class OutboxWorker {
     database;
     dispatcher;
+    options;
     timer = null;
     running = false;
     stopped = false;
@@ -37,6 +38,7 @@ class OutboxWorker {
     constructor(database, dispatcher, options = {}) {
         this.database = database;
         this.dispatcher = dispatcher;
+        this.options = options;
         this.pollIntervalMs = options.pollIntervalMs ?? 10_000;
         this.leaseMs = options.leaseMs ?? 120_000;
         this.batchSize = options.batchSize ?? 4;
@@ -73,6 +75,7 @@ class OutboxWorker {
         let retried = 0;
         let dead = 0;
         for (let round = 0; round < maxRounds; round++) {
+            this.options.beforeDrain?.();
             const rows = this.database.outbox.claimDue(this.owner, this.leaseMs, this.batchSize);
             if (rows.length === 0)
                 break;
@@ -104,6 +107,7 @@ class OutboxWorker {
             return;
         this.running = true;
         try {
+            this.options.beforeDrain?.();
             const rows = this.database.outbox.claimDue(this.owner, this.leaseMs, this.batchSize);
             for (const row of rows) {
                 if (this.stopped) {

package/dist/notification/NotificationPolicy.d.ts

@@ -51,6 +51,8 @@ export declare class NotificationPolicy {
      * use `refetchOutcomeUrl`; generic notifications use `notificationUrl`.
      */
     private targetsWithUrl;
+    /** The durable cells remain the notification intent across crashes and late ACKs. */
+    reconcileScheduleSummaries(): void;
     private send;
     /**
      * Report the terminal verdict of a REMOTE MANUAL replacement ("重抓") back to

package/dist/notification/NotificationPolicy.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotificationPolicy = void 0;
 const DeliveryService_1 = require("../delivery/DeliveryService");
+const SlotCoordinator_1 = require("../scheduler/SlotCoordinator");
 const logger_1 = require("../logger");
 /**
  * Central policy for all operational notifications. Handlers/scheduler do not
@@ -76,8 +77,11 @@ class NotificationPolicy {
     }
     /** One consolidated summary per slot, delivered to every notifying target's endpoint. */
     sendSlotSummary(slot, schedule, rows) {
-        const targets = this.targetsWithUrl('scheduleOutcomeUrl');
-        if (targets.size === 0 || rows.length === 0)
+        if (slot.manualRequestId || rows.length === 0 || rows.some((r) => !['submitted', 'no_candidate', 'duplicate', 'failed'].includes(r.status)))
+            return;
+        const memberIds = new Set(rows.map((r) => r.targetId));
+        const targets = this.targetsWithUrl('scheduleOutcomeUrl', memberIds);
+        if (targets.size === 0)
             return;
         const icon = (s) => s === 'submitted' ? '✅' : s === 'no_candidate' ? '⚠️' : s === 'duplicate' ? '♱' : s === 'delivery_pending' ? '🕓' : '❌';
         const lines = rows.map((r) => `${icon(r.status)} ${r.label}（${r.workType === 'novel' ? '小说' : '插画'}）` +
@@ -93,8 +97,8 @@ class NotificationPolicy {
         ].join('\n');
         const outcomeStatus = submitted === rows.length ? 'success' : submitted > 0 ? 'partial' : 'failed';
         const service = new DeliveryService_1.DeliveryService(this.database);
-        for (const name of targets) {
-            service.enqueueNotification(name, text, NotificationPolicy.keys.summary(slot.slotId), undefined, {
+        for (const [index, name] of [...targets].entries()) {
+            service.enqueueNotification(name, text, NotificationPolicy.keys.summary(slot.slotId) + (index === 0 ? '' : `:${name}`), undefined, {
                 scheduleId: schedule.id,
                 slotId: slot.slotId,
                 status: outcomeStatus,
@@ -112,9 +116,11 @@ class NotificationPolicy {
      * Schedule summaries require `scheduleOutcomeUrl`; manual refetch outcomes
      * use `refetchOutcomeUrl`; generic notifications use `notificationUrl`.
      */
-    targetsWithUrl(urlKey) {
+    targetsWithUrl(urlKey, memberIds) {
         const result = new Set();
         for (const target of this.config.targets ?? []) {
+            if (memberIds && !memberIds.has(target.id ?? ''))
+                continue;
             const deliveryTarget = target.delivery?.target;
             if (!deliveryTarget)
                 continue;
@@ -125,6 +131,26 @@ class NotificationPolicy {
         }
         return result;
     }
+    /** The durable cells remain the notification intent across crashes and late ACKs. */
+    reconcileScheduleSummaries() {
+        for (const record of this.database.slots.getUnreportedTerminalSchedules()) {
+            const slot = {
+                slotId: record.id, scheduleId: record.scheduleId,
+                occurrenceAt: record.occurrenceAt ?? 0, occurrenceDate: record.occurrenceDate,
+                occurrenceLabel: record.occurrenceLabel, timezone: record.timezone,
+                triggerSource: 'http', slotName: record.slotName, slotDate: record.slotDate,
+            };
+            const schedule = this.config.schedules?.find((item) => item.id === record.scheduleId)
+                ?? { id: record.scheduleId };
+            const targets = this.config.targets.filter((target) => record.targetIds.includes(target.id ?? ''));
+            const summary = new SlotCoordinator_1.SlotCoordinator(this.database).finish(slot, schedule, targets);
+            this.sendSlotSummary(slot, schedule, summary.cells.map((cell) => ({
+                ...cell, label: cell.targetId,
+                workType: targets.find((target) => target.id === cell.targetId)?.type ?? 'unknown',
+                error: cell.error ?? null,
+            })));
+        }
+    }
     send(targetName, key, text) {
         try {
             new DeliveryService_1.DeliveryService(this.database).enqueueNotification(targetName, text, key);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "type": "commonjs",
   "name": "pixivflow",
-  "version": "2.20.3",
+  "version": "2.20.5",
   "private": true
 }

package/dist/storage/repositories/SlotRepository.d.ts

@@ -89,6 +89,8 @@ export declare class SlotRepository extends BaseRepository {
     /** Target ids materialized for a slot (stable membership; falls back to []). */
     getSlotTargetIds(id: string): string[];
     getRecentSlots(limit?: number): SlotRecord[];
+    /** Completed cells whose summary enqueue or aggregate rollup was interrupted. */
+    getUnreportedTerminalSchedules(): SlotRecord[];
     markSlotStatus(id: string, status: SlotStatus, error?: string): void;
     /** All cells for a slot (one per target). */
     getCells(slotId: string): SlotItemRecord[];

package/dist/storage/repositories/SlotRepository.js

@@ -71,6 +71,18 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             .all(limit);
         return rows.map((r) => this.toSlot(r));
     }
+    /** Completed cells whose summary enqueue or aggregate rollup was interrupted. */
+    getUnreportedTerminalSchedules() {
+        const rows = this.db.prepare(`SELECT s.* FROM schedule_slots s
+      WHERE s.manual_request_id IS NULL AND s.status != 'expired'
+        AND EXISTS (SELECT 1 FROM schedule_slot_items c WHERE c.slot_id = s.id)
+        AND NOT EXISTS (SELECT 1 FROM schedule_slot_items c WHERE c.slot_id = s.id
+          AND c.status NOT IN ('submitted', 'no_candidate', 'duplicate', 'failed'))
+        AND (s.status IN ('pending', 'running') OR NOT EXISTS (
+          SELECT 1 FROM outbox o WHERE o.idempotency_key = 'notification:' || s.id || ':summary'
+        ))`).all();
+        return rows.map((row) => this.toSlot(row));
+    }
     markSlotStatus(id, status, error) {
         const stamp = status === 'running' ? 'started_at' : status === 'success' || status === 'partial' || status === 'failed' ? 'completed_at' : null;
         const sets = ['status = @status', 'last_error = @error'];

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUILD = void 0;
 // GENERATED by scripts/write-version.js — do not edit manually.
-exports.BUILD = { version: '2.20.3', commit: '6ebffc579194' };
+exports.BUILD = { version: '2.20.5', commit: '9352c0253571' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

@@ -1,6 +1,6 @@
 {
   "type": "commonjs",
   "name": "pixivflow-webui-backend",
-  "version": "2.20.3",
+  "version": "2.20.5",
   "description": "PixivFlow WebUI Backend - CommonJS module"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixivflow",
-  "version": "2.20.3",
+  "version": "2.20.5",
   "description": "🎨 智能的 Pixiv 自动化下载工具 - 支持批量下载插画和小说、定时任务、Docker部署 | Intelligent Pixiv Automation Downloader with batch download, scheduler, and Docker support",
   "repository": {
     "type": "git",