dsh-plugin-litsearch 0.2.0 → 0.3.5

package/lib/host/tasks/service.js

@@ -5,7 +5,7 @@
  * 模型工具与面板 HTTP 路由都只调用这里，保证两边操作同一份状态。
  */
 import { randomUUID } from 'node:crypto';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, rm, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { MAX_LIMIT, PLUGIN_VERSION, getSettings } from '../../search/config.js';
 import { SearchError } from '../../search/errors.js';
@@ -17,8 +17,9 @@ import { fetchPubtatorEntities } from '../../search/pubtator-entities.js';
 import { SOURCE_IDS } from '../../search/types.js';
 import { TaskEvents } from '../events.js';
 import { buildExport } from '../export/index.js';
-import { cleanupPdfCache, epmcFullTextAvailable, persistPdf, probePdfRoot, readLocalPdf, readableFilename, resolvePdf, resolvePdfRoot, } from '../pdf/store.js';
+import { cleanupPdfCache, epmcFullTextAvailable, persistPdf, probePdfRoot, prunePdfCache, readSavedPdf, readableFilename, resolvePdf, resolvePdfRoot, } from '../pdf/store.js';
 import { ZoteroConnector } from '../zotero/connector.js';
+import { normalizeWorkspace } from '../workspace.js';
 import { compareTasks } from './compare.js';
 import { filterPapers } from './filter.js';
 import { TaskRunner } from './runner.js';
@@ -31,6 +32,48 @@ const MAX_TITLE = 120;
 const MAX_PAGE_LIMIT = 200;
 const MAX_TYPES = 20;
 const PROBE_QUERY = 'machine learning';
+/** 已下载文件存在性检查的短缓存：详情轮询时不必反复 stat 同一批文件。 */
+const PDF_EXISTS_TTL_MS = 10_000;
+const pdfExistsCache = new Map();
+async function pdfFileExists(filePath) {
+    const cached = pdfExistsCache.get(filePath);
+    if (cached !== undefined && Date.now() - cached.at < PDF_EXISTS_TTL_MS)
+        return cached.exists;
+    const exists = await stat(filePath)
+        .then((info) => info.isFile())
+        .catch(() => false);
+    pdfExistsCache.set(filePath, { exists, at: Date.now() });
+    return exists;
+}
+/**
+ * 已下载的 PDF 可能被用户在文件管理器里删掉（也可能从废纸篓恢复）：
+ * 每次读取任务时校准状态，删除后回到 `missing`，点击即可重新下载。
+ */
+async function reconcilePdfFiles(task) {
+    const downloads = Object.entries(task.states).filter(([, state]) => state.pdfFile !== undefined &&
+        (state.pdfStatus === 'downloaded' || state.pdfStatus === 'missing'));
+    if (downloads.length === 0)
+        return false;
+    const checks = await Promise.all(downloads.map(async ([paperId, state]) => ({
+        paperId,
+        exists: await pdfFileExists(state.pdfFile ?? ''),
+    })));
+    let changed = false;
+    for (const { paperId, exists } of checks) {
+        const current = task.states[paperId];
+        if (current === undefined)
+            continue;
+        if (current.pdfStatus === 'downloaded' && !exists) {
+            task.states[paperId] = { ...current, pdfStatus: 'missing' };
+            changed = true;
+        }
+        else if (current.pdfStatus === 'missing' && exists) {
+            task.states[paperId] = { ...current, pdfStatus: 'downloaded' };
+            changed = true;
+        }
+    }
+    return changed;
+}
 export class TaskService {
     ready;
     store = new TaskStore();
@@ -63,6 +106,8 @@ export class TaskService {
         catch (error) {
             console.warn('[dsh-plugin-litsearch] 任务目录加载失败：', error);
         }
+        // 与任务自动清理同批执行：按总量上限修剪 PDF 去重缓存（0 表示关闭）。
+        await this.trimPdfCache();
         let restored = false;
         try {
             const snapshot = await this.store.loadCurrent();
@@ -79,6 +124,21 @@ export class TaskService {
         if (!restored)
             this.bootstrapCurrentTask();
     }
+    /** 按设置的总量上限修剪 PDF 去重缓存；失败只告警，不阻断启动。 */
+    async trimPdfCache() {
+        const maxMb = getSettings().pdfCacheMaxMb;
+        if (maxMb <= 0)
+            return;
+        try {
+            const outcome = await prunePdfCache(this.store.root, maxMb * 1024 * 1024);
+            if (outcome.removed > 0) {
+                console.info(`[dsh-plugin-litsearch] PDF 缓存已修剪：删除 ${outcome.removed} 个文件，释放 ${Math.round(outcome.freedBytes / 1024 / 1024)} MB（上限 ${maxMb} MB）`);
+            }
+        }
+        catch (error) {
+            console.warn('[dsh-plugin-litsearch] PDF 缓存修剪失败：', error);
+        }
+    }
     /** 没有可用快照时，把最近更新的任务设为当前任务并落盘。 */
     bootstrapCurrentTask() {
         const latest = this.store.list()[0];
@@ -109,7 +169,11 @@ export class TaskService {
             globalRev: this.events.currentRev,
             sources: [...PROVIDER_INFOS],
             sourceHealth: sourceHealthList(),
-            keys: { ncbi: settings.ncbiApiKey !== '', s2: settings.s2ApiKey !== '' },
+            keys: {
+                ncbi: settings.ncbiApiKey !== '',
+                s2: settings.s2ApiKey !== '',
+                serpapi: settings.serpApiKey !== '',
+            },
             settings: {
                 defaultSources: [...settings.defaultSources],
                 defaultPageSize: settings.defaultPageSize,
@@ -119,7 +183,7 @@ export class TaskService {
                 maxTaskTabs: settings.maxTaskTabs,
             },
             fullText: {
-                pdfRoot: resolvePdfRoot(),
+                pdfRoot: settings.pdfRoot.trim() === '' ? '' : resolvePdfRoot(),
                 pdfMaxMb: settings.pdfMaxMb,
                 autoDownload: settings.autoDownloadPdf,
                 epmcFulltext: settings.enableEpmcFulltext,
@@ -161,8 +225,12 @@ export class TaskService {
             task.rounds = [];
         return task;
     }
-    async getDetail(id) {
-        return toDetail(await this.get(id));
+    async getDetail(id, workspace) {
+        const task = await this.get(id);
+        if (await reconcilePdfFiles(task))
+            await this.store.save(task);
+        const target = normalizeWorkspace(workspace) ?? normalizeWorkspace(task.workspace);
+        return { ...toDetail(task), downloadDir: resolvePdfRoot(target) };
     }
     /** 任务内轮次历史（时间升序、深拷贝）。 */
     async getRounds(id) {
@@ -206,11 +274,20 @@ export class TaskService {
         });
     }
     /** 用户从任务列表点开某任务 = 进入该任务，之后的模型检索默认落在这里。 */
-    async activate(id) {
+    async activate(id, workspace) {
         const task = await this.get(id);
+        await this.applyWorkspace(task, workspace);
         this.setCurrentTask(task.id);
         return task;
     }
+    /** 记下任务最近一次所在的工作目录；只改变下载落点，不改变 rev。 */
+    async applyWorkspace(task, workspace) {
+        const next = normalizeWorkspace(workspace);
+        if (next === undefined || next === task.workspace)
+            return;
+        task.workspace = next;
+        await this.store.save(task);
+    }
     /** 等待该任务当前这一轮结束；返回是否确实已空闲。 */
     async waitUntilIdle(id, timeoutMs, signal) {
         if (!this.runner.isRunning(id))
@@ -250,6 +327,7 @@ export class TaskService {
         const conditions = this.readConditions(input, settings);
         const title = readTitle(input.title, conditions);
         const inherited = input.fromTaskId === undefined ? undefined : await this.get(input.fromTaskId);
+        const workspace = normalizeWorkspace(input.workspace);
         const now = new Date().toISOString();
         const task = {
             id: `t${Date.now().toString(36)}${randomUUID().slice(0, 6)}`,
@@ -272,6 +350,7 @@ export class TaskService {
             result: { papers: [], sources: [] },
             rounds: [],
             states: inherited === undefined ? {} : inheritStates(inherited),
+            ...(workspace === undefined ? {} : { workspace }),
             ...(input.fromTaskId === undefined ? {} : { fromTaskId: input.fromTaskId }),
         };
         this.store.put(task);
@@ -342,17 +421,17 @@ export class TaskService {
      *
      * 任务已缓存时同步登记运行态，调用方紧接着调 `waitUntilIdle` 也不会误判为空闲。
      */
-    run(id, mode = 'new', origin = 'panel') {
+    run(id, mode = 'new', origin = 'panel', workspace) {
         const cached = this.store.cached(id);
         if (cached !== undefined) {
             try {
-                return this.begin(cached, mode, origin);
+                return this.begin(cached, mode, origin, workspace);
             }
             catch (error) {
                 return Promise.reject(error);
             }
         }
-        return this.get(id).then((task) => this.begin(task, mode, origin));
+        return this.get(id).then((task) => this.begin(task, mode, origin, workspace));
     }
     /**
      * 在同一任务内开新一轮：全量替换检索条件后执行，**不新建任务、不新开 tab**。
@@ -369,6 +448,9 @@ export class TaskService {
         if (nextTitle !== '')
             task.title = nextTitle.slice(0, MAX_TITLE);
         task.conditions = this.readConditions(input, getSettings());
+        const workspace = normalizeWorkspace(input.workspace);
+        if (workspace !== undefined)
+            task.workspace = workspace;
         task.rev += 1;
         task.updatedAt = new Date().toISOString();
         await this.store.save(task);
@@ -409,7 +491,7 @@ export class TaskService {
         const resolved = base === undefined ? filter : await this.withBaseFilter(task, filter);
         return computeStats(task, resolved, scope, base);
     }
-    /** 写入筛读 / 分组 / 必读 / 备注；返回新的 rev 与命中条数。 */
+    /** 写入筛读 / 分组；返回新的 rev 与命中条数。 */
     async annotate(id, inputs, expectedRev) {
         const task = await this.get(id);
         if (expectedRev !== undefined && expectedRev !== task.rev) {
@@ -483,10 +565,34 @@ export class TaskService {
             remaining: this.store.list().length,
         };
     }
+    /**
+     * 「查看已下载」前的存在性检查：页面加载后文件可能被删除或移走。
+     * 缺失时把状态改为 `missing` 并广播，所有面板随即显示「下载文件已删除」。
+     */
+    async recheckPdf(id, paperId) {
+        const task = await this.get(id);
+        findPaper(task, paperId);
+        const state = task.states[paperId];
+        const filePath = state?.pdfFile;
+        if (state === undefined || filePath === undefined)
+            return { exists: false };
+        pdfExistsCache.delete(filePath);
+        const exists = await pdfFileExists(filePath);
+        if (exists && state.pdfStatus !== 'downloaded') {
+            await this.setPdfState(task, paperId, { pdfStatus: 'downloaded', pdfFile: filePath });
+        }
+        else if (!exists && state.pdfStatus !== 'missing') {
+            await this.setPdfState(task, paperId, { pdfStatus: 'missing', pdfFile: filePath });
+        }
+        return { exists };
+    }
     /** 下载单篇 PDF；失败时写入失败状态，若有 EPMC 全文则降级为 html-only。 */
-    async downloadPdf(id, paperId) {
+    async downloadPdf(id, paperId, workspace) {
         const task = await this.get(id);
         const paper = findPaper(task, paperId);
+        const target = normalizeWorkspace(workspace) ?? normalizeWorkspace(task.workspace);
+        if (target !== undefined)
+            task.workspace = target;
         const settings = getSettings();
         const resolution = await resolvePdf(paper);
         if (!resolution.ok || resolution.buffer === undefined) {
@@ -500,10 +606,11 @@ export class TaskService {
                 status: fallback,
                 bytes: 0,
                 error: resolution.error ?? '下载失败',
+                ...(resolution.reason === undefined ? {} : { reason: resolution.reason }),
             };
             return result;
         }
-        const saved = await persistPdf(resolution.buffer, this.store.root, paper);
+        const saved = await persistPdf(resolution.buffer, this.store.root, paper, target);
         await this.setPdfState(task, paperId, {
             pdfStatus: 'downloaded',
             pdfFile: saved.filePath,
@@ -519,20 +626,6 @@ export class TaskService {
             result.url = resolution.url;
         return result;
     }
-    /** PDF 预览：优先用已落地文件；没有则临时抓取一次但不落盘。 */
-    async previewPdf(id, paperId) {
-        const task = await this.get(id);
-        const paper = findPaper(task, paperId);
-        const filename = readableFilename(paper);
-        const local = await readLocalPdf(paper);
-        if (local !== null)
-            return { buffer: local, filename };
-        const resolution = await resolvePdf(paper);
-        if (!resolution.ok || resolution.buffer === undefined) {
-            throw new SearchError('not_found', resolution.error ?? '没有可预览的 PDF');
-        }
-        return { buffer: resolution.buffer, filename };
-    }
     /** Europe PMC 全文（JATS → 只含安全标签的 HTML）。 */
     async fullText(id, paperId) {
         const task = await this.get(id);
@@ -554,15 +647,19 @@ export class TaskService {
         return html;
     }
     /** 单篇论文详情：独立论文页使用，含任务标题与分组。 */
-    async paperDetail(id, paperId) {
+    async paperDetail(id, paperId, workspace) {
         const task = await this.get(id);
+        if (await reconcilePdfFiles(task))
+            await this.store.save(task);
         const paper = findPaper(task, paperId);
+        const target = normalizeWorkspace(workspace) ?? normalizeWorkspace(task.workspace);
         const detail = {
             taskId: task.id,
             taskTitle: task.title,
             rev: task.rev,
             paper,
             groups: task.groups,
+            downloadDir: resolvePdfRoot(target),
         };
         const state = task.states[paperId];
         if (state !== undefined)
@@ -593,11 +690,12 @@ export class TaskService {
         }
     }
     /** 把选中论文同步到 Zotero（含本地 PDF 附件）。 */
-    async zoteroSync(id, paperIds) {
+    async zoteroSync(id, paperIds, workspace) {
         const settings = getSettings();
         if (!settings.zoteroEnabled)
             throw new SearchError('bad_request', 'Zotero 同步已在设置中关闭');
         const task = await this.get(id);
+        const target = normalizeWorkspace(workspace) ?? normalizeWorkspace(task.workspace);
         const wanted = paperIds === undefined || paperIds.length === 0
             ? task.result.papers.slice(0, 50)
             : paperIds.map((paperId) => findPaper(task, paperId));
@@ -612,8 +710,13 @@ export class TaskService {
         const attachPdf = settings.zoteroAttachPdf && !readOnlyAttachments;
         const inputs = [];
         for (const paper of wanted) {
-            const tags = task.states[paper.paperId]?.tags ?? [];
-            const pdfPath = attachPdf ? await this.ensureLocalPdf(paper) : undefined;
+            const state = task.states[paper.paperId];
+            // 标签已移除，用任务内的分组名承载 Zotero 侧的分类信息。
+            const group = task.groups.find((entry) => entry.id === state?.groupId);
+            const tags = group === undefined ? [] : [group.name];
+            const pdfPath = attachPdf
+                ? await this.ensureLocalPdf(paper, target, state?.pdfFile)
+                : undefined;
             inputs.push({ paper, tags, ...(pdfPath === undefined ? {} : { pdfPath }) });
         }
         try {
@@ -635,8 +738,8 @@ export class TaskService {
         }
     }
     /** 下载目录可写性测试（设置页）。 */
-    async storageProbe() {
-        const outcome = await probePdfRoot();
+    async storageProbe(workspace) {
+        const outcome = await probePdfRoot(workspace);
         if (outcome.writable)
             return { ok: true, root: outcome.root, writable: true };
         return {
@@ -646,14 +749,19 @@ export class TaskService {
             ...(outcome.error === undefined ? {} : { error: outcome.error }),
         };
     }
-    async ensureLocalPdf(paper) {
-        const local = await readLocalPdf(paper);
-        if (local !== null)
-            return join(resolvePdfRoot(), readableFilename(paper));
+    async ensureLocalPdf(paper, workspace, recordedPath) {
+        if (recordedPath !== undefined) {
+            const recorded = await readSavedPdf(recordedPath);
+            if (recorded !== null)
+                return recordedPath;
+        }
+        const localPath = join(resolvePdfRoot(workspace), readableFilename(paper));
+        if ((await readSavedPdf(localPath)) !== null)
+            return localPath;
         const resolution = await resolvePdf(paper).catch(() => null);
         if (resolution === null || !resolution.ok || resolution.buffer === undefined)
             return undefined;
-        const saved = await persistPdf(resolution.buffer, this.store.root, paper);
+        const saved = await persistPdf(resolution.buffer, this.store.root, paper, workspace);
         return saved.filePath;
     }
     async setPdfState(task, paperId, patch) {
@@ -670,6 +778,10 @@ export class TaskService {
             delete next.pdfFile;
         else
             next.pdfFile = patch.pdfFile.slice(0, 1024);
+        // 刚写入的文件立即视为存在，避免存在性缓存把状态又翻回 `missing`。
+        if (patch.pdfStatus === 'downloaded' && next.pdfFile !== undefined) {
+            pdfExistsCache.set(next.pdfFile, { exists: true, at: Date.now() });
+        }
         task.states[paperId] = next;
         task.rev += 1;
         task.updatedAt = new Date().toISOString();
@@ -744,10 +856,15 @@ export class TaskService {
         this.runner.cancelAll();
         void this.store.flush();
     }
-    begin(task, mode, origin = task.origin) {
+    begin(task, mode, origin = task.origin, workspace) {
         if (this.runner.isRunning(task.id)) {
             throw new SearchError('conflict', '任务正在运行');
         }
+        const nextWorkspace = normalizeWorkspace(workspace);
+        if (nextWorkspace !== undefined && nextWorkspace !== task.workspace) {
+            task.workspace = nextWorkspace;
+            void this.store.save(task);
+        }
         if (mode === 'more') {
             throw new SearchError('bad_request', '续页加载将在后续版本提供，请先重跑任务');
         }
@@ -796,7 +913,7 @@ export class TaskService {
                 }
                 continue;
             }
-            const saved = await persistPdf(resolution.buffer, this.store.root, paper);
+            const saved = await persistPdf(resolution.buffer, this.store.root, paper, task.workspace);
             await this.setPdfState(task, paper.paperId, {
                 pdfStatus: 'downloaded',
                 pdfFile: saved.filePath,
@@ -914,14 +1031,8 @@ function readTitle(title, conditions) {
 function inheritStates(base) {
     const states = {};
     for (const [paperId, state] of Object.entries(base.states)) {
-        // 分组是任务内概念，继承时只带筛读、必读顺序、备注与标签。
+        // 分组是任务内概念，继承时只带筛读状态。
         const next = { screening: state.screening };
-        if (state.shortlistOrder !== undefined)
-            next.shortlistOrder = state.shortlistOrder;
-        if (state.note !== undefined)
-            next.note = state.note;
-        if (state.tags !== undefined)
-            next.tags = [...state.tags];
         states[paperId] = next;
     }
     return states;

package/lib/host/tasks/states.d.ts

@@ -1,5 +1,5 @@
 /**
- * 筛读台账：论文级状态（四态筛读 / 分组 / 必读顺序 / 备注 / 标签）与任务分组。
+ * 筛读台账：论文级状态（四态筛读 / 分组）与任务分组。
  *
  * 所有写入口（面板注解、模型 `literature_task annotate`、分组编辑）都先经过
  * 这里的校验，确保状态结构稳定；`states` 以稳定的 `paperId` 为键，因此跨任务
@@ -24,5 +24,3 @@ export declare function applyAnnotations(task: SearchTask, inputs: readonly Anno
 export declare function normalizeGroups(values: readonly TaskGroup[] | undefined): TaskGroup[] | undefined;
 /** 分组若仍有论文引用，删除前提醒调用方（调用方决定是否允许）。 */
 export declare function groupUsage(task: SearchTask, groupId: string): number;
-/** 按必读顺序、年份、标题排序某组的论文。 */
-export declare function sortGroupPapers(task: SearchTask, papers: readonly Paper[]): Paper[];

package/lib/host/tasks/states.js

@@ -1,5 +1,5 @@
 /**
- * 筛读台账：论文级状态（四态筛读 / 分组 / 必读顺序 / 备注 / 标签）与任务分组。
+ * 筛读台账：论文级状态（四态筛读 / 分组）与任务分组。
  *
  * 所有写入口（面板注解、模型 `literature_task annotate`、分组编辑）都先经过
  * 这里的校验，确保状态结构稳定；`states` 以稳定的 `paperId` 为键，因此跨任务
@@ -10,17 +10,14 @@ const MAX_ANNOTATIONS = 50;
 const MAX_GROUPS = 50;
 const MAX_GROUP_NAME = 60;
 const MAX_GROUP_DESCRIPTION = 500;
-const MAX_NOTE = 4000;
-const MAX_TAGS = 20;
-const MAX_TAG = 40;
 const MAX_PDF_ERROR = 300;
 const MAX_PDF_FILE = 1024;
-const MAX_SHORTLIST_ORDER = 100_000;
 export const SCREENINGS = ['unread', 'read', 'included', 'excluded'];
 export const PDF_STATUSES = [
     'unknown',
     'available',
     'downloaded',
+    'missing',
     'html-only',
     'paywalled',
     'blocked',
@@ -86,40 +83,6 @@ export function applyAnnotations(task, inputs) {
             }
             touched = true;
         }
-        if (input.shortlistOrder !== undefined) {
-            if (input.shortlistOrder === null) {
-                delete next.shortlistOrder;
-            }
-            else {
-                if (!Number.isInteger(input.shortlistOrder) ||
-                    input.shortlistOrder < 0 ||
-                    input.shortlistOrder > MAX_SHORTLIST_ORDER) {
-                    throw new SearchError('bad_request', `shortlistOrder 必须是 0..${MAX_SHORTLIST_ORDER} 的整数`);
-                }
-                next.shortlistOrder = input.shortlistOrder;
-            }
-            touched = true;
-        }
-        if (input.note !== undefined) {
-            if (typeof input.note !== 'string')
-                throw new SearchError('bad_request', 'note 必须是字符串');
-            const note = input.note.trim();
-            if (note === '')
-                delete next.note;
-            else
-                next.note = note.slice(0, MAX_NOTE);
-            touched = true;
-        }
-        if (input.tags !== undefined) {
-            if (!Array.isArray(input.tags))
-                throw new SearchError('bad_request', 'tags 必须是字符串数组');
-            const tags = normalizeTags(input.tags);
-            if (tags.length === 0)
-                delete next.tags;
-            else
-                next.tags = tags;
-            touched = true;
-        }
         if (input.pdfStatus !== undefined) {
             if (!isPdfStatus(input.pdfStatus)) {
                 throw new SearchError('bad_request', `pdfStatus 只能是 ${PDF_STATUSES.join(' / ')}`);
@@ -194,30 +157,3 @@ export function normalizeGroups(values) {
 export function groupUsage(task, groupId) {
     return Object.values(task.states).filter((state) => state.groupId === groupId).length;
 }
-/** 按必读顺序、年份、标题排序某组的论文。 */
-export function sortGroupPapers(task, papers) {
-    return [...papers].sort((a, b) => {
-        const left = stateOf(task, a.paperId).shortlistOrder;
-        const right = stateOf(task, b.paperId).shortlistOrder;
-        if (left !== undefined || right !== undefined) {
-            if (left === undefined)
-                return 1;
-            if (right === undefined)
-                return -1;
-            if (left !== right)
-                return left - right;
-        }
-        return (b.year ?? 0) - (a.year ?? 0) || a.title.localeCompare(b.title);
-    });
-}
-function normalizeTags(values) {
-    const seen = new Set();
-    for (const raw of values) {
-        const tag = raw.trim().slice(0, MAX_TAG);
-        if (tag !== '')
-            seen.add(tag);
-        if (seen.size >= MAX_TAGS)
-            break;
-    }
-    return [...seen];
-}

package/lib/host/tasks/stats.js

@@ -10,6 +10,8 @@ const CACHE_TTL_MS = 30_000;
 const CACHE_MAX = 16;
 const TOP_LIST = 15;
 const TOP_PAPERS = 10;
+/** 出处 / 作者候选值的上限：筛选下拉直接用这份清单，按命中数取前 500。 */
+const FACET_LIST = 500;
 const cache = new Map();
 export function computeStats(task, filter, scope, base) {
     const key = `${task.id}:${task.rev}:${scope}:${filterKey(filter)}:${base?.rev ?? ''}`;
@@ -53,8 +55,8 @@ function buildReport(task, filter, scope, base) {
         byYear: buildYearStats(task, papers),
         byType: countBy(task, papers, (paper) => paper.type),
         byLanguage: countBy(task, papers, (paper) => paper.language ?? ''),
-        topVenues: topBy(task, papers, (paper) => (paper.venue === '' ? [] : [paper.venue])),
-        topAuthors: topBy(task, papers, (paper) => paper.authors),
+        topVenues: topBy(task, papers, (paper) => (paper.venue === '' ? [] : [paper.venue]), FACET_LIST),
+        topAuthors: topBy(task, papers, (paper) => paper.authors, FACET_LIST),
         metrics: buildMetrics(papers, base),
         screeningProgress: { included, excluded, pending: unread },
         unavailableFullText: {
@@ -70,6 +72,7 @@ function countFullText(task, papers) {
         unknown: 0,
         available: 0,
         downloaded: 0,
+        missing: 0,
         htmlOnly: 0,
         paywalled: 0,
         blocked: 0,
@@ -83,6 +86,8 @@ function countFullText(task, papers) {
             coverage.available += 1;
         else if (status === 'downloaded')
             coverage.downloaded += 1;
+        else if (status === 'missing')
+            coverage.missing += 1;
         else if (status === 'paywalled')
             coverage.paywalled += 1;
         else if (status === 'blocked')
@@ -175,7 +180,7 @@ function countBy(task, papers, keyOf) {
         .map(([key, entry]) => ({ key, ...entry }))
         .sort((a, b) => b.count - a.count);
 }
-function topBy(task, papers, keysOf) {
+function topBy(task, papers, keysOf, limit) {
     const counts = new Map();
     for (const paper of papers) {
         const included = screeningOf(task, paper) === 'included';
@@ -193,7 +198,7 @@ function topBy(task, papers, keysOf) {
     return [...counts.entries()]
         .map(([key, entry]) => ({ key, ...entry }))
         .sort((a, b) => b.count - a.count)
-        .slice(0, TOP_LIST);
+        .slice(0, limit);
 }
 function buildMetrics(papers, base) {
     const total = papers.length;

package/lib/host/tasks/store.d.ts

@@ -47,7 +47,7 @@ export declare class TaskStore {
     /** 读取「当前任务」快照；文件缺失或损坏时返回 null（由调用方自举）。 */
     loadCurrent(): Promise<CurrentTaskSnapshot | null>;
     saveCurrent(snapshot: CurrentTaskSnapshot): Promise<void>;
-    /** 手动清理：删除所有未置顶任务，返回条数与释放的字节数。 */
+    /** 手动清理：删除所有未保留任务，返回条数与释放的字节数。 */
     cleanupUnpinned(): Promise<{
         removed: number;
         freedBytes: number;

package/lib/host/tasks/store.js

@@ -135,7 +135,7 @@ export class TaskStore {
             await atomicWrite(this.currentFile, body);
         });
     }
-    /** 手动清理：删除所有未置顶任务，返回条数与释放的字节数。 */
+    /** 手动清理：删除所有未保留任务，返回条数与释放的字节数。 */
     async cleanupUnpinned() {
         const targets = this.list().filter((summary) => !summary.pinned);
         let freedBytes = 0;

package/lib/host/tasks/summary.js

@@ -27,7 +27,7 @@ export function toSummary(task) {
 export function toDetail(task) {
     const states = {};
     for (const [paperId, state] of Object.entries(task.states)) {
-        states[paperId] = { ...state, ...(state.tags === undefined ? {} : { tags: [...state.tags] }) };
+        states[paperId] = { ...state };
     }
     return {
         ...toSummary(task),

package/lib/host/tools.d.ts

@@ -6,7 +6,7 @@
  *   都有效）；只有用户明确要求新任务时才新建。等待最多 25 秒后把任务头部与前
  *   若干条结果交给模型，并明确要求本轮到此为止、只给完善建议、不发起下一轮。
  * - `literature_sources`：列出已接入的数据源与能力，便于模型决定后续策略。
- * - `literature_task`：读取/修改已保存任务（含轮次历史），写入筛读、分组与备注，
+ * - `literature_task`：读取/修改已保存任务（含轮次历史），写入筛读与分组，
  *   做新老对比与统计。
  * - `literature_export`：把任务（按筛选）导出为 CSV / RIS / BibTeX / Markdown 并落盘。
  *