@restregular/dsh-notepad 0.4.0 → 0.5.0

package/README.md

@@ -1,8 +1,8 @@
 # dsh-notepad
 
-在 DeepSeek Harness 的会话界面里放一张**属于当前工作区**的分段便签浮窗：一行一个问题、一段一个卡片，回车就能新建下一段；需要时把某一段、或勾选后的多段一起插入 / 替换 / 发送到对话框。除了文字，也可以直接**粘贴或选择图片**，输入框里会用缩略芯片显示，插入 / 发送时按路径引用。0.4 起新分段置顶、卡片可写标题、点击序号选中、拖拽排序、合并多段，并可用 AI 优化单段或全部分段；隐藏时记事本和侧边栏工作区都会显示未发送数量角标。
+在 DeepSeek Harness 的会话界面里放一张**属于当前工作区**的分段便签浮窗：一行一个问题、一段一个卡片，回车就能新建下一段；需要时把某一段、或勾选后的多段一起插入 / 替换 / 发送到对话框。除了文字，也可以直接**粘贴或选择图片**，输入框里会用缩略芯片显示，插入 / 发送时按路径引用。0.4 起新分段置顶、点击序号选中、拖拽排序、合并多段；0.5 起空标题只在点击后显示输入框，上下方向键可切换分段，AI 优化只处理选中的分段且优化后按钮变为「撤销优化」，相同内容复用上次结果；自动刷新保持列表滚动位置，新增 `Ctrl/Cmd + Shift + 0` 复位浮窗位置和尺寸，浮窗也不会再越过窗口标题栏。
 
-> A per-workspace floating segmented notepad for DeepSeek Harness sessions. New segment cards lead the list, each card has an editable title, click the index to select, drag to reorder, merge a selection, and improve one or all cards with AI. Pending counts appear on the hidden launcher and the sidebar workspace row. Paste or pick images as in-input thumbnail chips; insert, replace, or send one segment or a multi-selection; sending archives the segment automatically. Notes live in `<workspace>/.dsh/notepad.json`, pasted images in `<workspace>/.dsh/notepad/images/`, and every session opened from that workspace shares the same note.
+> A per-workspace floating segmented notepad for DeepSeek Harness sessions. New segment cards lead the list; an empty title is a click-to-edit placeholder, arrow keys move between cards, and AI improvement only touches the selected cards — the button toggles to undo and unchanged content reuses the cached answer. Pending counts appear on the hidden launcher and the sidebar workspace row. Paste or pick images as in-input thumbnail chips; insert, replace, or send one segment or a multi-selection; sending archives the segment automatically. Auto refresh preserves the list scroll position, `Ctrl/Cmd + Shift + 0` resets the window geometry, the panel never covers the host title bar, and notes live in `<workspace>/.dsh/notepad.json` shared by every session from that workspace.
 
 ## 安装
 
@@ -31,9 +31,11 @@ dsh plugin --profile web add @restregular/dsh-notepad
 ```
 
 - **新建分段置顶**：标题栏 `+` 或分段末尾回车会在列表顶部创建新卡片；卡片从上到下保持最近在前，拖拽后按你的顺序保存。
-- **标题**：序号右边的输入框就是分段标题，边输入边自动保存。
+- **标题**：空标题只显示「分段标题（可选）」占位，没有 hover 底色；点击后才出现输入框。已有标题的卡片直接显示输入框，边输入边自动保存；在输入框里清空后不会立刻消失，失焦才回到占位状态。
 - **序号**：显示当前顺序（`01`、`02`…），点击可选中 / 取消选中这一段，拖动序号可调整卡片顺序。
-- **AI 优化**：卡片工具栏的 ✦ 优化此段；顶部工具栏的 ✦ 优化全部非空分段；结果可撤销。
+- **AI 优化**：勾选分段后，顶部工具栏的 ✦ 只优化选中的分段；卡片工具栏的 ✦ 优化此段。优化成功后，刚点过的按钮变成「撤销优化」，再点一次恢复原文；相同且未改动的标题 + 内容再次优化时直接复用上次结果，不再调用大模型。
+- **方向键**：光标在分段首行按 `↑` 跳到上一张卡片末尾；在末行按 `↓` 跳到下一张卡片开头。多行分段内部仍按正常文本光标移动。
+- **复位浮窗**：`Ctrl / Cmd + Shift + 0` 把位置和尺寸恢复为右下角的默认 `420 × 460`，最小化 / 归档展开等状态不变。
 - **合并**：勾选 2 段以上后点顶部工具栏的合并按钮，合并结果留在最靠上的选中位置。
 - **回车 / Enter**：把当前分段从光标处拆开，创建一张新的分段卡片（光标前的文字留在原卡片，光标后的文字进入新卡片）。在末尾回车就是新建一个空分段并置顶。
 - **Shift + Enter**：分段内换行。
@@ -46,12 +48,14 @@ dsh plugin --profile web add @restregular/dsh-notepad
 | --- | --- | --- |
 | 新建分段 | 标题栏 `+`，或分段末尾按回车 | 新卡片置顶并自动获得焦点 |
 | 编辑分段 | 点击卡片文本区 | 停止输入约 0.5 秒后自动保存 |
-| 分段标题 | 序号右侧的标题输入框 | 可留空；停止输入约 0.5 秒后自动保存 |
+| 分段标题 | 空标题卡片的占位 / 已有标题的输入框 | 空标题点击后才出现输入框；停止输入约 0.5 秒后自动保存 |
 | 选中分段 | 点击左上角序号，或左侧复选框 | 序号与复选框状态同步；点击序号即可参与批量操作 |
 | 拖拽排序 | 按住左上角序号拖动到另一张卡片的上 / 下半区 | 松开后按新顺序保存，序号自动重排 |
 | 合并分段 | 勾选 2 段以上 → 顶部工具栏合并按钮 | 按当前显示顺序合并文字、标题和图片，可撤销 |
-| AI 优化此段 | 卡片工具栏的 ✦ 按钮 | 用当前默认模型润色这一段，保留图片；可撤销 |
-| AI 优化全部 | 顶部工具栏的 ✦ 按钮 | 依次优化所有非空未归档分段，显示进度；可撤销 |
+| AI 优化此段 | 卡片工具栏的 ✦ 按钮 | 用当前默认模型润色这一段，保留图片；成功后按钮变为「撤销优化」 |
+| AI 优化选中 | 勾选分段 → 顶部工具栏的 ✦ 按钮 | 只优化勾选的非空未归档分段，显示进度；按钮变为「撤销优化」，可整体撤销 |
+| 撤销优化 | 优化后的 ✦ 按钮（或顶部工具栏） | 恢复优化前的文字；再次优化相同内容时直接复用上次结果 |
+| 方向键切换 | 分段文本内按 `↑` / `↓` | 首行 `↑` 到上一段末尾，末行 `↓` 到下一段开头 |
 | 未发送角标 | 最小化后的右下角图标；左侧边栏工作区行左上角 | 有未发送内容时显示数量，超过 99 显示 `99+` |
 | 添加图片（选择） | 卡片头部的图片按钮 | 桌面端直接用所选文件的宿主路径引入，不复制文件 |
 | 添加图片（粘贴） | 在分段文本区粘贴截图 / 图片 | 写入 `.dsh/notepad/images/`，再以该路径引入 |
@@ -71,9 +75,10 @@ dsh plugin --profile web add @restregular/dsh-notepad
 | 清空归档 | 归档区标题「清空归档」 | 批量删除归档，可撤销 |
 | 复制全部 | 标题栏复制按钮 | 复制所有分段（含归档），用空行合并 |
 | 调整尺寸 | 拖动右下角斜纹手柄 | 宽高按浏览器记忆，最小 320 × 240 |
+| 复位位置和尺寸 | `Ctrl/Cmd + Shift + 0` | 恢复默认 420 × 460 并停到右下角，其它状态不变 |
 | 折叠 / 展开 | 标题栏上下折叠箭头 | 只保留标题栏，内容继续自动保存 |
 | 最小化 / 恢复 | 标题栏最小化图标，或 `Ctrl/Cmd + Shift + N` | 收成右下角小图标，带平滑过渡 |
-| 拖动位置 | 按住标题栏拖动 | 位置按浏览器记忆 |
+| 拖动位置 | 按住标题栏拖动 | 位置按浏览器记忆；不会越过 DSH 窗口最顶部的标题栏（最大化 / 最小化 / 关闭那一栏） |
 
 同一个工作区里的不同会话共用同一份笔记：在 A 会话写的内容，切到同工作区的 B 会话仍然在。切换工作区时浮窗自动加载对应工作区的文件。
 
@@ -114,17 +119,19 @@ dsh plugin --profile web add @restregular/dsh-notepad
   `text` 是 `segments`（含图片引用）用空行合并后的副本，方便人工查看，也兼容旧版本。旧版单段文件（只有 `text`）、v2/v3 分段文件和手动改成纯文本的文件会在读取时迁移；没有 `createdAt` 的旧笔记会按「最近在前」反转一次显示顺序，之后按卡片数组顺序保存（拖拽后的顺序不会被自动重排）。`images[].path` 工作区内用相对路径，工作区外保留绝对路径；`name` 仅用于显示和 Markdown 替代文本。`title` 最长 200 字符。
 - **粘贴的图片**保存在 `<工作区>/.dsh/notepad/images/`，由宿主接口原子写入，只接受 PNG / JPEG / WebP / GIF，单张最大 20 MB；笔记只保存路径，不内嵌 base64。**选择的图片**直接引用原路径，不复制。每段最多 20 张。
 - **删除图片芯片**会同时删除插件自己保存在 `.dsh/notepad/images/` 下的对应文件；引用工作区外原路径的图片只删引用，不碰原文件。删除已归档分段 / 清空归档时，未被其它分段引用的插件图片会在撤销窗口结束后自动清理。
-- 浮窗位置、尺寸、折叠 / 最小化 / 隐藏状态、归档区是否展开保存在浏览器 `localStorage` 的 `dsh-notepad.ui.v1` 中，按浏览器 / 设备生效，不写入工作区。
+- 浮窗位置、尺寸、折叠 / 最小化 / 隐藏状态、归档区是否展开保存在浏览器 `localStorage` 的 `dsh-notepad.ui.v1` 中，按浏览器 / 设备生效，不写入工作区。位置会被限制在宿主标题栏下方（读取 DSH 的 `--dsh-frame-chrome-top` / `--dsh-frame-top-clearance`），`Ctrl/Cmd + Shift + 0` 可随时复位位置和尺寸。
 - 每个工作区一份笔记，最多 **200 段 / 512 KB**（单段输入框限制 16 万字符，每段最多 20 张图片）。浮窗内是纯文本编辑，不做 Markdown 渲染；图片以缩略芯片展示。
 - 浮窗只在**会话视图**出现：打开设置等非会话页面时自动隐藏，回到会话后恢复。
 - 写入走宿主同源回环路由 `/dsh-notepad/api/note`，粘贴图片走 `/dsh-notepad/api/image`，AI 优化走 `/dsh-notepad/api/optimize`，侧边栏角标计数走 `/dsh-notepad/api/unsent`；这些都只接受 127.0.0.1 的同源请求，并且只允许当前会话的 cwd 或已注册工作区。图片接口只会在固定的 `.dsh/notepad/images/` 下写入 / 删除合法的图片文件，不能用来读写或删除工作区里的其它文件。AI 优化使用当前默认模型，未配置模型时返回 `unavailable`，不会影响记事本的其它功能。
-- 窗口重新获得焦点时，如果本地没有未保存的修改，会自动读取磁盘上的最新内容；多窗口同时编辑时以最后一次保存为准，读取时保留当前卡片顺序，不会让正在看的卡片跳动。
+- **AI 优化缓存**：客户端按「工作区 + 标题 + 正文」缓存本页内的优化结果；宿主进程内也保留一份同样键的缓存（最多 64 条 / 约 200 万字符）。相同且未改动的标题 + 正文再次优化时直接复用上次结果，不再调用大模型；标题或正文变化后会重新请求。
+- 窗口重新获得焦点（或页面重新可见）时，如果本地没有未保存的修改，会自动读取磁盘上的最新内容；刷新前会立即记录列表的 `scrollTop`，写入新内容后恢复，读取时也保留当前卡片顺序，不会让正在看的卡片或列表位置跳动。
 
 ## 实现
 
-- **Host**（`index.js` + `lib/note-store.js` + `lib/image-store.js`）：`ctx.inject(['webServer'])` 注册 `/dsh-notepad/api` 下的 `GET/PUT /note`、`POST/DELETE /image`、`GET /unsent` 与 `POST /optimize`，用临时文件 + rename 原子写入 `.dsh/notepad.json`；`GET` 返回 `segments`（含 `title` / `createdAt` / `images`）与合并后的 `text`，`PUT` 接受 `{ segments: [...] }`，也兼容旧的 `{ text }`。`POST /image` 校验 base64、MIME 与文件签名后写入 `.dsh/notepad/images/`；`DELETE /image` 只允许删除该目录下的普通文件。`/unsent` 为已注册工作区统计未发送段数；`/optimize` 通过 `agentDefaultModel.currentSelection()` + `llm.prepareCall()` 调用当前默认模型，流式拼接文本后返回。
-- **Client**（`client.js`）：整个 bundle 包在 IIFE 里；通过 `shell.overlay` 注册浮窗，读取 `uiSession.adapter.current` 得到当前会话与工作区。标题、序号、拖拽排序和合并都在本地分段数组上完成，数组顺序就是保存顺序。侧边栏角标用 `MutationObserver` 监听 `[data-row-key^="workspace:"]` 并把未发送数量写成 `data-np-unsent` 属性，由 CSS 伪元素显示。粘贴图片用 `FileReader` 读成 base64 交给宿主保存；选择 / 拖入图片优先通过桌面桥 `__DSH_HOST_PATHS__.pathFor(file)` 拿宿主路径。插入 / 替换通过会话绑定里的 `inputActions.captureInsertion()/insertText()` 与 `setDraft()`；发送优先走 `sessions.scope(id).conversation.send()`，并回退到 `sessions.binding(id).session.prompt()`。图片在插入 / 发送时以 Markdown 图片语法追加，聊天记录里的 DSH 渲染器会按工作区 cwd 解析这些路径。
-- AI 优化只改分段文字，不动标题和图片；单段与批量优化都支持撤销。没有默认模型或模型调用失败时只提示错误，不影响笔记读写。
+- **Host**（`index.js` + `lib/note-store.js` + `lib/image-store.js`）：`ctx.inject(['webServer'])` 注册 `/dsh-notepad/api` 下的 `GET/PUT /note`、`POST/DELETE /image`、`GET /unsent` 与 `POST /optimize`，用临时文件 + rename 原子写入 `.dsh/notepad.json`；`GET` 返回 `segments`（含 `title` / `createdAt` / `images`）与合并后的 `text`，`PUT` 接受 `{ segments: [...] }`，也兼容旧的 `{ text }`。`POST /image` 校验 base64、MIME 与文件签名后写入 `.dsh/notepad/images/`；`DELETE /image` 只允许删除该目录下的普通文件。`/unsent` 为已注册工作区统计未发送段数；`/optimize` 先用 `workspace + title + text` 查进程内缓存，命中时返回 `{ cached: true }`，否则通过 `agentDefaultModel.currentSelection()` + `llm.prepareCall()` 调用当前默认模型，流式拼接文本后写入缓存并返回。
+- **Client**（`client.js`）：整个 bundle 包在 IIFE 里；通过 `shell.overlay` 注册浮窗，读取 `uiSession.adapter.current` 得到当前会话与工作区。标题、序号、拖拽排序和合并都在本地分段数组上完成，数组顺序就是保存顺序；空标题用占位按钮渲染，点击后才挂载输入框，`↑` / `↓` 在首 / 末行时把焦点和光标移到相邻卡片。侧边栏角标用 `MutationObserver` 监听 `[data-row-key^="workspace:"]` 并把未发送数量写成 `data-np-unsent` 属性，由 CSS 伪元素显示。粘贴图片用 `FileReader` 读成 base64 交给宿主保存；选择 / 拖入图片优先通过桌面桥 `__DSH_HOST_PATHS__.pathFor(file)` 拿宿主路径。插入 / 替换通过会话绑定里的 `inputActions.captureInsertion()/insertText()` 与 `setDraft()`；发送优先走 `sessions.scope(id).conversation.send()`，并回退到 `sessions.binding(id).session.prompt()`。图片在插入 / 发送时以 Markdown 图片语法追加，聊天记录里的 DSH 渲染器会按工作区 cwd 解析这些路径。
+- AI 优化只改分段文字，不动标题和图片；单段优化后该卡片按钮变为「撤销优化」，批量优化后工具栏按钮变为「撤销优化」，撤销会恢复优化前的文字。优化结果按内容缓存在客户端与宿主两侧，相同内容再次优化不会重复请求；没有默认模型或模型调用失败时只提示错误，不影响笔记读写。
+- 浮窗坐标同时受视口和宿主标题栏约束：拖动、调整尺寸、窗口缩放和快捷键复位都走同一个 `clampUi()`，最小 `top` 取 `--dsh-frame-chrome-top`（全屏时为 0）/ `--dsh-frame-top-clearance` 再加 8px。
 - 文案通过宿主 `locale` 服务注册中英文；找不到 locale 时按浏览器语言回退。
 
 ## 开发
@@ -148,14 +155,14 @@ node test/package.test.mjs
 npm test
 ```
 
-`test/client-smoke.mjs` 会真正执行 `apply(ctx)` 并渲染浮窗，覆盖：分段加载、编辑自动保存、新分段置顶、标题自动保存、序号选中、合并、单段 / 批量 AI 优化、拖拽排序、未发送角标、侧边栏工作区角标、回车拆分、单段/多段插入与替换、单段/多段发送与自动归档、归档显示隐藏、归档恢复与删除（含撤销）、全选、折叠、最小化 / 恢复、拖动调整尺寸、全局快捷键、深色模式与字体 CSS、重复执行 bundle 的兼容性，以及粘贴 / 选择图片、图片芯片、删除芯片时清理磁盘文件与带图插入发送。
+`test/client-smoke.mjs` 会真正执行 `apply(ctx)` 并渲染浮窗，覆盖：分段加载、编辑自动保存、自动刷新保持列表滚动位置、新分段置顶、空标题占位与点击后出现输入框、标题自动保存、序号选中、方向键跨分段切换光标、合并、单段 / 选中分段 AI 优化、优化后按钮切换为撤销、相同内容命中缓存、拖拽排序、未发送角标、侧边栏工作区角标、回车拆分、单段/多段插入与替换、单段/多段发送与自动归档、归档显示隐藏、归档恢复与删除（含撤销）、全选、折叠、最小化 / 恢复、拖动调整尺寸、标题栏下方位置限制、全局快捷键与复位快捷键、深色模式与字体 CSS、重复执行 bundle 的兼容性，以及粘贴 / 选择图片、图片芯片、删除芯片时清理磁盘文件与带图插入发送。
 
 ## 已知限制
 
 - 浮窗不会自动把内容推给 Agent；发送使用当前会话的排队发送，需要 Agent 可接收消息。
 - 发送按钮依赖 DSH 的会话接口；接口不可用时降级为插入输入框并提示。
 - 图片只支持 PNG / JPEG / WebP / GIF，单张最大 20 MB、每段最多 20 张；其它附件类型暂不支持。
-- AI 优化需要 DSH 里已配置默认模型；未配置时按钮会提示不可用，记笔记本身不受影响。
+- AI 优化需要 DSH 里已配置默认模型；未配置时按钮会提示不可用，记笔记本身不受影响。优化缓存保存在宿主进程内，重启 DSH 或切换默认模型后，相同内容会再请求一次。
 - 删除图片芯片会删除插件目录里的文件；如果同一路径仍被其它分段引用，则保留文件。选择的原路径图片只删引用，不删除原图。
 - 网页版没有 `__DSH_HOST_PATHS__` 桥，选择 / 拖入的图片会像粘贴一样先复制到 `.dsh/notepad/images/`。
 - 图片在浮窗里用缩略芯片表示，不提供富文本行内图文混排；插入 / 发送后由聊天记录按 Markdown 渲染。

package/client.js

@@ -37,7 +37,7 @@ window.__ModuleLoader__.load({
   factory: (require) => {
     const React = require('react');
     const h = React.createElement;
-    const { useState, useEffect, useRef } = React;
+    const { useState, useEffect, useLayoutEffect, useRef } = React;
 
     const NS = 'dsh-notepad';
     const API = '/dsh-notepad/api';
@@ -56,6 +56,8 @@ window.__ModuleLoader__.load({
     const MAX_OPTIMIZE_CHARS = 60000;
     const SIDEBAR_REFRESH_MS = 20000;
     const IMAGE_DELETE_DELAY = 5000;
+    const OPTIMIZE_CACHE_LIMIT = 100;
+    const EDGE_GAP = 8;
     const IMAGE_MIME = {
       'image/png': 'png',
       'image/jpeg': 'jpg',
@@ -114,11 +116,14 @@ window.__ModuleLoader__.load({
         mergeHint: '至少选择 2 段才能合并',
         mergedToast: '已合并 {n} 段',
         optimizeSegment: 'AI 优化此段',
-        optimizeAll: 'AI 优化全部分段',
+        optimizeSelected: 'AI 优化选中的 {n} 段',
+        optimizeSelectHint: '勾选分段后可批量优化',
         optimizeAllProgress: 'AI 优化中 {done}/{total}',
         optimizing: '优化中…',
+        undoOptimize: '撤销优化',
         optimizedToast: '已优化此段',
         optimizedCount: '已优化 {n} 段',
+        optimizeUndone: '已撤销优化',
         optimizeEmpty: '没有可优化的文字',
         optimizeTooLong: '内容太长，无法优化',
         optimizeUnavailable: 'AI 服务不可用',
@@ -155,9 +160,10 @@ window.__ModuleLoader__.load({
         show: '显示记事本（Ctrl+Shift+N）',
         chars: '{n} 字符',
         segments: '{n} 段',
-        hint: 'Enter 新建分段 · Shift+Enter 换行 · Ctrl+Enter 插入 · 支持粘贴图片',
+        hint: 'Enter 新建分段 · Shift+Enter 换行 · Ctrl+Enter 插入 · Ctrl+Shift+0 复位浮窗 · 支持粘贴图片',
         workspace: '工作区',
         resize: '拖动调整大小',
+        uiReset: '已复位浮窗位置和尺寸',
         addImage: '添加图片',
         removeImage: '移除图片',
         openImage: '打开图片',
@@ -218,11 +224,14 @@ window.__ModuleLoader__.load({
         mergeHint: 'Select at least 2 segments to merge',
         mergedToast: 'Merged {n} segments',
         optimizeSegment: 'Improve this segment with AI',
-        optimizeAll: 'Improve all segments with AI',
+        optimizeSelected: 'Improve {n} selected with AI',
+        optimizeSelectHint: 'Select segments to improve',
         optimizeAllProgress: 'Improving {done}/{total}',
         optimizing: 'Improving…',
+        undoOptimize: 'Undo improvement',
         optimizedToast: 'Segment improved',
         optimizedCount: 'Improved {n} segments',
+        optimizeUndone: 'Improvement undone',
         optimizeEmpty: 'Nothing to improve',
         optimizeTooLong: 'Too long to improve',
         optimizeUnavailable: 'AI service unavailable',
@@ -259,9 +268,10 @@ window.__ModuleLoader__.load({
         show: 'Show notepad (Ctrl+Shift+N)',
         chars: '{n} chars',
         segments: '{n} segments',
-        hint: 'Enter new segment · Shift+Enter newline · Ctrl+Enter insert · Paste images',
+        hint: 'Enter new segment · Shift+Enter newline · Ctrl+Enter insert · Ctrl+Shift+0 reset window · Paste images',
         workspace: 'Workspace',
         resize: 'Drag to resize',
+        uiReset: 'Window position and size reset',
         addImage: 'Add image',
         removeImage: 'Remove image',
         openImage: 'Open image',
@@ -548,6 +558,24 @@ window.__ModuleLoader__.load({
       );
     }
 
+    /** Curved arrow: undo the last AI improvement. */
+    function UndoIcon({ size = 16 }) {
+      return h(
+        Svg,
+        { size, viewBox: '0 0 16 16' },
+        h('path', {
+          d: 'M5.4 4.2 2.8 6.8l2.6 2.6',
+          stroke: 'currentColor', strokeWidth: 1.35,
+          strokeLinecap: 'round', strokeLinejoin: 'round',
+        }),
+        h('path', {
+          d: 'M3 6.8h5.3c2.7 0 4.9 2.2 4.9 4.9',
+          stroke: 'currentColor', strokeWidth: 1.35,
+          strokeLinecap: 'round', strokeLinejoin: 'round',
+        }),
+      );
+    }
+
     /** Two arrows converging: merge selected segments into one. */
     function MergeIcon({ size = 16 }) {
       return h(
@@ -608,7 +636,7 @@ window.__ModuleLoader__.load({
 .dsh-np-btn[data-accent=true]{background:var(--np-accent);color:var(--np-accent-fg)}
 .dsh-np-btn[data-accent=true]:hover:not(:disabled){background:color-mix(in srgb,var(--np-accent) 88%,#000);color:var(--np-accent-fg)}
 .dsh-np-btn:disabled{opacity:.38;cursor:default;background:transparent;color:var(--dsw-alias-label-tertiary,#6b7280)}
-.dsh-np-btn:focus-visible,.dsh-np-segbtn:focus-visible,.dsh-np-link:focus-visible,.dsh-np-empty-add:focus-visible,.dsh-np-toast-action:focus-visible,.dsh-np-selectall input:focus-visible,.dsh-np-check input:focus-visible,.dsh-np-restore:focus-visible,.dsh-np-img-open:focus-visible,.dsh-np-img-remove:focus-visible{outline:2px solid var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary,#4176e6));outline-offset:-2px}
+.dsh-np-btn:focus-visible,.dsh-np-segbtn:focus-visible,.dsh-np-link:focus-visible,.dsh-np-empty-add:focus-visible,.dsh-np-toast-action:focus-visible,.dsh-np-selectall input:focus-visible,.dsh-np-check input:focus-visible,.dsh-np-title-add:focus-visible,.dsh-np-restore:focus-visible,.dsh-np-img-open:focus-visible,.dsh-np-img-remove:focus-visible{outline:2px solid var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary,#4176e6));outline-offset:-2px}
 .dsh-np-body{display:flex;flex:1 1 auto;flex-direction:column;min-height:0;padding:8px 10px 0;opacity:1;transition:opacity .16s ease,visibility 0s linear 0s}
 .dsh-np-card[data-minimized=true] .dsh-np-body{opacity:0;visibility:hidden;pointer-events:none;transition:opacity .16s ease,visibility 0s linear .16s}
 .dsh-np-tools{display:flex;align-items:center;flex-wrap:wrap;gap:4px;flex:none;padding:0 2px 7px;border-bottom:1px solid var(--dsw-alias-border-l1,rgb(15 23 42/.08))}
@@ -633,6 +661,7 @@ window.__ModuleLoader__.load({
 .dsh-np-title-input::placeholder{color:var(--dsw-alias-label-caption,#9aa3b2);font-weight:400}
 .dsh-np-title-input:hover{background:var(--dsw-alias-interactive-bg-hover,rgb(38 49 72/.06))}
 .dsh-np-title-input:focus{background:var(--np-surface);box-shadow:0 0 0 1px var(--np-accent) inset;color:var(--dsw-alias-label-primary,#1f2430)}
+.dsh-np-title-add{flex:1 1 auto;min-width:0;width:0;height:20px;padding:0 4px;border:0;border-radius:5px;background:transparent;color:var(--dsw-alias-label-caption,#9aa3b2);font:inherit;font-size:11px;font-weight:400;line-height:20px;text-align:left;cursor:text;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;opacity:.75}
 .dsh-np-seg-title{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-secondary,#4b5563);font-size:11px;font-weight:600}
 .dsh-np-archived-chip{flex:none;padding:0 6px;border-radius:5px;background:var(--dsw-alias-interactive-bg-hover,rgb(38 49 72/.06));color:var(--dsw-alias-label-tertiary,#6b7280);font-size:10px;line-height:16px}
 .dsh-np-segbtn{flex:none;display:inline-flex;align-items:center;justify-content:center;width:24px;height:24px;padding:0;border:0;border-radius:6px;background:transparent;color:var(--dsw-alias-label-tertiary,#6b7280);cursor:pointer;transition:background .12s,color .12s,opacity .12s;opacity:.8}
@@ -1032,6 +1061,43 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
       return parts.length === 0 ? String(root ?? '') : parts[parts.length - 1];
     }
 
+    /**
+     * Height of the chrome the host draws over the page (the Windows title bar
+     * with maximize / minimize / close, or the macOS traffic lights). The
+     * floating card must never move above that strip. The host exposes it as a
+     * CSS variable on <html>; standalone browsers have none, so this is 0.
+     * @returns {number}
+     */
+    function hostChromeTop() {
+      try {
+        const root = typeof document !== 'undefined' ? document.documentElement : null;
+        if (root === null || root === undefined) return 0;
+        const hasAttribute = (name) => typeof root.hasAttribute === 'function' && root.hasAttribute(name);
+        const readVar = (name) => {
+          try {
+            if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function') return NaN;
+            const style = window.getComputedStyle(root);
+            return Number.parseFloat(style?.getPropertyValue(name) ?? '');
+          } catch {
+            return NaN;
+          }
+        };
+        // `--dsh-frame-chrome-top` is 0 while the host is in fullscreen.
+        const chrome = readVar('--dsh-frame-chrome-top');
+        if (Number.isFinite(chrome)) return Math.max(0, chrome);
+        const clearance = readVar('--dsh-frame-top-clearance');
+        if (Number.isFinite(clearance) && clearance > 0) return clearance;
+        if (hasAttribute('data-windows-titlebar')) {
+          const titlebar = readVar('--dsh-windows-titlebar-height');
+          return Number.isFinite(titlebar) && titlebar > 0 ? titlebar : 32;
+        }
+        const platform = typeof root.getAttribute === 'function' ? root.getAttribute('data-platform') : '';
+        return platform === 'darwin' ? 48 : 0;
+      } catch {
+        return 0;
+      }
+    }
+
     function readStoredUi() {
       const base = {
         x: null,
@@ -1064,17 +1130,18 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
     function clampUi(ui) {
       const vw = (typeof window !== 'undefined' && window.innerWidth) || 1280;
       const vh = (typeof window !== 'undefined' && window.innerHeight) || 800;
-      const widthLimit = Math.max(240, vw - 16);
-      const heightLimit = Math.max(180, vh - 16);
+      const minTop = hostChromeTop() + EDGE_GAP;
+      const widthLimit = Math.max(240, vw - EDGE_GAP * 2);
+      const heightLimit = Math.max(180, vh - minTop - EDGE_GAP);
       const width = Math.min(Math.max(MIN_W, Number(ui.width) || DEFAULT_W), widthLimit);
       const height = Math.min(Math.max(MIN_H, Number(ui.height) || DEFAULT_H), heightLimit);
       const displayHeight = ui.minimized ? HEAD_H : height;
       const x = ui.x === null || ui.x === undefined
-        ? vw - width - 24
-        : Math.min(Math.max(8, ui.x), Math.max(8, vw - width - 8));
+        ? Math.max(EDGE_GAP, vw - width - 24)
+        : Math.min(Math.max(EDGE_GAP, ui.x), Math.max(EDGE_GAP, vw - width - EDGE_GAP));
       const y = ui.y === null || ui.y === undefined
-        ? vh - displayHeight - 24
-        : Math.min(Math.max(8, ui.y), Math.max(8, vh - displayHeight - 8));
+        ? Math.max(minTop, vh - displayHeight - 24)
+        : Math.min(Math.max(minTop, ui.y), Math.max(minTop, vh - displayHeight - EDGE_GAP));
       return { ...ui, x, y, width, height };
     }
 
@@ -1201,7 +1268,7 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
       const [error, setError] = useState('');
       const [savedAt, setSavedAt] = useState(null);
       const [toast, setToast] = useState(null);
-      const [ui, setUi] = useState(readStoredUi);
+      const [ui, setUi] = useState(() => clampUi(readStoredUi()));
       const [sending, setSending] = useState(false);
       const [resizing, setResizing] = useState(false);
       const [uploading, setUploading] = useState({});
@@ -1209,7 +1276,10 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
       const [reorderDrag, setReorderDrag] = useState('');
       const [reorderOver, setReorderOver] = useState(null);
       const [optimizing, setOptimizing] = useState(() => new Set());
-      const [optimizeAll, setOptimizeAll] = useState(null);
+      const [optimizeBatch, setOptimizeBatch] = useState(null);
+      const [segmentUndo, setSegmentUndo] = useState(() => new Map());
+      const [batchUndo, setBatchUndo] = useState(null);
+      const [titleEditing, setTitleEditing] = useState('');
       const [wsCounts, setWsCounts] = useState({});
       const [currentWsId, setCurrentWsId] = useState('');
 
@@ -1235,9 +1305,13 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
       const fileInputRefs = useRef(new Map());
       const listRef = useRef(null);
       const pendingFocusRef = useRef(null);
+      const pendingScrollRef = useRef(null);
+      const refreshSeqRef = useRef(0);
       const undoRef = useRef(null);
       const optimizingRef = useRef(new Set());
-      const optimizeAllRef = useRef(false);
+      const optimizeBatchRef = useRef(false);
+      const optimizeCacheRef = useRef(new Map());
+      const batchUndoRef = useRef(null);
       const reorderDragRef = useRef('');
       const reorderOverRef = useRef(null);
       const imageDeleteTimersRef = useRef(new Map());
@@ -1259,6 +1333,17 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         if (changed) setSelection(pruned);
       };
 
+      /** Keep the ref and the state in sync for the batch-optimize undo slot. */
+      const setBatchUndoState = (value) => {
+        batchUndoRef.current = value;
+        setBatchUndo(value);
+      };
+
+      /** Any local edit invalidates the "undo the last batch" offer. */
+      const invalidateBatchUndo = () => {
+        if (batchUndoRef.current !== null) setBatchUndoState(null);
+      };
+
       // Session + workspace -------------------------------------------------
       useEffect(() => {
         let disposed = false;
@@ -1378,6 +1463,7 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
       saveNowRef.current = saveNow;
 
       const commitSegments = (next, options = {}) => {
+        invalidateBatchUndo();
         segmentsRef.current = next;
         setSegments(next);
         pruneSelectionFor(next);
@@ -1396,6 +1482,10 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
           segmentsRef.current = [];
           setSegments([]);
           setSelection(new Set());
+          setSegmentUndo(new Map());
+          setBatchUndoState(null);
+          setTitleEditing('');
+          pendingScrollRef.current = null;
           setStatus('idle');
           setError('');
           return undefined;
@@ -1412,6 +1502,10 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         segmentsRef.current = [];
         setSegments([]);
         setSelection(new Set());
+        setSegmentUndo(new Map());
+        setBatchUndoState(null);
+        setTitleEditing('');
+        pendingScrollRef.current = null;
         setStatus('loading');
         setError('');
         const load = () => {
@@ -1430,6 +1524,8 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
               segmentsRef.current = value;
               setSegments(value);
               setSelection(new Set());
+              setSegmentUndo(new Map());
+              setBatchUndoState(null);
               versionRef.current = typeof data.mtimeMs === 'number' ? data.mtimeMs : null;
               setSavedAt(typeof data.mtimeMs === 'number' ? data.mtimeMs : null);
               dirtyRef.current = false;
@@ -1566,14 +1662,41 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         autoGrow(element);
       }, [segments]);
 
+      // Restore a captured scroll offset right after a refresh commits ------
+      useLayoutEffect(() => {
+        const pending = pendingScrollRef.current;
+        if (pending === null || pending === undefined) return;
+        pendingScrollRef.current = null;
+        const list = listRef.current;
+        if (list === null || list === undefined) return;
+        try {
+          list.scrollTop = pending;
+        } catch {
+          /* A detached list cannot be scrolled. */
+        }
+      }, [segments]);
+
       // Keyboard ------------------------------------------------------------
       useEffect(() => {
         const onKeyDown = (event) => {
           const chord = event.ctrlKey || event.metaKey;
-          if (!chord || !event.shiftKey) return;
-          if (event.key !== 'N' && event.key !== 'n') return;
-          event.preventDefault();
-          setUi((previous) => clampUi({ ...previous, hidden: !previous.hidden }));
+          if (!chord || !event.shiftKey || event.altKey) return;
+          if (event.key === 'N' || event.key === 'n') {
+            event.preventDefault();
+            setUi((previous) => clampUi({ ...previous, hidden: !previous.hidden }));
+            return;
+          }
+          if (event.key === '0' || event.code === 'Digit0' || event.code === 'Numpad0') {
+            event.preventDefault();
+            setUi((previous) => clampUi({
+              ...previous,
+              x: null,
+              y: null,
+              width: DEFAULT_W,
+              height: DEFAULT_H,
+            }));
+            showToast(t('uiReset'));
+          }
         };
         window.addEventListener('keydown', onKeyDown, true);
         return () => {
@@ -1616,10 +1739,25 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
           const active = typeof document !== 'undefined' ? document.activeElement : null;
           if (active !== null && active !== undefined && typeof active.closest === 'function'
             && active.closest('[data-dsh-notepad="true"]') !== null) return;
+          // Snapshot the scroll offset right before the refresh; the list may
+          // re-render (and jump) while the updated note is applied.
+          const list = listRef.current;
+          const scrollTop = list !== null && list !== undefined && Number.isFinite(list.scrollTop)
+            ? list.scrollTop
+            : null;
+          const mySeq = ++refreshSeqRef.current;
+          pendingScrollRef.current = scrollTop;
           fetchNote(root, sessionId)
             .then((data) => {
-              if (rootRef.current !== root || dirtyRef.current) return;
-              if (typeof data.mtimeMs === 'number' && data.mtimeMs === versionRef.current) return;
+              if (mySeq !== refreshSeqRef.current) return;
+              if (rootRef.current !== root || dirtyRef.current) {
+                pendingScrollRef.current = null;
+                return;
+              }
+              if (typeof data.mtimeMs === 'number' && data.mtimeMs === versionRef.current) {
+                pendingScrollRef.current = null;
+                return;
+              }
               let incoming = normalizeServerSegments(data);
               if (isLegacyPayload(data)) incoming = incoming.slice().reverse();
               if (incoming.length === 0) incoming = [newSegment('')];
@@ -1627,11 +1765,15 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
               segmentsRef.current = value;
               setSegments(value);
               pruneSelectionFor(value);
+              setSegmentUndo(new Map());
+              setBatchUndoState(null);
               versionRef.current = typeof data.mtimeMs === 'number' ? data.mtimeMs : null;
               setSavedAt(typeof data.mtimeMs === 'number' ? data.mtimeMs : null);
               setStatus('saved');
             })
-            .catch(() => {});
+            .catch(() => {
+              if (mySeq === refreshSeqRef.current) pendingScrollRef.current = null;
+            });
         };
         const onVisibility = () => {
           if (typeof document !== 'undefined' && document.visibilityState === 'visible') refresh();
@@ -1650,9 +1792,17 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
 
       // Segment mutations ---------------------------------------------------
       const updateSegmentText = (id, value) => {
+        invalidateBatchUndo();
         const next = segmentsRef.current.map((segment) => (segment.id === id ? { ...segment, text: value } : segment));
         segmentsRef.current = next;
         setSegments(next);
+        setSegmentUndo((previous) => {
+          const record = previous.get(id);
+          if (record === undefined || record.after === value) return previous;
+          const pruned = new Map(previous);
+          pruned.delete(id);
+          return pruned;
+        });
         dirtyRef.current = true;
         setStatus('dirty');
         setError('');
@@ -1663,6 +1813,7 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         const title = String(value ?? '').slice(0, MAX_TITLE_CHARS);
         const target = segmentsRef.current.find((segment) => segment.id === id);
         if (target === undefined || target.title === title) return;
+        invalidateBatchUndo();
         const next = segmentsRef.current.map((segment) => (segment.id === id ? { ...segment, title } : segment));
         segmentsRef.current = next;
         setSegments(next);
@@ -1935,6 +2086,8 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         if (record === null || record === undefined) return;
         undoRef.current = null;
         clearPendingImageDeletes();
+        setSegmentUndo(new Map());
+        setBatchUndoState(null);
         commitSegments(record.snapshot);
         setToast(null);
       };
@@ -2084,14 +2237,33 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         setOptimizing(next);
       };
 
+      /** Cache key: the prompt depends on the workspace, title and card text. */
+      const optimizationCacheKey = (root, segment) =>
+        `${root}\u0000${segment.title ?? ''}\u0000${segment.text}`;
+
+      const rememberOptimization = (key, value) => {
+        const cache = optimizeCacheRef.current;
+        cache.delete(key);
+        cache.set(key, value);
+        while (cache.size > OPTIMIZE_CACHE_LIMIT) {
+          const oldest = cache.keys().next();
+          if (oldest.done === true) break;
+          cache.delete(oldest.value);
+        }
+      };
+
       const requestOptimization = async (segment) => {
         const root = rootRef.current;
         const sessionId = rootSessionRef.current;
         if (root === '' || sessionId === '') throw new Error(t('optimizeUnavailable'));
         if (segment.text.length > MAX_OPTIMIZE_CHARS) throw new Error(t('optimizeTooLong'));
+        const cacheKey = optimizationCacheKey(root, segment);
+        const cached = optimizeCacheRef.current.get(cacheKey);
+        if (typeof cached === 'string' && cached !== '') return cached;
         const data = await optimizeNoteText(root, sessionId, segment.text, segment.title ?? '');
         const value = typeof data.text === 'string' ? data.text.trim() : '';
         if (value === '') throw new Error(t('optimizeFailed'));
+        rememberOptimization(cacheKey, value);
         return value;
       };
 
@@ -2102,18 +2274,21 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
           showToast(t('optimizeEmpty'));
           return;
         }
-        const snapshot = segmentsRef.current;
         const original = target.text;
         markOptimizing(id, true);
         try {
           const value = await requestOptimization(target);
           const current = segmentsRef.current.find((segment) => segment.id === id);
           if (current === undefined || current.text !== original || value === original) return;
-          undoRef.current = { snapshot };
           const next = segmentsRef.current.map((segment) =>
             (segment.id === id ? { ...segment, text: value } : segment));
           commitSegments(next);
-          showToast(t('optimizedToast'), { label: t('undo'), onClick: undoLast });
+          setSegmentUndo((previous) => {
+            const updated = new Map(previous);
+            updated.set(id, { before: original, after: value });
+            return updated;
+          });
+          showToast(t('optimizedToast'));
         } catch (reason) {
           const message = String(reason?.message ?? reason);
           showToast(message === t('optimizeTooLong') || message === t('optimizeUnavailable')
@@ -2124,20 +2299,46 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         }
       };
 
-      const optimizeAllSegments = async () => {
-        if (optimizeAllRef.current) return;
+      const undoOptimizeSegment = (id) => {
+        const record = segmentUndo.get(id);
+        const current = segmentsRef.current.find((segment) => segment.id === id);
+        if (record !== undefined && current !== undefined && current.text === record.after) {
+          const next = segmentsRef.current.map((segment) =>
+            (segment.id === id ? { ...segment, text: record.before } : segment));
+          commitSegments(next);
+          setSegmentUndo((previous) => {
+            if (!previous.has(id)) return previous;
+            const updated = new Map(previous);
+            updated.delete(id);
+            return updated;
+          });
+          showToast(t('optimizeUndone'));
+          return;
+        }
+        setSegmentUndo((previous) => {
+          if (!previous.has(id)) return previous;
+          const updated = new Map(previous);
+          updated.delete(id);
+          return updated;
+        });
+      };
+
+      /** Improve only the checked segments; identical text is answered from cache. */
+      const optimizeSelectedSegments = async () => {
+        if (optimizeBatchRef.current) return;
+        const ids = new Set(selectedRef.current);
         const targets = segmentsRef.current.filter((segment) =>
-          segment.archived !== true && segment.text.trim() !== '');
+          segment.archived !== true && ids.has(segment.id) && segment.text.trim() !== '');
         if (targets.length === 0) {
           showToast(t('optimizeEmpty'));
           return;
         }
-        optimizeAllRef.current = true;
+        optimizeBatchRef.current = true;
         const snapshot = segmentsRef.current;
         let done = 0;
         let changed = 0;
         let failed = 0;
-        setOptimizeAll({ done, total: targets.length });
+        setOptimizeBatch({ done, total: targets.length });
         try {
           for (const target of targets) {
             const current = segmentsRef.current.find((segment) =>
@@ -2152,6 +2353,11 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
                       ? { ...segment, text: value }
                       : segment));
                   commitSegments(next);
+                  setSegmentUndo((previous) => {
+                    const updated = new Map(previous);
+                    updated.set(target.id, { before: current.text, after: value });
+                    return updated;
+                  });
                   changed += 1;
                 }
               } catch {
@@ -2161,20 +2367,29 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
               }
             }
             done += 1;
-            setOptimizeAll({ done, total: targets.length });
+            setOptimizeBatch({ done, total: targets.length });
           }
           if (changed > 0) {
-            undoRef.current = { snapshot };
-            showToast(t('optimizedCount', { n: changed }), { label: t('undo'), onClick: undoLast });
+            setBatchUndoState({ snapshot });
+            showToast(t('optimizedCount', { n: changed }));
           } else {
             showToast(failed > 0 ? t('optimizeFailed') : t('optimizedToast'));
           }
         } finally {
-          optimizeAllRef.current = false;
-          setOptimizeAll(null);
+          optimizeBatchRef.current = false;
+          setOptimizeBatch(null);
         }
       };
 
+      const undoBatchOptimization = () => {
+        const record = batchUndoRef.current;
+        if (record === null || record === undefined) return;
+        setBatchUndoState(null);
+        setSegmentUndo(new Map());
+        commitSegments(record.snapshot);
+        showToast(t('optimizeUndone'));
+      };
+
       // Selection -----------------------------------------------------------
       const toggleSelected = (id) => {
         const next = new Set(selectedRef.current);
@@ -2370,6 +2585,34 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         updateSegmentText(id, event.target?.value ?? '');
       };
 
+      /** Focus a card's textarea and place the caret at an absolute offset. */
+      const focusSegmentAt = (id, caret) => {
+        const element = textareaRefs.current.get(id);
+        if (element === null || element === undefined) return false;
+        try {
+          element.focus?.({ preventScroll: true });
+        } catch {
+          try {
+            element.focus?.();
+          } catch {
+            /* ignore */
+          }
+        }
+        try {
+          const value = typeof element.value === 'string' ? element.value : '';
+          const position = Math.max(0, Math.min(Number(caret) || 0, value.length));
+          if (typeof element.setSelectionRange === 'function') element.setSelectionRange(position, position);
+        } catch {
+          /* A non-layout shim may not support ranges. */
+        }
+        try {
+          element.scrollIntoView?.({ block: 'nearest' });
+        } catch {
+          /* ignore */
+        }
+        return true;
+      };
+
       const onSegmentKeyDown = (event, id) => {
         if (event.isComposing === true || event.nativeEvent?.isComposing === true) return;
         const chord = event.ctrlKey || event.metaKey;
@@ -2384,6 +2627,28 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
           insertSegments(list);
           return;
         }
+        if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
+          if (event.altKey || event.shiftKey || chord) return;
+          const element = event.currentTarget ?? event.target;
+          const value = typeof element?.value === 'string' ? element.value : '';
+          const start = typeof element?.selectionStart === 'number' ? element.selectionStart : null;
+          const end = typeof element?.selectionEnd === 'number' ? element.selectionEnd : start;
+          if (start === null || start !== end) return;
+          const firstBreak = value.indexOf('\n');
+          const lastBreak = value.lastIndexOf('\n');
+          const up = event.key === 'ArrowUp';
+          const atEdge = up
+            ? (firstBreak === -1 || start <= firstBreak)
+            : (lastBreak === -1 || start > lastBreak);
+          if (!atEdge) return;
+          const active = segmentsRef.current.filter((segment) => segment.archived !== true);
+          const position = active.findIndex((segment) => segment.id === id);
+          const neighbor = position < 0 ? undefined : active[position + (up ? -1 : 1)];
+          if (neighbor !== undefined && focusSegmentAt(neighbor.id, up ? neighbor.text.length : 0)) {
+            event.preventDefault?.();
+          }
+          return;
+        }
         if (event.key !== 'Enter' || event.shiftKey || event.altKey || chord) return;
         event.preventDefault();
         splitSegment(id, event.currentTarget ?? event.target);
@@ -2400,8 +2665,11 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
           const vw = window.innerWidth || 1280;
           const vh = window.innerHeight || 800;
           const height = ui.minimized ? HEAD_H : ui.height;
-          const x = Math.min(Math.max(8, start.x + moveEvent.clientX - start.px), Math.max(8, vw - ui.width - 8));
-          const y = Math.min(Math.max(8, start.y + moveEvent.clientY - start.py), Math.max(8, vh - height - 8));
+          const minY = hostChromeTop() + EDGE_GAP;
+          const x = Math.min(Math.max(EDGE_GAP, start.x + moveEvent.clientX - start.px),
+            Math.max(EDGE_GAP, vw - ui.width - EDGE_GAP));
+          const y = Math.min(Math.max(minY, start.y + moveEvent.clientY - start.py),
+            Math.max(minY, vh - height - EDGE_GAP));
           setUi((previous) => ({ ...previous, x, y }));
         };
         const stop = () => {
@@ -2427,17 +2695,20 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
         const move = (moveEvent) => {
           const vw = window.innerWidth || 1280;
           const vh = window.innerHeight || 800;
-          const width = Math.min(Math.max(MIN_W, start.width + moveEvent.clientX - start.px), Math.max(MIN_W, vw - 16));
-          const height = Math.min(Math.max(MIN_H, start.height + moveEvent.clientY - start.py), Math.max(MIN_H, vh - 16));
+          const minY = hostChromeTop() + EDGE_GAP;
+          const width = Math.min(Math.max(MIN_W, start.width + moveEvent.clientX - start.px),
+            Math.max(MIN_W, vw - EDGE_GAP * 2));
+          const height = Math.min(Math.max(MIN_H, start.height + moveEvent.clientY - start.py),
+            Math.max(MIN_H, vh - minY - EDGE_GAP));
           setUi((previous) => {
-            const maxX = Math.max(8, vw - width - 8);
-            const maxY = Math.max(8, vh - height - 8);
+            const maxX = Math.max(EDGE_GAP, vw - width - EDGE_GAP);
+            const maxY = Math.max(minY, vh - height - EDGE_GAP);
             return {
               ...previous,
               width,
               height,
-              x: typeof previous.x === 'number' ? Math.min(previous.x, maxX) : previous.x,
-              y: typeof previous.y === 'number' ? Math.min(previous.y, maxY) : previous.y,
+              x: typeof previous.x === 'number' ? Math.min(Math.max(EDGE_GAP, previous.x), maxX) : previous.x,
+              y: typeof previous.y === 'number' ? Math.min(Math.max(minY, previous.y), maxY) : previous.y,
             };
           });
         };
@@ -2465,8 +2736,9 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
       const totalChars = segments.reduce((sum, segment) => sum + segment.text.length, 0);
       const displayWidth = ui.width;
       const displayHeight = ui.minimized ? HEAD_H : ui.height;
-      const fallbackX = Math.max(8, ((typeof window !== 'undefined' && window.innerWidth) || 1280) - displayWidth - 24);
-      const fallbackY = Math.max(8, ((typeof window !== 'undefined' && window.innerHeight) || 800) - displayHeight - 24);
+      const fallbackX = Math.max(EDGE_GAP, ((typeof window !== 'undefined' && window.innerWidth) || 1280) - displayWidth - 24);
+      const fallbackY = Math.max(hostChromeTop() + EDGE_GAP,
+        ((typeof window !== 'undefined' && window.innerHeight) || 800) - displayHeight - 24);
       const left = typeof ui.x === 'number' ? ui.x : fallbackX;
       const top = typeof ui.y === 'number' ? ui.y : fallbackY;
 
@@ -2622,17 +2894,24 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
           {
             type: 'button',
             className: 'dsh-np-btn',
-            'data-active': optimizeAll !== null ? 'true' : 'false',
-            title: optimizeAll !== null
-              ? t('optimizeAllProgress', { done: optimizeAll.done, total: optimizeAll.total })
-              : t('optimizeAll'),
-            'aria-label': t('optimizeAll'),
-            disabled: activeSegments.length === 0 || optimizeAll !== null,
-            onClick: optimizeAllSegments,
+            'data-active': optimizeBatch !== null || batchUndo !== null ? 'true' : 'false',
+            title: optimizeBatch !== null
+              ? t('optimizeAllProgress', { done: optimizeBatch.done, total: optimizeBatch.total })
+              : batchUndo !== null
+                ? t('undoOptimize')
+                : selectedCount > 0
+                  ? t('optimizeSelected', { n: selectedCount })
+                  : t('optimizeSelectHint'),
+            'aria-label': batchUndo !== null
+              ? t('undoOptimize')
+              : selectedCount > 0 ? t('optimizeSelected', { n: selectedCount }) : t('optimizeSelectHint'),
+            disabled: optimizeBatch !== null
+              || (batchUndo === null && selectedCount === 0),
+            onClick: batchUndo !== null ? undoBatchOptimization : optimizeSelectedSegments,
           },
-          optimizeAll !== null
+          optimizeBatch !== null
             ? h('span', { className: 'dsh-np-mini-spinner' })
-            : h(SparkleIcon, { size: 14 }),
+            : batchUndo !== null ? h(UndoIcon, { size: 14 }) : h(SparkleIcon, { size: 14 }),
         ),
         h(
           'button',
@@ -2720,6 +2999,15 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
       const activeCards = activeSegments.map((segment, index) => {
         const images = Array.isArray(segment.images) ? segment.images : [];
         const empty = segment.text.trim() === '' && images.length === 0;
+        const titleValue = segment.title ?? '';
+        const showTitleInput = titleValue !== '' || titleEditing === segment.id;
+        const undoRecord = segmentUndo.get(segment.id);
+        const canUndoOptimize = undoRecord !== undefined && undoRecord.after === segment.text;
+        const optimizingNow = optimizing.has(segment.id);
+        const aiBusy = optimizingNow || optimizeBatch !== null;
+        const aiTitle = aiBusy
+          ? t('optimizing')
+          : canUndoOptimize ? t('undoOptimize') : t('optimizeSegment');
         return h(
           'article',
           {
@@ -2786,28 +3074,43 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
               },
               String(index + 1).padStart(2, '0'),
             ),
-            h('input', {
-              type: 'text',
-              className: 'dsh-np-title-input',
-              value: segment.title ?? '',
-              placeholder: t('titlePlaceholder'),
-              maxLength: MAX_TITLE_CHARS,
-              'aria-label': t('segmentTitle'),
-              spellCheck: false,
-              onChange: (event) => updateSegmentTitle(segment.id, event.target?.value ?? ''),
-              onKeyDown: (event) => {
-                if (event.key !== 'Enter') return;
-                event.preventDefault();
-                try {
-                  event.currentTarget?.blur?.();
-                } catch {
-                  /* ignore */
-                }
-              },
-              onBlur: () => {
-                if (dirtyRef.current) saveNowRef.current?.();
-              },
-            }),
+            showTitleInput
+              ? h('input', {
+                  type: 'text',
+                  className: 'dsh-np-title-input',
+                  value: titleValue,
+                  placeholder: t('titlePlaceholder'),
+                  maxLength: MAX_TITLE_CHARS,
+                  autoFocus: titleValue === '',
+                  'aria-label': t('segmentTitle'),
+                  spellCheck: false,
+                  onFocus: () => setTitleEditing(segment.id),
+                  onChange: (event) => updateSegmentTitle(segment.id, event.target?.value ?? ''),
+                  onKeyDown: (event) => {
+                    if (event.key !== 'Enter') return;
+                    event.preventDefault();
+                    try {
+                      event.currentTarget?.blur?.();
+                    } catch {
+                      /* ignore */
+                    }
+                  },
+                  onBlur: () => {
+                    if (dirtyRef.current) saveNowRef.current?.();
+                    if ((segment.title ?? '') === '') setTitleEditing('');
+                  },
+                })
+              : h(
+                  'button',
+                  {
+                    type: 'button',
+                    className: 'dsh-np-title-add',
+                    title: t('segmentTitle'),
+                    'aria-label': t('segmentTitle'),
+                    onClick: () => setTitleEditing(segment.id),
+                  },
+                  t('titlePlaceholder'),
+                ),
             h(
               'button',
               {
@@ -2861,14 +3164,16 @@ body[data-ds-dark-theme] .dsh-np-seg[data-archived=true]{opacity:.7}
                 type: 'button',
                 className: 'dsh-np-segbtn',
                 'data-ai': 'true',
-                title: optimizing.has(segment.id) ? t('optimizing') : t('optimizeSegment'),
-                'aria-label': t('optimizeSegment'),
-                disabled: empty || optimizing.has(segment.id) || optimizeAll !== null,
-                onClick: () => optimizeSegment(segment.id),
+                title: aiTitle,
+                'aria-label': aiTitle,
+                disabled: aiBusy || (canUndoOptimize ? false : empty),
+                onClick: canUndoOptimize
+                  ? () => undoOptimizeSegment(segment.id)
+                  : () => optimizeSegment(segment.id),
               },
-              optimizing.has(segment.id)
+              optimizingNow
                 ? h('span', { className: 'dsh-np-mini-spinner' })
-                : h(SparkleIcon, { size: 14 }),
+                : canUndoOptimize ? h(UndoIcon, { size: 14 }) : h(SparkleIcon, { size: 14 }),
             ),
             h(
               'button',

package/index.js

@@ -38,7 +38,7 @@ import {
 const ROUTE = '/dsh-notepad/api';
 
 /** Plugin version mirrored in package.json. */
-const VERSION = '0.4.0';
+const VERSION = '0.5.0';
 
 /** Request body cap for note writes. */
 const BODY_LIMIT = 1024 * 1024;
@@ -55,6 +55,12 @@ const OPTIMIZE_TIMEOUT_MS = 120_000;
 /** Default output cap for one optimized segment. */
 const OPTIMIZE_MAX_TOKENS = 4096;
 
+/** Entries kept in the in-process optimizer cache. */
+const OPTIMIZE_CACHE_LIMIT = 64;
+
+/** Maximum key + value characters kept in the optimizer cache. */
+const OPTIMIZE_CACHE_CHARS = 2_000_000;
+
 /** Shared instruction for the optional writing assistant. */
 const OPTIMIZE_SYSTEM = [
   'You are a writing assistant for a developer notepad.',
@@ -238,6 +244,41 @@ function cleanOptimizedText(value) {
   return text;
 }
 
+/**
+ * Results of earlier optimizer calls. Re-optimizing content that has not
+ * changed returns the previous answer instead of billing another model call.
+ * The cache is per host process and bounded by entry count and characters.
+ * @type {Map<string, string>}
+ */
+const optimizeCache = new Map();
+let optimizeCacheChars = 0;
+
+/**
+ * @param {string} key
+ * @param {string} text
+ */
+function cacheOptimizedText(key, text) {
+  const previous = optimizeCache.get(key);
+  if (previous !== undefined) {
+    optimizeCacheChars -= key.length + previous.length;
+    optimizeCache.delete(key);
+  }
+  optimizeCache.set(key, text);
+  optimizeCacheChars += key.length + text.length;
+  while (optimizeCache.size > OPTIMIZE_CACHE_LIMIT || optimizeCacheChars > OPTIMIZE_CACHE_CHARS) {
+    const oldest = optimizeCache.keys().next();
+    if (oldest.done === true) break;
+    const value = optimizeCache.get(oldest.value) ?? '';
+    optimizeCacheChars -= oldest.value.length + value.length;
+    optimizeCache.delete(oldest.value);
+  }
+}
+
+/** Workspace + title + text: everything the optimizer prompt depends on. */
+function optimizeCacheKey(root, title, text) {
+  return `${root}\u0000${title}\u0000${text}`;
+}
+
 /**
  * Ask the currently selected default model to improve one note segment.
  * The LLM service is optional: a deployment without one reports a stable
@@ -425,8 +466,16 @@ async function dispatchRequest(ctx, req, res) {
         `Segment is too large to optimize (${text.length} characters; limit ${MAX_OPTIMIZE_CHARS}).`,
       );
     }
-    const optimized = await optimizeText(ctx, text, typeof body.title === 'string' ? body.title : '');
-    sendJson(res, { ok: true, root, text: optimized });
+    const title = typeof body.title === 'string' ? body.title : '';
+    const cacheKey = optimizeCacheKey(root, title, text);
+    const cached = optimizeCache.get(cacheKey);
+    if (typeof cached === 'string' && cached !== '') {
+      sendJson(res, { ok: true, root, text: cached, cached: true });
+      return;
+    }
+    const optimized = await optimizeText(ctx, text, title);
+    cacheOptimizedText(cacheKey, optimized);
+    sendJson(res, { ok: true, root, text: optimized, cached: false });
     return;
   }
   if (action !== 'note') {

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Notepad",
-    "description": "A per-workspace floating notepad in the session view. New segment cards lead the list, each card has an editable title; click an index to select, drag to reorder, merge a selection, and improve one or all cards with AI. Paste or pick images as path-based chips; removing a chip cleans up plugin-owned files. Pending counts appear on the hidden launcher and the sidebar workspace row. Insert, replace, or send one or many; sending archives automatically. Archived segments can be shown, hidden, restored, and deleted. Resizable and dark-mode aware."
+    "description": "A per-workspace floating notepad in the session view. New segment cards lead the list; an empty title is just a placeholder until clicked. Click an index to select, drag to reorder, merge a selection, move between cards with the arrow keys, and improve only the selected cards with AI — the button turns into undo and identical content reuses the previous answer. Paste or pick images as path-based chips; removing a chip cleans up plugin-owned files. Pending counts appear on the hidden launcher and the sidebar workspace row. Insert, replace, or send one or many; sending archives automatically. Archived segments can be shown, hidden, restored, and deleted. Auto refresh keeps the list scroll position, Ctrl+Shift+0 resets the panel geometry, the panel never covers the host title bar, and it is resizable and dark-mode aware."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "记事本",
-    "description": "在会话界面显示一个按工作区共享的分段便签浮窗：新分段置顶，标题可编辑，点击序号选中，可拖拽排序、合并多段并用 AI 优化单段或全部；支持粘贴或选择图片并以路径附件形式引入，删除图片芯片会清理插件目录里的文件；隐藏按钮和侧边栏工作区显示未发送数量角标；支持单段/多段插入、替换与发送，发送后自动归档，归档可显示、隐藏、恢复与删除，浮窗可调整尺寸并适配深色模式。"
+    "description": "在会话界面显示一个按工作区共享的分段便签浮窗：新分段置顶，空标题点击后才显示输入框，点击序号选中，可拖拽排序、合并多段、用上下方向键切换分段；AI 优化只作用于选中的分段，优化后按钮变为撤销，相同内容直接复用上次结果；支持粘贴或选择图片并以路径附件形式引入，删除图片芯片会清理插件目录里的文件；隐藏按钮和侧边栏工作区显示未发送数量角标；支持单段/多段插入、替换与发送，发送后自动归档，归档可显示、隐藏、恢复与删除；自动刷新保持滚动位置，浮窗可调整尺寸，Ctrl+Shift+0 复位位置和尺寸，且不会越过窗口标题栏。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@restregular/dsh-notepad",
-  "version": "0.4.0",
-  "description": "Notepad — a per-workspace floating notepad in the DeepSeek Harness session view: newest segment cards first with editable titles, drag to reorder, merge selected segments, AI improve one or all, click an index to select, image chips with automatic file cleanup, pending-count badges on the hidden button and the sidebar workspace, batch insert / replace / send, archive management, resizable panel and dark-mode styling. · 记事本 — 在 DeepSeek Harness 会话界面显示一个按工作区共享的分段便签浮窗：新分段置顶且标题可编辑，可拖拽排序、合并选中分段、AI 优化单段或全部、点击序号选中，图片芯片删除时自动清理磁盘文件，隐藏按钮与侧边栏工作区显示未发送数量角标，支持单段/多段插入、替换与发送，发送自动归档，归档可显示隐藏和恢复删除，可调整尺寸并适配深色模式。",
+  "version": "0.5.0",
+  "description": "Notepad — a per-workspace floating notepad in the DeepSeek Harness session view: newest segment cards first with titles that appear only after a click, drag to reorder, merge selected segments, arrow keys to move between cards, AI improve limited to the selected segments with a one-click undo and cached results, image chips with automatic file cleanup, pending-count badges on the hidden button and the sidebar workspace, batch insert / replace / send, archive management, scroll position kept across automatic refreshes, resizable panel, Ctrl+Shift+0 geometry reset, a title-bar-safe position, and dark-mode styling. · 记事本 — 在 DeepSeek Harness 会话界面显示一个按工作区共享的分段便签浮窗：新分段置顶且空标题只在点击后显示输入框，可拖拽排序、合并选中分段、上下方向键切换分段、只对选中分段做 AI 优化，优化后按钮变为撤销并复用相同内容的缓存结果；图片芯片删除时自动清理磁盘文件；隐藏按钮与侧边栏工作区显示未发送数量角标；支持单段/多段插入、替换与发送，发送自动归档，归档可显示隐藏和恢复删除；自动刷新保持列表滚动位置；可调整尺寸，Ctrl+Shift+0 复位位置和尺寸，浮窗不会越过窗口标题栏，并适配深色模式。",
   "icon": "./icon.svg",
   "type": "module",
   "main": "index.js",