pixivflow 2.28.1 → 2.29.0

package/dist/commands/scheduler-runtime.js

@@ -709,6 +709,7 @@ async function createSchedulerRuntime(configPathArg) {
                             error: c.error ?? null,
                             terminal_reason_code: c.terminalReasonCode ?? null,
                             reason: c.terminalReasonMessage ?? null,
+                            candidateReport: c.candidateReport ?? null,
                         };
                     }));
                 }

package/dist/delivery/DeliveryService.d.ts

@@ -50,6 +50,7 @@ export interface ScheduleOutcomePayload {
         workType: string;
         status: string;
         workId?: string | null;
+        candidateReport?: Record<string, unknown> | null;
     }>;
 }
 export declare class DeliveryService {

package/dist/delivery/HttpMultipartDelivery.js

@@ -176,6 +176,7 @@ class HttpMultipartDelivery {
                         stage: t.stage ?? null,
                         retryable: t.retryable ?? null,
                         operator_hint: t.operator_hint ?? null,
+                        candidate_report: t.candidate_report ?? null,
                     })),
                 }
                 : { text: request.text, idempotency_key: request.idempotencyKey };

package/dist/delivery/types.d.ts

@@ -146,6 +146,8 @@ export interface DeliveryNotificationRequest {
             /** Whether a later/manual attempt may succeed; terminal does not mean auto-retry pending. */
             retryable?: boolean | null;
             operator_hint?: string | null;
+            /** Phase 1 Candidate Supply Report ({fetched, selected, rejected, reasons}). */
+            candidate_report?: Record<string, unknown> | null;
         }>;
     };
 }

package/dist/download/handlers/IllustrationTargetHandler.d.ts

@@ -25,6 +25,11 @@ export declare class IllustrationTargetHandler {
      * explicit verdict instead of an ambiguous "completed".
      */
     private scan;
+    /**
+     * Upstream topic-supply funnel accumulated across a lookback scan (Phase 1
+     * Candidate Report: fetched/selected/rejected + reasons).
+     */
+    private supplyRep;
     /**
      * Global candidate-scan bound (`download.candidateScanLimit`), supplied by
      * DownloadManager. This is what lets the FETCH stage ask for more than one

package/dist/download/handlers/IllustrationTargetHandler.js

@@ -29,6 +29,11 @@ class IllustrationTargetHandler {
      * explicit verdict instead of an ambiguous "completed".
      */
     scan = null;
+    /**
+     * Upstream topic-supply funnel accumulated across a lookback scan (Phase 1
+     * Candidate Report: fetched/selected/rejected + reasons).
+     */
+    supplyRep = null;
     /**
      * Global candidate-scan bound (`download.candidateScanLimit`), supplied by
      * DownloadManager. This is what lets the FETCH stage ask for more than one
@@ -68,6 +73,7 @@ class IllustrationTargetHandler {
     async handle(target, execution) {
         this.outcomes = [];
         this.scan = null;
+        this.supplyRep = null;
         this.execution = execution && (0, WorkIdentity_1.isSingleWorkCell)(target) ? execution : null;
         // A cell that already owns a work is in RECOVERY, not in a new selection.
         // Crash/shutdown recovery is not an intentional second run: running the
@@ -113,6 +119,9 @@ class IllustrationTargetHandler {
      * scheduled slot report success after submitting nothing.
      */
     summarize(target) {
+        if (this.scan && this.supplyRep) {
+            this.scan = { ...this.scan, supply: (0, TargetOutcome_1.withScanSkips)(this.supplyRep, this.scan) };
+        }
         const scan = this.scan ?? undefined;
         const submitted = this.outcomes.find((o) => o.kind === 'submitted');
         if (submitted)
@@ -198,7 +207,8 @@ class IllustrationTargetHandler {
     }
     async fetchIllustrations(target, mode) {
         if (mode === 'topic') {
-            return this.fetchTopicIllustrations(target);
+            const { works } = await this.fetchTopicIllustrations(target);
+            return works;
         }
         if (mode === 'ranking') {
             return this.fetchRankingIllustrations(target);
@@ -223,7 +233,19 @@ class IllustrationTargetHandler {
         const pipeline = this.topicPipelineFactory();
         const { works, selection } = await pipeline.selectWorks(target, 'illustration', day, selectionLimit, target.topicDiscovery ?? {}, target.candidateCollection ?? {});
         logger_1.logger.info(`Topic "${topic}" illustration: tags=${selection.resolvedTagCount} raw=${selection.rawCount} deduped=${selection.dedupedCount} aiExcluded=${selection.aiExcludedCount} accepted=${selection.acceptedCount} candidates=${works.length} target=${limit}`);
-        return works;
+        // Candidate Supply Observability: fold this lookback day's upstream funnel
+        // into the target's accumulated Candidate Report.
+        const report = (0, TargetOutcome_1.emptyCandidateSupplyReport)();
+        report.fetched = selection.rawCount;
+        report.selected = selection.acceptedCount;
+        report.rejected = Math.max(0, selection.rawCount - selection.acceptedCount);
+        report.reasons = [
+            { code: 'duplicate', count: selection.duplicateRemovedCount },
+            { code: 'ai_filtered', count: selection.aiExcludedCount },
+            { code: 'metadata_filtered', count: Math.max(0, selection.dedupedCount - selection.acceptedCount) },
+        ].filter((r) => r.count > 0);
+        this.supplyRep = (0, TargetOutcome_1.mergeCandidateSupplyReports)(this.supplyRep ?? undefined, report);
+        return { works, selection };
     }
     async handleTopicWithLookback(target, displayTag) {
         const requested = target.limit || 1;
@@ -241,7 +263,7 @@ class IllustrationTargetHandler {
                     fallbackOffset: offset,
                 });
             }
-            const illusts = await this.fetchTopicIllustrations(attemptTarget);
+            const { works: illusts } = await this.fetchTopicIllustrations(attemptTarget);
             const result = await this.pipeline.run(illusts, attemptTarget, 'illustration', (illust, tag) => this.downloadAndDeliver(illust, tag, attemptTarget));
             // The lookback loop is one bounded scan: accumulate every day's
             // skips/outages so the final verdict covers all candidates attempted.

package/dist/download/handlers/NovelTargetHandler.d.ts

@@ -24,6 +24,10 @@ export declare class NovelTargetHandler {
      * explicit verdict instead of an ambiguous "completed".
      */
     private scan;
+    /**
+     * Upstream topic-supply funnel accumulated across a lookback scan.
+     */
+    private supplyRep;
     /**
      * Global candidate-scan bound (`download.candidateScanLimit`), supplied by
      * DownloadManager. This is what lets the FETCH stage ask for more than one

package/dist/download/handlers/NovelTargetHandler.js

@@ -29,6 +29,10 @@ class NovelTargetHandler {
      * explicit verdict instead of an ambiguous "completed".
      */
     scan = null;
+    /**
+     * Upstream topic-supply funnel accumulated across a lookback scan.
+     */
+    supplyRep = null;
     /**
      * Global candidate-scan bound (`download.candidateScanLimit`), supplied by
      * DownloadManager. This is what lets the FETCH stage ask for more than one
@@ -68,6 +72,7 @@ class NovelTargetHandler {
     async handle(target, execution) {
         this.outcomes = [];
         this.scan = null;
+        this.supplyRep = null;
         this.execution = execution && (0, WorkIdentity_1.isSingleWorkCell)(target) ? execution : null;
         // A cell that already owns a work is in RECOVERY, not in a new selection.
         // Crash/shutdown recovery is not an intentional second run: running the
@@ -126,6 +131,9 @@ class NovelTargetHandler {
      * single-work RECOVERY path, whose cell identity is fixed.
      */
     summarize() {
+        if (this.scan && this.supplyRep) {
+            this.scan = { ...this.scan, supply: (0, TargetOutcome_1.withScanSkips)(this.supplyRep, this.scan) };
+        }
         const scan = this.scan ?? undefined;
         const submitted = this.outcomes.find((o) => o.kind === 'submitted');
         if (submitted)
@@ -200,7 +208,8 @@ class NovelTargetHandler {
     }
     async fetchNovels(target, mode) {
         if (mode === 'topic') {
-            return this.fetchTopicNovels(target);
+            const { works } = await this.fetchTopicNovels(target);
+            return works;
         }
         if (mode === 'ranking') {
             return this.fetchRankingNovels(target);
@@ -223,7 +232,16 @@ class NovelTargetHandler {
         const pipeline = this.topicPipelineFactory();
         const { works, selection } = await pipeline.selectWorks(target, 'novel', day, selectionLimit, target.topicDiscovery ?? {}, target.candidateCollection ?? {});
         logger_1.logger.info(`Topic "${topic}" novel: tags=${selection.resolvedTagCount} raw=${selection.rawCount} deduped=${selection.dedupedCount} accepted=${selection.acceptedCount} candidates=${works.length} target=${limit}`);
-        return works;
+        const report = (0, TargetOutcome_1.emptyCandidateSupplyReport)();
+        report.fetched = selection.rawCount;
+        report.selected = selection.acceptedCount;
+        report.rejected = Math.max(0, selection.rawCount - selection.acceptedCount);
+        report.reasons = [
+            { code: 'duplicate', count: selection.duplicateRemovedCount },
+            { code: 'metadata_filtered', count: Math.max(0, selection.dedupedCount - selection.acceptedCount) },
+        ].filter((r) => r.count > 0);
+        this.supplyRep = (0, TargetOutcome_1.mergeCandidateSupplyReports)(this.supplyRep ?? undefined, report);
+        return { works, selection };
     }
     async handleTopicWithLookback(target, displayTag) {
         const requested = target.limit || 1;
@@ -253,7 +271,7 @@ class NovelTargetHandler {
                     fallbackOffset: offset,
                 });
             }
-            const novels = await this.fetchTopicNovels(attemptTarget);
+            const { works: novels } = await this.fetchTopicNovels(attemptTarget);
             totalFound += novels.length;
             const result = await this.pipeline.run(novels, attemptTarget, 'novel', (novel, tag) => this.downloadAndDeliver(novel, tag, attemptTarget));
             // The lookback loop is ONE bounded scan: accumulate every day's

package/dist/notification/NotificationPolicy.d.ts

@@ -46,6 +46,7 @@ export declare class NotificationPolicy {
         error: string | null;
         terminal_reason_code?: string | null;
         reason?: string | null;
+        candidateReport?: Record<string, unknown> | null;
     }>): void;
     /**
      * Delivery targets whose HTTP target declares the given outcome URL.

package/dist/notification/NotificationPolicy.js

@@ -145,6 +145,7 @@ class NotificationPolicy {
                         stage: operational?.stage ?? null,
                         retryable: operational?.retryable ?? null,
                         operator_hint: operational?.operatorHint ?? null,
+                        candidate_report: r.candidateReport ?? null,
                     };
                 }),
             });

package/dist/package.json

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

package/dist/scheduler/SlotCoordinator.d.ts

@@ -67,6 +67,8 @@ export interface SlotCellSummary {
     terminalReasonCode?: string | null;
     /** User-facing business reason message (§terminal-reason). */
     terminalReasonMessage?: string | null;
+    /** Phase 1 Candidate Supply Report attached to the durable cell. */
+    candidateReport?: Record<string, unknown> | null;
 }
 export interface SlotRunSummary {
     scheduleId: string;
@@ -82,6 +84,8 @@ export interface ScheduleOutcomeTarget {
     status: CellStatus;
     work_id: string | null;
     error: string | null;
+    /** Phase 1 Candidate Supply Report ({fetched, selected, rejected, reasons}). */
+    candidate_report: Record<string, unknown> | null;
 }
 /**
  * Business categories an operator actually asks about, counted per cell. The
@@ -254,6 +258,8 @@ export declare class SlotCoordinator {
      * sole path to the submitted cell state.
      */
     applyOutcome(slotId: string, targetId: string, outcome: TargetOutcome): void;
+    /** Persist the Phase 1 candidate-report funnel for a target cell. */
+    private persistCandidateReport;
     /**
      * Persist the normalized terminal reason (§terminal-reason) for a cell that
      * just reached a terminal state. Never unwinds the run and never leaks raw

package/dist/scheduler/SlotCoordinator.js

@@ -255,6 +255,7 @@ class SlotCoordinator {
         switch (outcome.kind) {
             case 'submitted':
                 this.database.slots.lockCellWork(slotId, targetId, outcome.workId, outcome.workType);
+                this.persistCandidateReport(slotId, targetId, outcome);
                 this.safeTransition(slotId, targetId, 'submitted');
                 return;
             case 'stored':
@@ -262,22 +263,26 @@ class SlotCoordinator {
                 // cell, but labelled via the ledger-free 'submitted' aggregate state so
                 // download-only schedules do not rerun forever.
                 this.database.slots.lockCellWork(slotId, targetId, outcome.workId, outcome.workType);
+                this.persistCandidateReport(slotId, targetId, outcome);
                 this.safeTransition(slotId, targetId, 'submitted');
                 return;
             case 'delivery_pending':
                 this.database.slots.lockCellWork(slotId, targetId, outcome.workId, outcome.workType);
+                this.persistCandidateReport(slotId, targetId, outcome);
                 this.safeTransition(slotId, targetId, 'delivery_pending');
                 return;
             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) {
+                    this.persistCandidateReport(slotId, targetId, outcome);
                     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.persistCandidateReport(slotId, targetId, outcome);
                 this.safeTransition(slotId, targetId, 'duplicate', outcome.reason);
                 this.persistTerminalReason(slotId, targetId, outcome);
                 return;
@@ -286,13 +291,31 @@ class SlotCoordinator {
                     // Leave non-terminal (selected/delivery_pending) so a later trigger
                     // resumes the SAME work. Record the error without a terminal state.
                     this.database.slots.setCellError?.(slotId, targetId, outcome.error);
+                    this.persistCandidateReport(slotId, targetId, outcome);
                     return;
                 }
+                this.persistCandidateReport(slotId, targetId, outcome);
                 this.safeTransition(slotId, targetId, 'failed', outcome.error);
                 this.persistTerminalReason(slotId, targetId, outcome);
                 return;
         }
     }
+    /** Persist the Phase 1 candidate-report funnel for a target cell. */
+    persistCandidateReport(slotId, targetId, outcome) {
+        const report = outcome.scan?.supply;
+        if (!report)
+            return;
+        try {
+            this.database.slots.setCellCandidateReport(slotId, targetId, report);
+        }
+        catch (error) {
+            logger_1.logger.debug('Failed to persist candidate report', {
+                slot: slotId,
+                target: targetId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     /**
      * Persist the normalized terminal reason (§terminal-reason) for a cell that
      * just reached a terminal state. Never unwinds the run and never leaks raw
@@ -444,6 +467,7 @@ class SlotCoordinator {
             error: c.lastError,
             terminalReasonCode: c.terminalReasonCode,
             terminalReasonMessage: c.terminalReasonMessage,
+            candidateReport: c.candidateReport,
         }));
         // 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.
@@ -493,6 +517,7 @@ class SlotCoordinator {
                 error: cell.lastError,
                 terminal_reason_code: cell.terminalReasonCode,
                 terminal_reason_message: cell.terminalReasonMessage,
+                candidate_report: cell.candidateReport,
             };
         });
         // A fully-submitted slot has no non-submitted cell at all, and reporting
@@ -611,6 +636,7 @@ class SlotCoordinator {
             status: c.status,
             workId: c.workId,
             error: c.lastError,
+            candidateReport: c.candidateReport,
         }));
         const slotRec = this.database.slots.getSlot(slotId);
         return {

package/dist/scheduler/TargetOutcome.d.ts

@@ -96,6 +96,46 @@ export type CandidateAttempt =
     kind: 'skipped';
     skip: CandidateSkip;
 };
+/**
+ * Upstream candidate-supply funnel for one target run (topic pipeline).
+ *
+ * Deliberately an open `reasons` bucket, NOT a fixed list of columns:
+ * illustration and novel filter chains differ, and future TopicProfile /
+ * CandidateInventory phases must be able to extend the taxonomy without a
+ * breaking schema change.
+ */
+export interface CandidateSupplyReason {
+    /** Stable machine-readable reason code, e.g. `duplicate`, `ai_filtered`. */
+    code: string;
+    count: number;
+}
+/** Candidate-supply observability snapshot (Phase 1 Candidate Report). */
+export interface CandidateSupplyReport {
+    /** Total works surfaced by the topic search before any filtering. */
+    fetched: number;
+    /** Candidates that survived upload selection (the pool handed to the scan). */
+    selected: number;
+    /** Count rejected by all filters (fetched - selected is a stable invariant). */
+    rejected: number;
+    /** Why candidates were rejected, by reason code (extensible). */
+    reasons: CandidateSupplyReason[];
+}
+/**
+ * A freshly-harvested upstream funnel with no candidates selected yet.
+ */
+export declare function emptyCandidateSupplyReport(): CandidateSupplyReport;
+/**
+ * Fold two supply snapshots of the SAME logical target together, so a
+ * multi-day lookback scan reports the whole funnel rather than only its last
+ * day. Reasons are summed by code.
+ */
+export declare function mergeCandidateSupplyReports(first: CandidateSupplyReport | undefined, second: CandidateSupplyReport): CandidateSupplyReport;
+/**
+ * Fold the scan-level (download-time) candidate skips into the upstream
+ * candidate report. `selected` is reduced by every usable candidate actually
+ * offered to the scan, and the skip reasons join the upstream reasons.
+ */
+export declare function withScanSkips(report: CandidateSupplyReport | undefined, scan: CandidateScanSummary | undefined): CandidateSupplyReport | undefined;
 /**
  * Bookkeeping for a target's bounded candidate scan. Attached to the terminal
  * target outcome so the run can state exactly one of:
@@ -122,6 +162,12 @@ export interface CandidateScanSummary {
     skipped: CandidateSkip[];
     /** Job-level outages observed while scanning (never a candidate verdict). */
     outages: JobLevelOutage[];
+    /**
+     * Upstream candidate-supply funnel that produced this scan, when the target
+     * ran through the topic pipeline (illustration or novel). Optional so ranking
+     * / search targets without a topic funnel keep working unchanged.
+     */
+    supply?: CandidateSupplyReport;
 }
 /**
  * A scan that attempted nothing. The real pipeline always reports its own scan;

package/dist/scheduler/TargetOutcome.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TERMINAL_REASON_MESSAGES = void 0;
+exports.emptyCandidateSupplyReport = emptyCandidateSupplyReport;
+exports.mergeCandidateSupplyReports = mergeCandidateSupplyReports;
+exports.withScanSkips = withScanSkips;
 exports.emptyCandidateScan = emptyCandidateScan;
 exports.isTerminalOutcome = isTerminalOutcome;
 exports.isSelectedAttempt = isSelectedAttempt;
@@ -13,6 +16,60 @@ exports.classifyCandidateFailure = classifyCandidateFailure;
 exports.classifyJobLevelOutage = classifyJobLevelOutage;
 exports.operationalReasonForCode = operationalReasonForCode;
 exports.terminalReasonFor = terminalReasonFor;
+/**
+ * A freshly-harvested upstream funnel with no candidates selected yet.
+ */
+function emptyCandidateSupplyReport() {
+    return { fetched: 0, selected: 0, rejected: 0, reasons: [] };
+}
+/**
+ * Fold two supply snapshots of the SAME logical target together, so a
+ * multi-day lookback scan reports the whole funnel rather than only its last
+ * day. Reasons are summed by code.
+ */
+function mergeCandidateSupplyReports(first, second) {
+    if (!first)
+        return second;
+    const byCode = new Map();
+    for (const r of [...first.reasons, ...second.reasons]) {
+        byCode.set(r.code, (byCode.get(r.code) ?? 0) + r.count);
+    }
+    const reasons = [...byCode.entries()]
+        .map(([code, count]) => ({ code, count }))
+        .filter((r) => r.count > 0)
+        .sort((a, b) => b.count - a.count);
+    return {
+        fetched: first.fetched + second.fetched,
+        selected: first.selected + second.selected,
+        rejected: Math.max(0, first.fetched + second.fetched - (first.selected + second.selected)),
+        reasons,
+    };
+}
+/**
+ * Fold the scan-level (download-time) candidate skips into the upstream
+ * candidate report. `selected` is reduced by every usable candidate actually
+ * offered to the scan, and the skip reasons join the upstream reasons.
+ */
+function withScanSkips(report, scan) {
+    if (!scan || scan.skipped.length === 0)
+        return report;
+    const base = report ?? emptyCandidateSupplyReport();
+    const byCode = new Map(base.reasons.map((r) => [r.code, r.count]));
+    for (const skip of scan.skipped) {
+        byCode.set(skip.code, (byCode.get(skip.code) ?? 0) + 1);
+    }
+    const reasons = [...byCode.entries()]
+        .map(([code, count]) => ({ code, count }))
+        .filter((r) => r.count > 0)
+        .sort((a, b) => b.count - a.count);
+    const selected = Math.max(0, base.selected - scan.skipped.length);
+    return {
+        fetched: base.fetched,
+        selected,
+        rejected: Math.max(0, base.fetched - selected),
+        reasons,
+    };
+}
 /**
  * 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
@@ -130,6 +187,9 @@ function mergeScanSummaries(first, second) {
         attempted: first.attempted + second.attempted,
         skipped: [...first.skipped, ...second.skipped],
         outages: [...new Set([...first.outages, ...second.outages])],
+        supply: second.supply
+            ? mergeCandidateSupplyReports(first.supply, second.supply)
+            : first.supply,
     };
 }
 const SQLITE_OUTAGE = /sqlite|database (?:is )?locked|unable to open database|no such table|disk i\/o error/i;

package/dist/storage/DatabaseMigration.js

@@ -135,6 +135,7 @@ class DatabaseMigration {
             -- code plus a user-facing business message, durable across restarts.
             terminal_reason_code TEXT,
             terminal_reason_message TEXT,
+            candidate_report TEXT,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
             updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
             completed_at DATETIME,
@@ -287,6 +288,9 @@ class DatabaseMigration {
             if (!itemCols.includes('terminal_reason_message')) {
                 columnAlters.push(`ALTER TABLE schedule_slot_items ADD COLUMN terminal_reason_message TEXT`);
             }
+            if (!itemCols.includes('candidate_report')) {
+                columnAlters.push(`ALTER TABLE schedule_slot_items ADD COLUMN candidate_report 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

@@ -62,6 +62,11 @@ export interface SlotItemRecord {
     terminalReasonCode: string | null;
     /** User-facing business message for the terminal reason. */
     terminalReasonMessage: string | null;
+    /**
+     * Candidate Supply Report (Phase 1), persisted as JSON on the same cell so
+     * the durable outcome and the review-group message can never disagree.
+     */
+    candidateReport: Record<string, unknown> | null;
     createdAt: string;
     updatedAt: string;
     completedAt: string | null;
@@ -172,6 +177,12 @@ export declare class SlotRepository extends BaseRepository {
      * a later reasoned verdict.
      */
     setCellTerminalReason(slotId: string, targetId: string, code: string, message: string): void;
+    /**
+     * Persist the Phase 1 candidate-supply funnel for a cell (JSON). Idempotent;
+     * recovery re-rolls overwrite with the newer observed funnel. A malformed
+     * payload must never block the terminal transition, so it is sanitised here.
+     */
+    setCellCandidateReport(slotId: string, targetId: string, report: Record<string, unknown> | null): 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

@@ -266,6 +266,22 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
          WHERE slot_id = @slotId AND target_id = @targetId`)
             .run({ slotId, targetId, code: code.slice(0, 64), message: message.slice(0, 400) });
     }
+    /**
+     * Persist the Phase 1 candidate-supply funnel for a cell (JSON). Idempotent;
+     * recovery re-rolls overwrite with the newer observed funnel. A malformed
+     * payload must never block the terminal transition, so it is sanitised here.
+     */
+    setCellCandidateReport(slotId, targetId, report) {
+        const json = report == null ? null : JSON.stringify(report);
+        if (json != null && json.length > 4000) {
+            throw new Error('candidate_report exceeds 4000 chars');
+        }
+        this.db
+            .prepare(`UPDATE schedule_slot_items
+         SET candidate_report = @report, updated_at = CURRENT_TIMESTAMP
+         WHERE slot_id = @slotId AND target_id = @targetId`)
+            .run({ slotId, targetId, report: json });
+    }
     /**
      * Transition a cell with FSM validation. Never downgrades a confirmed cell;
      * an illegal transition throws rather than silently corrupting state.
@@ -441,6 +457,7 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             lastError: row.last_error,
             terminalReasonCode: row.terminal_reason_code ?? null,
             terminalReasonMessage: row.terminal_reason_message ?? null,
+            candidateReport: row.candidate_report ? JSON.parse(row.candidate_report) : null,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
             completedAt: row.completed_at,

package/dist/topic/TopicPipeline.d.ts

@@ -9,6 +9,8 @@ export interface TopicSelection {
     dedupedCount: number;
     acceptedCount: number;
     aiExcludedCount: number;
+    /** Works seen more than once across the topic tag space (recorded, dropped). */
+    duplicateRemovedCount: number;
 }
 /**
  * Resolves a topic to a tag space, collects that day's works across the tags,

package/dist/topic/TopicPipeline.js

@@ -50,6 +50,7 @@ class TopicPipeline {
         const byId = new Map();
         let rawCount = 0;
         let aiExcludedCount = 0;
+        let duplicateRemovedCount = 0;
         const tagNames = space.tags.map((t) => t.name);
         for (let i = 0; i < tagNames.length; i++) {
             if (byId.size >= maxCandidates)
@@ -65,8 +66,10 @@ class TopicPipeline {
                     aiExcludedCount += 1;
                     continue;
                 }
-                if (byId.has(work.id))
+                if (byId.has(work.id)) {
+                    duplicateRemovedCount += 1;
                     continue;
+                }
                 byId.set(work.id, { work, candidate: this.toCandidate(work, contentType) });
                 if (byId.size >= maxCandidates)
                     break;
@@ -107,6 +110,7 @@ class TopicPipeline {
                 dedupedCount,
                 acceptedCount: accepted.length,
                 aiExcludedCount,
+                duplicateRemovedCount,
             },
         };
     }

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.28.1', commit: '1f5f0c240a38' };
+exports.BUILD = { version: '2.29.0', commit: '13e234a69cd2' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixivflow",
-  "version": "2.28.1",
+  "version": "2.29.0",
   "description": "🎨 Pixiv 下载、筛选与自动收集工具 - 批量下载插画和小说、按标签/热度/日期筛选、定时任务与可靠 HTTP 交付 | Pixiv downloader and automation toolkit with filtering, scheduling and reliable HTTP delivery",
   "repository": {
     "type": "git",