pixivflow 2.28.1 → 2.30.0

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,59 @@ 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;
+}
+/** Phase 5: durable 待发池 snapshot for sparse topics (only when enabled). */
+export interface CandidateInventoryReport {
+    /** Rows still usable for fallback at report time. */
+    pendingCount: number;
+    /** Target's configured max retained rows. */
+    reserveSize: number;
+    /** Max age in days before a pending candidate expires. */
+    maxAgeDays: number;
+    /** Earliest still-pending first-seen date (YYYY-MM-DD), null when empty. */
+    oldestSeenDate: string | null;
+}
+/** 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[];
+    /** Phase 5: durable 待发池 reserve (optional, present only when enabled). */
+    inventory?: CandidateInventoryReport;
+}
+/**
+ * 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 +175,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,62 @@ 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: [], inventory: undefined };
+}
+/**
+ * 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,
+        inventory: second.inventory ?? first.inventory,
+    };
+}
+/**
+ * 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,
+        inventory: base.inventory,
+    };
+}
 /**
  * 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 +189,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/Database.d.ts

@@ -5,6 +5,7 @@ import { OutboxRepository } from './repositories/OutboxRepository';
 import { MetadataRepository } from './repositories/MetadataRepository';
 import { SQLiteRateLimitStateStore } from './repositories/RateLimitStateRepository';
 import { SystemErrorRepository } from './repositories/SystemErrorRepository';
+import { CandidateInventoryRepository } from './repositories/CandidateInventoryRepository';
 export interface AccessTokenStore {
     accessToken: string;
     expiresAt: number;
@@ -48,6 +49,7 @@ export declare class Database implements IDatabase {
     private metadataRepo;
     private rateLimitStateStore;
     private systemErrorRepo;
+    private candidateInventoryRepo;
     constructor(databasePath: string);
     migrate(): void;
     /** Absolute path of the SQLite file (used to locate sibling cache dirs). */
@@ -64,6 +66,8 @@ export declare class Database implements IDatabase {
     get rateLimitState(): SQLiteRateLimitStateStore;
     /** Durable system-error ledger (observability; never throws). */
     get systemErrors(): SystemErrorRepository;
+    /** Phase 5 CandidateInventory (待发池) for sparse topics. */
+    get candidateInventory(): CandidateInventoryRepository;
     /** Raw transactional boundary for atomic multi-table intents. */
     transaction<T>(fn: () => T): T;
     /** Expose a prepared-statement helper if needed by services (pragmas etc). */

package/dist/storage/Database.js

@@ -18,6 +18,7 @@ const OutboxRepository_1 = require("./repositories/OutboxRepository");
 const MetadataRepository_1 = require("./repositories/MetadataRepository");
 const RateLimitStateRepository_1 = require("./repositories/RateLimitStateRepository");
 const SystemErrorRepository_1 = require("./repositories/SystemErrorRepository");
+const CandidateInventoryRepository_1 = require("./repositories/CandidateInventoryRepository");
 const NodeSqliteDriver_1 = require("./drivers/NodeSqliteDriver");
 class Database {
     databasePath;
@@ -35,6 +36,7 @@ class Database {
     metadataRepo;
     rateLimitStateStore;
     systemErrorRepo;
+    candidateInventoryRepo;
     constructor(databasePath) {
         this.databasePath = databasePath;
         try {
@@ -63,6 +65,7 @@ class Database {
             this.metadataRepo = new MetadataRepository_1.MetadataRepository(this.db);
             this.rateLimitStateStore = new RateLimitStateRepository_1.SQLiteRateLimitStateStore(this.db);
             this.systemErrorRepo = new SystemErrorRepository_1.SystemErrorRepository(this.db);
+            this.candidateInventoryRepo = new CandidateInventoryRepository_1.CandidateInventoryRepository(this.db);
         }
         catch (error) {
             throw new errors_1.DatabaseError(`Failed to initialize database at ${this.databasePath}`, error instanceof Error ? error : undefined);
@@ -102,6 +105,10 @@ class Database {
     get systemErrors() {
         return this.systemErrorRepo;
     }
+    /** Phase 5 CandidateInventory (待发池) for sparse topics. */
+    get candidateInventory() {
+        return this.candidateInventoryRepo;
+    }
     /** Raw transactional boundary for atomic multi-table intents. */
     transaction(fn) {
         return this.db.transaction(fn)();

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,
@@ -221,6 +222,25 @@ class DatabaseMigration {
             scope TEXT PRIMARY KEY,
             state TEXT NOT NULL,
             updated_at INTEGER NOT NULL
+          )`,
+                // Phase 5 CandidateInventory: durable 待发池 for sparse topics. Same
+                // database and transaction world as the Slot Ledger; never a second
+                // state authority. Only populated when target.topicProfile.inventory.enabled.
+                `CREATE TABLE IF NOT EXISTS candidate_inventory (
+            pixiv_id TEXT NOT NULL,
+            work_type TEXT NOT NULL,
+            topic TEXT NOT NULL,
+            target_id TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            snapshot_json TEXT NOT NULL,
+            first_seen_date TEXT NOT NULL,
+            last_seen_date TEXT NOT NULL,
+            seen_count INTEGER NOT NULL DEFAULT 1,
+            attempt_count INTEGER NOT NULL DEFAULT 0,
+            expires_at TEXT NOT NULL,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (pixiv_id, work_type, topic, target_id)
           )`,
                 // Durable error event ledger for observability (structured error
                 // taxonomy; populated by download/system handlers and shown in the
@@ -243,6 +263,7 @@ class DatabaseMigration {
             resolved_at DATETIME
           )`,
                 `CREATE INDEX IF NOT EXISTS idx_system_errors_bot_created ON system_errors(bot_id, created_at)`,
+                `CREATE INDEX IF NOT EXISTS idx_cinventory_pending ON candidate_inventory(status, first_seen_date, expires_at)`,
             ];
             // Phase 1: create tables (idempotent). Must run before any PRAGMA-based
             // column check, otherwise a fresh DB would report the table as missing and
@@ -287,6 +308,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/CandidateInventoryRepository.d.ts

@@ -0,0 +1,51 @@
+import { BaseRepository } from './BaseRepository';
+export type CandidateInventoryStatus = 'pending' | 'selected' | 'submitted' | 'filtered' | 'expired';
+export interface CandidateInventoryRow {
+    pixivId: string;
+    workType: 'illustration' | 'novel';
+    topic: string;
+    targetId: string;
+    status: CandidateInventoryStatus;
+    snapshotJson: string;
+    firstSeenDate: string;
+    lastSeenDate: string;
+    seenCount: number;
+    attemptCount: number;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CandidateInventorySnapshot {
+    pixivId: string;
+    workType: 'illustration' | 'novel';
+    topic: string;
+    targetId: string;
+    snapshot: unknown;
+    date: string;
+    maxAgeDays: number;
+}
+/** Phase 5 durable 待发池 — same SQLite database as the Slot Ledger. */
+export declare class CandidateInventoryRepository extends BaseRepository {
+    upsert(input: CandidateInventorySnapshot): void;
+    /** Marks a claimed candidate and returns its snapshot for the pipeline. */
+    claimNext(input: {
+        topic: string;
+        targetId: string;
+        reserveSize: number;
+        date: string;
+    }): CandidateInventoryRow | null;
+    markSubmitted(pixivId: string, workType: string, topic: string, targetId: string): void;
+    markFiltered(pixivId: string, workType: string, topic: string, targetId: string): void;
+    markSelectedBackToPending(pixivId: string, workType: string, topic: string, targetId: string): void;
+    countPending(topic: string, targetId: string): number;
+    pendingSummary(topic: string, targetId: string): {
+        count: number;
+        oldestSeenDate: string | null;
+    };
+    /** Sweep rows past maxAgeDays; idempotent per scheduled scan. */
+    evictExpired(topic: string, targetId: string): number;
+    private toRow;
+    private todayUtc;
+    private addDaysUtc;
+}
+//# sourceMappingURL=CandidateInventoryRepository.d.ts.map

package/dist/storage/repositories/CandidateInventoryRepository.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CandidateInventoryRepository = void 0;
+const BaseRepository_1 = require("./BaseRepository");
+/** Phase 5 durable 待发池 — same SQLite database as the Slot Ledger. */
+class CandidateInventoryRepository extends BaseRepository_1.BaseRepository {
+    upsert(input) {
+        const expiresAt = this.addDaysUtc(input.date, input.maxAgeDays);
+        this.db
+            .prepare(`INSERT INTO candidate_inventory
+           (pixiv_id, work_type, topic, target_id, status, snapshot_json,
+            first_seen_date, last_seen_date, seen_count, attempt_count, expires_at)
+         VALUES
+           (@pixivId, @workType, @topic, @targetId, 'pending', @snapshot,
+            @date, @date, 1, 0, @expiresAt)
+         ON CONFLICT(pixiv_id, work_type, topic, target_id) DO UPDATE SET
+           snapshot_json = excluded.snapshot_json,
+           last_seen_date = excluded.last_seen_date,
+           seen_count = candidate_inventory.seen_count + 1,
+           status = CASE
+             WHEN candidate_inventory.status IN ('selected','submitted','filtered','expired')
+                  THEN candidate_inventory.status
+             ELSE 'pending'
+           END,
+           expires_at = excluded.expires_at,
+           updated_at = CURRENT_TIMESTAMP`)
+            .run({
+            pixivId: input.pixivId,
+            workType: input.workType,
+            topic: input.topic,
+            targetId: input.targetId,
+            snapshot: JSON.stringify(input.snapshot),
+            date: input.date,
+            expiresAt,
+        });
+    }
+    /** Marks a claimed candidate and returns its snapshot for the pipeline. */
+    claimNext(input) {
+        const rows = this.db
+            .prepare(`SELECT * FROM candidate_inventory
+         WHERE topic = ? AND target_id = ?
+           AND status = 'pending'
+           AND expires_at >= ?
+         ORDER BY first_seen_date ASC, seen_count ASC
+         LIMIT ?`)
+            .all(input.topic, input.targetId, this.addDaysUtc(input.date, 0), input.reserveSize);
+        for (const row of rows) {
+            const updated = this.db
+                .prepare(`UPDATE candidate_inventory
+           SET status = 'selected', attempt_count = attempt_count + 1, updated_at = CURRENT_TIMESTAMP
+           WHERE pixiv_id = ? AND work_type = ? AND topic = ? AND target_id = ? AND status = 'pending'`)
+                .run(row.pixiv_id, row.work_type, row.topic, row.target_id);
+            if (updated.changes > 0)
+                return this.toRow(row);
+        }
+        return null;
+    }
+    markSubmitted(pixivId, workType, topic, targetId) {
+        this.db
+            .prepare(`UPDATE candidate_inventory
+         SET status = 'submitted', updated_at = CURRENT_TIMESTAMP
+         WHERE pixiv_id = ? AND work_type = ? AND topic = ? AND target_id = ?`)
+            .run(pixivId, workType, topic, targetId);
+    }
+    markFiltered(pixivId, workType, topic, targetId) {
+        this.db
+            .prepare(`UPDATE candidate_inventory
+         SET status = 'filtered', updated_at = CURRENT_TIMESTAMP
+         WHERE pixiv_id = ? AND work_type = ? AND topic = ? AND target_id = ?`)
+            .run(pixivId, workType, topic, targetId);
+    }
+    markSelectedBackToPending(pixivId, workType, topic, targetId) {
+        this.db
+            .prepare(`UPDATE candidate_inventory
+         SET status = 'pending', updated_at = CURRENT_TIMESTAMP
+         WHERE pixiv_id = ? AND work_type = ? AND topic = ? AND target_id = ? AND status = 'selected'`)
+            .run(pixivId, workType, topic, targetId);
+    }
+    countPending(topic, targetId) {
+        const rows = this.db
+            .prepare(`SELECT COUNT(*) AS n FROM candidate_inventory WHERE topic = ? AND target_id = ? AND status = 'pending' AND expires_at >= ?`)
+            .get(topic, targetId, this.todayUtc());
+        return Number(rows?.n ?? 0);
+    }
+    pendingSummary(topic, targetId) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) AS n, MIN(first_seen_date) AS oldest
+         FROM candidate_inventory
+         WHERE topic = ? AND target_id = ? AND status = 'pending' AND expires_at >= ?`)
+            .get(topic, targetId, this.todayUtc());
+        return { count: Number(row?.n ?? 0), oldestSeenDate: row?.oldest ?? null };
+    }
+    /** Sweep rows past maxAgeDays; idempotent per scheduled scan. */
+    evictExpired(topic, targetId) {
+        const info = this.db
+            .prepare(`UPDATE candidate_inventory
+         SET status = 'expired', updated_at = CURRENT_TIMESTAMP
+         WHERE topic = ? AND target_id = ? AND status IN ('pending','selected') AND expires_at < ?`)
+            .run(topic, targetId, this.todayUtc());
+        return info.changes;
+    }
+    toRow(row) {
+        return {
+            pixivId: String(row.pixiv_id),
+            workType: row.work_type,
+            topic: row.topic,
+            targetId: row.target_id,
+            status: row.status,
+            snapshotJson: row.snapshot_json,
+            firstSeenDate: row.first_seen_date,
+            lastSeenDate: row.last_seen_date,
+            seenCount: Number(row.seen_count ?? 1),
+            attemptCount: Number(row.attempt_count ?? 0),
+            expiresAt: row.expires_at,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    todayUtc() {
+        return new Date().toISOString().slice(0, 10);
+    }
+    addDaysUtc(date, days) {
+        const d = new Date(`${date}T00:00:00.000Z`);
+        d.setUTCDate(d.getUTCDate() + days);
+        return d.toISOString().slice(0, 10);
+    }
+}
+exports.CandidateInventoryRepository = CandidateInventoryRepository;
+//# sourceMappingURL=CandidateInventoryRepository.js.map

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.30.0', commit: '153116bd9b08' };
 //# sourceMappingURL=version.js.map