dsh-plugin-litsearch 0.2.0 → 0.3.0

package/lib/host/tasks/service.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';
@@ -63,6 +64,8 @@ export class TaskService {
         catch (error) {
             console.warn('[dsh-plugin-litsearch] 任务目录加载失败：', error);
         }
+        // 与任务自动清理同批执行：按总量上限修剪 PDF 去重缓存（0 表示关闭）。
+        await this.trimPdfCache();
         let restored = false;
         try {
             const snapshot = await this.store.loadCurrent();
@@ -79,6 +82,21 @@ export class TaskService {
         if (!restored)
             this.bootstrapCurrentTask();
     }
+    /** 按设置的总量上限修剪 PDF 去重缓存；失败只告警，不阻断启动。 */
+    async trimPdfCache() {
+        const maxMb = getSettings().pdfCacheMaxMb;
+        if (maxMb <= 0)
+            return;
+        try {
+            const outcome = await prunePdfCache(this.store.root, maxMb * 1024 * 1024);
+            if (outcome.removed > 0) {
+                console.info(`[dsh-plugin-litsearch] PDF 缓存已修剪：删除 ${outcome.removed} 个文件，释放 ${Math.round(outcome.freedBytes / 1024 / 1024)} MB（上限 ${maxMb} MB）`);
+            }
+        }
+        catch (error) {
+            console.warn('[dsh-plugin-litsearch] PDF 缓存修剪失败：', error);
+        }
+    }
     /** 没有可用快照时，把最近更新的任务设为当前任务并落盘。 */
     bootstrapCurrentTask() {
         const latest = this.store.list()[0];
@@ -109,7 +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,
@@ -119,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,
@@ -206,11 +228,20 @@ export class TaskService {
         });
     }
     /** 用户从任务列表点开某任务 = 进入该任务，之后的模型检索默认落在这里。 */
-    async activate(id) {
+    async activate(id, workspace) {
         const task = await this.get(id);
+        await this.applyWorkspace(task, workspace);
         this.setCurrentTask(task.id);
         return task;
     }
+    /** 记下任务最近一次所在的工作目录；只改变下载落点，不改变 rev。 */
+    async applyWorkspace(task, workspace) {
+        const next = normalizeWorkspace(workspace);
+        if (next === undefined || next === task.workspace)
+            return;
+        task.workspace = next;
+        await this.store.save(task);
+    }
     /** 等待该任务当前这一轮结束；返回是否确实已空闲。 */
     async waitUntilIdle(id, timeoutMs, signal) {
         if (!this.runner.isRunning(id))
@@ -250,6 +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)}`,
@@ -272,6 +304,7 @@ export class TaskService {
             result: { papers: [], sources: [] },
             rounds: [],
             states: inherited === undefined ? {} : inheritStates(inherited),
+            ...(workspace === undefined ? {} : { workspace }),
             ...(input.fromTaskId === undefined ? {} : { fromTaskId: input.fromTaskId }),
         };
         this.store.put(task);
@@ -342,17 +375,17 @@ export class TaskService {
      *
      * 任务已缓存时同步登记运行态，调用方紧接着调 `waitUntilIdle` 也不会误判为空闲。
      */
-    run(id, mode = 'new', origin = 'panel') {
+    run(id, mode = 'new', origin = 'panel', workspace) {
         const cached = this.store.cached(id);
         if (cached !== undefined) {
             try {
-                return this.begin(cached, mode, origin);
+                return this.begin(cached, mode, origin, workspace);
             }
             catch (error) {
                 return Promise.reject(error);
             }
         }
-        return this.get(id).then((task) => this.begin(task, mode, origin));
+        return this.get(id).then((task) => this.begin(task, mode, origin, workspace));
     }
     /**
      * 在同一任务内开新一轮：全量替换检索条件后执行，**不新建任务、不新开 tab**。
@@ -369,6 +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);
@@ -484,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) {
@@ -503,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,
@@ -520,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);
@@ -593,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));
@@ -612,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 {
@@ -635,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 {
@@ -646,14 +692,19 @@ export class TaskService {
             ...(outcome.error === undefined ? {} : { error: outcome.error }),
         };
     }
-    async ensureLocalPdf(paper) {
-        const local = await readLocalPdf(paper);
-        if (local !== null)
-            return join(resolvePdfRoot(), readableFilename(paper));
+    async ensureLocalPdf(paper, workspace, recordedPath) {
+        if (recordedPath !== undefined) {
+            const recorded = await readSavedPdf(recordedPath);
+            if (recorded !== null)
+                return recordedPath;
+        }
+        const localPath = join(resolvePdfRoot(workspace), readableFilename(paper));
+        if ((await readSavedPdf(localPath)) !== null)
+            return localPath;
         const resolution = await resolvePdf(paper).catch(() => null);
         if (resolution === null || !resolution.ok || resolution.buffer === undefined)
             return undefined;
-        const saved = await persistPdf(resolution.buffer, this.store.root, paper);
+        const saved = await persistPdf(resolution.buffer, this.store.root, paper, workspace);
         return saved.filePath;
     }
     async setPdfState(task, paperId, patch) {
@@ -744,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', '续页加载将在后续版本提供，请先重跑任务');
         }
@@ -796,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

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

package/lib/host/tasks/store.js

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

package/lib/host/tools.js

@@ -16,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 走分页端点，不受此限制）。 */
@@ -24,7 +25,7 @@ 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 = [
@@ -105,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',
@@ -247,7 +248,7 @@ export function literatureTools(service) {
         {
             name: 'literature_search',
             description: '检索免费开放学术文献。并发查询 PubMed、Europe PMC、OpenAlex、Crossref、Semantic Scholar、arXiv、PubTator，跨源与跨检索式去重合并成一篇文献一条，返回标题、作者、年份、出处、DOI、被引次数、开放获取状态与摘要，支持一次提交多条检索式（queries）。' +
-                '【任务模型】一个研究主题 = 一个任务 = 一个右侧栏 tab；一个对话只保留一个任务 tab，切换任务由用户在任务列表里完成。若不确定这个对话当前用哪个任务，先调用 literature_task（action=current）查清再执行。默认复用「当前任务」并在同一任务内开新一轮：任务 id 不变、tab 不变，结果替换为最新一轮，已有的已读/纳入/排除/备注按文献身份保留；绝不会新建任务或新开 tab。当前任务是持久化的「最近一次使用或打开的任务」，跨对话、宿主重启都有效；用户从右侧栏点开别的任务会切换当前任务。只有用户明确要求新建查询任务，或研究主题与当前任务明显不同时，才传 newTask=true 并用 title 给新任务起一个概括主题的名称；也可用 taskId 显式指定要复用的任务（先用 literature_task current/list 查 id，或让用户点右侧栏的「带入对话」把任务 id 带进对话）。每次调用请提交【完整】的新检索条件，缺省项回落到插件默认设置而非沿用旧条件。' +
+                '【任务模型】一个研究主题 = 一个任务 = 一个右侧栏 tab；一个对话只保留一个任务 tab，切换任务由用户在任务列表里完成。若不确定这个对话当前用哪个任务，先调用 literature_task（action=current）查清再执行。默认复用「当前任务」并在同一任务内开新一轮：任务 id 不变、tab 不变，结果替换为最新一轮，已有的已读/纳入/排除/备注按文献身份保留；绝不会新建任务或新开 tab。当前任务是持久化的「最近一次使用或打开的任务」，跨对话、宿主重启都有效；用户从右侧栏点开别的任务会切换当前任务。只有用户明确要求新建查询任务，或研究主题与当前任务明显不同时，才传 newTask=true 并用 title 给新任务起一个概括主题的名称；也可用 taskId 显式指定要复用的任务（先用 literature_task current/list 查 id，或让用户点右侧栏的「加入对话」把任务 id 带进对话）。每次调用请提交【完整】的新检索条件，缺省项回落到插件默认设置而非沿用旧条件。' +
                 '【轮次约束】本轮检索结束后，只给用户一份「如何完善检索」的建议，禁止自行发起下一轮、禁止重复调用本工具；必须等用户查看结果后，在右侧栏调整条件、或在对话里明确要求调整，才可在同一任务里再搜一次。' +
                 '超过 25 秒仍在进行时会先返回当前进度，任务会继续在右侧栏完成。适合找论文、查某主题的代表作、补充参考文献。',
             parameters: SEARCH_PARAMETERS,
@@ -255,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) {
@@ -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() {
@@ -769,10 +776,11 @@ async function runTaskAction(service, args, signal, sessionId) {
         case 'run': {
             const id = requireId(args);
             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'));
+            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, {
@@ -853,7 +861,7 @@ function formatCurrentTask(task) {
     if (task === undefined) {
         return [
             '当前没有任务：这个对话还没有任何检索任务。',
-            '若用户要求检索，请直接调用 literature_search（不要传 newTask）；若用户要继续某个已有任务，请让用户从右侧栏任务列表打开它，或点任务页的「带入对话」把任务 id 带进对话。',
+            '若用户要求检索，请直接调用 literature_search（不要传 newTask）；若用户要继续某个已有任务，请让用户从右侧栏任务列表打开它，或点任务页的「加入对话」把任务 id 带进对话。',
         ].join('\n');
     }
     const conditions = task.conditions;
@@ -1002,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 全文兜底。 */