dsh-plugin-litsearch 0.1.0 → 0.3.0

package/lib/host/tasks/store.js

@@ -1,33 +1,54 @@
 /**
  * 任务持久化：`<root>/tasks/<id>.json` + `tasks/index.json`。
  *
+ * - 数据根目录为 `$DSH_HOME/storages/dsh-plugin-litsearch`（见 `host/paths.ts`），
+ *   加载时若新目录为空而旧目录有任务，会一次性复制过来；显式传入 root 时不迁移；
  * - 写盘全部串行执行，先写临时文件再 rename，避免半截 JSON；
  * - 内存里只保留摘要，任务正文按需从磁盘读；
  * - 落盘时摘要截到 {@link MAX_ABSTRACT_CHARS} 字符，任务数按保留策略裁剪。
  */
 import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { MAX_ABSTRACT_CHARS } from '../../search/config.js';
+import { resolveStorageRoot, storageRoot } from '../paths.js';
 import { cloneRound, roundsOf, toSummary, trimRounds } from './summary.js';
 const INDEX_VERSION = 1;
 export class TaskStore {
     root;
     tasksDir;
     indexFile;
+    currentFile;
     summaries = new Map();
     cache = new Map();
     chain = Promise.resolve();
     retention = { retentionDays: 90, retentionCount: 120 };
-    constructor(root = join(homedir(), '.dsh', 'dsh-litsearch')) {
-        this.root = root;
-        this.tasksDir = join(root, 'tasks');
+    /** 只有使用默认（平台统一）目录时才做旧数据迁移；显式 root 多用于测试。 */
+    migrateOnLoad;
+    /** 迁移过来的任务文件必须重建索引，避免沿用旧目录里那份空 index.json。 */
+    forceRebuildIndex = false;
+    constructor(root) {
+        this.migrateOnLoad = root === undefined;
+        this.root = root ?? storageRoot();
+        this.tasksDir = join(this.root, 'tasks');
         this.indexFile = join(this.tasksDir, 'index.json');
+        this.currentFile = join(this.root, 'current.json');
     }
     async load(retention) {
         this.retention = retention;
+        if (this.migrateOnLoad) {
+            try {
+                const resolution = await resolveStorageRoot();
+                this.rebind(resolution.root);
+                // 复制过来的 index.json 可能不含新任务，强制按任务文件重建一次。
+                this.forceRebuildIndex = resolution.migratedFrom !== undefined;
+            }
+            catch (error) {
+                // 目录解析失败不应阻断任务系统启动，继续用构造时的默认目录。
+                console.warn('[dsh-plugin-litsearch] 数据目录解析失败，沿用默认目录：', error);
+            }
+        }
         await mkdir(this.tasksDir, { recursive: true });
-        const index = await this.readIndex();
+        const index = this.forceRebuildIndex ? null : await this.readIndex();
         if (index === null) {
             await this.rebuildIndex();
         }
@@ -75,6 +96,9 @@ export class TaskStore {
         this.summaries.set(task.id, toSummary(task));
     }
     async save(task) {
+        // 运行中的任务可能被用户删除：删除后的迟到落盘会重建文件与索引，这里直接丢弃。
+        if (!this.summaries.has(task.id))
+            return;
         this.put(task);
         const file = this.taskFile(task.id);
         const body = JSON.stringify({ version: INDEX_VERSION, task: truncateForDisk(task) });
@@ -94,7 +118,24 @@ export class TaskStore {
     async flush() {
         await this.chain;
     }
-    /** 手动清理：删除所有未置顶任务，返回条数与释放的字节数。 */
+    /** 读取「当前任务」快照；文件缺失或损坏时返回 null（由调用方自举）。 */
+    async loadCurrent() {
+        try {
+            const parsed = JSON.parse(await readFile(this.currentFile, 'utf8'));
+            const current = readBinding(parsed.current);
+            return { version: INDEX_VERSION, ...(current === undefined ? {} : { current }) };
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveCurrent(snapshot) {
+        const body = JSON.stringify(snapshot);
+        await this.enqueue(async () => {
+            await atomicWrite(this.currentFile, body);
+        });
+    }
+    /** 手动清理：删除所有未保留任务，返回条数与释放的字节数。 */
     async cleanupUnpinned() {
         const targets = this.list().filter((summary) => !summary.pinned);
         let freedBytes = 0;
@@ -109,6 +150,15 @@ export class TaskStore {
         }
         return { removed: targets.length, freedBytes };
     }
+    /** 迁移回退时切回旧目录读取，所有派生路径（含设置页展示）同步更新。 */
+    rebind(root) {
+        if (root === this.root)
+            return;
+        this.root = root;
+        this.tasksDir = join(root, 'tasks');
+        this.indexFile = join(this.tasksDir, 'index.json');
+        this.currentFile = join(root, 'current.json');
+    }
     taskFile(id) {
         return join(this.tasksDir, `${id}.json`);
     }
@@ -185,6 +235,14 @@ async function atomicWrite(file, body) {
     await writeFile(temp, body, 'utf8');
     await rename(temp, file);
 }
+function readBinding(value) {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    if (typeof record.taskId !== 'string' || record.taskId === '')
+        return undefined;
+    return { taskId: record.taskId, at: typeof record.at === 'number' ? record.at : 0 };
+}
 function truncateForDisk(task) {
     return {
         ...task,

package/lib/host/tools.d.ts

@@ -1,9 +1,10 @@
 /**
  * 模型侧工具：直接注册进 dsh 工具表（不经过外部 MCP）。
  *
- * - `literature_search`：一个研究主题 = 一个任务 = 一个 tab。默认复用「当前任务」
- *   并在其中开新一轮；主题变了才新建。等待最多 25 秒后把任务头部与前若干条结果
- *   交给模型，并明确要求本轮到此为止、只给完善建议、不自行发起下一轮。
+ * - `literature_search`：一个研究主题 = 一个任务 = 一个 tab。默认复用「当前
+ *   任务」并在其中开新一轮（当前任务是持久化的最近使用任务，跨对话、宿主重启
+ *   都有效）；只有用户明确要求新任务时才新建。等待最多 25 秒后把任务头部与前
+ *   若干条结果交给模型，并明确要求本轮到此为止、只给完善建议、不发起下一轮。
  * - `literature_sources`：列出已接入的数据源与能力，便于模型决定后续策略。
  * - `literature_task`：读取/修改已保存任务（含轮次历史），写入筛读、分组与备注，
  *   做新老对比与统计。
@@ -16,6 +17,14 @@ import type { TaskService } from './tasks/service.js';
 export interface ToolsService {
     register(definition: unknown): () => void;
 }
+/** 执行时附带的上下文：取消信号 + 发起调用的会话。 */
+interface ToolRunExec {
+    signal?: AbortSignal;
+    /** 当前会话；用于把聚焦请求送回发起检索的那个对话。 */
+    agent?: {
+        id: string;
+    };
+}
 interface ToolDefinition {
     name: string;
     description: string;
@@ -29,9 +38,7 @@ interface ToolDefinition {
             text: string;
         }>;
     };
-    execute: (args: unknown, exec: {
-        signal?: AbortSignal;
-    }) => Promise<{
+    execute: (args: unknown, exec: ToolRunExec) => Promise<{
         text: string;
     }>;
 }

package/lib/host/tools.js

@@ -1,9 +1,10 @@
 /**
  * 模型侧工具：直接注册进 dsh 工具表（不经过外部 MCP）。
  *
- * - `literature_search`：一个研究主题 = 一个任务 = 一个 tab。默认复用「当前任务」
- *   并在其中开新一轮；主题变了才新建。等待最多 25 秒后把任务头部与前若干条结果
- *   交给模型，并明确要求本轮到此为止、只给完善建议、不自行发起下一轮。
+ * - `literature_search`：一个研究主题 = 一个任务 = 一个 tab。默认复用「当前
+ *   任务」并在其中开新一轮（当前任务是持久化的最近使用任务，跨对话、宿主重启
+ *   都有效）；只有用户明确要求新任务时才新建。等待最多 25 秒后把任务头部与前
+ *   若干条结果交给模型，并明确要求本轮到此为止、只给完善建议、不发起下一轮。
  * - `literature_sources`：列出已接入的数据源与能力，便于模型决定后续策略。
  * - `literature_task`：读取/修改已保存任务（含轮次历史），写入筛读、分组与备注，
  *   做新老对比与统计。
@@ -15,7 +16,8 @@ import { MAX_LIMIT } from '../search/config.js';
 import { SearchError } from '../search/errors.js';
 import { asRecord } from '../search/normalize.js';
 import { PROVIDER_INFOS } from '../search/providers/index.js';
-import { SOURCE_IDS } from '../search/types.js';
+import { SOURCE_IDS, TASK_LANGUAGES } from '../search/types.js';
+import { resolveSessionWorkspace } from './workspace.js';
 /** 模型侧最多等多久；超时后任务继续跑，只返回当前进度与已有结果。 */
 const MODEL_WAIT_MS = 25_000;
 /** 交给模型的条数（UI 走分页端点，不受此限制）。 */
@@ -23,10 +25,11 @@ const TOOL_PAPER_LIMIT = 10;
 /** 复用任务时，最多等多久让上一轮跑完；超时直接返回提示，绝不新建任务。 */
 const WAIT_PREVIOUS_MS = 12_000;
 const SORT_MODES = ['relevance', 'citations', 'year'];
-const LANGUAGES = ['any', 'eng', 'chi'];
+const LANGUAGES = TASK_LANGUAGES;
 const SCREENINGS = ['unread', 'read', 'included', 'excluded'];
 const EXPORT_FORMATS = ['csv', 'ris', 'bibtex', 'md'];
 const TASK_ACTIONS = [
+    'current',
     'list',
     'get',
     'update',
@@ -64,11 +67,11 @@ const SEARCH_PARAMETERS = {
         },
         taskId: {
             type: 'string',
-            description: '要复用的已有任务 id。同一主题的后续检索必须复用同一个任务；通常省略即可自动复用「当前任务」，也可用 literature_task list 查到 id 后显式指定。指定后不会新建任务、不会新开 tab。',
+            description: '要复用的已有任务 id。同一主题的后续检索必须复用同一个任务；通常省略即可复用「当前任务」（最近一次使用或打开的任务，跨对话持续有效），也可用 literature_task list 查到 id 后显式指定。指定后不会新建任务、不会新开 tab。',
         },
         newTask: {
             type: 'boolean',
-            description: '仅当研究主题与当前任务明显不同时才设为 true，强制新建一个任务（此时请同时给 title）。同一主题改检索式时绝对不要设 true。',
+            description: '仅当用户明确要求「新建一个查询任务」，或研究主题与当前任务明显不同时才设为 true（此时请同时给 title）。同一主题改检索式（如加宽年份、换同义词）时绝对不要设 true。',
         },
         query: {
             type: 'string',
@@ -103,7 +106,7 @@ const SEARCH_PARAMETERS = {
         sources: {
             type: 'array',
             items: { type: 'string', enum: [...SOURCE_IDS] },
-            description: `要查询的数据源：${SOURCE_IDS.join(', ')}；省略表示全部。`,
+            description: `要查询的数据源：${SOURCE_IDS.join(', ')}；省略表示默认数据源（googlescholar 需配置 SerpAPI Key，默认关闭）。`,
         },
         limit: {
             type: 'integer',
@@ -136,9 +139,9 @@ const TASK_PARAMETERS = {
         action: {
             type: 'string',
             enum: [...TASK_ACTIONS],
-            description: 'list 列任务；get 读条件与结果；update 改条件/标题/笔记/分组；run 重跑（仅在用户明确要求进入下一轮时使用）；rounds 读该任务的检索轮次历史；annotate 写筛读/备注；compare 与旧任务对比；stats 读语料统计。',
+            description: 'current 读「当前任务」（推荐在执行检索/任务操作前先调用，确认这个对话正在用哪个任务，无需 id）；list 列任务；get 读条件与结果；update 改条件/标题/笔记/分组；run 重跑（仅在用户明确要求进入下一轮时使用）；rounds 读该任务的检索轮次历史；annotate 写筛读/备注；compare 与旧任务对比；stats 读语料统计。',
         },
-        id: { type: 'string', description: '任务 id；除 list 外必填。' },
+        id: { type: 'string', description: '任务 id；除 current / list 外必填。' },
         withTaskId: { type: 'string', description: 'compare 时的基准任务 id。' },
         limit: {
             type: 'integer',
@@ -245,7 +248,7 @@ export function literatureTools(service) {
         {
             name: 'literature_search',
             description: '检索免费开放学术文献。并发查询 PubMed、Europe PMC、OpenAlex、Crossref、Semantic Scholar、arXiv、PubTator，跨源与跨检索式去重合并成一篇文献一条，返回标题、作者、年份、出处、DOI、被引次数、开放获取状态与摘要，支持一次提交多条检索式（queries）。' +
-                '【任务模型】一个研究主题 = 一个任务 = 一个右侧栏 tab。默认复用「当前任务」并在同一任务内开新一轮：任务 id 不变、tab 不变，结果替换为最新一轮，已有的已读/纳入/排除/备注按文献身份保留；绝不会新建任务或新开 tab。仅当研究主题与当前任务明显不同时，才传 newTask=true 并用 title 自己给新任务起一个概括主题的名称；也可用 taskId 显式指定要复用的任务（先用 literature_task list 查 id）。每次调用请提交【完整】的新检索条件，缺省项回落到插件默认设置而非沿用旧条件。' +
+                '【任务模型】一个研究主题 = 一个任务 = 一个右侧栏 tab；一个对话只保留一个任务 tab，切换任务由用户在任务列表里完成。若不确定这个对话当前用哪个任务，先调用 literature_task（action=current）查清再执行。默认复用「当前任务」并在同一任务内开新一轮：任务 id 不变、tab 不变，结果替换为最新一轮，已有的已读/纳入/排除/备注按文献身份保留；绝不会新建任务或新开 tab。当前任务是持久化的「最近一次使用或打开的任务」，跨对话、宿主重启都有效；用户从右侧栏点开别的任务会切换当前任务。只有用户明确要求新建查询任务，或研究主题与当前任务明显不同时，才传 newTask=true 并用 title 给新任务起一个概括主题的名称；也可用 taskId 显式指定要复用的任务（先用 literature_task current/list 查 id，或让用户点右侧栏的「加入对话」把任务 id 带进对话）。每次调用请提交【完整】的新检索条件，缺省项回落到插件默认设置而非沿用旧条件。' +
                 '【轮次约束】本轮检索结束后，只给用户一份「如何完善检索」的建议，禁止自行发起下一轮、禁止重复调用本工具；必须等用户查看结果后，在右侧栏调整条件、或在对话里明确要求调整，才可在同一任务里再搜一次。' +
                 '超过 25 秒仍在进行时会先返回当前进度，任务会继续在右侧栏完成。适合找论文、查某主题的代表作、补充参考文献。',
             parameters: SEARCH_PARAMETERS,
@@ -253,7 +256,13 @@ export function literatureTools(service) {
             async execute(args, exec) {
                 const input = readSearchArgs(args);
                 const { title, taskId, newTask, ...conditions } = input;
-                const createInput = { ...conditions, origin: 'model', runNow: false };
+                const workspace = await resolveSessionWorkspace(exec.agent?.id);
+                const createInput = {
+                    ...conditions,
+                    origin: 'model',
+                    runNow: false,
+                    ...(workspace === undefined ? {} : { workspace }),
+                };
                 let task;
                 let reused = false;
                 if (taskId !== undefined) {
@@ -261,18 +270,14 @@ export function literatureTools(service) {
                     reused = true;
                 }
                 else if (newTask !== true) {
-                    const current = await service.currentTask();
-                    if (current !== undefined) {
-                        task = current;
-                        reused = true;
-                    }
+                    task = await service.currentTask();
+                    reused = task !== undefined;
                 }
                 if (task === undefined) {
                     task = await service.create({
                         ...createInput,
                         ...(title === undefined ? {} : { title }),
                     });
-                    service.setCurrentTask(task.id);
                 }
                 else {
                     // 上一轮还在跑时先等，绝不「换一个任务重搜」——那正是多开 tab 的根因。
@@ -287,6 +292,8 @@ export function literatureTools(service) {
                         };
                     }
                 }
+                // 让客户端把该任务 tab 打开/切到前台（右侧面板关着时重新打开）。
+                service.focusTask(task.id, task.title, exec.agent?.id);
                 // 复用时不带 title：命名只属于新建任务，避免误改已有任务名。
                 const running = reused
                     ? service.rerun(task.id, createInput, 'model')
@@ -315,7 +322,7 @@ export function literatureTools(service) {
         },
         {
             name: 'literature_sources',
-            description: '列出本插件已接入的免费文献数据源：能力（摘要、被引次数、开放获取、PDF 链接）、限流额度、检索式语法与是否需要可选 API Key。',
+            description: '列出本插件已接入的文献数据源：能力（摘要、被引次数、开放获取、PDF 链接）、限流额度、检索式语法与是否需要可选 API Key。默认数据源均免费；Google Scholar 需在设置页配置 SerpAPI Key（有免费额度，超出付费），未配置时不参与检索。',
             parameters: { type: 'object', properties: {}, additionalProperties: false },
             output: TEXT_OUTPUT,
             async execute() {
@@ -324,12 +331,14 @@ export function literatureTools(service) {
         },
         {
             name: 'literature_task',
-            description: '读取与推进已保存的检索任务。list 列出任务；get 读条件、分组、笔记与结果（可按筛读/分组/检索式/关键词过滤）；update 改标题、条件、任务笔记与分组；rounds 读该任务的检索轮次历史（每轮时间、条件、发起方、命中数与状态）；annotate 批量写入筛读状态、分组、必读顺序、备注与标签；compare 与旧任务按论文身份对比新增/缺失；stats 读语料统计（年份、来源、期刊、作者、类型、语言）。' +
-                '注意：run 会在【同一任务】内开新一轮检索，与 literature_search 一样受「用户查看结果并明确要求后才能进入下一轮」约束，不能用它绕过该约束自行加搜；也不要用 update 改完条件就立刻 run。适合在检索之后做筛选、整理与汇报。',
+            description: '读取与推进已保存的检索任务。current 读「当前任务」（推荐在执行任何检索/任务操作前先调用，确认这个对话正在用哪个任务；无需 id）；list 列出任务；get 读条件、分组、笔记与结果（可按筛读/分组/检索式/关键词过滤）；update 改标题、条件、任务笔记与分组；rounds 读该任务的检索轮次历史（每轮时间、条件、发起方、命中数与状态）；annotate 批量写入筛读状态、分组、必读顺序、备注与标签；compare 与旧任务按论文身份对比新增/缺失；stats 读语料统计（年份、来源、期刊、作者、类型、语言）。' +
+                '注意：一个对话只保留一个任务 tab，切换任务由用户在任务列表里完成；run 会在指定任务内开新一轮检索（并把它设为当前任务），与 literature_search 一样受「用户查看结果并明确要求后才能进入下一轮」约束，不能用它绕过该约束自行加搜；也不要用 update 改完条件就立刻 run。适合在检索之后做筛选、整理与汇报。',
             parameters: TASK_PARAMETERS,
             output: TEXT_OUTPUT,
             async execute(args, exec) {
-                return { text: await runTaskAction(service, readTaskArgs(args), exec.signal) };
+                return {
+                    text: await runTaskAction(service, readTaskArgs(args), exec.signal, exec.agent?.id),
+                };
             },
         },
         {
@@ -519,7 +528,7 @@ function readTaskArgs(args) {
     const id = readText(record['id'], 'id');
     if (id !== undefined)
         input.id = id;
-    if (input.action !== 'list' && input.id === undefined) {
+    if (input.action !== 'list' && input.action !== 'current' && input.id === undefined) {
         throw new Error(`action=${input.action} 需要 id`);
     }
     const withTaskId = readText(record['withTaskId'], 'withTaskId');
@@ -739,8 +748,12 @@ function readExportArgs(args) {
         input.queryId = queryId;
     return input;
 }
-async function runTaskAction(service, args, signal) {
+async function runTaskAction(service, args, signal, sessionId) {
     switch (args.action) {
+        case 'current': {
+            const task = await service.currentTask();
+            return formatCurrentTask(task);
+        }
         case 'list': {
             const tasks = await service.list();
             return formatTaskList(tasks, args.limit ?? 30);
@@ -762,10 +775,13 @@ async function runTaskAction(service, args, signal) {
         }
         case 'run': {
             const id = requireId(args);
-            await service.get(id);
-            service.setCurrentTask(id);
-            const outcome = await runWithin(service, id, signal, service.run(id, 'new', 'model'));
             const task = await service.get(id);
+            const workspace = await resolveSessionWorkspace(sessionId);
+            // 用户明确要求推进这个任务：它成为当前任务，并让客户端打开/聚焦对应 tab。
+            service.setCurrentTask(id);
+            service.focusTask(task.id, task.title, sessionId);
+            const outcome = await runWithin(service, id, signal, service.run(id, 'new', 'model', workspace));
+            const latest = await service.get(id);
             const detail = await service.getDetail(id);
             const page = await service.results(id, {
                 ...readFilterArgs(args),
@@ -773,7 +789,7 @@ async function runTaskAction(service, args, signal) {
                 offset: args.offset ?? 0,
             });
             // 这条旁路同样附上「不自动下一轮」约束，避免模型绕过 literature_search。
-            return `${formatTaskDetail(detail, page, task.states, task.groups, outcome)}\n\n${NO_AUTO_NEXT_ROUND}`;
+            return `${formatTaskDetail(detail, page, latest.states, latest.groups, outcome)}\n\n${NO_AUTO_NEXT_ROUND}`;
         }
         case 'rounds': {
             const id = requireId(args);
@@ -840,6 +856,32 @@ function readText(value, name, allowEmpty = false) {
         return undefined;
     return allowEmpty ? value : value.trim();
 }
+/** 「当前任务」的轻量快照：模型在执行检索/任务操作前先确认这个对话正在用哪个任务。 */
+function formatCurrentTask(task) {
+    if (task === undefined) {
+        return [
+            '当前没有任务：这个对话还没有任何检索任务。',
+            '若用户要求检索，请直接调用 literature_search（不要传 newTask）；若用户要继续某个已有任务，请让用户从右侧栏任务列表打开它，或点任务页的「加入对话」把任务 id 带进对话。',
+        ].join('\n');
+    }
+    const conditions = task.conditions;
+    const queries = conditions.queries.map((query) => `${query.name}=「${query.text}」`).join('；');
+    const last = task.rounds[task.rounds.length - 1];
+    const screening = task.stats.screening;
+    const lines = [
+        `当前任务：${task.title}（id: ${task.id}）`,
+        `状态：${statusLabel(task.status)}${task.error === undefined ? '' : `（${task.error}）`}`,
+        `检索轮次：共 ${task.rounds.length} 轮${last === undefined
+            ? ''
+            : `｜最近一轮 ${last.createdAt.slice(0, 19).replace('T', ' ')}（${last.origin === 'model' ? '模型' : '面板'}）`}`,
+        `检索式：${queries === '' ? '（无）' : queries}`,
+        `条件：数据源 ${conditions.sources.join('/')}｜每源 ${conditions.pageSize} 条｜年份 ${conditions.yearFrom ?? '不限'}-${conditions.yearTo ?? '不限'}｜${conditions.openAccessOnly ? '仅开放获取' : '不限获取方式'}｜语言 ${conditions.language}｜排序 ${conditions.sort}`,
+        `漏斗：原始 ${task.stats.rawHits}｜去重 ${task.stats.deduped}｜已加载 ${task.result.papers.length}｜纳入 ${screening.included}、排除 ${screening.excluded}、待读 ${screening.unread}、已读 ${screening.read}`,
+        '',
+        '用法：同一主题继续检索时省略 taskId 即复用该任务；需要调整条件时直接在 literature_search 里提交【完整】的新条件；只有用户明确要求新建查询任务时才传 newTask=true。',
+    ];
+    return lines.join('\n');
+}
 function formatTaskList(tasks, limit) {
     if (tasks.length === 0)
         return '还没有保存的检索任务。可先用 literature_search 检索。';
@@ -968,7 +1010,9 @@ function percent(value) {
     return `${Math.round(value * 100)}%`;
 }
 function formatSources() {
-    const lines = ['已接入的免费文献数据源（无需付费；部分支持可选 Key 提高额度）：'];
+    const lines = [
+        '已接入的文献数据源（默认均为免费；Google Scholar 需在设置页配置 SerpAPI Key，未配置时不参与检索）：',
+    ];
     for (const info of PROVIDER_INFOS) {
         const caps = [
             info.capabilities.abstract ? '摘要' : '',

package/lib/host/workspace.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 会话工作目录解析。
+ *
+ * DSH 为每个会话保存一个绝对工作目录（SessionHeader.cwd）。PDF 默认落在
+ * 该目录下的 `dsh-litsearch/`，让下载物跟随项目而不是散落到 `~/Downloads`。
+ * 会话服务由宿主注入；未装配或读不到时返回 undefined，由调用方回落到旧默认。
+ */
+/** `ctx.sessionPersistence` 中本插件用到的最小结构。 */
+export interface SessionStoreLike {
+    stat(id: string): Promise<{
+        header: {
+            cwd?: string;
+        };
+    } | undefined>;
+}
+export declare function setSessionStore(store: SessionStoreLike | undefined): void;
+/** 读取某个会话的工作目录；只接受绝对路径。 */
+export declare function resolveSessionWorkspace(sessionId: string | undefined): Promise<string | undefined>;
+/** 规范化工作目录：去空白、去尾斜杠，只接受绝对路径。 */
+export declare function normalizeWorkspace(value: string | undefined): string | undefined;

package/lib/host/workspace.js

@@ -0,0 +1,32 @@
+/**
+ * 会话工作目录解析。
+ *
+ * DSH 为每个会话保存一个绝对工作目录（SessionHeader.cwd）。PDF 默认落在
+ * 该目录下的 `dsh-litsearch/`，让下载物跟随项目而不是散落到 `~/Downloads`。
+ * 会话服务由宿主注入；未装配或读不到时返回 undefined，由调用方回落到旧默认。
+ */
+import { isAbsolute, resolve } from 'node:path';
+let sessionStore;
+export function setSessionStore(store) {
+    sessionStore = store;
+}
+/** 读取某个会话的工作目录；只接受绝对路径。 */
+export async function resolveSessionWorkspace(sessionId) {
+    const id = sessionId?.trim() ?? '';
+    if (id === '' || sessionStore === undefined)
+        return undefined;
+    try {
+        const snapshot = await sessionStore.stat(id);
+        return normalizeWorkspace(snapshot?.header.cwd);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 规范化工作目录：去空白、去尾斜杠，只接受绝对路径。 */
+export function normalizeWorkspace(value) {
+    const path = value?.trim() ?? '';
+    if (path === '' || !isAbsolute(path))
+        return undefined;
+    return resolve(path);
+}

package/lib/index.d.ts

@@ -14,6 +14,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
+import type { TaskLanguage } from './search/types.js';
 export declare const name = "dsh-plugin-litsearch";
 /**
  * 插件配置 schema（逐字段 volatile）。
@@ -28,6 +29,8 @@ export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
     ncbiApiKey: Schema<string, string, "volatile-defined">;
     /** 可选 Semantic Scholar API Key。 */
     s2ApiKey: Schema<string, string, "volatile-defined">;
+    /** 可选 SerpAPI Key；配置后启用 Google Scholar 数据源（付费/有免费额度）。 */
+    serpApiKey: Schema<string, string, "volatile-defined">;
     /** 各源最小请求间隔（毫秒）。 */
     pubmedIntervalMs: Schema<number, number, "volatile-defined">;
     s2IntervalMs: Schema<number, number, "volatile-defined">;
@@ -37,22 +40,24 @@ export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
     /** 单次上游请求超时（毫秒）。 */
     requestTimeoutMs: Schema<number, number, "volatile-defined">;
     /** 默认数据源。 */
-    defaultSources: Schema<NoInfer<("pubmed" | "europepmc" | "openalex" | "crossref" | "semanticscholar" | "arxiv" | "pubtator")[]>, NoInfer<("pubmed" | "europepmc" | "openalex" | "crossref" | "semanticscholar" | "arxiv" | "pubtator")[]>, "volatile-defined">;
+    defaultSources: Schema<NoInfer<("pubmed" | "europepmc" | "openalex" | "crossref" | "semanticscholar" | "arxiv" | "pubtator" | "googlescholar")[]>, NoInfer<("pubmed" | "europepmc" | "openalex" | "crossref" | "semanticscholar" | "arxiv" | "pubtator" | "googlescholar")[]>, "volatile-defined">;
     defaultSort: Schema<"relevance" | "citations" | "year", "relevance" | "citations" | "year", "volatile-defined">;
-    defaultLanguage: Schema<"any" | "eng" | "chi", "any" | "eng" | "chi", "volatile-defined">;
+    defaultLanguage: Schema<TaskLanguage, TaskLanguage, "volatile-defined">;
     /** 模型发起检索后是否自动打开任务 tab。 */
     autoOpenTaskTab: Schema<boolean, boolean, "volatile-defined">;
     /** 同时保留的任务 tab 上限。 */
     maxTaskTabs: Schema<number, number, "volatile-defined">;
-    /** 任务保留天数与条数（置顶任务不受限）。 */
+    /** 任务保留天数与条数（已保留任务不受限）。 */
     taskRetentionDays: Schema<number, number, "volatile-defined">;
     taskRetentionCount: Schema<number, number, "volatile-defined">;
     /** 单任务结果上限。 */
     taskMaxPapers: Schema<number, number, "volatile-defined">;
-    /** PDF 下载根目录。 */
+    /** PDF 下载根目录；留空时跟随会话工作目录（其下的 dsh-litsearch/）。 */
     pdfRoot: Schema<string, string, "volatile-defined">;
     /** 单个 PDF 最大体积（MB）。 */
     pdfMaxMb: Schema<number, number, "volatile-defined">;
+    /** PDF 去重缓存总量上限（MB），启动时随任务清理一起修剪；0 表示关闭。 */
+    pdfCacheMaxMb: Schema<number, number, "volatile-defined">;
     /** 检索完成后自动下载缺失 PDF。 */
     autoDownloadPdf: Schema<boolean, boolean, "volatile-defined">;
     /** 无 PDF 时用 Europe PMC HTML 全文兜底。 */
@@ -69,6 +74,8 @@ export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
     ncbiApiKey: Schema<string, string, "volatile-defined">;
     /** 可选 Semantic Scholar API Key。 */
     s2ApiKey: Schema<string, string, "volatile-defined">;
+    /** 可选 SerpAPI Key；配置后启用 Google Scholar 数据源（付费/有免费额度）。 */
+    serpApiKey: Schema<string, string, "volatile-defined">;
     /** 各源最小请求间隔（毫秒）。 */
     pubmedIntervalMs: Schema<number, number, "volatile-defined">;
     s2IntervalMs: Schema<number, number, "volatile-defined">;
@@ -78,22 +85,24 @@ export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
     /** 单次上游请求超时（毫秒）。 */
     requestTimeoutMs: Schema<number, number, "volatile-defined">;
     /** 默认数据源。 */
-    defaultSources: Schema<NoInfer<("pubmed" | "europepmc" | "openalex" | "crossref" | "semanticscholar" | "arxiv" | "pubtator")[]>, NoInfer<("pubmed" | "europepmc" | "openalex" | "crossref" | "semanticscholar" | "arxiv" | "pubtator")[]>, "volatile-defined">;
+    defaultSources: Schema<NoInfer<("pubmed" | "europepmc" | "openalex" | "crossref" | "semanticscholar" | "arxiv" | "pubtator" | "googlescholar")[]>, NoInfer<("pubmed" | "europepmc" | "openalex" | "crossref" | "semanticscholar" | "arxiv" | "pubtator" | "googlescholar")[]>, "volatile-defined">;
     defaultSort: Schema<"relevance" | "citations" | "year", "relevance" | "citations" | "year", "volatile-defined">;
-    defaultLanguage: Schema<"any" | "eng" | "chi", "any" | "eng" | "chi", "volatile-defined">;
+    defaultLanguage: Schema<TaskLanguage, TaskLanguage, "volatile-defined">;
     /** 模型发起检索后是否自动打开任务 tab。 */
     autoOpenTaskTab: Schema<boolean, boolean, "volatile-defined">;
     /** 同时保留的任务 tab 上限。 */
     maxTaskTabs: Schema<number, number, "volatile-defined">;
-    /** 任务保留天数与条数（置顶任务不受限）。 */
+    /** 任务保留天数与条数（已保留任务不受限）。 */
     taskRetentionDays: Schema<number, number, "volatile-defined">;
     taskRetentionCount: Schema<number, number, "volatile-defined">;
     /** 单任务结果上限。 */
     taskMaxPapers: Schema<number, number, "volatile-defined">;
-    /** PDF 下载根目录。 */
+    /** PDF 下载根目录；留空时跟随会话工作目录（其下的 dsh-litsearch/）。 */
     pdfRoot: Schema<string, string, "volatile-defined">;
     /** 单个 PDF 最大体积（MB）。 */
     pdfMaxMb: Schema<number, number, "volatile-defined">;
+    /** PDF 去重缓存总量上限（MB），启动时随任务清理一起修剪；0 表示关闭。 */
+    pdfCacheMaxMb: Schema<number, number, "volatile-defined">;
     /** 检索完成后自动下载缺失 PDF。 */
     autoDownloadPdf: Schema<boolean, boolean, "volatile-defined">;
     /** 无 PDF 时用 Europe PMC HTML 全文兜底。 */