@huanlin/dsh-plugin-input-history 0.1.2 → 0.2.0

package/README.md

@@ -12,69 +12,69 @@
 
 ## 功能
 
-- **↑ / ↓ 切换历史**：在 DSH prompt 输入框（聊天页底部那个 textarea）按方向键，从最近一条 prompt 开始向旧回溯，或向新前进。
+- **↑ / ↓ 切换历史**：在 DSH prompt 输入框（聊天页底部的 Lexical 编辑器）按方向键，从最近一条 prompt 开始向旧回溯，或向新前进。
 - **草稿保留**：切到历史预览后，按 ↓ 越过最新条目会自动恢复用户原本正在编辑的草稿——不会丢失在途文本。
 - **跨会话全局持久化**：历史来自所有会话的 `user` + `steering` 消息，存到 `localStorage`（FIFO，500 条上限），刷新浏览器、新建会话、切换 workspace 都保留。
 - **多行边界触发**：ArrowUp 仅在光标位于第一行任意位置时触发；ArrowDown 仅在最后一行任意位置时触发。多行编辑时方向键仍正常移动光标，不会被劫持。
 - **IME 安全**：中文/日文输入法候选词状态按方向键不会被劫持（遵循 DSH core InputBar 的 IME 守卫约定，issue #535）。
-- **斜杠菜单兼容**：斜杠命令菜单打开时，方向键归菜单高亮导航使用，插件不动。
-- **零源码 patch**：纯插件，通过 `conversation.composer.dock` 隐藏条目挂载 `document` 级 `keydown` 监听器。不修改 DSH 源码任何文件。
+- **斜杠菜单兼容**：斜杠命令 / @ 引用菜单打开时，方向键归菜单高亮导航使用，插件不动。
+- **零源码 patch**：纯插件，通过 `conversation.composer.dock` 隐藏条目挂载捕获阶段 `keydown` 监听器。不修改 DSH 源码任何文件。
 
 ## 架构
 
-单 bundle 双入口（host `.` + 浏览器 `./client` + invariant `./invariant`），仿照 `dsh-spur` / `dsh-auto-blame`。
+单 bundle 双入口（host `.` + 浏览器 `./client`），仿照 `dsh-spur` / `dsh-auto-blame`。不发布 `./invariant` 伴生入口（rc.1 起上游禁止空 invariant installer：本插件的 slot 注册由 HMR 安全 spec 覆盖、localStorage 写入有 try/catch 包裹，均无独立可分歧的观察，故按新规省略其源码与装配）。
 
 - **宿主半边**（`src/index.ts`）：空 `apply`——纯客户端插件。
-- **浏览器半边**（`src/client/index.ts`）：
-  - 注册 `conversation.composer.dock` list slot（id `dsh-plugin-input-history`，order 100）。dock 条目渲染一个 `display: none` 的不可见 anchor，仅负责**历史收集**（每次 render 读 `session.nodes`，新 user/steering 文本 append 到 store）。
-  - 在 `apply` 里直接挂 `document.addEventListener('keydown', ...)` bubble-phase 监听器，负责**历史导航**。监听器放在 `apply` 而非 dock 组件里，因为 dock 是 session scope，而 DSH 把 blank session 当作 hero 渲染（`ConversationRoot.tsx:79-80`），hero 模式下 dock 不挂载（`ConversationRoot.tsx:156` 的 `!hero` 守卫）。放在 `apply` 确保健听器始终在线。
+- **浏览器半边**（`src/client/index.ts`）：注册 `conversation.composer.dock` list slot（id `dsh-plugin-input-history`，order 100，与 ui-chat 的 StatsLine 同槽共存）。dock 条目渲染一个 `display: none` 的不可见 anchor，**历史收集**与**历史导航**都由这个 session 作用域的 dock 组件承担——两者都需要只有 session 作用域 slot 组件才能拿到的机器接口（`useChat` / `inputActions`）。
 - **纯函数模块**：
   - `src/client/history.ts`：`appendHistory` / `nextIndex` / `entryAt` / `HistoryStore`（localStorage 后端，quota 异常降级为内存）
-  - `src/client/dom.ts`：`cursorLineInfo`（多行边界判断）/ `findComposerTextarea`（DOM 查询）
+  - `src/client/dom.ts`：`findComposerEditable` / `findTriggerMenu`（data-attribute 定位器）/ `caretLineBoundary`（光标-行盒几何）/ `boundaryFromLineTops`（纯判定核心）
   - `src/client/ime.ts`：`isImeComposition`（IME 守卫）
 
-### 历史回填机制：native setter + dispatch input event
+### 历史回填机制：`inputActions.setDraft`
 
-监听器不通过 `inputActions.setDraft`（那是 per-session 的，通过 slot provide 注入，hero/blank 模式下 dock 不挂载时拿不到）。而是用 native prototype setter 改 textarea.value + dispatch `input` event，触发 InputBar 的 `onChange` → `keyboard.setDraft`——与用户手动输入走同一路径。这是浏览器自动化库（Playwright / Testing Library）模拟用户输入的标准手法。
+v0.1.2 起 composer 是 Lexical contenteditable，没有 textarea 可以用 native setter 驱动。插件改走 slot 系统注入的 `inputActions.setDraft(text)`——这是 input machine 的公开整草稿写入口（Lexical update、光标落到末尾、undo 合并）。注意：含引用 chip 的草稿恢复时按 clipboard 投影文本还原（chip 变回 `/name` 形式）。
 
 ### Slot 选择
 
-`conversation.composer.dock`（list，session 作用域）——编辑器卡片下方的条带，由 `ui-conversation` 拥有。dock 条目从框架接收 `InputZone`（owner：`session: ConversationSnapshot`）+ `SessionStandardProps`。dock 只负责历史收集；导航监听器在 `apply` 里，不依赖 dock 挂载。
+`conversation.composer.dock`（list，session 作用域）——composer 卡片下方的条带，由 `ui-conversation` 拥有。**rc.1 起该 slot 不再有 `InputZone` owner props**（`input` 不随 props 下发），dock 条目从框架接收 `SessionStandardProps`（`sessionId` / `useInput` / `inputActions`，以及 ui-chat merge 进来的 `useChat`），`input` 改经 `useInput(s => s)` 读取。DSH 把 blank session 当作 hero 渲染时该 dock 不挂载，插件随之休眠——hero 模式本就没有 input machine，导航无处落地（见已知限制）。
 
 ### 历史收集
 
-每次 render 读 `props.session.nodes`（point-in-time 快照），从尾向前找到第一个 `kind === 'user'` 或 `kind === 'steering'` 节点，提取其 `content` 中所有 `type === 'text'` 块的文本拼接。与上次看到的文本比较，不同则 `append` 到 `HistoryStore`。store 内部做去重（最新相等 no-op、旧出现移到末尾）和 FIFO 截断。
+dock 通过 `useChat(s => s.legacy.nodes)` 订阅 Chat target 的节点列表（`ConversationNode` 平铺数组，新在后），从尾向前找到第一个 `kind === 'user'` 或 `kind === 'steering'` 节点，提取其 `content` 中所有 `type === 'text'` 块的文本拼接。文本变化时 append 到 `HistoryStore`。store 内部做去重（最新相等 no-op、旧出现移到末尾）和 FIFO 截断，重复 append 无副作用。
 
 ### 键盘事件处理链
 
-`document.addEventListener('keydown', handler, false)`（bubble 阶段，在 React 委托的 root handler 之后触发），监听器挂在 `apply` 里（非 dock 组件）：
+`document.addEventListener('keydown', handler, true)`（**捕获阶段**，在 Lexical 挂在 editable 元素上的 keydown 监听器之前触发），监听器由 dock 组件挂载/卸载：
 
 1. **键过滤**：只处理 `ArrowUp` / `ArrowDown`。
 2. **IME 守卫**：`event.isComposing || event.keyCode === 229` → 放行。
-3. **斜杠菜单兼容**：`event.defaultPrevented` → 放行（InputBar 已消费，菜单打开中方向键移动高亮）。
-4. **textarea 定位**：从 `event.target` 向上找 `[data-composer-card]` 祖先，找其下的 `<textarea>`；找不到放行。
-5. **target 校验**：`event.target !== textarea` 放行（排除点击 composer 卡片 chrome 的情况）。
-6. **readOnly/disabled gate**：`textarea.readOnly || textarea.disabled` 放行（hero 模式 workspace picker trigger、submit 进行中）。
-7. **多行边界**：`cursorLineInfo(value, selStart, selEnd)` 计算；ArrowUp 仅 `atFirstLine` 触发，ArrowDown 仅 `atLastLine` 触发。
-8. **导航**：`nextIndex(cursor, total, dir)` 计算下一索引；`null` 表示越过最新端 → 恢复 `savedDraft`；否则 `setNativeTextareaValue(textarea, entry)` + `event.preventDefault()`。
-9. **草稿保存**：第一次从"未导航"切到"导航中"时，把当前 `textarea.value` 存到 `savedDraft`。
-
-### 历史回填：native setter
-
-`setNativeTextareaValue(textarea, value)` 用 `Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value').set` 调用原生 setter（绕过 React 的 value tracker），然后 `dispatchEvent(new Event('input', { bubbles: true }))`。React 感知到值变化，触发 InputBar 的 `onChange` → `keyboard.setDraft(next)` → input machine 更新 draft → React 重新渲染 textarea value。与用户手动输入走完全相同的路径。
+3. **已拦截守卫**：`event.defaultPrevented` → 放行。
+4. **editable 定位**：`findComposerEditable(event.target)` 向上找 `[data-composer-card]` 祖先，查其下 `[data-composer-input]`（Lexical contenteditable），并要求 target 在 editable 内部（卡片按钮/chrome 上的按键不触发）。
+5. **菜单兼容**：`findTriggerMenu(editable)` 在同一卡片内查 `[data-trigger-menu]`——菜单打开时方向键归菜单高亮仲裁（捕获阶段先于 keymap 的 arbitrate，不能再用 `defaultPrevented` 启发式）。
+6. **phase gate**：`input.phase !== 'plain'` 放行（adjudicating / claimed / submitting 提交事务中不干扰）。
+7. **多行边界**：`caretLineBoundary(editable)` 用折叠选区的 rect 与内容行盒 tops 比较；ArrowUp 仅 `atFirstLine` 触发，ArrowDown 仅 `atLastLine` 触发；几何不可得（无布局环境）→ 不导航。
+8. **导航**：`nextIndex(cursor, total, dir)` 计算下一索引；`null` 表示越过最新端 → `inputActions.setDraft(savedDraft)` 恢复草稿；否则 `setDraft(entry)`。
+9. **草稿保存**：第一次从"未导航"切到"导航中"时，把当前 `input.draft`（clipboard 投影）存到 `savedDraft`。
+10. **消费事件**：`preventDefault()` + `stopPropagation()`。捕获阶段在 document 上 `stopPropagation` 使事件永远到不了 Lexical 的 editable 监听器——否则 keymap 会在草稿已被替换后再移动光标。
 
 ## 开发
 
 ```sh
 pnpm install          # 安装开发依赖
-pnpm run typecheck    # tsc --noEmit（通过 ../dsh 解析 DSH 源码）
+pnpm run typecheck    # tsc --noEmit（通过 tsconfig paths + node_modules junction 解析 DSH 源码）
 pnpm test             # vitest run（纯函数单元测试）
-pnpm run build        # tsc + tsdown → lib/index.js, lib/invariant.js, lib/client.js
+pnpm run build        # tsdown + tsc → lib/index.js, lib/client.js, lib/types/
 ```
 
 ### 基于 DSH checkout 类型检查
 
-`tsconfig.json` 继承 `../dsh/tsconfig.base.client.json`，继承其 `paths` 映射到同级 DSH checkout 的 `packages/*/*/src`。需在 `../dsh` 是 DSH checkout 根目录的同级布局下运行 typecheck。
+`@deepseek-ai/*` 的 alpha 版本未发布到 npm：`peerDependencies` 照写 `^0.1.2-rc.1`（仅声明），本地开发用两条通道解析类型——
+
+1. `tsconfig.json` 的 `paths` 指向 `C:/Users/Administrator/.dsh/source/current/packages/*/lib/types`（需该 checkout 已 `pnpm run build`）；
+2. `node_modules/@deepseek-ai/*` 为指向同一 checkout 的 junction（首次需手工创建，或从 dsh-interpreters / dsh-mineru 复制做法）。
+
+`pnpm-workspace.yaml` 的 `autoInstallPeers: false` 阻止 pnpm 去 registry 拉取不存在的 peer 版本（pnpm 10 读 workspace.yaml 的这一项，不是 `.npmrc`）。
 
 ### 预构建 lib/
 
@@ -102,9 +102,9 @@ dsh plugin --profile web add link:D:/Projects/deepseek-harness/dsh-plugin-input-
 ## 已知限制
 
 - **Capacity 硬编码。** 历史上限固定为 500 条（`DEFAULT_CAPACITY` in `src/client/history.ts`）。改为 `Config` 字段需要 host-client 间 RPC 通道（client bundle 与 host bundle 是独立的模块作用域，无法直接共享 Config）。如需调整，编辑源码后重建 `lib/`。
-- **textarea DOM 句柄无私有 API。** 插件通过 `document.querySelector('[data-composer-card] textarea')` 定位 InputBar 的 textarea。`data-composer-card` 属性是 `ui-conversation` 包的内部实现（`InputBar.tsx:629`），目前稳定但无文档保证；上游若改名，定位器需要更新（单点：`findComposerTextarea`）。
-- **斜杠菜单开/关状态无私有 API。** 通过 `event.defaultPrevented` 启发式判断：InputBar 的 onKeyDown 在菜单打开时方向键已 `preventDefault`（`InputBar.tsx:316`），bubble 阶段监听器据此识别"菜单已消费"。若上游改变该逻辑，启发式可能失效。
-- **hero 模式（无 workspace 的 workspace picker）下不触发。** hero 模式的 textarea 是 readOnly 的 workspace picker trigger，`textarea.readOnly` 守卫会放行。但 blank session（有 workspace、textarea 可编辑）下正常工作——这是关键修复点，因为 DSH 把 blank session 当 hero 渲染导致 dock 不挂载，监听器放在 `apply` 里绕过了这个限制。
+- **DOM 标记是上游内部属性。** 插件通过 `[data-composer-card]` / `[data-composer-input]` / `[data-trigger-menu]` 定位 composer 卡片、Lexical editable 与触发菜单。这些属性是 `ui-conversation` / `ui-input-trigger` 包的内部实现，目前稳定但无文档保证；上游若改名，定位器需要更新（单点：`src/client/dom.ts`）。
+- **hero / blank session 下休眠。** DSH 把 blank session 当作 hero 渲染，`conversation.composer.dock` 不挂载，插件的收集与监听都随 dock 休眠。且 hero 模式本就没有当前 session 的 input machine（`inputActions` 不存在），导航无处落地。会话激活后（发出第一条消息）恢复正常。
+- **含 chip 的草稿按纯文本恢复。** 导航保存的"在途草稿"是 `input.draft`（clipboard 投影）：恢复时引用 chip 会变回 `/name` 纯文本形式。历史条目本身也始终是纯文本。
 - **无跨 tab 同步。** 多窗口同时发消息时 localStorage 写竞争通过 try/catch 容错；最坏丢一条，下次 append 会纠正。
 - **历史范围全局共享。** 不区分 workspace / session，所有 `user` + `steering` 消息进同一历史。如需按 workspace 隔离，需要扩展 `HistoryStore` 的 key 命名空间。
 

package/lib/client.js

@@ -204,58 +204,116 @@ function safeLocalStorage() {
 }
 
 //#endregion
-//#region src/client/HistoryDock.tsx
+//#region src/client/dom.ts
 /**
-* Module-scope history store, initialized once on first dock mount.
-* Shared with the keydown listener in `apply` via `getHistoryStore()`.
+* Pure decision over caret geometry: where a caret resting at `caretTop`
+* sits relative to the box whose visual line tops are `lineTops` (ascending,
+* one entry per visual line, viewport coordinates).
+*
+* @param caretTop - viewport `top` of the collapsed caret's box.
+* @param lineTops - viewport `top` of each visual line, ascending.
+* @param tolerance - px slop absorbing subpixel rounding between the caret
+*   rect and its line's rect.
+* @returns the boundary flags; an empty `lineTops` (empty editable) is
+*   treated as a single virtual line, so both flags are true.
 */
-let historyStore = null;
-/** Get the shared history store (initializes lazily on first call). */
-function getHistoryStore() {
-	if (historyStore === null) historyStore = new HistoryStore(DEFAULT_CAPACITY);
-	return historyStore;
+function boundaryFromLineTops(caretTop, lineTops, tolerance) {
+	if (lineTops.length === 0) return {
+		atFirstLine: true,
+		atLastLine: true
+	};
+	return {
+		atFirstLine: caretTop <= lineTops[0] + tolerance,
+		atLastLine: caretTop >= lineTops[lineTops.length - 1] - tolerance
+	};
 }
 /**
-* Render the invisible history-collection dock entry.
+* Locate the DSH composer editable the event targeted.
 *
-* @param props - dock runtime share (InputZone owner + session kit) + locale seat.
-* @returns an `aria-hidden` anchor with zero layout footprint.
+* Walks from the event target up to the closest `[data-composer-card]`
+* ancestor, queries the `[data-composer-input]` contenteditable inside it,
+* and confirms the target sits inside that editable (keystrokes on the
+* card's buttons and chrome do not navigate history). Returns `null` when
+* the target is not inside the composer editable.
+*
+* @param from - the event target (or any node inside the composer editable).
+* @returns the editable element, or `null` when not found.
 */
-function HistoryDock({ session }) {
-	const store = getHistoryStore();
-	const lastSeenTextRef = (0, react.useRef)(null);
-	const lastText = latestUserOrSteeringText(session.nodes);
-	if (lastText !== null && lastText !== lastSeenTextRef.current) {
-		lastSeenTextRef.current = lastText;
-		store.append(lastText);
-	}
-	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-		"aria-hidden": true,
-		style: { display: "none" },
-		"data-dsh-plugin-input-history": ""
-	});
+function findComposerEditable(from) {
+	if (typeof document === "undefined") return null;
+	if (from === null || !(from instanceof Element)) return null;
+	const card = from.closest("[data-composer-card]");
+	if (card === null) return null;
+	const editable = card.querySelector("[data-composer-input]");
+	if (editable === null) return null;
+	return editable.contains(from) ? editable : null;
 }
 /**
-* Extract the text of the latest `user` or `steering` node from a
-* conversation snapshot's nodes list.
+* Detect an open trigger (slash-command / @-mention) menu inside the
+* composer card that owns `editable`.
 *
-* Returns the concatenated text of all `type: 'text'` content blocks.
-* Returns `null` when no user/steering node is present (e.g. a fresh
-* session with only a system/context message).
+* While the menu is open, ArrowUp/ArrowDown move the highlighted row and
+* must not recall history. The menu renders inside the same
+* `[data-composer-card]` as the editable and carries the stable
+* `data-trigger-menu` marker.
 *
-* @param nodes - the conversation snapshot's `nodes` array.
+* @param editable - the composer editable element.
+* @returns the menu element, or `null` when no menu is open.
 */
-function latestUserOrSteeringText(nodes) {
-	for (let i = nodes.length - 1; i >= 0; i--) {
-		const node = nodes[i];
-		if (node.kind !== "user" && node.kind !== "steering") continue;
-		const content = node.content;
-		if (content === void 0) continue;
-		let text = "";
-		for (const block of content) if (block.type === "text" && typeof block.text === "string") text += block.text;
-		return text;
+function findTriggerMenu(editable) {
+	const card = editable.closest("[data-composer-card]");
+	return card === null ? null : card.querySelector("[data-trigger-menu]");
+}
+/**
+* Decide the collapsed caret's line boundary inside the composer editable.
+*
+* Compares the caret's viewport box against the editable content's visual
+* line boxes (`Range.getClientRects()` yields one rect per line fragment;
+* fragments of the same visual line share a top within subpixel slop, so
+* tops are deduped with a 2px threshold). A non-collapsed selection and a
+* geometry-less environment (headless/jsdom) both return `null`, which the
+* caller must treat as "do not navigate".
+*
+* @param editable - the composer editable element.
+* @param tolerance - px slop between the caret rect and its line rect
+*   (defaults to 4px).
+* @returns the boundary flags, or `null` when they cannot be determined.
+*/
+function caretLineBoundary(editable, tolerance = 4) {
+	const selection = window.getSelection();
+	if (selection === null || selection.rangeCount === 0) return null;
+	if (!selection.isCollapsed) return null;
+	const caretTop = caretTopOf(selection);
+	if (caretTop === null) return null;
+	const lineTops = contentLineTops(editable);
+	if (lineTops === null) return null;
+	return boundaryFromLineTops(caretTop, lineTops, tolerance);
+}
+/** Viewport `top` of the collapsed caret's box, or `null` when unmeasurable. */
+function caretTopOf(selection) {
+	const rects = selection.getRangeAt(0).getClientRects();
+	for (let i = 0; i < rects.length; i++) {
+		const rect = rects[i];
+		if (rect.height === 0 && rect.width === 0) continue;
+		return rect.top;
 	}
-	return null;
+	const anchor = selection.anchorNode;
+	const el = anchor instanceof HTMLElement ? anchor : anchor?.parentElement;
+	return el === void 0 || el === null ? null : el.getBoundingClientRect().top;
+}
+/** Ascending, deduped tops of the editable content's visual lines; `null` without geometry. Empty for an empty editable. */
+function contentLineTops(editable) {
+	const range = document.createRange();
+	range.selectNodeContents(editable);
+	const rects = range.getClientRects();
+	const tops = [];
+	for (let i = 0; i < rects.length; i++) {
+		const rect = rects[i];
+		if (rect.height === 0 && rect.width === 0) continue;
+		const top = rect.top;
+		if (tops.length === 0 || Math.abs(top - tops[tops.length - 1]) > 2) tops.push(top);
+	}
+	return tops;
 }
 
 //#endregion
@@ -284,68 +342,118 @@ function isImeComposition(event) {
 }
 
 //#endregion
-//#region src/client/dom.ts
+//#region src/client/HistoryDock.tsx
 /**
-* Compute the caret's line position in a textarea value.
-*
-* Lines are split on `\n` (the textarea's own line break character). The
-* caret must be collapsed (`selectionStart === selectionEnd`) for the
-* `atFirstLine` / `atLastLine` flags to be true — a non-collapsed
-* selection spanning multiple lines should not trigger history navigation.
+* Module-scope history store, initialized once on first dock mount.
+* Shared across dock mount/unmount cycles; the underlying data persists
+* in `localStorage`.
+*/
+let historyStore = null;
+/** Get the shared history store (initializes lazily on first call). */
+function getHistoryStore() {
+	if (historyStore === null) historyStore = new HistoryStore(DEFAULT_CAPACITY);
+	return historyStore;
+}
+/**
+* Render the invisible history dock entry: collection + navigation.
 *
-* @param value - the textarea's current value.
-* @param selectionStart - the textarea's `selectionStart`.
-* @param selectionEnd - the textarea's `selectionEnd` (defaults to `selectionStart`).
-* @returns the caret's line information.
+* @param props - dock runtime share (standard hooks) + locale seat.
+* @returns an `aria-hidden` anchor with zero layout footprint.
 */
-function cursorLineInfo(value, selectionStart, selectionEnd = selectionStart) {
-	const rawStart = Math.min(selectionStart, selectionEnd);
-	const rawEnd = Math.max(selectionStart, selectionEnd);
-	const clampedStart = Math.max(0, Math.min(rawStart, value.length));
-	const collapsed = clampedStart === Math.max(clampedStart, Math.min(rawEnd, value.length));
-	const lines = value.split("\n");
-	const totalLines = lines.length;
-	let currentLine = 0;
-	let runningLength = 0;
-	for (let i = 0; i < totalLines; i++) {
-		const line = lines[i];
-		const lineEnd = runningLength + line.length;
-		const upperBound = i === totalLines - 1 ? lineEnd + 1 : lineEnd + 1;
-		if (clampedStart >= runningLength && clampedStart < upperBound) {
-			currentLine = i;
-			break;
-		}
-		runningLength = lineEnd + 1;
+function HistoryDock({ useInput, useChat, inputActions, sessionId }) {
+	const input = useInput((s) => s);
+	const nodes = useChat((s) => s.legacy.nodes);
+	const lastText = (0, react.useMemo)(() => latestUserOrSteeringText(nodes), [nodes]);
+	(0, react.useEffect)(() => {
+		if (lastText !== null) getHistoryStore().append(lastText);
+	}, [lastText]);
+	const navCursorRef = (0, react.useRef)(null);
+	const savedDraftRef = (0, react.useRef)(null);
+	const prevSessionRef = (0, react.useRef)(sessionId);
+	if (prevSessionRef.current !== sessionId) {
+		prevSessionRef.current = sessionId;
+		navCursorRef.current = null;
+		savedDraftRef.current = null;
 	}
-	return {
-		currentLine,
-		totalLines,
-		atFirstLine: collapsed && currentLine === 0,
-		atLastLine: collapsed && currentLine === totalLines - 1
-	};
+	const inputRef = (0, react.useRef)(input);
+	inputRef.current = input;
+	const actionsRef = (0, react.useRef)(inputActions);
+	actionsRef.current = inputActions;
+	(0, react.useEffect)(() => {
+		if (typeof document === "undefined") return void 0;
+		const handler = (event) => {
+			if (event.key !== "ArrowUp" && event.key !== "ArrowDown") return;
+			if (isImeComposition(event)) return;
+			if (event.defaultPrevented) return;
+			if (actionsRef.current === void 0 || inputRef.current === void 0) return;
+			const editable = findComposerEditable(event.target);
+			if (editable === null) return;
+			if (findTriggerMenu(editable) !== null) return;
+			if (inputRef.current.phase !== "plain") return;
+			const boundary = caretLineBoundary(editable);
+			if (boundary === null) return;
+			if (event.key === "ArrowUp" && !boundary.atFirstLine) return;
+			if (event.key === "ArrowDown" && !boundary.atLastLine) return;
+			const history = getHistoryStore().list;
+			const dir = event.key === "ArrowUp" ? "up" : "down";
+			const next = nextIndex(navCursorRef.current, history.length, dir);
+			if (next === null) {
+				const saved = savedDraftRef.current;
+				navCursorRef.current = null;
+				if (saved !== null) {
+					actionsRef.current.setDraft(saved);
+					savedDraftRef.current = null;
+				}
+				consume(event);
+				return;
+			}
+			if (navCursorRef.current === null && savedDraftRef.current === null) savedDraftRef.current = inputRef.current.draft;
+			const entry = entryAt(history, next);
+			if (entry === null) return;
+			navCursorRef.current = next;
+			actionsRef.current.setDraft(entry);
+			consume(event);
+		};
+		document.addEventListener("keydown", handler, true);
+		return () => {
+			document.removeEventListener("keydown", handler, true);
+		};
+	}, []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		"aria-hidden": true,
+		style: { display: "none" },
+		"data-dsh-plugin-input-history": ""
+	});
 }
 /**
-* Locate the DSH composer textarea in the current document.
-*
-* Walks from the event target up to find the closest `[data-composer-card]`
-* ancestor, then queries the descendant `<textarea>` inside it. Returns
-* `null` when the target is not inside the composer card (e.g. the user
-* is typing in another input or the textarea is momentarily absent).
+* Consume a navigated keystroke: `preventDefault` stops the browser's own
+* gesture, `stopPropagation` (capture phase, document level) keeps the
+* event from ever reaching Lexical's editable keydown listener — otherwise
+* the keymap would move the caret after the draft was already replaced.
+*/
+function consume(event) {
+	event.preventDefault();
+	event.stopPropagation();
+}
+/**
+* Extract the text of the latest `user` or `steering` node from the Chat
+* target's legacy node list.
 *
-* When called without an event target, falls back to a document-wide
-* query — used in tests and ad-hoc probing.
+* Returns the concatenated text of all `type: 'text'` content blocks.
+* Returns `null` when no user/steering node is present (e.g. a fresh
+* session with only a system/context message).
 *
-* @param from - the event target (or any node inside the composer card).
-* @returns the textarea element, or `null` when not found.
+* @param nodes - the Chat snapshot's legacy `nodes` array (newest last).
 */
-function findComposerTextarea(from) {
-	if (typeof document === "undefined") return null;
-	if (from === void 0) return document.querySelector("[data-composer-card] textarea");
-	if (from === null) return null;
-	const card = from instanceof Element ? from.closest("[data-composer-card]") : null;
-	if (card !== null) {
-		const ta = card.querySelector("textarea");
-		if (ta !== null) return ta;
+function latestUserOrSteeringText(nodes) {
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		const node = nodes[i];
+		if (node.kind !== "user" && node.kind !== "steering") continue;
+		const content = node.content;
+		if (content === void 0) continue;
+		let text = "";
+		for (const block of content) if (block.type === "text" && typeof block.text === "string") text += block.text;
+		return text;
 	}
 	return null;
 }
@@ -495,14 +603,7 @@ const dicts = {
 /** Required services: slots + locale. */
 const inject = ["slots", "locale"];
 /**
-* Navigation cursor + saved draft for the keydown listener. Module-scoped
-* because the listener is attached once in `apply` and must persist across
-* dock mount/unmount cycles.
-*/
-let navCursor = null;
-let savedDraft = null;
-/**
-* Client plugin body: register the dock + attach the keydown listener.
+* Client plugin body: register the dock + locale dictionaries.
 *
 * @param ctx - client root context.
 */
@@ -532,70 +633,6 @@ function apply(ctx) {
 		order: 100,
 		locale: NS
 	}, HistoryDock));
-	ctx.effect(() => {
-		if (typeof document === "undefined") return () => {};
-		const handler = (event) => {
-			if (event.key !== "ArrowUp" && event.key !== "ArrowDown") return;
-			if (isImeComposition(event)) return;
-			if (event.defaultPrevented) return;
-			const textarea = findComposerTextarea(event.target);
-			if (textarea === null) return;
-			if (event.target !== textarea) return;
-			if (textarea.readOnly || textarea.disabled) return;
-			const history = getHistoryStore().list;
-			const info = cursorLineInfo(textarea.value, textarea.selectionStart, textarea.selectionEnd);
-			if (event.key === "ArrowUp" && !info.atFirstLine) return;
-			if (event.key === "ArrowDown" && !info.atLastLine) return;
-			const dir = event.key === "ArrowUp" ? "up" : "down";
-			const next = nextIndex(navCursor, history.length, dir);
-			if (next === null) {
-				const saved = savedDraft;
-				navCursor = null;
-				if (saved !== null) {
-					setNativeTextareaValue(textarea, saved);
-					savedDraft = null;
-				}
-				event.preventDefault();
-				return;
-			}
-			if (navCursor === null && savedDraft === null) savedDraft = textarea.value;
-			const entry = entryAt(history, next);
-			if (entry === null) return;
-			navCursor = next;
-			setNativeTextareaValue(textarea, entry);
-			event.preventDefault();
-		};
-		document.addEventListener("keydown", handler, false);
-		return () => {
-			document.removeEventListener("keydown", handler, false);
-		};
-	}, "dsh-plugin-input-history: keydown listener");
-}
-/**
-* Set the textarea value via the native prototype setter and dispatch an
-* `input` event so React's controlled-component onChange fires.
-*
-* React 18 tracks the textarea's value internally; directly assigning
-* `textarea.value = x` does NOT trigger React's onChange because React's
-* value tracker compares against its last-seen value. Using the native
-* prototype setter bypasses React's tracker, and the dispatched `input`
-* event makes React detect the change and run InputBar's `onChange` →
-* `keyboard.setDraft(next)`. This is the same technique used by
-* browser automation libraries (Playwright, Testing Library) to simulate
-* user typing in React controlled inputs.
-*
-* @param textarea - the target textarea element.
-* @param value - the new value to set.
-*/
-function setNativeTextareaValue(textarea, value) {
-	const proto = window.HTMLTextAreaElement.prototype;
-	const descriptor = Object.getOwnPropertyDescriptor(proto, "value");
-	if (descriptor === void 0 || descriptor.set === void 0) {
-		textarea.value = value;
-		return;
-	}
-	descriptor.set.call(textarea, value);
-	textarea.dispatchEvent(new Event("input", { bubbles: true }));
 }
 
 //#endregion