dsh-edit-turn 0.5.2 → 0.5.4

package/README.md

@@ -61,7 +61,9 @@ dsh plugin --profile web add /path/to/dsh-edit-turn
 编辑器里，消息带的图片与文件**各显示成一个芯片**（缩略图或文件名 + 大小 + 删除按钮）：不碰就原样保留，点删除就是不要它了；旁边还有一个「**添加附件**」（这条消息本来没有附件时也能用）。缩略图由本插件的只读路由按需取回；取不回来、或那些字节不是图片，芯片退回显示名字。**只有当这个部署没有附件存储时**，编辑器才会改回旧的那句话——「这条消息包含图片或文件附件，改写会丢弃它们，只保留文字」——并且不出现添加入口。
 **一字不改就按保存，什么都不会发生。** 编辑器预填的就是这条消息**现在**的文本，所以「打开编辑器、不输入、直接保存」等于没提出任何修改：宿主不写任何事件（不落替换、不开合成轮次、不追加回答），编辑器照常关闭、**一条提示都不显示**（0.2.20 起；这条提示此前压在输入框的占位文字上）。会话日志、轮次导轨、轨迹视图都保持原样——此前它照样落一条替换（一次会话里三条），改回答时还会多出一整个轮次（用户只发了两条消息，轨迹视图里却有四轮）。**「重跑」不受这条守卫影响**：文本没变但用户点的是「重跑」，宿主同样不写，重跑照常发起（用户的意图就是让这一轮重新生成）。
 
-**编辑模型的回答**：悬停任意一条模型回复，同样会出现编辑入口。编辑器上方多一个**块选择器**：一条回复同时带思维链和正文时，可以选「思维链」或「正文」，只改选中的那一块。改完点「保存」——记录只追加一条 `plugin:dsh-edit-turn/patch`，投影在模型下一次折叠时生效；**这条回答仍在原来的位置，后面的轮次原样不动**，工具调用和其他块也不动。转录里正文会就地显示改后的文字；思维链被改时会出现一条注记，展开就能看到模型实际读到的内容。
+**术语**：编辑器里的「**思维链**」「**正文**」「**全部**」三个界面叫**页**；「全部」页里的「思维链」「正文」条目叫**子页**（也叫**块**）。页与子页指的是同一份内容，所以**在任一页里改动、切到别的页再切回来，改过的内容都还在**（只有关掉编辑器才会丢）；子页之间也是同一份草稿。
+
+**编辑模型的回答**：悬停任意一条模型回复，同样会出现编辑入口。编辑器上方多一个**页选择器**：一条回复同时带思维链和正文时，可以选「思维链」「正文」页，或切到「全部」页一次看完整轮。改完点「保存」——记录只追加一条 `plugin:dsh-edit-turn/patch`，投影在模型下一次折叠时生效；**这条回答仍在原来的位置，后面的轮次原样不动**，工具调用和其他块也不动。转录里正文会就地显示改后的文字；思维链被改时会出现一条注记，展开就能看到模型实际读到的内容。
 
 在退回重放路径的宿主上（或显式 `replyMode: replay`），行为仍是 0.2.21 的：整条回答被替换，后面的轮次回退再逐事件重放；这种模式下只能改正文，工具调用与思维链无法保留（编辑器会提示）。
 
@@ -276,7 +278,29 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
-**0.5.2（工作区）** —— 回复编辑不再等这一轮回复结束；编辑器跟着当前皮肤走。
+**0.5.4** —— 设置卡导出给组合包（dsh-as-aistudio）；会话 id 校验放宽，空会话按空状态处理。
+
+- **会话 id 不再只认 UUID**：命名会话（例如 `bili-whale`，`~/.dsh/storages/<profile>/sessions/bili-whale.json`）是完全合法的会话，但这里的校验只接受 UUID 形式，于是对它的每个请求都被 400 拒掉 —— 面板上就是「状态加载失败，稍后重试。」。现在按 DSH 自己的语法（宿主侧 schema 就是 `z.string().min(1)`）放宽为 `/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/`，仍然挡住 `/`、`\`、`..`、空白与控制字符。
+- **查不到会话按空状态处理**：没有日志的会话（刚建的命名会话）返回空状态而不是 404 —— 面板正常加载、显示"没有可操作的内容"，日志一出现下一次刷新就接上。
+- **设置卡导出**：`exports.ConfigCard`（就是 `EditorStyleOption` 那个组件）现在对外导出，于是聚合包 dsh-as-aistudio 能在自己的插件页上渲染**这同一张卡**，而不是照着重画一份。同一份设置、同一份存储键，两个入口不会漂移；单独装本插件时那张卡仍在本插件自己的行上。
+
+
+**0.5.3** —— 编辑框随内容长高；隐藏兜底不再吞掉第三方插件的按钮。
+
+- **换页不再丢草稿**：以前「正文」页写的内容只存在单块草稿里、「全部」页的子页各自另存一份，而且切页时草稿会被重置成记录原文 —— 于是「正文」页写个 1、切到「全部」页，子页里没有这个 1；切回来也没了。现在三页共用**一份按块索引的草稿**（`正文` 页与它在「全部」页里的子页是同一个块、同一个 key），任何一页里打的字，切到别的页、再切回来都还在；保存时发出的也是草稿（真页面复验：正文页写 `1` → 全部页正文子页显示 `1` → 在全部页改思维链子页 → 切回正文页仍是 `1` → 切到思维链页是 `thought draft` → 再切回正文页仍是 `1`）。
+
+- **往下滚自动弹回顶部（主要问题）**：测量每个块的 textarea 要把它塌成 `height: auto`，整个文档随之变矮，浏览器就把滚动条的 `scrollTop` 夹到新的上限（≈0）—— 高度随后虽然恢复，**位置已经丢了**。宿主在流式回复时会不停重绘，所以表现为「滚到下面自动回上去」。实测：滚到底（`scrollTop 847 = max 847`）后触发一次布局，`scrollTop` 变 **0**。修法：新增 `withScrollKept(scroller, work)`，测量前后保存/恢复滚动位置；「全部」页的整体重测、逐块撑高、单块模式的测量全部走它。修后同样操作 `scrollTop` 保持 **847**。
+- **最后一行滚不到**：同一次「设成 `auto` 再读 `scrollHeight`」的读取**永远少一行**（换行在写完样式之后才落定），元素被钉在偏小高度且 `overflow:hidden`，外层滚动条按这个值算高度 → 最后一行既看不见也滚不到（实测：一次读 2392、二次读 2415，行高 23px）。修法：抽出 `settleAreaHeight()`，重置后**读两次**再落定。
+- **真页面复验**：正文灌到 1200 / 3000 / 6000 / 12000 字符，`clipped` 全为 0、滚动条都能到底、最后一行完整可见且停在底栏上方 8px；滚到底后连续两次布局，位置不动。
+- **改写后的提示词气泡跟随 Markdown 渲染**：装了 `dsh-markdown-bubble` 时，改写后那条气泡（`.dshet-revision`）不再固定成纯文本，而是走宿主自己的 `MarkdownText`（用 `react-dom/client` 挂载 —— 宿主自己的包也是这么用的，已实测可行）。判据是那个插件自己的存在标记 `globalThis.__DSH_MARKDOWN_BUBBLE__`：**装了才渲染 Markdown，没装就保持纯文本**，因为没装时宿主画的其它用户气泡就是纯文本，只有跟着一致才不会出现「改写过的和没改写过的长得不一样」。理由与上游建议见 [deepseek-harness#10704](https://github.com/deepseek-ai/deepseek-harness/discussions/10704)。
+- **编辑时框跟着内容长高**：以前框高在打开那一刻定死（「一轮最大」还带缓存），打字变多也不长 —— 内容超出后只能靠框内滚动条。现在：**打字变多就长高，删字就变矮，但不会比「打开时」更矮**（这道地板属于这一次编辑，切页也保留，保存或点叉才结束）。方向看空间：下面够就在下方长，下面不够就把底边钉在输入框卡片上沿、往上长（实测底边 680 / 输入框卡片上沿 688，留 8px 边距）；整段都装不下就铺满对话区上下边界、由框内滚动。三档「高度」偏好只决定**打开时**多大，编辑中的跟随规则三档一致（设置页的说明文案已同步）。
+- **隐藏兜底会吞掉第三方插件的按钮（issue #1，静默失败）**：折叠一条被改写的消息时，那段兜底是「除我自己的三个类名外，兄弟节点一律隐藏」。`dsh-rewind-pro` 这类插件把图标注入到同一条用户消息里（动作条旁边 / 插槽旁边），于是被一并隐藏 —— DOM 里在、点得到、屏幕上 `display:none`，**没有任何报错**，自动化测试（`querySelectorAll` 数得到元素）也全绿，所以很难发现。现在只隐藏**装着消息正文**的那个子树：兄弟节点里不含正文的一律不动（`messageContentRoot` 找不到宿主形状时仍退回旧行为，免得改写后的消息留在屏幕上）。回归测试里注入两个第三方节点（动作条旁、插槽旁），断言它们保持可见、且不带本插件的折叠标记 —— 改回旧写法该测试转红。
+- **补上 `error.session-empty` 的中英文案**：宿主半部对「还没有内容的会话」会报这个 code，客户端字典里缺它，静态校验（`verify:client`）一直在红。
+- **单块页（思维链 / 正文 / 用户输入）滚不动**：真因不是滚轮，而是**滚动位置活不过下一次布局** —— 给 textarea 赋 `value` 会把它的滚动位置扔回顶部（Chromium 实测：赋**同一个**字符串位置不变，赋**另一个**字符串位置归零，再赋回原值也回不来）。而「一轮最大」的高度测量正是把**同一轮其它块**的文字写进这个输入框来量的，于是每次**缓存未命中**的布局（第一次布局、切页、以及一轮里块还在变的时候——也就是模型流式输出期间）都会把读者扔回顶部。修法：测量前后保存/恢复 `scrollTop`。真页面复验：用户输入页灌 3000 字 → 滚到 400 → 强制重新测量（改宽度 + 输入）→ 仍是 **400**。
+- **思维链页保存后立即渲染**（两层原因）：① 宿主对一条思维链会保留**多份拷贝** —— 折叠时那一行留在 DOM 里但 `display:none`，展开面板时再渲染一份**可见的**正文；而补丁逻辑只要「记住的那个元素还连在文档里」就认为已经打过补丁并 `continue`，于是**用户正在看的那一份**始终是记录原文，直到整页刷新（刷新会从日志重新折叠，宿主自己就画对了）。现在这一支会**把所有拷贝一起打上**（记住的元素、所有带标记的元素、所有文本等于原文/上一次文本的元素，含 `findReasoningElements` 这个复数版搜索），实测同一次保存后 `data-dshet-patch` 出现两份 `335:0`。② 一条回复的块列表是**整轮**的（宿主把同一轮里每一步的思维链和正文都挂在回答行上，每块带自己的 `seq`），于是同一份列表里会有多个 `index` 相同的块（第一步的思维链和第四步的思维链都是 `index 0`）。以前两处都只按 `index` 找块：保存后本地那条「乐观」补丁还按**回答行的 seq** 记，渲染时又用 `find(index === …)` 命中**第一个**同 index 的块 —— 两处都拿错了 `original`，于是补丁在 DOM 里匹配不到任何东西，思维链正文要等刷新才变。现在补丁按**块自己的 seq** 记，查块按 **(seq, index)** 查，并顺着块找到**承载它的那条回复条目**（后一步的块住在以回答行 seq 为键的条目里）。
+- **测试**：`npm test` **254/254**（新增六例：补丁只落在目标步的思维链上；保存后思维链正文立即变；后开的思考面板同样显示改写；测量后 textarea 的滚动位置不变；编辑时随内容长高、删字只矮回打开时的高度；下方没空间时向上长而不压输入框 —— 六例在改回旧写法时都会失败）。（新增五例：换页保留草稿；模拟「第一次读少一行」的 textarea 断言最终高度；模拟浏览器夹滚动条断言测量后位置不变；装了 markdown 插件时改写气泡走宿主渲染器、没装时保持纯文本 —— 把修法还原成旧写法时都会失败）。
+
+**0.5.2** —— 回复编辑不再等这一轮回复结束；编辑器跟着当前皮肤走。
 
 - **回复编辑不再被「正在回复中」挡住**：就地记录（patch）只 append 一条 `ignorable` 事件，不改任何 surface 节点，所以它可以在 agent 还在写的时候落盘 —— 模型下一次折叠就读到。宿主侧只在**会移动 surface** 的路径上保留忙时拒绝：改写提示词（surface replace）和 replay 兜底（遮蔽窗口 + 重放尾部）。客户端同步：回复就地编辑不再禁用保存、不再显示「该会话正在回复中」横幅；提示词编辑与 replay 路径照旧拦下并说明。
 - **测试**：回复编辑在未闭合的 turn 中保存成功、提示词改写仍被拒、整轮多块在忙时保存成功。
@@ -288,7 +312,7 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 - **改写后的提示词气泡用皮肤自己的气泡色**（`--dsw-specific-bubble`），圆角用 `--dsw-radius-xl`，与真实用户气泡一致。
 - **测试**：`npm test` **241/241**、`npm run verify:contract` **96** 项、`npm run verify:client` **192** 项。
 
-**0.5.1（工作区）** —— 思维链就地画出来、保存不再“点不动”、同一个块可以反复编辑。
+**0.5.1** —— 思维链就地画出来、保存不再“点不动”、同一个块可以反复编辑。
 
 - **删掉「思维链已改写（模型可见）」卡片**：reasoning 正文只要在 DOM 里就就地改写；没有正文时不再插入任何占位卡片。
 - **无限次编辑**：记录「上一次画上去的文本」，第二、第三次编辑同一个块时仍能找到元素并更新。

package/lib/client.js

@@ -45,7 +45,7 @@ window.__ModuleLoader__.load({
     const RERUN_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.5.2'
+    const PLUGIN_VERSION = '0.5.4'
 
     // --- copy -----------------------------------------------------------------
 
@@ -78,9 +78,9 @@ window.__ModuleLoader__.load({
       'config.summary.height.max': '一轮最大',
       'config.summary.height.content': '随内容',
       'config.summary.height.fill': '全部铺满',
-      'config.hint.height.max': '取这一轮所有思维链/正文里的最大高度，切换块时框不变。',
-      'config.hint.height.content': '框高跟着当前块的内容走，切换块时框会变。',
-      'config.hint.height.fill': '普通块按一轮最大；选「全部」时自动铺满对话区到输入框之间的整段高度（刚好触碰上下边界），只有一个滚动条。',
+      'config.hint.height.max': '打开时取这一轮所有思维链/正文里的最大高度；编辑中随你打字长高、删字变矮，但不会比打开时更矮。',
+      'config.hint.height.content': '打开时框高跟着当前块走；编辑中随你打字长高、删字变矮，但不会比打开时更矮。',
+      'config.hint.height.fill': '普通块打开时按一轮最大，编辑中随打字长高、删字变矮（不会比打开时更矮）；选「全部」时铺满对话区到输入框之间的整段高度，只有一个滚动条。',
       'placement.overlay': '浮层',
       'placement.inline': '页面内联',
       'placement.legacy': '整行旧版',
@@ -114,6 +114,7 @@ window.__ModuleLoader__.load({
       'error.invalid': '请求无效，请刷新后重试。',
       'error.session-not-active': '这个会话当前未激活，请先打开该会话再编辑。',
       'error.session-not-found': '找不到该会话的日志。',
+      'error.session-empty': '这个会话还没有内容，暂时没有可编辑的东西。',
       'error.busy': '该会话正在回复中，请等回复结束后再编辑。',
       'error.not-editable': '这条消息不支持编辑。',
       'error.unsupported': '当前宿主不支持就地改写回复，需要走重放路径。',
@@ -164,9 +165,9 @@ window.__ModuleLoader__.load({
       'config.summary.height.max': 'Turn max',
       'config.summary.height.content': 'Content',
       'config.summary.height.fill': 'Fill when all',
-      'config.hint.height.max': 'Uses the tallest reasoning/text block of the turn, so the box does not resize when switching.',
-      'config.hint.height.content': 'The box follows the current block, so it resizes when switching.',
-      'config.hint.height.fill': 'Single blocks use the turn max; the all-blocks page fills the whole band between the conversation top and the composer, with one scrollbar.',
+      'config.hint.height.max': 'Opens at the tallest reasoning/text block of the turn; while editing it grows with your text and shrinks back, never below the height it opened at.',
+      'config.hint.height.content': 'Opens sized for the current block; while editing it grows with your text and shrinks back, never below the height it opened at.',
+      'config.hint.height.fill': 'Single blocks open at the turn max and follow your text while editing (never below the opening height); the all-blocks page fills the whole band between the conversation top and the composer, with one scrollbar.',
       'placement.overlay': 'Overlay',
       'placement.inline': 'In-page',
       'placement.legacy': 'Legacy row',
@@ -200,6 +201,7 @@ window.__ModuleLoader__.load({
       'error.invalid': 'Invalid request; refresh and try again.',
       'error.session-not-active': 'This session is not open in DSH; open it first.',
       'error.session-not-found': 'No session log was found for this id.',
+      'error.session-empty': 'This session has nothing in it yet; there is nothing to edit.',
       'error.busy': 'This session is still replying; wait for it to finish.',
       'error.not-editable': 'This message cannot be edited.',
       'error.unsupported': 'This harness does not expose the in-place reply path; the replay path is needed.',
@@ -236,6 +238,70 @@ window.__ModuleLoader__.load({
       return t(typeof code === 'string' && ERROR_KEYS.has(`error.${code}`) ? `error.${code}` : 'error.generic')
     }
 
+    // --- a rewritten prompt, rendered the way the bubble it stands in for is ---
+
+    /**
+     * Whether the markdown bubble plugin is on this page.
+     *
+     * Its own presence marker is the only honest signal: the host draws a user
+     * bubble as plain text (`white-space: pre-wrap`), so rendering markdown in
+     * the revision bubble is only correct when something else is already
+     * rendering the OTHER user bubbles that way. Without it, a rewritten prompt
+     * would look different from every untouched prompt around it.
+     */
+    function markdownBubbleInstalled() {
+      try {
+        return typeof globalThis !== 'undefined' && globalThis.__DSH_MARKDOWN_BUBBLE__ !== undefined
+      } catch {
+        return false
+      }
+    }
+
+    /** One mounted markdown occurrence per bubble, so a rebuild can unmount it. */
+    const revisionRoots = new WeakMap()
+
+    /**
+     * Draw one rewritten prompt's text into `host`.
+     *
+     * The host's own markdown renderer (`MarkdownText`) is a React component and
+     * this half builds DOM by hand, so it is mounted through `react-dom/client` -
+     * the same module the host's own bundles require. Anything missing (no
+     * react-dom, no primitives, a hostile host shape) falls back to the plain
+     * text node this bubble has always used.
+     *
+     * @param host - the bubble element that shows the text.
+     * @param text - the rewritten text.
+     * @returns whether the markdown path was used.
+     */
+    function renderRevisionText(host, text) {
+      if (!markdownBubbleInstalled()) return false
+      try {
+        const react = require('react')
+        const reactDom = require('react-dom/client')
+        const MarkdownText = primitives.MarkdownText
+        if (
+          typeof react?.createElement !== 'function' ||
+          typeof reactDom?.createRoot !== 'function' ||
+          MarkdownText === undefined ||
+          MarkdownText === null
+        ) {
+          return false
+        }
+        const previous = revisionRoots.get(host)
+        if (previous !== undefined && typeof previous.unmount === 'function') previous.unmount()
+        const node = document.createElement('span')
+        node.className = 'dshet-revision-text'
+        host.appendChild(node)
+        const root = reactDom.createRoot(node)
+        root.render(react.createElement(MarkdownText, { text }))
+        revisionRoots.set(host, root)
+        return true
+      } catch (error) {
+        console.warn('[dsh-edit-turn] the rewritten prompt could not be rendered as markdown:', error)
+        return false
+      }
+    }
+
     // --- style ----------------------------------------------------------------
     /**
      * Take the active skin's own surfaces when they are actually opaque.
@@ -574,6 +640,8 @@ window.__ModuleLoader__.load({
         this.editorStyle = 'frame'
         this.editorFocus = false
         this.editorDraft = ''
+        this.editorBlockKey = ''
+        this.editorDrafts = new Map()
         // The block list being edited: what the carrier will be rebuilt from.
         // Every entry is either `{ keep: <index> }` - a block of this message the
         // user left alone - or `{ add: { data, mediaType?, name } }` for
@@ -802,8 +870,16 @@ window.__ModuleLoader__.load({
         this.editorBlockKind = chosen === undefined ? null : chosen.kind
         this.editorTargetSeq = chosen !== undefined && typeof chosen.seq === 'number' ? chosen.seq : null
         this.editorAll = false
-        this.editorAllDrafts = new Map()
+        // The height the box opens at: the floor the user cannot shrink below
+        // for as long as this edit lasts (save or cancel ends it). Null until
+        // the first layout measures it.
+        this.editorBaseHeight = null
+        // ONE draft store per open, keyed by block: the 正文/思维链 pages and the
+        // sub-pages inside 全部 all read and write it, so switching pages never
+        // drops what the user typed (only closing the editor does).
+        this.editorDrafts = new Map()
         if (!same) {
+          this.editorBlockKey = chosen === undefined ? '' : blockDraftKey(chosen)
           this.editorDraft = chosen === undefined ? target.text : chosen.text
           this.editorParts = blocksToParts(normalized, this.sessionId)
         }
@@ -870,8 +946,9 @@ window.__ModuleLoader__.load({
         if (target === null || !Array.isArray(target.blocks)) return
         const raw = String(value)
         if (raw === 'all') {
+          // The all-blocks page reads the SAME drafts: a block edited on its own
+          // page shows that edit in its sub-page, and the other way round.
           this.editorAll = true
-          this.editorAllDrafts = new Map(target.blocks.map((block) => [`${typeof block.seq === 'number' ? block.seq : ''}:${block.index}`, block.text]))
           this.editorElement = null
           this.publish({ allBlocks: true, blockIndex: null, blockKind: null, targetSeq: null, failure: null })
           return
@@ -894,9 +971,12 @@ window.__ModuleLoader__.load({
         this.editorBlockIndex = block.index
         this.editorBlockKind = block.kind
         this.editorTargetSeq = typeof block.seq === 'number' ? block.seq : this.editorTargetSeq
-        this.editorDraft = block.text
+        this.editorBlockKey = blockDraftKey(block)
+        // This block's own draft, which may already carry what the user typed on
+        // another page - never the recorded text, which used to wipe it.
+        this.editorDraft = this.draftOfBlock(block)
         this.editorElement = null
-        this.publish({ draft: block.text, blockIndex: block.index, blockKind: block.kind, targetSeq: this.editorTargetSeq, allBlocks: false, failure: null })
+        this.publish({ draft: this.editorDraft, blockIndex: block.index, blockKind: block.kind, targetSeq: this.editorTargetSeq, allBlocks: false, failure: null })
       }
 
       close() {
@@ -918,12 +998,40 @@ window.__ModuleLoader__.load({
         this.editorBlockKind = null
         this.editorTargetSeq = null
         this.editorAll = false
-        this.editorAllDrafts = new Map()
+        this.editorDrafts = new Map()
+        this.editorBlockKey = ''
+        this.editorBaseHeight = null
         this.publish({ editing: null, draft: '', parts: [], blocks: [], blockIndex: null, blockKind: null, confirming: false, failure: null })
       }
 
+      /** The draft of one block: what the user typed, else the recorded text. */
+      draftOfBlock(block) {
+        const drafts = this.editorDrafts
+        if (drafts instanceof Map) {
+          const key = blockDraftKey(block)
+          const typed = drafts.get(key)
+          if (typeof typed === 'string') return typed
+        }
+        return block !== null && block !== undefined && typeof block.text === 'string' ? block.text : ''
+      }
+
+      /** Remember one block's draft, wherever the user typed it. */
+      setDraftFor(block, value) {
+        if (!(this.editorDrafts instanceof Map)) this.editorDrafts = new Map()
+        this.editorDrafts.set(blockDraftKey(block), String(value ?? ''))
+      }
+
       setDraft(value) {
         this.editorDraft = value
+        // The 正文/思维链 page and the matching sub-page inside 全部 are the same
+        // block: one store, so the edit survives a page switch.
+        const blocks = Array.isArray(this.editorBlocks) ? this.editorBlocks : []
+        const current =
+          blocks.find((block) => blockDraftKey(block) === this.editorBlockKey) ??
+          (typeof this.editorBlockIndex === 'number'
+            ? blocks.find((block) => block.index === this.editorBlockIndex && (this.editorBlockKind === null || block.kind === this.editorBlockKind))
+            : undefined)
+        if (current !== undefined) this.setDraftFor(current, value)
       }
 
       setEditorStyle(style) {
@@ -1001,11 +1109,9 @@ window.__ModuleLoader__.load({
       /** The all-blocks save: one request carrying every edited block. */
       async confirmAll(target) {
         const blocks = Array.isArray(target.blocks) ? target.blocks : []
-        const drafts = this.editorAllDrafts instanceof Map ? this.editorAllDrafts : new Map()
         const targets = []
         for (const block of blocks) {
-          const key = `${typeof block.seq === 'number' ? block.seq : ''}:${block.index}`
-          const text = drafts.get(key)
+          const text = this.draftOfBlock(block)
           if (typeof text !== 'string' || text.trim() === '') {
             this.publish({ failure: 'empty' })
             return
@@ -1040,7 +1146,7 @@ window.__ModuleLoader__.load({
           this.editor = null
           this.editorDraft = ''
           this.editorAll = false
-          this.editorAllDrafts = new Map()
+          this.editorDrafts = new Map()
           this.editorElement = null
           this.editorBox = null
           this.editorRow = null
@@ -1177,8 +1283,17 @@ window.__ModuleLoader__.load({
           let patches = this.view.patches
           let patchBySeq = this.view.patchBySeq
           if (data.mode === 'patch' && data.target && typeof data.target.blockIndex === 'number') {
+            // The BLOCK's own seq, not the reply's. A turn's reasoning can live
+            // in another step's message, and the host reports that seq in the
+            // answer. Keying the optimistic patch by the reply's seq looked up
+            // the wrong block, took the wrong `original`, and the patch then
+            // matched nothing in the DOM - the edit appeared only after a reload,
+            // when /state supplied it under its own seq (reported from the field
+            // for the 思维链 page; the 正文 page looked fine because its block IS
+            // the reply's own).
+            const patchSeq = typeof data.target.seq === 'number' ? data.target.seq : target.seq
             const targetPatch = {
-              seq: target.seq,
+              seq: patchSeq,
               blockIndex: data.target.blockIndex,
               kind: data.target.kind === 'reasoning' ? 'reasoning' : 'text',
               text: String(data.target.text ?? ''),
@@ -1190,10 +1305,21 @@ window.__ModuleLoader__.load({
             const byBlock = new Map(patchBySeq.get(targetPatch.seq) ?? [])
             byBlock.set(targetPatch.blockIndex, targetPatch)
             patchBySeq.set(targetPatch.seq, byBlock)
-            const entry = replies.get(target.seq)
+            // The entry that carries this block: the reply's own, or the one
+            // whose block list holds another step's reasoning.
+            let entry = replies.get(patchSeq)
+            if (entry === undefined || !Array.isArray(entry.blocks)) {
+              for (const candidate of replies.values()) {
+                if (Array.isArray(candidate?.blocks) && candidate.blocks.some((block) => block.seq === patchSeq)) {
+                  entry = candidate
+                  break
+                }
+              }
+            }
             if (entry !== undefined && Array.isArray(entry.blocks)) {
               const blocks = entry.blocks.map((block) =>
-                block.index === targetPatch.blockIndex
+                block.index === targetPatch.blockIndex &&
+                (block.seq === undefined || block.seq === patchSeq)
                   ? { ...block, text: targetPatch.text, patched: true }
                   : block)
               const text = blocks.filter((block) => block.kind === 'text').map((block) => block.text).join('\n')
@@ -1623,15 +1749,23 @@ window.__ModuleLoader__.load({
       // like the images were deleted.
       const signature = text + '|' + extraBlocks.map((block) =>
         `${String(block.index)}:${String(block.type)}:${String(block.name ?? '')}:${String(block.bytes ?? '')}`).join(',')
-      if (bubble.dataset.dshetRevisionContent !== signature) {
+      // The signature carries whether the markdown path was used: installing or
+      // removing the markdown bubble plugin must redraw this bubble too.
+      const markdownSignature = signature + '|md:' + (markdownBubbleInstalled() ? '1' : '0')
+      if (bubble.dataset.dshetRevisionContent !== markdownSignature) {
+        const previous = revisionRoots.get(bubble)
+        if (previous !== undefined && typeof previous.unmount === 'function') previous.unmount()
+        revisionRoots.delete(bubble)
         bubble.textContent = ''
-        const textNode = document.createElement('span')
-        textNode.className = 'dshet-revision-text'
-        textNode.textContent = text
-        bubble.appendChild(textNode)
+        if (!renderRevisionText(bubble, text)) {
+          const textNode = document.createElement('span')
+          textNode.className = 'dshet-revision-text'
+          textNode.textContent = text
+          bubble.appendChild(textNode)
+        }
         const files = revisionAttachments(entry, controller)
         if (files !== null) bubble.appendChild(files)
-        bubble.dataset.dshetRevisionContent = signature
+        bubble.dataset.dshetRevisionContent = markdownSignature
       }
       // The edit entry goes where every other action of this row lives: the
       // platform's own bar, which the collapse keeps standing, at its right end
@@ -2034,9 +2168,39 @@ window.__ModuleLoader__.load({
     // `_actions` suffix is stable) and hides that strip's ancestors' other
     // children up to the row. Returns false when there is no strip to keep, and
     // false is what tells the caller to hide the whole row instead.
+    /**
+     * The host's own message markup inside a row - the stack / bubble / markdown
+     * the transcript draws the text in. That subtree is the ONLY thing the
+     * collapse walk may hide: a sibling that does not contain it belongs to
+     * somebody else (another plugin's injected button, a portal), and hiding it
+     * is issue #1 - `dsh-rewind-pro`'s button stayed in the DOM, stayed
+     * clickable, and was `display:none` on screen with no console error to
+     * notice. Null when the host shape is not one we recognise; the walk then
+     * keeps its old "everything but ours" behaviour instead of leaving a
+     * rewritten prompt on screen.
+     */
+    function messageContentRoot(row) {
+      const selectors = ['[class*="_bubble"]', '[class*="userStack"]', '[class*="_markdown"]', '[class*="_stack"]', '[class*="messageBody"]']
+      for (const selector of selectors) {
+        let found = null
+        try {
+          found = row.querySelector(selector)
+        } catch {
+          found = null
+        }
+        if (found === null || found === undefined) continue
+        if (typeof found.closest === 'function' && found.closest('.dshet-editor') !== null) continue
+        return found
+      }
+      return null
+    }
+
     function collapseRowContent(row, hide) {
       const strip = row.querySelector('[class*="_actions"]')
       if (strip === null) return false
+      // Only consulted while hiding: the restore pass goes by the marker this
+      // plugin wrote, so a node an older build had hidden is still restored.
+      const contentRoot = hide ? messageContentRoot(row) : null
       let node = strip
       while (node !== null && node !== row) {
         const parent = node.parentElement
@@ -2056,6 +2220,16 @@ window.__ModuleLoader__.load({
           ) {
             continue
           }
+          // I5 / issue #1: another plugin's node beside the message is not ours
+          // to hide. Only a sibling that holds the message content is.
+          if (
+            hide &&
+            contentRoot !== null &&
+            typeof child.contains === 'function' &&
+            child.contains(contentRoot) !== true
+          ) {
+            continue
+          }
           if (hide) {
             // Written only when the value changes: this runs on every DOM pass,
             // and an attribute write the observer can see would never settle.
@@ -2544,7 +2718,7 @@ window.__ModuleLoader__.load({
       return bounds
     }
 
-    function placeEditor(row, box, mode = 'reply', style = 'frame', blockKind = null, blocks = null) {
+    function placeEditor(row, box, mode = 'reply', style = 'frame', blockKind = null, blocks = null, controller = null) {
       const layer = ensureEditorLayer()
       if (box.parentElement !== layer) layer.appendChild(box)
       const placement = readStoredEditorPlacement() ?? 'overlay'
@@ -2718,11 +2892,23 @@ window.__ModuleLoader__.load({
         try {
           const previousValue = area.value
           const previousHeight = area.style.height
+          // Assigning `value` drops a textarea's scroll position to the top -
+          // even when the assignment is only a measuring detour. Verified in
+          // Chromium: the SAME string keeps the scroll, a DIFFERENT string
+          // resets it to 0, and putting the original back does not bring it
+          // back. The "turn max" pass below writes every other block's text into
+          // this field, so every cache-miss layout (the first one, a page
+          // switch, and every pass while the turn's blocks change - i.e. while
+          // the model streams) threw the reader back to the top. That is what
+          // "the 思维链/正文 page cannot be scrolled down" was: the wheel worked,
+          // the position did not survive the next layout.
+          const previousScroll = typeof area.scrollTop === 'number' ? area.scrollTop : 0
           const measure = (text) => {
             area.value = text
-            area.style.height = 'auto'
-            const measured = area.scrollHeight
-            return typeof measured === 'number' && measured > 0 ? Math.round(measured) : 0
+            // The settled height: one pass reads a line short (see
+            // settleAreaHeight), and this number decides the whole box. The
+            // scroller is the box itself, so its position is kept too.
+            return Math.round(withScrollKept(box, () => settleAreaHeight(area)))
           }
           const own = measure(previousValue)
           if (own > 0) contentHeight = own
@@ -2748,11 +2934,26 @@ window.__ModuleLoader__.load({
           }
           area.value = previousValue
           area.style.height = previousHeight
+          if (typeof area.scrollTop === 'number' && area.scrollTop !== previousScroll) {
+            area.scrollTop = previousScroll
+          }
         } catch {}
       }
       // Every mode hugs the measured content; `coveredHeight` is only a
       // fallback for a host whose textarea cannot be measured.
-      let height = Math.max(minimumHeight, contentHeight + headerOffset + FOOTER_BAND)
+      // While the editor is open its height FOLLOWS the draft: more lines grow
+      // the box, deleting lines shrinks it - but never below the height it had
+      // when it opened, and never past the composer below or the conversation
+      // top above. The floor belongs to the whole edit (a page switch keeps it)
+      // and only a save or a cancel ends it.
+      const baseHeight =
+        controller !== null &&
+        controller !== undefined &&
+        typeof controller.editorBaseHeight === 'number' &&
+        controller.editorBaseHeight > 0
+          ? controller.editorBaseHeight
+          : null
+      let height = Math.max(minimumHeight, contentHeight + headerOffset + FOOTER_BAND, baseHeight === null ? 0 : baseHeight)
       let clampedTop = null
       if (clamped) {
         const bounds = conversationBounds(row)
@@ -2763,14 +2964,32 @@ window.__ModuleLoader__.load({
           // fills the WHOLE band (not just the message's own position), so the
           // top touches the conversation edge and the bottom the composer.
           const fillAll = allBox !== null && allBox !== undefined && heightMode !== 'content'
-          clampedTop = fillAll ? topLimit : Math.max(base.top, topLimit)
-          height = fillAll
-            ? Math.max(minimumHeight, bottomLimit - clampedTop)
-            : Math.min(height, Math.max(minimumHeight, bottomLimit - clampedTop))
+          const band = bottomLimit - topLimit
+          if (fillAll) {
+            clampedTop = topLimit
+            height = Math.max(minimumHeight, band)
+          } else if (height <= band) {
+            // It fits: grow DOWN from the row while there is room for it, and
+            // when there is not, keep the bottom at the composer edge and grow
+            // UP instead - the direction follows the space, the box never covers
+            // the composer and never leaves the conversation's top.
+            const room = bottomLimit - Math.max(base.top, topLimit)
+            clampedTop = height <= room ? Math.max(base.top, topLimit) : Math.max(topLimit, bottomLimit - height)
+            height = Math.min(height, band)
+          } else {
+            // Taller than the whole band: fill it and let the field scroll.
+            clampedTop = topLimit
+            height = Math.max(minimumHeight, band)
+          }
         }
       }
       if (!inline && !clamped && viewport.height > 0) height = Math.min(height, Math.max(minimumHeight, viewport.height - margin * 2))
       height = Math.max(minimumHeight, height)
+      if (baseHeight === null && controller !== null && controller !== undefined) {
+        // The first layout of this open fixes the floor: from here on the box
+        // may grow and shrink with the draft, but not below this.
+        controller.editorBaseHeight = height
+      }
       box.style.height = `${height}px`
       box.style.maxHeight = ''
       let top = clampedTop === null ? base.top : clampedTop
@@ -2794,11 +3013,9 @@ window.__ModuleLoader__.load({
         // is exactly as tall as its text and the ONE scrollbar appears when it
         // overflows the band.
         if (typeof allBox.querySelectorAll === 'function') {
-          for (const blockArea of allBox.querySelectorAll('.dshet-all-area')) {
-            blockArea.style.height = 'auto'
-            const measured = blockArea.scrollHeight
-            if (typeof measured === 'number' && measured > 0) blockArea.style.height = `${measured}px`
-          }
+          withScrollKept(allBox, () => {
+            for (const blockArea of allBox.querySelectorAll('.dshet-all-area')) settleAreaHeight(blockArea)
+          })
         }
       } else if (area !== null && area !== undefined) {
         const offsetLeft = Math.max(0, bubble.rect.left - base.left)
@@ -2836,6 +3053,73 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /**
+     * Run `work` without losing the reader's place.
+     *
+     * Measuring a textarea means collapsing it (`height: auto`), which shrinks
+     * the document; the browser then clamps the scroller's `scrollTop` to the
+     * new maximum, and the position is gone even though the heights come back.
+     * The host re-renders constantly (a streaming turn, a state refresh), so
+     * this is what "scroll down and it jumps back up" was. The position is
+     * captured before the work and put back after.
+     *
+     * @param scroller - the scrolling element that holds the textareas.
+     * @param work - the measuring pass.
+     * @returns whatever `work` returned.
+     */
+    function withScrollKept(scroller, work) {
+      const keep =
+        scroller !== null && scroller !== undefined && typeof scroller.scrollTop === 'number'
+          ? scroller.scrollTop
+          : null
+      const result = work()
+      if (keep !== null && scroller.scrollTop !== keep) scroller.scrollTop = keep
+      return result
+    }
+
+    /**
+     * The content height of one textarea, SETTLED and applied.
+     *
+     * One measurement is not enough. With the height reset to `auto`, the first
+     * read comes back exactly one line short - the wrap is resolved after the
+     * style write - and the element is then pinned to that height with
+     * `overflow:hidden`. In the all-blocks page that made the last line of a
+     * long body unreachable: the surrounding scroller's height is computed from
+     * the pinned value, so it cannot scroll to a line the textarea is hiding
+     * (reported from the field: a long 正文 could not be scrolled past).
+     *
+     * Measured live: first read 2392, second read 2415, line height 23px.
+     *
+     * @param area - the textarea to measure and size.
+     * @returns the applied height in CSS pixels, or 0 when unmeasurable.
+     */
+    function settleAreaHeight(area) {
+      if (area === null || area === undefined || typeof area.scrollHeight !== 'number') return 0
+      area.style.height = 'auto'
+      const first = area.scrollHeight
+      if (!(typeof first === 'number' && first > 0)) return 0
+      area.style.height = `${first}px`
+      const settled = area.scrollHeight
+      const height = typeof settled === 'number' && settled > first ? settled : first
+      area.style.height = `${height}px`
+      return height
+    }
+
+    /**
+     * One block's identity inside the editor's draft store.
+     *
+     * A turn's blocks are addressed by (seq, index): the same block reached from
+     * the 正文 page and from its sub-page inside 全部 must resolve to the SAME
+     * key, or an unsaved edit disappears when the user switches pages.
+     *
+     * @param block - an editor block (seq, index).
+     * @returns the stable key.
+     */
+    function blockDraftKey(block) {
+      if (block === null || block === undefined) return ''
+      return `${typeof block.seq === 'number' ? block.seq : ''}:${block.index}`
+    }
+
     // Grow the textarea to its content, the way a normal input box behaves.
     // Without this it sits at a fixed `rows` height and a two-line edit floats
     // in half an empty box. The stylesheet owns the limits (`min-height`,
@@ -2845,9 +3129,12 @@ window.__ModuleLoader__.load({
 
     function fitEditorHeight(area) {
       if (typeof area.closest === 'function' && area.closest('[data-dshet-inplace="1"]') !== null) return
-      area.style.height = 'auto'
-      const height = area.scrollHeight
-      if (typeof height === 'number' && height > 0) area.style.height = `${height + 2}px`
+      const scroller =
+        typeof area.closest === 'function'
+          ? area.closest('.dshet-all') ?? area.closest('.dshet-editor')
+          : null
+      const height = withScrollKept(scroller, () => settleAreaHeight(area))
+      if (height > 0) area.style.height = `${height + 2}px`
     }
 
     // Wire an action so a host re-render cannot eat the click.
@@ -3134,7 +3421,7 @@ window.__ModuleLoader__.load({
         ? controller.editorBox
         : null
       if (existing && existing.dataset.dshetFor === marker) {
-        placeEditor(row, existing, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks)
+        placeEditor(row, existing, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks, controller)
         return
       }
 
@@ -3235,13 +3522,13 @@ window.__ModuleLoader__.load({
         fitEditorHeight(area)
         const row = controller.editorRow
         const box = controller.editorBox
-        if (row !== null && box !== null && box.isConnected === true) placeEditor(row, box, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks)
+        if (row !== null && box !== null && box.isConnected === true) placeEditor(row, box, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks, controller)
       })
       area.addEventListener('compositionend', () => {
         fitEditorHeight(area)
         const row = controller.editorRow
         const box = controller.editorBox
-        if (row !== null && box !== null && box.isConnected === true) placeEditor(row, box, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks)
+        if (row !== null && box !== null && box.isConnected === true) placeEditor(row, box, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks, controller)
       })
       area.addEventListener('focus', () => {
         controller.editorFocus = true
@@ -3314,15 +3601,15 @@ window.__ModuleLoader__.load({
           blockArea.style.position = 'static'
           blockArea.style.left = 'auto'
           blockArea.style.top = 'auto'
-          blockArea.value = controller.editorAllDrafts instanceof Map ? (controller.editorAllDrafts.get(key) ?? block.text) : block.text
+          blockArea.value = controller.draftOfBlock(block)
           blockArea.disabled = view.pending || view.confirming
-          const grow = () => {
-            blockArea.style.height = 'auto'
-            const measured = blockArea.scrollHeight
-            if (typeof measured === 'number' && measured > 0) blockArea.style.height = `${measured}px`
-          }
+          const grow = () =>
+            withScrollKept(
+              typeof blockArea.closest === 'function' ? blockArea.closest('.dshet-all') : null,
+              () => settleAreaHeight(blockArea),
+            )
           blockArea.addEventListener('input', () => {
-            if (controller.editorAllDrafts instanceof Map) controller.editorAllDrafts.set(key, blockArea.value)
+            controller.setDraftFor(block, blockArea.value)
             grow()
           })
           section.appendChild(head)
@@ -3523,7 +3810,7 @@ window.__ModuleLoader__.load({
       controller.editorBox = box
       controller.editorRow = row
       controller.editorElement = area
-      placeEditor(row, box, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks)
+      placeEditor(row, box, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks, controller)
       fitEditorHeight(area)
       if (!view.confirming && !view.pending && (fresh || wasFocused)) {
         try {
@@ -3735,6 +4022,49 @@ window.__ModuleLoader__.load({
      * the deepest element whose text is the recorded original (or what we last
      * painted there).
      */
+    /**
+     * EVERY element that shows this reasoning text.
+     *
+     * Plural on purpose: the host keeps more than one copy of a turn's reasoning.
+     * The collapsed process row stays in the DOM with `display: none`, and opening
+     * the panel renders a second, visible body. Patching only the first one left
+     * the copy the user was looking at showing the recorded text.
+     *
+     * @param root - the conversation root to search.
+     * @param wanted - the patch (`original` text, new `text`).
+     * @param previousText - what the patch showed before this pass, if anything.
+     * @returns the deepest matching elements, best match first.
+     */
+    function findReasoningElements(root, wanted, previousText) {
+      if (root === null || root === undefined || typeof root.querySelectorAll !== 'function') return []
+      const original = matchText(wanted.original)
+      const previous = matchText(previousText)
+      if (original === '' && previous === '') return []
+      const found = []
+      for (const el of root.querySelectorAll('*')) {
+        if (el.getAttribute(PATCH_ATTR) !== null) continue
+        try {
+          if (el.closest('.dshet-editor, .dshet-action, .dshet-pick, button, time') !== null) continue
+        } catch {
+          /* a detached node is still a candidate */
+        }
+        const text = matchText(el.textContent)
+        if (text === '') continue
+        if (text !== original && !(previous !== '' && text === previous)) continue
+        let deeper = false
+        for (const child of el.children ?? []) {
+          if (matchText(child.textContent) === text) {
+            deeper = true
+            break
+          }
+        }
+        if (deeper) continue
+        found.push({ el, score: Math.abs(text.length - original.length) })
+      }
+      found.sort((a, b) => a.score - b.score)
+      return found.map((entry) => entry.el)
+    }
+
     function findReasoningElement(root, wanted, previousText) {
       if (root === null || root === undefined || typeof root.querySelectorAll !== 'function') return null
       const original = matchText(wanted.original)
@@ -3804,9 +4134,38 @@ window.__ModuleLoader__.load({
       const wantedText = new Map()
       const wantedReasoning = new Map()
       for (const patch of Array.isArray(view.patches) ? view.patches : []) {
-        const reply = replies.get(patch.seq)
-        if (reply === undefined || !Array.isArray(reply.blocks)) continue
-        const block = reply.blocks.find((entry) => entry.index === patch.blockIndex)
+        // Find the block by (seq, index) AND the entry that carries it.
+        //
+        // One reply entry carries its whole TURN's blocks, so several blocks
+        // share an index - the first step's reasoning and the fourth step's
+        // reasoning are both "index 0" - and a later step's block lives in the
+        // entry keyed by the ANSWER's seq, not by its own. Keying the lookup by
+        // `patch.seq` alone found no entry, and `find(index === ...)` alone found
+        // the wrong block: either way the patch matched nothing in the DOM and
+        // the reasoning body kept the recorded text until a reload (reported from
+        // the field for the 思维链 page; a save on another step's reasoning wrote
+        // the record and /state reported it, yet the transcript did not move).
+        let reply = replies.get(patch.seq)
+        let block = Array.isArray(reply?.blocks)
+          ? reply.blocks.find(
+              (entry) =>
+                entry.index === patch.blockIndex &&
+                (entry.seq === undefined || patch.seq === undefined || entry.seq === patch.seq),
+            )
+          : undefined
+        if (block === undefined) {
+          for (const candidate of replies.values()) {
+            if (!Array.isArray(candidate?.blocks)) continue
+            const found = candidate.blocks.find(
+              (entry) => entry.index === patch.blockIndex && entry.seq === patch.seq,
+            )
+            if (found !== undefined) {
+              reply = candidate
+              block = found
+              break
+            }
+          }
+        }
         if (block === undefined) continue
         if (patch.kind === 'text') {
           wantedText.set(`${patch.seq}:${patch.blockIndex}`, {
@@ -3928,37 +4287,34 @@ window.__ModuleLoader__.load({
       // in the DOM (or is drawn as a short summary without the full text).
       for (const [key, wanted] of wantedReasoning) {
         const owner = rowBySeq.get(wanted.seq)
+        const shown = displayText(wanted.text)
+        const previousText = patchedTexts.get(key) ?? ''
+        const original = matchText(wanted.original)
+        const previous = matchText(previousText)
+        // EVERY copy of this reasoning, not just the one this pass remembers.
+        //
+        // The host keeps the collapsed process row in the DOM with `display:
+        // none` and renders a SECOND body when the panel is opened. Trusting the
+        // remembered element because it is still `isConnected` meant the copy the
+        // user was looking at kept the recorded text until a reload - which is
+        // exactly the reported "思维链页保存后不能马上渲染".
+        const targets = new Set()
         const remembered = patchedElements.get(key)
         if (remembered !== undefined) {
-          // The reasoning part is its own row (the flow key carries a
-          // `,reasoning` group part), so it is NOT the row `rowBySeq` picked for
-          // the seq - that one draws the answer. Only connectivity matters here.
-          const stillThere = remembered.isConnected === true
-          if (stillThere) {
-            const shown = displayText(wanted.text)
-            if (normalizedText(remembered.textContent) !== normalizedText(shown)) remembered.textContent = shown
-            if (remembered.getAttribute(PATCH_ATTR) !== key) remembered.setAttribute(PATCH_ATTR, key)
-            remembered.style.whiteSpace = 'pre-wrap'
-            patchedTexts.set(key, wanted.text)
-            continue
-          }
-          patchedElements.delete(key)
+          if (remembered.isConnected === true) targets.add(remembered)
+          else patchedElements.delete(key)
         }
-        const done = [...root.querySelectorAll(`[${PATCH_ATTR}]`)].find((el) => el.getAttribute(PATCH_ATTR) === key)
-        if (done !== undefined) {
-          patchedElements.set(key, done)
-          continue
+        for (const el of root.querySelectorAll(`[${PATCH_ATTR}]`)) {
+          if (el.getAttribute(PATCH_ATTR) === key) targets.add(el)
         }
-        const original = matchText(wanted.original)
-        const previous = matchText(patchedTexts.get(key) ?? '')
-        const previousText = patchedTexts.get(key) ?? ''
-        let best = null
         if (original !== '' || previous !== '') {
           // The owning row first (a host that draws the reasoning inside the
           // answer row), then the whole conversation: on this host the reasoning
           // is its own row, so the answer row holds no reasoning text at all.
+          // EVERY scope is merged, never just the first one that matched: the
+          // point of this pass is to catch all copies at once.
           for (const scope of owner === undefined ? [null] : [owner, null]) {
-            let bestScore = Infinity
+            let foundInScope = false
             for (const el of containers) {
               if (el.getAttribute(PATCH_ATTR) !== null) continue
               if (scope !== null) {
@@ -3971,29 +4327,29 @@ window.__ModuleLoader__.load({
               const text = matchText(el.textContent)
               if (text === '') continue
               if (text !== original && !(previous !== '' && text === previous)) continue
-              const score = Math.abs(text.length - original.length)
-              if (score < bestScore) {
-                best = el
-                bestScore = score
-              }
+              targets.add(el)
+              foundInScope = true
             }
-            if (best !== null) break
+            if (foundInScope) break
           }
-          if (best === null) best = findPatchTextFallback(owner ?? null, wanted, previousText)
-          if (best === null) best = findReasoningElement(root, wanted, previousText)
+          const fallback = findPatchTextFallback(owner ?? null, wanted, previousText)
+          if (fallback !== null) targets.add(fallback)
+          for (const el of findReasoningElements(root, wanted, previousText)) targets.add(el)
         }
-        if (best === null) {
+        if (targets.size === 0) {
           // No body in the DOM (the panel is closed): the header snippet is the
           // only place the edit can show.
           if (owner !== undefined) patchReasoningSummary(owner, wanted)
           patchReasoningSummary(root, wanted)
           continue
         }
-        patchOriginals.set(best, { html: best.innerHTML, text: best.textContent })
-        best.textContent = displayText(wanted.text)
-        best.setAttribute(PATCH_ATTR, key)
-        best.style.whiteSpace = 'pre-wrap'
-        patchedElements.set(key, best)
+        for (const el of targets) {
+          if (!patchOriginals.has(el)) patchOriginals.set(el, { html: el.innerHTML, text: el.textContent })
+          if (normalizedText(el.textContent) !== normalizedText(shown)) el.textContent = shown
+          if (el.getAttribute(PATCH_ATTR) !== key) el.setAttribute(PATCH_ATTR, key)
+          el.style.whiteSpace = 'pre-wrap'
+          patchedElements.set(key, el)
+        }
         patchedTexts.set(key, wanted.text)
         if (owner !== undefined) patchReasoningSummary(owner, wanted)
         patchReasoningSummary(root, wanted)
@@ -4217,7 +4573,7 @@ window.__ModuleLoader__.load({
             const key = `${Math.round(rect.top)}:${Math.round(rect.height)}:${Math.round(typeof window !== 'undefined' && typeof window.scrollY === 'number' ? window.scrollY : 0)}:${viewportWidth}x${viewportHeight}:${controller.editorBlockKind}:${controller.editorAll === true ? 'all' : ''}`
             if (key === lastPlacementKey) return
             lastPlacementKey = key
-            placeEditor(row, box, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks)
+            placeEditor(row, box, controller.editorMode, controller.editorStyle, controller.editorBlockKind, controller.editorBlocks, controller)
           }
           if (typeof requestAnimationFrame === 'function') requestAnimationFrame(run)
           else window.setTimeout(run, 16)
@@ -4684,6 +5040,10 @@ window.__ModuleLoader__.load({
     }
 
     exports.apply = apply
+    // The settings card, exported so a composing bundle (dsh-as-aistudio) can
+    // render THE SAME component on its own page instead of re-implementing it:
+    // one source of truth for 编辑与重跑 settings.
+    exports.ConfigCard = EditorStyleOption
     exports.inject = ['slots', 'locale']
     exports.PLUGIN_VERSION = PLUGIN_VERSION
     return module.exports

package/lib/index.js

@@ -80,7 +80,7 @@ export const PLUGIN_ID = 'dsh-edit-turn'
 export const name = PLUGIN_ID
 
 /** Keep in sync with package.json and lib/client.js. */
-export const PLUGIN_VERSION = '0.5.2'
+export const PLUGIN_VERSION = '0.5.4'
 
 // A ring of the last few requests, answering "did the browser half even ask, and
 // what did it get?" without needing its console. Read-only diagnostics: the
@@ -100,7 +100,15 @@ export function recentRequests() {
 }
 
 const ROUTE_PREFIX = '/dsh-edit-turn'
-const SESSION_ID_RE = /^(session-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+// A session id is an OPAQUE string to DSH: the host's own schema is
+// `z.string().min(1)`, and a named session created in the GUI (`bili-whale`,
+// stored as ~/.dsh/storages/<profile>/sessions/bili-whale.json) is exactly as
+// real as a UUID one. A UUID-only test rejected those with a 400, so the panel
+// answered "状态加载失败" for a session that plainly exists. The character class
+// still refuses everything that could leave a path or a URL: `/`, `\`, `..`
+// (the first character must be alphanumeric, so a leading dot is already out),
+// whitespace and control characters.
+const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/
 const MAX_TEXT = 200_000
 const FLUSH_DEADLINE_MS = 5_000
 
@@ -1683,8 +1691,34 @@ export async function attachmentBytes(ctx, sessionId, seq, index) {
 async function stateOf(ctx, sessionId, config) {
   const events = await readEvents(ctx, sessionId)
   if (!events) {
-    noteRequest({ kind: 'state', sessionId, ok: false, code: 'session-not-found' })
-    throw new HttpError(404, 'session-not-found', 'no session log for this id')
+    // A named session with nothing in it yet is an EMPTY session, not a failed
+    // one: the editor opens with nothing to edit, and the next refresh picks the
+    // log up once it exists. Answering 404 here is what the panel printed as
+    // "状态加载失败，稍后重试。". The capability probe still runs, because "what
+    // can this deployment do" does not depend on the log.
+    noteRequest({ kind: 'state', sessionId, ok: true, code: 'session-empty' })
+    const store = resolveAttachmentStore(ctx)
+    return {
+      hidden: [],
+      edits: 0,
+      revisions: [],
+      surface: [],
+      turns: [],
+      replies: [],
+      patches: [],
+      mode: config.patch === true ? 'patch' : 'replay',
+      live: false,
+      busy: false,
+      lastSeq: -1,
+      capabilities: { attachments: store !== null, preview: canPreviewAttachments(store) },
+      config: {
+        confirm: config.confirm,
+        replyMode: config.replyMode,
+        patch: config.patch === true,
+        editorStyle: config.editorStyle,
+      },
+      version: PLUGIN_VERSION,
+    }
   }
   const folded = foldSurface(events)
   const ledger = rollbackLedger(events)
@@ -2477,12 +2511,71 @@ export function isProjectionUnavailable(message) {
 }
 
 function failure(res, error) {
+  const message = String((error && error.message) || error)
+  // The host refuses to derive a session whose projection left the registry
+  // (`SurfaceManager._assertProjections`). It is a known, self-explaining state
+  // - the plugin was reloaded while that session was open - not an internal
+  // fault, so it answers 409 with the host's own words and does not dump a stack
+  // into the log on every request.
+  if (isProjectionUnavailable(message)) {
+    sendJson(res, 409, { ok: false, code: 'projection-missing', error: message })
+    return
+  }
   const status = error instanceof HttpError ? error.status : 500
   const code = error instanceof HttpError ? error.code : 'internal'
   // An unexpected throw is the only case the client cannot explain; leave the
   // stack in the host log so a report can name the cause.
   if (!(error instanceof HttpError)) console.error('[dsh-edit-turn] internal error', error)
-  sendJson(res, status, { ok: false, code, error: String((error && error.message) || error) })
+  sendJson(res, status, { ok: false, code, error: message })
+}
+
+/**
+ * The one projection object this PROCESS uses, kept across plugin reloads.
+ *
+ * The host registry compares projection IDENTITY, not type:
+ * `SurfaceManager._assertProjections()` (dsh-session/lib/index.js) throws
+ * `session message projection "<type>" was removed or replaced` when a
+ * projection a LIVE session already folded with is no longer in the registry
+ * array, and `registerMessageProjection`'s own docstring states the rule:
+ * "Disposing the contribution makes sessions that used it refuse further
+ * derivation."
+ *
+ * A reload disposes the previous fiber, which splices the old object out of the
+ * registry. Building a fresh object then leaves every open session that carries
+ * a patch event unable to derive anything: the surface read throws, so this
+ * plugin's own save/state paths answer 500, and so does any sibling that reads
+ * `session.surface.nodes` (verified live - dsh-delete-turn's /state answered 500
+ * for such a session after a reload). Reusing one object from a process-global
+ * hands the registry the SAME definition back, so a reloaded plugin keeps the
+ * open sessions foldable.
+ *
+ * The object is a pure, stateless interpreter, which is what makes the reuse
+ * safe. One consequence is deliberate: after a code change the projection keeps
+ * running the PREVIOUS definition for sessions that are already open, until the
+ * session is reopened or DSH restarts. That is the better half of the trade -
+ * the alternative is a session that cannot be read at all.
+ *
+ * @returns the process-wide projection definition.
+ */
+function sharedPatchProjection() {
+  const KEY = '__DSH_EDIT_TURN_PATCH_PROJECTION__'
+  try {
+    const stashed = globalThis[KEY]
+    if (
+      stashed !== undefined &&
+      stashed !== null &&
+      typeof stashed.project === 'function' &&
+      stashed.type === PATCH_TYPE
+    ) {
+      return stashed
+    }
+    const fresh = patchProjection()
+    globalThis[KEY] = fresh
+    return fresh
+  } catch {
+    // A frozen or absent globalThis is not worth failing the load over.
+    return patchProjection()
+  }
 }
 
 // --- plugin ------------------------------------------------------------------
@@ -2523,7 +2616,7 @@ export function apply(ctx, config) {
       const existing = Array.isArray(registry)
         ? registry.find((entry) => entry && entry.type === PATCH_TYPE)
         : undefined
-      if (existing === undefined) sessionsService.registerMessageProjection(patchProjection())
+      if (existing === undefined) sessionsService.registerMessageProjection(sharedPatchProjection())
       patch = true
     } catch (error) {
       if (resolved.replyMode === 'patch') throw error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Edit any message in DeepSeek Harness in place: a prompt is replaced where it stands; a model reply block (answer text or reasoning) is patched through a plugin record and a message projection, so the turn stays where it is, later turns are untouched and the log grows by one small record. Falls back to the replay splice on hosts without the projection API. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",