dsh-plugin-litsearch 0.1.0 → 0.3.0

package/lib/host/tasks/runner.js

@@ -8,6 +8,7 @@
 import { DEFAULT_TASK_MAX_ROUNDS, MAX_LIMIT, getSettings } from '../../search/config.js';
 import { searchSources } from '../../search/aggregate.js';
 import { mergeHits } from '../../search/identity.js';
+import { matchesLanguage } from './filter.js';
 import { finishRound, startRound } from './rounds.js';
 import { countScreening } from './states.js';
 class RunCanceled extends Error {
@@ -198,11 +199,3 @@ function matchesConditions(paper, conditions) {
     }
     return true;
 }
-function matchesLanguage(paper, language) {
-    if (language === 'any')
-        return true;
-    const value = (paper.language ?? '').toLowerCase();
-    if (language === 'chi')
-        return value.startsWith('chi') || value.startsWith('zh');
-    return value.startsWith('eng') || value.startsWith('en');
-}

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

@@ -25,8 +25,9 @@ export interface CreateTaskInput {
     types?: string[];
     sort?: SortMode;
     origin: TaskOrigin;
-    sessionId?: string;
     fromTaskId?: string;
+    /** 发起方所在会话的工作目录；下载默认落在这里。 */
+    workspace?: string;
     runNow?: boolean;
 }
 export interface TaskPatch {
@@ -62,17 +63,25 @@ export declare class TaskService {
     private readonly events;
     private readonly runner;
     /**
-     * 进程内「当前任务」。
+     * 全局「当前任务」：最后一次使用或打开的任务。
      *
-     * 工具执行上下文没有会话 id（已核实 @deepseek-ai/dsh-tools 的
-     * ToolExecutionInput），只能用「最近使用的任务 + TTL」做降级：同一主题
-     * 的多次检索默认落在同一个任务里，从而从根上避免重复开 tab。
-     * 跨会话误并的风险由 TTL、工具返回里自报任务名、以及模型可显式
-     * `newTask` / `taskId` 覆盖来缓解。
+     * 不按对话、也不按时间过期——同一主题的后续检索必须在原任务里加一轮，
+     * 跨对话、宿主重启都成立。只有用户显式新建任务或点开别的任务时才会改变。
      */
     private currentTaskId;
     private currentTaskAt;
     constructor();
+    /**
+     * 先加载任务索引，再恢复「当前任务」快照。
+     *
+     * 快照缺失或指向已删除任务时，自举为最近更新的任务，避免下一轮检索
+     * 又新建一个同名任务。
+     */
+    private restore;
+    /** 按设置的总量上限修剪 PDF 去重缓存；失败只告警，不阻断启动。 */
+    private trimPdfCache;
+    /** 没有可用快照时，把最近更新的任务设为当前任务并落盘。 */
+    private bootstrapCurrentTask;
     get globalRev(): number;
     get root(): string;
     isRunning(id: string): boolean;
@@ -83,12 +92,22 @@ export declare class TaskService {
     getDetail(id: string): Promise<TaskDetail>;
     /** 任务内轮次历史（时间升序、深拷贝）。 */
     getRounds(id: string): Promise<SearchRound[]>;
-    /** 当前任务（TTL 内且仍存在）；模型不指定 taskId 时默认复用它。 */
+    /**
+     * 当前任务：最近一次使用或打开的任务。
+     *
+     * 没有时间窗口、也不区分对话；只要任务还在就一直有效。任务被全部删除后
+     * 返回 undefined，由调用方决定是否新建。
+     */
     currentTask(): Promise<SearchTask | undefined>;
-    /** 记住最近使用的任务（模型新建/复用后由工具层调用）。 */
+    /** 记住最近使用的任务（下一次模型检索默认落在这里）。 */
     setCurrentTask(id: string): void;
+    /** 请求客户端打开/聚焦某任务 tab（面板被关掉时重新打开）。 */
+    focusTask(id: string, title: string, sessionId?: string): void;
+    private persistCurrent;
     /** 用户从任务列表点开某任务 = 进入该任务，之后的模型检索默认落在这里。 */
-    activate(id: string): Promise<SearchTask>;
+    activate(id: string, workspace?: string): Promise<SearchTask>;
+    /** 记下任务最近一次所在的工作目录；只改变下载落点，不改变 rev。 */
+    private applyWorkspace;
     /** 等待该任务当前这一轮结束；返回是否确实已空闲。 */
     waitUntilIdle(id: string, timeoutMs: number, signal?: AbortSignal): Promise<boolean>;
     create(input: CreateTaskInput): Promise<SearchTask>;
@@ -99,7 +118,7 @@ export declare class TaskService {
      *
      * 任务已缓存时同步登记运行态，调用方紧接着调 `waitUntilIdle` 也不会误判为空闲。
      */
-    run(id: string, mode?: 'new' | 'more', origin?: TaskOrigin): Promise<SearchTask>;
+    run(id: string, mode?: 'new' | 'more', origin?: TaskOrigin, workspace?: string): Promise<SearchTask>;
     /**
      * 在同一任务内开新一轮：全量替换检索条件后执行，**不新建任务、不新开 tab**。
      *
@@ -124,9 +143,9 @@ export declare class TaskService {
     /** 设置页清理：任务文件与 PDF 缓存。 */
     cleanup(scope: CleanupScope): Promise<CleanupResult>;
     /** 下载单篇 PDF；失败时写入失败状态，若有 EPMC 全文则降级为 html-only。 */
-    downloadPdf(id: string, paperId: string): Promise<PdfDownloadResult>;
+    downloadPdf(id: string, paperId: string, workspace?: string): Promise<PdfDownloadResult>;
     /** PDF 预览：优先用已落地文件；没有则临时抓取一次但不落盘。 */
-    previewPdf(id: string, paperId: string): Promise<{
+    previewPdf(id: string, paperId: string, workspace?: string): Promise<{
         buffer: Buffer;
         filename: string;
     }>;
@@ -139,9 +158,9 @@ export declare class TaskService {
     /** 测试 Zotero connector 是否可达，并返回当前选中的分类。 */
     zoteroProbe(): Promise<ZoteroProbeResult>;
     /** 把选中论文同步到 Zotero（含本地 PDF 附件）。 */
-    zoteroSync(id: string, paperIds?: readonly string[]): Promise<ZoteroSyncResult>;
+    zoteroSync(id: string, paperIds?: readonly string[], workspace?: string): Promise<ZoteroSyncResult>;
     /** 下载目录可写性测试（设置页）。 */
-    storageProbe(): Promise<StorageProbeResult>;
+    storageProbe(workspace?: string): Promise<StorageProbeResult>;
     private ensureLocalPdf;
     private setPdfState;
     /** 单源诊断：用固定短查询测一次连通性与延迟（不受冷却影响）。 */

package/lib/host/tasks/service.js

@@ -5,9 +5,9 @@
  * 模型工具与面板 HTTP 路由都只调用这里，保证两边操作同一份状态。
  */
 import { randomUUID } from 'node:crypto';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { CURRENT_TASK_TTL_MS, MAX_LIMIT, PLUGIN_VERSION, getSettings, } from '../../search/config.js';
+import { MAX_LIMIT, PLUGIN_VERSION, 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,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, readLocalPdf, 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';
@@ -37,25 +38,78 @@ export class TaskService {
     events = new TaskEvents();
     runner = new TaskRunner();
     /**
-     * 进程内「当前任务」。
+     * 全局「当前任务」：最后一次使用或打开的任务。
      *
-     * 工具执行上下文没有会话 id（已核实 @deepseek-ai/dsh-tools 的
-     * ToolExecutionInput），只能用「最近使用的任务 + TTL」做降级：同一主题
-     * 的多次检索默认落在同一个任务里，从而从根上避免重复开 tab。
-     * 跨会话误并的风险由 TTL、工具返回里自报任务名、以及模型可显式
-     * `newTask` / `taskId` 覆盖来缓解。
+     * 不按对话、也不按时间过期——同一主题的后续检索必须在原任务里加一轮，
+     * 跨对话、宿主重启都成立。只有用户显式新建任务或点开别的任务时才会改变。
      */
     currentTaskId;
     currentTaskAt = 0;
     constructor() {
-        this.ready = this.store
-            .load({
-            retentionDays: getSettings().taskRetentionDays,
-            retentionCount: getSettings().taskRetentionCount,
-        })
-            .catch((error) => {
+        this.ready = this.restore();
+    }
+    /**
+     * 先加载任务索引，再恢复「当前任务」快照。
+     *
+     * 快照缺失或指向已删除任务时，自举为最近更新的任务，避免下一轮检索
+     * 又新建一个同名任务。
+     */
+    async restore() {
+        try {
+            await this.store.load({
+                retentionDays: getSettings().taskRetentionDays,
+                retentionCount: getSettings().taskRetentionCount,
+            });
+        }
+        catch (error) {
             console.warn('[dsh-plugin-litsearch] 任务目录加载失败：', error);
-        });
+        }
+        // 与任务自动清理同批执行：按总量上限修剪 PDF 去重缓存（0 表示关闭）。
+        await this.trimPdfCache();
+        let restored = false;
+        try {
+            const snapshot = await this.store.loadCurrent();
+            if (snapshot?.current !== undefined &&
+                this.store.summary(snapshot.current.taskId) !== undefined) {
+                this.currentTaskId = snapshot.current.taskId;
+                this.currentTaskAt = snapshot.current.at;
+                restored = true;
+            }
+        }
+        catch (error) {
+            console.warn('[dsh-plugin-litsearch] 当前任务快照加载失败：', error);
+        }
+        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];
+        if (latest === undefined) {
+            // 任务已全部删除：清掉快照里的旧 id，避免 current.json 指向不存在的任务。
+            this.currentTaskId = undefined;
+            this.currentTaskAt = 0;
+            this.persistCurrent();
+            return;
+        }
+        this.currentTaskId = latest.id;
+        this.currentTaskAt = Date.parse(latest.updatedAt) || Date.now();
+        this.persistCurrent();
     }
     get globalRev() {
         return this.events.currentRev;
@@ -73,7 +127,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,
@@ -83,7 +141,7 @@ export class TaskService {
                 maxTaskTabs: settings.maxTaskTabs,
             },
             fullText: {
-                pdfRoot: resolvePdfRoot(),
+                pdfRoot: settings.pdfRoot.trim() === '' ? '' : resolvePdfRoot(),
                 pdfMaxMb: settings.pdfMaxMb,
                 autoDownload: settings.autoDownloadPdf,
                 epmcFulltext: settings.enableEpmcFulltext,
@@ -132,32 +190,58 @@ export class TaskService {
     async getRounds(id) {
         return roundsOf(await this.get(id)).map(cloneRound);
     }
-    /** 当前任务（TTL 内且仍存在）；模型不指定 taskId 时默认复用它。 */
+    /**
+     * 当前任务：最近一次使用或打开的任务。
+     *
+     * 没有时间窗口、也不区分对话；只要任务还在就一直有效。任务被全部删除后
+     * 返回 undefined，由调用方决定是否新建。
+     */
     async currentTask() {
+        await this.ready;
         if (this.currentTaskId === undefined)
             return undefined;
-        if (Date.now() - this.currentTaskAt > CURRENT_TASK_TTL_MS) {
-            this.currentTaskId = undefined;
-            return undefined;
-        }
         const task = await this.tryGet(this.currentTaskId);
-        if (task === undefined) {
-            this.currentTaskId = undefined;
+        if (task !== undefined)
+            return task;
+        this.currentTaskId = undefined;
+        this.bootstrapCurrentTask();
+        if (this.currentTaskId === undefined)
             return undefined;
-        }
-        return task;
+        return this.tryGet(this.currentTaskId);
     }
-    /** 记住最近使用的任务（模型新建/复用后由工具层调用）。 */
+    /** 记住最近使用的任务（下一次模型检索默认落在这里）。 */
     setCurrentTask(id) {
         this.currentTaskId = id;
         this.currentTaskAt = Date.now();
+        this.persistCurrent();
+    }
+    /** 请求客户端打开/聚焦某任务 tab（面板被关掉时重新打开）。 */
+    focusTask(id, title, sessionId) {
+        this.events.requestFocus(id, title, sessionId);
+    }
+    persistCurrent() {
+        void this.store.saveCurrent({
+            version: 1,
+            ...(this.currentTaskId === undefined
+                ? {}
+                : { current: { taskId: this.currentTaskId, at: this.currentTaskAt } }),
+        });
     }
     /** 用户从任务列表点开某任务 = 进入该任务，之后的模型检索默认落在这里。 */
-    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))
@@ -197,6 +281,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)}`,
@@ -219,11 +304,13 @@ export class TaskService {
             result: { papers: [], sources: [] },
             rounds: [],
             states: inherited === undefined ? {} : inheritStates(inherited),
-            ...(input.sessionId === undefined ? {} : { sessionId: input.sessionId }),
+            ...(workspace === undefined ? {} : { workspace }),
             ...(input.fromTaskId === undefined ? {} : { fromTaskId: input.fromTaskId }),
         };
         this.store.put(task);
         await this.store.save(task);
+        // 新建的任务就是「当前任务」：后续检索默认在它里面加轮次。
+        this.setCurrentTask(task.id);
         this.events.publish(toSummary(task));
         if (input.runNow !== false) {
             void this.begin(task, 'new').catch((error) => {
@@ -271,28 +358,34 @@ export class TaskService {
     }
     async remove(id) {
         const task = await this.get(id);
-        this.runner.cancel(id);
+        // 先等这一轮收尾（finally 里还会落一次盘），再删文件，避免任务被写回。
+        if (this.runner.cancel(task.id))
+            await this.runner.wait(task.id);
         await this.store.remove(task.id);
+        // 模型工具导出到 <storage>/out/<taskId>/ 的文件随任务一起清掉。
+        await rm(join(this.store.root, 'out', task.id), { recursive: true, force: true });
         this.events.remove(task.id);
-        if (this.currentTaskId === task.id)
-            this.currentTaskId = undefined;
+        if (this.currentTaskId !== task.id)
+            return;
+        this.currentTaskId = undefined;
+        this.bootstrapCurrentTask();
     }
     /**
      * 启动一次执行（任务内新一轮）；返回的 Promise 在运行结束后 resolve 为最新任务。
      *
      * 任务已缓存时同步登记运行态，调用方紧接着调 `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**。
@@ -309,6 +402,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);
@@ -424,9 +520,12 @@ export class TaskService {
         };
     }
     /** 下载单篇 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) {
@@ -443,7 +542,7 @@ export class TaskService {
             };
             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,
@@ -460,11 +559,14 @@ export class TaskService {
         return result;
     }
     /** PDF 预览：优先用已落地文件；没有则临时抓取一次但不落盘。 */
-    async previewPdf(id, paperId) {
+    async previewPdf(id, paperId, workspace) {
         const task = await this.get(id);
         const paper = findPaper(task, paperId);
         const filename = readableFilename(paper);
-        const local = await readLocalPdf(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);
@@ -533,11 +635,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));
@@ -552,8 +655,11 @@ 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];
+            const tags = state?.tags ?? [];
+            const pdfPath = attachPdf
+                ? await this.ensureLocalPdf(paper, target, state?.pdfFile)
+                : undefined;
             inputs.push({ paper, tags, ...(pdfPath === undefined ? {} : { pdfPath }) });
         }
         try {
@@ -575,8 +681,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 {
@@ -586,17 +692,25 @@ 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) {
+        // 下载进行中任务被删除：不再写回，也不向客户端广播已删除的任务。
+        if (this.store.summary(task.id) === undefined)
+            return;
         const current = task.states[paperId] ?? emptyState();
         const next = { ...current, pdfStatus: patch.pdfStatus };
         if (patch.pdfError === undefined)
@@ -681,10 +795,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', '续页加载将在后续版本提供，请先重跑任务');
         }
@@ -693,7 +812,12 @@ export class TaskService {
             throw new SearchError('bad_request', '没有启用的检索式');
         const done = this.runner.start(task, {
             persist: (current) => this.store.save(current),
-            publish: (current) => this.events.publish(toSummary(current)),
+            publish: (current) => {
+                // 删除后这一轮收尾仍会 publish，跳过已删除任务，避免客户端又去打开它。
+                if (this.store.summary(current.id) !== undefined) {
+                    this.events.publish(toSummary(current));
+                }
+            },
         }, origin);
         return done.then(() => {
             if (getSettings().autoDownloadPdf) {
@@ -710,6 +834,9 @@ export class TaskService {
             .filter((paper) => paper.pdfUrl !== '' || paper.ids.pmcid !== '' || paper.ids.arxivId !== '')
             .slice(0, 10);
         for (const paper of targets) {
+            // 任务中途被删除时停止后续下载，避免继续往用户下载目录写文件。
+            if (this.store.summary(task.id) === undefined)
+                return;
             if (task.states[paper.paperId]?.pdfStatus === 'downloaded')
                 continue;
             const resolution = await resolvePdf(paper).catch(() => null);
@@ -725,7 +852,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,

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: {
@@ -175,7 +177,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 +195,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

@@ -1,6 +1,8 @@
 /**
  * 任务持久化：`<root>/tasks/<id>.json` + `tasks/index.json`。
  *
+ * - 数据根目录为 `$DSH_HOME/storages/dsh-plugin-litsearch`（见 `host/paths.ts`），
+ *   加载时若新目录为空而旧目录有任务，会一次性复制过来；显式传入 root 时不迁移；
  * - 写盘全部串行执行，先写临时文件再 rename，避免半截 JSON；
  * - 内存里只保留摘要，任务正文按需从磁盘读；
  * - 落盘时摘要截到 {@link MAX_ABSTRACT_CHARS} 字符，任务数按保留策略裁剪。
@@ -10,14 +12,27 @@ export interface RetentionOptions {
     retentionDays: number;
     retentionCount: number;
 }
+/** 「当前任务」快照：最近一次使用或打开的任务。 */
+export interface CurrentTaskSnapshot {
+    version: number;
+    current?: {
+        taskId: string;
+        at: number;
+    };
+}
 export declare class TaskStore {
-    readonly root: string;
-    private readonly tasksDir;
-    private readonly indexFile;
+    root: string;
+    private tasksDir;
+    private indexFile;
+    private currentFile;
     private readonly summaries;
     private readonly cache;
     private chain;
     private retention;
+    /** 只有使用默认（平台统一）目录时才做旧数据迁移；显式 root 多用于测试。 */
+    private readonly migrateOnLoad;
+    /** 迁移过来的任务文件必须重建索引，避免沿用旧目录里那份空 index.json。 */
+    private forceRebuildIndex;
     constructor(root?: string);
     load(retention: RetentionOptions): Promise<void>;
     list(): TaskSummary[];
@@ -29,11 +44,16 @@ export declare class TaskStore {
     save(task: SearchTask): Promise<void>;
     remove(id: string): Promise<void>;
     flush(): Promise<void>;
-    /** 手动清理：删除所有未置顶任务，返回条数与释放的字节数。 */
+    /** 读取「当前任务」快照；文件缺失或损坏时返回 null（由调用方自举）。 */
+    loadCurrent(): Promise<CurrentTaskSnapshot | null>;
+    saveCurrent(snapshot: CurrentTaskSnapshot): Promise<void>;
+    /** 手动清理：删除所有未保留任务，返回条数与释放的字节数。 */
     cleanupUnpinned(): Promise<{
         removed: number;
         freedBytes: number;
     }>;
+    /** 迁移回退时切回旧目录读取，所有派生路径（含设置页展示）同步更新。 */
+    private rebind;
     private taskFile;
     private readIndex;
     /** 索引缺失/损坏时按任务文件重建（只读头部，不长期占内存）。 */