dsh-plugin-litsearch 0.1.0 → 0.2.0

package/lib/host/events.d.ts

@@ -9,8 +9,11 @@ import type { EventsPage, TaskSummary } from '../search/types.js';
 export declare class TaskEvents {
     private rev;
     private readonly entries;
+    private focus;
     get currentRev(): number;
     publish(summary: TaskSummary): void;
+    /** 请求客户端把某个任务 tab 打开/切到前台（面板关着时重新打开）。 */
+    requestFocus(taskId: string, title: string, sessionId?: string): void;
     remove(id: string): void;
     since(sinceRev: number): EventsPage;
 }

package/lib/host/events.js

@@ -8,6 +8,7 @@
 export class TaskEvents {
     rev = 0;
     entries = new Map();
+    focus;
     get currentRev() {
         return this.rev;
     }
@@ -15,8 +16,21 @@ export class TaskEvents {
         this.rev += 1;
         this.entries.set(summary.id, { globalRev: this.rev, summary });
     }
+    /** 请求客户端把某个任务 tab 打开/切到前台（面板关着时重新打开）。 */
+    requestFocus(taskId, title, sessionId) {
+        this.rev += 1;
+        this.focus = {
+            globalRev: this.rev,
+            taskId,
+            title,
+            at: Date.now(),
+            ...(sessionId === undefined ? {} : { sessionId }),
+        };
+    }
     remove(id) {
         this.entries.delete(id);
+        if (this.focus?.taskId === id)
+            this.focus = undefined;
     }
     since(sinceRev) {
         if (!Number.isFinite(sinceRev) || sinceRev < 0) {
@@ -29,6 +43,16 @@ export class TaskEvents {
             .filter((entry) => entry.globalRev > sinceRev)
             .sort((a, b) => a.globalRev - b.globalRev)
             .map((entry) => entry.summary);
-        return { rev: this.rev, reset: false, tasks };
+        const focus = this.focus !== undefined && this.focus.globalRev > sinceRev
+            ? {
+                taskId: this.focus.taskId,
+                title: this.focus.title,
+                at: this.focus.at,
+                ...(this.focus.sessionId === undefined
+                    ? {}
+                    : { sessionId: this.focus.sessionId }),
+            }
+            : undefined;
+        return { rev: this.rev, reset: false, tasks, ...(focus === undefined ? {} : { focus }) };
     }
 }

package/lib/host/paths.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 插件数据目录解析与旧版数据迁移。
+ *
+ * 平台约定：插件私有数据统一放在 `$DSH_HOME/storages/<plugin-id>/`，
+ * `DSH_HOME` 由宿主注入，未设置时回落 `~/.dsh`。本插件历史版本把数据直接
+ * 写在 `~/.dsh/dsh-litsearch/`，这里负责一次性搬迁到统一存储区：
+ *
+ * - 只复制、不删除，旧目录原样保留作备份；
+ * - 不覆盖新目录里已有的文件，重复启动不会反复迁移；
+ * - 复制失败或校验不通过时回退到旧目录读取，保证任务标注不丢。
+ *
+ * PDF 的可读文件由设置项 `pdfRoot` 决定（默认 `~/Downloads/dsh-litsearch`），
+ * 不受本模块影响；只有插件内部的去重缓存 `<root>/pdfs` 随数据目录一起搬迁。
+ */
+export declare const PLUGIN_ID = "dsh-plugin-litsearch";
+/** 历史版本使用的目录名（`$DSH_HOME` 下的一级目录）。 */
+export declare const LEGACY_DIR = "dsh-litsearch";
+/** 解析宿主数据根目录；支持绝对路径、`~/...` 与空值回落。 */
+export declare function dshHome(env?: NodeJS.ProcessEnv, home?: string): string;
+/** 当前数据根目录：平台统一存储区下的插件域。 */
+export declare function storageRoot(env?: NodeJS.ProcessEnv, home?: string): string;
+/** 旧数据根目录候选，按优先级排列，已排除新根目录。 */
+export declare function legacyRoots(env?: NodeJS.ProcessEnv, home?: string): string[];
+/** 目录里是否存在至少一个任务正文文件（索引与快照不算）。 */
+export declare function hasTaskFiles(root: string): Promise<boolean>;
+export interface StorageResolution {
+    /** 最终使用的数据根目录。 */
+    root: string;
+    /** 本次复制的文件数。 */
+    copied: number;
+    /** 从该旧目录迁移成功。 */
+    migratedFrom?: string;
+    /** 迁移失败，暂时回退到该旧目录读取。 */
+    fallbackFrom?: string;
+}
+/**
+ * 决定最终数据根目录，并在必要时做一次性迁移：
+ *
+ * 1. 新目录已有任务 → 直接使用，绝不碰旧数据；
+ * 2. 新目录为空且旧目录有任务 → 复制缺失文件到新目录，旧目录保留；
+ * 3. 复制失败或复制后仍无任务 → 回滚本次副本并回退到旧目录读取。
+ */
+export declare function resolveStorageRoot(env?: NodeJS.ProcessEnv, home?: string): Promise<StorageResolution>;

package/lib/host/paths.js

@@ -0,0 +1,128 @@
+/**
+ * 插件数据目录解析与旧版数据迁移。
+ *
+ * 平台约定：插件私有数据统一放在 `$DSH_HOME/storages/<plugin-id>/`，
+ * `DSH_HOME` 由宿主注入，未设置时回落 `~/.dsh`。本插件历史版本把数据直接
+ * 写在 `~/.dsh/dsh-litsearch/`，这里负责一次性搬迁到统一存储区：
+ *
+ * - 只复制、不删除，旧目录原样保留作备份；
+ * - 不覆盖新目录里已有的文件，重复启动不会反复迁移；
+ * - 复制失败或校验不通过时回退到旧目录读取，保证任务标注不丢。
+ *
+ * PDF 的可读文件由设置项 `pdfRoot` 决定（默认 `~/Downloads/dsh-litsearch`），
+ * 不受本模块影响；只有插件内部的去重缓存 `<root>/pdfs` 随数据目录一起搬迁。
+ */
+import { copyFile, mkdir, readdir, rm, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+export const PLUGIN_ID = 'dsh-plugin-litsearch';
+/** 历史版本使用的目录名（`$DSH_HOME` 下的一级目录）。 */
+export const LEGACY_DIR = 'dsh-litsearch';
+/** 允许搬迁的条目：任务正文与索引、导出文件、PDF 去重缓存、当前任务快照。 */
+const MIGRATABLE_ENTRIES = ['tasks', 'out', 'pdfs', 'current.json'];
+/** 解析宿主数据根目录；支持绝对路径、`~/...` 与空值回落。 */
+export function dshHome(env = process.env, home = homedir()) {
+    const raw = env.DSH_HOME?.trim() ?? '';
+    if (raw === '')
+        return join(home, '.dsh');
+    if (raw === '~')
+        return home;
+    if (raw.startsWith('~/'))
+        return join(home, raw.slice(2));
+    // 绝对路径原样规范化，相对路径按进程工作目录解析（与宿主 path.resolve 一致）。
+    return resolve(raw);
+}
+/** 当前数据根目录：平台统一存储区下的插件域。 */
+export function storageRoot(env = process.env, home = homedir()) {
+    return join(dshHome(env, home), 'storages', PLUGIN_ID);
+}
+/** 旧数据根目录候选，按优先级排列，已排除新根目录。 */
+export function legacyRoots(env = process.env, home = homedir()) {
+    const current = storageRoot(env, home);
+    const candidates = [
+        join(dshHome(env, home), LEGACY_DIR), // 过渡形态：$DSH_HOME/dsh-litsearch
+        join(home, '.dsh', LEGACY_DIR), // 历史硬编码：~/.dsh/dsh-litsearch
+    ];
+    return [...new Set(candidates)].filter((path) => path !== current);
+}
+/** 目录里是否存在至少一个任务正文文件（索引与快照不算）。 */
+export async function hasTaskFiles(root) {
+    const names = await readdir(join(root, 'tasks')).catch(() => []);
+    return names.some((name) => name.endsWith('.json') && name !== 'index.json');
+}
+/**
+ * 决定最终数据根目录，并在必要时做一次性迁移：
+ *
+ * 1. 新目录已有任务 → 直接使用，绝不碰旧数据；
+ * 2. 新目录为空且旧目录有任务 → 复制缺失文件到新目录，旧目录保留；
+ * 3. 复制失败或复制后仍无任务 → 回滚本次副本并回退到旧目录读取。
+ */
+export async function resolveStorageRoot(env = process.env, home = homedir()) {
+    const root = storageRoot(env, home);
+    if (await hasTaskFiles(root))
+        return { root, copied: 0 };
+    for (const legacy of legacyRoots(env, home)) {
+        if (!(await hasTaskFiles(legacy)))
+            continue;
+        const copied = [];
+        try {
+            await copyLegacyStorage(legacy, root, copied);
+            if (await hasTaskFiles(root)) {
+                console.info(`[dsh-plugin-litsearch] 任务数据已迁移：${legacy} → ${root}（${copied.length} 个文件，原目录保留）`);
+                return { root, migratedFrom: legacy, copied: copied.length };
+            }
+            await rollback(copied);
+        }
+        catch (error) {
+            await rollback(copied);
+            console.warn('[dsh-plugin-litsearch] 任务数据迁移失败：', error);
+        }
+        console.warn(`[dsh-plugin-litsearch] 暂时沿用旧任务目录：${legacy}`);
+        return { root: legacy, fallbackFrom: legacy, copied: 0 };
+    }
+    return { root, copied: 0 };
+}
+/** 复制旧目录里的已知条目；目标已存在则跳过，复制路径写入 `copied` 供回滚。 */
+async function copyLegacyStorage(from, to, copied) {
+    for (const entry of MIGRATABLE_ENTRIES) {
+        const source = join(from, entry);
+        const target = join(to, entry);
+        const info = await stat(source).catch(() => null);
+        if (info === null)
+            continue;
+        if (info.isFile()) {
+            await copyFileIfAbsent(source, target, copied);
+        }
+        else if (info.isDirectory()) {
+            await copyDirIfAbsent(source, target, copied);
+        }
+    }
+}
+async function copyDirIfAbsent(source, target, copied) {
+    const entries = await readdir(source, { withFileTypes: true });
+    for (const entry of entries) {
+        // 跳过原子写残留的临时文件与系统杂项。
+        if (entry.name.startsWith('.') || entry.name.endsWith('.tmp'))
+            continue;
+        const from = join(source, entry.name);
+        const to = join(target, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirIfAbsent(from, to, copied);
+        }
+        else if (entry.isFile()) {
+            await copyFileIfAbsent(from, to, copied);
+        }
+    }
+}
+async function copyFileIfAbsent(source, target, copied) {
+    if ((await stat(target).catch(() => null)) !== null)
+        return;
+    await mkdir(dirname(target), { recursive: true });
+    await copyFile(source, target);
+    copied.push(target);
+}
+/** 迁移未完成时清掉本次副本，让下次启动可以重新迁移（源文件始终不动）。 */
+async function rollback(files) {
+    for (const file of files)
+        await rm(file, { force: true }).catch(() => { });
+}

package/lib/host/router.js

@@ -15,6 +15,15 @@ const SORT_MODES = ['relevance', 'citations', 'year'];
 const LANGUAGES = ['any', 'eng', 'chi'];
 const ORIGINS = ['model', 'panel', 'history', 'api'];
 const SCREENINGS = ['unread', 'read', 'included', 'excluded'];
+const PDF_STATUSES = [
+    'unknown',
+    'available',
+    'downloaded',
+    'html-only',
+    'paywalled',
+    'blocked',
+    'failed',
+];
 const EXPORT_FORMATS = ['csv', 'ris', 'bibtex', 'md'];
 const CLEANUP_SCOPES = ['tasks', 'pdf', 'all'];
 const MAX_ANNOTATIONS = 50;
@@ -521,6 +530,9 @@ function readResultsFilter(params) {
     const missingFullText = params.get('missingFullText');
     if (missingFullText === '1' || missingFullText === 'true')
         filter.missingFullText = true;
+    const pdfStatus = readEnum(params.get('pdfStatus') ?? undefined, 'pdfStatus', PDF_STATUSES);
+    if (pdfStatus !== undefined)
+        filter.pdfStatus = pdfStatus;
     const groupId = params.get('groupId')?.trim() ?? '';
     if (groupId !== '')
         filter.groupId = groupId;

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

@@ -20,6 +20,8 @@ export interface PaperFilter {
     hasPdf?: boolean;
     /** 只保留尚无可用全文（PDF 或 EPMC HTML）的论文。 */
     missingFullText?: boolean;
+    /** 只保留有效全文状态恰为该值的论文（与覆盖率的 pdfStatusOf 同一口径）。 */
+    pdfStatus?: PdfStatus;
     /** 只保留归入该分组的论文。 */
     groupId?: string;
     /** 期刊/出处（精确匹配，不分大小写）。 */

package/lib/host/tasks/filter.js

@@ -38,6 +38,9 @@ export function filterPapers(task, filter = {}) {
             if (status === 'downloaded' || status === 'available' || status === 'html-only')
                 return false;
         }
+        if (filter.pdfStatus !== undefined && pdfStatusOf(task, paper) !== filter.pdfStatus) {
+            return false;
+        }
         if (filter.groupId !== undefined && task.states[paper.paperId]?.groupId !== filter.groupId) {
             return false;
         }
@@ -88,6 +91,7 @@ export function filterKey(filter) {
         filter.language ?? '',
         filter.hasPdf === true ? '1' : '',
         filter.missingFullText === true ? '1' : '',
+        filter.pdfStatus ?? '',
         filter.groupId ?? '',
         filter.venue ?? '',
         filter.author ?? '',

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

@@ -25,7 +25,6 @@ export interface CreateTaskInput {
     types?: string[];
     sort?: SortMode;
     origin: TaskOrigin;
-    sessionId?: string;
     fromTaskId?: string;
     runNow?: boolean;
 }
@@ -62,17 +61,23 @@ 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;
+    /** 没有可用快照时，把最近更新的任务设为当前任务并落盘。 */
+    private bootstrapCurrentTask;
     get globalRev(): number;
     get root(): string;
     isRunning(id: string): boolean;
@@ -83,10 +88,18 @@ 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>;
     /** 等待该任务当前这一轮结束；返回是否确实已空闲。 */

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';
@@ -37,25 +37,61 @@ 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);
-        });
+        }
+        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();
+    }
+    /** 没有可用快照时，把最近更新的任务设为当前任务并落盘。 */
+    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;
@@ -132,25 +168,42 @@ 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) {
@@ -219,11 +272,12 @@ export class TaskService {
             result: { papers: [], sources: [] },
             rounds: [],
             states: inherited === undefined ? {} : inheritStates(inherited),
-            ...(input.sessionId === undefined ? {} : { sessionId: input.sessionId }),
             ...(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,11 +325,17 @@ 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 为最新任务。
@@ -597,6 +657,9 @@ export class TaskService {
         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)
@@ -693,7 +756,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 +778,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);

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;
     /** 索引缺失/损坏时按任务文件重建（只读头部，不长期占内存）。 */