diff --git a/plugins/pasteboard-pro/CHANGELOG.md b/plugins/pasteboard-pro/CHANGELOG.md
index e129bc2ca..d262bc606 100644
--- a/plugins/pasteboard-pro/CHANGELOG.md
+++ b/plugins/pasteboard-pro/CHANGELOG.md
@@ -1,5 +1,16 @@
 # 更新日志
 
+## 1.3.0 - 2026-09-01
+
+- 适配 ZTools 3.2：新增截图入库、原生文件外拖和插件专属 `pluginData` 附件目录；首次启动会校验迁移旧附件、重写数据库路径并删除旧目录。ZTools 2.4–3.1 直接安装仍使用旧目录与浏览器拖拽回退。截图对公开的一参数 wrapper 以第二参数 `false` 作 best-effort 编辑态请求，不能保证 wrapper 会转发；区域尺寸按宿主是否回传而可选。
+- ZTools Shelf 截图只写系统剪贴板，由主窗口唯一负责历史镜像与广播，避免双窗口重复入库。
+- 插件附件删除改为内容寻址白名单，复核 SHA-256、无符号链接文件句柄、canonical 路径、父链和 inode；无法验证或仍被记录引用时拒绝删除。
+- 低于 ZTools 2.4 时只显示升级提示，不初始化剪贴板数据库、同步、窗口或后台监听。
+- Windows/Linux 列表快捷键改用 Ctrl，覆盖搜索、新建、复制、暂停、编辑、重命名、全选、多选和数字快捷粘贴。
+- 通用设置新增 ZTools 全局快捷键入口，并明确 `Win + V` 为 Windows 系统剪贴板历史快捷键。
+- 修复带 Ctrl、Meta 或 Alt 的方向键和 Enter 被误判为裸键、导致搜索框失焦或列表误操作的问题。
+- 统一卡片与列表的 Enter/Space 键盘路由，避免事件冒泡造成重复粘贴或绕过修饰键保护。
+
 ## 1.2.0 - 2026-08-03
 
 - 插件源码目录与唯一 ID 保持为 `pasteboard-pro`，兼容既有安装、数据和同步协议。
diff --git a/plugins/pasteboard-pro/README.md b/plugins/pasteboard-pro/README.md
index a319cb12b..ad37e013e 100644
--- a/plugins/pasteboard-pro/README.md
+++ b/plugins/pasteboard-pro/README.md
@@ -15,7 +15,7 @@ Paste剪切板是一款 Paste 风格的本地优先剪贴板历史插件。它
 - 按内容、来源 App、日期、类型和分组搜索历史。
 - 创建、重命名、排序和着色分组，支持拖动内容加入或移出分组。
 - 预览文本、图片与 PDF，支持平台文件预览、图片旋转和 OCR。
-- 使用方向键浏览，按 Enter 粘贴，按 Escape 关闭，支持 `Command + 1–9` 快捷粘贴。
+- 使用方向键浏览，按 Enter 粘贴，按 Escape 关闭；macOS 支持 `Command + 1–9`，Windows/Linux 支持 `Ctrl + 1–9` 快捷粘贴。
 - 将多项内容加入粘贴队列；macOS 关闭面板后连续按 `Command + V` 依次粘贴，Windows/Linux 按 Enter 后按选择顺序逐项粘贴。
 - 新复制内容实时定位；图片优先加载轻量缩略图，避免阻塞历史列表。
 - 支持紧凑布局和上、下、左、右贴边显示，始终跟随当前鼠标所在屏幕。
@@ -23,6 +23,7 @@ Paste剪切板是一款 Paste 风格的本地优先剪贴板历史插件。它
 - 使用端到端加密 WebDAV 同步正文、OCR、分组、图片、PDF 与外观配置。
 - 主题色、纯色背景和背景图片持久保存在插件本地；选图时不会上传，只有启用 WebDAV 后才进入加密同步。
 - 可从设置的隐私页清空全部剪贴板历史、插件自管附件和当前系统剪贴板。
+- ZTools 3.2 可从工具栏截图：Shelf 只写入系统剪贴板，再由主窗口唯一的历史监听器入库；插件会 best-effort 传入 `autoConfirm=false`，但当前公开的一参数 wrapper 可能忽略它，因此不能保证进入截图编辑态。截图区域尺寸也只在宿主实际回传时显示。ZTools 3.2 还支持将本地图片和文件原生拖到外部应用。
 
 ## 使用方式
 
@@ -30,7 +31,8 @@ Paste剪切板是一款 Paste 风格的本地优先剪贴板历史插件。它
 2. 首次打开后，插件会登记为随 ZTools 启动；后续无需手动打开即可持续记录复制内容。
 3. 使用鼠标、方向键或搜索框定位内容，按 Enter 或点击卡片完成粘贴。
 4. 多选后点击“队列”；macOS 可连续按 `Command + V`，Windows/Linux 在面板内按 Enter 逐项粘贴。
-5. 在设置中选择贴边位置、历史保留策略、附件预算和隐私规则。
+5. 在“设置 → 通用”中可跳转到 ZTools 的全局快捷键配置；Windows 请使用未被系统占用的组合，`Win + V` 保留给系统剪贴板历史。
+6. 在设置中选择贴边位置、历史保留策略、附件预算和隐私规则。
 
 ## 平台支持
 
@@ -38,6 +40,7 @@ Paste剪切板是一款 Paste 风格的本地优先剪贴板历史插件。它
 - Windows / Linux：支持历史捕获、搜索、分组、复制、直接粘贴、文件拖拽和系统文件预览；OCR 需要安装 Tesseract，图片旋转需要安装 ImageMagick。
 - ATools：使用 Svelte UI 与 ATools 原生 bridge。
 - ZTools：使用 Vue 3 UI、Electron preload；macOS 使用 Vision helper，Windows/Linux 使用系统安全存储和外部 Tesseract/ImageMagick 命令。
+- 最低支持 ZTools 2.4；2.4–3.1 使用旧数据目录与浏览器拖拽路径。3.2 首次启动会校验迁移旧附件并重写数据库路径，完成后删除旧目录，之后仅使用宿主提供的插件专属 `pluginData`。
 
 ## 隐私与同步
 
@@ -46,6 +49,7 @@ Paste剪切板是一款 Paste 风格的本地优先剪贴板历史插件。它
 - WebDAV record、blob 和 index 均经过端到端加密。
 - WebDAV 凭据与派生密钥不进入 renderer，本地密钥材料存放于系统钥匙串。
 - 搜索工具仅返回脱敏的结构化元数据，不把 OCR 正文写入 Agent 审计内容。
+- 附件清理只接受插件生成的内容寻址路径，并在删除前校验实际 SHA-256、`O_NOFOLLOW` 文件句柄、canonical 路径及 inode；校验异常时拒绝删除。Node.js 没有 `unlinkat`，因此这里不宣称能原子防御同一系统账号的恶意进程在最终 unlink 瞬间并发替换父目录。
 
 ## 技术实现
 
@@ -58,11 +62,14 @@ Paste剪切板是一款 Paste 风格的本地优先剪贴板历史插件。它
 ## 本地开发
 
 ```bash
+npm install -g @ztools-center/plugin-cli
 corepack pnpm@9.15.9 install --frozen-lockfile
 corepack pnpm@9.15.9 --filter @pasteboard-pro/ztools dev
 ```
 
-ZTools 开发页面默认由 Vite 启动；ATools 与 ZTools 使用独立 UI，不共享前端框架。
+官方 CLI 1.2.0 提供 `ztools create`、`ztools publish` 和 `ztools pull-contributions`。现有项目通过包内脚本启动 Vite、构建和测试；CLI 没有独立的 dev/build 子命令。独立插件仓库完成提交后使用 `ztools publish`；已经位于中心仓库工作树、且 PR 使用自定义分支时，需要沿用该 PR 的实际 head 分支更新，避免 CLI 固定的 `plugin/<name>` 分支另建 PR。1.2.0 的 `publish --help` 会执行发布流程，不可当作只读帮助命令。
+
+ATools 与 ZTools 使用独立 UI，不共享前端框架。
 
 ## 验证
 
@@ -85,6 +92,41 @@ pnpm verify:visual-artifact
 
 仓库通用构建器会读取插件根目录的 `plugin.json`，在对应平台 runner 上构建；macOS 编译并临时签名 Vision helper，Windows/Linux 跳过该 helper 并使用对应平台命令，最后从 `dist/ztools` 打包 ZIP。native 构建逻辑仍限制在插件目录内。
 
+## 大数据量列表回归
+
+ZTools 时间线按可视范围动态挂载 30～50 张卡片（结果不足 30 条时全部挂载，超大视口优先覆盖完整可视范围），支持横向、纵向与紧凑模式。首批加载 50 条，接近末尾时预取下一页；跨页方向键等待页面返回后继续移动，刷新保留已经加载的范围和选择。拖拽排序在完整分组顺序上计算，可保存十万条 ID，避免覆盖未加载记录的顺序。
+
+搜索在主插件窗口持有的 Node Worker 中执行，关闭 Paste 面板后复用缓存；输入合并窗口为 120 ms，过期结果不会覆盖新查询。后台缓存完整正文、HTML、OCR 和规范化搜索字段，沿用共享查询函数的子串、短语和筛选规则，搜索不再受界面已加载记录或一万条限制。返回列表的文本预览截取至 4096 字符；粘贴、批量粘贴、编辑和预览按 ID 读取完整原文。图片缩略图和原生拖拽按记录 ID 读取，不再为每批缩略图全量扫描历史。
+
+分页游标指向带版本的搜索结果快照。数据更新或游标过期时重新查询，避免跳项；新增、编辑、删除和插件 WebDAV 同步通过文档 ID 通知更新缓存。旧宿主或未知变更通知回退为一次完整刷新。
+
+```bash
+# 启动时序用例直接验证生产 renderer，先生成它：
+pnpm --filter @pasteboard-pro/ztools build:renderer
+pnpm exec playwright test --config playwright.performance.config.ts
+# 如本地没有 Playwright 自带浏览器，可使用已安装的 Chrome：
+PLAYWRIGHT_CHANNEL=chrome pnpm exec playwright test --config playwright.performance.config.ts
+# 可选：与虚拟列表改动之前的提交比较相同 10,000 条记录的组件挂载耗时
+PB_BENCH_REF=bd12eb67 PLAYWRIGHT_CHANNEL=chrome pnpm exec playwright test --config playwright.performance.config.ts
+```
+
+浏览器报告位于 `artifacts/virtual-timeline/`，包含十万条模拟数据的生产 Vue 界面、全库搜索、连续输入、分页和键盘回归。打包后的 Node Worker 可单独压测：
+
+```bash
+pnpm --filter @pasteboard-pro/ztools build
+node scripts/benchmark-history-worker.mjs
+```
+
+报告位于 `artifacts/search-capacity-20260908/worker-performance.json`，包括十万条模拟记录中的长文本、HTML、OCR、冷启动、查询往返 P95、调用线程定时器间隔和增量读取次数。该基准不包含 ZTools 数据库 IPC 与原生窗口创建，不代表十万条真实历史在所有机器上的性能保证。
+
+宿主数据库目前没有公开原生游标／limit 查询，本次实现的是 Worker 缓存上的结果分页：主插件首次建立缓存、重载或未知外部变更仍需全量读取一次。数据库加载、宿主迁移、保留策略清理与同步仍可能产生额外全量读取；没有改写历史格式，也没有引入数据库迁移。
+
+## 窗口首次显示
+
+Shelf 和独立面板以隐藏状态创建。宿主 DOM-ready 后等待 renderer 的 `pasteboard-pro:window-ready` 信号；Vue 在主题、首屏数据和 DOM 更新完成后发出该信号。已就绪标记支持晚到的宿主回调，窗口不再主动刷新。macOS 的首次 `show()` 可能重新放置外接屏窗口，因此显示时先设为透明，调用 show/focus 后重新校准最新屏幕坐标，再恢复可见；尺寸补偿仅在实际 bounds 不匹配时执行。旧宿主不提供透明度 API 时仍立即校准显示后的坐标。加载期间关闭或替换窗口不会在异步加载结束后抢焦点；初始化失败时显示可关闭的错误提示。
+
+`apps/ztools/tests/window.test.ts` 覆盖首次显示、连续打开、关闭重开和加载失败；`tests/performance/window-startup.spec.ts` 对生产 renderer 验证延迟主题/历史、空历史、错误状态、独立编辑窗口以及万条历史搜索。浏览器测试不代替 ZTools 原生窗口的视觉验收。
+
 ## 目录结构
 
 ```text
diff --git a/plugins/pasteboard-pro/apps/ztools/package.json b/plugins/pasteboard-pro/apps/ztools/package.json
index faf661525..68f8942b6 100644
--- a/plugins/pasteboard-pro/apps/ztools/package.json
+++ b/plugins/pasteboard-pro/apps/ztools/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@pasteboard-pro/ztools",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "scripts": {
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/clipboard-store.ts b/plugins/pasteboard-pro/apps/ztools/preload/clipboard-store.ts
index ae6f96a24..7c504b048 100644
--- a/plugins/pasteboard-pro/apps/ztools/preload/clipboard-store.ts
+++ b/plugins/pasteboard-pro/apps/ztools/preload/clipboard-store.ts
@@ -1,3 +1,4 @@
+import { markRecordChanged, rememberRecord, recordDocumentFor } from "./record-index";
 import {
   compareStableOrder,
   orderKeyBetween,
@@ -57,6 +58,7 @@ export type DeleteRecordsResult = Readonly<{
 export type CanonicalStoreOptions = Readonly<{
   deviceId?: string;
   now?: () => number;
+  ready?: Promise<void>;
 }>;
 
 export interface HostClipboardApi {
@@ -157,7 +159,7 @@ async function getOptionalDocument(
   }
 }
 
-function storedRecord(value: unknown): CanonicalClipboardRecord | undefined {
+export function storedRecord(value: unknown): CanonicalClipboardRecord | undefined {
   if (
     !isRecord(value) ||
     value.type !== "pasteboard-pro-record" ||
@@ -246,6 +248,7 @@ async function putWithConflictRetry(
 export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
   private readonly deviceId: string;
   private readonly now: () => number;
+  private readonly ready: Promise<void>;
 
   constructor(
     private readonly database: ZToolsDocumentDatabase,
@@ -253,9 +256,11 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
   ) {
     this.deviceId = options.deviceId?.trim() || "ztools-local";
     this.now = options.now ?? Date.now;
+    this.ready = options.ready ?? Promise.resolve();
   }
 
   async findByFingerprint(fingerprint: string): Promise<PasteItem | undefined> {
+    await this.ready;
     const document = await getOptionalDocument(
       this.database,
       this.recordDocumentId(fingerprint),
@@ -264,6 +269,7 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
   }
 
   async put(record: CanonicalClipboardRecord): Promise<void> {
+    await this.ready;
     const id = this.recordDocumentId(record.item.contentFingerprint);
     await putWithConflictRetry(this.database, id, (revision) => ({
       _id: id,
@@ -271,6 +277,8 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
       type: "pasteboard-pro-record",
       record: structuredClone(record),
     } satisfies StoredRecordDocument));
+    rememberRecord(this.database, record.item.id, id);
+    markRecordChanged(this.database, id);
   }
 
   async putSyncedItem(item: PasteItem): Promise<void> {
@@ -320,6 +328,7 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
     }
     const current = await this.findRecordByItemId(itemId);
     if (current === undefined) return;
+    markRecordChanged(this.database, this.recordDocumentId(current.item.contentFingerprint));
     try {
       await this.database.remove(
         await this.database.get(this.recordDocumentId(current.item.contentFingerprint)),
@@ -330,12 +339,14 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
   }
 
   async getCursor(): Promise<HostCursor | undefined> {
+    await this.ready;
     return storedCursor(
       await getOptionalDocument(this.database, CURSOR_DOCUMENT_ID),
     );
   }
 
   async setCursor(cursor: HostCursor): Promise<void> {
+    await this.ready;
     await putWithConflictRetry(
       this.database,
       CURSOR_DOCUMENT_ID,
@@ -348,7 +359,44 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
     );
   }
 
+  async readHistoryDocuments(): Promise<unknown[]> {
+    await this.ready;
+    if (this.database.allDocs === undefined) throw new TypeError("ZTools database does not expose allDocs");
+    const result = await this.database.allDocs({
+      include_docs: true, startkey: "pasteboard-pro:record:", endkey: "pasteboard-pro:record:\uffff",
+    });
+    const documents = documentsFromAllDocs(result, "ZTools database returned invalid record rows");
+    // Only inspect IDs here. Full schema validation and search run in the worker.
+    for (let offset = 0; offset < documents.length; offset += 500) {
+      for (const document of documents.slice(offset, offset + 500)) {
+        if (isRecord(document) && typeof document._id === "string" && isRecord(document.record) &&
+            isRecord(document.record.item) && typeof document.record.item.id === "string") {
+          rememberRecord(this.database, document.record.item.id, document._id);
+        }
+      }
+      if (offset + 500 < documents.length) await new Promise(resolve => setTimeout(resolve, 0));
+    }
+    return documents;
+  }
+
+  async readHistoryChanges(ids: readonly string[]): Promise<unknown[]> {
+    await this.ready;
+    const documents: unknown[] = [];
+    for (let offset = 0; offset < ids.length; offset += 50) {
+      const batch = await Promise.all(ids.slice(offset, offset + 50).map(id => getOptionalDocument(this.database, id)));
+      for (const document of batch) {
+        const record = storedRecord(document);
+        if (record !== undefined && isRecord(document) && typeof document._id === "string") {
+          rememberRecord(this.database, record.item.id, document._id);
+          documents.push(document);
+        }
+      }
+    }
+    return documents;
+  }
+
   async listRecords(): Promise<CanonicalClipboardRecord[]> {
+    await this.ready;
     if (this.database.allDocs === undefined) {
       throw new TypeError("ZTools database does not expose allDocs");
     }
@@ -363,6 +411,7 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
     )
       .flatMap((document) => {
         const record = storedRecord(document);
+        if (record !== undefined) rememberRecord(this.database, record.item.id, this.recordDocumentId(record.item.contentFingerprint));
         return record === undefined ? [] : [record];
       })
       .sort(
@@ -376,6 +425,13 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
     query: string,
     limit: number,
   ): Promise<Readonly<{ items: PasteItem[]; total: number }>> {
+    return (await this.searchWithRecords(query, limit)).result;
+  }
+
+  async searchWithRecords(query: string, limit: number): Promise<Readonly<{
+    result: Readonly<{ items: PasteItem[]; total: number }>;
+    records: CanonicalClipboardRecord[];
+  }>> {
     if (!Number.isInteger(limit) || limit < 1 || limit > 10_000) {
       throw new RangeError("Search limit must be an integer between 1 and 10000");
     }
@@ -384,12 +440,18 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
       records.map((record) => record.item),
       query,
     );
-    return { items: matched.slice(0, limit), total: matched.length };
+    return { result: { items: matched.slice(0, limit), total: matched.length }, records };
   }
 
   async findRecordByItemId(
     itemId: string,
   ): Promise<CanonicalClipboardRecord | undefined> {
+    const documentId = recordDocumentFor(this.database, itemId);
+    if (documentId !== undefined) {
+      await this.ready;
+      const record = storedRecord(await getOptionalDocument(this.database, documentId));
+      return record?.item.id === itemId ? record : undefined;
+    }
     return (await this.listRecords()).find((record) => record.item.id === itemId);
   }
 
@@ -572,9 +634,11 @@ export class ZToolsCanonicalClipboardStore implements CanonicalClipboardStore {
         }));
         const document = await this.database.get(documentId);
         await this.database.remove(document);
+        markRecordChanged(this.database, documentId);
         deletedIds.push(record.item.id);
       } catch (error) {
         if (isDatabaseStatus(error, 404)) {
+          markRecordChanged(this.database, documentId);
           deletedIds.push(record.item.id);
         } else {
           failures.push({
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/clipboard-window-role.ts b/plugins/pasteboard-pro/apps/ztools/preload/clipboard-window-role.ts
new file mode 100644
index 000000000..2b1d8750f
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/clipboard-window-role.ts
@@ -0,0 +1,15 @@
+export type ClipboardWindowRole = "primary" | "shelf" | "panel";
+
+export function clipboardWindowRole(
+  parameters: URLSearchParams,
+): ClipboardWindowRole {
+  if (parameters.get("shelf") === "1") return "shelf";
+  if (parameters.has("panel")) return "panel";
+  return "primary";
+}
+
+export function ownsClipboardHistoryMirror(
+  role: ClipboardWindowRole,
+): boolean {
+  return role === "primary";
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/history-page.ts b/plugins/pasteboard-pro/apps/ztools/preload/history-page.ts
new file mode 100644
index 000000000..405bead2a
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/history-page.ts
@@ -0,0 +1,16 @@
+import type { PasteItem } from "@pasteboard-pro/core";
+
+export type HistoryRequest = Readonly<{
+  query?: string;
+  pinboardId?: string;
+  orderedIds?: readonly string[];
+  cursor?: string;
+  limit?: number;
+}>;
+
+export type HistoryPage = Readonly<{
+  items: PasteItem[];
+  total: number;
+  nextCursor?: string;
+  reset?: boolean;
+}>;
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/history-rpc.ts b/plugins/pasteboard-pro/apps/ztools/preload/history-rpc.ts
new file mode 100644
index 000000000..9312daf92
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/history-rpc.ts
@@ -0,0 +1,49 @@
+import type { HistoryPage, HistoryRequest } from "./history-page";
+
+export const HISTORY_QUERY_CHANNEL = "pasteboard-pro:history-query";
+export const HISTORY_RESULT_CHANNEL = "pasteboard-pro:history-result";
+export type HistoryReply = Readonly<{ id: string; page?: HistoryPage; error?: string }>;
+
+/** Reuse the primary window's worker when the shelf closes after each paste. */
+export class HistoryRpcClient {
+  private readonly pending = new Map<string, {
+    resolve(page: HistoryPage): void;
+    reject(error: Error): void;
+    timer: ReturnType<typeof setTimeout>;
+  }>();
+  private sequence = 0;
+  constructor(
+    private readonly session: string,
+    private readonly send: (id: string, request: HistoryRequest) => void,
+  ) {}
+
+  page(request: HistoryRequest): Promise<HistoryPage> {
+    const id = `${this.session}:${++this.sequence}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("历史查询超时，请重试"));
+      }, 30_000);
+      this.pending.set(id, { resolve, reject, timer });
+      try { this.send(id, request); }
+      catch (error) { clearTimeout(timer); this.pending.delete(id); reject(error); }
+    });
+  }
+
+  receive(reply: HistoryReply): void {
+    const pending = this.pending.get(reply.id);
+    if (pending === undefined) return;
+    clearTimeout(pending.timer);
+    this.pending.delete(reply.id);
+    if (reply.page !== undefined) pending.resolve(reply.page);
+    else pending.reject(new Error(reply.error ?? "历史查询失败"));
+  }
+
+  dispose(): void {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("History window closed"));
+    }
+    this.pending.clear();
+  }
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/history-search-index.ts b/plugins/pasteboard-pro/apps/ztools/preload/history-search-index.ts
new file mode 100644
index 000000000..268c77f27
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/history-search-index.ts
@@ -0,0 +1,123 @@
+import { searchPasteItems, type PasteItem } from "@pasteboard-pro/core";
+import { applyListOrder } from "../src/list-order";
+import { isSmartPinboardId, matchesSmartPinboard } from "../src/smart-pinboards";
+import { storedRecord, type CanonicalClipboardRecord } from "./clipboard-store";
+import type { HistoryPage, HistoryRequest } from "./history-page";
+
+/** Lives exclusively in the worker. Cursors address a versioned result snapshot. */
+export class HistorySearchIndex {
+  private readonly records = new Map<string, CanonicalClipboardRecord>();
+  private version = 0;
+  private orderedSearchItems: PasteItem[] | undefined;
+  private readonly searchable = new Map<string, PasteItem>();
+  private readonly originals = new WeakMap<PasteItem, PasteItem>();
+  private sequence = 0;
+  private readonly snapshots = new Map<string, { key: string; items: PasteItem[] }>();
+
+  replace(documents: readonly unknown[]): void {
+    this.records.clear();
+    this.searchable.clear();
+    this.update(documents, []);
+  }
+
+  update(documents: readonly unknown[], removed: readonly string[]): void {
+    for (const id of removed) { this.records.delete(id); this.searchable.delete(id); }
+    for (const document of documents) {
+      const record = storedRecord(document);
+      const id = (document as { _id?: unknown } | null)?._id;
+      if (typeof id !== "string") continue;
+      if (record === undefined) { this.records.delete(id); this.searchable.delete(id); }
+      else {
+        this.records.set(id, record);
+        const normalized = normalizedSearchItem(record.item);
+        this.searchable.set(id, normalized);
+        this.originals.set(normalized, record.item);
+      }
+    }
+    this.orderedSearchItems = undefined;
+    this.version++;
+    this.snapshots.clear();
+  }
+
+  order(request: HistoryRequest): string[] {
+    const { cursor: _cursor, ...firstPage } = request;
+    this.page({ ...firstPage, limit: 1 });
+    return [...this.snapshots.values()].at(-1)!.items.map(item => item.id);
+  }
+
+  page(request: HistoryRequest): HistoryPage {
+    const limit = request.limit ?? 50;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new RangeError("Page size must be 1–100");
+    const key = JSON.stringify([request.query ?? "", request.pinboardId, request.orderedIds ?? []]);
+    let offset = 0;
+    let token: string | undefined;
+    let snapshot: { key: string; items: PasteItem[] } | undefined;
+    if (request.cursor !== undefined) {
+      const match = /^(\d+-\d+):(\d+)$/.exec(request.cursor);
+      token = match?.[1];
+      offset = Number(match?.[2]);
+      snapshot = token === undefined ? undefined : this.snapshots.get(token);
+      if (snapshot?.key !== key || !Number.isSafeInteger(offset) || offset < 0) {
+        const { cursor: _cursor, ...firstPage } = request;
+        return { ...this.page(firstPage), reset: true };
+      }
+    }
+    if (snapshot === undefined) {
+      // Stable tie order matches listRecords; the shared query function preserves
+      // substring matching, Chinese text, quoted phrases, OCR and all filters.
+      this.orderedSearchItems ??= [...this.searchable.values()].sort((a, b) =>
+        Date.parse(b.copiedAt) - Date.parse(a.copiedAt) || a.id.localeCompare(b.id));
+      const matched = searchPasteItems(this.orderedSearchItems, request.query ?? "")
+        .map(item => this.originals.get(item)!);
+      const scope = request.pinboardId;
+      const scoped = scope === undefined ? matched : matched.filter(item =>
+        isSmartPinboardId(scope) ? matchesSmartPinboard(item, scope) : item.pinboardId === scope);
+      snapshot = { key, items: applyListOrder(scoped, request.orderedIds ?? []) };
+      token = `${this.version}-${++this.sequence}`;
+      this.snapshots.set(token, snapshot);
+      while (this.snapshots.size > 4) this.snapshots.delete(this.snapshots.keys().next().value!);
+    }
+    const end = Math.min(snapshot.items.length, offset + limit);
+    return {
+      items: snapshot.items.slice(offset, end).map(historyCard),
+      total: snapshot.items.length,
+      ...(end < snapshot.items.length ? { nextCursor: `${token}:${end}` } : {}),
+    };
+  }
+}
+
+/** The list gets bounded previews; clipboard actions always fetch full records. */
+function historyCard(item: PasteItem): PasteItem {
+  return {
+    ...item,
+    ...(item.title === undefined ? {} : { title: item.title.slice(0, 1_024) }),
+    ...(item.ocrText === undefined ? {} : { ocrText: item.ocrText.slice(0, 4_096) }),
+    payload: {
+      ...item.payload,
+      ...(item.payload.text === undefined ? {} : { text: item.payload.text.slice(0, 4_096) }),
+      ...(item.payload.html === undefined ? {} : { html: item.payload.html.slice(0, 4_096) }),
+    },
+  };
+}
+
+/** Normalize searchable fields once per change, retaining originals for display/paste. */
+function normalizedSearchItem(item: PasteItem): PasteItem {
+  return {
+    ...item,
+    ...(item.title === undefined ? {} : { title: item.title.toLowerCase() }),
+    ...(item.ocrText === undefined ? {} : { ocrText: item.ocrText.toLowerCase() }),
+    sourceDeviceId: item.sourceDeviceId.toLowerCase(),
+    ...(item.sourceApp === undefined ? {} : { sourceApp: {
+      ...item.sourceApp,
+      ...(item.sourceApp.name === undefined ? {} : { name: item.sourceApp.name.toLowerCase() }),
+      ...(item.sourceApp.bundleId === undefined ? {} : { bundleId: item.sourceApp.bundleId.toLowerCase() }),
+    } }),
+    payload: {
+      ...item.payload,
+      ...(item.payload.text === undefined ? {} : { text: item.payload.text.toLowerCase() }),
+      ...(item.payload.html === undefined ? {} : { html: item.payload.html.toLowerCase() }),
+      ...(item.payload.mediaType === undefined ? {} : { mediaType: item.payload.mediaType.toLowerCase() }),
+      ...(item.payload.filePaths === undefined ? {} : { filePaths: item.payload.filePaths.map(value => value.toLowerCase()) }),
+    },
+  };
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/history-search.ts b/plugins/pasteboard-pro/apps/ztools/preload/history-search.ts
new file mode 100644
index 000000000..4fcb3ede9
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/history-search.ts
@@ -0,0 +1,102 @@
+import { Worker } from "node:worker_threads";
+import type { HistoryPage, HistoryRequest } from "./history-page";
+
+export type HistoryDocumentReader = Readonly<{
+  all(): Promise<unknown[]>;
+  changed(ids: readonly string[]): Promise<unknown[]>;
+}>;
+
+/** One lazy worker per window; full records never enter Vue's reactive state. */
+export class HistorySearchService {
+  private worker: Worker | undefined;
+  private serial = 0;
+  private readonly pending = new Map<number, { resolve(value: unknown): void; reject(error: Error): void }>();
+  private loaded = false;
+  private disposed = false;
+  private dirty: Set<string> | undefined = new Set();
+  private queue: Promise<unknown> = Promise.resolve();
+
+  constructor(private readonly filename: string, private readonly reader: HistoryDocumentReader) {}
+
+  invalidate(ids?: readonly string[]): void {
+    if (ids === undefined) this.dirty = undefined;
+    else if (this.dirty !== undefined) ids.forEach(id => this.dirty!.add(id));
+  }
+
+  page(request: HistoryRequest): Promise<HistoryPage> {
+    return this.query("page", request) as Promise<HistoryPage>;
+  }
+
+  order(request: HistoryRequest): Promise<string[]> {
+    return this.query("order", request) as Promise<string[]>;
+  }
+
+  private query(type: "page" | "order", request: HistoryRequest): Promise<unknown> {
+    const operation = this.queue.then(async () => {
+      if (this.disposed) throw new Error("History search closed");
+      if (!this.loaded || this.dirty === undefined) {
+        this.dirty = new Set();
+        try {
+          await this.call({ type: "replace", documents: await this.reader.all() });
+          this.loaded = true;
+        } catch (error) { this.loaded = false; throw error; }
+      }
+      while (this.dirty === undefined || this.dirty.size > 0) {
+        const ids = this.dirty === undefined ? undefined : [...this.dirty];
+        this.dirty = new Set();
+        try {
+          if (ids === undefined) await this.call({ type: "replace", documents: await this.reader.all() });
+          else await this.call({ type: "update", documents: await this.reader.changed(ids), removed: ids });
+        } catch (error) { this.dirty = undefined; throw error; }
+      }
+      return this.call({ type, request });
+    });
+    this.queue = operation.catch(() => undefined);
+    return operation;
+  }
+
+  dispose(): void {
+    this.disposed = true;
+    this.fail(new Error("History search closed"));
+    void this.worker?.terminate();
+    this.worker = undefined;
+  }
+
+  private fail(error: Error): void {
+    this.loaded = false;
+    for (const request of this.pending.values()) request.reject(error);
+    this.pending.clear();
+  }
+
+  private call(message: Record<string, unknown>): Promise<unknown> {
+    if (this.disposed) return Promise.reject(new Error("History search closed"));
+    if (this.worker === undefined) {
+      const worker = new Worker(this.filename);
+      this.worker = worker;
+      worker.on("message", (response: { id: number; value?: unknown; error?: string }) => {
+        const request = this.pending.get(response.id);
+        this.pending.delete(response.id);
+        if (response.error === undefined) request?.resolve(response.value);
+        else request?.reject(new Error(response.error));
+      });
+      worker.on("error", error => {
+        if (this.worker !== worker) return;
+        this.worker = undefined;
+        this.fail(error);
+        void worker.terminate();
+      });
+      worker.on("exit", () => {
+        if (this.worker === worker) {
+          this.worker = undefined;
+          this.fail(new Error("History search worker exited"));
+        }
+      });
+    }
+    const id = ++this.serial;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      try { this.worker!.postMessage({ ...message, id }); }
+      catch (error) { this.pending.delete(id); reject(error); }
+    });
+  }
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/history-worker.ts b/plugins/pasteboard-pro/apps/ztools/preload/history-worker.ts
new file mode 100644
index 000000000..4946a2354
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/history-worker.ts
@@ -0,0 +1,22 @@
+import { parentPort } from "node:worker_threads";
+import { HistorySearchIndex } from "./history-search-index";
+import type { HistoryRequest } from "./history-page";
+
+const index = new HistorySearchIndex();
+parentPort?.on("message", (message: {
+  id: number;
+  type: "replace" | "update" | "page" | "order";
+  documents?: unknown[];
+  removed?: string[];
+  request?: HistoryRequest;
+}) => {
+  try {
+    let value: unknown;
+    if (message.type === "replace") index.replace(message.documents ?? []);
+    else if (message.type === "update") index.update(message.documents ?? [], message.removed ?? []);
+    else value = message.type === "order" ? index.order(message.request ?? {}) : index.page(message.request ?? {});
+    parentPort?.postMessage({ id: message.id, value });
+  } catch (error) {
+    parentPort?.postMessage({ id: message.id, error: error instanceof Error ? error.message : String(error) });
+  }
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/host-compatibility.ts b/plugins/pasteboard-pro/apps/ztools/preload/host-compatibility.ts
new file mode 100644
index 000000000..5b292a38d
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/host-compatibility.ts
@@ -0,0 +1,131 @@
+export const MINIMUM_ZTOOLS_VERSION = "2.4.0";
+export const EDITABLE_SCREEN_CAPTURE_VERSION = "3.2.0";
+
+export type ZToolsHostCompatibility = Readonly<{
+  currentVersion?: string;
+  minimumVersion: string;
+  supported: boolean;
+  supportsPluginData: boolean;
+  supportsNativeFileDrag: boolean;
+  supportsScreenCapture: boolean;
+}>;
+
+type VersionHost = Readonly<{
+  getAppVersion?: () => unknown;
+  getPath?: (name: string) => unknown;
+  startDrag?: unknown;
+  screenCapture?: unknown;
+}>;
+
+type VersionParts = Readonly<{
+  core: readonly [number, number, number];
+  prerelease: readonly string[];
+}>;
+
+function versionParts(value: string): VersionParts | undefined {
+  const match = /^(\d+)\.(\d+)(?:\.(\d+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u.exec(
+    value.trim(),
+  );
+  if (match === null) return undefined;
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3] ?? 0)],
+    prerelease: match[4]?.split(".") ?? [],
+  };
+}
+
+function comparePrerelease(
+  left: readonly string[],
+  right: readonly string[],
+): number {
+  if (left.length === 0 || right.length === 0) {
+    return left.length === right.length ? 0 : left.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left[index];
+    const rightPart = right[index];
+    if (leftPart === undefined || rightPart === undefined) {
+      return leftPart === rightPart ? 0 : leftPart === undefined ? -1 : 1;
+    }
+    if (leftPart === rightPart) continue;
+    const leftNumeric = /^\d+$/u.test(leftPart);
+    const rightNumeric = /^\d+$/u.test(rightPart);
+    if (leftNumeric && rightNumeric) return Number(leftPart) - Number(rightPart);
+    if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+    return leftPart.localeCompare(rightPart);
+  }
+  return 0;
+}
+
+export function compareZToolsVersions(left: string, right: string): number | undefined {
+  const leftParts = versionParts(left);
+  const rightParts = versionParts(right);
+  if (leftParts === undefined || rightParts === undefined) return undefined;
+  for (let index = 0; index < 3; index += 1) {
+    const difference = leftParts.core[index]! - rightParts.core[index]!;
+    if (difference !== 0) return difference;
+  }
+  return comparePrerelease(leftParts.prerelease, rightParts.prerelease);
+}
+
+export const compareVersions = compareZToolsVersions;
+
+export function detectZToolsHostCompatibility(host: VersionHost): ZToolsHostCompatibility {
+  let currentVersion: string | undefined;
+  try {
+    const value = host.getAppVersion?.();
+    if (typeof value === "string" && value.trim().length > 0) {
+      currentVersion = value.trim();
+    }
+  } catch {
+    currentVersion = undefined;
+  }
+  const comparison =
+    currentVersion === undefined
+      ? undefined
+      : compareZToolsVersions(currentVersion, MINIMUM_ZTOOLS_VERSION);
+  const editableScreenCaptureComparison =
+    currentVersion === undefined
+      ? undefined
+      : compareZToolsVersions(currentVersion, EDITABLE_SCREEN_CAPTURE_VERSION);
+  let supportsPluginData = false;
+  try {
+    const pluginData = host.getPath?.("pluginData");
+    supportsPluginData = typeof pluginData === "string" && pluginData.length > 0;
+  } catch {
+    supportsPluginData = false;
+  }
+  let supportsNativeFileDrag = false;
+  try {
+    supportsNativeFileDrag = typeof host.startDrag === "function";
+  } catch {
+    supportsNativeFileDrag = false;
+  }
+  let supportsScreenCapture = false;
+  try {
+    const screenCapture = host.screenCapture;
+    supportsScreenCapture =
+      editableScreenCaptureComparison !== undefined &&
+      editableScreenCaptureComparison >= 0 &&
+      typeof screenCapture === "function";
+  } catch {
+    supportsScreenCapture = false;
+  }
+  return {
+    ...(currentVersion === undefined ? {} : { currentVersion }),
+    minimumVersion: MINIMUM_ZTOOLS_VERSION,
+    // A real host with no readable version is treated as unsupported. Browser
+    // previews have no preload bridge and are handled separately in the UI.
+    supported: comparison !== undefined && comparison >= 0,
+    supportsPluginData,
+    supportsNativeFileDrag,
+    // ZTools 3.2 documents the editable capture contract as
+    // screenCapture(callback, autoConfirm). Some 3.2.0 installations still
+    // expose a one-argument wrapper even though the underlying host accepts
+    // autoConfirm as an optional second argument. Function.length therefore
+    // cannot be used as a capability signal; bounds remain optional at runtime.
+    supportsScreenCapture,
+  };
+}
+
+export const inspectHostCompatibility = detectZToolsHostCompatibility;
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/index.ts b/plugins/pasteboard-pro/apps/ztools/preload/index.ts
index 1df830b7d..1e87ba3a8 100644
--- a/plugins/pasteboard-pro/apps/ztools/preload/index.ts
+++ b/plugins/pasteboard-pro/apps/ztools/preload/index.ts
@@ -1,3 +1,8 @@
+import { HistoryRpcClient, HISTORY_QUERY_CHANNEL, HISTORY_RESULT_CHANNEL, type HistoryReply } from "./history-rpc";
+import { reorderItemGroupIds, listOrderScope, type ListReorderRequest } from "../src/list-order";
+import { HistorySearchService } from "./history-search";
+import { rememberRecord, takeRecordChanges } from "./record-index";
+import type { HistoryPage, HistoryRequest } from "./history-page";
 import { readFile, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -8,10 +13,25 @@ import {
   type HostClipboardApi,
   type ZToolsDocumentDatabase,
 } from "./clipboard-store";
+import {
+  clipboardWindowRole,
+  ownsClipboardHistoryMirror,
+} from "./clipboard-window-role";
 import { ensureZToolsAutoStart } from "./auto-start";
 import type { PasteStackState } from "@pasteboard-pro/core";
 import { createOcrClient, createTesseractOcrClient } from "./ocr";
 import { NativeFileDragService } from "./native-file-drag";
+import {
+  inspectHostCompatibility,
+  type ZToolsHostCompatibility,
+} from "./host-compatibility";
+import { migratePasteboardProPluginData } from "./plugin-data-migration";
+import { resolvePasteboardProDataPaths } from "./plugin-data";
+import {
+  importScreenCapture,
+  type ScreenCaptureImportResult,
+  type ScreenshotNativeImageApi,
+} from "./screenshot-import";
 import { localizeMirroredImage } from "./mirrored-image";
 import { openQuickLook } from "./quick-look";
 import { rotateImageFile } from "./image-rotation";
@@ -104,13 +124,19 @@ type ZToolsDisplay = Readonly<{
 }>;
 
 type ZToolsHost = Readonly<{
+  getAppVersion?(): unknown;
+  getPath?(name: string): unknown;
   onPluginEnter(callback: (parameter: unknown) => void): void;
   registerTool(
     name: string,
     handler: (input?: unknown) => Promise<unknown>,
   ): void;
   getNativeId(): string;
-  startDrag(file: string | string[]): void;
+  startDrag?(file: string | string[]): void;
+  screenCapture?(
+    callback: (image: unknown, bounds?: unknown) => void,
+    autoConfirm?: boolean,
+  ): void | Promise<unknown>;
   clipboard: HostClipboardApi &
     ClipboardPasteHost &
     Readonly<{
@@ -138,14 +164,21 @@ type ZToolsHost = Readonly<{
 }>;
 
 type PasteboardProBridge = Readonly<{
+  getHostCompatibility(): ZToolsHostCompatibility;
   getPlatformCapabilities(): Readonly<{
     platform: NodeJS.Platform;
     supportsGlobalPasteQueue: boolean;
     supportsQuickLook: boolean;
     supportsSystemOcr: boolean;
     supportsImageRotation: boolean;
+    supportsNativeFileDrag: boolean;
+    supportsScreenCapture: boolean;
   }>;
+  captureScreenshot(): Promise<ScreenCaptureImportResult>;
   searchHistory(query?: string, limit?: number): Promise<Readonly<{ items: unknown[]; total: number }>>;
+  searchHistoryPage(request: HistoryRequest): Promise<HistoryPage>;
+  getHistoryItem(itemId: string, fingerprint?: string): Promise<unknown>;
+  reorderHistory(request: ListReorderRequest, pinboardId?: string): Promise<ListOrders>;
   getPrivacySettings(): Promise<PrivacySettings>;
   savePrivacySettings(settings: PrivacySettings): Promise<PrivacySettings>;
   setCapturePause(pause: CapturePauseState): Promise<PrivacySettings>;
@@ -200,12 +233,44 @@ if (host === undefined) {
 }
 
 const ztools: ZToolsHost = host;
+const hostCompatibility = inspectHostCompatibility(ztools);
+const platformCapabilities = {
+  platform: process.platform,
+  supportsGlobalPasteQueue: process.platform === "darwin",
+  supportsQuickLook:
+    process.platform === "darwin" ||
+    process.platform === "win32" ||
+    process.platform === "linux",
+  supportsSystemOcr: true,
+  supportsImageRotation:
+    process.platform === "darwin" ||
+    process.platform === "win32" ||
+    process.platform === "linux",
+  supportsNativeFileDrag: hostCompatibility.supportsNativeFileDrag,
+  supportsScreenCapture: hostCompatibility.supportsScreenCapture,
+} as const;
+
+if (!hostCompatibility.supported) {
+  const compatibilityBridge = {
+    getHostCompatibility: () => hostCompatibility,
+    getPlatformCapabilities: () => platformCapabilities,
+  } as PasteboardProBridge;
+  (window as Window & { pasteboardPro?: PasteboardProBridge }).pasteboardPro =
+    compatibilityBridge;
+} else {
 const windowParams = new URLSearchParams(window.location.search);
-const isShelfWindow = windowParams.get("shelf") === "1";
-const isPanelWindow = windowParams.has("panel");
-const isPrimaryWindow = !isShelfWindow && !isPanelWindow;
+const windowRole = clipboardWindowRole(windowParams);
+const isShelfWindow = windowRole === "shelf";
+const isPanelWindow = windowRole === "panel";
+const isPrimaryWindow = windowRole === "primary";
+const dataPaths = resolvePasteboardProDataPaths(ztools);
+const dataMigration = isPrimaryWindow
+  ? migratePasteboardProPluginData(ztools.db.promises, dataPaths)
+  : Promise.resolve();
+dataMigration.catch((error) => console.error("[pasteboard-pro] pluginData migration failed", error));
 const store = new ZToolsCanonicalClipboardStore(ztools.db.promises, {
   deviceId: ztools.getNativeId(),
+  ready: dataMigration,
 });
 const privacyStore = new ZToolsPrivacySettingsStore(ztools.db.promises);
 const windowPreferencesStore = new ZToolsWindowPreferencesStore(ztools.db.promises, {
@@ -237,11 +302,28 @@ const keychain =
 const syncRepository = new ZToolsSyncEntityRepository(
   ztools.db.promises,
   ztools.getNativeId(),
+  dataPaths.blobRoot,
+  dataPaths.legacyBlobRoots,
+  dataMigration,
 );
 const shelfWindows = new ShelfWindowManager(ztools);
 const panelWindows = new PanelWindowManager(ztools);
 const thumbnailService = new ThumbnailService(store, nativeImage);
 const nativeFileDragService = new NativeFileDragService(store, ztools);
+const historySearch = new HistorySearchService(path.join(__dirname, "history-worker.cjs"), {
+  all: () => store.readHistoryDocuments(),
+  changed: ids => store.readHistoryChanges(ids),
+});
+const historyRpc = !isPrimaryWindow && ztools.sendToParent !== undefined
+  ? new HistoryRpcClient(`${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      (id, request) => ztools.sendToParent!(HISTORY_QUERY_CHANNEL, id, request))
+  : undefined;
+window.addEventListener(HISTORY_RESULT_CHANNEL, event => historyRpc?.receive((event as CustomEvent<HistoryReply>).detail));
+window.addEventListener("beforeunload", () => { historySearch.dispose(); historyRpc?.dispose(); });
+window.addEventListener("pasteboard-pro:history-changed", (event) => {
+  const detail = (event as CustomEvent<unknown>).detail;
+  historySearch.invalidate(Array.isArray(detail) && detail.every(id => typeof id === "string") ? detail : undefined);
+});
 const ocrClient =
   process.platform === "darwin"
     ? createOcrClient({
@@ -377,12 +459,13 @@ function requestShelfEdge(edge: ShelfDockEdge): void {
 
 function broadcastHistoryChanged(): void {
   thumbnailService.invalidateRecordIndex();
-  window.dispatchEvent(new CustomEvent(HISTORY_CHANGED_CHANNEL));
+  const changes = takeRecordChanges(ztools.db.promises);
+  window.dispatchEvent(new CustomEvent(HISTORY_CHANGED_CHANNEL, { detail: changes }));
   if (isPrimaryWindow) {
-    shelfWindows.notifyHistoryChanged();
+    shelfWindows.notifyHistoryChanged(changes);
     return;
   }
-  ztools.sendToParent?.(HISTORY_CHANGED_CHANNEL);
+  ztools.sendToParent?.(HISTORY_CHANGED_CHANNEL, changes);
 }
 
 function broadcastWindowPreferencesChanged(): void {
@@ -454,8 +537,8 @@ async function runRetentionIfDue(): Promise<void> {
   }
 }
 
-function scheduleHistoryMirror(): void {
-  synchronization = synchronization
+function scheduleHistoryMirror(): Promise<void> {
+  const nextSynchronization = synchronization
     .then(async () => {
       const privacy = await privacyStore.get();
       const result = await mirrorHostHistory(ztools.clipboard, store, {
@@ -485,11 +568,12 @@ function scheduleHistoryMirror(): void {
       await runRetentionIfDue();
       broadcastHistoryChanged();
       void scheduleVaultSync().catch(reportSynchronizationError);
-    })
-    .catch(reportSynchronizationError);
+    });
+  synchronization = nextSynchronization.catch(reportSynchronizationError);
+  return nextSynchronization;
 }
 
-if (isPrimaryWindow) {
+if (ownsClipboardHistoryMirror(windowRole)) {
   void ensureZToolsAutoStart(ipcRenderer).catch((error: unknown) => {
     console.warn("Paste剪切板自动启动登记失败", error);
   });
@@ -508,8 +592,18 @@ if (isPrimaryWindow) {
       void repositionShelf(edge).catch(reportSynchronizationError);
     }
   });
-  ipcRenderer.on(HISTORY_CHANGED_CHANNEL, () => {
-    shelfWindows.notifyHistoryChanged();
+  ipcRenderer.on(HISTORY_QUERY_CHANNEL, (_event, id, request) => {
+    if (typeof id !== "string" || id.length > 128 || !isRecord(request)) return;
+    void historySearch.page(request as HistoryRequest).then(
+      page => shelfWindows.notifyHistoryResult({ id, page }),
+      error => shelfWindows.notifyHistoryResult({ id, error: error instanceof Error ? error.message : "历史查询失败" }),
+    );
+  });
+  ipcRenderer.on(HISTORY_CHANGED_CHANNEL, (_event, detail) => {
+    const changes = Array.isArray(detail) && detail.every(id => typeof id === "string") ? detail : undefined;
+    historySearch.invalidate(changes);
+    thumbnailService.invalidateRecordIndex();
+    shelfWindows.notifyHistoryChanged(changes);
   });
   ipcRenderer.on(WINDOW_PREFERENCES_CHANGED_CHANNEL, () => {
     shelfWindows.notifyWindowPreferencesChanged();
@@ -574,22 +668,43 @@ if (isPrimaryWindow) {
 }
 
 const bridge: PasteboardProBridge = {
-  getPlatformCapabilities: () => ({
-    platform: process.platform,
-    supportsGlobalPasteQueue: process.platform === "darwin",
-    supportsQuickLook: process.platform === "darwin" || process.platform === "win32" || process.platform === "linux",
-    supportsSystemOcr: true,
-    supportsImageRotation: process.platform === "darwin" || process.platform === "win32" || process.platform === "linux",
-  }),
+  getHostCompatibility: () => hostCompatibility,
+  getPlatformCapabilities: () => platformCapabilities,
+  captureScreenshot: () =>
+    importScreenCapture(
+      ztools,
+      nativeImage as NativeImageApi & ScreenshotNativeImageApi,
+      clipboard,
+      {
+        canImport: async () => {
+          const privacy = await privacyStore.get();
+          return !isCapturePaused(privacy.pause);
+        },
+      },
+    ),
   async searchHistory(query = "", limit = 1_000) {
     const normalizedLimit = Math.max(1, Math.min(10_000, Math.floor(limit)));
-    const [result, records] = await Promise.all([
-      store.search(query, normalizedLimit),
-      store.listRecords(),
-    ]);
+    const { result, records } = await store.searchWithRecords(query, normalizedLimit);
     nativeFileDragService.refresh(records);
     return result;
   },
+  async searchHistoryPage(request) {
+    const page = await (historyRpc === undefined ? historySearch.page(request) : historyRpc.page(request));
+    for (const item of page.items) rememberRecord(ztools.db.promises, item.id, `pasteboard-pro:record:${item.contentFingerprint}`);
+    return page;
+  },
+  async getHistoryItem(itemId, fingerprint) {
+    if (fingerprint !== undefined) rememberRecord(ztools.db.promises, itemId, `pasteboard-pro:record:${fingerprint}`);
+    return (await store.findRecordByItemId(itemId))?.item;
+  },
+  async reorderHistory(request, pinboardId) {
+    const scope = listOrderScope(pinboardId);
+    const orders = await listOrderStore.get();
+    const ids = await historySearch.order({
+      ...(pinboardId === undefined ? {} : { pinboardId }), orderedIds: orders[scope] ?? [],
+    });
+    return listOrderStore.put(scope, reorderItemGroupIds(ids, request.sourceIds, request.targetId, request.position));
+  },
   getPrivacySettings: () => privacyStore.get(),
   async savePrivacySettings(settings) {
     await privacyStore.put(settings);
@@ -857,3 +972,4 @@ const bridge: PasteboardProBridge = {
 };
 
 (window as Window & { pasteboardPro?: PasteboardProBridge }).pasteboardPro = bridge;
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/list-order-store.ts b/plugins/pasteboard-pro/apps/ztools/preload/list-order-store.ts
index 5b0c77b1e..51a67e208 100644
--- a/plugins/pasteboard-pro/apps/ztools/preload/list-order-store.ts
+++ b/plugins/pasteboard-pro/apps/ztools/preload/list-order-store.ts
@@ -3,7 +3,7 @@ import type { ZToolsDocumentDatabase } from "./clipboard-store";
 export type ListOrders = Readonly<Record<string, readonly string[]>>;
 
 const LIST_ORDER_ID = "pasteboard-pro:settings:list-orders";
-const MAX_ORDERED_ITEMS = 10_000;
+const MAX_ORDERED_ITEMS = 100_000;
 const MAX_SCOPES = 258;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/native-file-drag.ts b/plugins/pasteboard-pro/apps/ztools/preload/native-file-drag.ts
index 3ec0f827c..d677eef92 100644
--- a/plugins/pasteboard-pro/apps/ztools/preload/native-file-drag.ts
+++ b/plugins/pasteboard-pro/apps/ztools/preload/native-file-drag.ts
@@ -1,9 +1,10 @@
+import { statSync } from "node:fs";
 import path from "node:path";
 
 import type { CanonicalClipboardRecord } from "./clipboard-store";
 
 type NativeFileDragHost = Readonly<{
-  startDrag(file: string | string[]): void;
+  startDrag?(file: string | string[]): void;
 }>;
 
 type NativeFileDragStore = Readonly<{
@@ -16,6 +17,13 @@ export class NativeFileDragService {
   constructor(
     private readonly store: NativeFileDragStore,
     private readonly host: NativeFileDragHost,
+    private readonly isFile: (filePath: string) => boolean = (filePath) => {
+      try {
+        return statSync(filePath).isFile();
+      } catch {
+        return false;
+      }
+    },
   ) {}
 
   refresh(records: readonly CanonicalClipboardRecord[]): void {
@@ -32,7 +40,14 @@ export class NativeFileDragService {
 
   start(itemId: string): boolean {
     const filePaths = this.paths.get(itemId);
-    if (filePaths === undefined) return false;
+    if (
+      filePaths === undefined ||
+      this.host.startDrag === undefined ||
+      filePaths.some((filePath) => !this.isFile(filePath))
+    ) {
+      this.paths.delete(itemId);
+      return false;
+    }
     try {
       this.host.startDrag(filePaths.length === 1 ? filePaths[0]! : [...filePaths]);
       return true;
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/plugin-data-migration.ts b/plugins/pasteboard-pro/apps/ztools/preload/plugin-data-migration.ts
new file mode 100644
index 000000000..796a96afc
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/plugin-data-migration.ts
@@ -0,0 +1,112 @@
+import { createHash } from "node:crypto";
+import { cp, lstat, mkdir, readFile, readdir, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import type { PasteboardProDataPaths } from "./plugin-data";
+
+type MigrationDatabase = Readonly<{
+  allDocs?: (options: Readonly<Record<string, unknown>>) => Promise<unknown>;
+  put: (document: Record<string, unknown>) => Promise<unknown>;
+}>;
+
+function inside(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+
+async function assertSafeTree(root: string): Promise<void> {
+  for (const entry of await readdir(root, { withFileTypes: true })) {
+    const candidate = path.join(root, entry.name);
+    const status = await lstat(candidate);
+    if (status.isSymbolicLink()) throw new TypeError("PasteboardPro 数据迁移不允许符号链接");
+    if (status.isDirectory()) await assertSafeTree(candidate);
+    else if (!status.isFile()) throw new TypeError("PasteboardPro 数据迁移只允许普通文件和目录");
+  }
+}
+
+async function fileDigest(filePath: string): Promise<string> {
+  return createHash("sha256").update(await readFile(filePath)).digest("hex");
+}
+
+async function copyAndVerify(source: string, destination: string): Promise<boolean> {
+  await mkdir(destination, { recursive: true });
+  for (const entry of await readdir(source, { withFileTypes: true })) {
+    const from = path.join(source, entry.name);
+    const to = path.join(destination, entry.name);
+    try { await stat(to); } catch { await cp(from, to, { recursive: true, force: false, errorOnExist: true }); }
+    const [sourceStatus, destinationStatus] = await Promise.all([lstat(from), lstat(to)]);
+    if (sourceStatus.isDirectory() !== destinationStatus.isDirectory()) return false;
+    if (sourceStatus.isDirectory()) {
+      if (!(await copyAndVerify(from, to))) return false;
+    } else if (!sourceStatus.isFile() || !destinationStatus.isFile()
+      || sourceStatus.size !== destinationStatus.size
+      || (await fileDigest(from)) !== (await fileDigest(to))) return false;
+  }
+  return true;
+}
+
+function documents(result: unknown): Record<string, any>[] {
+  if (Array.isArray(result)) return result.filter((value): value is Record<string, any> => value !== null && typeof value === "object");
+  if (!result || typeof result !== "object") return [];
+  const rows = (result as { rows?: unknown }).rows;
+  return Array.isArray(rows)
+    ? rows.flatMap((row) => row && typeof row === "object" && (row as any).doc ? [(row as any).doc] : [])
+    : [];
+}
+
+function failedResult(result: unknown): boolean {
+  if (!result || typeof result !== "object") return false;
+  const value = result as Record<string, unknown>;
+  return value.error === true || typeof value.error === "string" || value.ok === false
+    || (Number.isFinite(Number(value.status)) && Number(value.status) >= 400);
+}
+
+function migratedPath(filePath: unknown, legacyRoot: string, blobRoot: string): unknown {
+  if (typeof filePath !== "string") return filePath;
+  const absolute = path.resolve(filePath);
+  return inside(legacyRoot, absolute) ? path.join(blobRoot, path.relative(legacyRoot, absolute)) : filePath;
+}
+
+async function rewriteDatabasePaths(database: MigrationDatabase, legacyRoots: readonly string[], blobRoot: string): Promise<void> {
+  if (database.allDocs === undefined) throw new TypeError("ZTools database does not expose allDocs for pluginData migration");
+  const result = await database.allDocs({ include_docs: true, startkey: "pasteboard-pro:record:", endkey: "pasteboard-pro:record:\uffff" });
+  if (failedResult(result)) throw new Error("PasteboardPro 迁移读取数据库失败");
+  for (const document of documents(result)) {
+    const record = document.record;
+    const origin = record?.origin;
+    if (!origin || typeof origin !== "object") continue;
+    let imagePath = origin.imagePath;
+    for (const legacyRoot of legacyRoots) imagePath = migratedPath(imagePath, legacyRoot, blobRoot);
+    if (imagePath === origin.imagePath) continue;
+    const putResult = await database.put({ ...document, record: { ...record, origin: { ...origin, imagePath } } });
+    if (failedResult(putResult)) throw new Error("PasteboardPro 迁移更新附件路径失败");
+  }
+}
+
+export async function migratePasteboardProPluginData(database: MigrationDatabase, paths: PasteboardProDataPaths): Promise<void> {
+  if (!paths.usesPluginData || paths.legacyBlobRoots.length === 0) return;
+  const existingRoots: string[] = [];
+  for (const legacyRoot of paths.legacyBlobRoots) {
+    try {
+      if (!(await stat(legacyRoot)).isDirectory()) continue;
+      await assertSafeTree(legacyRoot);
+      if (!(await copyAndVerify(legacyRoot, paths.blobRoot))) throw new Error("PasteboardPro 旧附件校验失败");
+      existingRoots.push(path.resolve(legacyRoot));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+  if (existingRoots.length === 0) return;
+  await rewriteDatabasePaths(database, existingRoots, paths.blobRoot);
+  for (const legacyRoot of existingRoots) {
+    await rm(legacyRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    try { await stat(legacyRoot); throw new Error("PasteboardPro 旧附件目录清理失败"); } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+    try { await rmdir(path.dirname(legacyRoot)); } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "ENOENT" && code !== "ENOTEMPTY") throw error;
+    }
+  }
+  await writeFile(path.join(paths.dataRoot, ".pasteboard-pro-plugin-data-migration-v1.json"), JSON.stringify({ version: 1, completedAt: new Date().toISOString() }));
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/plugin-data.ts b/plugins/pasteboard-pro/apps/ztools/preload/plugin-data.ts
new file mode 100644
index 000000000..9ba0833fd
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/plugin-data.ts
@@ -0,0 +1,54 @@
+import os from "node:os";
+import path from "node:path";
+
+type PluginDataHost = Readonly<{
+  getPath?: (name: string) => unknown;
+}>;
+
+export type PasteboardProDataPaths = Readonly<{
+  dataRoot: string;
+  blobRoot: string;
+  legacyBlobRoots: readonly string[];
+  usesPluginData: boolean;
+}>;
+
+export function legacyPasteboardProDataRoot(homeDirectory = os.homedir()): string {
+  return path.join(homeDirectory, ".pasteboard-pro", "ztools");
+}
+
+export function resolvePasteboardProDataPaths(
+  host: PluginDataHost,
+  legacyDataRoot = legacyPasteboardProDataRoot(),
+): PasteboardProDataPaths {
+  let pluginDataRoot: string | undefined;
+  try {
+    const candidate = host.getPath?.("pluginData");
+    if (typeof candidate === "string" && path.isAbsolute(candidate)) {
+      pluginDataRoot = path.resolve(candidate);
+    }
+  } catch {
+    pluginDataRoot = undefined;
+  }
+  const resolvedLegacyRoot = path.resolve(legacyDataRoot);
+  const dataRoot = pluginDataRoot ?? resolvedLegacyRoot;
+  const blobRoot = path.join(dataRoot, ...(pluginDataRoot === undefined ? ["blobs"] : ["sync", "blobs"]));
+  const legacyBlobRoot = path.join(resolvedLegacyRoot, "blobs");
+  return {
+    dataRoot,
+    blobRoot,
+    legacyBlobRoots:
+      path.resolve(blobRoot) === path.resolve(legacyBlobRoot) ? [] : [legacyBlobRoot],
+    usesPluginData: pluginDataRoot !== undefined,
+  };
+}
+
+export function resolvePasteboardBlobRoots(
+  host: PluginDataHost,
+  homeDirectory = os.homedir(),
+): Readonly<{ primary: string; legacy: readonly string[] }> {
+  const paths = resolvePasteboardProDataPaths(
+    host,
+    legacyPasteboardProDataRoot(homeDirectory),
+  );
+  return { primary: paths.blobRoot, legacy: paths.legacyBlobRoots };
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/record-index.ts b/plugins/pasteboard-pro/apps/ztools/preload/record-index.ts
new file mode 100644
index 000000000..390b5ef7b
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/record-index.ts
@@ -0,0 +1,33 @@
+/** Shared by all canonical stores in one preload (including the sync store). */
+const indexes = new WeakMap<object, {
+  documents: Map<string, string>;
+  changes: Set<string>;
+}>();
+
+function index(database: object) {
+  let value = indexes.get(database);
+  if (value === undefined) {
+    value = { documents: new Map(), changes: new Set() };
+    indexes.set(database, value);
+  }
+  return value;
+}
+
+export function rememberRecord(database: object, itemId: string, documentId: string): void {
+  index(database).documents.set(itemId, documentId);
+}
+
+export function recordDocumentFor(database: object, itemId: string): string | undefined {
+  return index(database).documents.get(itemId);
+}
+
+export function markRecordChanged(database: object, documentId: string): void {
+  index(database).changes.add(documentId);
+}
+
+export function takeRecordChanges(database: object): string[] {
+  const value = index(database);
+  const changes = [...value.changes];
+  value.changes.clear();
+  return changes;
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/screenshot-import.ts b/plugins/pasteboard-pro/apps/ztools/preload/screenshot-import.ts
new file mode 100644
index 000000000..27183014b
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/preload/screenshot-import.ts
@@ -0,0 +1,134 @@
+import type { NativeImageLike } from "./thumbnail";
+
+export type ScreenCaptureBounds = Readonly<{
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}>;
+
+export type ScreenCaptureImportResult = Readonly<{
+  bounds?: ScreenCaptureBounds;
+}>;
+
+type ScreenCaptureHost = Readonly<{
+  screenCapture?: (
+    callback: (image: unknown, bounds?: unknown) => void,
+    autoConfirm?: boolean,
+  ) => void | Promise<unknown>;
+}>;
+
+export const SCREEN_CAPTURE_UNAVAILABLE_MESSAGE =
+  "当前 ZTools 版本不支持截图导入";
+export const SCREEN_CAPTURE_PAUSED_MESSAGE =
+  "剪贴板捕获已暂停，请先继续捕获";
+
+export type ScreenCaptureImportOptions = Readonly<{
+  canImport?: () => boolean | Promise<boolean>;
+}>;
+
+export type ScreenshotNativeImageApi = Readonly<{
+  createFromDataURL(value: string): NativeImageLike;
+}>;
+
+export type ScreenshotClipboard = Readonly<{
+  writeImage(image: NativeImageLike): void;
+}>;
+
+export function importCapturedScreenshot(
+  imageDataUrl: string,
+  dependencies: Readonly<{
+    nativeImage: ScreenshotNativeImageApi;
+    clipboard: ScreenshotClipboard;
+  }>,
+): boolean {
+  if (!/^data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/]+=*$/iu.test(imageDataUrl)) {
+    return false;
+  }
+  try {
+    const image = dependencies.nativeImage.createFromDataURL(imageDataUrl);
+    if (image.isEmpty()) return false;
+    dependencies.clipboard.writeImage(image);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function captureBounds(value: unknown): ScreenCaptureBounds | undefined {
+  if (value === null || typeof value !== "object") return undefined;
+  const candidate = value as Record<string, unknown>;
+  if (
+    typeof candidate.x !== "number" ||
+    typeof candidate.y !== "number" ||
+    typeof candidate.width !== "number" ||
+    typeof candidate.height !== "number" ||
+    candidate.width <= 0 ||
+    candidate.height <= 0
+  ) return undefined;
+  return {
+    x: candidate.x,
+    y: candidate.y,
+    width: candidate.width,
+    height: candidate.height,
+  };
+}
+
+export async function importScreenCapture(
+  host: ScreenCaptureHost,
+  nativeImage: ScreenshotNativeImageApi,
+  clipboard: ScreenshotClipboard,
+  options: ScreenCaptureImportOptions = {},
+): Promise<ScreenCaptureImportResult> {
+  const screenCapture = host.screenCapture;
+  if (screenCapture === undefined) {
+    throw new Error(SCREEN_CAPTURE_UNAVAILABLE_MESSAGE);
+  }
+  if (options.canImport !== undefined && !(await options.canImport())) {
+    throw new Error(SCREEN_CAPTURE_PAUSED_MESSAGE);
+  }
+  return new Promise<ScreenCaptureImportResult>((resolve, reject) => {
+    let settled = false;
+    const complete = (image: unknown, rawBounds?: unknown): void => {
+      if (settled) return;
+      settled = true;
+      void (async () => {
+        const bounds = captureBounds(rawBounds);
+        if (rawBounds !== undefined && rawBounds !== null && bounds === undefined) {
+          throw new TypeError("截图区域信息无效");
+        }
+        if (options.canImport !== undefined && !(await options.canImport())) {
+          throw new Error(SCREEN_CAPTURE_PAUSED_MESSAGE);
+        }
+        if (typeof image === "string") {
+          if (!importCapturedScreenshot(image, { nativeImage, clipboard })) {
+            throw new TypeError("截图图像无效");
+          }
+        } else {
+          const capturedImage = image as NativeImageLike;
+          if (
+            capturedImage === null ||
+            typeof capturedImage !== "object" ||
+            capturedImage.isEmpty()
+          ) throw new TypeError("截图图像无效");
+          clipboard.writeImage(capturedImage);
+        }
+        resolve(bounds === undefined ? {} : { bounds });
+      })().catch(reject);
+    };
+    try {
+      const result = screenCapture(complete, false);
+      if (result !== undefined && typeof (result as PromiseLike<unknown>).then === "function") {
+        void Promise.resolve(result).catch((error: unknown) => {
+          if (!settled) {
+            settled = true;
+            reject(error);
+          }
+        });
+      }
+    } catch (error) {
+      settled = true;
+      reject(error);
+    }
+  });
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/sync-repository.ts b/plugins/pasteboard-pro/apps/ztools/preload/sync-repository.ts
index f3c4671ac..5bee22892 100644
--- a/plugins/pasteboard-pro/apps/ztools/preload/sync-repository.ts
+++ b/plugins/pasteboard-pro/apps/ztools/preload/sync-repository.ts
@@ -1,5 +1,17 @@
 import { createHash } from "node:crypto";
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { constants as fileSystemConstants } from "node:fs";
+import {
+  lstat,
+  mkdir,
+  open,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  stat,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
@@ -23,6 +35,8 @@ import {
 
 const TOMBSTONE_PREFIX = "pasteboard-pro:tombstone:";
 const MAX_BLOB_BYTES = 100 * 1_024 * 1_024;
+const MANAGED_BLOB_FILE_PATTERN =
+  /^([0-9a-f]{64})\.(png|jpg|webp|tiff|pdf|rtf|rtfd|bin)$/u;
 
 function blobExtension(mediaType: string): string {
   return (
@@ -55,6 +69,118 @@ function databaseStatus(error: unknown, status: number): boolean {
   return isRecord(error) && (error.status === status || error.statusCode === status);
 }
 
+function missingFile(error: unknown): boolean {
+  return isRecord(error) && error.code === "ENOENT";
+}
+
+function insideRoot(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return (
+    relative.length > 0 &&
+    !relative.startsWith(`..${path.sep}`) &&
+    relative !== ".." &&
+    !path.isAbsolute(relative)
+  );
+}
+
+type PathIdentity = Readonly<{
+  path: string;
+  device: number;
+  inode: number;
+}>;
+
+async function checkedPathChain(
+  root: string,
+  target: string,
+): Promise<readonly PathIdentity[] | undefined> {
+  const relative = path.relative(root, target);
+  if (!insideRoot(root, target)) {
+    throw new TypeError("Refusing to inspect a blob outside its managed root");
+  }
+  const entries = [root];
+  let cursor = root;
+  for (const segment of relative.split(path.sep)) {
+    cursor = path.join(cursor, segment);
+    entries.push(cursor);
+  }
+
+  const identities: PathIdentity[] = [];
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index]!;
+    let status;
+    try {
+      status = await lstat(entry);
+    } catch (error) {
+      if (missingFile(error)) return undefined;
+      throw error;
+    }
+    if (status.isSymbolicLink()) {
+      throw new TypeError(
+        index === 0
+          ? "Refusing to delete through a symbolic-link blob root"
+          : "Refusing to delete through a symbolic link",
+      );
+    }
+    const isTarget = index === entries.length - 1;
+    if (!isTarget && !status.isDirectory()) {
+      throw new TypeError("Blob parent path must contain only directories");
+    }
+    if (isTarget && !status.isFile()) {
+      throw new TypeError("Managed blob target must be a regular file");
+    }
+    identities.push({
+      path: entry,
+      device: status.dev,
+      inode: status.ino,
+    });
+  }
+  return identities;
+}
+
+function samePathChain(
+  before: readonly PathIdentity[],
+  after: readonly PathIdentity[],
+): boolean {
+  return (
+    before.length === after.length &&
+    before.every((entry, index) => {
+      const candidate = after[index];
+      return (
+        candidate !== undefined &&
+        entry.path === candidate.path &&
+        entry.device === candidate.device &&
+        entry.inode === candidate.inode
+      );
+    })
+  );
+}
+
+function managedBlobDigest(root: string, filePath: string): string | undefined {
+  const relative = path.relative(root, filePath);
+  const segments = relative.split(path.sep);
+  if (segments.length !== 2) return undefined;
+  const match = MANAGED_BLOB_FILE_PATTERN.exec(segments[1]!);
+  if (match === null || segments[0] !== match[1]!.slice(0, 2)) return undefined;
+  return match[1];
+}
+
+function assertBlobIdentifier(blobId: string): void {
+  if (blobId.length === 0) {
+    throw new TypeError("Blob id must be non-empty");
+  }
+  if (blobId.includes("\0")) {
+    throw new TypeError("Blob id cannot contain a NUL byte");
+  }
+  if (
+    blobId === "." ||
+    blobId === ".." ||
+    blobId.includes("/") ||
+    blobId.includes("\\")
+  ) {
+    throw new TypeError("Blob id must be a safe object identifier");
+  }
+}
+
 function revision(value: unknown): string | undefined {
   return isRecord(value) && typeof value._rev === "string" ? value._rev : undefined;
 }
@@ -106,6 +232,8 @@ export class ZToolsSyncEntityRepository implements SyncEntityRepository {
       "ztools",
       "blobs",
     ),
+    private readonly legacyBlobRoots: readonly string[] = [],
+    private readonly ready: Promise<void> = Promise.resolve(),
   ) {
     this.clipboard = new ZToolsCanonicalClipboardStore(database, { deviceId });
     this.pinboards = new ZToolsPinboardStore(database, { deviceId });
@@ -130,6 +258,7 @@ export class ZToolsSyncEntityRepository implements SyncEntityRepository {
   }
 
   async listEntities(): Promise<SyncEntity[]> {
+    await this.ready;
     const preferences = await this.preferences.getSyncEntity();
     const entities: SyncEntity[] = [
       ...(await this.clipboard.listRecords()).map((record) => record.item),
@@ -196,6 +325,7 @@ export class ZToolsSyncEntityRepository implements SyncEntityRepository {
   }
 
   async applyEntities(entities: readonly SyncEntity[]): Promise<void> {
+    await this.ready;
     for (const entity of entities) {
       if ("deleted" in entity) {
         if (entity.entityType === "paste_item") {
@@ -217,6 +347,7 @@ export class ZToolsSyncEntityRepository implements SyncEntityRepository {
   }
 
   async readBlob(blobId: string): Promise<SyncBlob | undefined> {
+    await this.ready;
     const record = (await this.clipboard.listRecords()).find(
       (candidate) => candidate.item.payload.blobId === blobId,
     );
@@ -246,6 +377,7 @@ export class ZToolsSyncEntityRepository implements SyncEntityRepository {
     bytes: Uint8Array,
     mediaType: string,
   ): Promise<Readonly<{ id: string; imagePath: string; blobBytes: number }>> {
+    await this.ready;
     if (bytes.byteLength > MAX_BLOB_BYTES) {
       throw new RangeError("Blob exceeds 100 MiB");
     }
@@ -259,19 +391,117 @@ export class ZToolsSyncEntityRepository implements SyncEntityRepository {
   }
 
   async deleteLocalBlob(input: Readonly<{ blobId: string; filePath: string }>): Promise<void> {
-    if (input.blobId.length === 0) {
-      throw new TypeError("Blob id must be non-empty");
-    }
-    const root = path.resolve(this.blobRoot);
+    await this.ready;
+    assertBlobIdentifier(input.blobId);
     const filePath = path.resolve(input.filePath);
-    const relative = path.relative(root, filePath);
-    if (relative.length === 0 || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    const managedRoots = [this.blobRoot, ...this.legacyBlobRoots].map((root) => path.resolve(root));
+    const lexicalRoot = managedRoots.find((root) => insideRoot(root, filePath));
+    if (lexicalRoot === undefined) {
       throw new TypeError("Refusing to delete a blob outside the plugin blob directory");
     }
-    await rm(filePath, { force: true });
+
+    const initialChain = await checkedPathChain(lexicalRoot, filePath);
+    if (initialChain === undefined) return;
+    const expectedDigest = managedBlobDigest(lexicalRoot, filePath);
+    if (expectedDigest === undefined) {
+      throw new TypeError("Refusing to delete a blob outside the content-addressed layout");
+    }
+
+    const [canonicalRoot, canonicalFile] = await Promise.all([
+      realpath(lexicalRoot),
+      realpath(filePath),
+    ]);
+    if (!insideRoot(canonicalRoot, canonicalFile)) {
+      throw new TypeError("Refusing to delete a blob outside the canonical plugin blob directory");
+    }
+    if (managedBlobDigest(canonicalRoot, canonicalFile) !== expectedDigest) {
+      throw new TypeError("Canonical blob path does not match its content-addressed layout");
+    }
+
+    const noFollow = process.platform === "win32"
+      ? 0
+      : fileSystemConstants.O_NOFOLLOW;
+    const handle = await open(
+      canonicalFile,
+      fileSystemConstants.O_RDONLY | noFollow,
+    );
+    let handleOpen = true;
+    try {
+      const openedStatus = await handle.stat();
+      if (!openedStatus.isFile()) {
+        throw new TypeError("Managed blob target must remain a regular file");
+      }
+      if (openedStatus.size > MAX_BLOB_BYTES) {
+        throw new RangeError("Managed blob exceeds 100 MiB");
+      }
+      const actualDigest = createHash("sha256")
+        .update(await handle.readFile())
+        .digest("hex");
+      if (actualDigest !== expectedDigest) {
+        throw new TypeError("Managed blob content does not match its path digest");
+      }
+
+      const remainingRecords = await this.clipboard.listRecords();
+      for (const record of remainingRecords) {
+        const recordPath = record.origin.imagePath;
+        if (recordPath === undefined) continue;
+        let canonicalRecordPath: string;
+        try {
+          canonicalRecordPath = await realpath(recordPath);
+        } catch (error) {
+          if (missingFile(error)) continue;
+          throw error;
+        }
+        if (
+          canonicalRecordPath === canonicalFile ||
+          record.origin.pluginBlobId === input.blobId
+        ) {
+          return;
+        }
+      }
+
+      const finalChain = await checkedPathChain(lexicalRoot, filePath);
+      if (finalChain === undefined || !samePathChain(initialChain, finalChain)) {
+        throw new TypeError("Managed blob path changed during deletion validation");
+      }
+      const [finalCanonicalRoot, finalCanonicalFile] = await Promise.all([
+        realpath(lexicalRoot),
+        realpath(filePath),
+      ]);
+      if (
+        finalCanonicalRoot !== canonicalRoot ||
+        finalCanonicalFile !== canonicalFile
+      ) {
+        throw new TypeError("Managed blob canonical path changed during deletion validation");
+      }
+      const finalStatus = await lstat(finalCanonicalFile);
+      if (
+        finalStatus.isSymbolicLink() ||
+        !finalStatus.isFile() ||
+        finalStatus.dev !== openedStatus.dev ||
+        finalStatus.ino !== openedStatus.ino
+      ) {
+        throw new TypeError("Managed blob file changed during deletion validation");
+      }
+
+      if (process.platform === "win32") {
+        await handle.close();
+        handleOpen = false;
+      }
+      // Node does not expose unlinkat(2), so the final pathname unlink cannot
+      // be made atomic with the verified file descriptor. The content-addressed
+      // whitelist plus repeated parent/canonical/inode checks fail closed for
+      // untrusted metadata and ordinary path replacement; a malicious process
+      // racing this exact final syscall under the same OS account is outside
+      // this API's enforceable boundary.
+      await unlink(finalCanonicalFile);
+    } finally {
+      if (handleOpen) await handle.close();
+    }
   }
 
   async writeBlob(blob: SyncBlob): Promise<void> {
+    await this.ready;
     if (blob.bytes.byteLength > MAX_BLOB_BYTES) {
       throw new RangeError(`Blob ${blob.id} exceeds 100 MiB`);
     }
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/thumbnail.ts b/plugins/pasteboard-pro/apps/ztools/preload/thumbnail.ts
index bb13f9ce9..be92b3460 100644
--- a/plugins/pasteboard-pro/apps/ztools/preload/thumbnail.ts
+++ b/plugins/pasteboard-pro/apps/ztools/preload/thumbnail.ts
@@ -22,6 +22,7 @@ export type NativeImageApi = Readonly<{
 
 export type ThumbnailRecordStore = Readonly<{
   listRecords(): Promise<CanonicalClipboardRecord[]>;
+  findRecordByItemId?(itemId: string): Promise<CanonicalClipboardRecord | undefined>;
 }>;
 
 const THUMBNAIL_WIDTH = 480;
@@ -82,13 +83,13 @@ export class ThumbnailService {
     const requestedIds = uniqueItemIds(itemIds);
     if (requestedIds.length === 0) return [];
 
-    const byId = await this.recordsById();
+    const byId = this.store.findRecordByItemId === undefined ? await this.recordsById() : undefined;
 
     const values = await concurrentMap(
       requestedIds,
       GENERATION_CONCURRENCY,
       async (itemId) => {
-        const record = byId.get(itemId);
+        const record = byId === undefined ? await this.store.findRecordByItemId!(itemId) : byId.get(itemId);
         return record === undefined ? null : await this.cachedThumbnail(record);
       },
     );
diff --git a/plugins/pasteboard-pro/apps/ztools/preload/window.ts b/plugins/pasteboard-pro/apps/ztools/preload/window.ts
index 8f26d3bff..0cfc433c7 100644
--- a/plugins/pasteboard-pro/apps/ztools/preload/window.ts
+++ b/plugins/pasteboard-pro/apps/ztools/preload/window.ts
@@ -1,9 +1,11 @@
+import type { HistoryReply } from "./history-rpc";
 import {
   clampShelfBounds,
   type DockEdge,
   type Rect,
 } from "@pasteboard-pro/design-tokens";
 import type { PasteStackState } from "@pasteboard-pro/core";
+import { waitForWindowReadyScript } from "../window-ready";
 
 export type ShelfDisplay = Readonly<{
   id: string | number;
@@ -49,7 +51,9 @@ export interface BrowserWindowHandle {
   show(): void;
   focus(): void;
   close(): void;
-  setBounds(bounds: Rect): void;
+  setBounds(bounds: Rect, animate?: boolean): void;
+  getBounds?(): Rect;
+  setOpacity?(opacity: number): void;
   setContentProtection(enabled: boolean): void;
 }
 
@@ -86,17 +90,20 @@ const PANEL_SIZES: Readonly<Record<AuxiliaryPanel, Readonly<{ width: number; hei
   editor: { width: 660, height: 520 },
 };
 
+const requestedWindowBounds = new WeakMap<BrowserWindowHandle, BrowserWindowOptions>();
+
 function setWindowBounds(
   handle: BrowserWindowHandle,
   options: BrowserWindowOptions,
 ): void {
   if (handle.isDestroyed()) return;
+  requestedWindowBounds.set(handle, options);
   handle.setBounds({
     x: options.x,
     y: options.y,
     width: options.width,
     height: options.height,
-  });
+  }, false);
 }
 
 function scheduleBoundsCorrection(
@@ -104,11 +111,63 @@ function scheduleBoundsCorrection(
   options: BrowserWindowOptions,
 ): void {
   for (const delay of [50, 250, 750]) {
-    const timer = globalThis.setTimeout(() => setWindowBounds(handle, options), delay);
+    const timer = globalThis.setTimeout(() => {
+      if (handle.isDestroyed()) return;
+      const target = requestedWindowBounds.get(handle) ?? options;
+      const actual = handle.getBounds?.();
+      if (actual !== undefined && actual.x === target.x && actual.y === target.y &&
+        actual.width === target.width && actual.height === target.height) return;
+      setWindowBounds(handle, target);
+    }, delay);
     (timer as unknown as { unref?: () => void }).unref?.();
   }
 }
 
+// On macOS, show() can move an off-primary-screen window even when its
+// hidden bounds are correct. Materialize it at zero opacity, then correct the
+// native frame after show/focus before exposing any pixels. Older hosts without
+// opacity support still receive the immediate post-show correction.
+function revealWindow(handle: BrowserWindowHandle): void {
+  handle.setOpacity?.(0);
+  handle.show();
+  handle.focus();
+  const bounds = requestedWindowBounds.get(handle);
+  if (bounds !== undefined) setWindowBounds(handle, bounds);
+  handle.setOpacity?.(1);
+}
+
+// ZTools invokes its DOM-ready callback once. Never reload or reveal the window
+// there: the renderer still needs to load its preferences and initial content.
+function createReadyWindow(
+  host: ShelfWindowHost,
+  url: string,
+  options: BrowserWindowOptions,
+  isCurrent: (handle: BrowserWindowHandle) => boolean,
+  onReady: (handle: BrowserWindowHandle) => void,
+): BrowserWindowHandle {
+  let waiting = false;
+  const handle = host.createBrowserWindow(url, options, () => {
+    if (waiting) return;
+    waiting = true;
+    // Also supports hosts that invoke the callback before returning the handle.
+    queueMicrotask(async () => {
+      if (handle.isDestroyed() || !isCurrent(handle)) return;
+      try {
+        await handle.webContents.executeJavaScript(waitForWindowReadyScript);
+        if (handle.isDestroyed() || !isCurrent(handle)) return;
+        onReady(handle);
+        revealWindow(handle);
+      } catch (error) {
+        // A closed/replaced window must never steal focus when its work settles.
+        if (handle.isDestroyed() || !isCurrent(handle)) return;
+        console.error("Paste window initialization failed", error);
+        handle.close();
+      }
+    });
+  });
+  return handle;
+}
+
 function preferredBounds(display: ShelfDisplay, edge: DockEdge): Rect {
   const { workArea } = display;
 
@@ -243,6 +302,7 @@ export function resolveShelfPlacement(
 }
 
 export class ShelfWindowManager {
+  private readonly readyHandles = new WeakSet<BrowserWindowHandle>();
   private current: BrowserWindowHandle | undefined;
   private currentEdge: DockEdge | undefined;
 
@@ -281,8 +341,9 @@ export class ShelfWindowManager {
       setWindowBounds(this.current, windowOptions);
       scheduleBoundsCorrection(this.current, windowOptions);
       this.current.setContentProtection(options.contentProtection);
-      this.current.show();
-      this.current.focus();
+      if (this.readyHandles.has(this.current)) {
+        revealWindow(this.current);
+      }
       return this.current;
     }
     if (this.current !== undefined && !this.current.isDestroyed()) {
@@ -291,41 +352,18 @@ export class ShelfWindowManager {
     this.current = undefined;
 
     const url = `index.html?shelf=1&dock=${encodeURIComponent(options.edge)}&display=${encodeURIComponent(String(display.id))}`;
-    let handle: BrowserWindowHandle | undefined;
-    let readyBeforeAssignment = false;
-    let preloadReloaded = false;
-    const finishOpening = (): void => {
-      if (handle === undefined) {
-        readyBeforeAssignment = true;
-        return;
-      }
-      if (!preloadReloaded) {
-        preloadReloaded = true;
-        void handle.webContents.executeJavaScript("window.location.reload()");
-        return;
-      }
-      setWindowBounds(handle, windowOptions);
-      handle.show();
-      handle.focus();
-      this.host.hideMainWindow(false);
-    };
-
-    handle = this.host.createBrowserWindow(
+    const handle = createReadyWindow(
+      this.host,
       url,
       windowOptions,
-      finishOpening,
+      (candidate) => this.current === candidate,
+      (candidate) => this.readyHandles.add(candidate),
     );
     this.current = handle;
     this.currentEdge = options.edge;
     setWindowBounds(handle, windowOptions);
     scheduleBoundsCorrection(handle, windowOptions);
     handle.setContentProtection(options.contentProtection);
-    handle.show();
-    handle.focus();
-
-    if (readyBeforeAssignment) {
-      finishOpening();
-    }
 
     return handle;
   }
@@ -344,10 +382,20 @@ export class ShelfWindowManager {
     }
   }
 
-  notifyHistoryChanged(): void {
+  notifyHistoryResult(result: HistoryReply): void {
+    if (this.current === undefined || this.current.isDestroyed()) return;
+    const detail = JSON.stringify(result).replaceAll("<", "\\u003c");
+    void this.current.webContents.executeJavaScript(
+      `window.dispatchEvent(new CustomEvent('pasteboard-pro:history-result', { detail: ${detail} }))`,
+    );
+  }
+
+  notifyHistoryChanged(changes?: readonly string[]): void {
     if (this.current === undefined || this.current.isDestroyed()) return;
     void this.current.webContents.executeJavaScript(
-      "window.dispatchEvent(new CustomEvent('pasteboard-pro:history-changed'))",
+      changes === undefined
+        ? "window.dispatchEvent(new CustomEvent('pasteboard-pro:history-changed'))"
+        : `window.dispatchEvent(new CustomEvent('pasteboard-pro:history-changed', { detail: ${JSON.stringify(changes).replaceAll("<", "\\u003c")} }))`,
     );
   }
 
@@ -368,6 +416,7 @@ export class ShelfWindowManager {
 }
 
 export class PanelWindowManager {
+  private readonly readyHandles = new WeakSet<BrowserWindowHandle>();
   private current:
     | Readonly<{ key: string; handle: BrowserWindowHandle }>
     | undefined;
@@ -396,8 +445,9 @@ export class PanelWindowManager {
     ) {
       setWindowBounds(this.current.handle, windowOptions);
       scheduleBoundsCorrection(this.current.handle, windowOptions);
-      this.current.handle.show();
-      this.current.handle.focus();
+      if (this.readyHandles.has(this.current.handle)) {
+        revealWindow(this.current.handle);
+      }
       return this.current.handle;
     }
 
@@ -406,38 +456,16 @@ export class PanelWindowManager {
     }
 
     const url = `index.html?${params.toString()}`;
-    let handle: BrowserWindowHandle | undefined;
-    let readyBeforeAssignment = false;
-    let preloadReloaded = false;
-    const finishOpening = (): void => {
-      if (handle === undefined) {
-        readyBeforeAssignment = true;
-        return;
-      }
-      if (!preloadReloaded) {
-        preloadReloaded = true;
-        void handle.webContents.executeJavaScript("window.location.reload()");
-        return;
-      }
-      setWindowBounds(handle, windowOptions);
-      handle.show();
-      handle.focus();
-    };
-
-    handle = this.host.createBrowserWindow(
+    const handle = createReadyWindow(
+      this.host,
       url,
       windowOptions,
-      finishOpening,
+      (candidate) => this.current?.handle === candidate,
+      (candidate) => this.readyHandles.add(candidate),
     );
     this.current = { key, handle };
     setWindowBounds(handle, windowOptions);
     scheduleBoundsCorrection(handle, windowOptions);
-    handle.show();
-    handle.focus();
-
-    if (readyBeforeAssignment) {
-      finishOpening();
-    }
 
     return handle;
   }
diff --git a/plugins/pasteboard-pro/apps/ztools/public/plugin.json b/plugins/pasteboard-pro/apps/ztools/public/plugin.json
index b7c11f391..1c1df09d6 100644
--- a/plugins/pasteboard-pro/apps/ztools/public/plugin.json
+++ b/plugins/pasteboard-pro/apps/ztools/public/plugin.json
@@ -4,7 +4,7 @@
   "title": "Paste剪切板",
   "description": "Paste 风格的本地剪贴板历史、分组、预览与连续粘贴队列",
   "author": "harris",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "main": "index.html",
   "preload": "preload.js",
   "unpack": "@(pasteboard-vision|paste-stack-key-monitor.py)",
@@ -17,6 +17,7 @@
   "features": [
     {
       "code": "pasteboard-pro",
+      "mainHide": true,
       "explain": "打开 Paste剪切板历史",
       "icon": "logo.png",
       "cmds": [
diff --git a/plugins/pasteboard-pro/apps/ztools/scripts/assemble-dist.mjs b/plugins/pasteboard-pro/apps/ztools/scripts/assemble-dist.mjs
index 084084916..ae8fd6890 100644
--- a/plugins/pasteboard-pro/apps/ztools/scripts/assemble-dist.mjs
+++ b/plugins/pasteboard-pro/apps/ztools/scripts/assemble-dist.mjs
@@ -35,6 +35,7 @@ export async function verifyAssembledPackage(root) {
     manifest.preload,
     manifest.logo,
     "package.json",
+    "history-worker.cjs",
     ...(includeVisionHelper ? ["pasteboard-vision"] : []),
   ]) {
     assert.equal(typeof relative, "string");
diff --git a/plugins/pasteboard-pro/apps/ztools/src/App.vue b/plugins/pasteboard-pro/apps/ztools/src/App.vue
index 1eaf7edf8..75339e84b 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/App.vue
+++ b/plugins/pasteboard-pro/apps/ztools/src/App.vue
@@ -1,8 +1,9 @@
 <script setup lang="ts">
-import { computed, nextTick, onBeforeUnmount, onMounted, reactive, ref } from "vue";
+import { computed, nextTick, onBeforeUnmount, onMounted, shallowReactive, ref } from "vue";
 
 import {
   PinboardSchema,
+  PasteItemSchema,
   type PasteItem,
   type PasteStackAction,
   type PasteStackState,
@@ -21,7 +22,10 @@ import {
   type WindowPreferences,
 } from "../preload/window-preferences";
 
+import { markWindowReady } from "../window-ready";
 import Shelf from "./components/Shelf.vue";
+import { createHistoryRefresh } from "./history-refresh";
+import { HistoryPager } from "./history-pager";
 import Preview from "./components/Preview.vue";
 import SettingsPanel from "./components/SettingsPanel.vue";
 import TextEditor from "./components/TextEditor.vue";
@@ -34,6 +38,12 @@ import {
 } from "./state";
 import { queryAfterTypeToSearch } from "./type-to-search";
 import { isListNavigationKey, shouldResumeListControl } from "./list-control-key";
+import { shelfKeyboardRoute } from "./keyboard-routing";
+import {
+  hasAnyCommandModifier,
+  matchesPrimaryShortcut,
+  resolveShortcutPlatform,
+} from "./platform-shortcuts";
 import { themeCssVariables } from "./theme";
 import {
   applyListOrder,
@@ -57,6 +67,14 @@ const panelMode =
     ? panel
     : undefined;
 const isShelfMode = params.get("shelf") === "1";
+const hostCompatibility = window.pasteboardPro?.getHostCompatibility();
+const requiresHostUpgrade = hostCompatibility?.supported === false;
+const platformCapabilities = window.pasteboardPro?.getPlatformCapabilities();
+const shortcutPlatform = resolveShortcutPlatform(
+  platformCapabilities?.platform,
+);
+const supportsScreenCapture =
+  platformCapabilities?.supportsScreenCapture === true;
 const dockValue = params.get("dock");
 const edge: DockEdge =
   dockValue === "top" ||
@@ -66,20 +84,31 @@ const edge: DockEdge =
     ? dockValue
     : "floating";
 
-const state = reactive(
+// State methods replace snapshots; avoid proxying every field of 10,000 records.
+const state = shallowReactive(
   createPasteboardState({
     items: [],
     dockEdge: edge,
+    shortcutPlatform,
   }),
 );
 const pinboards = ref<Pinboard[]>([]);
 const query = ref("");
+const pagedHistory = window.pasteboardPro?.searchHistoryPage !== undefined;
+const historyTotal = ref(0);
+const hasMoreHistory = ref(false);
+let queryTimer: ReturnType<typeof setTimeout> | undefined;
 const paused = ref(false);
+const canCaptureScreen = computed(
+  () => supportsScreenCapture && !paused.value,
+);
 const activePinboardId = ref<string>();
 const listOrders = ref<ListOrders>({});
 const listOrderSaving = ref(false);
 const previewItemId = ref<string>();
 const status = ref("本地历史已就绪");
+const startupError = ref<string>();
+const shelfView = ref<InstanceType<typeof Shelf>>();
 const syncSettings = ref<SyncSettings>(structuredClone(defaultSyncSettings));
 const privacySettings = ref<PrivacySettings>(structuredClone(defaultPrivacySettings));
 const windowPreferences = ref<WindowPreferences>(structuredClone(defaultWindowPreferences));
@@ -125,6 +154,7 @@ async function loadDevelopmentFixtures(): Promise<void> {
 
 const visibleItems = computed(() => {
   const items = state.visibleItems;
+  if (pagedHistory) return items;
   const pinboardId = activePinboardId.value;
   const filtered = pinboardId === undefined
     ? items
@@ -147,6 +177,15 @@ const focusedItem = computed<PasteItem | undefined>(() => {
 
 function updateQuery(value: string): void {
   query.value = value;
+  if (pagedHistory) {
+    clearTimeout(queryTimer);
+    // Invalidate the old query immediately; debounce only the next search.
+    historyPager?.invalidate();
+    state.replaceResolvedItems([]);
+    hasMoreHistory.value = false;
+    queryTimer = setTimeout(() => { queryTimer = undefined; void loadPagedHistory(false).catch(reportHistoryError); }, 120);
+    return;
+  }
   state.setQuery(value);
   state.restoreSelection(visibleItems.value.map((item) => item.id));
 }
@@ -180,12 +219,7 @@ function focusLatestItem(itemId: string): void {
 
 function focusListCard(itemId: string | undefined): void {
   if (itemId === undefined) return;
-  void nextTick(() => {
-    const card = [...document.querySelectorAll<HTMLElement>("[data-pb-item-id]")]
-      .find((candidate) => candidate.dataset.pbItemId === itemId);
-    card?.focus({ preventScroll: true });
-    card?.scrollIntoView({ block: "nearest", inline: "nearest" });
-  });
+  void shelfView.value?.focusItem(itemId);
 }
 
 async function pasteItem(
@@ -212,10 +246,13 @@ async function pasteItems(
   plainText = false,
   combineText = true,
 ): Promise<void> {
-  const items = itemIds.flatMap((itemId) => {
-    const item = visibleItems.value.find((candidate) => candidate.id === itemId);
-    return item === undefined ? [] : [item];
-  });
+  const items = pagedHistory
+    ? (await Promise.all(itemIds.map(id => window.pasteboardPro?.getHistoryItem?.(id))))
+        .flatMap(value => { const result = PasteItemSchema.safeParse(value); return result.success ? [result.data] : []; })
+    : itemIds.flatMap((itemId) => {
+        const item = visibleItems.value.find((candidate) => candidate.id === itemId);
+        return item === undefined ? [] : [item];
+      });
   const combinedContent =
     combineText && items.length === itemIds.length && items.length > 1
       ? combinedTextPasteContent(items)
@@ -259,16 +296,21 @@ function createTextItem(): void {
   });
 }
 
+function itemPanelParams(itemId: string): Record<string, string> {
+  const item = visibleItems.value.find(candidate => candidate.id === itemId);
+  return { itemId, ...(item === undefined ? {} : { fingerprint: item.contentFingerprint }) };
+}
+
 function editItem(itemId: string): void {
-  window.pasteboardPro?.openPanel("editor", { mode: "edit", itemId });
+  window.pasteboardPro?.openPanel("editor", { mode: "edit", ...itemPanelParams(itemId) });
 }
 
 function renameItem(itemId: string): void {
-  window.pasteboardPro?.openPanel("editor", { mode: "rename", itemId });
+  window.pasteboardPro?.openPanel("editor", { mode: "rename", ...itemPanelParams(itemId) });
 }
 
 function openPreview(itemId: string): void {
-  window.pasteboardPro?.openPanel("preview", { itemId });
+  window.pasteboardPro?.openPanel("preview", itemPanelParams(itemId));
 }
 
 async function saveEditor(value: { title: string; text: string }): Promise<void> {
@@ -369,7 +411,7 @@ async function handleEffect(effect: PasteboardKeyboardEffect | null): Promise<vo
   await pasteItems(effect.itemIds, effect.plainText);
 }
 
-function onKeydown(event: KeyboardEvent): void {
+async function onKeydown(event: KeyboardEvent): Promise<void> {
   if (event.isComposing) return;
   if (event.key === "Escape" && (isShelfMode || panelMode !== undefined)) {
     event.preventDefault();
@@ -378,12 +420,12 @@ function onKeydown(event: KeyboardEvent): void {
   }
   if (!isShelfMode) return;
   if (settingsOpen.value) return;
-  if (event.metaKey && event.key.toLowerCase() === "f") {
+  if (matchesPrimaryShortcut(event, shortcutPlatform, "f")) {
     event.preventDefault();
     document.querySelector<HTMLInputElement>("[data-pb-search]")?.focus();
     return;
   }
-  if (event.metaKey && !event.shiftKey && event.key.toLowerCase() === "n") {
+  if (matchesPrimaryShortcut(event, shortcutPlatform, "n")) {
     event.preventDefault();
     createTextItem();
     return;
@@ -420,33 +462,50 @@ function onKeydown(event: KeyboardEvent): void {
       return;
     }
   }
-  if (event.metaKey && !event.shiftKey && event.key.toLowerCase() === "c") {
+  if (matchesPrimaryShortcut(event, shortcutPlatform, "c")) {
     event.preventDefault();
     void copySelection();
     return;
   }
-  if (event.metaKey && !event.shiftKey && event.key.toLowerCase() === "t") {
+  if (matchesPrimaryShortcut(event, shortcutPlatform, "t")) {
     event.preventDefault();
     void togglePause();
     return;
   }
-  if (event.metaKey && !event.shiftKey && event.key.toLowerCase() === "e" && focusedItem.value !== undefined) {
+  if (matchesPrimaryShortcut(event, shortcutPlatform, "e") && focusedItem.value !== undefined) {
     event.preventDefault();
     editItem(focusedItem.value.id);
     return;
   }
-  if (event.metaKey && !event.shiftKey && event.key.toLowerCase() === "r" && focusedItem.value !== undefined) {
+  if (matchesPrimaryShortcut(event, shortcutPlatform, "r") && focusedItem.value !== undefined) {
     event.preventDefault();
     renameItem(focusedItem.value.id);
     return;
   }
-  const isSpaceActivation =
-    event.key === " " &&
-    event.target instanceof Element &&
-    event.target.closest(
-      "button, a[href], summary, [role='button'], [role='menuitem']",
-    ) !== null;
-  const nextQuery = isSpaceActivation
+  const previousSelection = state.selection.selected.join("\0");
+  const keyboardTarget = event.target instanceof Element ? event.target : undefined;
+  const listCardTarget = keyboardTarget?.closest<HTMLElement>("[data-pb-item-id]");
+  const keyboardRoute = shelfKeyboardRoute(event.key, {
+    nativeControl:
+      keyboardTarget !== undefined &&
+      keyboardTarget.closest(
+        "button, a[href], summary, [role='button'], [role='menuitem']",
+      ) !== null,
+    listCard: listCardTarget !== undefined && listCardTarget !== null,
+  });
+  if (keyboardRoute === "native-control") return;
+  if (
+    keyboardRoute === "list-card" &&
+    !hasAnyCommandModifier(event) &&
+    listCardTarget !== undefined &&
+    listCardTarget !== null
+  ) {
+    const itemId = listCardTarget.dataset.pbItemId;
+    if (itemId !== undefined && !state.selection.selected.includes(itemId)) {
+      state.replaceSelection(itemId);
+    }
+  }
+  const nextQuery = keyboardRoute === "list-card"
     ? undefined
     : queryAfterTypeToSearch(query.value, event);
   if (nextQuery !== undefined) {
@@ -459,11 +518,20 @@ function onKeydown(event: KeyboardEvent): void {
     );
     return;
   }
-  const previousSelection = state.selection.selected.join("\0");
+  if (pagedHistory && hasMoreHistory.value &&
+      (event.key === "ArrowRight" || event.key === "ArrowDown") &&
+      state.selection.focus === visibleItems.value.at(-1)?.id) {
+    event.preventDefault();
+    const currentQuery = query.value;
+    const currentBoard = activePinboardId.value;
+    try { await historyPager?.loadMore(); } catch (error) { reportHistoryError(error); return; }
+    if (query.value !== currentQuery || activePinboardId.value !== currentBoard) return;
+  }
   const effect = state.handleKeyboard(
     {
       key: event.key,
       metaKey: event.metaKey,
+      ctrlKey: event.ctrlKey,
       shiftKey: event.shiftKey,
       altKey: event.altKey,
     },
@@ -493,22 +561,84 @@ async function togglePause(): Promise<void> {
   status.value = paused.value ? "剪贴板捕获已暂停" : "剪贴板捕获已继续";
 }
 
+async function captureScreen(): Promise<void> {
+  status.value = "正在截取屏幕…";
+  try {
+    const result = await window.pasteboardPro?.captureScreenshot();
+    if (result === undefined) throw new Error("当前 ZTools 版本不支持截图导入");
+    const bounds = result.bounds;
+    status.value = bounds === undefined
+      ? "截图已写入剪贴板，正在同步历史"
+      : `截图已写入剪贴板（${Math.round(bounds.width)} × ${Math.round(bounds.height)}），正在同步历史`;
+  } catch (error) {
+    status.value = error instanceof Error ? error.message : "截图导入失败";
+  }
+}
+
 function onMirrored(event: Event): void {
   const detail = (event as CustomEvent<{ imported: number }>).detail;
   status.value = detail.imported > 0 ? `已导入 ${detail.imported} 条记录` : "历史已同步";
 }
 
+const loadLegacyHistory = createHistoryRefresh(
+  async () => window.pasteboardPro?.searchHistory("", 10_000),
+  (history) => {
+    if (history !== undefined) {
+      state.replaceItems(history.items);
+      state.restoreSelection(visibleItems.value.map((item) => item.id));
+      status.value = `已载入 ${history.total} 条记录`;
+    }
+  },
+);
+
+function createPager(): HistoryPager | undefined {
+  if (!pagedHistory) return undefined;
+  return new HistoryPager(
+    request => window.pasteboardPro!.searchHistoryPage!(request),
+    page => {
+      state.replaceResolvedItems(page.items);
+      state.restoreSelection(page.items.map(item => item.id));
+      historyTotal.value = page.total;
+      hasMoreHistory.value = page.nextCursor !== undefined;
+      status.value = `已载入 ${page.items.length} / ${page.total} 条记录`;
+    },
+  );
+}
+const historyPager = createPager();
+function reportHistoryError(error: unknown): void {
+  status.value = error instanceof Error ? error.message : "历史加载失败";
+}
+function loadPagedHistory(preserveCount = true): Promise<void> {
+  return historyPager!.refresh({
+    query: query.value,
+    ...(activePinboardId.value === undefined ? {} : { pinboardId: activePinboardId.value }),
+    orderedIds: [...(listOrders.value[listOrderScope(activePinboardId.value)] ?? [])],
+  }, preserveCount);
+}
 async function loadHistory(): Promise<void> {
-  const history = await window.pasteboardPro?.searchHistory("", 10_000);
-  if (history !== undefined) {
-    state.replaceItems(history.items);
-    state.restoreSelection(visibleItems.value.map((item) => item.id));
-    status.value = `已载入 ${history.total} 条记录`;
+  if (!pagedHistory) return loadLegacyHistory();
+  if (panelMode === "preview" || panelMode === "editor") {
+    const id = params.get("itemId");
+    const item = id === null ? undefined : await window.pasteboardPro?.getHistoryItem?.(id, params.get("fingerprint") ?? undefined);
+    state.replaceResolvedItems(item === undefined ? [] : [item]);
+    return;
   }
+  await loadPagedHistory();
+}
+function loadMoreHistory(): void {
+  if (queryTimer !== undefined || !hasMoreHistory.value) return;
+  void historyPager?.loadMore().catch(reportHistoryError);
+}
+
+function onHistoryChanged(): void {
+  void loadHistory().catch((error: unknown) => {
+    status.value = error instanceof Error ? error.message : "历史加载失败";
+  });
 }
 
 function selectPinboard(pinboardId: string | undefined): void {
   activePinboardId.value = pinboardId;
+  if (pagedHistory) { void loadPagedHistory(false).catch(reportHistoryError); return; }
   state.restoreSelection(visibleItems.value.map((item) => item.id));
 }
 
@@ -535,8 +665,11 @@ async function reorderVisibleItems(value: ListReorderRequest): Promise<void> {
   state.restoreSelection(nextIds);
   listOrderSaving.value = true;
   try {
-    const saved = await window.pasteboardPro?.saveListOrder(scope, nextIds);
+    const saved = pagedHistory
+      ? await window.pasteboardPro?.reorderHistory?.(value, activePinboardId.value)
+      : await window.pasteboardPro?.saveListOrder(scope, nextIds);
     if (saved !== undefined) listOrders.value = saved;
+    if (pagedHistory) await loadPagedHistory();
     status.value = "列表顺序已保存";
   } catch (error) {
     if (
@@ -803,7 +936,11 @@ async function onWindowPreferencesChanged(): Promise<void> {
   if (preferences !== undefined) windowPreferences.value = preferences;
 }
 
-onMounted(async () => {
+async function initializeWindow(): Promise<void> {
+  if (requiresHostUpgrade) return;
+  if (!import.meta.env.DEV && window.pasteboardPro === undefined) {
+    throw new Error("Paste preload bridge is unavailable");
+  }
   window.addEventListener("keydown", onKeydown);
   window.addEventListener("pasteboard-pro:paste-stack-changed", onPasteStackChanged);
   window.addEventListener(
@@ -866,7 +1003,7 @@ onMounted(async () => {
   }
   if (!isShelfMode) return;
   window.addEventListener("pasteboard-pro:history-mirrored", onMirrored);
-  window.addEventListener("pasteboard-pro:history-changed", loadHistory);
+  window.addEventListener("pasteboard-pro:history-changed", onHistoryChanged);
   const [settings, savedListOrders] = await Promise.all([
     window.pasteboardPro?.getPrivacySettings(),
     window.pasteboardPro?.getListOrders(),
@@ -888,15 +1025,31 @@ onMounted(async () => {
   }
   await loadHistory();
   await loadPinboards();
+}
+
+onMounted(async () => {
+  try {
+    await initializeWindow();
+  } catch (error) {
+    console.error("Paste initial content failed to load", error);
+    startupError.value = "加载失败，请关闭后重新打开 Paste";
+  } finally {
+    // nextTick includes child updates from the initial history and theme. Unlike
+    // requestAnimationFrame, it also runs while an Electron window is hidden.
+    await nextTick();
+    markWindowReady();
+  }
 });
 
 onBeforeUnmount(() => {
+  clearTimeout(queryTimer);
+  historyPager?.dispose();
   window.removeEventListener("keydown", onKeydown);
   window.removeEventListener("pasteboard-pro:paste-stack-changed", onPasteStackChanged);
   window.removeEventListener("focus", onWindowFocus);
   window.removeEventListener("blur", onWindowBlur);
   window.removeEventListener("pasteboard-pro:history-mirrored", onMirrored);
-  window.removeEventListener("pasteboard-pro:history-changed", loadHistory);
+  window.removeEventListener("pasteboard-pro:history-changed", onHistoryChanged);
   window.removeEventListener(
     "pasteboard-pro:window-preferences-changed",
     onWindowPreferencesChanged,
@@ -911,13 +1064,32 @@ onBeforeUnmount(() => {
     :style="themeStyle"
     :class="{
       'stage--panel': panelMode !== undefined,
-      'stage--primary': !isShelfMode && panelMode === undefined,
+      'stage--primary': !requiresHostUpgrade && !isShelfMode && panelMode === undefined,
       'stage--image-background': hasImageBackground,
     }"
   >
+    <section v-if="requiresHostUpgrade" class="upgrade-required" role="alert">
+      <img src="/logo.png" alt="" />
+      <h1>请升级 ZTools</h1>
+      <p>
+        Paste剪切板需要 ZTools {{ hostCompatibility?.minimumVersion ?? "2.4.0" }} 或更高版本。
+      </p>
+      <small v-if="hostCompatibility?.currentVersion">
+        当前版本：{{ hostCompatibility.currentVersion }}
+      </small>
+    </section>
+    <section v-else-if="startupError" class="upgrade-required" role="alert">
+      <p>{{ startupError }}</p>
+      <button type="button" @click="closeWindow">关闭</button>
+    </section>
+    <template v-else>
     <Shelf
+      ref="shelfView"
       v-if="isShelfMode"
       :items="visibleItems"
+      :total="pagedHistory ? historyTotal : visibleItems.length"
+      :has-more="hasMoreHistory"
+      @load-more="loadMoreHistory"
       :pinboards="pinboards"
       :smart-pinboards="defaultSmartPinboards"
       :selected-ids="state.selection.selected"
@@ -930,6 +1102,7 @@ onBeforeUnmount(() => {
       :paste-stack-count="state.pasteStack.itemIds.length"
       :paste-stack-direction="state.pasteStack.direction"
       :reorder-enabled="reorderEnabled"
+      :can-capture-screen="canCaptureScreen"
       @update:query="updateQuery"
       @select="selectItem"
       @paste="pasteItem"
@@ -948,6 +1121,7 @@ onBeforeUnmount(() => {
       @clear-stack="updatePasteStack({ type: 'clear' })"
       @open-privacy-settings="openPrivacySettings"
       @create-text="createTextItem"
+      @capture-screen="captureScreen"
       @edit-item="editItem"
       @rename-item="renameItem"
       @reorder="reorderVisibleItems"
@@ -988,6 +1162,7 @@ onBeforeUnmount(() => {
       @rename="renameItem"
     />
     <p v-if="isShelfMode" class="status" aria-live="polite">{{ status }}</p>
+    </template>
   </main>
 </template>
 
@@ -1017,6 +1192,24 @@ onBeforeUnmount(() => {
   place-items: center;
 }
 
+.upgrade-required {
+  align-self: center;
+  justify-self: center;
+  width: min(420px, calc(100% - 32px));
+  padding: 28px;
+  border: 1px solid var(--pb-line);
+  border-radius: 20px;
+  background: var(--pb-glass-strong);
+  box-shadow: 0 24px 80px var(--pb-shadow);
+  color: var(--pb-ink);
+  text-align: center;
+}
+
+.upgrade-required img { width: 52px; height: 52px; border-radius: 14px; }
+.upgrade-required h1 { margin: 14px 0 8px; font-size: 22px; }
+.upgrade-required p { margin: 0; color: var(--pb-muted); line-height: 1.6; }
+.upgrade-required small { display: block; margin-top: 10px; color: var(--pb-muted); }
+
 .stage--image-background .shelf.glass-surface {
   background-color: var(--pb-theme-background-color, var(--pb-window-bg));
   background-image: var(--pb-theme-background-image, none);
diff --git a/plugins/pasteboard-pro/apps/ztools/src/components/PasteCard.vue b/plugins/pasteboard-pro/apps/ztools/src/components/PasteCard.vue
index edd977f33..3ba56ac00 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/components/PasteCard.vue
+++ b/plugins/pasteboard-pro/apps/ztools/src/components/PasteCard.vue
@@ -10,12 +10,14 @@ import {
 import { containContextMenuKeydown } from "../context-menu-keyboard";
 import { writeSourceDragData } from "../drag-content";
 import { LIST_REORDER_MIME } from "../list-order";
+import { hasPrimaryShortcutModifier, resolveShortcutPlatform } from "../platform-shortcuts";
 
 const props = defineProps<{
   item: PasteItem;
   pinboards: readonly Pinboard[];
   selected: boolean;
   index: number;
+  total?: number;
   vertical?: boolean;
   compact?: boolean;
   reorderEnabled?: boolean;
@@ -38,6 +40,9 @@ const card = ref<HTMLElement>();
 const thumbnailUrl = ref<string>();
 const thumbnailRequested = ref(false);
 const reorderDragging = ref(false);
+const shortcutPlatform = resolveShortcutPlatform(
+  window.pasteboardPro?.getPlatformCapabilities().platform,
+);
 const contextMenu = ref<{ x: number; y: number }>();
 let stopObservingThumbnail: (() => void) | undefined;
 let reorderDragPreview: HTMLElement | undefined;
@@ -71,6 +76,15 @@ function openContextMenu(event: MouseEvent): void {
   window.addEventListener("keydown", closeContextMenuOnEscape);
 }
 
+function selectCard(event: MouseEvent): void {
+  emit(
+    "select",
+    props.item.id,
+    event.shiftKey,
+    hasPrimaryShortcutModifier(event, shortcutPlatform),
+  );
+}
+
 function assignToPinboard(pinboardId: string | undefined): void {
   emit("assignPinboard", { pinboardId, itemId: props.item.id });
   closeContextMenu();
@@ -228,16 +242,18 @@ function prepareNativeFileDrag(): void {
 }
 
 function beginNativeFileDrag(event: DragEvent): void {
-  event.dataTransfer?.setData("application/x-pasteboard-pro-item", props.item.id);
+  // Stop nested image/file drag events from reaching the card reorder handler.
+  event.stopPropagation();
+  const started = window.pasteboardPro?.startNativeFileDrag(props.item.id) ?? false;
+  if (started) {
+    event.preventDefault();
+    return;
+  }
+  // ZTools 2.4–3.1 has no startDrag API. Preserve the browser data-transfer
+  // payload so those hosts still support in-plugin/source dragging.
   if (event.dataTransfer !== null) {
-    event.dataTransfer.effectAllowed = "copy";
+    writeSourceDragData(props.item, event.dataTransfer);
   }
-  // The nested <img> element has a browser-native drag behavior that exposes
-  // its thumbnail URL. Always cancel that default payload; the host API below
-  // supplies the original image/file as a native file drag instead.
-  window.pasteboardPro?.startNativeFileDrag(props.item.id);
-  event.preventDefault();
-  event.stopPropagation();
 }
 
 const bodyText = computed(() => {
@@ -288,17 +304,17 @@ onBeforeUnmount(() => {
     :class="[`paste-card--${item.kind}`, { 'paste-card--selected': selected, 'paste-card--vertical': vertical, 'paste-card--compact': compact, 'paste-card--dragging': reorderDragging || reorderHidden, 'paste-card--reorder-active': reorderActive, 'paste-card--shift-backward': reorderShift < 0, 'paste-card--shift-forward': reorderShift > 0 }]"
     :style="reorderTransformStyle"
     :aria-selected="selected"
+    :aria-posinset="index + 1"
+    :aria-setsize="total"
     :data-pb-item-id="item.id"
     role="option"
     tabindex="0"
     :draggable="reorderEnabled !== false"
-    @click="emit('select', item.id, $event.shiftKey, $event.metaKey)"
+    @click="selectCard"
     @dblclick="emit('paste', item.id)"
     @contextmenu.prevent.stop="openContextMenu"
     @dragstart="beginReorderDrag"
     @dragend="finishReorderDrag"
-    @keydown.enter="emit('paste', item.id)"
-    @keydown.space.prevent="emit('preview', item.id)"
   >
     <header>
       <span class="kind">{{ item.kind.replace('_', ' ') }}</span>
diff --git a/plugins/pasteboard-pro/apps/ztools/src/components/PinboardStrip.vue b/plugins/pasteboard-pro/apps/ztools/src/components/PinboardStrip.vue
index 8ffd22462..8e75cb4fb 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/components/PinboardStrip.vue
+++ b/plugins/pasteboard-pro/apps/ztools/src/components/PinboardStrip.vue
@@ -2,6 +2,8 @@
 import { computed, onBeforeUnmount, ref } from "vue";
 
 import type { Pinboard } from "@pasteboard-pro/core";
+
+import { primaryModifierLabel, resolveShortcutPlatform } from "../platform-shortcuts";
 import type { SmartPinboard } from "../smart-pinboards";
 import { containContextMenuKeydown } from "../context-menu-keyboard";
 
@@ -20,6 +22,13 @@ const emit = defineEmits<{
   assign: [pinboardId: string | undefined, itemId: string];
 }>();
 
+const quickPasteShortcutLabel = computed(() => {
+  const platform = resolveShortcutPlatform(
+    window.pasteboardPro?.getPlatformCapabilities().platform,
+  );
+  return `${primaryModifierLabel(platform)} 1–9 快捷粘贴`;
+});
+
 const creating = ref(false);
 const editingId = ref<string>();
 const draft = ref("");
@@ -204,7 +213,7 @@ onBeforeUnmount(closeManagementMenu);
       @blur="commitCreate"
     />
     <button v-else type="button" class="add-button" aria-label="新建分组" @click="beginCreate">+</button>
-    <span class="pinboards__hint">⌘ 1–9 快捷粘贴</span>
+    <span class="pinboards__hint">{{ quickPasteShortcutLabel }}</span>
   </nav>
   <Teleport to="body">
     <div
diff --git a/plugins/pasteboard-pro/apps/ztools/src/components/SearchBar.vue b/plugins/pasteboard-pro/apps/ztools/src/components/SearchBar.vue
index 4f9df7688..a5b0c3e60 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/components/SearchBar.vue
+++ b/plugins/pasteboard-pro/apps/ztools/src/components/SearchBar.vue
@@ -1,6 +1,17 @@
 <script setup lang="ts">
+import { computed } from "vue";
+
+import { primaryModifierLabel, resolveShortcutPlatform } from "../platform-shortcuts";
+
 defineProps<{ modelValue: string }>();
 const emit = defineEmits<{ "update:modelValue": [value: string] }>();
+
+const searchShortcutLabel = computed(() => {
+  const platform = resolveShortcutPlatform(
+    window.pasteboardPro?.getPlatformCapabilities().platform,
+  );
+  return `${primaryModifierLabel(platform)} F`;
+});
 </script>
 
 <template>
@@ -18,7 +29,7 @@ const emit = defineEmits<{ "update:modelValue": [value: string] }>();
       autocomplete="off"
       @input="emit('update:modelValue', ($event.target as HTMLInputElement).value)"
     />
-    <kbd>⌘ F</kbd>
+    <kbd>{{ searchShortcutLabel }}</kbd>
   </label>
 </template>
 
diff --git a/plugins/pasteboard-pro/apps/ztools/src/components/SettingsPanel.vue b/plugins/pasteboard-pro/apps/ztools/src/components/SettingsPanel.vue
index 17fdddcda..6c88a76e6 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/components/SettingsPanel.vue
+++ b/plugins/pasteboard-pro/apps/ztools/src/components/SettingsPanel.vue
@@ -26,6 +26,11 @@ import {
 } from "../privacy-view";
 import { syncStatusPresentation } from "../sync-view";
 import { themeCssVariables } from "../theme";
+import {
+  primaryModifierName,
+  resolveShortcutPlatform,
+} from "../platform-shortcuts";
+import { openPasteShortcutSettings, type ZToolsShortcutSettingsApi } from "../hotkey-settings";
 
 type SettingsTab = "general" | "appearance" | "privacy" | "sync";
 type ThemeBackgroundType = ThemeBackground["type"];
@@ -72,6 +77,7 @@ const backgroundImageError = ref("");
 const clearingHistory = ref(false);
 const historyClearMessage = ref("");
 const historyClearFailed = ref(false);
+const hotkeySettingsMessage = ref("");
 const initialBlobBudgetUnit = preferredBlobBudgetUnit(
   props.privacySettings.retention.maxBlobBytes,
 );
@@ -111,6 +117,24 @@ const blobBudgetConstraints = computed(() =>
 const syncPresentation = computed(() =>
   syncStatusPresentation(props.syncSettings.status),
 );
+const shortcutPlatform = computed(() =>
+  resolveShortcutPlatform(window.pasteboardPro?.getPlatformCapabilities().platform),
+);
+const multiPasteHint = computed(() => {
+  if (shortcutPlatform.value === "darwin") {
+    return "一次性模式按 Enter 合并粘贴；逐一模式可连续按 Command-V。";
+  }
+  if (shortcutPlatform.value === "win32") {
+    return "一次性模式按 Enter 合并粘贴；逐一模式需在插件内按 Enter。Win+V 是 Windows 系统剪贴板历史快捷键，不能用于 Paste。";
+  }
+  return "一次性模式按 Enter 合并粘贴；逐一模式需在插件内按 Enter。";
+});
+const hotkeySettingsHint = computed(() => {
+  if (shortcutPlatform.value === "win32") {
+    return "请设置未被系统占用的组合；Win+V 保留给 Windows 剪贴板历史。";
+  }
+  return `在 ZTools 中设置 Paste剪切板的全局唤起快捷键；列表内快捷键使用 ${primaryModifierName(shortcutPlatform.value)}。`;
+});
 const themePreviewStyle = computed<Record<string, string>>(() => {
   const variables = themeCssVariables(
     {
@@ -226,6 +250,13 @@ async function clearHistory(): Promise<void> {
   }
 }
 
+function openHotkeySettings(): void {
+  const ztools = (window as Window & { ztools?: ZToolsShortcutSettingsApi }).ztools;
+  hotkeySettingsMessage.value = openPasteShortcutSettings(ztools)
+    ? "已打开 ZTools 快捷键设置。"
+    : "当前环境不支持打开 ZTools 快捷键设置；请在 ZTools 中右键 Paste剪切板后选择设置快捷键。";
+}
+
 function selectedThemeBackground(): ThemeBackground {
   if (form.backgroundType === "color") {
     return { type: "color", color: form.backgroundColor };
@@ -321,8 +352,13 @@ function save(): void {
                   <span>{{ option[1] }}</span>
                 </label>
               </div>
-              <small>一次性模式按 Enter 合并粘贴；macOS 逐一模式可连续按 Command-V，Windows/Linux 按 Enter 逐项粘贴。</small>
+              <small>{{ multiPasteHint }}</small>
             </fieldset>
+            <div class="shortcut-settings">
+              <span><strong>全局唤起快捷键</strong><small>{{ hotkeySettingsHint }}</small></span>
+              <button type="button" @click="openHotkeySettings">设置 ZTools 快捷键</button>
+            </div>
+            <p v-if="hotkeySettingsMessage" class="settings-result" role="status">{{ hotkeySettingsMessage }}</p>
           </section>
 
           <section v-show="activeTab === 'appearance'" class="settings-page" aria-label="外观设置">
@@ -411,6 +447,7 @@ function save(): void {
 .option-field { display:grid; gap:9px; margin:0; padding:15px 0; border:0; border-top:1px solid var(--pb-line); }.option-field legend { padding:0; font-size:12px; font-weight:750; }.option-grid { display:grid; gap:7px; }.option-grid--four { grid-template-columns:repeat(4,1fr); }.option-grid--three { grid-template-columns:repeat(3,1fr); }.option-grid--two { grid-template-columns:repeat(2,1fr); }.option-grid label { position:relative; }.option-grid input { position:absolute; opacity:0; pointer-events:none; }.option-grid span { display:grid; min-height:36px; border:1px solid var(--pb-line); border-radius:10px; background:color-mix(in srgb,var(--pb-glass-strong) 58%,transparent); color:var(--pb-muted); cursor:pointer; font-size:11px; font-weight:700; place-items:center; }.option-grid input:checked + span { border-color:var(--pb-violet); background:color-mix(in srgb,var(--pb-violet) 12%,var(--pb-window-bg)); color:var(--pb-violet); }.option-grid input:disabled + span { cursor:not-allowed; opacity:.45; }.option-grid input:focus-visible + span { outline:2px solid color-mix(in srgb,var(--pb-violet) 45%,transparent); outline-offset:1px; }
 .theme-preview { display:grid; grid-template-columns:auto 1fr auto; gap:14px; align-items:center; min-height:112px; margin-bottom:16px; padding:20px; overflow:hidden; border:1px solid var(--pb-line); border-radius:16px; background-position:center; background-repeat:no-repeat; background-size:cover; box-shadow:inset 0 0 0 999px color-mix(in srgb,var(--pb-glass) 32%,transparent); }.theme-preview__brand { color:var(--preview-accent); font-size:20px; font-weight:850; letter-spacing:-.04em; }.theme-preview div { display:flex; gap:5px; }.theme-preview i { width:26px; height:32px; border:1px solid color-mix(in srgb,var(--preview-accent) 22%,var(--pb-line)); border-radius:8px; background:color-mix(in srgb,var(--pb-glass-strong) 72%,transparent); }.theme-preview__button { display:grid; min-height:34px; padding:0 12px; border-radius:9px; background:var(--preview-accent); color:var(--preview-on-accent); font-size:10px; font-weight:750; place-items:center; }.color-field,.background-image-control { display:flex; align-items:center; justify-content:space-between; gap:16px; padding:14px 0; border-top:1px solid var(--pb-line); }.color-field > span:first-child,.background-image-control > span:first-child { display:grid; gap:3px; }.color-field strong,.background-image-control strong { font-size:12px; }.color-field small,.background-image-control small { color:var(--pb-muted); font-size:10px; line-height:1.4; }.color-field__control { display:flex; align-items:center; gap:8px; }.color-field__control input { width:36px; height:32px; padding:2px; border:1px solid var(--pb-line); border-radius:9px; background:transparent; cursor:pointer; }.color-field__control code { min-width:66px; color:var(--pb-muted); font-size:10px; text-transform:uppercase; }.color-field--compact { border-bottom:1px solid var(--pb-line); }.background-image-control > div { display:flex; gap:7px; }.quiet-action { min-height:34px; padding:0 11px; border:1px solid var(--pb-line); border-radius:9px; background:color-mix(in srgb,var(--pb-glass-strong) 58%,transparent); color:var(--pb-ink); cursor:pointer; font-size:10px; font-weight:700; }.quiet-action:hover { border-color:var(--pb-violet); color:var(--pb-violet); }.quiet-action:disabled { cursor:wait; opacity:.55; }.quiet-action--danger { color:#c34455; }.settings-error { margin:8px 0 0; color:#c34455; font-size:10px; }
 .settings-toggle { display:flex; align-items:center; justify-content:space-between; gap:16px; padding:14px 0; border-top:1px solid var(--pb-line); }.settings-toggle span { display:grid; gap:3px; }.settings-toggle strong { font-size:12px; }.settings-toggle small { color:var(--pb-muted); font-size:10px; line-height:1.4; }.settings-toggle input { width:32px; accent-color:var(--pb-violet); }
+.shortcut-settings { display:flex; align-items:center; justify-content:space-between; gap:16px; padding:14px 0; border-top:1px solid var(--pb-line); }.shortcut-settings > span { display:grid; gap:3px; }.shortcut-settings strong { font-size:12px; }.shortcut-settings small { color:var(--pb-muted); font-size:10px; line-height:1.4; }.shortcut-settings button { flex:none; min-height:34px; padding:0 11px; border:1px solid var(--pb-line); border-radius:9px; background:color-mix(in srgb,var(--pb-glass-strong) 58%,transparent); color:var(--pb-ink); cursor:pointer; font-size:10px; font-weight:700; }.shortcut-settings button:hover,.shortcut-settings button:focus-visible { border-color:var(--pb-violet); color:var(--pb-violet); outline:2px solid color-mix(in srgb,var(--pb-violet) 30%,transparent); outline-offset:1px; }
 .danger-zone { display:flex; align-items:center; justify-content:space-between; gap:16px; margin-top:18px; padding:14px; border:1px solid color-mix(in srgb,#c34455 28%,var(--pb-line)); border-radius:13px; background:color-mix(in srgb,#c34455 5%,transparent); }.danger-zone > span { display:grid; gap:3px; }.danger-zone strong { color:#b63f50; font-size:12px; }.danger-zone small { color:var(--pb-muted); font-size:10px; line-height:1.45; }.danger-zone button { flex:none; min-height:34px; padding:0 12px; border:1px solid color-mix(in srgb,#c34455 38%,var(--pb-line)); border-radius:9px; background:transparent; color:#b63f50; cursor:pointer; font-size:10px; font-weight:750; }.danger-zone button:hover { background:color-mix(in srgb,#c34455 9%,transparent); }.danger-zone button:disabled { cursor:wait; opacity:.55; }.settings-result { margin:8px 0 0; color:#23825d; font-size:10px; }.settings-result--error { color:#c34455; }
 .settings-grid,.sync-grid { display:grid; grid-template-columns:1fr 1fr; gap:11px; padding:14px 0; border-top:1px solid var(--pb-line); }.settings-grid label,.settings-field { display:grid; gap:6px; }.settings-grid span,.settings-field span { color:var(--pb-muted); font-size:10px; font-weight:700; }.settings-grid input,.settings-field input,.settings-field textarea,textarea { width:100%; padding:9px 11px; border:1px solid var(--pb-line); border-radius:10px; outline:none; background:color-mix(in srgb,var(--pb-glass-strong) 58%,transparent); color:var(--pb-ink); }.settings-field { margin-top:12px; }.settings-field--wide { grid-column:1 / -1; margin-top:0; }.settings-field input:focus,.settings-field textarea:focus,textarea:focus { border-color:var(--pb-violet); box-shadow:0 0 0 3px color-mix(in srgb,var(--pb-violet) 14%,transparent); }.settings-field input:disabled { opacity:.45; } textarea { resize:vertical; font:11px/1.45 "SFMono-Regular",Consolas,monospace; }
 .budget-control { display:grid; grid-template-columns:minmax(0,1fr) 84px; overflow:hidden; border:1px solid var(--pb-line); border-radius:10px; background:color-mix(in srgb,var(--pb-glass-strong) 58%,transparent); }.budget-control input { min-width:0; border:0; border-radius:0; background:transparent; }.budget-control select { min-width:0; padding:0 10px; border:0; border-left:1px solid var(--pb-line); outline:0; background:color-mix(in srgb,var(--pb-violet) 7%,transparent); color:var(--pb-ink); cursor:pointer; font:700 11px/1 system-ui,sans-serif; }
diff --git a/plugins/pasteboard-pro/apps/ztools/src/components/Shelf.vue b/plugins/pasteboard-pro/apps/ztools/src/components/Shelf.vue
index e447c2aef..9beb03f1f 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/components/Shelf.vue
+++ b/plugins/pasteboard-pro/apps/ztools/src/components/Shelf.vue
@@ -14,6 +14,8 @@ import Toolbar from "./Toolbar.vue";
 
 const props = defineProps<{
   items: readonly PasteItem[];
+  total?: number;
+  hasMore?: boolean;
   pinboards: readonly Pinboard[];
   smartPinboards: readonly SmartPinboard[];
   selectedIds: readonly string[];
@@ -26,10 +28,12 @@ const props = defineProps<{
   pasteStackCount: number;
   pasteStackDirection: PasteStackDirection;
   reorderEnabled: boolean;
+  canCaptureScreen: boolean;
 }>();
 
 const emit = defineEmits<{
   "update:query": [value: string];
+  loadMore: [];
   select: [itemId: string, extend: boolean, toggle: boolean];
   paste: [itemId: string, plainText?: boolean];
   preview: [itemId: string];
@@ -47,11 +51,15 @@ const emit = defineEmits<{
   clearStack: [];
   openPrivacySettings: [];
   createText: [];
+  captureScreen: [];
   reorder: [value: ListReorderRequest];
 }>();
 
 const style = computed(() => visualState(props.edge, props.density));
 const pinboardStrip = ref<InstanceType<typeof PinboardStrip>>();
+const timeline = ref<InstanceType<typeof Timeline>>();
+
+defineExpose({ focusItem: (itemId: string) => timeline.value?.focusItem(itemId) });
 
 function forwardSelect(itemId: string, extend: boolean, toggle: boolean): void {
   emit("select", itemId, extend, toggle);
@@ -86,12 +94,14 @@ function requestCreatePinboard(): void {
       :paused="paused"
       :compact="density === 'compact'"
       :reorder-enabled="reorderEnabled"
+      :can-capture-screen="canCaptureScreen"
       :edge="edge"
       @update:query="emit('update:query', $event)"
       @toggle-pause="emit('togglePause')"
       @toggle-compact="emit('toggleCompact')"
       @open-privacy-settings="emit('openPrivacySettings')"
       @create-text="emit('createText')"
+      @capture-screen="emit('captureScreen')"
     />
     <PinboardStrip
       ref="pinboardStrip"
@@ -107,7 +117,12 @@ function requestCreatePinboard(): void {
       @assign="forwardAssignPinboard"
     />
     <Timeline
+      ref="timeline"
+      :reorder-enabled="reorderEnabled"
       :items="items"
+      :total="total ?? items.length"
+      :has-more="hasMore ?? false"
+      @load-more="emit('loadMore')"
       :pinboards="pinboards"
       :selected-ids="selectedIds"
       :focused-id="focusedItemId"
diff --git a/plugins/pasteboard-pro/apps/ztools/src/components/Timeline.vue b/plugins/pasteboard-pro/apps/ztools/src/components/Timeline.vue
index 24154e8fe..631c1d8ef 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/components/Timeline.vue
+++ b/plugins/pasteboard-pro/apps/ztools/src/components/Timeline.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, nextTick, onMounted, ref, watch } from "vue";
+import { computed, nextTick, onBeforeUnmount, ref, watch } from "vue";
 
 import type { PasteItem, Pinboard } from "@pasteboard-pro/core";
 
@@ -11,10 +11,13 @@ import {
   type ListReorderRequest,
 } from "../list-order";
 import PasteCard from "./PasteCard.vue";
+import { timelineFocusOffset, timelineRange } from "../virtual-timeline";
 
 const props = withDefaults(
   defineProps<{
     items: readonly PasteItem[];
+    total?: number;
+    hasMore?: boolean;
     pinboards: readonly Pinboard[];
     selectedIds: readonly string[];
     focusedId: string | undefined;
@@ -26,6 +29,7 @@ const props = withDefaults(
 );
 
 const emit = defineEmits<{
+  loadMore: [];
   select: [itemId: string, extend: boolean, toggle: boolean];
   paste: [itemId: string];
   preview: [itemId: string];
@@ -34,8 +38,21 @@ const emit = defineEmits<{
   createPinboard: [];
   reorder: [value: ListReorderRequest];
 }>();
-const track = ref<HTMLElement>();
+const track = ref<HTMLElement | null>();
 const followLatest = ref(true);
+const offset = ref(0);
+const viewport = ref(800);
+const cardSize = ref(240);
+const gap = computed(() => props.vertical && props.compact ? 8 : 12);
+const stride = computed(() => cardSize.value + gap.value);
+const selectedIdSet = computed(() => new Set(props.selectedIds));
+const itemPositions = computed(() => new Map(props.items.map((item, index) => [item.id, index])));
+const orderedSelectedIds = computed(() => props.items
+  .filter((item) => selectedIdSet.value.has(item.id)).map((item) => item.id));
+const dragOriginId = ref<string>();
+const mountedDragIds = ref<readonly string[]>([]);
+let resizeObserver: ResizeObserver | undefined;
+let itemsRevision = 0;
 const draggedItemIds = ref<readonly string[]>([]);
 const draggedItemIdSet = computed(() => new Set(draggedItemIds.value));
 const reorderTarget = ref<Readonly<{ itemId: string; position: ListDropPosition }>>();
@@ -58,7 +75,59 @@ const reorderShifts = computed(() => {
   );
 });
 
-type VisibleAnchor = Readonly<{ itemId: string; offset: number }>;
+const range = computed(() => timelineRange(
+  props.items.length, stride.value, offset.value, viewport.value,
+));
+// Project drag shifts before selecting visible cards: a distant card can move
+// into the viewport when a large selection is dragged. Keep only the actual
+// drag source and initially mounted selected cards alive until dragend.
+const projectedIndexes = computed(() => {
+  const indexes: Array<number | undefined> = new Array(props.items.length);
+  props.items.forEach((item, index) => {
+    if (!draggedItemIdSet.value.has(item.id)) {
+      indexes[index + (reorderShifts.value.get(item.id) ?? 0)] = index;
+    }
+  });
+  return indexes;
+});
+const renderedItems = computed(() => {
+  const indexes = projectedIndexes.value.slice(range.value.start, range.value.end)
+    .filter((index): index is number => index !== undefined);
+  const originIndex = dragOriginId.value === undefined
+    ? undefined : itemPositions.value.get(dragOriginId.value);
+  if (originIndex !== undefined && !indexes.includes(originIndex)) indexes.push(originIndex);
+  for (const itemId of mountedDragIds.value) {
+    const index = itemPositions.value.get(itemId);
+    if (index !== undefined && !indexes.includes(index)) indexes.push(index);
+  }
+  return indexes.sort((a, b) => a - b).map((index) => ({ item: props.items[index]!, index }));
+});
+const contentStyle = computed(() => {
+  const extent = Math.max(0, props.items.length * stride.value - gap.value);
+  return props.vertical
+    ? { height: `${extent}px`, width: "100%" }
+    : { width: `${extent}px`, height: "var(--pb-card-height)" };
+});
+
+function slotStyle(index: number): Record<string, string> {
+  return props.vertical
+    ? { top: `${index * stride.value}px`, left: "0", width: "100%" }
+    : { left: `${index * stride.value}px`, top: "0", width: `${cardSize.value}px` };
+}
+
+function measureTrack(): void {
+  const element = track.value;
+  if (element == null) return;
+  const css = getComputedStyle(element);
+  cardSize.value = props.vertical
+    ? Number.parseFloat(css.getPropertyValue("--pb-card-height")) || 142
+    : Number.parseFloat(css.getPropertyValue("--pb-card-width")) || 240;
+  const padding = props.vertical
+    ? Number.parseFloat(css.paddingTop) + Number.parseFloat(css.paddingBottom)
+    : Number.parseFloat(css.paddingLeft) + Number.parseFloat(css.paddingRight);
+  viewport.value = Math.max(1, (props.vertical ? element.clientHeight : element.clientWidth) - padding);
+  updateFollowLatest();
+}
 
 function forwardSelect(itemId: string, extend: boolean, toggle: boolean): void {
   emit("select", itemId, extend, toggle);
@@ -71,33 +140,35 @@ function scrollOffset(element: HTMLElement): number {
 function setScrollOffset(element: HTMLElement, value: number): void {
   if (props.vertical) element.scrollTop = value;
   else element.scrollLeft = value;
+  updateFollowLatest();
 }
 
 function updateFollowLatest(): void {
   const element = track.value;
-  if (element === undefined) return;
-  followLatest.value = scrollOffset(element) <= LEADING_EDGE_THRESHOLD;
+  if (element == null) return;
+  offset.value = scrollOffset(element);
+  followLatest.value = offset.value <= LEADING_EDGE_THRESHOLD;
+  if (props.hasMore && offset.value + viewport.value >= (props.items.length - 15) * stride.value) emit("loadMore");
 }
 
 function beginReorder(itemId: string): void {
   if (!props.reorderEnabled) return;
-  draggedItemIds.value = props.selectedIds.includes(itemId)
-    ? props.items
-        .map((item) => item.id)
-        .filter((candidateId) => props.selectedIds.includes(candidateId))
-    : [itemId];
+  mountedDragIds.value = renderedItems.value
+    .filter(({ item }) => item.id === itemId || selectedIdSet.value.has(item.id))
+    .map(({ item }) => item.id);
+  dragOriginId.value = itemId;
+  draggedItemIds.value = selectedIdSet.value.has(itemId) ? orderedSelectedIds.value : [itemId];
 }
 
 function clearReorder(): void {
+  mountedDragIds.value = [];
+  dragOriginId.value = undefined;
   draggedItemIds.value = [];
   reorderTarget.value = undefined;
 }
 
 function reorderItemIdsFor(itemId: string): readonly string[] {
-  if (!props.selectedIds.includes(itemId)) return [itemId];
-  return props.items
-    .map((item) => item.id)
-    .filter((candidateId) => props.selectedIds.includes(candidateId));
+  return selectedIdSet.value.has(itemId) ? orderedSelectedIds.value : [itemId];
 }
 
 function updateReorderTarget(event: DragEvent): void {
@@ -133,98 +204,27 @@ function commitReorder(event: DragEvent): void {
   clearReorder();
 }
 
-function captureVisibleAnchor(element: HTMLElement): VisibleAnchor | undefined {
-  const trackBounds = element.getBoundingClientRect();
-  for (const card of element.querySelectorAll<HTMLElement>("[data-pb-item-id]")) {
-    const bounds = card.getBoundingClientRect();
-    const visible = props.vertical
-      ? bounds.bottom > trackBounds.top && bounds.top < trackBounds.bottom
-      : bounds.right > trackBounds.left && bounds.left < trackBounds.right;
-    if (!visible) continue;
-    const itemId = card.dataset.pbItemId;
-    if (itemId === undefined) continue;
-    return {
-      itemId,
-      offset: props.vertical
-        ? bounds.top - trackBounds.top
-        : bounds.left - trackBounds.left,
-    };
-  }
-  return undefined;
-}
-
-function restoreVisibleAnchor(
-  element: HTMLElement,
-  anchor: VisibleAnchor,
-): boolean {
-  const card = [...element.querySelectorAll<HTMLElement>("[data-pb-item-id]")]
-    .find((candidate) => candidate.dataset.pbItemId === anchor.itemId);
-  if (card === undefined) return false;
-  const trackBounds = element.getBoundingClientRect();
-  const bounds = card.getBoundingClientRect();
-  const nextOffset = props.vertical
-    ? bounds.top - trackBounds.top
-    : bounds.left - trackBounds.left;
-  setScrollOffset(element, scrollOffset(element) + nextOffset - anchor.offset);
-  return true;
-}
-
-function cardStart(card: HTMLElement): number {
-  const bounds = card.getBoundingClientRect();
-  return props.vertical ? bounds.top : bounds.left;
-}
-
-function cardScrollStep(element: HTMLElement, card: HTMLElement): number {
-  const cards = [...element.querySelectorAll<HTMLElement>("[data-pb-item-id]")];
-  const index = cards.indexOf(card);
-  const neighbor = cards[index + 1] ?? cards[index - 1];
-  if (neighbor !== undefined) {
-    const measured = Math.abs(cardStart(neighbor) - cardStart(card));
-    if (measured > 0) return measured;
-  }
-  const bounds = card.getBoundingClientRect();
-  const gap = Number.parseFloat(getComputedStyle(element).gap) || 0;
-  return (props.vertical ? bounds.height : bounds.width) + gap;
-}
-
-function focusedCardOutsideViewport(
-  element: HTMLElement,
-  card: HTMLElement,
-  direction: -1 | 1,
-): boolean {
-  const trackBounds = element.getBoundingClientRect();
-  const cardBounds = card.getBoundingClientRect();
-  if (props.vertical) {
-    return direction < 0
-      ? cardBounds.top < trackBounds.top
-      : cardBounds.bottom > trackBounds.bottom;
-  }
-  return direction < 0
-    ? cardBounds.left < trackBounds.left
-    : cardBounds.right > trackBounds.right;
-}
-
 watch(
-  () => props.items[0]?.id,
-  async (itemId, previousItemId) => {
-    if (itemId === undefined || itemId === previousItemId) return;
-    const element = track.value;
+  () => props.items,
+  async (items, previousItems) => {
+    const revision = ++itemsRevision;
     const shouldFollow = followLatest.value;
-    const anchor = element === undefined || shouldFollow
-      ? undefined
-      : captureVisibleAnchor(element);
+    const previousIndex = Math.min(previousItems.length - 1, Math.floor(offset.value / stride.value));
+    const anchorId = previousItems[previousIndex]?.id;
+    const withinCard = offset.value - previousIndex * stride.value;
+    clearReorder();
+    // Set the range before patching DOM, otherwise a shortened search result
+    // could briefly mount a blank window at the old scroll position.
+    const anchorIndex = anchorId === undefined ? undefined : itemPositions.value.get(anchorId);
+    const nextOffset = shouldFollow || anchorIndex === undefined
+      ? 0 : Math.max(0, anchorIndex * stride.value + withinCard);
+    offset.value = nextOffset;
     await nextTick();
-    const current = track.value;
-    if (current === undefined) return;
-    if (shouldFollow) {
-      setScrollOffset(current, 0);
-      emit("latestVisible", itemId);
-      return;
-    }
-    if (anchor === undefined || !restoreVisibleAnchor(current, anchor)) {
-      setScrollOffset(current, 0);
-      followLatest.value = true;
-      emit("latestVisible", itemId);
+    if (revision !== itemsRevision || track.value == null) return;
+    measureTrack();
+    setScrollOffset(track.value, nextOffset);
+    if (nextOffset === 0 && items[0] !== undefined && items[0].id !== previousItems[0]?.id) {
+      emit("latestVisible", items[0].id);
     }
   },
 );
@@ -232,34 +232,53 @@ watch(
 watch(
   () => props.focusedId,
   async (itemId, previousItemId) => {
-    if (itemId === undefined || previousItemId === undefined || itemId === previousItemId) {
-      return;
-    }
-    const previousIndex = props.items.findIndex((item) => item.id === previousItemId);
-    const nextIndex = props.items.findIndex((item) => item.id === itemId);
-    if (previousIndex < 0 || nextIndex < 0 || previousIndex === nextIndex) return;
-    const direction: -1 | 1 = nextIndex < previousIndex ? -1 : 1;
+    if (itemId === undefined || itemId === previousItemId) return;
     await nextTick();
-    const element = track.value;
-    if (element === undefined) return;
-    const card = [...element.querySelectorAll<HTMLElement>("[data-pb-item-id]")]
-      .find((candidate) => candidate.dataset.pbItemId === itemId);
-    if (card === undefined || !focusedCardOutsideViewport(element, card, direction)) {
-      return;
-    }
-    setScrollOffset(
-      element,
-      scrollOffset(element) + direction * cardScrollStep(element, card),
-    );
-    updateFollowLatest();
+    if (track.value == null || props.focusedId !== itemId) return;
+    const index = itemPositions.value.get(itemId);
+    if (index === undefined) return;
+    setScrollOffset(track.value, timelineFocusOffset(
+      index, stride.value, cardSize.value, offset.value, viewport.value,
+    ));
   },
 );
 
-onMounted(() => {
-  updateFollowLatest();
+async function focusItem(itemId: string): Promise<void> {
+  await nextTick();
+  const element = track.value;
+  const index = itemPositions.value.get(itemId);
+  if (element == null || index === undefined) return;
+  setScrollOffset(element, timelineFocusOffset(
+    index, stride.value, cardSize.value, offset.value, viewport.value,
+  ));
+  await nextTick();
+  if (props.focusedId !== itemId) return;
+  const card = [...element.querySelectorAll<HTMLElement>("[data-pb-item-id]")]
+    .find((candidate) => candidate.dataset.pbItemId === itemId);
+  card?.focus({ preventScroll: true });
+}
+
+defineExpose({ focusItem });
+
+watch(track, (element) => {
+  resizeObserver?.disconnect();
+  if (element == null) return;
+  measureTrack();
+  resizeObserver = new ResizeObserver(measureTrack);
+  resizeObserver.observe(element);
   const itemId = props.items[0]?.id;
   if (itemId !== undefined && followLatest.value) emit("latestVisible", itemId);
+}, { flush: "post" });
+
+watch(() => [props.vertical, props.compact], async () => {
+  const index = Math.floor(offset.value / stride.value);
+  await nextTick();
+  if (track.value == null) return;
+  measureTrack();
+  setScrollOffset(track.value, index * stride.value);
 });
+
+onBeforeUnmount(() => resizeObserver?.disconnect());
 </script>
 
 <template>
@@ -285,28 +304,36 @@ onMounted(() => {
       @dragend="clearReorder"
       @dragleave.self="reorderTarget = undefined"
     >
-      <PasteCard
-        v-for="(item, index) in props.items"
-        :key="item.id"
-        :item="item"
-        :pinboards="props.pinboards"
-        :index="index"
-        :selected="props.selectedIds.includes(item.id)"
-        :vertical="props.vertical"
-        :compact="props.compact"
-        :reorder-enabled="props.reorderEnabled"
-        :reorder-active="draggedItemIds.length > 0"
-        :reorder-hidden="draggedItemIdSet.has(item.id)"
-        :reorder-item-ids="reorderItemIdsFor(item.id)"
-        :reorder-shift="reorderShifts.get(item.id) ?? 0"
-        @select="forwardSelect"
-        @paste="emit('paste', $event)"
-        @preview="emit('preview', $event)"
-        @assign-pinboard="emit('assignPinboard', $event.pinboardId, $event.itemId)"
-        @create-pinboard="emit('createPinboard')"
-        @reorder-drag-start="beginReorder"
-        @reorder-drag-end="clearReorder"
-      />
+      <div class="timeline__content" :style="contentStyle">
+        <div
+          v-for="{ item, index } in renderedItems"
+          :key="item.id"
+          class="timeline__slot"
+          :style="slotStyle(index)"
+        >
+          <PasteCard
+            :item="item"
+            :pinboards="props.pinboards"
+            :index="index"
+            :selected="selectedIdSet.has(item.id)"
+            :total="props.total ?? props.items.length"
+            :vertical="props.vertical"
+            :compact="props.compact"
+            :reorder-enabled="props.reorderEnabled"
+            :reorder-active="draggedItemIds.length > 0"
+            :reorder-hidden="draggedItemIdSet.has(item.id)"
+            :reorder-item-ids="reorderItemIdsFor(item.id)"
+            :reorder-shift="reorderShifts.get(item.id) ?? 0"
+            @select="forwardSelect"
+            @paste="emit('paste', $event)"
+            @preview="emit('preview', $event)"
+            @assign-pinboard="emit('assignPinboard', $event.pinboardId, $event.itemId)"
+            @create-pinboard="emit('createPinboard')"
+            @reorder-drag-start="beginReorder"
+            @reorder-drag-end="clearReorder"
+          />
+        </div>
+      </div>
     </div>
   </section>
 </template>
@@ -320,19 +347,23 @@ onMounted(() => {
 
 .timeline__track {
   --pb-reorder-gap: 12px;
-  display: flex;
-  gap: 12px;
+  --pb-card-height: 142px;
   min-height: 150px;
   padding: 4px 3px 12px;
   overflow-x: auto;
   overscroll-behavior-x: contain;
-  scroll-snap-type: x proximity;
+  overflow-anchor: none;
   scrollbar-color: color-mix(in srgb, var(--pb-violet) 30%, transparent) transparent;
   scrollbar-width: thin;
 }
 
-.timeline__track > * {
-  scroll-snap-align: start;
+.timeline__content {
+  position: relative;
+}
+
+.timeline__slot {
+  position: absolute;
+  height: var(--pb-card-height);
 }
 
 .timeline--vertical {
@@ -341,14 +372,12 @@ onMounted(() => {
 }
 
 .timeline--vertical .timeline__track {
-  flex-direction: column;
   height: 100%;
   min-height: 0;
   padding: 4px 4px 12px;
   overflow-x: hidden;
   overflow-y: auto;
   overscroll-behavior-y: contain;
-  scroll-snap-type: y proximity;
 }
 
 .timeline--vertical.timeline--compact {
@@ -357,7 +386,7 @@ onMounted(() => {
 
 .timeline--vertical.timeline--compact .timeline__track {
   --pb-reorder-gap: 8px;
-  gap: 8px;
+  --pb-card-height: 108px;
   padding: 3px 3px 9px;
 }
 
diff --git a/plugins/pasteboard-pro/apps/ztools/src/components/Toolbar.vue b/plugins/pasteboard-pro/apps/ztools/src/components/Toolbar.vue
index a7c03f4ab..1fb059712 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/components/Toolbar.vue
+++ b/plugins/pasteboard-pro/apps/ztools/src/components/Toolbar.vue
@@ -1,12 +1,15 @@
 <script setup lang="ts">
+import { computed } from "vue";
 import type { DockEdge } from "@pasteboard-pro/design-tokens";
 
+import { primaryModifierName, resolveShortcutPlatform } from "../platform-shortcuts";
 import SearchBar from "./SearchBar.vue";
 
 defineProps<{
   query: string;
   paused: boolean;
   compact: boolean;
+  canCaptureScreen: boolean;
   edge: DockEdge;
 }>();
 
@@ -16,7 +19,15 @@ const emit = defineEmits<{
   toggleCompact: [];
   openPrivacySettings: [];
   createText: [];
+  captureScreen: [];
 }>();
+
+const createTextShortcutTitle = computed(() => {
+  const platform = resolveShortcutPlatform(
+    window.pasteboardPro?.getPlatformCapabilities().platform,
+  );
+  return `新建文本（${primaryModifierName(platform)}-N）`;
+});
 </script>
 
 <template>
@@ -27,7 +38,14 @@ const emit = defineEmits<{
     </div>
     <SearchBar :model-value="query" @update:model-value="emit('update:query', $event)" />
     <div class="toolbar__actions">
-      <button type="button" class="tool-button" title="新建文本（Command-N）" @click="emit('createText')"><span aria-hidden="true">＋</span>新建</button>
+      <button type="button" class="tool-button" :title="createTextShortcutTitle" @click="emit('createText')"><span aria-hidden="true">＋</span>新建</button>
+      <button
+        v-if="canCaptureScreen"
+        type="button"
+        class="tool-button"
+        title="截取屏幕并加入剪贴板历史"
+        @click="emit('captureScreen')"
+      ><span aria-hidden="true">⌗</span>截图</button>
       <button
         type="button"
         class="tool-button"
diff --git a/plugins/pasteboard-pro/apps/ztools/src/env.d.ts b/plugins/pasteboard-pro/apps/ztools/src/env.d.ts
index cc14fbd0b..d273919a3 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/env.d.ts
+++ b/plugins/pasteboard-pro/apps/ztools/src/env.d.ts
@@ -1,3 +1,5 @@
+import type { ListReorderRequest } from "./list-order";
+import type { HistoryPage, HistoryRequest } from "../preload/history-page";
 /// <reference types="vite/client" />
 
 import type {
@@ -16,17 +18,38 @@ import type { PasteStackState } from "@pasteboard-pro/core";
 declare global {
   interface Window {
     pasteboardPro?: Readonly<{
+      getHostCompatibility(): {
+        currentVersion?: string;
+        minimumVersion: string;
+        supported: boolean;
+        supportsPluginData: boolean;
+        supportsNativeFileDrag: boolean;
+        supportsScreenCapture: boolean;
+      };
       getPlatformCapabilities(): {
         platform: NodeJS.Platform;
         supportsGlobalPasteQueue: boolean;
         supportsQuickLook: boolean;
         supportsSystemOcr: boolean;
         supportsImageRotation: boolean;
+        supportsNativeFileDrag: boolean;
+        supportsScreenCapture: boolean;
       };
+      captureScreenshot(): Promise<{
+        bounds?: {
+          x: number;
+          y: number;
+          width: number;
+          height: number;
+        };
+      }>;
       searchHistory(
         query?: string,
         limit?: number,
       ): Promise<Readonly<{ items: unknown[]; total: number }>>;
+      searchHistoryPage?(request: HistoryRequest): Promise<HistoryPage>;
+      getHistoryItem?(itemId: string, fingerprint?: string): Promise<unknown>;
+      reorderHistory?(request: ListReorderRequest, pinboardId?: string): Promise<ListOrders>;
       getPrivacySettings(): Promise<PrivacySettings>;
       savePrivacySettings(settings: PrivacySettings): Promise<PrivacySettings>;
       setCapturePause(pause: CapturePauseState): Promise<PrivacySettings>;
diff --git a/plugins/pasteboard-pro/apps/ztools/src/history-pager.ts b/plugins/pasteboard-pro/apps/ztools/src/history-pager.ts
new file mode 100644
index 000000000..80777a26e
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/src/history-pager.ts
@@ -0,0 +1,78 @@
+import type { HistoryPage, HistoryRequest } from "../preload/history-page";
+
+/** Serializes reads; a new query supersedes in-flight pages before they reach Vue. */
+export class HistoryPager {
+  private request: HistoryRequest = {};
+  private revision = 0;
+  private dirty = false;
+  private desiredCount = 50;
+  private pending: Promise<void> | undefined;
+  private page: HistoryPage = { items: [], total: 0 };
+  private disposed = false;
+
+  constructor(
+    private readonly read: (request: HistoryRequest) => Promise<HistoryPage>,
+    private readonly apply: (page: HistoryPage) => void,
+  ) {}
+
+  refresh(request: HistoryRequest, preserveCount = false): Promise<void> {
+    this.request = request;
+    this.revision++;
+    this.desiredCount = preserveCount ? Math.max(50, this.page.items.length) : 50;
+    this.dirty = true;
+    return this.run();
+  }
+
+  loadMore(): Promise<void> {
+    if (this.pending !== undefined || this.page.nextCursor === undefined) return this.pending ?? Promise.resolve();
+    return this.run(true);
+  }
+
+  invalidate(): void { this.revision++; this.dirty = false; }
+  dispose(): void { this.disposed = true; this.invalidate(); }
+
+  private async readCurrent(request: HistoryRequest, revision: number): Promise<HistoryPage | undefined> {
+    try { return await this.read(request); }
+    catch (error) {
+      if (revision !== this.revision || this.disposed) return undefined;
+      throw error;
+    }
+  }
+
+  private run(append = false): Promise<void> {
+    this.pending ??= Promise.resolve().then(async () => {
+      try {
+        do {
+          if (this.disposed) return;
+          const revision = this.revision;
+          const request = this.request;
+          const continuing = append && !this.dirty;
+          this.dirty = false;
+          let page = await this.readCurrent({
+            ...request, limit: 50,
+            ...(continuing && this.page.nextCursor !== undefined ? { cursor: this.page.nextCursor } : {}),
+          }, revision);
+          if (page === undefined) { append = false; continue; }
+          if (revision !== this.revision || this.disposed) { append = false; continue; }
+          if (continuing && !page.reset) page = { ...page, items: [...this.page.items, ...page.items] };
+          // Refresh the previously loaded range so clipboard changes do not
+          // discard a scrolled-to page or its keyboard selection.
+          while (!continuing && page.items.length < this.desiredCount && page.nextCursor !== undefined) {
+            const next = await this.readCurrent({ ...request, limit: 50, cursor: page.nextCursor }, revision);
+            if (next === undefined) break;
+            if (revision !== this.revision || this.disposed) break;
+            if (next.reset) { this.dirty = true; break; }
+            page = { ...next, items: [...page.items, ...next.items] };
+          }
+          if (revision === this.revision && !this.disposed && !this.dirty) {
+            const seen = new Set<string>();
+            this.page = { ...page, items: page.items.filter(item => !seen.has(item.id) && !!seen.add(item.id)) };
+            this.apply(this.page);
+          }
+          append = false;
+        } while (this.dirty && !this.disposed);
+      } finally { this.pending = undefined; }
+    });
+    return this.pending;
+  }
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/src/history-refresh.ts b/plugins/pasteboard-pro/apps/ztools/src/history-refresh.ts
new file mode 100644
index 000000000..6e34b87af
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/src/history-refresh.ts
@@ -0,0 +1,25 @@
+/** Serialize reads and merge a burst of change notifications into one follow-up. */
+export function createHistoryRefresh<T>(
+  read: () => Promise<T>,
+  apply: (value: T) => void,
+): () => Promise<void> {
+  let pending: Promise<void> | undefined;
+  let dirty = false;
+  return () => {
+    dirty = true;
+    pending ??= Promise.resolve().then(async () => {
+      try {
+        while (dirty) {
+          dirty = false;
+          const value = await read();
+          // A newer change arrived while reading; don't replace the UI with a
+          // stale snapshot. All callers wait for the final, up-to-date result.
+          if (!dirty) apply(value);
+        }
+      } finally {
+        pending = undefined;
+      }
+    });
+    return pending;
+  };
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/src/hotkey-settings.ts b/plugins/pasteboard-pro/apps/ztools/src/hotkey-settings.ts
new file mode 100644
index 000000000..f4a96f730
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/src/hotkey-settings.ts
@@ -0,0 +1,21 @@
+/** The command label registered by the Paste plugin in ZTools. */
+export const pasteShortcutCommandLabel = "pasteboard-pro/Paste剪切板";
+
+export type ZToolsShortcutSettingsApi = Readonly<{
+  redirectHotKeySetting?: (cmdLabel: string) => void | boolean;
+}>;
+
+/**
+ * Opens ZTools' native shortcut settings when the host supports the public API.
+ * The boolean result lets the renderer give useful feedback in Web Dev previews.
+ */
+export function openPasteShortcutSettings(
+  ztools: ZToolsShortcutSettingsApi | undefined,
+): boolean {
+  if (typeof ztools?.redirectHotKeySetting !== "function") return false;
+  try {
+    return ztools.redirectHotKeySetting(pasteShortcutCommandLabel) !== false;
+  } catch {
+    return false;
+  }
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/src/keyboard-routing.ts b/plugins/pasteboard-pro/apps/ztools/src/keyboard-routing.ts
new file mode 100644
index 000000000..ff0798b0c
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/src/keyboard-routing.ts
@@ -0,0 +1,20 @@
+export type ShelfKeyboardTarget = Readonly<{
+  nativeControl: boolean;
+  listCard: boolean;
+}>;
+
+export type ShelfKeyboardRoute = "native-control" | "list-card" | undefined;
+
+/**
+ * Keeps Enter/Space on buttons and menu items native while routing card
+ * activation through the single window-level list state machine.
+ */
+export function shelfKeyboardRoute(
+  key: string,
+  target: ShelfKeyboardTarget,
+): ShelfKeyboardRoute {
+  if (key !== "Enter" && key !== " ") return undefined;
+  if (target.nativeControl) return "native-control";
+  if (target.listCard) return "list-card";
+  return undefined;
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/src/list-control-key.ts b/plugins/pasteboard-pro/apps/ztools/src/list-control-key.ts
index 57bafee86..75a85b68e 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/list-control-key.ts
+++ b/plugins/pasteboard-pro/apps/ztools/src/list-control-key.ts
@@ -1,13 +1,16 @@
+import { hasAnyCommandModifier } from "./platform-shortcuts";
+
 export type ListControlKeyboardEvent = Readonly<{
   key: string;
   metaKey: boolean;
+  ctrlKey?: boolean;
   altKey: boolean;
 }>;
 
 export function shouldResumeListControl(
   event: ListControlKeyboardEvent,
 ): boolean {
-  if (event.metaKey || event.altKey) return false;
+  if (hasAnyCommandModifier(event)) return false;
   return isListNavigationKey(event.key) || event.key === "Enter";
 }
 
diff --git a/plugins/pasteboard-pro/apps/ztools/src/platform-shortcuts.ts b/plugins/pasteboard-pro/apps/ztools/src/platform-shortcuts.ts
new file mode 100644
index 000000000..2f4e02cc1
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/src/platform-shortcuts.ts
@@ -0,0 +1,76 @@
+/**
+ * Renderer-friendly platform conventions for shortcuts. Keep the platform an
+ * explicit input so keyboard behavior can be tested on any development host.
+ */
+export type ShortcutPlatform = "darwin" | "win32" | "linux";
+
+export type PrimaryModifierEvent = Readonly<{
+  metaKey: boolean;
+  ctrlKey?: boolean;
+}>;
+
+export type ShortcutModifierEvent = PrimaryModifierEvent & Readonly<{
+  altKey?: boolean;
+}>;
+
+export type PrimaryShortcutEvent = ShortcutModifierEvent & Readonly<{
+  key: string;
+  shiftKey?: boolean;
+}>;
+
+export function resolveShortcutPlatform(
+  platform: string | undefined,
+  browserPlatform: string | undefined =
+    typeof navigator === "undefined" ? undefined : navigator.platform,
+): ShortcutPlatform {
+  if (platform === "darwin") return "darwin";
+  if (platform === "win32") return "win32";
+  if (platform === "linux") return "linux";
+  if (/mac/i.test(browserPlatform ?? "")) return "darwin";
+  if (/win/i.test(browserPlatform ?? "")) return "win32";
+  return "linux";
+}
+
+export function hasPrimaryModifier(
+  event: PrimaryModifierEvent,
+  platform: ShortcutPlatform,
+): boolean {
+  return platform === "darwin" ? event.metaKey : event.ctrlKey === true;
+}
+
+/**
+ * Matches the platform's primary modifier without also accepting the other
+ * operating-system modifier or Alt. Shift is intentionally left to the
+ * individual shortcut so Shift+primary can retain its existing meaning.
+ */
+export function hasPrimaryShortcutModifier(
+  event: ShortcutModifierEvent,
+  platform: ShortcutPlatform,
+): boolean {
+  if (!hasPrimaryModifier(event, platform) || event.altKey === true) return false;
+  return platform === "darwin" ? event.ctrlKey !== true : !event.metaKey;
+}
+
+export function matchesPrimaryShortcut(
+  event: PrimaryShortcutEvent,
+  platform: ShortcutPlatform,
+  key: string,
+): boolean {
+  return (
+    hasPrimaryShortcutModifier(event, platform) &&
+    event.shiftKey !== true &&
+    event.key.toLowerCase() === key.toLowerCase()
+  );
+}
+
+export function hasAnyCommandModifier(event: ShortcutModifierEvent): boolean {
+  return event.metaKey || event.ctrlKey === true || event.altKey === true;
+}
+
+export function primaryModifierLabel(platform: ShortcutPlatform): "⌘" | "Ctrl" {
+  return platform === "darwin" ? "⌘" : "Ctrl";
+}
+
+export function primaryModifierName(platform: ShortcutPlatform): "Command" | "Ctrl" {
+  return platform === "darwin" ? "Command" : "Ctrl";
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/src/state.ts b/plugins/pasteboard-pro/apps/ztools/src/state.ts
index ac331b069..85504ed35 100644
--- a/plugins/pasteboard-pro/apps/ztools/src/state.ts
+++ b/plugins/pasteboard-pro/apps/ztools/src/state.ts
@@ -14,10 +14,16 @@ import {
   pasteboardTokens,
   type DockEdge,
 } from "@pasteboard-pro/design-tokens";
+import {
+  hasAnyCommandModifier,
+  hasPrimaryShortcutModifier,
+  type ShortcutPlatform,
+} from "./platform-shortcuts";
 
 export type PasteboardKeyboardEvent = Readonly<{
   key: string;
   metaKey: boolean;
+  ctrlKey?: boolean;
   shiftKey: boolean;
   altKey: boolean;
 }>;
@@ -43,16 +49,20 @@ export type PasteboardStateInput = Readonly<{
   }>;
   dockEdge?: DockEdge;
   density?: ShelfDensity;
+  shortcutPlatform?: ShortcutPlatform;
 }>;
 
 export function keyboardAction(
   event: PasteboardKeyboardEvent,
   orderedIds: readonly string[],
+  shortcutPlatform: ShortcutPlatform = "darwin",
 ): SelectionAction | null {
-  if (event.metaKey && !event.shiftKey && !event.altKey && event.key.toLowerCase() === "a") {
+  const hasPrimary = hasPrimaryShortcutModifier(event, shortcutPlatform);
+  const hasCommandModifier = hasAnyCommandModifier(event);
+  if (hasPrimary && !event.shiftKey && !event.altKey && event.key.toLowerCase() === "a") {
     return { type: "select-all", orderedIds };
   }
-  if (!event.metaKey && !event.altKey && event.shiftKey) {
+  if (!hasCommandModifier && event.shiftKey) {
     if (event.key === "ArrowLeft" || event.key === "ArrowUp") {
       return { type: "extend", orderedIds, direction: -1 };
     }
@@ -61,7 +71,7 @@ export function keyboardAction(
     }
   }
   if (
-    !event.metaKey &&
+    !hasCommandModifier &&
     !event.shiftKey &&
     !event.altKey &&
     event.key === "Escape"
@@ -125,11 +135,13 @@ export class PasteboardState {
   private items: PasteItem[];
   private readonly explicitOrder: ReadonlyMap<string, number> | undefined;
   private query = "";
+  private resolvedItems = false;
 
   selection: SelectionState;
   pasteStack: PasteStackState;
   dockEdge: DockEdge;
   density: ShelfDensity;
+  private readonly shortcutPlatform: ShortcutPlatform;
 
   constructor(input: PasteboardStateInput) {
     this.items = input.items.map((item) => PasteItemSchema.parse(item));
@@ -141,9 +153,11 @@ export class PasteboardState {
     this.pasteStack = clonePasteStack(input.pasteStack);
     this.dockEdge = input.dockEdge ?? "floating";
     this.density = input.density ?? "expanded";
+    this.shortcutPlatform = input.shortcutPlatform ?? "darwin";
   }
 
   get visibleItems(): PasteItem[] {
+    if (this.resolvedItems) return this.items;
     const items = searchPasteItems(this.items, this.query);
     if (this.query.trim().length > 0 || this.explicitOrder === undefined) {
       return items;
@@ -175,7 +189,13 @@ export class PasteboardState {
     });
   }
 
+  replaceResolvedItems(items: readonly unknown[]): void {
+    this.resolvedItems = true;
+    this.items = items.map(item => PasteItemSchema.parse(item));
+  }
+
   replaceItems(items: readonly unknown[]): void {
+    this.resolvedItems = false;
     this.items = items.map((item) => PasteItemSchema.parse(item));
     const orderedIds = this.visibleItems.map((item) => item.id);
     this.selection = reduceSelection(this.selection, {
@@ -293,20 +313,22 @@ export class PasteboardState {
     orderedIds: readonly string[] = this.visibleItems.map((item) => item.id),
   ): PasteboardKeyboardEffect | null {
     const scopedIds = this.scopedOrderedIds(orderedIds);
-    const selectionAction = keyboardAction(event, scopedIds);
+    const selectionAction = keyboardAction(event, scopedIds, this.shortcutPlatform);
     if (selectionAction !== null) {
       this.selection = reduceSelection(this.selection, selectionAction);
       return null;
     }
 
-    if (event.metaKey && !event.altKey && /^[1-9]$/u.test(event.key)) {
+    const hasPrimary = hasPrimaryShortcutModifier(event, this.shortcutPlatform);
+    const hasCommandModifier = hasAnyCommandModifier(event);
+    if (hasPrimary && !event.altKey && /^[1-9]$/u.test(event.key)) {
       const itemId = scopedIds[Number(event.key) - 1];
       return itemId === undefined
         ? null
         : { type: "quick-paste", itemId, plainText: event.shiftKey };
     }
 
-    if (!event.metaKey && !event.shiftKey && !event.altKey) {
+    if (!hasCommandModifier && !event.shiftKey) {
       if (
         event.key === "ArrowLeft" ||
         event.key === "ArrowRight" ||
@@ -336,7 +358,7 @@ export class PasteboardState {
       }
     }
 
-    if (!event.metaKey && event.shiftKey && !event.altKey && event.key === "Enter") {
+    if (!hasCommandModifier && event.shiftKey && event.key === "Enter") {
       const available = new Set(scopedIds);
       const selected = this.selection.selected.filter((id) => available.has(id));
       return selected.length === 0
diff --git a/plugins/pasteboard-pro/apps/ztools/src/virtual-timeline.ts b/plugins/pasteboard-pro/apps/ztools/src/virtual-timeline.ts
new file mode 100644
index 000000000..92f63552e
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/src/virtual-timeline.ts
@@ -0,0 +1,33 @@
+/** Fixed-size cards share a scroll axis in horizontal and vertical docks. */
+export function timelineRange(
+  count: number,
+  stride: number,
+  offset: number,
+  viewport: number,
+): Readonly<{ start: number; end: number }> {
+  if (count === 0) return { start: 0, end: 0 };
+  const first = Math.min(count - 1, Math.max(0, Math.floor(offset / stride)));
+  const visibleEnd = Math.min(count, Math.max(first + 1, Math.ceil((offset + viewport) / stride)));
+  const visibleCount = visibleEnd - first;
+  // Keep 30–50 cards warm, sharing the buffer across both sides. A viewport
+  // large enough to show more than 50 cards must still be covered completely.
+  const size = Math.min(count, Math.max(visibleCount, Math.min(50, Math.max(30, visibleCount + 20))));
+  const start = Math.max(0, Math.min(count - size, first - Math.floor((size - visibleCount) / 2)));
+  return { start, end: start + size };
+}
+
+/** Bring even an unmounted keyboard target into view, without a DOM lookup. */
+export function timelineFocusOffset(
+  index: number,
+  stride: number,
+  cardSize: number,
+  offset: number,
+  viewport: number,
+): number {
+  const start = index * stride;
+  if (start < offset) return start;
+  if (start + cardSize > offset + viewport) {
+    return cardSize > viewport ? start : Math.max(0, start + cardSize - viewport);
+  }
+  return offset;
+}
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/adapter.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/adapter.test.ts
index b50e60c5f..d02a97364 100644
--- a/plugins/pasteboard-pro/apps/ztools/tests/adapter.test.ts
+++ b/plugins/pasteboard-pro/apps/ztools/tests/adapter.test.ts
@@ -463,3 +463,21 @@ describe("ZTools clipboard adapter", () => {
     });
   });
 });
+
+
+describe("shared history search snapshot", () => {
+  it("uses one database read for search results and native drag records", async () => {
+    const allDocs = vi.fn(async () => ({ rows: [] }));
+    const store = new ZToolsCanonicalClipboardStore({
+      get: async () => undefined,
+      put: async () => ({ ok: true }),
+      allDocs,
+    });
+    await expect(store.searchWithRecords("", 10000)).resolves.toEqual({
+      result: { items: [], total: 0 }, records: [],
+    });
+    expect(allDocs).toHaveBeenCalledTimes(1);
+    await expect(store.searchWithRecords("", 0)).rejects.toThrow(RangeError);
+    expect(allDocs).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/assembly.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/assembly.test.ts
index fe1137802..2740844e2 100644
--- a/plugins/pasteboard-pro/apps/ztools/tests/assembly.test.ts
+++ b/plugins/pasteboard-pro/apps/ztools/tests/assembly.test.ts
@@ -29,6 +29,7 @@ async function packageFixture(): Promise<string> {
   await Promise.all([
     writeFile(path.join(root, "index.html"), "<!doctype html>"),
     writeFile(path.join(root, "preload.js"), ""),
+    writeFile(path.join(root, "history-worker.cjs"), ""),
     writeFile(path.join(root, "logo.svg"), "<svg/>", "utf8"),
     writeFile(path.join(root, "package.json"), '{"type":"commonjs"}'),
     writeFile(path.join(root, "pasteboard-vision"), "binary"),
@@ -46,6 +47,12 @@ describe("ZTools package assembly verifier", () => {
     expect(result.files).toContain(path.join("assets", "index.js"));
   });
 
+  it("rejects packages missing the search worker", async () => {
+    const root = await packageFixture();
+    await rm(path.join(root, "history-worker.cjs"));
+    await expect(verifyAssembledPackage(root)).rejects.toThrow();
+  });
+
   it("rejects source maps and credential-like files", async () => {
     const root = await packageFixture();
     await writeFile(path.join(root, "assets", "index.js.map"), "{}");
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/browser/history-worker.ts b/plugins/pasteboard-pro/apps/ztools/tests/browser/history-worker.ts
new file mode 100644
index 000000000..f73c9396d
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/browser/history-worker.ts
@@ -0,0 +1,24 @@
+import { HistorySearchIndex } from "../../preload/history-search-index";
+import type { HistoryRequest } from "../../preload/history-page";
+import type { PasteItem } from "@pasteboard-pro/core";
+
+function item(i: number): PasteItem {
+  return {
+    id: `item-${i}`, kind: "text", title: `Record ${i}`,
+    sourceDeviceId: "test", copiedAt: new Date(1_800_000_000_000 - i).toISOString(),
+    updatedAt: new Date(1_800_000_000_000 - i).toISOString(),
+    contentFingerprint: `sha256:${i}`, payload: {
+      revision: String(i), text: i === 99_999 ? "x".repeat(8_192) + " 中文尾部命中" : `Clipboard ${i}`,
+    }, pinned: false, fieldClocks: {},
+  };
+}
+const index = new HistorySearchIndex();
+function document(i: number) {
+  return { _id: `pasteboard-pro:record:sha256:${i}`, type: "pasteboard-pro-record",
+    record: { item: item(i), origin: { host: "sync", remoteAvailable: true } } };
+}
+index.replace(Array.from({ length: 100_000 }, (_, i) => document(i)));
+globalThis.onmessage = (event: MessageEvent<{ id: number; request: HistoryRequest; prepend?: boolean }>) => {
+  if (event.data.prepend) index.update([document(-1)], []);
+  globalThis.postMessage({ id: event.data.id, page: index.page(event.data.request) });
+};
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/browser/history.html b/plugins/pasteboard-pro/apps/ztools/tests/browser/history.html
new file mode 100644
index 000000000..a3833a1fa
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/browser/history.html
@@ -0,0 +1,3 @@
+<!doctype html>
+<html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>History performance fixture</title></head>
+<body><div id="app"></div><script type="module" src="./history.ts"></script></body></html>
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/browser/history.ts b/plugins/pasteboard-pro/apps/ztools/tests/browser/history.ts
new file mode 100644
index 000000000..537144d04
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/browser/history.ts
@@ -0,0 +1,31 @@
+import type { HistoryPage, HistoryRequest } from "../../preload/history-page";
+
+const worker = new Worker(new URL("./history-worker.ts", import.meta.url), { type: "module" });
+let sequence = 0;
+const pending = new Map<number, (page: HistoryPage) => void>();
+const metrics = { requests: [] as HistoryRequest[], sizes: [] as number[], prepend: false };
+worker.onmessage = (event: MessageEvent<{ id: number; page: HistoryPage }>) => {
+  metrics.sizes.push(event.data.page.items.length);
+  pending.get(event.data.id)?.(event.data.page);
+  pending.delete(event.data.id);
+};
+(window as Window & { historyTest?: typeof metrics }).historyTest = metrics;
+window.pasteboardPro = {
+  getHostCompatibility: () => ({ supported: true }),
+  getPlatformCapabilities: () => ({ platform: "darwin" }),
+  getWindowPreferences: async () => undefined,
+  getPrivacySettings: async () => ({ pause: { paused: false } }),
+  getListOrders: async () => ({}),
+  getPasteStack: async () => undefined,
+  getItemThumbnails: async () => [],
+  prepareNativeFileDrag: async () => false,
+  listPinboards: async () => [],
+  searchHistoryPage: (request: HistoryRequest) => new Promise<HistoryPage>(resolve => {
+    metrics.requests.push(request);
+    const id = ++sequence;
+    pending.set(id, resolve);
+    worker.postMessage({ id, request, prepend: metrics.prepend });
+    metrics.prepend = false;
+  }),
+} as unknown as NonNullable<Window["pasteboardPro"]>;
+await import("../../src/main");
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/browser/timeline.html b/plugins/pasteboard-pro/apps/ztools/tests/browser/timeline.html
new file mode 100644
index 000000000..d02eda83b
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/browser/timeline.html
@@ -0,0 +1,3 @@
+<!doctype html>
+<html><head><meta charset="UTF-8"><link rel="icon" href="data:,"><title>Timeline performance fixture</title></head>
+<body><div id="app"></div><script type="module" src="./timeline.ts"></script></body></html>
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/browser/timeline.ts b/plugins/pasteboard-pro/apps/ztools/tests/browser/timeline.ts
new file mode 100644
index 000000000..afc382007
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/browser/timeline.ts
@@ -0,0 +1,82 @@
+import { createApp, h, nextTick, ref, shallowRef } from "vue";
+import Timeline from "../../src/components/Timeline.vue";
+import { reorderItemGroupIds, type ListReorderRequest } from "../../src/list-order";
+import type { PasteItem } from "@pasteboard-pro/core";
+import "../../src/styles/tokens.css";
+import "../../src/styles/layout.css";
+
+const params = new URLSearchParams(location.search);
+const count = Number(params.get("count") ?? 10000);
+const vertical = ref(params.get("vertical") === "1");
+const compact = ref(params.get("compact") === "1");
+const image = params.get("images") === "1";
+const makeItem = (index: number): PasteItem => ({
+  id: `item-${index}`, kind: image ? "image" : "text", title: `Record ${index}`,
+  sourceDeviceId: "test", copiedAt: new Date(1800000000000 - index).toISOString(),
+  updatedAt: new Date(1800000000000 - index).toISOString(),
+  contentFingerprint: `sha256:${index}`, payload: {
+    revision: String(index), ...(image ? { blobId: `blob-${index}`, mediaType: "image/png" } : { text: `Clipboard record ${index}` }),
+  }, pinned: false, fieldClocks: {},
+});
+const items = shallowRef(Array.from({ length: count }, (_, index) => makeItem(index)));
+const selected = ref<string[]>([]);
+const focused = ref<string>();
+const timeline = ref<{ focusItem(itemId: string): Promise<void> }>();
+const thumbnailIds: string[] = [];
+const latest: string[] = [];
+(window as any).pasteboardPro = {
+  getPlatformCapabilities: () => ({ platform: "darwin" }),
+  prepareNativeFileDrag: async () => false,
+  getItemThumbnails: async (ids: string[]) => { thumbnailIds.push(...ids); return []; },
+};
+const started = performance.now();
+createApp({
+  setup: () => () => h("div", {
+    style: {
+      "--pb-card-width": compact.value ? "180px" : "240px",
+      width: vertical.value ? "360px" : "100%",
+      height: vertical.value ? "650px" : "200px",
+      display: "grid", minHeight: 0,
+    },
+  }, [h(Timeline, {
+    ref: timeline, items: items.value, selectedIds: selected.value,
+    focusedId: focused.value, vertical: vertical.value, compact: compact.value, pinboards: [],
+    onSelect: (id: string, extend: boolean, toggle: boolean) => {
+      if (extend && focused.value !== undefined) {
+        const a = items.value.findIndex((item) => item.id === focused.value);
+        const b = items.value.findIndex((item) => item.id === id);
+        selected.value = items.value.slice(Math.min(a, b), Math.max(a, b) + 1).map((item) => item.id);
+      } else if (toggle) {
+        selected.value = selected.value.includes(id) ? selected.value.filter((value) => value !== id) : [...selected.value, id];
+      } else selected.value = [id];
+      focused.value = id;
+    },
+    onLatestVisible: (id: string) => latest.push(id),
+    onReorder: ({ sourceIds, targetId, position }: ListReorderRequest) => {
+      const byId = new Map(items.value.map((item) => [item.id, item]));
+      items.value = reorderItemGroupIds(items.value.map((item) => item.id), sourceIds, targetId, position)
+        .map((id) => byId.get(id)!);
+    },
+  })]),
+}).mount("#app");
+(window as any).timelineTest = {
+  thumbnailIds, latest,
+  ids: () => items.value.map((item) => item.id),
+  selected: () => selected.value,
+  replace: (count: number) => { items.value = Array.from({ length: count }, (_, i) => makeItem(i)); },
+  prepend: () => { items.value = [makeItem(-1), ...items.value]; },
+  remove: (id: string) => { items.value = items.value.filter((item) => item.id !== id); },
+  select: (ids: string[]) => { selected.value = ids; },
+  density: (value: boolean) => { compact.value = value; },
+  focus: async (index: number) => {
+    focused.value = items.value[index]!.id;
+    selected.value = [focused.value];
+    await nextTick();
+    await timeline.value?.focusItem(focused.value);
+  },
+  ready: false, mountMs: 0,
+};
+await nextTick();
+await new Promise(requestAnimationFrame);
+(window as any).timelineTest.mountMs = performance.now() - started;
+(window as any).timelineTest.ready = true;
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/clipboard-window-role.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/clipboard-window-role.test.ts
new file mode 100644
index 000000000..1d9d1f0d1
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/clipboard-window-role.test.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  clipboardWindowRole,
+  ownsClipboardHistoryMirror,
+} from "../preload/clipboard-window-role";
+
+describe("clipboard window responsibilities", () => {
+  it("assigns clipboard history mirroring exclusively to the primary preload", () => {
+    const primary = clipboardWindowRole(new URLSearchParams());
+    const shelf = clipboardWindowRole(new URLSearchParams("shelf=1"));
+    const panel = clipboardWindowRole(new URLSearchParams("panel=privacy"));
+
+    expect(primary).toBe("primary");
+    expect(shelf).toBe("shelf");
+    expect(panel).toBe("panel");
+    expect(ownsClipboardHistoryMirror(primary)).toBe(true);
+    expect(ownsClipboardHistoryMirror(shelf)).toBe(false);
+    expect(ownsClipboardHistoryMirror(panel)).toBe(false);
+  });
+
+  it("keeps a shelf window non-owning even if a panel parameter is present", () => {
+    const role = clipboardWindowRole(
+      new URLSearchParams("shelf=1&panel=privacy"),
+    );
+    expect(role).toBe("shelf");
+    expect(ownsClipboardHistoryMirror(role)).toBe(false);
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/history-refresh.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/history-refresh.test.ts
new file mode 100644
index 000000000..efac0a726
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/history-refresh.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from "vitest";
+import { createHistoryRefresh } from "../src/history-refresh";
+
+describe("history refresh", () => {
+  it("coalesces synchronous notifications into one read", async () => {
+    const read = vi.fn(async () => 1);
+    const apply = vi.fn();
+    const refresh = createHistoryRefresh(read, apply);
+    await Promise.all(Array.from({ length: 20 }, refresh));
+    expect(read).toHaveBeenCalledTimes(1);
+    expect(apply).toHaveBeenCalledExactlyOnceWith(1);
+  });
+
+  it("serializes an event burst during a read and never applies stale data", async () => {
+    let resolve!: (value: number) => void;
+    const read = vi.fn(() => new Promise<number>((done) => { resolve = done; }));
+    const apply = vi.fn();
+    const refresh = createHistoryRefresh(read, apply);
+    const first = refresh();
+    await Promise.resolve();
+    const waiting = Array.from({ length: 20 }, refresh);
+    expect(read).toHaveBeenCalledTimes(1);
+    resolve(1);
+    await Promise.resolve();
+    expect(read).toHaveBeenCalledTimes(2);
+    expect(apply).not.toHaveBeenCalled();
+    resolve(2);
+    await Promise.all([first, ...waiting]);
+    expect(apply).toHaveBeenCalledExactlyOnceWith(2);
+  });
+
+  it("allows another refresh after failure", async () => {
+    const read = vi.fn().mockRejectedValueOnce(new Error("database busy")).mockResolvedValue(2);
+    const apply = vi.fn();
+    const refresh = createHistoryRefresh(read, apply);
+    await expect(refresh()).rejects.toThrow("database busy");
+    await refresh();
+    expect(apply).toHaveBeenCalledExactlyOnceWith(2);
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/history-search.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/history-search.test.ts
new file mode 100644
index 000000000..b2163c071
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/history-search.test.ts
@@ -0,0 +1,137 @@
+import { describe, expect, it, vi } from "vitest";
+import { historyFixture } from "@pasteboard-pro/contract-fixtures";
+import { PasteItemSchema, searchPasteItems, type PasteItem } from "@pasteboard-pro/core";
+import { HistorySearchIndex } from "../preload/history-search-index";
+import { HistoryPager } from "../src/history-pager";
+import { HistoryRpcClient } from "../preload/history-rpc";
+import { ZToolsCanonicalClipboardStore } from "../preload/clipboard-store";
+import { takeRecordChanges } from "../preload/record-index";
+import type { HistoryPage } from "../preload/history-page";
+
+function item(i: number): PasteItem {
+  return {
+    ...historyFixture[0]!, id: `item-${i}`, contentFingerprint: `fp-${i}`,
+    kind: "text", title: `Record ${i}`, pinned: false,
+    copiedAt: new Date(1_800_000_000_000 - i).toISOString(),
+    payload: { revision: `r-${i}`, text: `Clipboard ${i}` },
+  };
+}
+function doc(value: PasteItem) {
+  return { _id: `pasteboard-pro:record:${value.contentFingerprint}`, type: "pasteboard-pro-record",
+    record: { item: value, origin: { host: "sync", remoteAvailable: true } } };
+}
+
+describe("worker history index", () => {
+  it("searches beyond 10k, pages 100k records and retains full text outside card previews", () => {
+    const index = new HistorySearchIndex();
+    const items = Array.from({ length: 100_000 }, (_, i) => item(i));
+    items[99_999] = { ...items[99_999]!, payload: { revision: "long", text: "x".repeat(8_192) + " 中文尾部命中" } };
+    index.replace(items.map(doc));
+    const first = index.page({});
+    expect(first.total).toBe(100_000);
+    expect(first.items).toHaveLength(50);
+    expect(index.page({ cursor: first.nextCursor! }).items[0]?.id).toBe("item-50");
+    const search = index.page({ query: "中文尾部命中" });
+    expect(search.items.map(value => value.id)).toEqual(["item-99999"]);
+    expect(search.items[0]?.payload.text).toHaveLength(4_096);
+    expect(index.order({})).toHaveLength(100_000);
+  }, 15_000);
+
+  it.each(["", "type:image", "invoice", '"hello world"', "app:Safari", "device:mac", "date:2026-07-16", "board:work"])(
+    "preserves shared search semantics for %s", query => {
+      const index = new HistorySearchIndex();
+      index.replace(historyFixture.map(value => doc(PasteItemSchema.parse(value))));
+      const sorted = historyFixture.map(value => PasteItemSchema.parse(value)).sort((a, b) => Date.parse(b.copiedAt) - Date.parse(a.copiedAt) || a.id.localeCompare(b.id));
+      expect(index.page({ query, limit: 100 }).items.map(value => value.id))
+        .toEqual(searchPasteItems(sorted, query).map(value => value.id));
+    },
+  );
+
+  it("invalidates cursors after a write, deletion or query change without skipping rows", () => {
+    const index = new HistorySearchIndex();
+    index.replace(Array.from({ length: 120 }, (_, i) => doc(item(i))));
+    const first = index.page({});
+    index.update([doc(item(-1))], [doc(item(0))._id]);
+    const restarted = index.page({ cursor: first.nextCursor! });
+    expect(restarted.reset).toBe(true);
+    expect(restarted.items[0]?.id).toBe("item--1");
+    expect(restarted.total).toBe(120);
+    expect(index.page({ query: "missing", cursor: restarted.nextCursor! })).toMatchObject({ items: [], total: 0, reset: true });
+  });
+
+  it("keeps full-scope ordering and filters before paging", () => {
+    const index = new HistorySearchIndex();
+    index.replace(Array.from({ length: 120 }, (_, i) => doc({ ...item(i), pinboardId: i % 2 === 0 ? "work" : "personal" })));
+    const ids = index.order({ pinboardId: "work" });
+    const reordered = [ids.at(-1)!, ...ids.slice(0, -1)];
+    const first = index.page({ pinboardId: "work", orderedIds: reordered });
+    expect(first.total).toBe(60);
+    expect(first.items[0]?.id).toBe("item-118");
+    expect(index.page({ pinboardId: "work", orderedIds: reordered, cursor: first.nextCursor! }).items).toHaveLength(10);
+  });
+});
+
+describe("history pager", () => {
+  it("discards stale replies and coalesces rapid query changes", async () => {
+    let resolve!: (value: HistoryPage) => void;
+    const read = vi.fn().mockImplementationOnce(() => new Promise<HistoryPage>(done => { resolve = done; }))
+      .mockResolvedValue({ items: [item(99)], total: 1 });
+    const apply = vi.fn();
+    const pager = new HistoryPager(read, apply);
+    const first = pager.refresh({ query: "old" });
+    await Promise.resolve();
+    void pager.refresh({ query: "intermediate" });
+    void pager.refresh({ query: "latest" });
+    resolve({ items: [item(0)], total: 1 });
+    await first;
+    expect(read).toHaveBeenCalledTimes(2);
+    expect(read.mock.calls[1]?.[0].query).toBe("latest");
+    expect(apply).toHaveBeenCalledTimes(1);
+    expect(apply.mock.calls[0]?.[0].items[0].id).toBe("item-99");
+  });
+
+  it("preserves the loaded range on refresh and restarts an expired append cursor", async () => {
+    const index = new HistorySearchIndex();
+    index.replace(Array.from({ length: 120 }, (_, i) => doc(item(i))));
+    const apply = vi.fn();
+    const pager = new HistoryPager(async request => index.page(request), apply);
+    await pager.refresh({});
+    await pager.loadMore();
+    expect(apply.mock.lastCall?.[0].items).toHaveLength(100);
+    await pager.refresh({}, true);
+    expect(apply.mock.lastCall?.[0].items).toHaveLength(100);
+    index.update([doc(item(-1))], []);
+    await pager.loadMore();
+    expect(apply.mock.lastCall?.[0].items).toHaveLength(50);
+    expect(apply.mock.lastCall?.[0].items[0].id).toBe("item--1");
+  });
+});
+
+it("routes only the current shelf session's response and cleans up pending RPCs", async () => {
+  const send = vi.fn();
+  const rpc = new HistoryRpcClient("new-window", send);
+  const pending = rpc.page({ query: "needle" });
+  rpc.receive({ id: "old-window:1", page: { items: [], total: 0 } });
+  rpc.receive({ id: send.mock.calls[0]![0], page: { items: [item(1)], total: 1 } });
+  await expect(pending).resolves.toMatchObject({ total: 1 });
+  const closing = rpc.page({});
+  rpc.dispose();
+  await expect(closing).rejects.toThrow("closed");
+});
+
+it("indexes IDs once and reads only changed/requested documents across store instances", async () => {
+  const documents = new Map([[doc(item(0))._id, doc(item(0))]]);
+  const allDocs = vi.fn(async () => [...documents.values()]);
+  const get = vi.fn(async (id: string) => documents.get(id));
+  const database = { allDocs, get, put: async (value: Record<string, unknown>) => { documents.set(String(value._id), value as ReturnType<typeof doc>); } };
+  const store = new ZToolsCanonicalClipboardStore(database);
+  const syncStore = new ZToolsCanonicalClipboardStore(database);
+  await store.readHistoryDocuments();
+  await store.findRecordByItemId("item-0");
+  await syncStore.put(doc(item(1)).record as Parameters<typeof store.put>[0]);
+  const changes = takeRecordChanges(database);
+  expect(changes).toEqual([doc(item(1))._id]);
+  await store.readHistoryChanges(changes);
+  await store.findRecordByItemId("item-1");
+  expect(allDocs).toHaveBeenCalledTimes(1);
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/host-compatibility.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/host-compatibility.test.ts
new file mode 100644
index 000000000..ac9e5ca8e
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/host-compatibility.test.ts
@@ -0,0 +1,76 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  compareZToolsVersions,
+  detectZToolsHostCompatibility,
+} from "../preload/host-compatibility";
+
+describe("ZTools host compatibility", () => {
+  it("uses 2.4 as the supported host floor", () => {
+    expect(compareZToolsVersions("2.3.9", "2.4.0")).toBeLessThan(0);
+    expect(compareZToolsVersions("2.4.0", "2.4.0")).toBe(0);
+    expect(compareZToolsVersions("2.4.0-beta.1", "2.4.0")).toBeLessThan(0);
+    expect(compareZToolsVersions("3.2.0-beta.1", "3.2.0")).toBeLessThan(0);
+    expect(compareZToolsVersions("2.4.0-invalid!", "2.4.0")).toBeUndefined();
+  });
+
+  it("detects 3.2 capabilities without making them mandatory", () => {
+    const startDrag = vi.fn();
+    function editableScreenCapture(
+      _callback: (image: unknown, bounds: unknown) => void,
+      _autoConfirm: boolean,
+    ): void {}
+    expect(
+      detectZToolsHostCompatibility({
+        getAppVersion: () => "3.2.0",
+        getPath: (name) => name === "pluginData" ? "/tmp/pasteboard-data" : "",
+        startDrag,
+        screenCapture: editableScreenCapture,
+      }),
+    ).toEqual({
+      currentVersion: "3.2.0",
+      minimumVersion: "2.4.0",
+      supported: true,
+      supportsPluginData: true,
+      supportsNativeFileDrag: true,
+      supportsScreenCapture: true,
+    });
+  });
+
+  it("accepts the official one-argument 3.2 wrapper but not pre-3.2 hosts", () => {
+    function legacyScreenCapture(
+      _callback: (image: unknown, bounds?: unknown) => void,
+    ): void {}
+    function editableScreenCapture(
+      _callback: (image: unknown, bounds: unknown) => void,
+      _autoConfirm: boolean,
+    ): void {}
+
+    expect(
+      detectZToolsHostCompatibility({
+        getAppVersion: () => "3.2.0",
+        screenCapture: legacyScreenCapture,
+      }).supportsScreenCapture,
+    ).toBe(true);
+    expect(
+      detectZToolsHostCompatibility({
+        getAppVersion: () => "3.1.9",
+        screenCapture: editableScreenCapture,
+      }).supportsScreenCapture,
+    ).toBe(false);
+  });
+
+  it("prompts on old or unknown hosts while preserving feature fallbacks", () => {
+    expect(
+      detectZToolsHostCompatibility({
+        getAppVersion: () => "2.3.9",
+        getPath: () => "",
+      }),
+    ).toMatchObject({
+      supported: false,
+      supportsPluginData: false,
+      supportsNativeFileDrag: false,
+    });
+    expect(detectZToolsHostCompatibility({}).supported).toBe(false);
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/hotkey-settings.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/hotkey-settings.test.ts
new file mode 100644
index 000000000..4af4cbf46
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/hotkey-settings.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  openPasteShortcutSettings,
+  pasteShortcutCommandLabel,
+} from "../src/hotkey-settings";
+
+describe("Paste shortcut settings entry", () => {
+  it("redirects to Paste's canonical ZTools command label", () => {
+    const redirectHotKeySetting = vi.fn();
+
+    expect(openPasteShortcutSettings({ redirectHotKeySetting })).toBe(true);
+    expect(redirectHotKeySetting).toHaveBeenCalledWith(pasteShortcutCommandLabel);
+    expect(pasteShortcutCommandLabel).toBe("pasteboard-pro/Paste剪切板");
+  });
+
+  it("reports when the ZTools public API is unavailable", () => {
+    expect(openPasteShortcutSettings(undefined)).toBe(false);
+    expect(openPasteShortcutSettings({})).toBe(false);
+  });
+
+  it("reports host rejection or redirect errors", () => {
+    expect(
+      openPasteShortcutSettings({ redirectHotKeySetting: () => false }),
+    ).toBe(false);
+    expect(
+      openPasteShortcutSettings({
+        redirectHotKeySetting: () => {
+          throw new Error("host unavailable");
+        },
+      }),
+    ).toBe(false);
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/keyboard-routing.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/keyboard-routing.test.ts
new file mode 100644
index 000000000..d70256340
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/keyboard-routing.test.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+
+import { shelfKeyboardRoute } from "../src/keyboard-routing";
+
+describe("shelf keyboard event routing", () => {
+  it.each(["Enter", " "])("routes card %s through the list state machine", (key) => {
+    expect(
+      shelfKeyboardRoute(key, { nativeControl: false, listCard: true }),
+    ).toBe("list-card");
+  });
+
+  it("lets controls inside a card keep native Enter/Space activation", () => {
+    expect(
+      shelfKeyboardRoute("Enter", { nativeControl: true, listCard: true }),
+    ).toBe("native-control");
+    expect(
+      shelfKeyboardRoute(" ", { nativeControl: true, listCard: true }),
+    ).toBe("native-control");
+  });
+
+  it("does not intercept printable keys outside a card", () => {
+    expect(
+      shelfKeyboardRoute("a", { nativeControl: false, listCard: true }),
+    ).toBeUndefined();
+    expect(
+      shelfKeyboardRoute(" ", { nativeControl: false, listCard: false }),
+    ).toBeUndefined();
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/list-control-key.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/list-control-key.test.ts
index f83ef9e7b..7606e9ec5 100644
--- a/plugins/pasteboard-pro/apps/ztools/tests/list-control-key.test.ts
+++ b/plugins/pasteboard-pro/apps/ztools/tests/list-control-key.test.ts
@@ -16,6 +16,24 @@ describe("search to list keyboard handoff", () => {
     expect(shouldResumeListControl({ key: "Enter", metaKey: false, altKey: true })).toBe(false);
   });
 
+  it("keeps Ctrl navigation and activation in a Windows/Linux search field", () => {
+    expect(
+      shouldResumeListControl(
+        { key: "ArrowDown", metaKey: false, ctrlKey: true, altKey: false },
+      ),
+    ).toBe(false);
+    expect(
+      shouldResumeListControl(
+        { key: "Enter", metaKey: false, ctrlKey: true, altKey: false },
+      ),
+    ).toBe(false);
+    expect(
+      shouldResumeListControl(
+        { key: "Enter", metaKey: false, ctrlKey: false, altKey: false },
+      ),
+    ).toBe(true);
+  });
+
   it("distinguishes focus-only navigation from list activation", () => {
     expect(isListNavigationKey("ArrowDown")).toBe(true);
     expect(isListNavigationKey("Enter")).toBe(false);
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/native-file-drag.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/native-file-drag.test.ts
index c21a48806..8e5f6aed6 100644
--- a/plugins/pasteboard-pro/apps/ztools/tests/native-file-drag.test.ts
+++ b/plugins/pasteboard-pro/apps/ztools/tests/native-file-drag.test.ts
@@ -24,6 +24,7 @@ describe("ZTools native file drag", () => {
     const service = new NativeFileDragService(
       { findRecordByItemId: async () => undefined },
       { startDrag },
+      () => true,
     );
 
     service.refresh([image]);
@@ -46,6 +47,7 @@ describe("ZTools native file drag", () => {
     const service = new NativeFileDragService(
       { findRecordByItemId: async () => undefined },
       { startDrag },
+      () => true,
     );
 
     service.refresh([files]);
@@ -68,6 +70,7 @@ describe("ZTools native file drag", () => {
     const service = new NativeFileDragService(
       { findRecordByItemId: async () => files },
       { startDrag },
+      () => true,
     );
 
     await expect(service.prepare(files.item.id)).resolves.toBe(true);
@@ -92,6 +95,7 @@ describe("ZTools native file drag", () => {
     const service = new NativeFileDragService(
       { findRecordByItemId: async () => undefined },
       { startDrag },
+      () => true,
     );
 
     service.refresh([text, relativeFiles]);
@@ -115,10 +119,35 @@ describe("ZTools native file drag", () => {
           throw new Error("missing file");
         },
       },
+      () => true,
     );
     service.refresh([files]);
 
     expect(service.start(files.item.id)).toBe(false);
     expect(service.start(files.item.id)).toBe(false);
   });
+
+  it("falls back when the host API is absent or a source file no longer exists", () => {
+    const files = record({
+      id: "files-stale",
+      type: "file",
+      timestamp: 700,
+      files: [{ path: "/tmp/stale.pdf", name: "stale.pdf" }],
+    });
+    const withoutApi = new NativeFileDragService(
+      { findRecordByItemId: async () => undefined },
+      {},
+      () => true,
+    );
+    const missingFile = new NativeFileDragService(
+      { findRecordByItemId: async () => undefined },
+      { startDrag: vi.fn() },
+      () => false,
+    );
+    withoutApi.refresh([files]);
+    missingFile.refresh([files]);
+
+    expect(withoutApi.start(files.item.id)).toBe(false);
+    expect(missingFile.start(files.item.id)).toBe(false);
+  });
 });
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/platform-shortcuts.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/platform-shortcuts.test.ts
new file mode 100644
index 000000000..1ba3d53f9
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/platform-shortcuts.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  hasPrimaryModifier,
+  hasPrimaryShortcutModifier,
+  matchesPrimaryShortcut,
+  hasAnyCommandModifier,
+  primaryModifierLabel,
+  primaryModifierName,
+  resolveShortcutPlatform,
+} from "../src/platform-shortcuts";
+
+describe("platform shortcut conventions", () => {
+  it("maps macOS to Command and Windows/Linux to Ctrl", () => {
+    expect(resolveShortcutPlatform("darwin")).toBe("darwin");
+    expect(resolveShortcutPlatform("win32")).toBe("win32");
+    expect(resolveShortcutPlatform("linux")).toBe("linux");
+    expect(resolveShortcutPlatform(undefined, "MacIntel")).toBe("darwin");
+    expect(resolveShortcutPlatform(undefined, "Win32")).toBe("win32");
+    expect(resolveShortcutPlatform(undefined, "Linux x86_64")).toBe("linux");
+
+    expect(hasPrimaryModifier({ metaKey: true, ctrlKey: false }, "darwin")).toBe(true);
+    expect(hasPrimaryModifier({ metaKey: false, ctrlKey: true }, "win32")).toBe(true);
+    expect(hasPrimaryModifier({ metaKey: false, ctrlKey: true }, "linux")).toBe(true);
+    expect(hasPrimaryModifier({ metaKey: true, ctrlKey: false }, "win32")).toBe(false);
+    expect(
+      hasPrimaryShortcutModifier(
+        { metaKey: false, ctrlKey: true, altKey: false },
+        "win32",
+      ),
+    ).toBe(true);
+    expect(
+      hasPrimaryShortcutModifier(
+        { metaKey: true, ctrlKey: true, altKey: false },
+        "win32",
+      ),
+    ).toBe(false);
+    expect(
+      hasPrimaryShortcutModifier(
+        { metaKey: true, ctrlKey: false, altKey: true },
+        "darwin",
+      ),
+    ).toBe(false);
+    expect(hasAnyCommandModifier({ metaKey: false, ctrlKey: true })).toBe(true);
+    expect(hasAnyCommandModifier({ metaKey: true, ctrlKey: false })).toBe(true);
+    expect(hasAnyCommandModifier({ metaKey: false, ctrlKey: false, altKey: true })).toBe(true);
+    expect(hasAnyCommandModifier({ metaKey: false, ctrlKey: false, altKey: false })).toBe(false);
+  });
+
+  it("exposes platform-appropriate labels", () => {
+    expect(primaryModifierLabel("darwin")).toBe("⌘");
+    expect(primaryModifierLabel("win32")).toBe("Ctrl");
+    expect(primaryModifierName("darwin")).toBe("Command");
+    expect(primaryModifierName("linux")).toBe("Ctrl");
+  });
+
+  it("matches Paste shelf shortcuts with Ctrl on Windows/Linux", () => {
+    for (const key of ["f", "n", "c", "t", "e", "r"]) {
+      expect(
+        matchesPrimaryShortcut(
+          { key, metaKey: false, ctrlKey: true, altKey: false, shiftKey: false },
+          "win32",
+          key,
+        ),
+      ).toBe(true);
+      expect(
+        matchesPrimaryShortcut(
+          { key, metaKey: true, ctrlKey: false, altKey: false, shiftKey: false },
+          "win32",
+          key,
+        ),
+      ).toBe(false);
+    }
+
+    expect(
+      matchesPrimaryShortcut(
+        { key: "f", metaKey: false, ctrlKey: true, altKey: false, shiftKey: true },
+        "win32",
+        "f",
+      ),
+    ).toBe(false);
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/plugin-data-migration.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/plugin-data-migration.test.ts
new file mode 100644
index 000000000..7e68bbe05
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/plugin-data-migration.test.ts
@@ -0,0 +1,60 @@
+import { mkdtemp, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { migratePasteboardProPluginData } from "../preload/plugin-data-migration";
+
+describe("pluginData migration", () => {
+  it("moves legacy blobs, rewrites database paths, and removes the legacy root", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "pasteboard-plugin-data-"));
+    const legacy = path.join(root, "legacy", "blobs");
+    const pluginData = path.join(root, "pluginData");
+    const blobRoot = path.join(pluginData, "sync", "blobs");
+    const relative = path.join("ab", `${"a".repeat(64)}.png`);
+    const oldPath = path.join(legacy, relative);
+    await mkdir(path.dirname(oldPath), { recursive: true });
+    await writeFile(oldPath, "blob");
+    const documents = [{
+      _id: "pasteboard-pro:record:test",
+      _rev: "1-a",
+      type: "pasteboard-pro-record",
+      record: { item: { id: "item" }, origin: { host: "sync", imagePath: oldPath } },
+    }];
+    const database = {
+      async allDocs() { return { rows: documents.map((doc) => ({ doc })) }; },
+      async put(document: Record<string, unknown>) { documents.splice(0, 1, document as any); return { ok: true }; },
+    };
+
+    await migratePasteboardProPluginData(database, {
+      dataRoot: pluginData,
+      blobRoot,
+      legacyBlobRoots: [legacy],
+      usesPluginData: true,
+    });
+
+    await expect(stat(legacy)).rejects.toMatchObject({ code: "ENOENT" });
+    expect(await readFile(path.join(blobRoot, relative), "utf8")).toBe("blob");
+    expect((documents[0] as any).record.origin.imagePath).toBe(path.join(blobRoot, relative));
+  });
+
+  it("retains the legacy root when database path rewriting fails", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "pasteboard-plugin-data-fail-"));
+    const legacy = path.join(root, "legacy", "blobs");
+    const pluginData = path.join(root, "pluginData");
+    const oldPath = path.join(legacy, "aa", "blob.png");
+    await mkdir(path.dirname(oldPath), { recursive: true });
+    await writeFile(oldPath, "blob");
+    const database = {
+      async allDocs() { return { rows: [{ doc: { _id: "pasteboard-pro:record:test", type: "pasteboard-pro-record", record: { origin: { imagePath: oldPath } } } }] }; },
+      async put() { return { ok: false, error: "conflict" }; },
+    };
+    await expect(migratePasteboardProPluginData(database, {
+      dataRoot: pluginData,
+      blobRoot: path.join(pluginData, "sync", "blobs"),
+      legacyBlobRoots: [legacy],
+      usesPluginData: true,
+    })).rejects.toThrow("更新附件路径失败");
+    expect((await stat(legacy)).isDirectory()).toBe(true);
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/plugin-data.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/plugin-data.test.ts
new file mode 100644
index 000000000..e1479aef9
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/plugin-data.test.ts
@@ -0,0 +1,31 @@
+import path from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { resolvePasteboardBlobRoots } from "../preload/plugin-data";
+
+describe("Pasteboard plugin data", () => {
+  it("uses the 3.2 plugin-owned directory while retaining the legacy root", () => {
+    expect(
+      resolvePasteboardBlobRoots(
+        { getPath: () => "/tmp/ztools/pasteboard-pro" },
+        "/tmp/home",
+      ),
+    ).toEqual({
+      primary: path.join("/tmp/ztools/pasteboard-pro", "sync", "blobs"),
+      legacy: [path.join("/tmp/home", ".pasteboard-pro", "ztools", "blobs")],
+    });
+  });
+
+  it("falls back to the historical directory on ZTools 2.4-3.1", () => {
+    expect(
+      resolvePasteboardBlobRoots(
+        { getPath: () => { throw new Error("unknown path"); } },
+        "/tmp/home",
+      ),
+    ).toEqual({
+      primary: path.join("/tmp/home", ".pasteboard-pro", "ztools", "blobs"),
+      legacy: [],
+    });
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/screenshot-import.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/screenshot-import.test.ts
new file mode 100644
index 000000000..119abda97
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/screenshot-import.test.ts
@@ -0,0 +1,133 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  importCapturedScreenshot,
+  importScreenCapture,
+  SCREEN_CAPTURE_PAUSED_MESSAGE,
+  SCREEN_CAPTURE_UNAVAILABLE_MESSAGE,
+} from "../preload/screenshot-import";
+
+function image(empty = false) {
+  return {
+    isEmpty: () => empty,
+    resize: () => image(empty),
+    toJPEG: () => new Uint8Array(),
+  };
+}
+
+describe("captured screenshot import", () => {
+  it("writes a valid captured image to the system clipboard", () => {
+    const writeImage = vi.fn();
+    const createFromDataURL = vi.fn(() => image());
+
+    expect(importCapturedScreenshot("data:image/png;base64,aGVsbG8=", {
+      clipboard: { writeImage },
+      nativeImage: { createFromDataURL },
+    })).toBe(true);
+    expect(createFromDataURL).toHaveBeenCalledOnce();
+    expect(writeImage).toHaveBeenCalledOnce();
+  });
+
+  it("rejects invalid or empty images without changing the clipboard", () => {
+    const writeImage = vi.fn();
+    const createFromDataURL = vi.fn(() => image(true));
+    const dependencies = {
+      clipboard: { writeImage },
+      nativeImage: { createFromDataURL },
+    };
+
+    expect(importCapturedScreenshot("https://example.com/image.png", dependencies)).toBe(false);
+    expect(importCapturedScreenshot("data:image/png;base64,", dependencies)).toBe(false);
+    expect(writeImage).not.toHaveBeenCalled();
+  });
+
+  it("requests editable capture and writes only to the clipboard", async () => {
+    const writeImage = vi.fn();
+    const canImport = vi.fn(async () => true);
+    let requestedAutoConfirm: boolean | undefined;
+
+    const result = await importScreenCapture(
+      {
+        screenCapture(callback, autoConfirm) {
+          requestedAutoConfirm = autoConfirm;
+          callback(image(), { x: 10, y: 20, width: 300, height: 180 });
+        },
+      },
+      { createFromDataURL: () => image() },
+      { writeImage },
+      { canImport },
+    );
+
+    expect(requestedAutoConfirm).toBe(false);
+    expect(result).toEqual({
+      bounds: { x: 10, y: 20, width: 300, height: 180 },
+    });
+    expect(canImport).toHaveBeenCalledTimes(2);
+    expect(writeImage).toHaveBeenCalledOnce();
+  });
+
+  it("accepts the official one-argument wrapper and optional bounds", async () => {
+    const writeImage = vi.fn();
+    function legacyScreenCapture(
+      callback: (captured: unknown, bounds?: unknown) => void,
+    ): void {
+      callback(image());
+    }
+
+    await expect(importScreenCapture(
+      { screenCapture: legacyScreenCapture },
+      { createFromDataURL: () => image() },
+      { writeImage },
+    )).resolves.toEqual({});
+    expect(writeImage).toHaveBeenCalledOnce();
+  });
+
+  it("rejects hosts without screen capture", async () => {
+    await expect(importScreenCapture(
+      {},
+      { createFromDataURL: () => image() },
+      { writeImage: vi.fn() },
+    )).rejects.toThrow(SCREEN_CAPTURE_UNAVAILABLE_MESSAGE);
+  });
+
+  it("does not invoke capture while privacy pause is active", async () => {
+    let invoked = false;
+    function screenCapture(
+      _callback: (captured: unknown, bounds?: unknown) => void,
+      _autoConfirm?: boolean,
+    ): void {
+      invoked = true;
+    }
+
+    await expect(
+      importScreenCapture(
+        { screenCapture },
+        { createFromDataURL: () => image() },
+        { writeImage: vi.fn() },
+        { canImport: async () => false },
+      ),
+    ).rejects.toThrow(SCREEN_CAPTURE_PAUSED_MESSAGE);
+    expect(invoked).toBe(false);
+  });
+
+  it("rechecks privacy after capture and before writing the clipboard", async () => {
+    const writeImage = vi.fn();
+    let checks = 0;
+    function screenCapture(
+      callback: (captured: unknown, bounds?: unknown) => void,
+      _autoConfirm?: boolean,
+    ): void {
+      callback(image(), { x: 0, y: 0, width: 100, height: 100 });
+    }
+
+    await expect(
+      importScreenCapture(
+        { screenCapture },
+        { createFromDataURL: () => image() },
+        { writeImage },
+        { canImport: async () => (checks += 1) === 1 },
+      ),
+    ).rejects.toThrow(SCREEN_CAPTURE_PAUSED_MESSAGE);
+    expect(writeImage).not.toHaveBeenCalled();
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/state.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/state.test.ts
index 67b4c762b..34f997e8d 100644
--- a/plugins/pasteboard-pro/apps/ztools/tests/state.test.ts
+++ b/plugins/pasteboard-pro/apps/ztools/tests/state.test.ts
@@ -114,6 +114,82 @@ describe("Vue canonical state", () => {
     ).toBeNull();
   });
 
+  it("maps Ctrl shortcuts to selection and Quick Paste on Windows/Linux", () => {
+    const state = createPasteboardState({
+      items: historyFixture,
+      shortcutPlatform: "win32",
+    });
+
+    expect(
+      state.handleKeyboard({
+        key: "a",
+        metaKey: false,
+        ctrlKey: true,
+        shiftKey: false,
+        altKey: false,
+      }),
+    ).toBeNull();
+    expect(state.selection.selected).toEqual(state.visibleItems.map((item) => item.id));
+
+    expect(
+      state.handleKeyboard({
+        key: "2",
+        metaKey: false,
+        ctrlKey: true,
+        shiftKey: false,
+        altKey: false,
+      }),
+    ).toEqual({
+      type: "quick-paste",
+      itemId: state.visibleItems[1]?.id,
+      plainText: false,
+    });
+
+    expect(
+      state.handleKeyboard({
+        key: "2",
+        metaKey: false,
+        ctrlKey: true,
+        shiftKey: true,
+        altKey: false,
+      }),
+    ).toEqual({
+      type: "quick-paste",
+      itemId: state.visibleItems[1]?.id,
+      plainText: true,
+    });
+  });
+
+  it("does not treat a non-primary platform modifier as a bare list action", () => {
+    const state = createPasteboardState({
+      items: historyFixture,
+      shortcutPlatform: "win32",
+    });
+    const firstId = state.visibleItems[0]!.id;
+    state.replaceSelection(firstId);
+
+    expect(
+      state.handleKeyboard({
+        key: "ArrowRight",
+        metaKey: true,
+        ctrlKey: false,
+        shiftKey: false,
+        altKey: false,
+      }),
+    ).toBeNull();
+    expect(state.selection.selected).toEqual([firstId]);
+
+    expect(
+      state.handleKeyboard({
+        key: "Enter",
+        metaKey: true,
+        ctrlKey: false,
+        shiftKey: false,
+        altKey: false,
+      }),
+    ).toBeNull();
+  });
+
   it("moves single selection with arrows and exposes paste/preview effects", () => {
     const state = createPasteboardState({ items: historyFixture });
     const firstId = state.visibleItems[0]!.id;
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/sync-repository.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/sync-repository.test.ts
index 9d361910a..76b6477b5 100644
--- a/plugins/pasteboard-pro/apps/ztools/tests/sync-repository.test.ts
+++ b/plugins/pasteboard-pro/apps/ztools/tests/sync-repository.test.ts
@@ -1,4 +1,14 @@
-import { mkdtemp, readFile, rm, stat, utimes } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  stat,
+  symlink,
+  utimes,
+  writeFile,
+} from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
@@ -49,6 +59,19 @@ function database(): ZToolsDocumentDatabase {
   };
 }
 
+async function writeManagedBlob(
+  root: string,
+  bytes: Uint8Array,
+  extension = "png",
+): Promise<string> {
+  const digest = createHash("sha256").update(bytes).digest("hex");
+  const directory = path.join(root, digest.slice(0, 2));
+  const file = path.join(directory, `${digest}.${extension}`);
+  await mkdir(directory, { recursive: true });
+  await writeFile(file, bytes);
+  return file;
+}
+
 describe("ZTools sync entity repository", () => {
   it("stores derived image bytes in the content-addressed blob directory", async () => {
     const root = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-derived-"));
@@ -90,6 +113,161 @@ describe("ZTools sync entity repository", () => {
     }
   });
 
+  it("rejects managed roots, invalid blob ids, and symlink escape paths", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-safe-delete-"));
+    const outsideRoot = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-delete-outside-"));
+    const outsideFile = path.join(outsideRoot, "outside.png");
+    const targetLink = path.join(root, "target-link.png");
+    const parentLink = path.join(root, "parent-link");
+    try {
+      await writeFile(outsideFile, Buffer.from([1, 2, 3]));
+      await symlink(outsideFile, targetLink);
+      await symlink(outsideRoot, parentLink, "dir");
+      const repository = new ZToolsSyncEntityRepository(database(), "host-a", root);
+
+      await expect(
+        repository.deleteLocalBlob({ blobId: "blob-target", filePath: targetLink }),
+      ).rejects.toThrow(/symbolic link/i);
+      await expect(
+        repository.deleteLocalBlob({
+          blobId: "blob-parent",
+          filePath: path.join(parentLink, "outside.png"),
+        }),
+      ).rejects.toThrow(/symbolic link/i);
+      await expect(
+        repository.deleteLocalBlob({ blobId: "blob-root", filePath: root }),
+      ).rejects.toThrow(/outside/i);
+      await expect(
+        repository.deleteLocalBlob({ blobId: "blob\0invalid", filePath: targetLink }),
+      ).rejects.toThrow(/NUL/i);
+      await expect(
+        repository.deleteLocalBlob({ blobId: "../blob-invalid", filePath: targetLink }),
+      ).rejects.toThrow(/safe object identifier/i);
+      expect(await readFile(outsideFile)).toEqual(Buffer.from([1, 2, 3]));
+    } finally {
+      await rm(root, { recursive: true, force: true });
+      await rm(outsideRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects a symbolic-link managed root", async () => {
+    const realRoot = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-real-root-"));
+    const linkParent = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-link-root-"));
+    const linkedRoot = path.join(linkParent, "blobs");
+    const file = path.join(realRoot, "blob.png");
+    try {
+      await writeFile(file, Buffer.from([7, 8, 9]));
+      await symlink(realRoot, linkedRoot, "dir");
+      const repository = new ZToolsSyncEntityRepository(
+        database(),
+        "host-a",
+        linkedRoot,
+      );
+
+      await expect(
+        repository.deleteLocalBlob({
+          blobId: "blob-root-link",
+          filePath: path.join(linkedRoot, "blob.png"),
+        }),
+      ).rejects.toThrow(/symbolic-link blob root/i);
+      expect(await readFile(file)).toEqual(Buffer.from([7, 8, 9]));
+    } finally {
+      await rm(linkParent, { recursive: true, force: true });
+      await rm(realRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps legacy blob records removable after new writes move to pluginData", async () => {
+    const currentRoot = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-current-"));
+    const legacyRoot = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-legacy-"));
+    try {
+      const legacyFile = await writeManagedBlob(
+        legacyRoot,
+        new Uint8Array([4, 5, 6]),
+      );
+      const repository = new ZToolsSyncEntityRepository(
+        database(),
+        "host-a",
+        currentRoot,
+        [legacyRoot],
+      );
+      const current = await repository.storeLocalBlob(
+        new Uint8Array([1, 2, 3]),
+        "image/png",
+      );
+
+      expect(current.imagePath.startsWith(currentRoot)).toBe(true);
+      await repository.deleteLocalBlob({ blobId: "blob-legacy", filePath: legacyFile });
+      await expect(stat(legacyFile)).rejects.toMatchObject({ code: "ENOENT" });
+    } finally {
+      await rm(currentRoot, { recursive: true, force: true });
+      await rm(legacyRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("refuses a content-addressed path whose bytes do not match its digest", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-digest-delete-"));
+    try {
+      const claimedBytes = new Uint8Array([1, 1, 1]);
+      const digest = createHash("sha256").update(claimedBytes).digest("hex");
+      const directory = path.join(root, digest.slice(0, 2));
+      const file = path.join(directory, `${digest}.png`);
+      await mkdir(directory, { recursive: true });
+      await writeFile(file, new Uint8Array([9, 9, 9]));
+      const repository = new ZToolsSyncEntityRepository(database(), "host-a", root);
+
+      await expect(
+        repository.deleteLocalBlob({ blobId: "blob-mismatch", filePath: file }),
+      ).rejects.toThrow(/content does not match/i);
+      expect(await readFile(file)).toEqual(Buffer.from([9, 9, 9]));
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps a verified blob while another database record still references it", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "pasteboard-pro-referenced-delete-"));
+    try {
+      const db = database();
+      const repository = new ZToolsSyncEntityRepository(db, "host-a", root);
+      const stored = await repository.storeLocalBlob(
+        new Uint8Array([3, 1, 4, 1, 5]),
+        "image/png",
+      );
+      const fixture = historyFixture.find((item) => item.kind === "image");
+      if (fixture === undefined) throw new Error("Image fixture is required");
+      const item = PasteItemSchema.parse({
+        ...fixture,
+        payload: {
+          ...fixture.payload,
+          blobId: stored.id,
+          mediaType: "image/png",
+        },
+      });
+      const store = new ZToolsCanonicalClipboardStore(db, { deviceId: "host-a" });
+      await store.put({
+        item,
+        origin: {
+          host: "sync",
+          remoteAvailable: true,
+          imagePath: stored.imagePath,
+          blobBytes: stored.blobBytes,
+          pluginBlobId: stored.id,
+        },
+      });
+
+      await repository.deleteLocalBlob({
+        blobId: stored.id,
+        filePath: stored.imagePath,
+      });
+      expect(await readFile(stored.imagePath)).toEqual(
+        Buffer.from([3, 1, 4, 1, 5]),
+      );
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
   it("turns local deletion into a tombstone and permits only a newer live edit to return", async () => {
     const db = database();
     const clipboard = new ZToolsCanonicalClipboardStore(db, {
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/virtual-timeline.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/virtual-timeline.test.ts
new file mode 100644
index 000000000..32afe46fa
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/tests/virtual-timeline.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { timelineFocusOffset, timelineRange } from "../src/virtual-timeline";
+
+describe("virtual timeline", () => {
+  it("bounds rendering at the start, middle, and end of 10,000 records", () => {
+    for (const stride of [252, 154, 116]) {
+      for (const offset of [0, 5000 * stride, 10000 * stride]) {
+        const { start, end } = timelineRange(10000, stride, offset, 900);
+        expect(start).toBeGreaterThanOrEqual(0);
+        expect(end).toBeLessThanOrEqual(10000);
+        expect(end - start).toBeGreaterThanOrEqual(30);
+        expect(end - start).toBeLessThanOrEqual(50);
+      }
+    }
+  });
+
+  it("handles empty and shortened search results at an old scroll position", () => {
+    expect(timelineRange(0, 154, 50000, 500)).toEqual({ start: 0, end: 0 });
+    expect(timelineRange(2, 154, 50000, 500)).toEqual({ start: 0, end: 2 });
+  });
+
+  it("reveals unmounted focus targets and keeps already visible targets stable", () => {
+    expect(timelineFocusOffset(0, 154, 142, 9000, 500)).toBe(0);
+    const offset = timelineFocusOffset(9999, 154, 142, 0, 500);
+    expect(offset + 500).toBe(9999 * 154 + 142);
+    const range = timelineRange(10000, 154, offset, 500);
+    expect(range.end).toBe(10000);
+    expect(timelineFocusOffset(3, 154, 142, 400, 500)).toBe(400);
+    expect(timelineFocusOffset(3, 154, 142, 0, 100)).toBe(462);
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tests/window.test.ts b/plugins/pasteboard-pro/apps/ztools/tests/window.test.ts
index 5b5cdcecf..33b5404ac 100644
--- a/plugins/pasteboard-pro/apps/ztools/tests/window.test.ts
+++ b/plugins/pasteboard-pro/apps/ztools/tests/window.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 import {
   buildPanelWindowOptions,
@@ -10,6 +10,8 @@ import {
   type ShelfWindowHost,
 } from "../preload/window";
 
+import { waitForWindowReadyScript } from "../window-ready";
+
 const primaryDisplay = {
   id: "primary",
   workArea: { x: 0, y: 24, width: 1440, height: 876 },
@@ -224,7 +226,7 @@ describe("ZTools shelf lifecycle", () => {
     expect(closed).toBe(1);
   });
 
-  it("creates one shelf, applies content protection, and repositions it across displays", () => {
+  it("creates one shelf, applies content protection, and repositions it across displays", async () => {
     const calls: string[] = [];
     let readyCallback: (() => void) | undefined;
     const windowHandle: BrowserWindowHandle = {
@@ -262,6 +264,7 @@ describe("ZTools shelf lifecycle", () => {
         contentProtection: true,
       }),
     ).toBe(windowHandle);
+    await vi.waitFor(() => expect(calls).toContain("show"));
     expect(
       manager.open(
         {
@@ -280,9 +283,9 @@ describe("ZTools shelf lifecycle", () => {
     expect(calls).toContain("protect:true");
     expect(calls).toContain("bounds:0,620,1440,280");
     expect(calls).toContain("bounds:-1920,800,1920,280");
-    expect(calls).toContain("script:window.location.reload()");
+    expect(calls).toContain(`script:${waitForWindowReadyScript}`);
     expect(calls).toContain("hide:false");
-    expect(calls.slice(-2)).toEqual(["show", "focus"]);
+    expect(calls.slice(-3)).toEqual(["show", "focus", "bounds:-1920,800,1920,280"]);
     manager.setContentProtection(false);
     expect(calls.at(-1)).toBe("protect:false");
   });
@@ -323,7 +326,7 @@ describe("ZTools shelf lifecycle", () => {
 });
 
 describe("ZTools settings panel lifecycle", () => {
-  it("centers, reloads, reuses, and replaces independent panels", () => {
+  it("centers, waits for content, reuses, and replaces independent panels", async () => {
     const calls: string[] = [];
     let activeReady: (() => void) | undefined;
     const handles: BrowserWindowHandle[] = [];
@@ -360,6 +363,7 @@ describe("ZTools settings panel lifecycle", () => {
     const manager = new PanelWindowManager(host);
 
     expect(manager.open(primaryDisplay, { panel: "privacy" })).toBe(handles[0]);
+    await vi.waitFor(() => expect(calls).toContain("show"));
     expect(manager.open(primaryDisplay, { panel: "privacy" })).toBe(handles[0]);
     expect(manager.open(primaryDisplay, { panel: "sync" })).toBe(handles[1]);
 
@@ -367,7 +371,151 @@ describe("ZTools settings panel lifecycle", () => {
       "create:index.html?panel=privacy&display=primary",
       "create:index.html?panel=sync&display=primary",
     ]);
-    expect(calls).toContain("script:window.location.reload()");
+    expect(calls).toContain(`script:${waitForWindowReadyScript}`);
     expect(calls).toContain("close");
   });
 });
+
+
+describe.each(["shelf", "panel"] as const)("%s first reveal", (kind) => {
+  function setup(synchronousCallback = false) {
+    const windows: {
+      handle: BrowserWindowHandle;
+      domReady: () => void;
+      contentReady: () => void;
+      fail: (error: Error) => void;
+    }[] = [];
+    const host: ShelfWindowHost = {
+      hideMainWindow: vi.fn(),
+      createBrowserWindow(_url, options, onReady) {
+        expect(options.show).toBe(false);
+        let destroyed = false;
+        let contentReady!: () => void;
+        let fail!: (error: Error) => void;
+        const ready = new Promise<void>((resolve, reject) => {
+          contentReady = resolve;
+          fail = reject;
+        });
+        const handle: BrowserWindowHandle = {
+          isDestroyed: () => destroyed,
+          webContents: { executeJavaScript: vi.fn(() => ready) },
+          show: vi.fn(), focus: vi.fn(), setBounds: vi.fn(),
+          setContentProtection: vi.fn(),
+          close: vi.fn(() => { destroyed = true; }),
+        };
+        windows.push({ handle, domReady: () => onReady?.(), contentReady, fail });
+        if (synchronousCallback) onReady?.();
+        return handle;
+      },
+    };
+    const shelf = new ShelfWindowManager(host);
+    const panel = new PanelWindowManager(host);
+    const open = (replace = false) => kind === "shelf"
+      ? shelf.open(primaryDisplay, { edge: replace ? "left" : "bottom", contentProtection: true })
+      : panel.open(primaryDisplay, { panel: replace ? "sync" : "privacy" });
+    return { windows, open, shelf };
+  }
+
+  it.each([false, true])("stays hidden through DOM readiness (synchronous callback: %s)", async (sync) => {
+    const { windows, open } = setup(sync);
+    const handle = open();
+    expect(handle.show).not.toHaveBeenCalled();
+    windows[0]!.domReady();
+    await Promise.resolve();
+    expect(handle.webContents.executeJavaScript).toHaveBeenCalledExactlyOnceWith(waitForWindowReadyScript);
+    expect(handle.show).not.toHaveBeenCalled();
+    // Reopening the same window while loading must not bypass readiness.
+    expect(open()).toBe(handle);
+    expect(handle.show).not.toHaveBeenCalled();
+    windows[0]!.contentReady();
+    await vi.waitFor(() => expect(handle.show).toHaveBeenCalledTimes(1));
+    expect(handle.focus).toHaveBeenCalledTimes(1);
+    windows[0]!.domReady();
+    await Promise.resolve();
+    expect(handle.show).toHaveBeenCalledTimes(1);
+    expect(open()).toBe(handle);
+    expect(handle.show).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not resurrect a closed window, and the next window can open", async () => {
+    const { windows, open } = setup();
+    const first = open();
+    windows[0]!.domReady();
+    await Promise.resolve();
+    first.close();
+    const second = open();
+    windows[0]!.contentReady();
+    windows[1]!.domReady();
+    await Promise.resolve();
+    windows[1]!.contentReady();
+    await vi.waitFor(() => expect(second.show).toHaveBeenCalledTimes(1));
+    expect(first.show).not.toHaveBeenCalled();
+    expect(first.focus).not.toHaveBeenCalled();
+  });
+
+  it("keeps a replaced window hidden even if its content finishes late", async () => {
+    const { windows, open } = setup();
+    const first = open();
+    windows[0]!.domReady();
+    await Promise.resolve();
+    const second = open(true);
+    windows[0]!.contentReady();
+    windows[1]!.domReady();
+    await Promise.resolve();
+    windows[1]!.contentReady();
+    await vi.waitFor(() => expect(second.show).toHaveBeenCalledTimes(1));
+    expect(first.close).toHaveBeenCalledTimes(1);
+    expect(first.show).not.toHaveBeenCalled();
+  });
+
+  it("corrects the native show/focus offset before restoring opacity", async () => {
+    const { windows, open } = setup();
+    const handle = open();
+    const expected = kind === "shelf"
+      ? { x: 0, y: 620, width: 1440, height: 280 }
+      : { x: 370, y: 132, width: 700, height: 660 };
+    let bounds = { ...expected };
+    let opacity = 1;
+    const order: string[] = [];
+    handle.setOpacity = vi.fn(value => {
+      opacity = value;
+      order.push(`opacity:${value}`);
+      if (value === 1) expect(bounds).toEqual(expected);
+    });
+    handle.getBounds = () => bounds;
+    vi.mocked(handle.show).mockImplementation(() => {
+      expect(opacity).toBe(0);
+      order.push("show");
+      bounds = { ...bounds, x: 14 }; // Observed native show() relocation.
+    });
+    vi.mocked(handle.focus).mockImplementation(() => { order.push("focus"); });
+    vi.mocked(handle.setBounds).mockImplementation((next, animate) => {
+      expect(opacity).toBe(0);
+      expect(animate).toBe(false);
+      order.push("bounds");
+      bounds = { ...next };
+    });
+    windows[0]!.domReady();
+    await Promise.resolve();
+    windows[0]!.contentReady();
+    await vi.waitFor(() => expect(handle.setOpacity).toHaveBeenLastCalledWith(1));
+    expect(order).toEqual(["opacity:0", "show", "focus", "bounds", "opacity:1"]);
+    expect(bounds).toEqual(expected);
+  });
+
+  it("closes a failed renderer so a subsequent activation can retry", async () => {
+    const log = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const { windows, open } = setup();
+      const first = open();
+      windows[0]!.domReady();
+      await Promise.resolve();
+      windows[0]!.fail(new Error("Window destroyed while executing script"));
+      await vi.waitFor(() => expect(first.close).toHaveBeenCalledTimes(1));
+      expect(first.show).not.toHaveBeenCalled();
+      expect(open()).not.toBe(first);
+    } finally {
+      log.mockRestore();
+    }
+  });
+});
diff --git a/plugins/pasteboard-pro/apps/ztools/tsconfig.json b/plugins/pasteboard-pro/apps/ztools/tsconfig.json
index a7ce36e68..3c69ca6c9 100644
--- a/plugins/pasteboard-pro/apps/ztools/tsconfig.json
+++ b/plugins/pasteboard-pro/apps/ztools/tsconfig.json
@@ -8,6 +8,7 @@
     "types": ["vite/client"]
   },
   "include": [
+    "window-ready.ts",
     "preload/**/*.ts",
     "src/**/*.ts",
     "src/**/*.vue",
diff --git a/plugins/pasteboard-pro/apps/ztools/vite.preload.config.ts b/plugins/pasteboard-pro/apps/ztools/vite.preload.config.ts
index 2ce8f6a63..e037cdbec 100644
--- a/plugins/pasteboard-pro/apps/ztools/vite.preload.config.ts
+++ b/plugins/pasteboard-pro/apps/ztools/vite.preload.config.ts
@@ -7,16 +7,19 @@ export default defineConfig({
     emptyOutDir: false,
     target: "node18",
     lib: {
-      entry: fileURLToPath(new URL("./preload/index.ts", import.meta.url)),
+      entry: {
+        preload: fileURLToPath(new URL("./preload/index.ts", import.meta.url)),
+        "history-worker": fileURLToPath(new URL("./preload/history-worker.ts", import.meta.url)),
+      },
       formats: ["cjs"],
-      fileName: () => "preload.js",
+      fileName: (_format, name) => name === "preload" ? "preload.js" : `${name}.cjs`,
     },
     outDir: "dist",
     rollupOptions: {
       external: [/^node:/],
       output: {
         exports: "none",
-        inlineDynamicImports: true,
+        chunkFileNames: "chunks/[name]-[hash].cjs",
       },
     },
   },
diff --git a/plugins/pasteboard-pro/apps/ztools/window-ready.ts b/plugins/pasteboard-pro/apps/ztools/window-ready.ts
new file mode 100644
index 000000000..ed90391a0
--- /dev/null
+++ b/plugins/pasteboard-pro/apps/ztools/window-ready.ts
@@ -0,0 +1,14 @@
+const READY_EVENT = "pasteboard-pro:window-ready";
+const READY_ATTRIBUTE = "data-pasteboard-ready";
+
+// The host callback only guarantees DOM readiness. Wait for Vue's initial data
+// and theme to be committed, including when they finish before this script runs.
+export const waitForWindowReadyScript = `new Promise((resolve) => {
+  if (document.documentElement.hasAttribute('${READY_ATTRIBUTE}')) resolve(true);
+  else window.addEventListener('${READY_EVENT}', () => resolve(true), { once: true });
+})`;
+
+export function markWindowReady(): void {
+  document.documentElement.setAttribute(READY_ATTRIBUTE, "true");
+  window.dispatchEvent(new Event(READY_EVENT));
+}
diff --git a/plugins/pasteboard-pro/playwright.performance.config.ts b/plugins/pasteboard-pro/playwright.performance.config.ts
new file mode 100644
index 000000000..eb8453c40
--- /dev/null
+++ b/plugins/pasteboard-pro/playwright.performance.config.ts
@@ -0,0 +1,19 @@
+import { defineConfig } from "playwright/test";
+
+export default defineConfig({
+  testDir: "./tests/performance",
+  outputDir: "./artifacts/virtual-timeline/results",
+  workers: 1,
+  reporter: [["list"], ["json", { outputFile: "artifacts/virtual-timeline/report.json" }]],
+  use: {
+    ...(process.env.PLAYWRIGHT_CHANNEL ? { channel: process.env.PLAYWRIGHT_CHANNEL } : {}),
+    baseURL: "http://127.0.0.1:5187",
+    viewport: { width: 1200, height: 800 },
+    screenshot: "only-on-failure",
+  },
+  webServer: {
+    command: "node apps/ztools/node_modules/vite/bin/vite.js apps/ztools --config apps/ztools/vite.config.ts --host 127.0.0.1 --port 5187",
+    url: "http://127.0.0.1:5187",
+    reuseExistingServer: false,
+  },
+});
diff --git a/plugins/pasteboard-pro/plugin.json b/plugins/pasteboard-pro/plugin.json
index b7c11f391..1c1df09d6 100644
--- a/plugins/pasteboard-pro/plugin.json
+++ b/plugins/pasteboard-pro/plugin.json
@@ -4,7 +4,7 @@
   "title": "Paste剪切板",
   "description": "Paste 风格的本地剪贴板历史、分组、预览与连续粘贴队列",
   "author": "harris",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "main": "index.html",
   "preload": "preload.js",
   "unpack": "@(pasteboard-vision|paste-stack-key-monitor.py)",
@@ -17,6 +17,7 @@
   "features": [
     {
       "code": "pasteboard-pro",
+      "mainHide": true,
       "explain": "打开 Paste剪切板历史",
       "icon": "logo.png",
       "cmds": [
diff --git a/plugins/pasteboard-pro/scripts/benchmark-history-worker.mjs b/plugins/pasteboard-pro/scripts/benchmark-history-worker.mjs
new file mode 100644
index 000000000..b053ee606
--- /dev/null
+++ b/plugins/pasteboard-pro/scripts/benchmark-history-worker.mjs
@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { readFile, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+const root = fileURLToPath(new URL("../", import.meta.url));
+// Run the current service source and the real packaged Node worker.
+const source = await readFile(path.join(root, "apps/ztools/preload/history-search.ts"), "utf8");
+const code = ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext } }).outputText;
+const { HistorySearchService } = await import(`data:text/javascript;base64,${Buffer.from(code).toString("base64")}`);
+const documents = Array.from({ length: 100_000 }, (_, i) => ({
+  _id: `pasteboard-pro:record:fp-${i}`, type: "pasteboard-pro-record",
+  record: { origin: { host: "sync", remoteAvailable: true }, item: {
+    id: `item-${i}`, kind: i % 10 === 0 ? "html" : "text", title: `Record ${i}`,
+    sourceDeviceId: "test", sourceApp: { name: "Safari", bundleId: "com.apple.Safari" },
+    copiedAt: new Date(1_800_000_000_000 - i).toISOString(), updatedAt: new Date(1_800_000_000_000 - i).toISOString(),
+    contentFingerprint: `fp-${i}`, payload: { revision: String(i),
+      text: i === 99_999 ? "x".repeat(16_384) + " 中文尾部命中" : `Clipboard content ${i}`,
+      ...(i % 100 === 0 ? { html: `<p>${"long html paragraph ".repeat(800)}末尾</p>` } : {}),
+    }, ...(i % 20 === 0 ? { ocrText: `Invoice ${i}` } : {}), pinned: false, fieldClocks: {},
+  } },
+}));
+const stats = { fullReads: 0, changedReads: 0 };
+const service = new HistorySearchService(path.join(root, "apps/ztools/dist/history-worker.cjs"), {
+  all: async () => { stats.fullReads++; return documents; },
+  changed: async ids => { stats.changedReads += ids.length; return ids.flatMap(id => documents.find(doc => doc._id === id) ?? []); },
+});
+const started = performance.now();
+try {
+  const first = await service.page({});
+  const coldMs = performance.now() - started;
+  assert.equal(first.items.length, 50);
+  assert.equal(first.total, 100_000);
+  const heartbeatGaps = [];
+  let lastBeat = performance.now();
+  const timer = setInterval(() => { const now = performance.now(); heartbeatGaps.push(now - lastBeat); lastBeat = now; }, 10);
+  const queries = [];
+  try {
+    for (const query of ["中文尾部命中", "Clipboard", "type:html app:Safari", "Invoice", "末尾"]) {
+      const durations = [];
+      let matches = 0;
+      for (let i = 0; i < 20; i++) {
+        const start = performance.now();
+        const result = await service.page({ query });
+        durations.push(performance.now() - start);
+        matches = result.total;
+        assert.ok(result.items.length <= 50);
+        if (query === "中文尾部命中") assert.equal(result.items[0].id, "item-99999");
+      }
+      durations.sort((a, b) => a - b);
+      queries.push({ query, matches, p95Ms: durations[18], medianMs: durations[10] });
+    }
+  } finally { clearInterval(timer); }
+  const before = await service.page({});
+  documents[99_999].record.item.payload.text = "incremental-needle";
+  service.invalidate([documents[99_999]._id]);
+  const after = await service.page({ query: "incremental-needle" });
+  assert.equal(after.total, 1);
+  assert.equal(stats.fullReads, 1);
+  assert.equal(stats.changedReads, 1);
+  assert.equal((await service.page({ cursor: before.nextCursor })).reset, true);
+  const report = {
+    generatedAt: new Date().toISOString(), node: process.version,
+    data: "100000 synthetic records including HTML, OCR and long-text tail matches",
+    scope: "packaged Node worker and current service; excludes ZTools database IPC and native window rendering",
+    coldMs, queries, maximumHeartbeatGapMs: Math.max(...heartbeatGaps), ...stats,
+  };
+  const output = path.join(root, "artifacts/search-capacity-20260908/worker-performance.json");
+  await mkdir(path.dirname(output), { recursive: true });
+  await writeFile(output, JSON.stringify(report, null, 2) + "\n");
+  console.log(JSON.stringify(report, null, 2));
+  assert.ok(queries.every(query => query.p95Ms < 250), "worker P95 exceeds 250 ms");
+  assert.ok(report.maximumHeartbeatGapMs < 150, "search blocks the caller's event loop");
+} finally { service.dispose(); }
diff --git a/plugins/pasteboard-pro/tests/performance/history-search.spec.ts b/plugins/pasteboard-pro/tests/performance/history-search.spec.ts
new file mode 100644
index 000000000..090bd1ca2
--- /dev/null
+++ b/plugins/pasteboard-pro/tests/performance/history-search.spec.ts
@@ -0,0 +1,52 @@
+import { expect, test } from "playwright/test";
+
+test("100k full-text search stays off the UI thread and returns only 50 items", async ({ page }) => {
+  const errors: string[] = [];
+  page.on("pageerror", error => errors.push(error.message));
+  await page.goto("/tests/browser/history.html?shelf=1&dock=bottom");
+  const cards = page.locator("[data-pb-item-id]");
+  await expect(cards.first()).toHaveAttribute("aria-setsize", "100000");
+  expect(await cards.count()).toBeLessThanOrEqual(50);
+  const input = page.getByRole("searchbox");
+  await input.fill("中文尾部命中");
+  await expect(cards).toHaveCount(1);
+  await expect(cards.first()).toHaveAttribute("data-pb-item-id", "item-99999");
+  await input.fill("Clipboard 9");
+  await input.fill("no-such-result");
+  await input.fill("中文尾部命中");
+  await expect(cards).toHaveCount(1);
+  await expect(cards.first()).toHaveAttribute("data-pb-item-id", "item-99999");
+  await page.evaluate(() => {
+    (window as any).historyTest.longTasks = [];
+    const observer = new PerformanceObserver(list => {
+      (window as any).historyTest.longTasks.push(...list.getEntries().map(entry => entry.duration));
+    });
+    observer.observe({ type: "longtask" });
+  });
+  await input.fill("Clipboard");
+  await expect(cards.first()).toHaveAttribute("aria-setsize", "99999");
+  const track = page.locator(".timeline__track");
+  await track.evaluate(element => { element.scrollLeft = element.scrollWidth; });
+  await expect.poll(() => page.evaluate(() => (window as any).historyTest.requests.some((request: any) => request.cursor))).toBe(true);
+  await expect.poll(() => page.evaluate(() => (window as any).historyTest.sizes.length)).toBeGreaterThan(3);
+  const sizes = await page.evaluate(() => (window as any).historyTest.sizes as number[]);
+  expect(sizes.every(size => size <= 50)).toBe(true);
+  const longTasks = await page.evaluate(() => (window as any).historyTest.longTasks as number[]);
+  expect(longTasks.filter(duration => duration > 100)).toEqual([]);
+  expect(errors).toEqual([]);
+});
+
+test("100k paged shelf preserves keyboard focus and loaded pages after changes", async ({ page }) => {
+  await page.goto("/tests/browser/history.html?shelf=1&dock=bottom");
+  const cards = page.locator("[data-pb-item-id]");
+  await expect(cards.first()).toHaveAttribute("aria-setsize", "100000");
+  await page.getByRole("searchbox").press("ArrowLeft");
+  for (let i = 0; i < 60; i++) await page.keyboard.press("ArrowRight");
+  await expect(page.locator('[data-pb-item-id="item-60"]')).toBeFocused();
+  await page.evaluate(() => {
+    (window as any).historyTest.prepend = true;
+    window.dispatchEvent(new CustomEvent("pasteboard-pro:history-changed"));
+  });
+  await expect(page.locator('[data-pb-item-id="item-60"]')).toHaveAttribute("aria-setsize", "100001");
+  await expect(page.locator('[data-pb-item-id="item-60"]')).toBeFocused();
+});
diff --git a/plugins/pasteboard-pro/tests/performance/render-benchmark.spec.ts b/plugins/pasteboard-pro/tests/performance/render-benchmark.spec.ts
new file mode 100644
index 000000000..ef352b1b5
--- /dev/null
+++ b/plugins/pasteboard-pro/tests/performance/render-benchmark.spec.ts
@@ -0,0 +1,36 @@
+import { execFileSync } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { test } from "playwright/test";
+
+test('isolated list mount benchmark', async ({ page }) => {
+  const baseline = process.env.PB_BENCH_REF;
+  test.skip(!baseline, 'Set PB_BENCH_REF to the commit to compare');
+  const root = path.resolve('apps/ztools/artifacts/virtual-benchmark');
+  await mkdir(root, { recursive: true });
+  const component = execFileSync('git', [
+    'show', `${baseline}:plugins/pasteboard-pro/apps/ztools/src/components/Timeline.vue`,
+  ], { encoding: 'utf8' })
+    .replace('"../list-order"', '"../../src/list-order"')
+    .replace('"./PasteCard.vue"', '"../../src/components/PasteCard.vue"');
+  await writeFile(path.join(root, 'TimelineBefore.vue'), component);
+  await writeFile(path.join(root, 'timeline.html'), await readFile('apps/ztools/tests/browser/timeline.html'));
+  await writeFile(path.join(root, 'timeline.ts'),
+    (await readFile('apps/ztools/tests/browser/timeline.ts', 'utf8'))
+      .replace('"../../src/components/Timeline.vue"', '"./TimelineBefore.vue"'));
+
+  const results: unknown[] = [];
+  for (const version of ['before', 'after']) {
+    for (let run = 0; run < 3; run++) {
+      const url = version === 'before' ? '/artifacts/virtual-benchmark/timeline.html' : '/tests/browser/timeline.html';
+      await page.goto(url);
+      await page.waitForFunction(() => (window as any).timelineTest?.ready);
+      results.push(await page.evaluate(({ version, run }) => ({
+        version, run,
+        mountMs: (window as any).timelineTest.mountMs,
+        cards: document.querySelectorAll('.timeline__track [role="option"]').length,
+      }), { version, run }));
+    }
+  }
+  console.log('RENDER_BENCHMARK', JSON.stringify(results));
+});
diff --git a/plugins/pasteboard-pro/tests/performance/virtual-timeline.spec.ts b/plugins/pasteboard-pro/tests/performance/virtual-timeline.spec.ts
new file mode 100644
index 000000000..86390f3b8
--- /dev/null
+++ b/plugins/pasteboard-pro/tests/performance/virtual-timeline.spec.ts
@@ -0,0 +1,191 @@
+import { expect, test, type Page } from "playwright/test";
+
+const api = async (page: Page, method: string, ...args: unknown[]) => page.evaluate(
+  async ({ method, args }) => (window as any).timelineTest[method](...args), { method, args },
+);
+const cards = (page: Page) => page.locator('.timeline__track [role="option"]');
+async function open(page: Page, query = "") {
+  page.on("pageerror", (error) => console.log("PAGE ERROR:", error.message));
+  page.on("console", (message) => { if (message.type() === "error") console.log(message.text()); });
+  await page.goto(`/tests/browser/timeline.html?${query}`);
+  await expect.poll(() => page.evaluate(() => (window as any).timelineTest?.ready)).toBe(true);
+}
+async function scrollTo(page: Page, value: number, vertical = false) {
+  await page.locator('.timeline__track').evaluate((node, { value, vertical }) => {
+    if (vertical) node.scrollTop = value; else node.scrollLeft = value;
+  }, { value, vertical });
+  await page.waitForTimeout(50);
+}
+async function visibleAnchor(page: Page, vertical: boolean) {
+  return page.locator('.timeline__track').evaluate((node, vertical) => {
+    const bounds = node.getBoundingClientRect();
+    for (const card of node.querySelectorAll<HTMLElement>('[data-pb-item-id]')) {
+      const box = card.getBoundingClientRect();
+      if (vertical ? box.bottom > bounds.top && box.top < bounds.bottom : box.right > bounds.left && box.left < bounds.right) {
+        return { id: card.dataset.pbItemId, offset: vertical ? box.top - bounds.top : box.left - bounds.left };
+      }
+    }
+    return undefined;
+  }, vertical);
+}
+
+for (const vertical of [false, true]) {
+  for (const compact of [false, true]) {
+    test(`10,000 cards: ${vertical ? 'vertical' : 'horizontal'} ${compact ? 'compact' : 'expanded'}`, async ({ page }) => {
+      const errors: string[] = [];
+      page.on('pageerror', error => errors.push(error.message));
+      await open(page, `vertical=${+vertical}&compact=${+compact}`);
+      expect(await cards(page).count()).toBeGreaterThanOrEqual(30);
+      expect(await cards(page).count()).toBeLessThanOrEqual(50);
+      await expect(cards(page).first()).toHaveAttribute('aria-setsize', '10000');
+      const stride = vertical ? (compact ? 116 : 154) : (compact ? 192 : 252);
+      await scrollTo(page, 5000 * stride + 25, vertical);
+      const anchor = await visibleAnchor(page, vertical);
+      expect(anchor?.id).toBe('item-5000');
+      expect(await cards(page).count()).toBeGreaterThanOrEqual(30);
+      expect(await cards(page).count()).toBeLessThanOrEqual(50);
+      await api(page, 'prepend');
+      await expect.poll(async () => (await visibleAnchor(page, vertical))?.id).toBe(anchor?.id);
+      expect(Math.abs((await visibleAnchor(page, vertical))!.offset - anchor!.offset)).toBeLessThan(2);
+      await api(page, 'remove', 'item--1');
+      await expect.poll(async () => (await visibleAnchor(page, vertical))?.id).toBe(anchor?.id);
+      await api(page, 'focus', 9999);
+      await expect(page.locator('[data-pb-item-id="item-9999"]')).toBeFocused();
+      expect(await cards(page).count()).toBeGreaterThanOrEqual(30);
+      expect(await cards(page).count()).toBeLessThanOrEqual(50);
+      await api(page, 'focus', 0);
+      await expect(page.locator('[data-pb-item-id="item-0"]')).toBeFocused();
+      await api(page, 'focus', 1000);
+      await api(page, 'replace', 2);
+      await expect(cards(page)).toHaveCount(2);
+      await expect(cards(page).first()).toBeInViewport();
+      await api(page, 'replace', 0);
+      await expect(cards(page)).toHaveCount(0);
+      await api(page, 'replace', 10000);
+      await expect(cards(page).first()).toHaveAttribute('data-pb-item-id', 'item-0');
+      await api(page, 'density', !compact);
+      await api(page, 'focus', 5000);
+      await expect(page.locator('[data-pb-item-id="item-5000"]')).toBeFocused();
+      expect(errors).toEqual([]);
+      console.log(JSON.stringify({ vertical, compact, mounted: await cards(page).count(), mountMs: await page.evaluate(() => (window as any).timelineTest.mountMs) }));
+    });
+  }
+}
+
+test('image thumbnails load only near the viewport', async ({ page }) => {
+  await open(page, 'images=1');
+  await expect.poll(() => page.evaluate(() => (window as any).timelineTest.thumbnailIds.length)).toBeGreaterThan(0);
+  expect(await page.evaluate(() => (window as any).timelineTest.thumbnailIds.length)).toBeLessThan(20);
+  await api(page, 'focus', 5000);
+  await expect.poll(() => page.evaluate(() => (window as any).timelineTest.thumbnailIds.includes('item-5000'))).toBe(true);
+  expect(await page.evaluate(() => (window as any).timelineTest.thumbnailIds.length)).toBeLessThan(40);
+});
+
+test('dragging preserves source DOM across virtualization and moves offscreen selections', async ({ page }) => {
+  await open(page);
+  await api(page, 'select', ['item-0', 'item-2', 'item-5000']);
+  await page.evaluate(() => {
+    const source = document.querySelector<HTMLElement>('[data-pb-item-id="item-0"]')!;
+    const transfer = new DataTransfer();
+    (window as any).dragTest = { source, transfer };
+    source.dispatchEvent(new DragEvent('dragstart', { bubbles: true, cancelable: true, dataTransfer: transfer }));
+  });
+  await scrollTo(page, 1000 * 252);
+  expect(await page.evaluate(() => (window as any).dragTest.source.isConnected)).toBe(true);
+  expect(await cards(page).count()).toBeLessThanOrEqual(50);
+  await page.evaluate(async () => {
+    const { source, transfer } = (window as any).dragTest;
+    const target = document.querySelector<HTMLElement>('[data-pb-item-id="item-1002"]')!;
+    const bounds = target.getBoundingClientRect();
+    target.dispatchEvent(new DragEvent('dragover', {
+      bubbles: true, cancelable: true, dataTransfer: transfer,
+      clientX: bounds.right - 2, clientY: bounds.top + 50,
+    }));
+    await new Promise(requestAnimationFrame);
+    target.dispatchEvent(new DragEvent('drop', { bubbles: true, cancelable: true, dataTransfer: transfer }));
+    source.dispatchEvent(new DragEvent('dragend', { bubbles: true, dataTransfer: transfer }));
+  });
+  const ids = await api(page, 'ids') as string[];
+  const index = ids.indexOf('item-1002');
+  expect(ids.slice(index + 1, index + 4)).toEqual(['item-0', 'item-2', 'item-5000']);
+  expect(await api(page, 'selected')).toEqual(['item-0', 'item-2', 'item-5000']);
+  expect(await cards(page).count()).toBeGreaterThanOrEqual(30);
+      expect(await cards(page).count()).toBeLessThanOrEqual(50);
+});
+
+test('real shelf: keyboard navigation, search and refresh keep virtualization intact', async ({ page }) => {
+  const errors: string[] = [];
+  page.on('pageerror', error => errors.push(error.message));
+  await page.addInitScript(() => {
+    const makeItem = (index: number) => ({
+      id: `item-${index}`, kind: 'text', title: index === 9999 ? 'needle-last' : `Record ${index}`,
+      sourceDeviceId: 'test', copiedAt: new Date(1800000000000 - index).toISOString(),
+      updatedAt: new Date(1800000000000 - index).toISOString(),
+      contentFingerprint: `sha256:${index}`, payload: { revision: String(index), text: `Clipboard record ${index}` },
+      pinned: false, fieldClocks: {},
+    });
+    const history = Array.from({ length: 10000 }, (_, i) => makeItem(i));
+    const metrics = { calls: 0, prepend: () => { history.unshift(makeItem(-1)); } };
+    (window as any).shelfTest = metrics;
+    (window as any).pasteboardPro = {
+      getHostCompatibility: () => ({ supported: true }),
+      getPlatformCapabilities: () => ({ platform: 'darwin' }),
+      getWindowPreferences: async () => undefined,
+      getPrivacySettings: async () => ({ pause: { paused: false } }),
+      getListOrders: async () => ({}),
+      getPasteStack: async () => undefined,
+      getItemThumbnails: async () => [],
+      prepareNativeFileDrag: async () => false,
+      listPinboards: async () => [],
+      searchHistory: async () => {
+        metrics.calls++;
+        await new Promise(resolve => setTimeout(resolve, 20));
+        return { items: structuredClone(history), total: history.length };
+      },
+    };
+  });
+  await page.goto('/?shelf=1&dock=bottom');
+  await expect(cards(page).first()).toHaveAttribute('aria-setsize', '10000');
+  expect(await cards(page).count()).toBeGreaterThanOrEqual(30);
+      expect(await cards(page).count()).toBeLessThanOrEqual(50);
+  const search = page.getByRole('searchbox');
+  await search.focus();
+  await search.press('ArrowLeft');
+  await expect(page.locator('[data-pb-item-id="item-0"]')).toBeFocused();
+  for (let i = 0; i < 30; i++) await page.keyboard.press('ArrowRight');
+  await expect(page.locator('[data-pb-item-id="item-30"]')).toBeFocused();
+  expect(await cards(page).count()).toBeGreaterThanOrEqual(30);
+      expect(await cards(page).count()).toBeLessThanOrEqual(50);
+  await page.keyboard.press('Shift+ArrowRight');
+  await expect(page.locator('[data-pb-item-id="item-30"]')).toHaveAttribute('aria-selected', 'true');
+  await expect(page.locator('[data-pb-item-id="item-31"]')).toHaveAttribute('aria-selected', 'true');
+  await search.fill('needle-last');
+  await expect(cards(page)).toHaveCount(1);
+  await expect(cards(page).first()).toHaveAttribute('data-pb-item-id', 'item-9999');
+  await expect(cards(page).first()).toHaveAttribute('draggable', 'false');
+  // Broad search still includes all 10,000 matches, even though only a window
+  // of result cards is mounted. The last record remains reachable.
+  await search.fill('Clipboard record');
+  await expect(cards(page).first()).toHaveAttribute('aria-setsize', '10000');
+  expect(await cards(page).count()).toBeLessThanOrEqual(50);
+  await search.fill('needle-last');
+  await expect(cards(page)).toHaveCount(1);
+  await expect(cards(page).first()).toHaveAttribute('data-pb-item-id', 'item-9999');
+  await search.fill('');
+  await expect(cards(page).first()).toHaveAttribute('aria-setsize', '10000');
+  await page.locator('.timeline__track').evaluate(node => {
+    const width = Number.parseFloat(getComputedStyle(node).getPropertyValue('--pb-card-width'));
+    node.scrollLeft = 5000 * (width + 12) + 25;
+  });
+  await expect.poll(async () => (await visibleAnchor(page, false))?.id).toBe('item-5000');
+  const anchor = await visibleAnchor(page, false);
+  await page.evaluate(() => {
+    (window as any).shelfTest.prepend();
+    for (let i = 0; i < 25; i++) window.dispatchEvent(new CustomEvent('pasteboard-pro:history-changed'));
+  });
+  await expect(cards(page).first()).toHaveAttribute('aria-setsize', '10001');
+  await expect.poll(async () => (await visibleAnchor(page, false))?.id).toBe(anchor?.id);
+  expect(await page.evaluate(() => (window as any).shelfTest.calls)).toBe(2);
+  expect(errors).toEqual([]);
+  await page.screenshot({ path: "artifacts/virtual-timeline/shelf-10000.png" });
+});
diff --git a/plugins/pasteboard-pro/tests/performance/window-startup.spec.ts b/plugins/pasteboard-pro/tests/performance/window-startup.spec.ts
new file mode 100644
index 000000000..a95af6b23
--- /dev/null
+++ b/plugins/pasteboard-pro/tests/performance/window-startup.spec.ts
@@ -0,0 +1,86 @@
+import { expect, test } from "playwright/test";
+import { waitForWindowReadyScript } from "../../apps/ztools/window-ready";
+
+for (const mode of ["history", "empty", "history-error", "preferences-error", "editor"] as const) {
+  test(`production window waits for initial content: ${mode}`, async ({ page }) => {
+    const errors: string[] = [];
+    page.on("pageerror", error => errors.push(error.message));
+    await page.addInitScript(({ mode, readyScript }) => {
+      const w = window as any;
+      let releasePreferences!: () => void;
+      let releaseHistory!: () => void;
+      const preferences = new Promise<void>(resolve => { releasePreferences = resolve; });
+      const history = new Promise<void>(resolve => { releaseHistory = resolve; });
+      w.startupTest = { releasePreferences, releaseHistory, historyRequested: false, reveals: [] };
+      window.addEventListener("pasteboard-pro:window-ready", () => {
+        w.startupTest.reveals.push({
+          cards: document.querySelectorAll('.timeline__track [role="option"]').length,
+          background: document.querySelector(".stage")?.getAttribute("style"),
+          alert: document.querySelector('[role="alert"]')?.textContent,
+          editor: document.querySelector("textarea") !== null,
+        });
+      });
+      // The same script used by the native window manager, registered before Vue.
+      document.addEventListener("DOMContentLoaded", () => {
+        void eval(readyScript).then(() => { w.startupTest.hostReady = true; });
+      });
+      w.pasteboardPro = {
+        getHostCompatibility: () => ({ supported: true }),
+        getPlatformCapabilities: () => ({ platform: "darwin" }),
+        getWindowPreferences: async () => {
+          await preferences;
+          if (mode === "preferences-error") throw new Error("preferences unavailable");
+          return { dockEdge: "bottom", multiPasteMode: "batch", theme: {
+            accentColor: "#6f61ea", background: { type: "color", color: "#123456" },
+          } };
+        },
+        getPrivacySettings: async () => ({ pause: { paused: false } }),
+        getListOrders: async () => ({}), getPasteStack: async () => undefined,
+        getItemThumbnails: async () => [], prepareNativeFileDrag: async () => false,
+        listPinboards: async () => [],
+        searchHistory: async () => {
+          w.startupTest.historyRequested = true;
+          await history;
+          if (mode === "history-error") throw new Error("history unavailable");
+          const items = mode === "empty" ? [] : Array.from({ length: 10000 }, (_, index) => ({
+            id: `item-${index}`, kind: "text", title: index === 9999 ? "needle-last" : `Record ${index}`,
+            sourceDeviceId: "test", copiedAt: new Date(1800000000000 - index).toISOString(),
+            updatedAt: new Date(1800000000000 - index).toISOString(),
+            contentFingerprint: `sha256:${index}`, payload: { revision: String(index), text: `Clipboard record ${index}` },
+            pinned: false, fieldClocks: {},
+          }));
+          return { items, total: items.length };
+        },
+      };
+    }, { mode, readyScript: waitForWindowReadyScript });
+    await page.goto(`/dist/index.html?${mode === "editor" ? "panel=editor&mode=create" : "shelf=1&dock=bottom"}`);
+    await expect(page.locator(".stage")).toBeAttached();
+    expect(await page.evaluate(() => (window as any).startupTest.hostReady)).toBeUndefined();
+    expect(await page.evaluate(() => (window as any).startupTest.reveals)).toEqual([]);
+    await page.evaluate(() => (window as any).startupTest.releasePreferences());
+    if (mode !== "editor" && mode !== "preferences-error") {
+      await expect.poll(() => page.evaluate(() => (window as any).startupTest.historyRequested)).toBe(true);
+      expect(await page.evaluate(() => (window as any).startupTest.hostReady)).toBeUndefined();
+      await page.evaluate(() => (window as any).startupTest.releaseHistory());
+    }
+    await expect.poll(() => page.evaluate(() => (window as any).startupTest.hostReady)).toBe(true);
+    const reveals = await page.evaluate(() => (window as any).startupTest.reveals);
+    expect(reveals).toHaveLength(1);
+    if (mode.endsWith("error")) {
+      expect(reveals[0].alert).toContain("加载失败");
+    } else {
+      expect(reveals[0].background).toContain("#123456");
+      if (mode === "history") {
+        expect(reveals[0].cards).toBeGreaterThanOrEqual(30);
+        expect(reveals[0].cards).toBeLessThanOrEqual(50);
+        await page.getByRole("searchbox").fill("needle-last");
+        await expect(page.locator('.timeline__track [role="option"]')).toHaveCount(1);
+        await expect(page.locator('[data-pb-item-id="item-9999"]')).toBeVisible();
+      } else if (mode === "empty") expect(reveals[0].cards).toBe(0);
+      else expect(reveals[0].editor).toBe(true);
+    }
+    // A host whose callback arrives after Vue is ready must not miss the signal.
+    expect(await page.evaluate(waitForWindowReadyScript)).toBe(true);
+    expect(errors).toEqual([]);
+  });
+}