pixivflow 2.20.4 → 2.21.0

package/dist/scheduler/SlotCoordinator.js

@@ -4,6 +4,7 @@ exports.SlotCoordinator = exports.SLOT_HEARTBEAT_MS = exports.SLOT_LEASE_TTL_MS
 exports.timezoneForSchedule = timezoneForSchedule;
 const logger_1 = require("../logger");
 const OccurrenceResolver_1 = require("./OccurrenceResolver");
+const TargetOutcome_1 = require("./TargetOutcome");
 const WorkIdentity_1 = require("./WorkIdentity");
 /**
  * Execution-lease TTL and heartbeat cadence.
@@ -129,6 +130,8 @@ class SlotCoordinator {
             slotName: slot.slotName,
             manualRequestId: slot.manualRequestId ?? null,
             correlationId: slot.correlationId ?? null,
+            recoveryRequestId: slot.recoveryRequestId ?? null,
+            recoveryMode: slot.recoveryMode ?? null,
         });
         if (created) {
             // Freeze membership: materialize one cell per target id from the snapshot.
@@ -267,12 +270,15 @@ class SlotCoordinator {
             case 'no_candidate':
                 // Only terminal if the cell never locked a work; a locked work whose
                 // delivery is still pending must not be collapsed to no_candidate.
-                if (!cell.workId)
+                if (!cell.workId) {
                     this.safeTransition(slotId, targetId, 'no_candidate', outcome.reason);
+                    this.persistTerminalReason(slotId, targetId, outcome);
+                }
                 return;
             case 'duplicate':
                 this.database.slots.lockCellWork(slotId, targetId, outcome.workId, cell.workType ?? 'unknown');
                 this.safeTransition(slotId, targetId, 'duplicate', outcome.reason);
+                this.persistTerminalReason(slotId, targetId, outcome);
                 return;
             case 'failed':
                 if (outcome.retryable) {
@@ -282,7 +288,27 @@ class SlotCoordinator {
                     return;
                 }
                 this.safeTransition(slotId, targetId, 'failed', outcome.error);
+                this.persistTerminalReason(slotId, targetId, outcome);
+                return;
+        }
+    }
+    /**
+     * Persist the normalized terminal reason (§terminal-reason) for a cell that
+     * just reached a terminal state. Never unwinds the run and never leaks raw
+     * error internals: only the stable code + business message are stored.
+     */
+    persistTerminalReason(slotId, targetId, outcome) {
+        try {
+            const reason = (0, TargetOutcome_1.terminalReasonFor)(outcome);
+            if (!reason)
                 return;
+            this.database.slots.setCellTerminalReason(slotId, targetId, reason.code, reason.message);
+        }
+        catch (error) {
+            logger_1.logger.debug('Failed to persist terminal reason', {
+                slot: slotId, target: targetId,
+                error: error instanceof Error ? error.message : String(error),
+            });
         }
     }
     /** Promote a delivery_pending cell to submitted from a confirmed ACK. */
@@ -393,7 +419,19 @@ class SlotCoordinator {
                 continue;
             if (cell.status === 'pending' || cell.status === 'selected') {
                 // Ran but never reached a terminal state (target threw before delivery).
-                this.database.slots.setCellStatus(slot.slotId, targetId, 'failed', cell.lastError ?? 'target did not complete');
+                // Persist a normalized reason so the operator sees a first-level cause,
+                // not a bare "target did not complete".
+                const error = cell.lastError ?? 'target did not complete';
+                this.database.slots.setCellStatus(slot.slotId, targetId, 'failed', error);
+                try {
+                    this.database.slots.setCellTerminalReason(slot.slotId, targetId, 'internal_error', TargetOutcome_1.TERMINAL_REASON_MESSAGES.internal_error);
+                }
+                catch (reasonError) {
+                    logger_1.logger.debug('Failed to persist terminal reason in rollup', {
+                        slot: slot.slotId, target: targetId,
+                        error: reasonError instanceof Error ? reasonError.message : String(reasonError),
+                    });
+                }
             }
         }
         const status = this.database.slots.deriveSlotStatus(slot.slotId);
@@ -403,6 +441,8 @@ class SlotCoordinator {
             status: c.status,
             workId: c.workId,
             error: c.lastError,
+            terminalReasonCode: c.terminalReasonCode,
+            terminalReasonMessage: c.terminalReasonMessage,
         }));
         // Rolled up AFTER the slot row carries its terminal status/completed_at, so
         // the outcome reports the durable timestamps rather than a fresh clock read.
@@ -450,6 +490,8 @@ class SlotCoordinator {
                 status: cell.status,
                 work_id: cell.workId,
                 error: cell.lastError,
+                terminal_reason_code: cell.terminalReasonCode,
+                terminal_reason_message: cell.terminalReasonMessage,
             };
         });
         // A fully-submitted slot has no non-submitted cell at all, and reporting

package/dist/scheduler/TargetOutcome.d.ts

@@ -253,4 +253,35 @@ export declare function mergeScanSummaries(first: CandidateScanSummary | null, s
 export declare function classifyCandidateFailure(error: unknown, workId: string): CandidateFailure;
 /** Hard job-level outage for a directly-thrown error, or null. */
 export declare function classifyJobLevelOutage(error: unknown): JobLevelOutage | null;
+/**
+ * Normalized terminal failure taxonomy (§terminal-reason).
+ *
+ * These codes are what operators actually see: the FIRST-LEVEL cause of a
+ * terminal cell. Recovery exhaustion is an execution state, never a root
+ * cause — a cell that exhausted its fallback stages because every candidate
+ * was a duplicate reports `duplicate_exhausted`, not `recovery_exhausted`.
+ * Queue waiting is not a terminal reason at all.
+ *
+ * Codes are kept deliberately small (no giant taxonomy): each maps to one
+ * real failure path in this codebase.
+ */
+export type TerminalReasonCode = 
+/** The candidate scan was empty — nothing was found in the day's ranked pool. */
+'no_candidate'
+/** Every candidate the scan saw was already delivered/pending for this target. */
+ | 'duplicate_exhausted'
+/** Candidates existed but none passed the target's own filters. */
+ | 'filter_exhausted' | 'download_timeout' | 'download_failed' | 'rate_limited' | 'auth_failed' | 'remote_http_error' | 'delivery_failed' | 'telegram_failed' | 'network_error' | 'execution_timeout' | 'configuration_error' | 'internal_error';
+export interface TerminalReason {
+    code: TerminalReasonCode;
+    /** Business-language message an operator/reviewer reads directly. */
+    message: string;
+}
+/** User-facing business messages — never stack traces, paths, SQL or tokens. */
+export declare const TERMINAL_REASON_MESSAGES: Record<TerminalReasonCode, string>;
+/**
+ * Map a typed terminal TargetOutcome onto the normalized reason. Returns null
+ * for non-terminal outcomes (they have no terminal reason yet).
+ */
+export declare function terminalReasonFor(outcome: TargetOutcome): TerminalReason | null;
 //# sourceMappingURL=TargetOutcome.d.ts.map

package/dist/scheduler/TargetOutcome.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TERMINAL_REASON_MESSAGES = void 0;
 exports.emptyCandidateScan = emptyCandidateScan;
 exports.isTerminalOutcome = isTerminalOutcome;
 exports.isSelectedAttempt = isSelectedAttempt;
@@ -10,6 +11,7 @@ exports.hasTransientFailure = hasTransientFailure;
 exports.mergeScanSummaries = mergeScanSummaries;
 exports.classifyCandidateFailure = classifyCandidateFailure;
 exports.classifyJobLevelOutage = classifyJobLevelOutage;
+exports.terminalReasonFor = terminalReasonFor;
 /**
  * A scan that attempted nothing. The real pipeline always reports its own scan;
  * this is for callers/tests that have no candidate-level information, so they
@@ -224,4 +226,116 @@ function classifyJobLevelOutage(error) {
     const failure = classifyCandidateFailure(error, '');
     return failure.scope === 'job' ? failure.outage : null;
 }
+/** User-facing business messages — never stack traces, paths, SQL or tokens. */
+exports.TERMINAL_REASON_MESSAGES = {
+    no_candidate: '没有找到合适的新作品',
+    duplicate_exhausted: '候选作品均已投稿过',
+    filter_exhausted: '没有符合筛选条件的新作品',
+    download_timeout: '图片下载超时',
+    download_failed: '图片下载失败',
+    rate_limited: 'Pixiv 请求频率受限',
+    auth_failed: 'Pixiv 登录已失效，需要重新登录',
+    remote_http_error: 'Pixiv 服务器返回错误',
+    delivery_failed: '投稿投递失败',
+    telegram_failed: 'Telegram 发送失败',
+    network_error: '网络异常',
+    execution_timeout: '执行超时',
+    configuration_error: '配置错误',
+    internal_error: '内部错误',
+};
+/**
+ * Map a typed terminal TargetOutcome onto the normalized reason. Returns null
+ * for non-terminal outcomes (they have no terminal reason yet).
+ */
+function terminalReasonFor(outcome) {
+    switch (outcome.kind) {
+        case 'submitted':
+        case 'stored':
+        case 'delivery_pending':
+            return null;
+        case 'no_candidate':
+            return reasonForNoCandidate(outcome);
+        case 'duplicate':
+            return {
+                code: 'duplicate_exhausted',
+                message: exports.TERMINAL_REASON_MESSAGES.duplicate_exhausted,
+            };
+        case 'failed':
+            return classifyFailedReason(outcome.error, outcome.scan);
+    }
+}
+/**
+ * Root cause for a `no_candidate` target, read from the scan's skip codes
+ * rather than from exhaustion bookkeeping: all duplicates ⇒
+ * `duplicate_exhausted`; otherwise the candidates were present but unusable
+ * (filter/deleted/denied/wrong media) ⇒ `filter_exhausted`; a scan that saw
+ * nothing at all ⇒ `no_candidate`.
+ */
+function reasonForNoCandidate(outcome) {
+    const skipped = outcome.scan?.skipped ?? [];
+    if (skipped.length > 0) {
+        const duplicates = skipped.filter((s) => s.code === 'duplicate').length;
+        if (duplicates === skipped.length) {
+            return { code: 'duplicate_exhausted', message: exports.TERMINAL_REASON_MESSAGES.duplicate_exhausted };
+        }
+        if (duplicates >= skipped.length / 2 || skipped.every((s) => s.code !== 'unavailable')) {
+            // Predominantly duplicates, or every skip was a hard work-level verdict:
+            // the pool contained works but none were usable for this target.
+            return { code: 'filter_exhausted', message: exports.TERMINAL_REASON_MESSAGES.filter_exhausted };
+        }
+    }
+    return { code: 'no_candidate', message: exports.TERMINAL_REASON_MESSAGES.no_candidate };
+}
+/**
+ * Classify a terminal `failed` reason from the error text + scan bookkeeping.
+ * Job-level outages from the scan win first (they describe the whole run), then
+ * message-shape heuristics; anything unclassifiable becomes `internal_error`
+ * rather than leaking raw error text to the review group.
+ */
+function classifyFailedReason(message, scan) {
+    const outage = scan?.outages?.[0];
+    if (outage === 'pixiv_auth_failure') {
+        return { code: 'auth_failed', message: exports.TERMINAL_REASON_MESSAGES.auth_failed };
+    }
+    if (outage === 'delivery_unavailable') {
+        return { code: 'delivery_failed', message: exports.TERMINAL_REASON_MESSAGES.delivery_failed };
+    }
+    if (outage === 'network_outage' || outage === 'database_unavailable') {
+        return { code: 'network_error', message: exports.TERMINAL_REASON_MESSAGES.network_error };
+    }
+    const text = String(message ?? '').slice(0, 600);
+    if (/\b429\b|rate ?limit/i.test(text)) {
+        return { code: 'rate_limited', message: exports.TERMINAL_REASON_MESSAGES.rate_limited };
+    }
+    if (/\b401\b|unauthorized|invalid grant|invalid refresh token|authentication failed|登录/i.test(text)) {
+        return { code: 'auth_failed', message: exports.TERMINAL_REASON_MESSAGES.auth_failed };
+    }
+    if (/timeout|timed ?out|timedout/i.test(text)) {
+        return /download|image|url|fetch/i.test(text)
+            ? { code: 'download_timeout', message: exports.TERMINAL_REASON_MESSAGES.download_timeout }
+            : { code: 'execution_timeout', message: exports.TERMINAL_REASON_MESSAGES.execution_timeout };
+    }
+    if (/502|503|504|bad gateway|service unavailable|server error|5\d\d/i.test(text)) {
+        return { code: 'remote_http_error', message: exports.TERMINAL_REASON_MESSAGES.remote_http_error };
+    }
+    if (/telegram/i.test(text)) {
+        return { code: 'telegram_failed', message: exports.TERMINAL_REASON_MESSAGES.telegram_failed };
+    }
+    // Configuration faults are reported as such even when they surface inside a
+    // delivery/submission path ("delivery target not configured"): the operator
+    // fixes configuration, not the upstream.
+    if (/not configured|missing (?:config|configuration|setting)|invalid config/i.test(text)) {
+        return { code: 'configuration_error', message: exports.TERMINAL_REASON_MESSAGES.configuration_error };
+    }
+    if (/delivery|submit(?:t?ed)?|publish|post|outbox/i.test(text)) {
+        return { code: 'delivery_failed', message: exports.TERMINAL_REASON_MESSAGES.delivery_failed };
+    }
+    if (/econnrefused|econnreset|enotfound|etimedout|ehostunreach|enetunreach|socket hang up|network is unreachable|getaddrinfo/i.test(text)) {
+        return { code: 'network_error', message: exports.TERMINAL_REASON_MESSAGES.network_error };
+    }
+    if (/config|missing|invalid/i.test(text)) {
+        return { code: 'configuration_error', message: exports.TERMINAL_REASON_MESSAGES.configuration_error };
+    }
+    return { code: 'internal_error', message: exports.TERMINAL_REASON_MESSAGES.internal_error };
+}
 //# sourceMappingURL=TargetOutcome.js.map

package/dist/storage/DatabaseMigration.js

@@ -108,6 +108,11 @@ class DatabaseMigration {
             -- the terminal outcome can be reported back to the requester
             -- without this service learning anything about the review.
             correlation_id TEXT,
+            -- Manual recovery request UUID + policy preset ("重试一次/放宽条件重试").
+            -- A recovery slot re-runs the failed target(s) under a per-occurrence
+            -- policy and reports through the schedule-outcome channel.
+            recovery_request_id TEXT,
+            recovery_mode TEXT,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
             started_at DATETIME,
             completed_at DATETIME,
@@ -126,6 +131,10 @@ class DatabaseMigration {
             attempt_count INTEGER NOT NULL DEFAULT 0,
             fallback_stage INTEGER NOT NULL DEFAULT 0,
             last_error TEXT,
+            -- Normalized terminal failure reason (§terminal-reason): stable reason
+            -- code plus a user-facing business message, durable across restarts.
+            terminal_reason_code TEXT,
+            terminal_reason_message TEXT,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
             updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
             completed_at DATETIME,
@@ -239,6 +248,8 @@ class DatabaseMigration {
                 heartbeat_at: 'ALTER TABLE schedule_slots ADD COLUMN heartbeat_at INTEGER',
                 manual_request_id: 'ALTER TABLE schedule_slots ADD COLUMN manual_request_id TEXT',
                 correlation_id: 'ALTER TABLE schedule_slots ADD COLUMN correlation_id TEXT',
+                recovery_request_id: 'ALTER TABLE schedule_slots ADD COLUMN recovery_request_id TEXT',
+                recovery_mode: 'ALTER TABLE schedule_slots ADD COLUMN recovery_mode TEXT',
             };
             const columnAlters = [];
             for (const [col, sql] of Object.entries(slotColumnMigrations)) {
@@ -249,6 +260,12 @@ class DatabaseMigration {
             if (!itemCols.includes('fallback_stage')) {
                 columnAlters.push(`ALTER TABLE schedule_slot_items ADD COLUMN fallback_stage INTEGER NOT NULL DEFAULT 0`);
             }
+            if (!itemCols.includes('terminal_reason_code')) {
+                columnAlters.push(`ALTER TABLE schedule_slot_items ADD COLUMN terminal_reason_code TEXT`);
+            }
+            if (!itemCols.includes('terminal_reason_message')) {
+                columnAlters.push(`ALTER TABLE schedule_slot_items ADD COLUMN terminal_reason_message TEXT`);
+            }
             // Create indexes for better query performance
             const indexes = [
                 `CREATE INDEX IF NOT EXISTS idx_downloads_pixiv_id_type ON downloads(pixiv_id, type)`,

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

@@ -29,6 +29,15 @@ export interface SlotRecord {
     manualRequestId: string | null;
     /** Opaque caller correlation (review chain / review id); null unless manual. */
     correlationId: string | null;
+    /**
+     * Request UUID of a remote MANUAL RECOVERY run (§manual-recovery); null for
+     * scheduled occurrences and review refetches. A recovery slot re-runs the
+     * failed target(s) under a per-occurrence recovery policy and reports its
+     * outcome through the schedule-outcome channel.
+     */
+    recoveryRequestId: string | null;
+    /** Recovery policy preset ('normal'|'relaxed'); null for non-recovery slots. */
+    recoveryMode: string | null;
 }
 export interface SlotItemRecord {
     id: number;
@@ -45,6 +54,14 @@ export interface SlotItemRecord {
      */
     fallback_stage: number;
     lastError: string | null;
+    /**
+     * Normalized terminal failure reason code (§terminal-reason) — one of the
+     * stable codes in TargetOutcome's failure taxonomy. Null for non-terminal
+     * cells or successful submissions.
+     */
+    terminalReasonCode: string | null;
+    /** User-facing business message for the terminal reason. */
+    terminalReasonMessage: string | null;
     createdAt: string;
     updatedAt: string;
     completedAt: string | null;
@@ -61,6 +78,8 @@ export interface SlotItemRecord {
 export declare class SlotRepository extends BaseRepository {
     /** Exact manual request/target lookup for authenticated convergence checks. */
     findManualSlot(requestId: string, targetId: string): SlotRecord | null;
+    /** Exact manual RECOVERY request/target lookup (§manual-recovery). */
+    findRecoverySlot(requestId: string, targetId: string): SlotRecord | null;
     /**
      * Fetch an existing slot or create it. On creation the schedule's target
      * membership is snapshotted (target_ids); a later config reload never mutates
@@ -81,6 +100,10 @@ export declare class SlotRepository extends BaseRepository {
         manualRequestId?: string | null;
         /** Opaque caller correlation recorded with a manual slot. */
         correlationId?: string | null;
+        /** Manual recovery request UUID (opens a `recover-` slot). */
+        recoveryRequestId?: string | null;
+        /** Manual recovery policy preset ('normal' | 'relaxed'). */
+        recoveryMode?: string | null;
     }): {
         slot: SlotRecord;
         created: boolean;
@@ -143,6 +166,12 @@ export declare class SlotRepository extends BaseRepository {
     bumpFallbackStage(slotId: string, targetId: string, reason: string): number;
     cellFallbackStage(slotId: string, targetId: string): number;
     setCellStatus(slotId: string, targetId: string, status: CellStatus, error?: string): void;
+    /**
+     * Persist the normalized terminal failure reason for a cell (§terminal-reason).
+     * Idempotent; a retried recovery/rollup only ever overwrites with the same or
+     * a later reasoned verdict.
+     */
+    setCellTerminalReason(slotId: string, targetId: string, code: string, message: string): void;
     /**
      * Transition a cell with FSM validation. Never downgrades a confirmed cell;
      * an illegal transition throws rather than silently corrupting state.

package/dist/storage/repositories/SlotRepository.js

@@ -17,6 +17,11 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
         const rows = this.db.prepare(`SELECT * FROM schedule_slots WHERE manual_request_id = ?`).all(requestId);
         return rows.map((row) => this.toSlot(row)).find((slot) => slot.targetIds.includes(targetId)) ?? null;
     }
+    /** Exact manual RECOVERY request/target lookup (§manual-recovery). */
+    findRecoverySlot(requestId, targetId) {
+        const rows = this.db.prepare(`SELECT * FROM schedule_slots WHERE recovery_request_id = ?`).all(requestId);
+        return rows.map((row) => this.toSlot(row)).find((slot) => slot.targetIds.includes(targetId)) ?? null;
+    }
     /**
      * Fetch an existing slot or create it. On creation the schedule's target
      * membership is snapshotted (target_ids); a later config reload never mutates
@@ -26,10 +31,12 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
     getOrCreateSlot(id, data) {
         const insert = this.db.prepare(`INSERT INTO schedule_slots
          (id, schedule_id, occurrence_at, occurrence_date, occurrence_label, timezone, target_ids,
-          status, trigger_source, slot_date, slot_name, manual_request_id, correlation_id)
+          status, trigger_source, slot_date, slot_name, manual_request_id, correlation_id,
+          recovery_request_id, recovery_mode)
        VALUES
          (@id, @scheduleId, @occurrenceAt, @occurrenceDate, @occurrenceLabel, @timezone, @targetIds,
-          'pending', @triggerSource, @slotDate, @slotName, @manualRequestId, @correlationId)
+          'pending', @triggerSource, @slotDate, @slotName, @manualRequestId, @correlationId,
+          @recoveryRequestId, @recoveryMode)
        ON CONFLICT(id) DO NOTHING`);
         const info = insert.run({
             id,
@@ -44,6 +51,8 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             slotName: data.slotName ?? '',
             manualRequestId: data.manualRequestId ?? null,
             correlationId: data.correlationId ?? null,
+            recoveryRequestId: data.recoveryRequestId ?? null,
+            recoveryMode: data.recoveryMode ?? null,
         });
         const created = info.changes > 0;
         return { slot: this.getSlot(id), created };
@@ -244,6 +253,19 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             .prepare(`UPDATE schedule_slot_items SET ${sets.join(', ')} WHERE slot_id = @slotId AND target_id = @targetId`)
             .run({ slotId, targetId, status, error: error ?? null });
     }
+    /**
+     * Persist the normalized terminal failure reason for a cell (§terminal-reason).
+     * Idempotent; a retried recovery/rollup only ever overwrites with the same or
+     * a later reasoned verdict.
+     */
+    setCellTerminalReason(slotId, targetId, code, message) {
+        this.db
+            .prepare(`UPDATE schedule_slot_items
+         SET terminal_reason_code = @code, terminal_reason_message = @message,
+             updated_at = CURRENT_TIMESTAMP
+         WHERE slot_id = @slotId AND target_id = @targetId`)
+            .run({ slotId, targetId, code: code.slice(0, 64), message: message.slice(0, 400) });
+    }
     /**
      * Transition a cell with FSM validation. Never downgrades a confirmed cell;
      * an illegal transition throws rather than silently corrupting state.
@@ -402,6 +424,8 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             heartbeatAt: row.heartbeat_at ?? null,
             manualRequestId: row.manual_request_id ?? null,
             correlationId: row.correlation_id ?? null,
+            recoveryRequestId: row.recovery_request_id ?? null,
+            recoveryMode: row.recovery_mode ?? null,
         };
     }
     toItem(row) {
@@ -415,6 +439,8 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             attemptCount: row.attempt_count,
             fallback_stage: Number(row.fallback_stage ?? 0),
             lastError: row.last_error,
+            terminalReasonCode: row.terminal_reason_code ?? null,
+            terminalReasonMessage: row.terminal_reason_message ?? null,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
             completedAt: row.completed_at,

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.4', commit: '5bb73436b670' };
+exports.BUILD = { version: '2.21.0', commit: '56d4043e026e' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixivflow",
-  "version": "2.20.4",
-  "description": "🎨 智能的 Pixiv 自动化下载工具 - 支持批量下载插画和小说、定时任务、Docker部署 | Intelligent Pixiv Automation Downloader with batch download, scheduler, and Docker support",
+  "version": "2.21.0",
+  "description": "🎨 Pixiv 下载、筛选与自动收集工具 - 批量下载插画和小说、按标签/热度/日期筛选、定时任务与可靠 HTTP 交付 | Pixiv downloader and automation toolkit with filtering, scheduling and reliable HTTP delivery",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/redtidev1918/PixivFlow.git"