dsh-plugin-litsearch 0.3.0 → 0.4.0

package/lib/host/tasks/service.js

@@ -5,9 +5,9 @@
  * 模型工具与面板 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 { MAX_LIMIT, getSettings } from '../../search/config.js';
 import { SearchError } from '../../search/errors.js';
 import { cooldownUntil, sourceHealthList } from '../../search/health.js';
 import { PROVIDER_INFOS } from '../../search/providers/index.js';
@@ -17,11 +17,11 @@ 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, prunePdfCache, readLocalPdf, readSavedPdf, 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 { filterPapers, sortPapers } from './filter.js';
 import { TaskRunner } from './runner.js';
 import { computeStats } from './stats.js';
 import { applyAnnotations, countScreening, emptyState, normalizeGroups } from './states.js';
@@ -32,11 +32,64 @@ 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();
+/** 右侧栏视图快照有效期：面板长时间不动时不拿旧页码替模型算「当前页」。 */
+const VIEW_TTL_MS = 30 * 60 * 1000;
+/** 最多保留多少个会话的视图快照，超出按上报时间淘汰最旧的。 */
+const MAX_VIEWS = 64;
+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();
     events = new TaskEvents();
     runner = new TaskRunner();
+    /**
+     * 每个会话最近一次的右侧栏视图快照（内存、不落盘）。
+     *
+     * 模型工具跑在 Host 侧看不到界面，靠它把「当前页」「当前筛选全部」算准；
+     * 宿主重启即失效，与事件日志 rev 的生命周期一致。
+     */
+    views = new Map();
     /**
      * 全局「当前任务」：最后一次使用或打开的任务。
      *
@@ -153,7 +206,6 @@ export class TaskService {
                 tag: settings.zoteroTag,
             },
             storageDir: this.store.root,
-            version: PLUGIN_VERSION,
         };
     }
     async eventsSince(sinceRev) {
@@ -183,8 +235,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) {
@@ -219,6 +275,53 @@ export class TaskService {
     focusTask(id, title, sessionId) {
         this.events.requestFocus(id, title, sessionId);
     }
+    /** 下发一条模型批量下载指令；右侧栏轮询 /events 拿增量后自行执行。 */
+    publishDownloadCommand(command) {
+        this.events.publishDownload(command);
+    }
+    /** 下发一条模型批量存入 Zotero 指令；与下载指令走独立的事件日志。 */
+    publishZoteroCommand(command) {
+        this.events.publishZotero(command);
+    }
+    /**
+     * 面板上报当前视图。会话 id 以请求头为准覆盖 body，防止伪造别的会话的视图；
+     * 时间也由 Host 重置，避免客户端时钟偏差影响过期判断。
+     */
+    saveViewSnapshot(sessionId, snapshot) {
+        if (sessionId === '' || snapshot.taskId === '')
+            return;
+        this.views.set(sessionId, { ...snapshot, sessionId, at: Date.now() });
+        if (this.views.size <= MAX_VIEWS)
+            return;
+        let oldestKey;
+        let oldestAt = Number.MAX_SAFE_INTEGER;
+        for (const [key, value] of this.views) {
+            if (value.at < oldestAt) {
+                oldestAt = value.at;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey !== undefined)
+            this.views.delete(oldestKey);
+    }
+    /** 取该会话在该任务上的最近视图；过期、跨任务或 rev 超前都视为不可信。 */
+    async getViewSnapshot(sessionId, taskId) {
+        await this.ready;
+        if (sessionId === undefined || sessionId === '')
+            return undefined;
+        const snapshot = this.views.get(sessionId);
+        if (snapshot === undefined || snapshot.taskId !== taskId)
+            return undefined;
+        if (Date.now() - snapshot.at > VIEW_TTL_MS) {
+            this.views.delete(sessionId);
+            return undefined;
+        }
+        // 每下载一篇都会让 rev +1，因此只做「快照不比任务更新」的宽松校验。
+        const task = await this.tryGet(taskId);
+        if (task === undefined || snapshot.rev > task.rev)
+            return undefined;
+        return snapshot;
+    }
     persistCurrent() {
         void this.store.saveCurrent({
             version: 1,
@@ -365,6 +468,10 @@ export class TaskService {
         // 模型工具导出到 <storage>/out/<taskId>/ 的文件随任务一起清掉。
         await rm(join(this.store.root, 'out', task.id), { recursive: true, force: true });
         this.events.remove(task.id);
+        for (const [key, value] of this.views) {
+            if (value.taskId === task.id)
+                this.views.delete(key);
+        }
         if (this.currentTaskId !== task.id)
             return;
         this.currentTaskId = undefined;
@@ -423,13 +530,7 @@ export class TaskService {
         const limit = clampInt(filter.limit ?? task.conditions.pageSize, 1, MAX_PAGE_LIMIT);
         const offset = clampInt(filter.offset ?? 0, 0, Number.MAX_SAFE_INTEGER);
         const papers = filterPapers(task, await this.withBaseFilter(task, filter));
-        const sort = filter.sort ?? task.conditions.sort;
-        if (sort === 'citations') {
-            papers.sort((a, b) => (b.citedBy ?? -1) - (a.citedBy ?? -1));
-        }
-        else if (sort === 'year') {
-            papers.sort((a, b) => (b.year ?? 0) - (a.year ?? 0));
-        }
+        sortPapers(papers, filter.sort ?? task.conditions.sort);
         return {
             taskId: task.id,
             rev: task.rev,
@@ -445,7 +546,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) {
@@ -519,6 +620,27 @@ 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, workspace) {
         const task = await this.get(id);
@@ -539,6 +661,7 @@ export class TaskService {
                 status: fallback,
                 bytes: 0,
                 error: resolution.error ?? '下载失败',
+                ...(resolution.reason === undefined ? {} : { reason: resolution.reason }),
             };
             return result;
         }
@@ -558,23 +681,6 @@ export class TaskService {
             result.url = resolution.url;
         return result;
     }
-    /** PDF 预览：优先用已落地文件；没有则临时抓取一次但不落盘。 */
-    async previewPdf(id, paperId, workspace) {
-        const task = await this.get(id);
-        const paper = findPaper(task, paperId);
-        const filename = readableFilename(paper);
-        const target = normalizeWorkspace(workspace) ?? normalizeWorkspace(task.workspace);
-        const recorded = task.states[paperId]?.pdfFile;
-        const saved = recorded === undefined ? null : await readSavedPdf(recorded);
-        const local = saved ?? (await readLocalPdf(paper, target));
-        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);
@@ -596,15 +702,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)
@@ -634,13 +744,23 @@ export class TaskService {
             return { ok: false, error: error instanceof Error ? error.message : String(error) };
         }
     }
-    /** 把选中论文同步到 Zotero（含本地 PDF 附件）。 */
-    async zoteroSync(id, paperIds, workspace) {
+    /** 可写入的 Zotero 库与分类，供同步弹窗选择目标目录。 */
+    async zoteroTargets() {
+        const settings = getSettings();
+        try {
+            return await new ZoteroConnector(settings.zoteroBaseUrl).listTargets();
+        }
+        catch (error) {
+            return { ok: false, targets: [], error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    /** 把选中论文同步到 Zotero（含本地 PDF 附件），并记录每篇的同步状态。 */
+    async zoteroSync(id, paperIds, workspace, target) {
         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 workspaceDir = normalizeWorkspace(workspace) ?? normalizeWorkspace(task.workspace);
         const wanted = paperIds === undefined || paperIds.length === 0
             ? task.result.papers.slice(0, 50)
             : paperIds.map((paperId) => findPaper(task, paperId));
@@ -651,14 +771,18 @@ export class TaskService {
         if (!probe.ok) {
             throw new SearchError('network_error', `Zotero 未运行或 connector 不可达：${probe.error ?? settings.zoteroBaseUrl}`);
         }
-        const readOnlyAttachments = settings.zoteroAttachPdf && probe.collection?.filesEditable === false;
+        // 目标目录优先：用户选定的分类可能是另一个库，不能只看当前选中的分类。
+        const filesEditable = target?.filesEditable ?? probe.collection?.filesEditable;
+        const readOnlyAttachments = settings.zoteroAttachPdf && filesEditable === false;
         const attachPdf = settings.zoteroAttachPdf && !readOnlyAttachments;
         const inputs = [];
         for (const paper of wanted) {
             const state = task.states[paper.paperId];
-            const tags = state?.tags ?? [];
+            // 标签已移除，用任务内的分组名承载 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)
+                ? await this.ensureLocalPdf(paper, workspaceDir, state?.pdfFile)
                 : undefined;
             inputs.push({ paper, tags, ...(pdfPath === undefined ? {} : { pdfPath }) });
         }
@@ -667,12 +791,31 @@ export class TaskService {
                 baseUrl: settings.zoteroBaseUrl,
                 attachPdf,
                 tag: settings.zoteroTag,
+                ...(target === undefined
+                    ? {}
+                    : {
+                        targetId: target.id,
+                        ...(target.name === undefined ? {} : { targetName: target.name }),
+                    }),
             });
-            if (probe.collection === undefined) {
+            if (target === undefined && probe.collection === undefined) {
                 result.messages.unshift('Zotero 当前未选择分类，条目已保存到「我的文库」');
             }
             else if (readOnlyAttachments) {
-                result.messages.unshift('当前分类不可写附件，已只保存条目；可在 Zotero 中换一个可写分类后重试');
+                const label = target === undefined ? '当前分类' : `「${target.name ?? target.id}」`;
+                result.messages.unshift(`${label}不可写附件，已只保存条目；可换一个可写目录后重试`);
+            }
+            const collectionName = target === undefined ? probe.collection?.name : target.name;
+            for (const item of result.items) {
+                await this.setZoteroState(task, item.paperId, item.ok
+                    ? {
+                        zoteroStatus: 'synced',
+                        ...(collectionName === undefined ? {} : { zoteroCollection: collectionName }),
+                    }
+                    : {
+                        zoteroStatus: 'failed',
+                        zoteroError: item.error ?? result.messages[0] ?? '同步失败',
+                    });
             }
             return result;
         }
@@ -680,6 +823,26 @@ export class TaskService {
             throw new SearchError('upstream_error', error instanceof Error ? error.message : String(error));
         }
     }
+    /** 记录单篇文献的 Zotero 同步状态；与 PDF 状态一样写回任务并广播。 */
+    async setZoteroState(task, paperId, patch) {
+        if (this.store.summary(task.id) === undefined)
+            return;
+        const current = task.states[paperId] ?? emptyState();
+        const next = { ...current, zoteroStatus: patch.zoteroStatus };
+        if (patch.zoteroCollection === undefined)
+            delete next.zoteroCollection;
+        else
+            next.zoteroCollection = patch.zoteroCollection.slice(0, 200);
+        if (patch.zoteroError === undefined)
+            delete next.zoteroError;
+        else
+            next.zoteroError = patch.zoteroError.slice(0, 300);
+        task.states[paperId] = next;
+        task.rev += 1;
+        task.updatedAt = new Date().toISOString();
+        await this.store.save(task);
+        this.events.publish(toSummary(task));
+    }
     /** 下载目录可写性测试（设置页）。 */
     async storageProbe(workspace) {
         const outcome = await probePdfRoot(workspace);
@@ -721,6 +884,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();
@@ -779,6 +946,13 @@ export class TaskService {
             return undefined;
         return { paperIds: new Set(base.result.papers.map((paper) => paper.paperId)), rev: base.rev };
     }
+    /**
+     * 供模型下载工具复用：`newOnly` 需要基准任务的论文集合才能与界面口径一致。
+     * 直接暴露给工具层，避免下载范围解析和 `/results` 出现两套过滤逻辑。
+     */
+    async resolveDownloadFilter(id, filter) {
+        return this.withBaseFilter(await this.get(id), filter);
+    }
     /** `newOnly` 需要基准任务的论文集合；基准已删除时忽略该条件。 */
     async withBaseFilter(task, filter) {
         if (filter.newOnly !== true || task.fromTaskId === undefined)
@@ -970,14 +1144,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

@@ -72,6 +72,7 @@ function countFullText(task, papers) {
         unknown: 0,
         available: 0,
         downloaded: 0,
+        missing: 0,
         htmlOnly: 0,
         paywalled: 0,
         blocked: 0,
@@ -85,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')

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,9 +6,13 @@
  *   都有效）；只有用户明确要求新任务时才新建。等待最多 25 秒后把任务头部与前
  *   若干条结果交给模型，并明确要求本轮到此为止、只给完善建议、不发起下一轮。
  * - `literature_sources`：列出已接入的数据源与能力，便于模型决定后续策略。
- * - `literature_task`：读取/修改已保存任务（含轮次历史），写入筛读、分组与备注，
+ * - `literature_task`：读取/修改已保存任务（含轮次历史），写入筛读与分组，
  *   做新老对比与统计。
  * - `literature_export`：把任务（按筛选）导出为 CSV / RIS / BibTeX / Markdown 并落盘。
+ * - `literature_download`：把自然语言下载请求解析成已校验的 paperId 清单，
+ *   通过事件下发给右侧栏，由右侧栏复用批量下载弹窗执行并逐篇展示。
+ * - `literature_zotero`：与下载共用范围解析，改为让右侧栏复用 Zotero 同步
+ *   弹窗；对话里点名目录且匹配成功才自动开跑，否则由用户选目录。
  *
  * 参数在边界做一次校验（模型输出不可信），服务层仍会再兜底。
  */