@kangyishuai/dsh-session-rewind 0.5.0 → 0.6.0

package/README.md

@@ -21,6 +21,7 @@ Long conversations drift. A few turns later you wish you had answered a prompt d
 - **Conversation.** The target message and everything after it are withdrawn from the model-visible context and from the transcript. The session id, title and earlier history are untouched. Nothing is deleted from the log — one marker event is appended.
 - **Files (optional).** Files changed by `write` / `edit` / `apply_patch` in the withdrawn turns are restored to their pre-change content. Files created after the target are moved to the plugin's trash instead of deleted. A rescue point of the current files is created before anything is written; failures roll back from it.
 - **Composer.** The target message's text (and images) is put back into the composer, ready to edit and send again. An existing draft is never overwritten. Tick **Send this message again right after rewinding** in the confirmation dialog to retry the turn in one click (conversation-only rewinds).
+- **Prompt recall without rewinding.** In the composer, bare `↑` on an empty draft (or with the caret on the first line) recalls the last prompt you sent in this session — `↑` again walks further back, `↓` walks forward and restores the draft you had before browsing. It only replaces the draft text: nothing is withdrawn from the context, sent or rewritten. Toggle it in **Settings**.
 - **Every view stays in sync.** Rewind in one tab or window and other open views of the same session hide the withdrawn rows immediately, without a reload (the notice travels through `localStorage`; the host's cuts remain the only source of truth).
 - **Rewind panel.** A new header action opens a panel with four tabs: **Withdrawn** (every message each rewind removed, searchable, copy or put back in the composer), **History** (a timeline of each rewind and each rescue-point file restore, newest first: scope, message count, tokens, file results), **Rescue points** (restore files from an earlier rescue), and **Settings** (default scope, page size, confirm-on-list, diagnostics).
 
@@ -35,6 +36,16 @@ The plugin also registers one **read-only** tool, `session_rewind_candidates`, s
 
 The tool never rewinds, never edits files and never appends to the session log — the rewind itself stays a user action (that is the point of the ADR 0006 design). Set `readOnlyTool: false` to unregister it; **Settings → Diagnostics** reports whether it registered.
 
+## What it looks like
+
+![The rewind confirmation dialog: target message, how many messages and tokens will be withdrawn, conversation-only vs conversation-and-files, and the resend option](https://raw.githubusercontent.com/kangyishuai/dsh-plugins/main/packages/session-rewind/assets/session-rewind-confirm.png)
+
+![The rewind panel: withdrawn messages, history timeline, rescue points and settings](https://raw.githubusercontent.com/kangyishuai/dsh-plugins/main/packages/session-rewind/assets/session-rewind-panel.png)
+
+Both screenshots come from a throwaway DSH home containing only a synthetic workspace and session (`pnpm shots:session-rewind` regenerates them), cropped to the dialog and the panel.
+
+> Image links are absolute (`raw.githubusercontent.com`) on purpose: npm does not ship `assets/` in the tarball, so a relative path would render as a broken image on npmjs.com.
+
 ## Install
 
 ```bash
@@ -59,6 +70,8 @@ Re-run `pnpm pack` + `add` after changing the code. The plugin has a host half,
 
 **Commands.** `/rewind` opens the same candidate list. `/rewind @<seq> [chat|both]` executes directly (the preview's seq is shown in the list). `/rewind` is decorated by the client; the bare form never sends text to the model.
 
+**Composer history — `↑` / `↓`.** Focus the composer and press `↑`: the newest prompt you sent in this session fills the draft; `↑` again walks further back, `↓` walks forward, and one more `↓` past the newest entry restores the draft you were typing. It works with an empty draft or when the caret sits on the first line — inside a multi-line draft on a later line the arrows keep moving the caret. Recall never rewinds, never sends and never writes to the session log. History covers the messages still in the model-visible surface (100 newest, older ones dropped) and excludes what an earlier rewind withdrew — those live in the panel's **Withdrawn** tab.
+
 **After a rewind** the target text returns to the composer (images are re-attached best-effort) and the composer is focused. If the composer already held a draft, the draft is kept and a notice says so.
 
 **What is refused**
@@ -102,13 +115,14 @@ On startup the plugin also removes data for sessions that no longer exist (they
 - **The marker is visible to the model** as a short `(empty message)` user message where the withdrawn turns used to be. It is not shown in the transcript.
 - **No network, no telemetry.** Everything is local; file snapshots may contain sensitive content, so treat `<DSH_HOME>/session-rewind/` like your workspace.
 - **Private client seams.** Hiding rows and injecting the ↶ button rely on DSH's internal view/slot registries. They are shape-checked at install and degrade to “context rewound, transcript not hidden” or “button missing” rather than breaking a session.
+- **Recall is a draft edit.** It fills the composer through the host facade, so `Ctrl+Z` steps back through recalls like any other draft change; it never appends to the session or the model context.
 - **POSIX/macOS paths only** in this version; Windows separators and permission bits are not verified.
 
 ## Compatibility
 
-| DSH version | Status                                                                                                 |
-| ----------- | ------------------------------------------------------------------------------------------------------ |
-| 0.2.2-rc.1  | Verified: 185 unit tests + `smoke:session-rewind` 34/34 + desktop 36/36 (`--deep`, file mode included) |
+| DSH version | Status                                                                                                                                                                                                   |
+| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 0.2.2-rc.1  | Verified 2026-11-09: 205 unit tests + web `smoke:session-rewind` 49/49 (temp DSH home) + desktop `smoke:session-rewind-desktop` 23/23 read-only and 30/30 with `--recall` (real Electron renderer, CDP). |
 
 The plugin declares no `engines.dsh` and no `@deepseek-ai/*` peer range: DSH is pre-release and semver ranges over prereleases are unreliable (see [ADR 0005](../../docs/adr/0005-dsh-version-compatibility.md)). Treat the table as the compatibility statement. After a DSH upgrade run `pnpm probe:runtime`, `pnpm smoke:session-rewind`, and check the plugin's diagnostics tab; if a private seam changed, the plugin degrades instead of breaking the session.
 
@@ -118,7 +132,7 @@ The plugin declares no `engines.dsh` and no `@deepseek-ai/*` peer range: DSH is
 pnpm test                     # unit tests (host engine, host RPC, client helpers)
 pnpm verify                   # repo-wide gates
 pnpm smoke:session-rewind           # temp DSH home + real GUI end-to-end (needs dsh & ego-browser)
-pnpm smoke:session-rewind-desktop   # desktop (Electron) check: 21 read-only + 12 with --deep --workspace <dir>
+pnpm smoke:session-rewind-desktop   # desktop (Electron) read-only check (23); --recall adds 5 composer-recall checks, --deep --workspace <dir> adds the file-mode run
 ```
 
 Design notes: [ADR 0006](../../docs/adr/0006-session-rewind-architecture.md) and [ADR 0007](../../docs/adr/0007-session-rewind-file-restore.md) (Chinese; the repository docs are written in Chinese).

package/README.zh-CN.md

@@ -21,6 +21,7 @@
 - **状态变更提示**：如果要撤回的区间里改过会话状态（plan 模式、goal、待办、模型选择、权限/沙箱预设、智能体预设、定时任务、工作目录），确认框会列出来并明确说明——回溯只撤回对话，**不会**回滚这些状态。
 - **运行中也能回退**：确认回退时如果这一轮正在跑，会先取消它（保留队列）、等它空闲，再对新历史重新求值。
 - **输入框**：目标消息文本（以及图片）放回输入框，改完可直接重发；已有草稿绝不覆盖。勾选「回退后立即重发」可一键重试这一轮（仅对话模式）。
+- **不回溯也能召回历史输入**：输入框为空时（或光标在第一行时）按 `↑`，上一条已发送的提示词回到草稿；再按 `↑` 继续往前翻，`↓` 往回走、到底时恢复你浏览前正在写的草稿。它只替换草稿文本，不从上下文撤回、不发送、不改写任何东西。可在**设置**里关闭。
 - **多视图自动同步**：在一个标签页/窗口里回溯后，其它已打开的同会话视图会立刻隐藏被撤回的行，无需刷新（通知走 `localStorage`，渲染只认宿主 cuts）。
 - **回溯面板**：会话头部新增一个入口，四个页签：**已撤回**（每次回溯撤回的全部消息，可搜索、复制、放回输入框）、**回溯记录**（时间线：每次回溯与每次救援点恢复，新在上；范围、条数、token、文件结果）、**救援点**（手动恢复文件）、**设置**（默认范围、每页数量、列表确认、诊断）。
 
@@ -35,6 +36,16 @@
 
 这个工具不回溯、不碰文件、不写会话日志——真正的回退始终由用户在界面确认（这是 ADR 0006 的设计前提）。设 `readOnlyTool: false` 可关闭；**设置 → 诊断**里能看到它是否注册成功。
 
+## 长什么样
+
+![回溯确认框：目标消息、将撤回多少条消息与 token、仅对话 vs 对话+文件、以及重发选项](https://raw.githubusercontent.com/kangyishuai/dsh-plugins/main/packages/session-rewind/assets/session-rewind-confirm.png)
+
+![回溯面板：已撤回、回溯记录、救援点、设置](https://raw.githubusercontent.com/kangyishuai/dsh-plugins/main/packages/session-rewind/assets/session-rewind-panel.png)
+
+两张图都来自一个只含**合成工作区与合成会话**的临时 DSH 目录（`pnpm shots:session-rewind` 可重新生成），并且按 DOM 矩形裁剪到对话框/面板本身。
+
+> 图片用绝对地址（`raw.githubusercontent.com`）而不是相对路径：npm 的 tarball 不含 `assets/`，相对路径在 npmjs.com 上会是破图。
+
 ## 安装
 
 ```bash
@@ -59,6 +70,8 @@ dsh plugin --profile desktop add /tmp/kangyishuai-dsh-session-rewind-*.tgz
 
 **命令。** `/rewind` 打开同一份候选列表；`/rewind @<序号> [chat|both]` 直接执行（序号在列表里可见）。客户端会接管裸 `/rewind`，不会把命令发给模型。
 
+**输入框历史 — `↑` / `↓`。** 把光标放进输入框后按 `↑`：本会话最新一条已发送提示词填进草稿；再按 `↑` 继续往前，`↓` 往回走，越过最新一条后再按一次 `↓` 就恢复你浏览前正在写的草稿。空草稿或光标在第一行时生效；多行草稿里光标在中间行时，方向键仍然只是移动光标。召回不回溯、不发送、不写会话日志。历史覆盖仍在模型可见上下文里的消息（取最新 100 条），已被回溯撤下的消息不在其中——它们在面板的**已撤回**页签里。
+
 **回溯之后**，目标文本回到输入框（图片尽力重新挂回）并获得焦点。如果输入框里本来有草稿，不会被覆盖，并会提示草稿已保留。
 
 **会被拒绝的情况**
@@ -102,13 +115,14 @@ dsh plugin --profile desktop add /tmp/kangyishuai-dsh-session-rewind-*.tgz
 - **marker 对模型可见**：在被撤回回合的位置，模型会看到一条很短的 `(empty message)` user 消息；界面不显示它。
 - **不联网、不上报**；文件快照可能含敏感内容，请把 `<DSH_HOME>/session-rewind/` 当工作区数据对待。
 - **客户端私有 seam**：隐藏行和注入 ↶ 按钮依赖 DSH 内部 view/slot 注册表；安装时做形状检查，失效时降级为「上下文已回溯、界面不隐藏」或「按钮消失」，不破坏会话。
+- **召回只是改草稿**：它通过宿主输入框 facade 整篇替换草稿，所以 `Ctrl+Z` 会像普通编辑一样一步步退回；它不会向会话或模型上下文追加任何东西。
 - **本版只验证 POSIX/macOS 路径**；Windows 分隔符与权限位未验证。
 
 ## 兼容性
 
-| DSH 版本   | 状态                                                                                     |
-| ---------- | ---------------------------------------------------------------------------------------- |
-| 0.2.2-rc.1 | 已验证：185 个单测 + `smoke:session-rewind` 34/34 + 桌面版 36/36（`--deep`，含文件模式） |
+| DSH 版本   | 状态                                                                                                                                                                                       |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 0.2.2-rc.1 | 2026-11-09 已验证：205 个单测 + Web `smoke:session-rewind` 49/49（临时 DSH home）+ 桌面 `smoke:session-rewind-desktop` 只读 23/23、加 `--recall` 30/30（真实 Electron 渲染进程，走 CDP）。 |
 
 插件不声明 `engines.dsh`，也不声明 `@deepseek-ai/*` 的 peer 范围：DSH 还在预发布阶段，预发布版本的 semver 范围不可靠（见 [ADR 0005](../../docs/adr/0005-dsh-version-compatibility.md)）。以这张表为准。DSH 升级后跑 `pnpm probe:runtime`、`pnpm smoke:session-rewind`，并看插件诊断页签；私有 seam 变了会降级而不是让会话出错。
 
@@ -118,7 +132,7 @@ dsh plugin --profile desktop add /tmp/kangyishuai-dsh-session-rewind-*.tgz
 pnpm test                     # 单测（宿主文件引擎、宿主 RPC、客户端 helper）
 pnpm verify                   # 仓库统一门禁
 pnpm smoke:session-rewind           # 临时 DSH 目录 + 真实 GUI 端到端（需要 dsh 与 ego-browser）
-pnpm smoke:session-rewind-desktop   # 桌面（Electron）回归：只读 21 项，加 --deep --workspace <dir> 再 +12 项
+pnpm smoke:session-rewind-desktop   # 桌面（Electron）只读回归（23 项）；--recall 再加 5 条召回断言，--deep --workspace <dir> 再跑文件模式
 ```
 
 设计记录：[ADR 0006](../../docs/adr/0006-session-rewind-architecture.md)、[ADR 0007](../../docs/adr/0007-session-rewind-file-restore.md)。

package/lib/client.js

@@ -147,6 +147,9 @@ window.__ModuleLoader__.load({
       "settings.pageSize": "候选每页数量",
       "settings.confirmOnList": "从候选列表选择时先确认",
       "settings.confirmOnListHint": "关闭后，默认「仅回退对话」时会直接执行；文件模式始终先确认。",
+      "settings.recall": "输入框 ↑/↓ 召回历史输入",
+      "settings.recallHint":
+        "空草稿（或光标在第一行）按 ↑ 召回上一条已发送消息，↓ 前进、到底恢复你原来的草稿；只填草稿，不回溯、不发送。",
       "settings.saved": "已保存",
       "settings.healthTitle": "诊断",
       "settings.healthRefresh": "刷新",
@@ -295,6 +298,9 @@ window.__ModuleLoader__.load({
       "settings.confirmOnList": "Confirm before executing from the list",
       "settings.confirmOnListHint":
         "When off, the default conversation-only mode runs directly; file mode always asks first.",
+      "settings.recall": "↑/↓ recalls earlier prompts in the composer",
+      "settings.recallHint":
+        "In an empty draft (or with the caret on the first line) ↑ recalls the last prompt you sent, ↓ walks forward and restores your own draft at the bottom; it only fills the draft — never rewinds, never sends.",
       "settings.saved": "Saved",
       "settings.healthTitle": "Diagnostics",
       "settings.healthRefresh": "Refresh",
@@ -606,6 +612,7 @@ window.__ModuleLoader__.load({
       defaultMode: "chat",
       pageSize: 100,
       confirmOnList: true,
+      recallEnabled: true,
     });
 
     /** 候选每页数量的合法范围。 */
@@ -642,7 +649,7 @@ window.__ModuleLoader__.load({
     /**
      * 规整客户端偏好（localStorage 里可能是旧版本、脏数据或非对象）。
      * @param {any} raw
-     * @returns {{ defaultMode: "chat" | "both", pageSize: number, confirmOnList: boolean }}
+     * @returns {{ defaultMode: "chat" | "both", pageSize: number, confirmOnList: boolean, recallEnabled: boolean }}
      */
     function sanitizePrefs(raw) {
       let source = raw && typeof raw === "object" ? raw : {};
@@ -650,6 +657,155 @@ window.__ModuleLoader__.load({
         defaultMode: source.defaultMode === "both" ? "both" : "chat",
         pageSize: clampInt(source.pageSize, PAGE_SIZE_MIN, PAGE_SIZE_MAX, PREF_DEFAULTS.pageSize),
         confirmOnList: source.confirmOnList !== false,
+        recallEnabled: source.recallEnabled !== false,
+      };
+    }
+
+    // ------------------------------------------------------------------
+    // 输入历史召回（非破坏性）：纯数据部分
+    // ------------------------------------------------------------------
+
+    /** 召回历史条目上限（更旧的先丢）。 */
+    let RECALL_LIMIT = 100;
+
+    /**
+     * 历史缓存的保鲜期（ms）。宿主 RPC 是本地调用，成本很低；用「先给旧的、后台刷新」
+     * 而不是每次按键都等一次往返。
+     */
+    let RECALL_TTL_MS = 1500;
+
+    /** 判定首/末行时允许的误差（行高比例）：行内任意位置都算该行。 */
+    let CARET_LINE_RATIO = 0.6;
+
+    /**
+     * 把宿主 `sessionRewind/candidates` 的一页（新→旧）转成召回历史（旧→新）。
+     * host 已经过滤掉非真人消息、已被 compaction 遮蔽的消息，这里只补两件事：
+     * 丢掉空文本、截到 RECALL_LIMIT。
+     * @param {any} candidates
+     * @returns {Array<{seq: number, text: string}>}
+     */
+    function historyFromCandidates(candidates) {
+      let source = Array.isArray(candidates) ? candidates : [];
+      /** @type {Array<{seq: number, text: string}>} */
+      let out = [];
+      for (let i = 0; i < source.length; i += 1) {
+        let item = source[i];
+        if (!item || typeof item.seq !== "number") continue;
+        let text = typeof item.text === "string" ? item.text : "";
+        if (text.trim() === "") continue;
+        out.push({ seq: item.seq, text: text });
+      }
+      /* host 给的是新→旧；召回要按时间升序（末尾最新） */
+      out.reverse();
+      return out.slice(-RECALL_LIMIT);
+    }
+
+    /**
+     * 是否是召回手势：裸 ↑/↓、无组合键、非输入法组合、尚未被别的监听者消费。
+     * 宿主在 fixed input 通道里已经算好 composing/defaultPrevented，这里只做判定。
+     * @param {any} gesture
+     * @returns {boolean}
+     */
+    function isRecallGesture(gesture) {
+      if (!gesture || typeof gesture !== "object") return false;
+      if (gesture.code !== "ArrowUp" && gesture.code !== "ArrowDown") return false;
+      if (gesture.control || gesture.alt || gesture.shift || gesture.meta) return false;
+      if (gesture.composing) return false;
+      if (gesture.defaultPrevented) return false;
+      return true;
+    }
+
+    /**
+     * 浏览一步（纯函数）：
+     * - `index === -1` 表示停在「正在编辑的那一行」；
+     * - `saved` 是开始浏览前用户自己的草稿，一路 ↓ 到底时原样还回去；
+     * - `restore !== null` 表示这一步要写回的文本（live line），否则按 index 取历史。
+     * @param {{index: number, saved: string}} state
+     * @param {"ArrowUp" | "ArrowDown"} code
+     * @param {number} total 历史条数
+     * @param {string} draft 当前草稿
+     * @returns {{index: number, saved: string, restore: string | null}}
+     */
+    function recallStep(state, code, total, draft) {
+      let index = state ? state.index : -1;
+      let saved = state ? state.saved : "";
+      if (total <= 0) return { index: -1, saved: "", restore: null };
+      if (code === "ArrowUp") {
+        if (index < 0) return { index: total - 1, saved: draft || "", restore: null };
+        return { index: Math.max(0, index - 1), saved: saved, restore: null };
+      }
+      if (index < 0) return { index: -1, saved: "", restore: null };
+      let next = index + 1;
+      if (next >= total) return { index: -1, saved: "", restore: saved };
+      return { index: next, saved: saved, restore: null };
+    }
+
+    /**
+     * 光标是否贴着输入框的首行 / 末行（只看矩形，便于单测）。
+     *
+     * 返回两个独立的布尔值而不是一个枚举：单行草稿的「首行」就是「末行」，
+     * 用枚举会丢掉其中一个（↑ 能用、↓ 反而被挡住的经典 bug）。
+     * @param {any} rect 光标的 getBoundingClientRect()
+     * @param {any} box 输入框的 getBoundingClientRect()
+     * @param {number} lineHeight 行高（px）
+     * @returns {{first: boolean, last: boolean}}
+     */
+    function caretEdges(rect, box, lineHeight) {
+      let none = { first: false, last: false };
+      if (!rect || !box) return none;
+      if (
+        typeof rect.top !== "number" ||
+        typeof rect.bottom !== "number" ||
+        typeof box.top !== "number" ||
+        typeof box.bottom !== "number"
+      )
+        return none;
+      let line = typeof lineHeight === "number" && lineHeight > 0 ? lineHeight : 20;
+      let tolerance = line * CARET_LINE_RATIO;
+      return {
+        first: rect.top - box.top <= tolerance,
+        last: box.bottom - rect.bottom <= tolerance,
+      };
+    }
+
+    /**
+     * 每会话的召回历史缓存：`peek` 拿旧值（立刻可用），`fresh` 判断要不要后台刷新。
+     * 宿主会话日志是唯一事实来源，这里只缓存它的投影。
+     * @param {() => number} [now] 可注入的时钟，便于单测
+     */
+    function createRecallCache(now) {
+      let clock = typeof now === "function" ? now : Date.now;
+      /** @type {Map<string, {items: Array<{seq: number, text: string}>, at: number}>} */
+      let entries = new Map();
+
+      /** @param {any} sessionId */
+      function keyOf(sessionId) {
+        return typeof sessionId === "string" ? sessionId : "";
+      }
+
+      return {
+        /** 最近一次读到的历史（可能已过期；没有时 undefined）。 */
+        peek(/** @type {any} */ sessionId) {
+          let entry = entries.get(keyOf(sessionId));
+          return entry ? entry.items : undefined;
+        },
+        /** 是否还在保鲜期内。 */
+        fresh(/** @type {any} */ sessionId) {
+          let entry = entries.get(keyOf(sessionId));
+          if (!entry) return false;
+          return clock() - entry.at < RECALL_TTL_MS;
+        },
+        /** 写入一页历史。 */
+        set(/** @type {any} */ sessionId, /** @type {any} */ items) {
+          entries.set(keyOf(sessionId), {
+            items: Array.isArray(items) ? items : [],
+            at: clock(),
+          });
+        },
+        /** 回溯/切换后丢弃缓存，下一次按键重新拉。 */
+        forget(/** @type {any} */ sessionId) {
+          entries.delete(keyOf(sessionId));
+        },
       };
     }
 
@@ -2708,6 +2864,24 @@ window.__ModuleLoader__.load({
         h("div", { className: "dsh-srw-option-hint" }, t("settings.confirmOnListHint")),
       );
 
+      let recallRow = h(
+        "div",
+        { className: "dsh-srw-setting" },
+        h(
+          "label",
+          { className: "dsh-srw-check" },
+          h("input", {
+            type: "checkbox",
+            checked: prefs.recallEnabled !== false,
+            onChange: (/** @type {any} */ event) => {
+              if (event?.target) api.updatePrefs({ recallEnabled: event.target.checked === true });
+            },
+          }),
+          h("span", null, t("settings.recall")),
+        ),
+        h("div", { className: "dsh-srw-option-hint" }, t("settings.recallHint")),
+      );
+
       let healthBlock;
       if (health.loading) {
         healthBlock = h("div", { className: "dsh-srw-dim" }, t("settings.healthLoading"));
@@ -2787,6 +2961,7 @@ window.__ModuleLoader__.load({
         ),
         pageRow,
         confirmRow,
+        recallRow,
         data.saved === true
           ? h("div", { className: "dsh-srw-dim dsh-srw-saved" }, t("settings.saved"))
           : null,
@@ -3174,6 +3349,9 @@ window.__ModuleLoader__.load({
 
       let cutStore = createCutStore();
 
+      /** 输入框召回历史缓存（来源是宿主 sessionRewind/candidates）。 */
+      let recallCache = createRecallCache();
+
       /** 读客户端偏好（localStorage 缺失/脏数据都退回默认值）。 */
       function readPrefs() {
         try {
@@ -3397,8 +3575,13 @@ window.__ModuleLoader__.load({
         }
       }
 
-      function fillComposer(/** @type {any} */ sessionId, /** @type {any} */ text) {
-        let facade;
+      /**
+       * 某会话输入框的 façade（`conversation.input.for(scope)`）。
+       * 拿不到时返回 undefined —— 调用方自己决定退化路径。
+       * @param {any} sessionId
+       * @returns {any}
+       */
+      function composerFacadeOf(/** @type {any} */ sessionId) {
         try {
           let conversation = safeGet(ctx, "conversation");
           let scope =
@@ -3410,11 +3593,281 @@ window.__ModuleLoader__.load({
             typeof conversation.input.for === "function" &&
             scope !== undefined
           ) {
-            facade = conversation.input.for(scope);
+            return conversation.input.for(scope);
+          }
+        } catch (_error) {
+          /* 退化到 DOM 通道 */
+        }
+        return undefined;
+      }
+
+      /**
+       * 把整段文本写进输入框草稿（召回用：允许覆盖当前草稿，与 fillComposer 的区别就在这里）。
+       * 优先走宿主 façade 的 `setDraft`；退化路径与 fillComposer 的 DOM 兜底一致。
+       * @param {any} sessionId
+       * @param {any} text
+       * @returns {"ok" | "none"}
+       */
+      function writeComposerDraft(/** @type {any} */ sessionId, /** @type {any} */ text) {
+        let value = typeof text === "string" ? text : "";
+        let facade = composerFacadeOf(sessionId);
+        if (facade && typeof facade.setDraft === "function") {
+          try {
+            facade.setDraft(value);
+            return "ok";
+          } catch (_error) {
+            /* 退化到 DOM 通道 */
+          }
+        }
+        let el = null;
+        try {
+          el = document.querySelector("[data-composer-input]");
+        } catch (_error) {
+          el = null;
+        }
+        if (!el || !(el instanceof HTMLElement)) return "none";
+        try {
+          el.focus();
+          let selection =
+            typeof document.getSelection === "function" ? document.getSelection() : null;
+          if (selection) {
+            let range = document.createRange();
+            range.selectNodeContents(el);
+            selection.removeAllRanges();
+            selection.addRange(range);
+          }
+          let ok = false;
+          try {
+            ok = document.execCommand("insertText", false, value);
+          } catch (_error) {
+            ok = false;
+          }
+          if (!ok) {
+            el.textContent = value;
+            el.dispatchEvent(new Event("input", { bubbles: true }));
+            ok = true;
+          }
+          return ok ? "ok" : "none";
+        } catch (_error) {
+          return "none";
+        }
+      }
+
+      /**
+       * 光标是否贴着输入框首/末行（浏览器侧封装；纯判定交给 caretEdges）。
+       * @param {any} el contenteditable 输入框
+       * @returns {{first: boolean, last: boolean}}
+       */
+      function caretEdgesOf(/** @type {any} */ el) {
+        try {
+          let selection =
+            typeof document.getSelection === "function" ? document.getSelection() : null;
+          if (!selection || selection.rangeCount === 0 || selection.isCollapsed !== true)
+            return { first: false, last: false };
+          let range = selection.getRangeAt(0).cloneRange();
+          range.collapse(true);
+          let rect = range.getBoundingClientRect();
+          if (
+            !rect ||
+            (rect.top === 0 && rect.bottom === 0 && rect.width === 0 && rect.height === 0)
+          ) {
+            let rects = range.getClientRects();
+            if (rects && rects.length > 0) rect = rects[0];
           }
+          let box = el.getBoundingClientRect();
+          let style =
+            typeof window.getComputedStyle === "function" ? window.getComputedStyle(el) : null;
+          let lineHeight = style ? parseFloat(style.lineHeight) : NaN;
+          if (!Number.isFinite(lineHeight) || lineHeight <= 0)
+            lineHeight = rect && rect.height > 0 ? rect.height : 20;
+          return caretEdges(rect, box, lineHeight);
         } catch (_error) {
-          facade = undefined;
+          return { first: false, last: false };
+        }
+      }
+
+      /**
+       * 读输入框草稿与提交阶段：优先宿主 façade，拿不到时退回 DOM 文本。
+       * @param {any} sessionId
+       * @param {any} target 焦点里的 contenteditable
+       * @returns {{draft: string, phase: string}}
+       */
+      function readComposer(/** @type {any} */ sessionId, /** @type {any} */ target) {
+        let facade = composerFacadeOf(sessionId);
+        let snapshot = facade ? facade.snapshot : undefined;
+        if (snapshot) {
+          return {
+            draft: typeof snapshot.draft === "string" ? snapshot.draft : "",
+            phase: typeof snapshot.phase === "string" ? snapshot.phase : "plain",
+          };
+        }
+        return {
+          draft: typeof target?.textContent === "string" ? target.textContent : "",
+          phase: "plain",
+        };
+      }
+
+      /**
+       * 输入框历史召回（↑/↓）：只替换草稿，绝不回溯、绝不发送。
+       *
+       * 历史来自本插件自己的宿主 RPC `sessionRewind/candidates`（真人消息、surface 感知、
+       * 完整文本），按会话缓存；键处理走宿主的 fixed input 通道
+       * （`shortcuts.observeFixedInput`）——裸 ↑/↓ 已被宿主固定动作 `move` 占用，
+       * 注册快捷键会冲突，而观察通道连输入法组合与「是否已被消费」都替我们算好了。
+       * @param {any} scope 拿到 shortcuts 的作用域
+       * @param {any} cache createRecallCache() 的实例
+       */
+      function installComposerRecall(/** @type {any} */ scope, /** @type {any} */ cache) {
+        let shortcuts = scope?.shortcuts;
+        if (!shortcuts || typeof shortcuts.observeFixedInput !== "function") return;
+        /**
+         * 每会话的浏览状态。`written` 记录我们最后写进草稿的文本：
+         * façade 的快照可能晚一拍，用它区分「快照还没跟上」和「用户真的改了」。
+         * @type {Map<string, {index: number, saved: string, written: string}>}
+         */
+        let states = new Map();
+        /** @type {Map<string, Promise<any>>} 并发合并：同一会话只发一次 RPC。 */
+        let inflight = new Map();
+
+        /** @param {any} sessionId */
+        function stateOf(sessionId) {
+          let found = states.get(sessionId);
+          if (!found) {
+            found = { index: -1, saved: "", written: "" };
+            states.set(sessionId, found);
+          }
+          return found;
+        }
+
+        /**
+         * 拉一页历史写进缓存。
+         * @param {any} sessionId
+         * @returns {Promise<Array<{seq: number, text: string}>>}
+         */
+        function loadHistory(sessionId) {
+          let running = inflight.get(sessionId);
+          if (running) return running;
+          let promise = call("candidates", { sessionId: sessionId, limit: RECALL_LIMIT })
+            .then((value) => historyFromCandidates(normalizeCandidatePage(value).candidates))
+            .catch(() => [])
+            .then((items) => {
+              inflight.delete(sessionId);
+              cache.set(sessionId, items);
+              return items;
+            });
+          inflight.set(sessionId, promise);
+          return promise;
+        }
+
+        /**
+         * 走一步浏览：算新状态、必要时写草稿。
+         * @param {any} sessionId
+         * @param {"ArrowUp" | "ArrowDown"} code
+         * @param {string} draft
+         * @param {Array<{seq: number, text: string}>} items
+         * @param {any} input fixed-input 输入（异步补填时传空对象，没有 consume）
+         * @returns {void}
+         */
+        function stepOnce(sessionId, code, draft, items, input) {
+          let state = stateOf(sessionId);
+          if (state.index >= 0) {
+            let current = items[state.index];
+            /* 用户自己改过草稿（既不是我们填的那条，也不是刚写进去的那条）→ 退出浏览 */
+            if (!current || (current.text !== draft && state.written !== draft)) {
+              state.index = -1;
+              state.saved = "";
+              state.written = "";
+              return;
+            }
+          }
+          let step = recallStep(state, code, items.length, draft);
+          state.index = step.index;
+          state.saved = step.saved;
+          let value =
+            step.restore !== null
+              ? step.restore
+              : step.index >= 0 && items[step.index]
+                ? items[step.index].text
+                : null;
+          if (typeof input?.consume === "function") input.consume();
+          if (value === null) return;
+          if (writeComposerDraft(sessionId, value) !== "ok") {
+            showToastKey("toast.refillNoComposer");
+            return;
+          }
+          state.written = value;
         }
+
+        /** @param {any} input */
+        function onFixedInput(input) {
+          try {
+            if (!prefs.recallEnabled) return;
+            if (input?.type !== "keydown") return;
+            if (!isRecallGesture(input.gesture)) return;
+            let context = input.context || {};
+            if (context.modal !== null && context.modal !== undefined) return;
+            if (context.region !== "editable") return;
+            let target = context.target;
+            if (target?.isContentEditable !== true) return;
+            let occurrence = target.closest ? target.closest("[data-conversation-session]") : null;
+            if (!occurrence) return;
+            let sessionId = occurrence.getAttribute("data-conversation-session");
+            if (!sessionId || isInert(sessionId)) return;
+
+            let code = input.gesture.code;
+            let composer = readComposer(sessionId, target);
+            if (composer.phase !== "plain") return;
+            let draft = composer.draft;
+            let browsing = stateOf(sessionId).index >= 0;
+
+            if (!browsing) {
+              if (code === "ArrowDown") return;
+              /* 有草稿时只有光标贴着首行才接管 ↑，否则方向键交给编辑器 */
+              if (draft.trim() !== "" && !caretEdgesOf(target).first) return;
+            } else if (code === "ArrowDown" && !caretEdgesOf(target).last) {
+              return;
+            }
+
+            /* 浏览中：列表必须保持稳定（否则下标会指向别的消息），只有浏览开始时才重拉。 */
+            if (browsing) {
+              let browsingItems = cache.peek(sessionId);
+              if (browsingItems === undefined || browsingItems.length === 0) return;
+              stepOnce(sessionId, code, draft, browsingItems, input);
+              return;
+            }
+
+            /* 开始浏览：缓存还新鲜就直接用，否则先拉一份最新的（本地 RPC，毫秒级），
+             * 这样「刚发出去的那条」一定在历史里。 */
+            let items = cache.peek(sessionId);
+            if (items !== undefined && cache.fresh(sessionId)) {
+              stepOnce(sessionId, code, draft, items, input);
+              return;
+            }
+
+            /* 冷启动或过期：先把方向键吃掉（避免光标乱跳），拿到历史再填草稿 */
+            if (typeof input.consume === "function") input.consume();
+            loadHistory(sessionId)
+              .then((loaded) => {
+                if (loaded.length === 0) return;
+                let again = readComposer(sessionId, target);
+                if (again.phase !== "plain" || again.draft !== draft) return;
+                if (stateOf(sessionId).index >= 0) return;
+                stepOnce(sessionId, "ArrowUp", draft, loaded, null);
+              })
+              .catch(() => {});
+          } catch (_error) {
+            /* 召回是锦上添花：任何异常都不影响输入框本身 */
+          }
+        }
+
+        scope.effect(
+          () => shortcuts.observeFixedInput(onFixedInput),
+          "session-rewind: composer recall",
+        );
+      }
+
+      function fillComposer(/** @type {any} */ sessionId, /** @type {any} */ text) {
+        let facade = composerFacadeOf(sessionId);
         if (facade) {
           let draft = "";
           try {
@@ -3796,6 +4249,8 @@ window.__ModuleLoader__.load({
           markerSeq: summary.markerSeq === null ? target.seq : summary.markerSeq,
         });
         rebuildSessionById(sessionId);
+        /* 召回历史也要跟着收缩：被这次回溯撤下的消息不能再被 ↑ 翻出来 */
+        recallCache.forget(sessionId);
         let outcome = fillComposer(sessionId, summary.text || target.text || "");
         // 同源其它视图也要立刻隐藏这些行（它们不会被这次 append 唤醒）。
         broadcastCut(sessionId, summary);
@@ -4476,6 +4931,9 @@ window.__ModuleLoader__.load({
               }),
             "session-rewind: esc esc",
           );
+
+          // 输入框 ↑/↓ 历史召回（非破坏性）：同一通道的第二个观察者。
+          installComposerRecall(scope, recallCache);
         });
       } catch (_error) {
         /* shortcuts 缺失时降级：无 Esc Esc 入口 */
@@ -4645,6 +5103,15 @@ window.__ModuleLoader__.load({
         rewindSummaryOf: rewindSummaryOf,
         normalizeTab: normalizeTab,
         modeLabelKey: modeLabelKey,
+        // v3：输入历史召回（非破坏性）
+        RECALL_LIMIT: RECALL_LIMIT,
+        CARET_LINE_RATIO: CARET_LINE_RATIO,
+        historyFromCandidates: historyFromCandidates,
+        isRecallGesture: isRecallGesture,
+        recallStep: recallStep,
+        caretEdges: caretEdges,
+        createRecallCache: createRecallCache,
+        RECALL_TTL_MS: RECALL_TTL_MS,
         dictionaries: Object.freeze({ zh: zh, en: en }),
       }),
     });

package/locale/en.json

@@ -89,6 +89,8 @@
     "settings.pageSize": "Candidates per page",
     "settings.confirmOnList": "Confirm before executing from the list",
     "settings.confirmOnListHint": "When off, the default conversation-only mode runs directly; file mode always asks first.",
+    "settings.recall": "↑/↓ recalls earlier prompts in the composer",
+    "settings.recallHint": "In an empty draft (or with the caret on the first line) ↑ recalls the last prompt you sent, ↓ walks forward and restores your own draft at the bottom; it only fills the draft — never rewinds, never sends.",
     "settings.saved": "Saved",
     "settings.healthTitle": "Diagnostics",
     "settings.healthRefresh": "Refresh",

package/locale/zh.json

@@ -89,6 +89,8 @@
     "settings.pageSize": "候选每页数量",
     "settings.confirmOnList": "从候选列表选择时先确认",
     "settings.confirmOnListHint": "关闭后，默认「仅回退对话」时会直接执行；文件模式始终先确认。",
+    "settings.recall": "输入框 ↑/↓ 召回历史输入",
+    "settings.recallHint": "空草稿（或光标在第一行）按 ↑ 召回上一条已发送消息，↓ 前进、到底恢复你原来的草稿；只填草稿，不回溯、不发送。",
     "settings.saved": "已保存",
     "settings.healthTitle": "诊断",
     "settings.healthRefresh": "刷新",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kangyishuai/dsh-session-rewind",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "In-place conversation rewind for DSH: withdraw a user message and everything after it, then refill the composer",
   "keywords": [
     "dsh",